PLM-146: Increase test timeout (#107)

Author: inelpandzic

main.go

@@ -584,28 +584,28 @@ func createServer(ctx context.Context, sourceURI, targetURI string) (*server, er
 	promRegistry := prometheus.NewRegistry()
 	metrics.Init(promRegistry)
 
-	mlink := plm.New(source, target)
+	lm := plm.New(source, target)
 
-	err = Restore(ctx, target, mlink)
+	err = Restore(ctx, target, lm)
 	if err != nil {
 		return nil, errors.Wrap(err, "recover PLM")
 	}
 
-	mlink.SetOnStateChanged(func(newState plm.State) {
-		err := DoCheckpoint(ctx, target, mlink)
+	lm.SetOnStateChanged(func(newState plm.State) {
+		err := DoCheckpoint(ctx, target, lm)
 		if err != nil {
 			log.New("http:checkpointing").Error(err, "checkpoint")
 		} else {
 			log.New("http:checkpointing").Debugf("Checkpoint saved on %q", newState)
 		}
 	})
 
-	go RunCheckpointing(ctx, target, mlink)
+	go RunCheckpointing(ctx, target, lm)
 
 	s := &server{
 		sourceCluster: source,
 		targetCluster: target,
-		plm:           mlink,
+		plm:           lm,
 		stopHeartbeat: stopHeartbeat,
 		promRegistry:  promRegistry,
 	}

tests/conftest.py

@@ -5,7 +5,7 @@
 
 import pytest
 import testing
-from mlink import PLM
+from plm import PLM
 from pymongo import MongoClient
 
 
@@ -52,7 +52,7 @@ def target_conn(request: pytest.FixtureRequest):
 
 
 @pytest.fixture(scope="session")
-def mlink(request: pytest.FixtureRequest):
+def plm(request: pytest.FixtureRequest):
     """Provide a plm instance."""
     url = request.config.getoption("--plm_url") or os.environ["TEST_PLM_URL"]
     return PLM(url)
@@ -65,8 +65,8 @@ def plm_bin(request: pytest.FixtureRequest):
 
 
 @pytest.fixture(scope="session")
-def t(source_conn: MongoClient, target_conn: MongoClient, mlink: PLM):
-    return testing.Testing(source_conn, target_conn, mlink)
+def t(source_conn: MongoClient, target_conn: MongoClient, plm: PLM):
+    return testing.Testing(source_conn, target_conn, plm)
 
 
 @pytest.fixture(autouse=True)

tests/mlink.py tests/plm.pytests/mlink.py renamed to tests/plm.py

@@ -25,7 +25,7 @@ def __str__(self):
 
 
 class PLM:
-    """MLink provides methods to interact with the PLM service."""
+    """PLM provides methods to interact with the PLM service."""
 
     class State(StrEnum):
         """State represents the state of the PLM service."""
@@ -38,7 +38,7 @@ class State(StrEnum):
         FINALIZED = "finalized"
 
     def __init__(self, uri: str):
-        """Initialize MLink with the given URI."""
+        """Initialize PLM with the given URI."""
         self.uri = uri
 
     def status(self):
@@ -116,13 +116,13 @@ class Phase(StrEnum):
     def __init__(
         self,
         source: MongoClient,
-        mlink: PLM,
+        plm: PLM,
         phase: Phase,
         options: dict,
         wait_timeout=None,
     ):
         self.source: MongoClient = source
-        self.mlink = mlink
+        self.plm = plm
         self.phase = phase
         self.options = options
         self.wait_timeout = wait_timeout or 10
@@ -147,43 +147,43 @@ def __exit__(self, _t, exc, _tb):
     def start(self, pause_on_initial_sync=False):
         """Start the PLM service."""
         self.finalize(fast=True)
-        self.mlink.start(pause_on_initial_sync=pause_on_initial_sync, **self.options)
+        self.plm.start(pause_on_initial_sync=pause_on_initial_sync, **self.options)
 
     def finalize(self, *, fast=False):
         """Finalize the PLM service."""
-        state = self.mlink.status()
+        state = self.plm.status()
 
         if state["state"] == PLM.State.PAUSED:
             if state["initialSync"]["cloneCompleted"]:
-                self.mlink.resume()
-                state = self.mlink.status()
+                self.plm.resume()
+                state = self.plm.status()
 
         if state["state"] == PLM.State.RUNNING:
             if not fast:
                 self.wait_for_current_optime()
             self.wait_for_initial_sync()
-            self.mlink.finalize()
-            state = self.mlink.status()
+            self.plm.finalize()
+            state = self.plm.status()
 
         if state["state"] == PLM.State.FINALIZING:
             if not fast:
                 self.wait_for_state(PLM.State.FINALIZED)
 
     def wait_for_state(self, state: PLM.State):
         """Wait for the PLM service to reach the specified state."""
-        if self.mlink.status()["state"] == state:
+        if self.plm.status()["state"] == state:
             return
 
         for _ in range(self.wait_timeout * 2):
             time.sleep(0.5)
-            if self.mlink.status()["state"] == state:
+            if self.plm.status()["state"] == state:
                 return
 
         raise WaitTimeoutError()
 
     def wait_for_current_optime(self):
         """Wait for the current operation time to be applied."""
-        status = self.mlink.status()
+        status = self.plm.status()
         assert status["state"] == PLM.State.RUNNING, status
 
         curr_optime = self.source.server_info()["$clusterTime"]["clusterTime"]
@@ -192,13 +192,13 @@ def wait_for_current_optime(self):
                 return
 
             time.sleep(0.5)
-            status = self.mlink.status()
+            status = self.plm.status()
 
         raise WaitTimeoutError()
 
     def wait_for_initial_sync(self):
         """Wait for the PLM service to be finalizable."""
-        status = self.mlink.status()
+        status = self.plm.status()
         assert status["state"] != PLM.State.IDLE, status
 
         if status["initialSync"]["completed"]:
@@ -211,28 +211,28 @@ def wait_for_initial_sync(self):
                 return
 
             time.sleep(0.5)
-            status = self.mlink.status()
+            status = self.plm.status()
 
         raise WaitTimeoutError()
 
     def wait_for_clone_completed(self):
         """Wait for the PLM service completed clone."""
-        status = self.mlink.status()
+        status = self.plm.status()
         assert status["state"] != PLM.State.IDLE, status
 
         for _ in range(self.wait_timeout * 2):
             if status["initialSync"]["cloneCompleted"]:
                 return
 
             time.sleep(0.5)
-            status = self.mlink.status()
+            status = self.plm.status()
 
         raise WaitTimeoutError()
 
     @property
     def last_applied_op(self):
         """Get the last applied operation time."""
-        status = self.mlink.status()
+        status = self.plm.status()
         if last_replicated_op_time := status.get("lastReplicatedOpTime"):
             t_s, i_s = last_replicated_op_time.split(".")
             return bson.Timestamp(int(t_s), int(i_s))

tests/test_collections.py

@@ -4,7 +4,7 @@
 
 import pytest
 import testing
-from mlink import PLM, Runner
+from plm import PLM, Runner
 from pymongo import MongoClient
 from testing import Testing
 
@@ -125,6 +125,7 @@ def test_create_view_with_collation(t: Testing, phase: Runner.Phase):
     t.compare_all()
 
 
+@pytest.mark.timeout(15)
 @pytest.mark.parametrize("phase", [Runner.Phase.APPLY, Runner.Phase.CLONE])
 def test_create_timeseries_ignored(t: Testing, phase: Runner.Phase):
     with t.run(phase):
@@ -326,6 +327,7 @@ def test_modify_view(t: Testing, phase: Runner.Phase):
     t.compare_all()
 
 
+@pytest.mark.timeout(15)
 @pytest.mark.parametrize("phase", [Runner.Phase.APPLY, Runner.Phase.CLONE])
 def test_modify_timeseries_options_ignored(t: Testing, phase: Runner.Phase):
     t.source["db_1"].create_collection(
@@ -586,7 +588,7 @@ def test_plm_109_rename_complex(t: Testing, phase: Runner.Phase):
 
     t.compare_all()
 
-
+@pytest.mark.timeout(30)
 def test_plm_110_rename_during_clone_and_repl(t: Testing):
     payload = random.randbytes(1000)
     for i in range(10):

tests/test_documents.py

@@ -3,7 +3,7 @@
 
 import pymongo
 import pytest
-from mlink import Runner
+from plm import Runner
 from testing import Testing
 
 

tests/test_indexes.py

@@ -4,7 +4,7 @@
 
 import pymongo
 import pytest
-from mlink import Runner
+from plm import Runner
 from testing import Testing
 
 
@@ -61,12 +61,12 @@ def test_create_partial(t: Testing, phase: Runner.Phase):
 
 @pytest.mark.parametrize("phase", [Runner.Phase.APPLY, Runner.Phase.CLONE])
 def test_create_hidden(t: Testing, phase: Runner.Phase):
-    with t.run(phase) as mlink:
+    with t.run(phase) as plm:
         name = t.source["db_1"]["coll_1"].create_index({"i": 1}, hidden=True)
         assert t.source["db_1"]["coll_1"].index_information()[name]["hidden"]
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             assert "hidden" not in t.target["db_1"]["coll_1"].index_information()[name]
 
     t.compare_all()
@@ -296,7 +296,7 @@ def test_modify_unique(t: Testing, phase: Runner.Phase):
 
 @pytest.mark.parametrize("phase", [Runner.Phase.APPLY, Runner.Phase.CLONE])
 def test_internal_create_many_props(t: Testing, phase: Runner.Phase):
-    with t.run(phase) as mlink:
+    with t.run(phase) as plm:
         options = {
             "unique": True,
             "hidden": True,
@@ -309,7 +309,7 @@ def test_internal_create_many_props(t: Testing, phase: Runner.Phase):
             assert source_index.get(prop) == val
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             for prop, val in options.items():
                 if prop == "expireAfterSeconds":
@@ -324,7 +324,7 @@ def test_internal_create_many_props(t: Testing, phase: Runner.Phase):
 def test_internal_modify_many_props(t: Testing, phase: Runner.Phase):
     index_name = t.source["db_1"]["coll_1"].create_index({"i": 1})
 
-    with t.run(phase) as mlink:
+    with t.run(phase) as plm:
         t.source["db_1"].command(
             {
                 "collMod": "coll_1",
@@ -336,7 +336,7 @@ def test_internal_modify_many_props(t: Testing, phase: Runner.Phase):
         assert source_index["prepareUnique"]
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             assert "prepareUnique" not in target_index
 
@@ -357,7 +357,7 @@ def test_internal_modify_many_props(t: Testing, phase: Runner.Phase):
             assert source_index.get(prop) == val
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             for prop, val in modify_options.items():
                 if prop == "expireAfterSeconds":
@@ -379,9 +379,9 @@ def test_internal_modify_index_props_complex(t: Testing, phase: Runner.Phase):
     assert "hidden" not in source_index1
     assert "expireAfterSeconds" not in source_index1
 
-    with t.run(phase) as mlink:
+    with t.run(phase) as plm:
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             assert "prepareUnique" not in target_index
             assert "unique" not in target_index
@@ -408,7 +408,7 @@ def test_internal_modify_index_props_complex(t: Testing, phase: Runner.Phase):
         assert source_index2["expireAfterSeconds"] == 132
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             assert "prepareUnique" not in target_index
             assert "unique" not in target_index
@@ -433,7 +433,7 @@ def test_internal_modify_index_props_complex(t: Testing, phase: Runner.Phase):
         assert source_index3["expireAfterSeconds"] == 133
 
         if phase == Runner.Phase.APPLY:
-            mlink.wait_for_current_optime()
+            plm.wait_for_current_optime()
             target_index = t.target["db_1"]["coll_1"].index_information()[index_name]
             assert "prepareUnique" not in target_index
             assert "unique" not in target_index
@@ -449,16 +449,16 @@ def test_internal_modify_index_props_complex(t: Testing, phase: Runner.Phase):
 
 
 def test_manual_create_ttl(t: Testing):
-    mlink = t.run(Runner.Phase.MANUAL)
+    plm = t.run(Runner.Phase.MANUAL)
     try:
         t.source["db_1"]["coll_1"].create_index({"a": 1}, expireAfterSeconds=1)
-        mlink.start()
+        plm.start()
         t.source["db_1"]["coll_1"].create_index({"b": 1}, expireAfterSeconds=1)
-        mlink.wait_for_initial_sync()
+        plm.wait_for_initial_sync()
         t.source["db_1"]["coll_1"].create_index({"c": 1}, expireAfterSeconds=1)
-        mlink.finalize()
+        plm.finalize()
     except:
-        mlink.finalize(fast=True)
+        plm.finalize(fast=True)
         raise
 
     t.compare_all()