From e39bd530d98f2ace35a26b5da6ec60e425669214 Mon Sep 17 00:00:00 2001
From: Dmitriy Ryajov <dryajov@gmail.com>
Date: Thu, 14 Sep 2023 18:05:58 -0600
Subject: [PATCH] wip

---
 tests/datastore/querycommontests.nim  | 366 +++++++++++++-------------
 tests/datastore/testthreadproxyds.nim |   2 +-
 2 files changed, 184 insertions(+), 184 deletions(-)

diff --git a/tests/datastore/querycommontests.nim b/tests/datastore/querycommontests.nim
index 5f63be0..9f305b0 100644
--- a/tests/datastore/querycommontests.nim
+++ b/tests/datastore/querycommontests.nim
@@ -26,108 +26,108 @@ template queryTests*(ds: Datastore, extended = true) {.dirty.} =
     val2 = "value for 2".toBytes
     val3 = "value for 3".toBytes
 
-  # test "Key should query all keys and all it's children":
-  #   let
-  #     q = Query.init(key1)
+  test "Key should query all keys and all it's children":
+    let
+      q = Query.init(key1)
 
-  #   (await ds.put(key1, val1)).tryGet
-  #   (await ds.put(key2, val2)).tryGet
-  #   (await ds.put(key3, val3)).tryGet
+    (await ds.put(key1, val1)).tryGet
+    (await ds.put(key2, val2)).tryGet
+    (await ds.put(key3, val3)).tryGet
 
-  #   let
-  #     iter = (await ds.query(q)).tryGet
-  #     res = block:
-  #       var
-  #         res: seq[QueryResponse]
-  #         cnt = 0
+    let
+      iter = (await ds.query(q)).tryGet
+      res = block:
+        var
+          res: seq[QueryResponse]
+          cnt = 0
 
-  #       while not iter.finished:
-  #         let (key, val) = (await iter.next()).tryGet
-  #         if key.isNone:
-  #           break
+        while not iter.finished:
+          let (key, val) = (await iter.next()).tryGet
+          if key.isNone:
+            break
 
-  #         res.add((key, val))
-  #         cnt.inc
+          res.add((key, val))
+          cnt.inc
 
-  #       res
+        res
 
-  #   check:
-  #     res.len == 3
-  #     res[0].key.get == key1
-  #     res[0].data == val1
+    check:
+      res.len == 3
+      res[0].key.get == key1
+      res[0].data == val1
 
-  #     res[1].key.get == key2
-  #     res[1].data == val2
+      res[1].key.get == key2
+      res[1].data == val2
 
-  #     res[2].key.get == key3
-  #     res[2].data == val3
+      res[2].key.get == key3
+      res[2].data == val3
 
-  #   (await iter.dispose()).tryGet
+    (await iter.dispose()).tryGet
 
-  # test "Key should query all keys without values":
-  #   let
-  #     q = Query.init(key1, value = false)
+  test "Key should query all keys without values":
+    let
+      q = Query.init(key1, value = false)
 
-  #   (await ds.put(key1, val1)).tryGet
-  #   (await ds.put(key2, val2)).tryGet
-  #   (await ds.put(key3, val3)).tryGet
+    (await ds.put(key1, val1)).tryGet
+    (await ds.put(key2, val2)).tryGet
+    (await ds.put(key3, val3)).tryGet
 
-  #   let
-  #     iter = (await ds.query(q)).tryGet
-  #     res = block:
-  #       var res: seq[QueryResponse]
-  #       while not iter.finished:
-  #         let (key, val) = (await iter.next()).tryGet
-  #         if key.isNone:
-  #           break
+    let
+      iter = (await ds.query(q)).tryGet
+      res = block:
+        var res: seq[QueryResponse]
+        while not iter.finished:
+          let (key, val) = (await iter.next()).tryGet
+          if key.isNone:
+            break
 
-  #         res.add((key, val))
+          res.add((key, val))
 
-  #       res
+        res
 
-  #   check:
-  #     res.len == 3
-  #     res[0].key.get == key1
-  #     res[0].data.len == 0
+    check:
+      res.len == 3
+      res[0].key.get == key1
+      res[0].data.len == 0
 
-  #     res[1].key.get == key2
-  #     res[1].data.len == 0
+      res[1].key.get == key2
+      res[1].data.len == 0
 
-  #     res[2].key.get == key3
-  #     res[2].data.len == 0
+      res[2].key.get == key3
+      res[2].data.len == 0
 
-  #   (await iter.dispose()).tryGet
+    (await iter.dispose()).tryGet
 
-  # test "Key should not query parent":
-  #   let
-  #     q = Query.init(key2)
+  test "Key should not query parent":
+    let
+      q = Query.init(key2)
 
