rename tests

tests/datastore/templates.nim

@@ -1 +0,0 @@
-template asyncTest*(name, body: untyped) = test(name, body)

tests/datastore/testdatastore.nim

@@ -5,25 +5,24 @@ import pkg/chronos
 import pkg/stew/results
 
 import ../../datastore
-import ./templates
 
 suite "Datastore (base)":
   let
     key = Key.init("a").get
     ds = Datastore()
 
-  asyncTest "put":
+  test "put":
     expect Defect: discard ds.put(key, @[1.byte])
 
-  asyncTest "delete":
+  test "delete":
     expect Defect: discard ds.delete(key)
 
-  asyncTest "contains":
+  test "contains":
     expect Defect: discard ds.contains(key)
 
-  asyncTest "get":
+  test "get":
     expect Defect: discard ds.get(key)
 
-  asyncTest "query":
+  test "query":
     expect Defect:
       for n in ds.query(Query.init(key)): discard

tests/datastore/testfsds.nim

@@ -0,0 +1,141 @@
+import std/algorithm
+import std/options
+import std/os
+
+import pkg/asynctest/unittest2
+import pkg/chronos
+import pkg/stew/results
+import pkg/stew/byteutils
+
+import pkg/datastore/fsds
+
+import ./basictests
+
+suite "Test Basic FSDatastore":
+  let
+    (path, _, _) = instantiationInfo(-1, fullPaths = true) # get this file's name
+    basePath = "tests_data"
+    basePathAbs = path.parentDir / basePath
+    key = Key.init("/a/b").tryGet()
+    bytes = "some bytes".toBytes
+    otherBytes = "some other bytes".toBytes
+
+  var
+    fsStore: FSDatastore
+
+  setupAll:
+    removeDir(basePathAbs)
+    require(not dirExists(basePathAbs))
+    createDir(basePathAbs)
+
+    fsStore = FSDatastore.new(root = basePathAbs).tryGet()
+
+  teardownAll:
+    removeDir(basePathAbs)
+    require(not dirExists(basePathAbs))
+
+  basicStoreTests(fsStore, key, bytes, otherBytes)
+
+suite "Test Misc FSDatastore":
+  let
+    (path, _, _) = instantiationInfo(-1, fullPaths = true) # get this file's name
+    basePath = "tests_data"
+    basePathAbs = path.parentDir / basePath
+    bytes = "some bytes".toBytes
+
+  setupAll:
+    removeDir(basePathAbs)
+    require(not dirExists(basePathAbs))
+    createDir(basePathAbs)
+
+  teardownAll:
+    removeDir(basePathAbs)
+    require(not dirExists(basePathAbs))
+
+  test "Test checkProtected()":
+    let
+      fs = FSDatastore.new(root = "/").tryGet()
+
+    for p in ProtectedPaths:
+      if p == "/": continue
+      let
+        key = Key.init(p).tryGet()
+
+      check:
+        fs.path(key).checkProtected()
+
+  test "Test protected paths":
+    let
+      fs = FSDatastore.new(root = "/").tryGet()
+
+    for p in ProtectedPaths:
+      if p == "/": continue
+      let
+        key = Key.init(p).tryGet()
+
+      check:
+        (await fs.put(key, bytes)).isErr
+        (await fs.get(key)).isErr
+        (await fs.delete(key)).isErr
+        (await fs.contains(key)).isErr
+
+  test "Test allowed()":
+    let
+      chars = [
+        "/a*", "/a/b*", "/a/b$", "/a/b()",
+        "/a/b+", "/a/b$", "/d%", "/A/b@",
+        "/A!", "/b#/##"]
+
+    for c in chars:
+      check not c.allowed
+
+  test "Test valid key (path) names":
+    let
+      fs = FSDatastore.new(root = basePathAbs).tryGet()
+      bytes = "some bytes".toBytes
+      chars =
+        ["/a*", "/a/b*", "/a/b$", "/a/b()",
+          "/a/b+", "/a/b$", "/d%", "/A/b@",
+          "/A!", "/b#/##"]
+
+    for c in chars:
+      let
+        key = Key.init(c).tryGet()
+
+      check:
+        (await fs.put(key, bytes)).isErr
+        (await fs.get(key)).isErr
+        (await fs.delete(key)).isErr
+        (await fs.contains(key)).isErr
+
+  test "Test validDepth()":
+    let
+      fs = FSDatastore.new(root = "/", depth = 3).tryGet()
+      invalid = Key.init("/a/b/c/d").tryGet()
+      valid = Key.init("/a/b/c").tryGet()
+
+    check:
+      not fs.validDepth(invalid)
+      fs.validDepth(valid)
+
+  test "Test invalid key (path) depth":
+    let
+      fs = FSDatastore.new(root = basePathAbs, depth = 3).tryGet()
+      key = Key.init("/a/b/c/d").tryGet()
+
+    check:
+      (await fs.put(key, bytes)).isErr
+      (await fs.get(key)).isErr
+      (await fs.delete(key)).isErr
+      (await fs.contains(key)).isErr
+
+  test "Test valid key (path) depth":
+    let
+      fs = FSDatastore.new(root = basePathAbs, depth = 3).tryGet()
+      key = Key.init("/a/b/c").tryGet()
+
+    check:
+      (await fs.put(key, bytes)).isOk
+      (await fs.get(key)).isOk
+      (await fs.delete(key)).isOk
+      (await fs.contains(key)).isOk

