Added unit tests for Authorizable

contracts/staking/test/unit_tests/authorizable.ts

@@ -0,0 +1,88 @@
+import { blockchainTests, constants, expect, filterLogsToArguments } from '@0x/contracts-test-utils';
+import {
+    AuthorizableAuthorizedAddressAddedEventArgs,
+    AuthorizableAuthorizedAddressRemovedEventArgs,
+    OwnableRevertErrors,
+} from '@0x/contracts-utils';
+
+import { artifacts, TestStakingContract, TestStakingEvents } from '../../src';
+
+blockchainTests.resets('Staking Authorization Tests', env => {
+    let testContract: TestStakingContract;
+
+    let owner: string;
+    let nonOwner: string;
+
+    before(async () => {
+        [owner, nonOwner] = await env.getAccountAddressesAsync();
+
+        testContract = await TestStakingContract.deployFrom0xArtifactAsync(
+            artifacts.TestStaking,
+            env.provider,
+            {
+                ...env.txDefaults,
+                from: owner,
+            },
+            artifacts,
+            constants.NULL_ADDRESS,
+            constants.NULL_ADDRESS,
+        );
+    });
+
+    it("shouldn't have any authorized addresses initially", async () => {
+        const authorities = await testContract.getAuthorizedAddresses().callAsync();
+        expect(authorities).to.be.deep.eq([]);
+    });
+
+    describe('addAuthorizedAddress', () => {
+        it('should allow owner to add authorized address', async () => {
+            const receipt = await testContract
+                .addAuthorizedAddress(nonOwner)
+                .awaitTransactionSuccessAsync({ from: owner });
+
+            const args = filterLogsToArguments<AuthorizableAuthorizedAddressAddedEventArgs>(
+                receipt.logs,
+                TestStakingEvents.AuthorizedAddressAdded,
+            );
+            expect(args).to.be.deep.eq([{ target: nonOwner, caller: owner }]);
+
+            const authorities = await testContract.getAuthorizedAddresses().callAsync();
+            expect(authorities).to.be.deep.eq([nonOwner]);
+        });
+
+        it('should throw if non-owner adds authorized address', async () => {
+            const tx = testContract.addAuthorizedAddress(owner).awaitTransactionSuccessAsync({ from: nonOwner });
+            const expectedError = new OwnableRevertErrors.OnlyOwnerError(nonOwner, owner);
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+
+    describe('removeAuthorizedAddress', () => {
+        before(async () => {
+            await testContract.addAuthorizedAddress(owner).awaitTransactionSuccessAsync({ from: owner });
+            const authorities = await testContract.getAuthorizedAddresses().callAsync();
+            expect(authorities).to.be.deep.eq([owner]);
+        });
+
+        it('should allow owner to remove authorized address', async () => {
+            const receipt = await testContract
+                .removeAuthorizedAddress(owner)
+                .awaitTransactionSuccessAsync({ from: owner });
+
+            const args = filterLogsToArguments<AuthorizableAuthorizedAddressRemovedEventArgs>(
+                receipt.logs,
+                TestStakingEvents.AuthorizedAddressRemoved,
+            );
+            expect(args).to.be.deep.eq([{ target: owner, caller: owner }]);
+
+            const authorities = await testContract.getAuthorizedAddresses().callAsync();
+            expect(authorities).to.be.deep.eq([]);
+        });
+
+        it('should throw if non-owner removes authorized address', async () => {
+            const tx = testContract.removeAuthorizedAddress(owner).awaitTransactionSuccessAsync({ from: nonOwner });
+            const expectedError = new OwnableRevertErrors.OnlyOwnerError(nonOwner, owner);
+            return expect(tx).to.revertWith(expectedError);
+        });
+    });
+});