-  #   (await ds.put(key1, val1)).tryGet
-  #   (await ds.put(key2, val2)).tryGet
-  #   (await ds.put(key3, val3)).tryGet
+    (await ds.put(key1, val1)).tryGet
+    (await ds.put(key2, val2)).tryGet
+    (await ds.put(key3, val3)).tryGet
 
-  #   let
-  #     iter = (await ds.query(q)).tryGet
-  #     res = block:
-  #       var res: seq[QueryResponse]
-  #       while not iter.finished:
-  #         let (key, val) = (await iter.next()).tryGet
-  #         if key.isNone:
-  #           break
+    let
+      iter = (await ds.query(q)).tryGet
+      res = block:
+        var res: seq[QueryResponse]
+        while not iter.finished:
+          let (key, val) = (await iter.next()).tryGet
+          if key.isNone:
+            break
 
-  #         res.add((key, val))
+          res.add((key, val))
 
-  #       res
+        res
 
-  #   check:
-  #     res.len == 2
-  #     res[0].key.get == key2
-  #     res[0].data == val2
+    check:
+      res.len == 2
+      res[0].key.get == key2
+      res[0].data == val2
 
-  #     res[1].key.get == key3
-  #     res[1].data == val3
+      res[1].key.get == key3
+      res[1].data == val3
 
-  #   (await iter.dispose()).tryGet
+    (await iter.dispose()).tryGet
 
   test "Key should list all keys at the same level":
     let
@@ -173,145 +173,145 @@ template queryTests*(ds: Datastore, extended = true) {.dirty.} =
 
     (await iter.dispose()).tryGet
 
-  # if extended:
-  #   test "Should apply limit":
-  #     let
-  #       key = Key.init("/a").tryGet
-  #       q = Query.init(key, limit = 10)
+  if extended:
+    test "Should apply limit":
+      let
+        key = Key.init("/a").tryGet
+        q = Query.init(key, limit = 10)
 
-  #     for i in 0..<100:
-  #       let
-  #         key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
-  #         val = ("val " & $i).toBytes
+      for i in 0..<100:
+        let
+          key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = ("val " & $i).toBytes
 
-  #       echo "putting ", $key
-  #       (await ds.put(key, val)).tryGet
+        echo "putting ", $key
+        (await ds.put(key, val)).tryGet
 
-  #     let
-  #       iter = (await ds.query(q)).tryGet
-  #       res = block:
-  #         var res: seq[QueryResponse]
-  #         while not iter.finished:
-  #           let (key, val) = (await iter.next()).tryGet
-  #           if key.isNone:
-  #             break
+      let
+        iter = (await ds.query(q)).tryGet
+        res = block:
+          var res: seq[QueryResponse]
+          while not iter.finished:
+            let (key, val) = (await iter.next()).tryGet
+            if key.isNone:
+              break
 
-  #           res.add((key, val))
+            res.add((key, val))
 
-  #         res
+          res
 
-  #     check:
-  #       res.len == 10
+      check:
+        res.len == 10
 
-  #     (await iter.dispose()).tryGet
+      (await iter.dispose()).tryGet
 
-    # test "Should not apply offset":
-    #   let
-    #     key = Key.init("/a").tryGet
-    #     q = Query.init(key, offset = 90)
+    test "Should not apply offset":
+      let
+        key = Key.init("/a").tryGet
+        q = Query.init(key, offset = 90)
 
-    #   for i in 0..<100:
-    #     let
-    #       key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
-    #       val = ("val " & $i).toBytes
+      for i in 0..<100:
+        let
+          key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = ("val " & $i).toBytes
 
-    #     (await ds.put(key, val)).tryGet
+        (await ds.put(key, val)).tryGet
 
-    #   let
-    #     iter = (await ds.query(q)).tryGet
-    #     res = block:
-    #       var res: seq[QueryResponse]
-    #       while not iter.finished:
-    #         let (key, val) = (await iter.next()).tryGet
-    #         if key.isNone:
-    #           break
+      let
+        iter = (await ds.query(q)).tryGet
+        res = block:
+          var res: seq[QueryResponse]
+          while not iter.finished:
+            let (key, val) = (await iter.next()).tryGet
+            if key.isNone:
+              break
 
-    #         res.add((key, val))
+            res.add((key, val))
 
-    #       res
+          res
 
-    #   check:
-    #     res.len == 10
+      check:
+        res.len == 10
 
-    #   (await iter.dispose()).tryGet
+      (await iter.dispose()).tryGet
 
-    # test "Should not apply offset and limit":
-    #   let
-    #     key = Key.init("/a").tryGet
-    #     q = Query.init(key, offset = 95, limit = 5)
+    test "Should not apply offset and limit":
+      let
+        key = Key.init("/a").tryGet
+        q = Query.init(key, offset = 95, limit = 5)
 
