From 8b464722ef4b88cb66b672e230564cd27e2eea7b Mon Sep 17 00:00:00 2001 From: alexcos20 Date: Tue, 23 Feb 2021 22:50:26 -0800 Subject: [PATCH] wip tests --- .travis.yml | 1 + test/integration/ComputeFlow.test.ts | 116 ++++++++++++++++++++++++++- 2 files changed, 116 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 03b44eb4..9f581792 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,6 +20,7 @@ before_script: # Barge setup - git clone https://github.com/oceanprotocol/barge - cd barge + - git checkout feature/improve_provider - export ADDRESS_FILE="${HOME}/.ocean/ocean-contracts/artifacts/address.json" - mkdir "${HOME}/.ocean/" - mkdir "${HOME}/.ocean/ocean-contracts/" diff --git a/test/integration/ComputeFlow.test.ts b/test/integration/ComputeFlow.test.ts index 833b631e..6a106f16 100644 --- a/test/integration/ComputeFlow.test.ts +++ b/test/integration/ComputeFlow.test.ts @@ -46,6 +46,7 @@ describe('Compute flow', () => { let asset: Metadata let datasetNoRawAlgo: DDO let datasetWithTrustedAlgo: DDO + let datasetWithBogusProvider: DDO let algorithmAsset: DDO let algorithmAssetRemoteProvider: DDO let contracts: TestContractHandler @@ -53,6 +54,7 @@ describe('Compute flow', () => { let tokenAddress: string let tokenAddressNoRawAlgo: string let tokenAddressWithTrustedAlgo: string + let tokenAddressWithBogusProvider: string let tokenAddressAlgorithm: string let tokenAddressAlgorithmRemoteProvider: string let tokenAddressAdditional1: string @@ -73,7 +75,7 @@ describe('Compute flow', () => { const dateCreated = new Date(Date.now()).toISOString().split('.')[0] + 'Z' // remove milliseconds const tokenAmount = '1000' - const aquaSleep = 30000 + const aquaSleep = 50000 const timeout = 86400 const algorithmMeta = { @@ -144,6 +146,17 @@ describe('Compute flow', () => { tokenAddressWithTrustedAlgo != null, 'Creation of tokenAddressWithTrustedAlgo failed' ) + tokenAddressWithBogusProvider = await datatoken.create( + blob, + alice.getId(), + '10000000000', + 'AssetWithTrustedDT', + 'AWTDT' + ) + assert( + tokenAddressWithBogusProvider != null, + 'Creation of tokenAddressWithTrustedAlgo failed' + ) tokenAddressAlgorithm = await datatoken.create( blob, @@ -502,6 +515,7 @@ describe('Compute flow', () => { await datatoken.mint(tokenAddress, alice.getId(), tokenAmount) await datatoken.mint(tokenAddressNoRawAlgo, alice.getId(), tokenAmount) await datatoken.mint(tokenAddressWithTrustedAlgo, alice.getId(), tokenAmount) + await datatoken.mint(tokenAddressWithBogusProvider, alice.getId(), tokenAmount) await datatoken.mint(tokenAddressAlgorithm, alice.getId(), tokenAmount) await datatoken.mint(tokenAddressAlgorithmRemoteProvider, alice.getId(), tokenAmount) await datatoken.mint(tokenAddressAdditional1, alice.getId(), tokenAmount) @@ -528,6 +542,16 @@ describe('Compute flow', () => { const balance = await datatoken.balance(tokenAddressWithTrustedAlgo, bob.getId()) assert(balance.toString() === dTamount.toString()) }) + + await datatoken + .transfer(tokenAddressWithBogusProvider, bob.getId(), dTamount, alice.getId()) + .then(async () => { + const balance = await datatoken.balance( + tokenAddressWithBogusProvider, + bob.getId() + ) + assert(balance.toString() === dTamount.toString()) + }) await datatoken .transfer(tokenAddressAlgorithm, bob.getId(), dTamount, alice.getId()) .then(async () => { @@ -1069,4 +1093,94 @@ describe('Compute flow', () => { ) assert(allowed === false, 'This should fail, the algo files section was changed!') }) + + it('should force publish a dataset with a compute service served by a non existant provider', async () => { + // will create a service with ocean.provider for metadata service, but bogus provider for compute service + const bogusRemoteProviderUri = 'http://172.15.0.7:2030' + const origComputePrivacy = { + allowRawAlgorithm: false, + allowNetworkAccess: false, + publisherTrustedAlgorithms: [] + } + + const computeService = ocean.compute.createComputeService( + alice, + '1000', + dateCreated, + providerAttributes, + origComputePrivacy as ServiceComputePrivacy, + 3600, + bogusRemoteProviderUri + ) + datasetWithBogusProvider = await ocean.assets.create( + asset, + alice, + [computeService], + tokenAddressWithBogusProvider + ) + assert( + datasetWithBogusProvider.dataToken === tokenAddressWithTrustedAlgo, + 'datasetWithTrustedAlgo.dataToken !== tokenAddressWithTrustedAlgo' + ) + await sleep(aquaSleep) + }) + it('Bob should fail to start a compute job for a bogus provider with a raw Algo', async () => { + const output = {} + const computeService = datasetWithBogusProvider.findServiceByType('compute') + // get the compute address first + computeAddress = await ocean.compute.getComputeAddress( + datasetWithBogusProvider.id, + computeService.index + ) + + // check if asset is orderable. otherwise, you might pay for it, but it has some algo restrictions + const allowed = await ocean.compute.isOrderable( + datasetWithBogusProvider.id, + computeService.index, + undefined, + algorithmMeta + ) + assert(allowed === false) + // we know that it is not Orderable, but we are trying to force it + computeOrderId = await ocean.compute.orderAsset( + bob.getId(), + datasetWithBogusProvider.id, + computeService.index, + undefined, + algorithmMeta, + null, // no marketplace fee + computeAddress // CtD is the consumer of the dataset + ) + assert(computeOrderId === null, 'computeOrderId !== null') + // we are forcing a bogus orderId + computeOrderId = '1234' + const response = await ocean.compute.start( + datasetWithBogusProvider.id, + computeOrderId, + tokenAddress, + bob, + undefined, + algorithmMeta, + output, + `${computeService.index}`, + computeService.type + ) + assert(response, 'Compute error') + }) + + it('Bob should failed to get status of all compute jobs from a dataset with bogus provider', async () => { + const response = await ocean.compute.status( + bob, + datasetWithBogusProvider.id, + undefined, + undefined, + false + ) + assert(response === undefined, 'Invalid response') + }) + it('Bob should fail to stop a fake compute job on a bogus provider', async () => { + const jobid = '1234' + const response = await ocean.compute.stop(bob, datasetWithBogusProvider.id, jobid) + assert(response === undefined, 'Invalid response') + }) })