forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-25 14:16:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Add geth compatible tests

Browse source
This commit is contained in:
Dimitar Manov 2025-06-11 13:30:02 +03:00
parent a68460f65d
commit 17e22b30d1
1 changed files with 57 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

161
hardhat/test/Lock.ts
View file

@ -1,127 +1,80 @@
import {
time,
loadFixture,
} from "@nomicfoundation/hardhat-toolbox/network-helpers";
import { anyValue } from "@nomicfoundation/hardhat-chai-matchers/withArgs";
import { expect } from "chai";
import hre from "hardhat";
describe("Lock", function () {
// We define a fixture to reuse the same setup in every test.
// We use loadFixture to run this setup once, snapshot that state,
// and reset Hardhat Network to that snapshot in every test.
async function deployOneYearLockFixture() {
const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
const ONE_GWEI = 1_000_000_000;
const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
const ONE_GWEI = 1_000_000_000;
const lockedAmount = ONE_GWEI;
const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;
let lock: any;
let unlockTime: number;
let lockedAmount: number;
let owner: any;
let otherAccount: any;
// Contracts are deployed using the first signer/account by default
const [owner, otherAccount] = await hre.ethers.getSigners();
beforeEach(async function () {
// Use block.timestamp + ONE_YEAR_IN_SECS
const latestBlock = await hre.ethers.provider.getBlock("latest");
unlockTime = latestBlock.timestamp + ONE_YEAR_IN_SECS;
lockedAmount = ONE_GWEI;
[owner, otherAccount] = await hre.ethers.getSigners();
const Lock = await hre.ethers.getContractFactory("Lock");
const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
return { lock, unlockTime, lockedAmount, owner, otherAccount };
}
describe("Deployment", function () {
it("Should set the right unlockTime", async function () {
const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);
expect(await lock.unlockTime()).to.equal(unlockTime);
});
it("Should set the right owner", async function () {
const { lock, owner } = await loadFixture(deployOneYearLockFixture);
expect(await lock.owner()).to.equal(owner.address);
});
it("Should receive and store the funds to lock", async function () {
const { lock, lockedAmount } = await loadFixture(
deployOneYearLockFixture
);
expect(await hre.ethers.provider.getBalance(lock.target)).to.equal(
lockedAmount
);
});
it("Should fail if the unlockTime is not in the future", async function () {
// We don't use the fixture here because we want a different deployment
const latestTime = await time.latest();
const Lock = await hre.ethers.getContractFactory("Lock");
await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
"Unlock time should be in the future"
);
lock = await Lock.connect(owner).deploy(unlockTime, {
value: lockedAmount,
});
await lock.waitForDeployment();
});
describe("Withdrawals", function () {
describe("Validations", function () {
it("Should revert with the right error if called too soon", async function () {
const { lock } = await loadFixture(deployOneYearLockFixture);
it("Should set the right unlockTime", async function () {
expect(await lock.unlockTime()).to.equal(unlockTime);
});
await expect(lock.withdraw()).to.be.revertedWith(
"You can't withdraw yet"
);
});
it("Should set the right owner", async function () {
expect(await lock.owner()).to.equal(owner.address);
});
it("Should revert with the right error if called from another account", async function () {
const { lock, unlockTime, otherAccount } = await loadFixture(
deployOneYearLockFixture
);
it("Should receive and store the funds to lock", async function () {
const balance = await hre.ethers.provider.getBalance(lock.target);
expect(balance).to.equal(lockedAmount);
});
// We can increase the time in Hardhat Network
await time.increaseTo(unlockTime);
it("Should fail if the unlockTime is not in the future", async function () {
const latestBlock = await hre.ethers.provider.getBlock("latest");
const Lock = await hre.ethers.getContractFactory("Lock");
await expect(
Lock.deploy(latestBlock.timestamp, { value: 1 })
).to.be.revertedWith("Unlock time should be in the future");
});
// We use lock.connect() to send a transaction from another account
await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
"You aren't the owner"
);
});
it("Should revert with the right error if called too soon", async function () {
await expect(lock.withdraw()).to.be.revertedWith("You can't withdraw yet");
});
it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
const { lock, unlockTime } = await loadFixture(
deployOneYearLockFixture
);
// Transactions are sent using the first signer by default
await time.increaseTo(unlockTime);
await expect(lock.withdraw()).not.to.be.reverted;
});
it("Should revert if called from another account", async function () {
// simulate time passing (skip in real Geth, or deploy with unlockTime already in past)
// For now, assume unlockTime is satisfied
const fakeUnlockTime = unlockTime - ONE_YEAR_IN_SECS - 1;
const Lock = await hre.ethers.getContractFactory("Lock");
const lockNow = await Lock.connect(owner).deploy(fakeUnlockTime, {
value: lockedAmount,
});
await lockNow.waitForDeployment();
describe("Events", function () {
it("Should emit an event on withdrawals", async function () {
const { lock, unlockTime, lockedAmount } = await loadFixture(
deployOneYearLockFixture
);
await expect(lockNow.connect(otherAccount).withdraw()).to.be.revertedWith(
"You aren't the owner"
);
});
await time.increaseTo(unlockTime);
await expect(lock.withdraw())
.to.emit(lock, "Withdrawal")
.withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
});
it("Should not fail if unlockTime has passed and owner calls it", async function () {
// simulate a contract deployed with past unlock time
const pastTime = unlockTime - ONE_YEAR_IN_SECS - 1;
const Lock = await hre.ethers.getContractFactory("Lock");
const lockNow = await Lock.connect(owner).deploy(pastTime, {
value: lockedAmount,
});
await lockNow.waitForDeployment();
describe("Transfers", function () {
it("Should transfer the funds to the owner", async function () {
const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
deployOneYearLockFixture
);
await time.increaseTo(unlockTime);
await expect(lock.withdraw()).to.changeEtherBalances(
[owner, lock],
[lockedAmount, -lockedAmount]
);
});
});
await expect(lockNow.withdraw()).not.to.be.reverted;
});
});