tests/datastore/testfstore.nim

@@ -1,196 +0,0 @@
-import std/options
-import std/os
-
-import pkg/asynctest/unittest2
-import pkg/chronos
-import pkg/questionable
-import pkg/questionable/results
-import pkg/stew/byteutils
-from pkg/stew/results as stewResults import get, isOk
-
-import ../../datastore/fsstore
-import ./templates
-
-suite "FSDatastore":
-  # assumes tests/test_all is run from project root, e.g. with `nimble test`
-  let
-    root = "tests" / "test_data"
-    rootAbs = getCurrentDir() / root
-
-  setup:
-    removeDir(rootAbs)
-    require(not dirExists(rootAbs))
-    createDir(rootAbs)
-
-  teardown:
-    removeDir(rootAbs)
-    require(not dirExists(rootAbs))
-
-  asyncTest "new":
-    var
-      dsRes: ?!FSDatastore
-
-    dsRes = FSDatastore.new(rootAbs / "missing")
-
-    check: dsRes.isErr
-
-    dsRes = FSDatastore.new(rootAbs)
-
-    check: dsRes.isOk
-
-    dsRes = FSDatastore.new(root)
-
-    check: dsRes.isOk
-
-  asyncTest "accessors":
-    let
-      ds = FSDatastore.new(root).get
-
-    check: ds.root == rootAbs
-
-  asyncTest "helpers":
-      let
-        ds = FSDatastore.new(root).tryGet()
-
-      check:
-        # see comment in ../../datastore/filesystem_datastore re: whether path
-        # equivalence of e.g. Key(/a:b) and Key(/a/b) is problematic
-        ds.path(Key.init("a").tryGet()) == rootAbs / "a"
-        ds.path(Key.init("a:b").tryGet()) == rootAbs / "a" / "b"
-        ds.path(Key.init("a/b").tryGet()) == rootAbs / "a" / "b"
-        ds.path(Key.init("a:b/c").tryGet()) == rootAbs / "a" / "b" / "c"
-        ds.path(Key.init("a/b/c").tryGet()) == rootAbs / "a" / "b" / "c"
-        ds.path(Key.init("a:b/c:d").tryGet()) == rootAbs / "a" / "b" / "c" / "d"
-        ds.path(Key.init("a/b/c:d").tryGet()) == rootAbs / "a" / "b" / "c" / "d"
-        ds.path(Key.init("a/b/c/d").tryGet()) == rootAbs / "a" / "b" / "c" / "d"
-
-  asyncTest "put":
-    let
-      ds = FSDatastore.new(root).get
-      key = Key.init("a:b/c/d:e").get
-      path = ds.path(key)
-
-    var
-      bytes: seq[byte]
-      putRes = await ds.put(key, bytes)
-
-    check:
-      putRes.isOk
-      readFile(path).toBytes == bytes
-
-    bytes = @[1.byte, 2.byte, 3.byte]
-
-    putRes = await ds.put(key, bytes)
-
-    check:
-      putRes.isOk
-      readFile(path).toBytes == bytes
-
-    bytes = @[4.byte, 5.byte, 6.byte]
-
-    putRes = await ds.put(key, bytes)
-
-    check:
-      putRes.isOk
-      readFile(path).toBytes == bytes
-
-  asyncTest "delete":
-    let
-      bytes = @[1.byte, 2.byte, 3.byte]
-      ds = FSDatastore.new(root).get
-
-    var
-      key = Key.init("a:b/c/d:e").get
-      path = ds.path(key)
-
-    let
-      putRes = await ds.put(key, bytes)
-
-    assert putRes.isOk
-
-    var
-      delRes = await ds.delete(key)
-
-    check:
-      delRes.isOk
-      not fileExists(path)
-      dirExists(parentDir(path))
-
-    key = Key.init("X/Y/Z").get
-    path = ds.path(key)
-    assert not fileExists(path)
-
-    delRes = await ds.delete(key)
-
-    check: delRes.isOk
-
-  asyncTest "contains":
-    let
-      bytes = @[1.byte, 2.byte, 3.byte]
-      ds = FSDatastore.new(root).get
-
-    var
-      key = Key.init("a:b/c/d:e").get
-      path = ds.path(key)
-      putRes = await ds.put(key, bytes)
-
-    assert putRes.isOk
-
-    var
-      containsRes = await ds.contains(key)
-
-    check:
-      containsRes.isOk
-      containsRes.get == true
-
-    key = Key.init("X/Y/Z").get
-    path = ds.path(key)
-    assert not fileExists(path)
-
-    containsRes = await ds.contains(key)
-
-    check:
-      containsRes.isOk
-      containsRes.get == false
-
-  asyncTest "get":
-    let
-      ds = FSDatastore.new(root).get
-
-    var
-      bytes: seq[byte]
-      key = Key.init("a:b/c/d:e").get
-      path = ds.path(key)
-      putRes = await ds.put(key, bytes)
-
-    assert putRes.isOk
-
-    var
-      getRes = await ds.get(key)
-      getOpt = getRes.get
-
-    check: getOpt.isSome and getOpt.get == bytes
-
-    bytes = @[1.byte, 2.byte, 3.byte]
-    putRes = await ds.put(key, bytes)
-
-    assert putRes.isOk
-
-    getRes = await ds.get(key)
-    getOpt = getRes.get
-
-    check: getOpt.isSome and getOpt.get == bytes
-
-    key = Key.init("X/Y/Z").get
-    path = ds.path(key)
-
-    assert not fileExists(path)
-
-    getRes = await ds.get(key)
-    getOpt = getRes.get
-
-    check: getOpt.isNone
-
-  # asyncTest "query":
-  #   check:
-  #     true

