add unit tests

contracts/build/Registry.abi

@@ -81,6 +81,30 @@
     "stateMutability": "view",
     "type": "function"
   },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_id",
+        "type": "uint256"
+      }
+    ],
+    "name": "getEntry",
+    "outputs": [
+      {
+        "internalType": "address[]",
+        "name": "",
+        "type": "address[]"
+      },
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
   {
     "inputs": [
       {

contracts/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "scripts": {
     "build": "npx hardhat compile && bash extract-abis.bash",
-    "test": "scripts/test test/contract.test.ts",
+    "test": "scripts/test test/*.test.ts",
     "deploy-local": "npx hardhat run scripts/deploy.ts --network localhost | tee contract-deployment.json"
   },
   "dependencies": {},

contracts/test/registry.test.ts

@@ -0,0 +1,95 @@
+import '@nomicfoundation/hardhat-chai-matchers';
+
+import {expect} from 'chai';
+import * as deployment from '../utils/deploy';
+import {getAccounts, Account} from '../utils/helpers';
+
+import {Registry} from '../types/contracts/Registry';
+import {BigNumber} from 'ethers';
+import {setAutoMine} from './helpers';
+
+describe('Registry contract', () => {
+  // Accounts
+  let deployer: Account;
+  let other: Account;
+
+  // Contracts
+  let registry: Registry;
+
+  before(async function () {
+    [deployer, other] = await getAccounts();
+
+    setAutoMine(true);
+  });
+
+  beforeEach(async function () {
+    registry = await deployment.deployRegistry(deployer.signer, false);
+  });
+
+  describe('constructor', function () {
+    it('should set the owner to the contract deployer address', async function () {
+      expect(await registry.owner()).to.eq(deployer.address);
+    });
+  });
+
+  describe('transferOwnership', function () {
+    it('should set the owner to the new owner', async function () {
+      await registry.transferOwnership(other.address);
+      expect(await registry.owner()).to.eq(other.address);
+    });
+  });
+
+  describe('insertEntry', function () {
+    it('should set entry', async function () {
+      const entryID = BigNumber.from(1);
+      const entry = {
+        subscriptions: [
+          '0x0000000000000000000000000000000000000001',
+          '0x0000000000000000000000000000000000000002',
+        ],
+        metadataHash: BigNumber.from(
+          '0x0000000000000000000000000000000000000000000000000000000000000001'
+        ),
+      };
+      await registry.insertEntry(entryID, entry);
+      const result = await registry.getEntry(entryID);
+      expect(result[0]).to.eql(entry.subscriptions);
+      expect(result[1]).to.eql(entry.metadataHash);
+    });
+
+    it('should overwrite entry', async function () {
+      const entryID = BigNumber.from(1);
+      const entry1 = {
+        subscriptions: ['0x0000000000000000000000000000000000000001'],
+        metadataHash: BigNumber.from(
+          '0x0000000000000000000000000000000000000000000000000000000000000001'
+        ),
+      };
+      const entry2 = {
+        subscriptions: ['0x0000000000000000000000000000000000000002'],
+        metadataHash: BigNumber.from(
+          '0x0000000000000000000000000000000000000000000000000000000000000002'
+        ),
+      };
+      await registry.insertEntry(entryID, entry1);
+      await registry.insertEntry(entryID, entry2);
+      const result = await registry.getEntry(entryID);
+      expect(result[0]).to.eql(entry2.subscriptions);
+      expect(result[1]).to.eql(entry2.metadataHash);
+    });
+  });
+
+  describe('removeEntry', function () {
+    it('should remove entry', async function () {
+      const entryID = BigNumber.from(1);
+      const subscriptions = ['0x0000000000000000000000000000000000000001'];
+      const metadataHash =
+        '0x0000000000000000000000000000000000000000000000000000000000000001';
+      await registry.insertEntry(entryID, {subscriptions, metadataHash});
+      await registry.removeEntry(entryID);
+      const result = await registry.getEntry(entryID);
+      expect(result[0]).to.eql([]);
+      expect(result[1]).to.eql(BigNumber.from(0));
+    });
+  });
+});

contracts/utils/deploy.ts

@@ -4,7 +4,7 @@ import { Artifacts } from 'hardhat/internal/artifacts'
 import { LinkReferences } from 'hardhat/types'
 
 import { Subscriptions } from '../types/contracts/Subscriptions'
-import { StableToken } from '../types'
+import { Registry, StableToken } from '../types'
 
 type Abi = Array<string | utils.FunctionFragment | utils.EventFragment | utils.ParamType>
 
@@ -71,4 +71,11 @@ export async function deployStableToken(
   logging = true
 ): Promise<StableToken> {
   return deployContract(args, sender, 'StableToken', logging) as unknown as Promise<StableToken>
-}
+}
+
+export async function deployRegistry(
+  sender: Signer,
+  logging = true
+): Promise<Registry> {
+  return deployContract([], sender, 'Registry', logging) as unknown as Promise<Registry>
+}