put back rerun with same agreement id

test/integration/ComputeFlow.test.ts

@@ -30,7 +30,6 @@ let datatoken: Datatoken
 let providerUrl: string
 let consumerAccount: string
 let publisherAccount: string
-let computeJobId: string
 let providerInitializeComputeResults
 let computeEnvs
 let addresses: any
@@ -39,6 +38,8 @@ let ddoWithNoTimeoutId
 let algoDdoWith1mTimeoutId
 let algoDdoWithNoTimeoutId
 
+let freeComputeJobId: string
+
 let resolvedDdoWith1mTimeout
 let resolvedDdoWithNoTimeout
 let resolvedAlgoDdoWith1mTimeout
@@ -495,71 +496,9 @@ describe('Simple compute tests', async () => {
     freeEnvDatasetTxId = assets[0].transferTxId
     freeEnvAlgoTxId = algo.transferTxId
     assert(computeJobs, 'Cannot start compute job')
-    computeJobId = computeJobs[0].jobId
+    freeComputeJobId = computeJobs[0].jobId
   })
 
-  // it('should restart a computeJob without paying anything, because order is valid and providerFees are still valid', async () => {
-  //   // we choose the free env
-  //   const computeEnv = computeEnvs.find((ce) => ce.priceMin === 0)
-  //   assert(computeEnv, 'Cannot find the free compute env')
-  //   console.log('free compute env', computeEnv)
-
-  //   const assets: ComputeAsset[] = [
-  //     {
-  //       documentId: resolvedDdoWith1mTimeout.id,
-  //       serviceId: resolvedDdoWith1mTimeout.services[0].id,
-  //       transferTxId: freeEnvDatasetTxId
-  //     }
-  //   ]
-  //   const algo: ComputeAlgorithm = {
-  //     documentId: resolvedAlgoDdoWith1mTimeout.id,
-  //     serviceId: resolvedAlgoDdoWith1mTimeout.services[0].id,
-  //     transferTxId: freeEnvAlgoTxId
-  //   }
-
-  //   providerInitializeComputeResults = await ProviderInstance.initializeCompute(
-  //     assets,
-  //     algo,
-  //     computeEnv.id,
-  //     computeValidUntil,
-  //     providerUrl,
-  //     consumerAccount
-  //   )
-  //   assert(
-  //     providerInitializeComputeResults.algorithm.validOrder,
-  //     'We should have a valid order for algorithm'
-  //   )
-  //   assert(
-  //     !providerInitializeComputeResults.algorithm.providerFee,
-  //     'We should not pay providerFees again for algorithm'
-  //   )
-  //   assert(
-  //     providerInitializeComputeResults.datasets[0].validOrder,
-  //     'We should have a valid order for dataset'
-  //   )
-  //   assert(
-  //     !providerInitializeComputeResults.datasets[0].providerFee,
-  //     'We should not pay providerFees again for dataset'
-  //   )
-  //   algo.transferTxId = providerInitializeComputeResults.algorithm.validOrder
-  //   assets[0].transferTxId = providerInitializeComputeResults.datasets[0].validOrder
-  //   assert(
-  //     algo.transferTxId === freeEnvAlgoTxId &&
-  //       assets[0].transferTxId === freeEnvDatasetTxId,
-  //     'We should use the same orders, because no fess must be paid'
-  //   )
-  //   const computeJobs = await ProviderInstance.computeStart(
-  //     providerUrl,
-  //     web3,
-  //     consumerAccount,
-  //     computeEnv.id,
-  //     assets[0],
-  //     algo
-  //   )
-  //   assert(computeJobs, 'Cannot start compute job')
-  //   computeJobId = computeJobs[0].jobId
-  // })
-
   // moving to paid environments
 
   it('should start a computeJob on a paid environment', async () => {
@@ -619,70 +558,8 @@ describe('Simple compute tests', async () => {
     paidEnvDatasetTxId = assets[0].transferTxId
     paidEnvAlgoTxId = algo.transferTxId
     assert(computeJobs, 'Cannot start compute job')
-    computeJobId = computeJobs[0].jobId
   })
 
-  // it('should restart a computeJob on paid environment, without paying anything, because order is valid and providerFees are still valid', async () => {
-  //   // we choose the paid env
-  //   const computeEnv = computeEnvs.find((ce) => ce.priceMin !== 0)
-  //   assert(computeEnv, 'Cannot find the free compute env')
-
-  //   const assets: ComputeAsset[] = [
-  //     {
-  //       documentId: resolvedDdoWith1mTimeout.id,
-  //       serviceId: resolvedDdoWith1mTimeout.services[0].id,
-  //       transferTxId: paidEnvDatasetTxId
-  //     }
-  //   ]
-  //   const algo: ComputeAlgorithm = {
-  //     documentId: resolvedAlgoDdoWith1mTimeout.id,
-  //     serviceId: resolvedAlgoDdoWith1mTimeout.services[0].id,
-  //     transferTxId: paidEnvAlgoTxId
-  //   }
-
-  //   providerInitializeComputeResults = await ProviderInstance.initializeCompute(
-  //     assets,
-  //     algo,
-  //     computeEnv.id,
-  //     computeValidUntil,
-  //     providerUrl,
-  //     consumerAccount
-  //   )
-  //   assert(
-  //     providerInitializeComputeResults.algorithm.validOrder,
-  //     'We should have a valid order for algorithm'
-  //   )
-  //   assert(
-  //     !providerInitializeComputeResults.algorithm.providerFee,
-  //     'We should not pay providerFees again for algorithm'
-  //   )
-  //   assert(
-  //     providerInitializeComputeResults.datasets[0].validOrder,
-  //     'We should have a valid order for dataset'
-  //   )
-  //   assert(
-  //     !providerInitializeComputeResults.datasets[0].providerFee,
-  //     'We should not pay providerFees again for dataset'
-  //   )
-  //   algo.transferTxId = providerInitializeComputeResults.algorithm.validOrder
-  //   assets[0].transferTxId = providerInitializeComputeResults.datasets[0].validOrder
-  //   assert(
-  //     algo.transferTxId === paidEnvAlgoTxId &&
-  //       assets[0].transferTxId === paidEnvDatasetTxId,
-  //     'We should use the same orders, because no fess must be paid'
-  //   )
-  //   const computeJobs = await ProviderInstance.computeStart(
-  //     providerUrl,
-  //     web3,
-  //     consumerAccount,
-  //     computeEnv.id,
-  //     assets[0],
-  //     algo
-  //   )
-  //   assert(computeJobs, 'Cannot start compute job')
-  //   computeJobId = computeJobs[0].jobId
-  // })
-
   // move to reuse Orders
 
   it('Should fast forward time and set a new computeValidUntil', async () => {
@@ -767,10 +644,9 @@ describe('Simple compute tests', async () => {
       assets[0],
       algo
     )
-    freeEnvDatasetTxId = assets[0].transferTxId
+    // freeEnvDatasetTxId = assets[0].transferTxId
-    freeEnvAlgoTxId = algo.transferTxId
+    // freeEnvAlgoTxId = algo.transferTxId
     assert(computeJobs, 'Cannot start compute job')
-    computeJobId = computeJobs[0].jobId
   })
 
   it('should start a computeJob using the paid environment, by paying only providerFee (reuseOrder)', async () => {
@@ -847,20 +723,21 @@ describe('Simple compute tests', async () => {
       assets[0],
       algo
     )
-    freeEnvDatasetTxId = assets[0].transferTxId
+    // freeEnvDatasetTxId = assets[0].transferTxId
-    freeEnvAlgoTxId = algo.transferTxId
+    // freeEnvAlgoTxId = algo.transferTxId
     assert(computeJobs, 'Cannot start compute job')
-    computeJobId = computeJobs[0].jobId
   })
 
+  // move to check status and get download url
+
   it('Check compute status', async () => {
     const jobStatus = (await ProviderInstance.computeStatus(
       providerUrl,
       consumerAccount,
-      computeJobId,
+      freeComputeJobId,
       resolvedDdoWith1mTimeout.id
     )) as ComputeJob
-    console.log('')
+    console.log('jobStatus', jobStatus)
     assert(jobStatus, 'Cannot retrieve compute status!')
   })
 
@@ -870,9 +747,134 @@ describe('Simple compute tests', async () => {
       providerUrl,
       web3,
       consumerAccount,
-      computeJobId,
+      freeComputeJobId,
       0
     )
     assert(downloadURL, 'Provider getComputeResultUrl failed!')
   })
+
+  // move to start orders with initial txid's and provider fees
+
+  it('should restart a computeJob without paying anything, because order is valid and providerFees are still valid', async () => {
+    sleep(10000)
+    // we choose the free env
+    const computeEnv = computeEnvs.find((ce) => ce.priceMin === 0)
+    assert(computeEnv, 'Cannot find the free compute env')
+    console.log('free compute env', computeEnv)
+
+    const assets: ComputeAsset[] = [
+      {
+        documentId: resolvedDdoWith1mTimeout.id,
+        serviceId: resolvedDdoWith1mTimeout.services[0].id,
+        transferTxId: freeEnvDatasetTxId
+      }
+    ]
+    const algo: ComputeAlgorithm = {
+      documentId: resolvedAlgoDdoWith1mTimeout.id,
+      serviceId: resolvedAlgoDdoWith1mTimeout.services[0].id,
+      transferTxId: freeEnvAlgoTxId
+    }
+
+    providerInitializeComputeResults = await ProviderInstance.initializeCompute(
+      assets,
+      algo,
+      computeEnv.id,
+      computeValidUntil,
+      providerUrl,
+      consumerAccount
+    )
+    assert(
+      providerInitializeComputeResults.algorithm.validOrder,
+      'We should have a valid order for algorithm'
+    )
+    assert(
+      !providerInitializeComputeResults.algorithm.providerFee,
+      'We should not pay providerFees again for algorithm'
+    )
+    assert(
+      providerInitializeComputeResults.datasets[0].validOrder,
+      'We should have a valid order for dataset'
+    )
+    assert(
+      !providerInitializeComputeResults.datasets[0].providerFee,
+      'We should not pay providerFees again for dataset'
+    )
+    algo.transferTxId = providerInitializeComputeResults.algorithm.validOrder
+    assets[0].transferTxId = providerInitializeComputeResults.datasets[0].validOrder
+    assert(
+      algo.transferTxId === freeEnvAlgoTxId &&
+        assets[0].transferTxId === freeEnvDatasetTxId,
+      'We should use the same orders, because no fess must be paid'
+    )
+    const computeJobs = await ProviderInstance.computeStart(
+      providerUrl,
+      web3,
+      consumerAccount,
+      computeEnv.id,
+      assets[0],
+      algo
+    )
+    assert(computeJobs, 'Cannot start compute job')
+  })
+
+  it('should restart a computeJob on paid environment, without paying anything, because order is valid and providerFees are still valid', async () => {
+    sleep(10000)
+    // we choose the paid env
+    const computeEnv = computeEnvs.find((ce) => ce.priceMin !== 0)
+    assert(computeEnv, 'Cannot find the free compute env')
+
+    const assets: ComputeAsset[] = [
+      {
+        documentId: resolvedDdoWith1mTimeout.id,
+        serviceId: resolvedDdoWith1mTimeout.services[0].id,
+        transferTxId: paidEnvDatasetTxId
+      }
+    ]
+    const algo: ComputeAlgorithm = {
+      documentId: resolvedAlgoDdoWith1mTimeout.id,
+      serviceId: resolvedAlgoDdoWith1mTimeout.services[0].id,
+      transferTxId: paidEnvAlgoTxId
+    }
+
+    providerInitializeComputeResults = await ProviderInstance.initializeCompute(
+      assets,
+      algo,
+      computeEnv.id,
+      computeValidUntil,
+      providerUrl,
+      consumerAccount
+    )
+    assert(
+      providerInitializeComputeResults.algorithm.validOrder,
+      'We should have a valid order for algorithm'
+    )
+    assert(
+      !providerInitializeComputeResults.algorithm.providerFee,
+      'We should not pay providerFees again for algorithm'
+    )
+    assert(
+      providerInitializeComputeResults.datasets[0].validOrder,
+      'We should have a valid order for dataset'
+    )
+    assert(
+      !providerInitializeComputeResults.datasets[0].providerFee,
+      'We should not pay providerFees again for dataset'
+    )
+    algo.transferTxId = providerInitializeComputeResults.algorithm.validOrder
+    assets[0].transferTxId = providerInitializeComputeResults.datasets[0].validOrder
+    assert(
+      algo.transferTxId === paidEnvAlgoTxId &&
+        assets[0].transferTxId === paidEnvDatasetTxId,
+      'We should use the same orders, because no fess must be paid'
+    )
+    const computeJobs = await ProviderInstance.computeStart(
+      providerUrl,
+      web3,
+      consumerAccount,
+      computeEnv.id,
+      assets[0],
+      algo
+    )
+    assert(computeJobs, 'Cannot start compute job')
+  })
 })