oceanprotocol/ocean.js
1
0
Fork 0
mirror of https://github.com/oceanprotocol/ocean.js.git synced 2024-11-26 20:39:05 +01:00
Code Releases Activity

fixed nftdatatoken tests

Browse Source
This commit is contained in:
Bogdan Fazakas 2021-11-02 14:40:58 +02:00
parent 0a0c818eb7
commit c91b2e4efc
3 changed files with 100 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
package.json
View File

@ -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'",

2
test/unit/Datatoken.test.ts
View File

@ -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(

178
test/unit/NFTDatatoken.test.ts
View File

@ -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,
ERC20Template.abi as AbiItem,
PoolTemplate.abi as AbiItem,
ERC721Factory.abi as AbiItem
ERC721Template.abi as AbiItem[],
ERC20Template.abi as AbiItem[],
PoolTemplate.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)
nftDatatoken = new NFTDatatoken(web3, ERC721Template.abi as AbiItem)
const nftData = {
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,
publishMarketFeeAdress,
oceanAddress,
'0,1',
user1,
user2,
'0x0000000000000000000000000000000000000000',
'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(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === false
)
assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === 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(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).deployERC20 === false
)
assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === true)
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(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
)
// assert(
// (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
// )
await nftDatatoken.addMetadataUpdater(nftAddress, nftOwner, user1)
assert(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
)
// assert(
// (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(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
)
// assert(
// (await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === false
// )
await nftDatatoken.removeMetadataUpdater(nftAddress, nftOwner, user1)
assert(
(await nftDatatoken.getNFTPermissions(nftAddress, user1)).updateMetadata === true
)
// assert(
// (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.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.isErc20Deployer(nftAddress, user1)) === 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)
assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === 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
)
// console.log(await nftDatatoken.isErc20Deployer(nftAddress, user1))
// assert((await nftDatatoken.isErc20Deployer(nftAddress, user1)) === false)
})
// Clear permisions
@ -267,15 +289,13 @@ describe('NFTDatatoken', () => {
})
it('#cleanPermissions - should cleanPermissions if NFTOwner', async () => {
assert((await nftDatatoken.getNFTPermissions(nftAddress, user1)).store === true)
assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === true)
await nftDatatoken.addManager(nftAddress, user1, user1)
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.getNFTPermissions(nftAddress, nftOwner)).manager === false)
await nftDatatoken.addManager(nftAddress, nftOwner, nftOwner)
assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === true)
assert((await nftDatatoken.isErc20Deployer(nftAddress, user2)) === false)
// assert((await nftDatatoken.getNFTPermissions(nftAddress, nftOwner)).manager === false)
})
})