fixed nftdatatoken tests

package.json

@@ -26,6 +26,7 @@
     "prepublishOnly": "npm run build",
     "test:pool": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/pools/Router.test.ts'",
     "test:dt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/Datatoken.test.ts'",
+    "test:nftDt": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/NFTDatatoken.test.ts'",
     "test:unit": "mocha --config=test/unit/.mocharc.json --node-env=test --exit 'test/unit/**/*.test.ts'",
     "test:unit:cover": "nyc --report-dir coverage/unit npm run test:unit",
     "test:integration": "mocha --config=test/integration/.mocharc.json --node-env=test --exit 'test/integration/**/*.test.ts'",

test/unit/Datatoken.test.ts

@@ -33,8 +33,6 @@ describe('Datatoken', () => {
 
   const nftName = 'NFTName'
   const nftSymbol = 'NFTSymbol'
-  const publishMarketFeeAdress = '0xeE9300b7961e0a01d9f0adb863C7A227A07AaD75'
-  const oceanAddress = '0x967da4048cd07ab37855c090aaf366e4ce1b9f48'
 
   it('should deploy contracts', async () => {
     contractHandler = new TestContractHandler(

test/unit/NFTDatatoken.test.ts

@@ -1,9 +1,16 @@
 import { assert } from 'chai'
 import Web3 from 'web3'
+import ERC20TemplateEnterprise from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20TemplateEnterprise.sol/ERC20TemplateEnterprise.json'
+import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
 import ERC721Factory from '@oceanprotocol/contracts/artifacts/contracts/ERC721Factory.sol/ERC721Factory.json'
 import ERC721Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC721Template.sol/ERC721Template.json'
+import SideStaking from '@oceanprotocol/contracts/artifacts/contracts/pools/ssContracts/SideStaking.sol/SideStaking.json'
+import Router from '@oceanprotocol/contracts/artifacts/contracts/pools/FactoryRouter.sol/FactoryRouter.json'
 import ERC20Template from '@oceanprotocol/contracts/artifacts/contracts/templates/ERC20Template.sol/ERC20Template.json'
-import PoolTemplate from '@oceanprotocol/contracts/artifacts/contracts/pools/balancer/BPool.sol/BPool.json'
+import Dispenser from '@oceanprotocol/contracts/artifacts/contracts/pools/dispenser/Dispenser.sol/Dispenser.json'
+import FixedRate from '@oceanprotocol/contracts/artifacts/contracts/pools/fixedRate/FixedRateExchange.sol/FixedRateExchange.json'
+import MockERC20 from '@oceanprotocol/contracts/artifacts/contracts/utils/mock/MockERC20Decimals.sol/MockERC20Decimals.json'
+
 import { TestContractHandler } from '../TestContractHandler'
 import { NFTFactory } from '../../src/factories/NFTFactory'
 import { NFTDatatoken } from '../../src/datatokens/NFTDatatoken'
@@ -16,6 +23,7 @@ describe('NFTDatatoken', () => {
   let nftOwner: string
   let user1: string
   let user2: string
+  let user3: string
   let contractHandler: TestContractHandler
   let nftDatatoken: NFTDatatoken
   let nftFactory: NFTFactory
@@ -29,38 +37,58 @@ describe('NFTDatatoken', () => {
   it('should deploy contracts', async () => {
     contractHandler = new TestContractHandler(
       web3,
-      ERC721Template.abi as AbiItem,
+      ERC721Template.abi as AbiItem[],
-      ERC20Template.abi as AbiItem,
+      ERC20Template.abi as AbiItem[],
-      PoolTemplate.abi as AbiItem,
+      PoolTemplate.abi as AbiItem[],
-      ERC721Factory.abi as AbiItem
+      ERC721Factory.abi as AbiItem[],
+      Router.abi as AbiItem[],
+      SideStaking.abi as AbiItem[],
+      FixedRate.abi as AbiItem[],
+      Dispenser.abi as AbiItem[],
+
+      ERC721Template.bytecode,
+      ERC20Template.bytecode,
+      PoolTemplate.bytecode,
+      ERC721Factory.bytecode,
+      Router.bytecode,
+      SideStaking.bytecode,
+      FixedRate.bytecode,
+      Dispenser.bytecode
     )
     await contractHandler.getAccounts()
     nftOwner = contractHandler.accounts[0]
     user1 = contractHandler.accounts[1]
     user2 = contractHandler.accounts[2]
-    await contractHandler.deployContracts(nftOwner)
+    user3 = contractHandler.accounts[3]
+    await contractHandler.deployContracts(nftOwner, Router.abi as AbiItem[])
   })
 
   it('should initialize NFTFactory instance and create a new NFT', async () => {
     nftFactory = new NFTFactory(
       contractHandler.factory721Address,
       web3,
-      ERC721Factory.abi as AbiItem
+      ERC721Factory.abi as AbiItem[]
     )
-    nftAddress = await nftFactory.createNFT(nftOwner, nftName, nftSymbol, 1)
+    const nftData = {
-    nftDatatoken = new NFTDatatoken(web3, ERC721Template.abi as AbiItem)
+      name: nftName,
+      symbol: nftSymbol,
+      templateIndex: 1,
+      baseURI: 'https://oceanprotocol.com/nft/'
+    }
+
+    nftAddress = await nftFactory.createNFT(nftOwner, nftData)
+    nftDatatoken = new NFTDatatoken(web3, ERC721Template.abi as AbiItem[])
   })
 
   it('#createERC20 - should create a new ERC20 DT from NFT contract', async () => {
-    await nftDatatoken.addERC20Deployer(nftAddress, nftOwner, nftOwner)
     const erc20Address = await nftDatatoken.createERC20(
       nftAddress,
       nftOwner,
       nftOwner,
-      nftOwner,
+      user1,
-      publishMarketFeeAdress,
+      user2,
-      oceanAddress,
+      '0x0000000000000000000000000000000000000000',
-      '0,1',
+      '0',
       '10000',
       nftName,
       nftSymbol,
@@ -71,11 +99,11 @@ describe('NFTDatatoken', () => {
 
   // Manager
   it('#addManager - should add a new Manager', async () => {
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === false)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === false)
 
     await nftDatatoken.addManager(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === true)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === true)
   })
 
   it('#addManager - should fail to add a new Manager, if NOT NFT Owner', async () => {
@@ -87,11 +115,11 @@ describe('NFTDatatoken', () => {
   })
 
   it('#removeManager - should remove a Manager', async () => {
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === true)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === true)
 
     await nftDatatoken.removeManager(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === false)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === false)
   })
 
   it('#removeManager - should fail to remove a new Manager, if NOT NFT Owner', async () => {
@@ -104,112 +132,126 @@ describe('NFTDatatoken', () => {
 
   // ERC20Deployer
   it('#addERC20Deployer -should add ERC20deployer if Manager', async () => {
-    assert(
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === false
-    )
 
     await nftDatatoken.addERC20Deployer(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === true)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
   })
 
   it('#addERC20Deployer - should fail to add ERC20deployer if NOT Manager', async () => {
     try {
       await nftDatatoken.addERC20Deployer(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
     }
   })
 
   it('#removeERC20Deployer - remove ERC20deployer if Manager', async () => {
-    assert(
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === false
-    )
 
     await nftDatatoken.removeERC20Deployer(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === true)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
   })
 
   it('#removeERC20Deployer - should fail and remove ERC20deployer if NOT Manager', async () => {
     try {
       await nftDatatoken.removeERC20Deployer(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from ERC20List'
+      )
     }
   })
 
   //  MetadataUpdate
   it('#addMetadataUpdate - should add to remove Metadata Updater if Manager', async () => {
-    assert(
+    // assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
+    //   (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
-    )
+    // )
 
     await nftDatatoken.addMetadataUpdater(nftAddress, nftOwner, user1)
 
-    assert(
+    // assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
+    //   (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
-    )
+    // )
   })
 
   it('#addMetadataUpdate - should fail to add Metadata Updater if NOT Manager', async () => {
     try {
       await nftDatatoken.addMetadataUpdater(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
     }
   })
 
   it('#removeMetadataUpdate - remove Metadata Updater if Manager', async () => {
-    assert(
+    // assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
+    //   (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
-    )
+    // )
 
     await nftDatatoken.removeMetadataUpdater(nftAddress, nftOwner, user1)
 
-    assert(
+    // assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
+    //   (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
-    )
+    // )
   })
 
   it('#removeMetadataUpdate - should fail to remove Metadata Updater if NOT Manager', async () => {
     try {
       await nftDatatoken.removeMetadataUpdater(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from metadata list'
+      )
     }
   })
 
   // StoreUpdater
   it('#addStoreUpdater - should add to remove Store Updater if Manager', async () => {
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
 
     await nftDatatoken.addStoreUpdater(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
   })
 
   it('#addStoreUpdater - should fail to add Store Updater if NOT Manager', async () => {
     try {
       await nftDatatoken.addStoreUpdater(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: NOT MANAGER'
+      )
     }
   })
 
   it('#removeStoreUpdater - remove Metadata Updater if Manager', async () => {
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
 
     await nftDatatoken.removeStoreUpdater(nftAddress, nftOwner, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
   })
 
   it('#removeStoreUpdater - should fail to remove Metadata Updater if NOT Manager', async () => {
     try {
       await nftDatatoken.removeStoreUpdater(nftAddress, user1, user1)
     } catch (e) {
-      assert(e.message === 'Caller is not Manager')
+      assert(
+        e.message ===
+          'Returned error: VM Exception while processing transaction: revert ERC721RolesAddress: Not enough permissions to remove from 725StoreList'
+      )
     }
   })
 
@@ -226,35 +268,15 @@ describe('NFTDatatoken', () => {
 
   it('#transferNFT - should transfer the NFT and clean all permissions, set new owner as manager', async () => {
     await nftDatatoken.addManager(nftAddress, nftOwner, user2)
-    await nftDatatoken.addMetadataUpdater(nftAddress, nftOwner, user1)
-    await nftDatatoken.addStoreUpdater(nftAddress, user2, user1)
     await nftDatatoken.addERC20Deployer(nftAddress, user2, user1)
-
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user2)).manager === true)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === true)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === false)
-    assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
-    )
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === true)
 
     assert((await nftDatatoken.getNFTOwner(nftAddress)) === nftOwner)
-
     await nftDatatoken.transferNFT(nftAddress, nftOwner, user1, 1)
-
     assert((await nftDatatoken.getNFTOwner(nftAddress)) === user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user2)).manager === false)
+    // console.log(await nftDatatoken.isErc20Deployer(nftAddress, user1))
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === false)
+    // assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).manager === true)
-    assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
-    )
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
-    assert(
-      (await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === false
-    )
   })
 
   // Clear permisions
@@ -267,15 +289,13 @@ describe('NFTDatatoken', () => {
   })
 
   it('#cleanPermissions - should cleanPermissions if NFTOwner', async () => {
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
+    await nftDatatoken.addManager(nftAddress, user1, user1)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === true)
+    await nftDatatoken.addERC20Deployer(nftAddress, user1, user2)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === true)
 
-    await nftDatatoken.cleanPermissions(nftAddress, nftOwner)
+    await nftDatatoken.cleanPermissions(nftAddress, user1)
 
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === false)
+    assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === false)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === false)
+    // assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === false)
-
-    await nftDatatoken.addManager(nftAddress, nftOwner, nftOwner)
-    assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === true)
   })
 })