openzeppelin-contracts/test/token/ERC20/StandardBurnableToken.test.js

import assertRevert from '../../helpers/assertRevert';
import { inLogs } from '../../helpers/expectEvent';
import shouldBehaveLikeBurnableToken from './BurnableToken.behaviour';

const StandardBurnableTokenMock = artifacts.require('StandardBurnableTokenMock');
const BigNumber = web3.BigNumber;
const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';

require('chai')
  .use(require('chai-as-promised'))
  .use(require('chai-bignumber')(BigNumber))
  .should();

contract('StandardBurnableToken', function ([owner, burner]) {
  const initialBalance = 1000;
  
  beforeEach(async function () {
    this.token = await StandardBurnableTokenMock.new(owner, initialBalance);
  });

  shouldBehaveLikeBurnableToken([owner], initialBalance);

  describe('burnFrom', function () {
    describe('on success', function () {
      const amount = 100;

      beforeEach(async function () {
        await this.token.approve(burner, 300, { from: owner });
        const { logs } = await this.token.burnFrom(owner, amount, { from: burner });
        this.logs = logs;
      });

      it('burns the requested amount', async function () {
        const balance = await this.token.balanceOf(owner);
        balance.should.be.bignumber.equal(initialBalance - amount);
      });

      it('decrements allowance', async function () {
        const allowance = await this.token.allowance(owner, burner);
        allowance.should.be.bignumber.equal(200);
      });

      it('emits a burn event', async function () {
        const event = await inLogs(this.logs, 'Burn');
        event.args.burner.should.eq(owner);
        event.args.value.should.be.bignumber.equal(amount);
      });

      it('emits a transfer event', async function () {
        const event = await inLogs(this.logs, 'Transfer');
        event.args.from.should.eq(owner);
        event.args.to.should.eq(ZERO_ADDRESS);
        event.args.value.should.be.bignumber.equal(amount);
      });
    });

    describe('when the given amount is greater than the balance of the sender', function () {
      const amount = initialBalance + 1;
      it('reverts', async function () {
        await this.token.approve(burner, amount, { from: owner });
        await assertRevert(this.token.burnFrom(owner, amount, { from: burner }));
      });
    });

    describe('when the given amount is greater than the allowance', function () {
      const amount = 100;
      it('reverts', async function () {
        await this.token.approve(burner, amount - 1, { from: owner });
        await assertRevert(this.token.burnFrom(owner, amount, { from: burner }));
      });
    });
  });
});