Skip to content

test for block token #50

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
gregemax wants to merge 1 commit into
base: Erc20-testing
Choose a base branch
from
Open

test for block token #50

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
102 changes: 101 additions & 1 deletion test/BlockToken.js
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -78,5 +78,105 @@ describe("BlockToken Test Suite", () => {
await BlockToken.connect(owner_).burn(100);
expect(await BlockToken.balanceOf(owner_)).to.eq(900);
});
it("Should allow only owner to burnFrom", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, addr1);
await expect(BlockToken.connect(addr1).burnFrom(addr1, 1000)).to.be.revertedWith(
"BlockToken:: Unauthorized User"
);
});
it("Should allow onlyOwner burn", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
// test owner mints successfully
await BlockToken.connect(owner_).mint(1000, addr1);
expect(await BlockToken.balanceOf(addr1)).to.eq(1000);

// test that another user cant call successfully
let malicioustxn = BlockToken.connect(addr1).burnFrom(addr1, 1000);
await expect(malicioustxn).to.be.revertedWith(
"BlockToken:: Unauthorized User"
);
});

});


describe("burnFrom", () => {
it("Should burn tokens from another account", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, addr1);
await BlockToken.connect(owner_).burnFrom(addr1, 500);
expect(await BlockToken.balanceOf(addr1)).to.eq(500);
});

it("Should revert if account has insufficient tokens", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await expect(BlockToken.connect(owner_).burnFrom(addr1, 500)).to.be.revertedWithCustomError(
BlockToken,
"ERC20InsufficientBalance"
);
});

it("Should revert if burning zero from address", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, addr1);
await expect(BlockToken.connect(owner_).burnFrom(addr1, 0)).to.be.revertedWith(
"BlockToken:: Zero amount not supported"
);
});
});

describe("Transfers", () => {
it("Should transfer tokens successfully", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, owner_);
await BlockToken.connect(owner_).transfer(addr1.address, 500);
expect(await BlockToken.balanceOf(owner_)).to.eq(500);
expect(await BlockToken.balanceOf(addr1)).to.eq(500);
});

it("Should revert transfer to zero address", async () => {
const { BlockToken, owner_ } = await loadFixture(deployBlockToken);
const zeroAddress = "0x0000000000000000000000000000000000000000"
await BlockToken.connect(owner_).mint(1000, owner_);
await expect(
BlockToken.connect(owner_).transfer(zeroAddress, 800)
).to.be.reverted;
});

it("Should revert transferFrom if allowance is insufficient", async () => {
const { BlockToken, owner_, addr1, addr2 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, addr1);
await BlockToken.connect(addr1).approve(owner_, 500);
await expect(
BlockToken.connect(owner_).transferFrom(addr1, addr2, 700)
).to.be.revertedWithCustomError(BlockToken, "ERC20InsufficientAllowance");
});

it("Should revert transferFrom to zero address", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
const zeroAddress = "0x0000000000000000000000000000000000000000"
await BlockToken.connect(owner_).mint(1000, addr1);
await BlockToken.connect(addr1).approve(owner_, 500);
await expect(
BlockToken.connect(owner_).transferFrom(addr1, zeroAddress, 400)
).to.be.revertedWithCustomError(BlockToken, "ERC20InvalidReceiver");
});

it("Should approve and update allowance", async () => {
const { BlockToken, owner_, addr1 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, owner_);
await BlockToken.connect(owner_).approve(addr1, 500);
await BlockToken.connect(owner_).approve(addr1, 700);
expect(await BlockToken.allowance(owner_, addr1)).to.eq(700);
});

it("Should execute transferFrom properly", async () => {
const { BlockToken, owner_, addr1, addr2 } = await loadFixture(deployBlockToken);
await BlockToken.connect(owner_).mint(1000, addr1);
await BlockToken.connect(addr1).approve(owner_, 500);
await BlockToken.connect(owner_).transferFrom(addr1, addr2, 400);
expect(await BlockToken.balanceOf(addr2)).to.eq(400);
});
});
});
});