mirror of
https://github.com/zoo-labs/zoo.git
synced 2026-11-10 22:32:34 +00:00
178 lines
4.5 KiB
TypeScript
178 lines
4.5 KiB
TypeScript
/**
|
|
* Custom Assertions
|
|
* Helper functions for common test assertions
|
|
*/
|
|
|
|
import { expect } from '@playwright/test';
|
|
import { ethers, Contract } from 'ethers';
|
|
|
|
/**
|
|
* Assert transaction succeeded
|
|
*/
|
|
export async function assertTransactionSuccess(
|
|
tx: ethers.providers.TransactionResponse
|
|
): Promise<ethers.providers.TransactionReceipt> {
|
|
const receipt = await tx.wait();
|
|
expect(receipt.status).toBe(1);
|
|
expect(receipt.transactionHash).toBeDefined();
|
|
expect(receipt.blockNumber).toBeGreaterThan(0);
|
|
return receipt;
|
|
}
|
|
|
|
/**
|
|
* Assert transaction failed
|
|
*/
|
|
export async function assertTransactionFails(
|
|
txPromise: Promise<ethers.providers.TransactionResponse>
|
|
): Promise<void> {
|
|
await expect(txPromise).rejects.toThrow();
|
|
}
|
|
|
|
/**
|
|
* Assert token balance
|
|
*/
|
|
export async function assertTokenBalance(
|
|
token: Contract,
|
|
address: string,
|
|
expectedBalance: ethers.BigNumber,
|
|
tolerance: ethers.BigNumber = ethers.BigNumber.from(0)
|
|
): Promise<void> {
|
|
const actualBalance = await token.balanceOf(address);
|
|
|
|
if (tolerance.isZero()) {
|
|
expect(actualBalance.eq(expectedBalance)).toBe(true);
|
|
} else {
|
|
const diff = actualBalance.sub(expectedBalance).abs();
|
|
expect(diff.lte(tolerance)).toBe(true);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assert ETH balance
|
|
*/
|
|
export async function assertEthBalance(
|
|
provider: ethers.providers.JsonRpcProvider,
|
|
address: string,
|
|
expectedBalance: ethers.BigNumber,
|
|
tolerance: ethers.BigNumber = ethers.utils.parseEther('0.01') // 0.01 ETH tolerance for gas
|
|
): Promise<void> {
|
|
const actualBalance = await provider.getBalance(address);
|
|
const diff = actualBalance.sub(expectedBalance).abs();
|
|
expect(diff.lte(tolerance)).toBe(true);
|
|
}
|
|
|
|
/**
|
|
* Assert event emitted
|
|
*/
|
|
export async function assertEventEmitted(
|
|
receipt: ethers.providers.TransactionReceipt,
|
|
contract: Contract,
|
|
eventName: string,
|
|
expectedArgs?: Record<string, any>
|
|
): Promise<void> {
|
|
const events = receipt.logs
|
|
.map(log => {
|
|
try {
|
|
return contract.interface.parseLog(log);
|
|
} catch {
|
|
return null;
|
|
}
|
|
})
|
|
.filter((e): e is ethers.utils.LogDescription => e !== null);
|
|
|
|
const event = events.find(e => e.name === eventName);
|
|
expect(event).toBeDefined();
|
|
|
|
if (expectedArgs && event) {
|
|
for (const [key, value] of Object.entries(expectedArgs)) {
|
|
expect(event.args[key]).toEqual(value);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assert block number increased
|
|
*/
|
|
export async function assertBlockNumberIncreased(
|
|
provider: ethers.providers.JsonRpcProvider,
|
|
startBlock: number,
|
|
minIncrease: number = 1
|
|
): Promise<void> {
|
|
const currentBlock = await provider.getBlockNumber();
|
|
expect(currentBlock).toBeGreaterThanOrEqual(startBlock + minIncrease);
|
|
}
|
|
|
|
/**
|
|
* Assert timestamp increased
|
|
*/
|
|
export async function assertTimestampIncreased(
|
|
provider: ethers.providers.JsonRpcProvider,
|
|
startTimestamp: number,
|
|
minIncrease: number = 1
|
|
): Promise<void> {
|
|
const block = await provider.getBlock('latest');
|
|
expect(block.timestamp).toBeGreaterThanOrEqual(startTimestamp + minIncrease);
|
|
}
|
|
|
|
/**
|
|
* Assert contract state
|
|
*/
|
|
export async function assertContractState(
|
|
contract: Contract,
|
|
method: string,
|
|
expectedValue: any,
|
|
...args: any[]
|
|
): Promise<void> {
|
|
const actualValue = await contract[method](...args);
|
|
expect(actualValue).toEqual(expectedValue);
|
|
}
|
|
|
|
/**
|
|
* Assert wallet has sufficient ETH
|
|
*/
|
|
export async function assertSufficientEth(
|
|
wallet: ethers.Wallet,
|
|
minBalance: ethers.BigNumber = ethers.utils.parseEther('1')
|
|
): Promise<void> {
|
|
const balance = await wallet.getBalance();
|
|
expect(balance.gte(minBalance)).toBe(true);
|
|
}
|
|
|
|
/**
|
|
* Assert app is running
|
|
*/
|
|
export async function assertAppRunning(url: string): Promise<void> {
|
|
const fetch = (await import('node-fetch')).default;
|
|
|
|
try {
|
|
const response = await fetch(url, { method: 'HEAD' });
|
|
expect(response.ok || response.status === 404).toBe(true);
|
|
} catch (error) {
|
|
throw new Error(`App not running at ${url}: ${error}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Assert governance proposal state
|
|
*/
|
|
export async function assertProposalState(
|
|
governor: Contract,
|
|
proposalId: ethers.BigNumber,
|
|
expectedState: number // 0=Pending, 1=Active, 2=Canceled, 3=Defeated, 4=Succeeded, 5=Queued, 6=Expired, 7=Executed
|
|
): Promise<void> {
|
|
const state = await governor.state(proposalId);
|
|
expect(state).toBe(expectedState);
|
|
}
|
|
|
|
/**
|
|
* Assert staking balance
|
|
*/
|
|
export async function assertStakingBalance(
|
|
stakingContract: Contract,
|
|
address: string,
|
|
expectedStaked: ethers.BigNumber
|
|
): Promise<void> {
|
|
const staked = await stakingContract.balanceOf(address);
|
|
expect(staked.eq(expectedStaked)).toBe(true);
|
|
}
|