tests/datastore/testnullds.nim

@@ -4,34 +4,33 @@ import pkg/asynctest/unittest2
 import pkg/chronos
 import pkg/stew/results
 
-import ../../datastore/null_datastore
-import ./templates
+import pkg/datastore/nullds
 
 suite "NullDatastore":
   let
     key = Key.init("a").get
     ds = NullDatastore.new()
 
-  asyncTest "new":
+  test "new":
     check: not ds.isNil
 
-  asyncTest "put":
+  test "put":
     check: (await ds.put(key, @[1.byte])).isOk
 
-  asyncTest "delete":
+  test "delete":
     check: (await ds.delete(key)).isOk
 
-  asyncTest "contains":
+  test "contains":
     check:
       (await ds.contains(key)).isOk
       (await ds.contains(key)).get == false
 
-  asyncTest "get":
+  test "get":
     check:
       (await ds.get(key)).isOk
       (await ds.get(key)).get.isNone
 
-  asyncTest "query":
+  test "query":
     var
       x = true
 

tests/datastore/testsql.nim

@@ -0,0 +1,4 @@
+import ./sql/testsqlitedsdb
+import ./sql/testsqliteds
+
+{.warning[UnusedImport]: off.}

tests/datastore/testtieredds.nim

@@ -5,10 +5,9 @@ import pkg/asynctest/unittest2
 import pkg/chronos
 import pkg/stew/results
 
