From ae311856a86003f5c5c69ae9eea82f7d23dc5bfd Mon Sep 17 00:00:00 2001
From: Jaremy Creechley <creechley@gmail.com>
Date: Wed, 27 Sep 2023 19:27:43 -0700
Subject: [PATCH] refactor - tests

---
 datastore/fsds.nim                     |   5 +-
 tests/datastore/backendCommonTests.nim | 165 +++++++++++++------------
 tests/datastore/testfsds.nim           |   2 +-
 3 files changed, 87 insertions(+), 85 deletions(-)

diff --git a/datastore/fsds.nim b/datastore/fsds.nim
index cad4a8e..3e09210 100644
--- a/datastore/fsds.nim
+++ b/datastore/fsds.nim
@@ -232,6 +232,7 @@ iterator iter*[K, V](handle: var DbQueryHandle[K, V, FsQueryEnv[K,V]]
     if flres.isErr():
       # echo "FS:ERROR: ", flres.error()
       yield DbQueryResponse[K,V].failure flres.error()
+      continue
 
     let
       key = K.toKey($Key.init(keyPath).expect("valid key"))
@@ -241,8 +242,8 @@ iterator iter*[K, V](handle: var DbQueryHandle[K, V, FsQueryEnv[K,V]]
           if res.isErr():
             # echo "FS:ERROR: ", res.error()
             yield DbQueryResponse[K,V].failure res.error()
-          else:
-            res.get()
+            continue
+          res.get()
         else:
           V.new()
 
diff --git a/tests/datastore/backendCommonTests.nim b/tests/datastore/backendCommonTests.nim
index b3fecbe..e292e6e 100644
--- a/tests/datastore/backendCommonTests.nim
+++ b/tests/datastore/backendCommonTests.nim
@@ -197,109 +197,110 @@ template queryTests*(
       res[2].key.get == key3
       res[2].data == val3
 
-  test "Should apply limit":
-    let
-      key = Key.init("/a").tryGet
-      q = dbQuery(key= key1, limit= 10, value= false)
-
-    for i in 0..<100:
+  if extended:
+    test "Should apply limit":
       let
-        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
-        val = DataBuffer.new("val " & $i)
+        key = Key.init("/a").tryGet
+        q = dbQuery(key= key1, limit= 10, value= false)
 
-      ds.put(key, val).tryGet
+      for i in 0..<100:
+        let
+          key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = DataBuffer.new("val " & $i)
 
-    var
-      handle  = ds.query(q).tryGet
-    let
-      res = handle.iter().toSeq().mapIt(it.tryGet())
+        ds.put(key, val).tryGet
 
-    check:
-      res.len == 10
-
-  test "Should not apply offset":
-    let
-      key = Key.init("/a").tryGet
-      keyId = KeyId.new $key
-      q = dbQuery(key= keyId, offset= 90)
-
-    for i in 0..<100:
+      var
+        handle  = ds.query(q).tryGet
       let
-        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
-        val = DataBuffer.new("val " & $i)
-
-      ds.put(key, val).tryGet
-
-    var
-      qr  = ds.query(q)
-    # echo "RES: ", qr.repr
-
-    var
-      handle  = ds.query(q).tryGet
-    let
-      res = handle.iter().toSeq().mapIt(it.tryGet())
-
-    # echo "RES: ", res.mapIt(it.key)
-    check:
-      res.len == 10
-
-  test "Should not apply offset and limit":
-    let
-      key = Key.init("/a").tryGet
-      keyId = KeyId.new $key
-      q = dbQuery(key= keyId, offset= 95, limit= 5)
-
-    for i in 0..<100:
-      let
-        key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
-        val = DataBuffer.new("val " & $i)
-
-      ds.put(key, val).tryGet
-
-    var
-      handle  = ds.query(q).tryGet
-      res = handle.iter().toSeq().mapIt(it.tryGet())
-
-    check:
-      res.len == 5
-
-    for i in 0..<res.high:
-      let
-        val = DataBuffer.new("val " & $(i + 95))
-        key = KeyId.new $Key.init(key, Key.init("/" & $(i + 95)).tryGet).tryGet
+        res = handle.iter().toSeq().mapIt(it.tryGet())
 
       check:
-        res[i].key.get == key
-        # res[i].data == val
+        res.len == 10
 
-    test "Should apply sort order - descending":
+    test "Should not apply offset":
       let
         key = Key.init("/a").tryGet
         keyId = KeyId.new $key
-        q = dbQuery(key= keyId, value=true, sort= SortOrder.Descending)
+        q = dbQuery(key= keyId, offset= 90)
 
-      var kvs: seq[DbQueryResponse[KeyId, DataBuffer]]
       for i in 0..<100:
         let
-          k = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
-          val = DataBuffer.new ("val " & $i)
+          key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = DataBuffer.new("val " & $i)
 
-        kvs.add((k.some, val))
-        ds.put(k, val).tryGet
+        ds.put(key, val).tryGet
 
-      # lexicographic sort, as it comes from the backend
-      kvs.sort do (a, b: DbQueryResponse[KeyId, DataBuffer]) -> int:
-        cmp($a.key.get, $b.key.get)
+      var
+        qr  = ds.query(q)
+      # echo "RES: ", qr.repr
+
+      var
+        handle  = ds.query(q).tryGet
+      let
+        res = handle.iter().toSeq().mapIt(it.tryGet())
+
+      # echo "RES: ", res.mapIt(it.key)
+      check:
+        res.len == 10
+
+    test "Should not apply offset and limit":
+      let
+        key = Key.init("/a").tryGet
+        keyId = KeyId.new $key
+        q = dbQuery(key= keyId, offset= 95, limit= 5)
+
+      for i in 0..<100:
+        let
+          key = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+          val = DataBuffer.new("val " & $i)
+
+        ds.put(key, val).tryGet
 
-      kvs = kvs.reversed
       var
         handle  = ds.query(q).tryGet
         res = handle.iter().toSeq().mapIt(it.tryGet())
 
       check:
-        res.len == 100
+        res.len == 5
+
+      for i in 0..<res.high:
+        let
+          val = DataBuffer.new("val " & $(i + 95))
+          key = KeyId.new $Key.init(key, Key.init("/" & $(i + 95)).tryGet).tryGet
 
-      for i, r in res[1..^1]:
         check:
-          res[i].key.get == kvs[i].key.get
-          res[i].data == kvs[i].data
\ No newline at end of file
+          res[i].key.get == key
+          # res[i].data == val
+
+      test "Should apply sort order - descending":
+        let
+          key = Key.init("/a").tryGet
+          keyId = KeyId.new $key
+          q = dbQuery(key= keyId, value=true, sort= SortOrder.Descending)
+
+        var kvs: seq[DbQueryResponse[KeyId, DataBuffer]]
+        for i in 0..<100:
+          let
+            k = KeyId.new $Key.init(key, Key.init("/" & $i).tryGet).tryGet
+            val = DataBuffer.new ("val " & $i)
+
+          kvs.add((k.some, val))
+          ds.put(k, val).tryGet
+
+        # lexicographic sort, as it comes from the backend
+        kvs.sort do (a, b: DbQueryResponse[KeyId, DataBuffer]) -> int:
+          cmp($a.key.get, $b.key.get)
+
+        kvs = kvs.reversed
+        var
+          handle  = ds.query(q).tryGet
+          res = handle.iter().toSeq().mapIt(it.tryGet())
+
+        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
\ No newline at end of file
diff --git a/tests/datastore/testfsds.nim b/tests/datastore/testfsds.nim
index 4eb4db3..8a0dd17 100644
--- a/tests/datastore/testfsds.nim
+++ b/tests/datastore/testfsds.nim
@@ -188,7 +188,7 @@ suite "queryTests":
     val2 = DataBuffer.new "value for 2"
     val3 = DataBuffer.new "value for 3"
 
-  queryTests(fsNew, key1, key2, key3, val1, val2, val3, extended=true)
+  queryTests(fsNew, key1, key2, key3, val1, val2, val3, extended=false)
 
   removeDir(basePathAbs)
   require(not dirExists(basePathAbs))