solid-grinder 1.1.8

A CLI that goes along with building blocks of smart contract. Along with our front-end snippets, this toolbox can reduce L2 gas cost by encoding calldata for dApps development to use as little bytes of calldata as possible.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

const { expectEvent, expectRevert } = require('@openzeppelin/test-helpers');

const { expect } = require('chai');

const PausableMock = artifacts.require('PausableMock');

contract('Pausable', function (accounts) {
  const [ pauser ] = accounts;

  beforeEach(async function () {
    this.pausable = await PausableMock.new();
  });

  context('when unpaused', function () {
    beforeEach(async function () {
      expect(await this.pausable.paused()).to.equal(false);
    });

    it('can perform normal process in non-pause', async function () {
      expect(await this.pausable.count()).to.be.bignumber.equal('0');

      await this.pausable.normalProcess();
      expect(await this.pausable.count()).to.be.bignumber.equal('1');
    });

    it('cannot take drastic measure in non-pause', async function () {
      await expectRevert(this.pausable.drasticMeasure(),
        'Pausable: not paused',
      );
      expect(await this.pausable.drasticMeasureTaken()).to.equal(false);
    });

    context('when paused', function () {
      beforeEach(async function () {
        ({ logs: this.logs } = await this.pausable.pause({ from: pauser }));
      });

      it('emits a Paused event', function () {
        expectEvent.inLogs(this.logs, 'Paused', { account: pauser });
      });

      it('cannot perform normal process in pause', async function () {
        await expectRevert(this.pausable.normalProcess(), 'Pausable: paused');
      });

      it('can take a drastic measure in a pause', async function () {
        await this.pausable.drasticMeasure();
        expect(await this.pausable.drasticMeasureTaken()).to.equal(true);
      });

      it('reverts when re-pausing', async function () {
        await expectRevert(this.pausable.pause(), 'Pausable: paused');
      });

      describe('unpausing', function () {
        it('is unpausable by the pauser', async function () {
          await this.pausable.unpause();
          expect(await this.pausable.paused()).to.equal(false);
        });

        context('when unpaused', function () {
          beforeEach(async function () {
            ({ logs: this.logs } = await this.pausable.unpause({ from: pauser }));
          });

          it('emits an Unpaused event', function () {
            expectEvent.inLogs(this.logs, 'Unpaused', { account: pauser });
          });

          it('should resume allowing normal process', async function () {
            expect(await this.pausable.count()).to.be.bignumber.equal('0');
            await this.pausable.normalProcess();
            expect(await this.pausable.count()).to.be.bignumber.equal('1');
          });

          it('should prevent drastic measure', async function () {
            await expectRevert(this.pausable.drasticMeasure(),
              'Pausable: not paused',
            );
          });

          it('reverts when re-unpausing', async function () {
            await expectRevert(this.pausable.unpause(), 'Pausable: not paused');
          });
        });
      });
    });
  });
});