-import ../../datastore/filesystem_datastore
-import ../../datastore/sqlite_datastore
-import ../../datastore/tiered_datastore
-import ./templates
+import ../../datastore/fsds
+import ../../datastore/sql
+import ../../datastore/tieredds
 
 suite "TieredDatastore":
   # assumes tests/test_all is run from project root, e.g. with `nimble test`
@@ -35,7 +34,7 @@ suite "TieredDatastore":
     removeDir(rootAbs)
     require(not dirExists(rootAbs))
 
-  asyncTest "new":
+  test "new":
     check:
       TieredDatastore.new().isErr
       TieredDatastore.new([]).isErr
@@ -44,7 +43,7 @@ suite "TieredDatastore":
       TieredDatastore.new([ds1, ds2]).isOk
       TieredDatastore.new(@[ds1, ds2]).isOk
 
-  asyncTest "accessors":
+  test "accessors":
     let
       stores = @[ds1, ds2]
 
@@ -53,7 +52,7 @@ suite "TieredDatastore":
       TieredDatastore.new([ds1, ds2]).get.stores == stores
       TieredDatastore.new(@[ds1, ds2]).get.stores == stores
 
-  asyncTest "put":
+  test "put":
     let
       ds = TieredDatastore.new(ds1, ds2).get
 
@@ -68,7 +67,7 @@ suite "TieredDatastore":
       (await ds1.get(key)).get.get == bytes
       (await ds2.get(key)).get.get == bytes
 
-  asyncTest "delete":
+  test "delete":
     let
       ds = TieredDatastore.new(ds1, ds2).get
       putRes = await ds.put(key, bytes)
@@ -85,7 +84,7 @@ suite "TieredDatastore":
       (await ds1.get(key)).get.isNone
       (await ds2.get(key)).get.isNone
 
-  asyncTest "contains":
+  test "contains":
     let
       ds = TieredDatastore.new(ds1, ds2).get
 
@@ -106,7 +105,7 @@ suite "TieredDatastore":
       (await ds1.contains(key)).get
       (await ds2.contains(key)).get
 
-  asyncTest "get":
+  test "get":
     var
       ds = TieredDatastore.new(ds1, ds2).get
 
@@ -149,6 +148,6 @@ suite "TieredDatastore":
       (await ds1.get(key)).get.isSome
       (await ds1.get(key)).get.get == bytes
 
-  # asyncTest "query":
+  # test "query":
   #   check:
   #     true

tests/test_all.nim

@@ -1,9 +0,0 @@
-import
-  ./datastore/test_key,
-  ./datastore/test_datastore,
-  ./datastore/test_null_datastore,
-  ./datastore/test_filesystem_datastore,
-  ./datastore/test_sqlite_datastore,
-  ./datastore/test_tiered_datastore
-
-{.warning[UnusedImport]: off.}

tests/testall.nim

@@ -0,0 +1,9 @@
+import
+  ./datastore/testkey,
+  ./datastore/testdatastore,
+  ./datastore/testnullds,
+  ./datastore/testfsds,
+  ./datastore/testsql,
+  ./datastore/testtieredds
+
+{.warning[UnusedImport]: off.}