Eliminate hacky use of timestamps and time.sleep in tests (#2120)

Author: kounelisagis

tiledb/tests/cc/test_group.py

@@ -28,7 +28,6 @@ def test_group_metadata(tmp_path):
     assert_array_equal(grp._get_metadata("flt", False)[0], flt_data)
     grp._close()
 
-    time.sleep(0.001)
     grp._open(lt.QueryType.WRITE)
     grp._delete_metadata("int")
     grp._close()

tiledb/tests/test_fixes.py

@@ -364,26 +364,16 @@ class SOMA919Test(DiskTestCase):
     We've distilled @atolopko-czi's gist example using the TileDB-Py API directly.
     """
 
-    def run_test(self, use_timestamps):
+    def run_test(self):
         import tempfile
 
         import numpy as np
 
         import tiledb
 
         root_uri = tempfile.mkdtemp()
-
-        if use_timestamps:
-            group_ctx100 = tiledb.Ctx(
-                {
-                    "sm.group.timestamp_start": 100,
-                    "sm.group.timestamp_end": 100,
-                }
-            )
-            timestamp = 100
-        else:
-            group_ctx100 = tiledb.Ctx()
-            timestamp = None
+        group_ctx100 = tiledb.Ctx()
+        timestamp = None
 
         # create the group and add a dummy subgroup "causes_bug"
         tiledb.Group.create(root_uri, ctx=group_ctx100)
@@ -411,13 +401,12 @@ def run_test(self, use_timestamps):
         tiledb.libtiledb.version() < (2, 15, 0),
         reason="SOMA919 fix implemented in libtiledb 2.15",
     )
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_soma919(self, use_timestamps):
+    def test_soma919(self):
         N = 100
         fails = 0
         for i in range(N):
             try:
-                self.run_test(use_timestamps)
+                self.run_test()
             except AssertionError:
                 fails += 1
         if fails > 0:

tiledb/tests/test_group.py

@@ -120,10 +120,7 @@ def test_move_group(self):
             ),
         ),
     )
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_group_metadata(
-        self, int_data, flt_data, str_data, str_type, capfd, use_timestamps
-    ):
+    def test_group_metadata(self, int_data, flt_data, str_data, str_type, capfd):
         def values_equal(lhs, rhs):
             if isinstance(lhs, np.ndarray):
                 if not isinstance(rhs, np.ndarray):
@@ -139,13 +136,13 @@ def values_equal(lhs, rhs):
         grp_path = self.path("test_group_metadata")
         tiledb.Group.create(grp_path)
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "w", cfg) as grp:
             grp.meta["int"] = int_data
             grp.meta["flt"] = flt_data
             grp.meta["str"] = str_data
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "r", cfg) as grp:
             assert len(grp.meta) == 3
             assert "int" in grp.meta
@@ -162,11 +159,11 @@ def values_equal(lhs, rhs):
             assert "Type: DataType.INT" in metadata_dump
             assert f"Type: DataType.{str_type}" in metadata_dump
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "w", cfg) as grp:
             del grp.meta["int"]
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "r", cfg) as grp:
             assert len(grp.meta) == 2
             assert "int" not in grp.meta
@@ -373,8 +370,7 @@ class GroupMetadataTest(GroupTestCase):
             (np.array([1, 2, 3]), np.array([1.5, 2.5, 3.5]), np.array(["x"])),
         ),
     )
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_group_metadata(self, int_data, flt_data, str_data, use_timestamps):
+    def test_group_metadata(self, int_data, flt_data, str_data):
         def values_equal(lhs, rhs):
             if isinstance(lhs, np.ndarray):
                 if not isinstance(rhs, np.ndarray):
@@ -390,13 +386,13 @@ def values_equal(lhs, rhs):
         grp_path = self.path("test_group_metadata")
         tiledb.Group.create(grp_path)
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "w", cfg) as grp:
             grp.meta["int"] = int_data
             grp.meta["flt"] = flt_data
             grp.meta["str"] = str_data
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "r", cfg) as grp:
             assert grp.meta.keys() == {"int", "flt", "str"}
             assert len(grp.meta) == 3
@@ -407,11 +403,11 @@ def values_equal(lhs, rhs):
             assert "str" in grp.meta
             assert values_equal(grp.meta["str"], str_data)
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "w", cfg) as grp:
             del grp.meta["int"]
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(grp_path, "r", cfg) as grp:
             assert len(grp.meta) == 2
             assert "int" not in grp.meta
@@ -641,21 +637,20 @@ def test_numpy(self, test_vals, ndarray):
         self.assert_metadata_roundtrip(grp.meta, test_vals)
         grp.close()
 
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_consolidation_and_vac(self, use_timestamps):
+    def test_consolidation_and_vac(self):
         vfs = tiledb.VFS()
         path = self.path("test_consolidation_and_vac")
         tiledb.Group.create(path)
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 1} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(path, "w", cfg) as grp:
             grp.meta["meta"] = 1
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 2} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(path, "w", cfg) as grp:
             grp.meta["meta"] = 2
 
-        cfg = tiledb.Config({"sm.group.timestamp_end": 3} if use_timestamps else {})
+        cfg = tiledb.Config()
         with tiledb.Group(path, "w", cfg) as grp:
             grp.meta["meta"] = 3
 

tiledb/tests/test_libtiledb.py

@@ -823,8 +823,7 @@ def test_ncell_int(self):
                 assert_array_equal(T, R)
                 assert_array_equal(T, R.multi_index[0:2][""])
 
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_open_with_timestamp(self, use_timestamps):
+    def test_open_with_timestamp(self):
         A = np.zeros(3)
 
         dom = tiledb.Domain(tiledb.Dim(domain=(0, 2), tile=3, dtype=np.int64))
@@ -841,15 +840,9 @@ def test_open_with_timestamp(self, use_timestamps):
             self.assertEqual(T[1], 0)
             self.assertEqual(T[2], 0)
 
-        if use_timestamps:
-            # sleep 200ms and write
-            time.sleep(0.2)
         with tiledb.DenseArray(self.path("foo"), mode="w") as T:
             T[0:1] = 1
 
-        if use_timestamps:
-            # sleep 200ms and write
-            time.sleep(0.2)
         with tiledb.DenseArray(self.path("foo"), mode="w") as T:
             T[1:2] = 2
 

tiledb/tests/test_metadata.py

@@ -189,8 +189,7 @@ def test_basic(self, test_vals):
 
     @given(st_metadata, st_ndarray)
     @settings(deadline=None)
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_numpy(self, use_timestamps, test_vals, ndarray):
+    def test_numpy(self, test_vals, ndarray):
         test_vals["ndarray"] = ndarray
 
         path = self.path()
@@ -203,9 +202,6 @@ def test_numpy(self, use_timestamps, test_vals, ndarray):
         with tiledb.Array(path) as A:
             self.assert_metadata_roundtrip(A.meta, test_vals)
 
-        if use_timestamps:
-            # test resetting a key with a ndarray value to a non-ndarray value
-            time.sleep(0.001)
         with tiledb.Array(path, "w") as A:
             A.meta["ndarray"] = 42
             test_vals["ndarray"] = 42
@@ -221,19 +217,13 @@ def test_numpy(self, use_timestamps, test_vals, ndarray):
         with tiledb.Array(path) as A:
             self.assert_metadata_roundtrip(A.meta, test_vals)
 
-        if use_timestamps:
-            # test del ndarray key
-            time.sleep(0.001)
         with tiledb.Array(path, "w") as A:
             del A.meta["ndarray"]
             del test_vals["ndarray"]
 
         with tiledb.Array(path) as A:
             self.assert_metadata_roundtrip(A.meta, test_vals)
 
-        if use_timestamps:
-            # test update
-            time.sleep(0.001)
         with tiledb.Array(path, mode="w") as A:
             test_vals.update(ndarray=np.stack([ndarray, ndarray]), transp=ndarray.T)
             A.meta.update(ndarray=np.stack([ndarray, ndarray]), transp=ndarray.T)
@@ -245,8 +235,7 @@ def test_numpy(self, use_timestamps, test_vals, ndarray):
     @tiledb.scope_ctx(
         {"sm.vacuum.mode": "array_meta", "sm.consolidation.mode": "array_meta"}
     )
-    @pytest.mark.parametrize("use_timestamps", [True, False])
-    def test_consecutive(self, use_timestamps):
+    def test_consecutive(self):
         vfs = tiledb.VFS()
         path = self.path("test_md_consecutive")
 
@@ -259,17 +248,10 @@ def test_consecutive(self, use_timestamps):
         randutf8s = [rand_utf8(i) for i in np.random.randint(1, 30, size=write_count)]
 
         # write 100 times, then consolidate
-        if use_timestamps:
-            for i in range(write_count):
-                with tiledb.Array(path, mode="w") as A:
-                    A.meta["randint"] = int(randints[i])
-                    A.meta["randutf8"] = randutf8s[i]
-                    time.sleep(0.001)
-        else:
-            for i in range(write_count):
-                with tiledb.Array(path, mode="w") as A:
-                    A.meta["randint"] = int(randints[i])
-                    A.meta["randutf8"] = randutf8s[i]
+        for i in range(write_count):
+            with tiledb.Array(path, mode="w") as A:
+                A.meta["randint"] = int(randints[i])
+                A.meta["randutf8"] = randutf8s[i]
 
         self.assertEqual(len(vfs.ls(os.path.join(path, "__meta"))), 100)
 
@@ -296,23 +278,11 @@ def test_consecutive(self, use_timestamps):
             self.assertEqual(A.meta["randutf8"], randutf8s[-1])
 
         # use randutf8s as keys, then consolidate
-        if use_timestamps:
-            for _ in range(2):
-                for i in range(write_count):
-                    with tiledb.Array(path, mode="w") as A:
-                        A.meta[randutf8s[i] + "{}".format(randints[i])] = int(
-                            randints[i]
-                        )
-                        A.meta[randutf8s[i]] = randutf8s[i]
-                        time.sleep(0.001)
-        else:
-            for _ in range(2):
-                for i in range(write_count):
-                    with tiledb.Array(path, mode="w") as A:
-                        A.meta[randutf8s[i] + "{}".format(randints[i])] = int(
-                            randints[i]
-                        )
-                        A.meta[randutf8s[i]] = randutf8s[i]
+        for _ in range(2):
+            for i in range(write_count):
+                with tiledb.Array(path, mode="w") as A:
+                    A.meta[randutf8s[i] + "{}".format(randints[i])] = int(randints[i])
+                    A.meta[randutf8s[i]] = randutf8s[i]
 
         # test data
         with tiledb.Array(path) as A: