From eda4a85c3e3809a628a13f54204597879c659f5b Mon Sep 17 00:00:00 2001
From: Eric <5089238+emizzle@users.noreply.github.com>
Date: Thu, 26 Oct 2023 15:47:08 +1100
Subject: [PATCH] DRYing, renaming

---
 tests/integration/codexclient.nim |  3 ++
 tests/integration/multinodes.nim  | 44 ++++++++--------
 tests/integration/testproofs.nim  | 88 +++++++++++++++++++------------
 3 files changed, 80 insertions(+), 55 deletions(-)

diff --git a/tests/integration/codexclient.nim b/tests/integration/codexclient.nim
index 6fe1556f..6de8a8f6 100644
--- a/tests/integration/codexclient.nim
+++ b/tests/integration/codexclient.nim
@@ -141,3 +141,6 @@ proc close*(client: CodexClient) =
 proc restart*(client: CodexClient) =
   client.http.close()
   client.http = newHttpClient()
+
+proc purchaseStateIs(client: CodexClient, id: PurchaseId, state: string): bool =
+  client.getPurchase(id).option.?state == some state
diff --git a/tests/integration/multinodes.nim b/tests/integration/multinodes.nim
index 85f8e17d..2094e012 100644
--- a/tests/integration/multinodes.nim
+++ b/tests/integration/multinodes.nim
@@ -23,18 +23,18 @@ type
     role*: Role
     node*: NodeProcess
     address*: ?Address
-  StartNodes* = object
-    clients*: StartNodeConfig
-    providers*: StartNodeConfig
-    validators*: StartNodeConfig
-    hardhat*: StartHardhatConfig
-  StartNodeConfig* = object
+  Nodes* = object
+    clients*: NodeConfig
+    providers*: NodeConfig
+    validators*: NodeConfig
+    hardhat*: HardhatConfig
+  NodeConfig* = object
     numNodes*: int
     cliOptions*: seq[CliOption]
     logFile*: bool
     logTopics*: seq[string]
     debugEnabled*: bool
-  StartHardhatConfig* = ref object
+  HardhatConfig* = ref object
     logFile*: bool
   Role* {.pure.} = enum
     Client,
@@ -58,7 +58,7 @@ proc new*(_: type RunningNode,
   RunningNode(role: role,
               node: node)
 
-proc nodes*(config: StartNodeConfig, numNodes: int): StartNodeConfig =
+proc nodes*(config: NodeConfig, numNodes: int): NodeConfig =
   if numNodes < 0:
     raise newException(ValueError, "numNodes must be >= 0")
 
@@ -67,10 +67,10 @@ proc nodes*(config: StartNodeConfig, numNodes: int): StartNodeConfig =
   return startConfig
 
 proc simulateProofFailuresFor*(
-  config: StartNodeConfig,
+  config: NodeConfig,
   providerIdx: int,
   failEveryNProofs: int
-): StartNodeConfig =
+): NodeConfig =
 
   if providerIdx > config.numNodes - 1:
     raise newException(ValueError, "provider index out of bounds")
@@ -85,16 +85,16 @@ proc simulateProofFailuresFor*(
   )
   return startConfig
 
-proc debug*(config: StartNodeConfig, enabled = true): StartNodeConfig =
+proc debug*(config: NodeConfig, enabled = true): NodeConfig =
   ## output log in stdout
   var startConfig = config
   startConfig.debugEnabled = enabled
   return startConfig
 
 # proc withLogFile*(
-#   config: StartNodeConfig,
+#   config: NodeConfig,
 #   file: bool | string
-# ): StartNodeConfig =
+# ): NodeConfig =
 
 #   var startConfig = config
 #   when file is bool:
@@ -109,34 +109,34 @@ proc debug*(config: StartNodeConfig, enabled = true): StartNodeConfig =
 #   return startConfig
 
 proc withLogTopics*(
-  config: StartNodeConfig,
+  config: NodeConfig,
   topics: varargs[string]
-): StartNodeConfig =
+): NodeConfig =
 
   var startConfig = config
   startConfig.logTopics = startConfig.logTopics.concat(@topics)
   return startConfig
 
 proc withLogFile*(
-  config: StartNodeConfig,
+  config: NodeConfig,
   logToFile: bool = true
-): StartNodeConfig =
+): NodeConfig =
 
   var startConfig = config
   startConfig.logFile = logToFile
   return startConfig
 
 proc withLogFile*(
-  config: StartHardhatConfig,
+  config: HardhatConfig,
   logToFile: bool = true
-): StartHardhatConfig =
+): HardhatConfig =
 
   var startConfig = config
   startConfig.logFile = logToFile
   return startConfig
 
 template multinodesuite*(name: string,
-  startNodes: StartNodes, body: untyped) =
+  startNodes: Nodes, body: untyped) =
 
   asyncchecksuite name:
 
