Test with live Sync server

Before starting the test-session, initiate a Sync server with Docker.

Author: Shubham

objectbox/sync.py

@@ -562,12 +562,14 @@ def close(self):
         It can no longer be used afterwards, make a new sync client instead.
         Does nothing if this sync client has already been closed.
         """
-        c.obx_sync_listener_error(self.__c_sync_client_ptr, None, None)
-        c.obx_sync_listener_login(self.__c_sync_client_ptr, None, None)
-        c.obx_sync_listener_login_failure(self.__c_sync_client_ptr, None, None)
-        c.obx_sync_listener_connect(self.__c_sync_client_ptr, None, None)
-        c.obx_sync_listener_disconnect(self.__c_sync_client_ptr, None, None)
-        c.obx_sync_listener_change(self.__c_sync_client_ptr, None, None)
+        c.obx_sync_listener_error(self.__c_sync_client_ptr, ctypes.cast(None, c.OBX_sync_listener_error_t), None)
+        c.obx_sync_listener_login(self.__c_sync_client_ptr, ctypes.cast(None, c.OBX_sync_listener_login_t), None)
+        c.obx_sync_listener_login_failure(self.__c_sync_client_ptr,
+                                          ctypes.cast(None, c.OBX_sync_listener_login_failure_t), None)
+        c.obx_sync_listener_connect(self.__c_sync_client_ptr, ctypes.cast(None, c.OBX_sync_listener_connect_t), None)
+        c.obx_sync_listener_disconnect(self.__c_sync_client_ptr, ctypes.cast(None, c.OBX_sync_listener_disconnect_t),
+                                       None)
+        c.obx_sync_listener_change(self.__c_sync_client_ptr, ctypes.cast(None, c.OBX_sync_listener_change_t), None)
         c.obx_sync_close(self.__c_sync_client_ptr)
         self.__c_sync_client_ptr = None
 

tests/common.py

@@ -1,11 +1,21 @@
 import os
+import time
+import subprocess
+import socket
+
 import pytest
 import objectbox
 from objectbox.logger import logger
 from tests.model import *
 import numpy as np
 from datetime import datetime, timezone
 from objectbox import *
+import logging
+
+from dataclasses import dataclass
+
+test_logger = logging.getLogger(__name__)
+
 
 def remove_json_model_file():
     path = os.path.dirname(os.path.realpath(__file__))
@@ -35,6 +45,56 @@ def create_test_store(db_path: str = "testdata", clear_db: bool = True) -> objec
     return objectbox.Store(model=create_default_model(), directory=db_path)
 
 
+@dataclass
+class SyncServerConfig:
+    container_id: str
+    port: int
+
+
+def start_sync_server() -> SyncServerConfig | None:
+    """ Starts the ObjectBox Sync Server in a Docker container. """
+    current_dir = os.path.dirname(os.path.realpath(__file__))
+    user_id = os.getuid()
+    try:
+        command = ("docker run "
+                   "--rm "
+                   "-d "
+                   f"--volume {current_dir}:/data "
+                   f"--user {user_id} "
+                   "-p 127.0.0.1:9999:9999 "
+                   "objectboxio/sync-server-trial "
+                   "--conf sync_server_config.json")
+        logger.info("Using command to start Sync Server Docker container:" + command)
+        stdout = subprocess.run(command.split(), check=True, capture_output=True, text=True).stdout
+        container_id = stdout.strip()
+
+        start_time = time.time()
+        while (time.time() - start_time) < 10:
+            try:
+                with socket.create_connection(("127.0.0.1", 9999)):
+                    break
+            except OSError:
+                pass
+        else:
+            raise RuntimeError("Timed out waiting for Sync Server to start")
+
+        test_logger.info("Started ObjectBox Sync Server in Docker")
+        return SyncServerConfig(container_id=container_id, port=9999)
+    except Exception as e:
+        test_logger.warning(f"Could not start ObjectBox Sync Server in Docker: {e}")
+        return None
+
+
+def stop_sync_server(container_id: str):
+    """ Stops the ObjectBox Sync Server Docker container. """
+    try:
+        command = f"docker stop {container_id}"
+        subprocess.run(command.split(), check=True)
+        test_logger.info("Stopped ObjectBox Sync Server Docker container")
+    except Exception as e:
+        test_logger.warning(f"Could not stop ObjectBox Sync Server Docker container: {e}")
+
+
 def assert_equal_prop(actual, expected, default):
     if isinstance(expected, objectbox.model.properties.Property):
         assert (actual == default)

tests/conftest.py

@@ -1,6 +1,6 @@
 import pytest
 from objectbox.logger import logger
-from objectbox.sync import SyncLoginListener, SyncConnectionListener, SyncErrorListener
+from objectbox.sync import SyncLoginListener, SyncConnectionListener, SyncErrorListener, SyncClient, SyncCredentials
 from common import *
 
 
@@ -21,6 +21,7 @@ def test_store():
     yield store
     store.close()
 
+
 class TestLoginListener(SyncLoginListener):
     def __init__(self):
         self.logged_in_called = False
@@ -52,22 +53,45 @@ def __init__(self):
     def on_error(self, sync_error_code: int):
         self.sync_error_code = sync_error_code
 
+
 @pytest.fixture
 def connection_listener():
     listener = TestConnectionListener()
     yield listener
     listener.connected_called = False
     listener.disconnected_called = False
 
+
 @pytest.fixture
 def login_listener():
     listener = TestLoginListener()
     yield listener
     listener.logged_in_called = False
     listener.login_failure_code = None
 
+
 @pytest.fixture
 def error_listener():
     listener = TestErrorListener()
     yield listener
-    listener.sync_error_code = None
+    listener.sync_error_code = None
+
+
+@pytest.fixture
+def sync_client(test_store, login_listener, connection_listener, error_listener):
+    server_urls = ["ws://127.0.0.1:9999"]
+    client = SyncClient(test_store, server_urls)
+    client.set_credentials(SyncCredentials.none())
+    client.set_login_listener(login_listener)
+    client.set_connection_listener(connection_listener)
+    client.set_error_listener(error_listener)
+    yield client
+    client.close()
+
+
+@pytest.fixture(scope="session")
+def sync_server():
+    server_config = start_sync_server()
+    yield server_config
+    if server_config:
+        stop_sync_server(server_config.container_id)

tests/sync_server_config.json

@@ -0,0 +1,8 @@
+{
+  "modelFile": "/data/objectbox-model.json",
+  "dbMaxSize": "1G",
+  "bind": "ws://0.0.0.0:9999",
+  "adminBind": "http://0.0.0.0:9980",
+  "unsecuredNoAuthentication": true,
+  "_debug": true
+}

tests/test_sync.py

@@ -1,5 +1,4 @@
 from collections.abc import Callable
-from time import sleep
 
 import pytest
 
@@ -11,32 +10,28 @@ def test_sync_protocol_version():
     version = SyncClient.protocol_version()
     assert version >= 1
 
-def test_sync_client_states(test_store):
-    server_urls = ["ws://localhost:9999"]
-    client = SyncClient(test_store, server_urls)
-    assert client.get_sync_state() == SyncState.CREATED
-    client.start()
-    assert client.get_sync_state() == SyncState.STARTED
-    client.stop()
-    assert client.get_sync_state() == SyncState.STOPPED
-    client.close()
 
-def test_sync_listener(test_store, login_listener, connection_listener):
-    server_urls = ["ws://127.0.0.1:9999"]
-    client = SyncClient(test_store, server_urls)
-    client.set_credentials(SyncCredentials.shared_secret_string("shared_secret"))
-    client.set_login_listener(login_listener)
-    client.set_connection_listener(connection_listener)
+def test_sync_client_states(sync_client):
+    assert sync_client.get_sync_state() == SyncState.CREATED
+    sync_client.start()
+    assert sync_client.get_sync_state() == SyncState.STARTED
+    sync_client.stop()
+    assert sync_client.get_sync_state() == SyncState.STOPPED
+    sync_client.close()
 
-    client.start()
-    sleep(1)
-    client.stop()
-    client.close()
 
-    assert login_listener.login_failure_code is not None
-    assert login_listener.login_failure_code == SyncCode.CREDENTIALS_REJECTED
+def test_sync_listener(sync_server, sync_client, login_listener, connection_listener):
+    if not sync_server:
+        pytest.skip("Sync server not available")
+
+    sync_client.start()
+    sync_client.wait_for_logged_in_state(timeout_millis=5000)
+    sync_client.stop()
+    sync_client.close()
+
+    assert login_listener.logged_in_called
+    assert login_listener.login_failure_code is None
     assert connection_listener.connected_called
-    assert connection_listener.disconnected_called
 
 
 def test_filter_variables(test_store):
@@ -59,35 +54,29 @@ def test_filter_variables(test_store):
     client.close()
 
 
-def test_outgoing_message_count(test_store):
-    server_urls = ["ws://localhost:9999"]
-    client = SyncClient(test_store, server_urls)
-
-    count = client.get_outgoing_message_count()
+def test_outgoing_message_count(sync_client):
+    count = sync_client.get_outgoing_message_count()
     assert count == 0
 
-    count_limited = client.get_outgoing_message_count(limit=10)
+    count_limited = sync_client.get_outgoing_message_count(limit=10)
     assert count_limited == 0
 
-    client.close()
-
-    with pytest.raises(IllegalArgumentError, match='Argument "sync" must not be null'):
-        client.get_outgoing_message_count()
+    sync_client.close()
 
+    with pytest.raises(ValueError, match='SyncClient already closed'):
+        sync_client.get_outgoing_message_count()
 
-def test_multiple_credentials(test_store):
-    server_urls = ["ws://localhost:9999"]
-    client = SyncClient(test_store, server_urls)
 
+def test_multiple_credentials(sync_client):
     # empty list should raise ValueError
     with pytest.raises(ValueError, match='Provide at least one credential'):
-        client.set_multiple_credentials([])
+        sync_client.set_multiple_credentials([])
 
     # SyncCredentials.none() is not supported with multiple credentials
     with pytest.raises(ValueError, match=r'SyncCredentials.none\(\) is not supported, use set_credentials\(\) instead'):
-        client.set_multiple_credentials([SyncCredentials.none()])
+        sync_client.set_multiple_credentials([SyncCredentials.none()])
 
-    client.set_multiple_credentials([
+    sync_client.set_multiple_credentials([
         SyncCredentials.google_auth("token_google"),
         SyncCredentials.user_and_password("user1", "password"),
         SyncCredentials.shared_secret_string("secret1"),
@@ -98,39 +87,34 @@ def test_multiple_credentials(test_store):
     ])
 
 
-def test_client_closed_when_store_closed(test_store):
-    server_urls = ["ws://localhost:9999"]
-    client = SyncClient(test_store, server_urls)
-
-    assert not client.is_closed()
+def test_client_closed_when_store_closed(test_store, sync_client):
+    assert not sync_client.is_closed()
     test_store.close()
-    assert client.is_closed()
+    assert sync_client.is_closed()
 
 
 def assert_raises_value_error(fn: Callable[[], object | None], message: str | None = None):
     with pytest.raises(ValueError, match=message):
         fn()
 
 
-def test_client_access_after_close_throws_error(test_store):
-    server_urls = ["ws://localhost:9999"]
-    client = SyncClient(test_store, server_urls)
-    client.close()
+def test_client_access_after_close_throws_error(sync_client):
+    sync_client.close()
 
-    assert client.is_closed()
+    assert sync_client.is_closed()
 
     match_error = "SyncClient already closed"
 
-    assert_raises_value_error(message=match_error, fn=lambda: client.start())
-    assert_raises_value_error(message=match_error, fn=lambda: client.stop())
-    assert_raises_value_error(message=match_error, fn=lambda: client.get_sync_state())
-    assert_raises_value_error(message=match_error, fn=lambda: client.get_outgoing_message_count())
-    assert_raises_value_error(message=match_error, fn=lambda: client.set_credentials(SyncCredentials.none()))
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.start())
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.stop())
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.get_sync_state())
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.get_outgoing_message_count())
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.set_credentials(SyncCredentials.none()))
     assert_raises_value_error(message=match_error,
-                              fn=lambda: client.set_credentials(SyncCredentials.google_auth("token_google")))
-    assert_raises_value_error(message=match_error, fn=lambda: client.set_multiple_credentials([
+                              fn=lambda: sync_client.set_credentials(SyncCredentials.google_auth("token_google")))
+    assert_raises_value_error(message=match_error, fn=lambda: sync_client.set_multiple_credentials([
         SyncCredentials.google_auth("token_google"),
         SyncCredentials.user_and_password("user1", "password")
     ]))
     assert_raises_value_error(message=match_error,
-                              fn=lambda: client.set_request_updates_mode(SyncRequestUpdatesMode.AUTO))
+                              fn=lambda: sync_client.set_request_updates_mode(SyncRequestUpdatesMode.AUTO))