-    #   for i in 0..<100:
-    #     let
-    #       key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
-    #       val = ("val " & $i).toBytes
+      for i in 0..<100:
+        let
+          key = Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = ("val " & $i).toBytes
 
-    #     (await ds.put(key, val)).tryGet
+        (await ds.put(key, val)).tryGet
 
-    #   let
-    #     iter = (await ds.query(q)).tryGet
-    #     res = block:
-    #       var res: seq[QueryResponse]
-    #       while not iter.finished:
-    #         let (key, val) = (await iter.next()).tryGet
-    #         if key.isNone:
-    #           break
+      let
+        iter = (await ds.query(q)).tryGet
+        res = block:
+          var res: seq[QueryResponse]
+          while not iter.finished:
+            let (key, val) = (await iter.next()).tryGet
+            if key.isNone:
+              break
 
-    #         res.add((key, val))
+            res.add((key, val))
 
-    #       res
+          res
 
-    #   check:
-    #     res.len == 5
+      check:
+        res.len == 5
 
-    #   for i in 0..<res.high:
-    #     let
-    #       val = ("val " & $(i + 95)).toBytes
-    #       key = Key.init(key, Key.init("/" & $(i + 95)).tryGet).tryGet
+      for i in 0..<res.high:
+        let
+          val = ("val " & $(i + 95)).toBytes
+          key = Key.init(key, Key.init("/" & $(i + 95)).tryGet).tryGet
 
-    #     check:
-    #       res[i].key.get == key
-    #       res[i].data == val
+        check:
+          res[i].key.get == key
+          res[i].data == val
 
-    #   (await iter.dispose()).tryGet
+      (await iter.dispose()).tryGet
 
-    # test "Should apply sort order - descending":
-    #   let
-    #     key = Key.init("/a").tryGet
-    #     q = Query.init(key, sort = SortOrder.Descending)
+    test "Should apply sort order - descending":
+      let
+        key = Key.init("/a").tryGet
+        q = Query.init(key, sort = SortOrder.Descending)
 
-    #   var kvs: seq[QueryResponse]
-    #   for i in 0..<100:
-    #     let
-    #       k = Key.init(key, Key.init("/" & $i).tryGet).tryGet
-    #       val = ("val " & $i).toBytes
+      var kvs: seq[QueryResponse]
+      for i in 0..<100:
+        let
+          k = Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = ("val " & $i).toBytes
 
-    #     kvs.add((k.some, val))
-    #     (await ds.put(k, val)).tryGet
+        kvs.add((k.some, val))
+        (await ds.put(k, val)).tryGet
 
-    #   # lexicographic sort, as it comes from the backend
-    #   kvs.sort do (a, b: QueryResponse) -> int:
-    #     cmp(a.key.get.id, b.key.get.id)
+      # lexicographic sort, as it comes from the backend
+      kvs.sort do (a, b: QueryResponse) -> int:
+        cmp(a.key.get.id, b.key.get.id)
 
-    #   kvs = kvs.reversed
-    #   let
-    #     iter = (await ds.query(q)).tryGet
-    #     res = block:
-    #       var res: seq[QueryResponse]
-    #       while not iter.finished:
-    #         let (key, val) = (await iter.next()).tryGet
-    #         if key.isNone:
-    #           break
+      kvs = kvs.reversed
+      let
+        iter = (await ds.query(q)).tryGet
+        res = block:
+          var res: seq[QueryResponse]
+          while not iter.finished:
+            let (key, val) = (await iter.next()).tryGet
+            if key.isNone:
+              break
 
-    #         res.add((key, val))
+            res.add((key, val))
 
-    #       res
+          res
 
-    #   check:
-    #     res.len == 100
+      check:
+        res.len == 100
 
-    #   for i, r in res[1..^1]:
-    #     check:
-    #       res[i].key.get == kvs[i].key.get
-    #       res[i].data == kvs[i].data
+      for i, r in res[1..^1]:
+        check:
+          res[i].key.get == kvs[i].key.get
+          res[i].data == kvs[i].data
 
-    #   (await iter.dispose()).tryGet
+      (await iter.dispose()).tryGet
diff --git a/tests/datastore/testthreadproxyds.nim b/tests/datastore/testthreadproxyds.nim
index 45434e7..c415dec 100644
--- a/tests/datastore/testthreadproxyds.nim
+++ b/tests/datastore/testthreadproxyds.nim
@@ -39,6 +39,7 @@ suite "Test Basic ThreadDatastore with SQLite":
     taskPool.shutdown()
 
   basicStoreTests(ds, key, bytes, otherBytes)
+  queryTests(ds, true)
 
 # suite "Test Basic ThreadDatastore with fsds":
 
@@ -55,4 +56,3 @@ suite "Test Basic ThreadDatastore with SQLite":
 #     ds: ThreadDatastore
 #     taskPool: Taskpool
 
-  queryTests(ds, true)