@@ -160,7 +160,7 @@ template multinodesuite*(name: string,
       let fileName = logDir / fn
       return fileName
 
-    proc newHardhatProcess(config: StartHardhatConfig, role: Role): NodeProcess =
+    proc newHardhatProcess(config: HardhatConfig, role: Role): NodeProcess =
       var options: seq[string] = @[]
       if config.logFile:
         let updatedLogFile = getLogFile(role, none int)
@@ -173,7 +173,7 @@ template multinodesuite*(name: string,
       return node
 
     proc newNodeProcess(roleIdx: int,
-                        config1: StartNodeConfig,
+                        config1: NodeConfig,
                         role: Role
     ): NodeProcess =
 
diff --git a/tests/integration/testproofs.nim b/tests/integration/testproofs.nim
index 029edd8b..7ec04a2b 100644
--- a/tests/integration/testproofs.nim
+++ b/tests/integration/testproofs.nim
@@ -5,10 +5,10 @@ import pkg/chronicles
 import pkg/stew/byteutils
 import pkg/codex/contracts
 import pkg/codex/periods
-import pkg/codex/rng
 import ../contracts/time
 import ../contracts/deployment
 import ../codex/helpers
+import ../examples
 import ./twonodes
 import ./multinodes
 
@@ -110,7 +110,7 @@ logScope:
 #     stopValidator(validator)
 
 # multinodesuite "Simulate invalid proofs",
-#   StartNodes.init(clients=1, providers=0, validators=1),
+#   Nodes.init(clients=1, providers=0, validators=1),
 #   DebugConfig.init(client=false, provider=false, validator=false):
 #     # .simulateProofFailuresFor(providerIdx = 0, failEveryNProofs = 2),
 
@@ -239,18 +239,48 @@ logScope:
 
 #     await subscription.unsubscribe()
 
-multinodesuite "Simulate invalid proofs",
-  StartNodes(
-    hardhat: StartHardhatConfig()
+multinodesuite "Simulate invalid proofs - 1 provider node",
+  Nodes(
+    hardhat: HardhatConfig()
               .withLogFile(),
 
-    clients: StartNodeConfig()
+    clients: NodeConfig()
               .nodes(1)
               .debug()
               .withLogFile()
               .withLogTopics("node"),
 
-    providers: StartNodeConfig()
+    providers: NodeConfig()
+                .nodes(1)
+                .simulateProofFailuresFor(providerIdx=0, failEveryNProofs=2)
+                .debug()
+                .withLogFile()
+                .withLogTopics(
+                  "marketplace",
+                  "sales",
+                  "reservations",
+                  "node",
+                  "JSONRPC-HTTP-CLIENT",
+                  "JSONRPC-WS-CLIENT",
+                  "ethers",
+                  "restapi"
+                )
+  ):
+    test "1=1":
+      check 1 == 1
+
+multinodesuite "Simulate invalid proofs",
+  Nodes(
+    hardhat: HardhatConfig()
+              .withLogFile(),
+
+    clients: NodeConfig()
+              .nodes(1)
+              .debug()
+              .withLogFile()
+              .withLogTopics("node"),
+
+    providers: NodeConfig()
                 .nodes(5)
                 .simulateProofFailuresFor(providerIdx=0, failEveryNProofs=2)
                 .debug()
@@ -266,18 +296,12 @@ multinodesuite "Simulate invalid proofs",
                   "restapi"
                 ),
 
-    validators: StartNodeConfig()
+    validators: NodeConfig()
                   .nodes(1)
                   .withLogFile()
                   .withLogTopics("validator", "initial-proving", "proving")
   ):
 
-    # .simulateProofFailuresFor(providerIdx = 0, failEveryNProofs = 2),
-  # DebugConfig.init(client=false, provider=true, validator=false, topics="marketplace,sales,proving,reservations,node,JSONRPC-HTTP-CLIENT,JSONRPC-WS-CLIENT,ethers"):
-
-  proc purchaseStateIs(client: CodexClient, id: PurchaseId, state: string): bool =
-    client.getPurchase(id).option.?state == some state
-
   var marketplace: Marketplace
   var period: uint64
   var token: Erc20Token
@@ -303,29 +327,27 @@ multinodesuite "Simulate invalid proofs",
     let endOfPeriod = periodicity.periodEnd(currentPeriod)
     await provider.advanceTimeTo(endOfPeriod + 1)
 
-  proc requestStorage(proofProbability: uint64 = 1,
+  proc createAvailabilities(datasetSize: int, duration: uint64) =
+    # post availability to each provider
+    for i in 0..<providers().len:
+      let provider = providers()[i].node.client
+
+      discard provider.postAvailability(
+        size=datasetSize.u256, # should match 1 slot only
+        duration=duration.u256,
+        minPrice=300.u256,
+        maxCollateral=200.u256
+      )
+
+  proc requestStorage(data: seq[byte],
+                      proofProbability: uint64 = 1,
                       duration: uint64 = 12.periods,
                       expiry: uint64 = 4.periods): Future[PurchaseId] {.async.} =
 
     if clients().len < 1 or providers().len < 2:
       raiseAssert("must start at least one client and two providers")
 
-    # post availability to each provider
-    for i in 0..<providers().len:
-      let provider = providers()[i].node.client
-
-      discard provider.postAvailability(
-        size=261888.u256, # should match 1 slot only
-        duration=duration.u256,
-        minPrice=300.u256,
-        maxCollateral=200.u256
-      )
-
-
     let client0 = clients()[0].node.client
-    let rng = rng.Rng.instance()
-    let chunker = RandomChunker.new(rng, size = DefaultBlockSize * 2, chunkSize = DefaultBlockSize * 2)
-    let data = await chunker.getBytes()
     let cid = client0.upload(byteutils.toHex(data)).get
     let expiry = (await provider.currentTime()) + expiry.u256
 
@@ -355,11 +377,11 @@ multinodesuite "Simulate invalid proofs",
     let provider1 = providers()[1]
     let totalProofs = 25
 
-    let purchaseId = await requestStorage(duration=totalProofs.periods)
+    let data = await exampleData()
+    createAvailabilities(byteutils.toHex(data).len, totalProofs.periods)
+    let purchaseId = await requestStorage(data, duration=totalProofs.periods)
     check eventually clientRestClient.purchaseStateIs(purchaseId, "started")
 
-    let duration = (totalProofs.periods.int + 2) * 10 # 10 seconds per period
-
     for _ in 0..<totalProofs.periods.int:
       if clientRestClient.purchaseStateIs(purchaseId, "finished"):
         break