add pre-check for sync client ptr not null

Author: Shubham

objectbox/sync.py

@@ -166,7 +166,12 @@ def close_sync_client():
 
         return close_sync_client
 
+    def __check_sync_ptr_not_null(self):
+        if self.__c_sync_client_ptr is None:
+            raise ValueError('SyncClient already closed')
+
     def set_credentials(self, credentials: SyncCredentials):
+        self.__check_sync_ptr_not_null()
         self.__credentials = credentials
         if isinstance(credentials, SyncCredentialsNone):
             c.obx_sync_credentials(self.__c_sync_client_ptr, credentials.type, None, 0)
@@ -181,6 +186,7 @@ def set_credentials(self, credentials: SyncCredentials):
                                    len(credentials.secret))
 
     def set_multiple_credentials(self, credentials_list: list[SyncCredentials]):
+        self.__check_sync_ptr_not_null()
         if len(credentials_list) == 0:
             raise ValueError("Provide at least one credential")
 
@@ -207,6 +213,7 @@ def set_multiple_credentials(self, credentials_list: list[SyncCredentials]):
 
 
     def set_request_updates_mode(self, mode: SyncRequestUpdatesMode):
+        self.__check_sync_ptr_not_null()
         if mode == SyncRequestUpdatesMode.MANUAL:
             c_mode = c.RequestUpdatesMode.MANUAL
         elif mode == SyncRequestUpdatesMode.AUTO:
@@ -218,6 +225,7 @@ def set_request_updates_mode(self, mode: SyncRequestUpdatesMode):
         c.obx_sync_request_updates_mode(self.__c_sync_client_ptr, c_mode)
 
     def get_sync_state(self) -> SyncState:
+        self.__check_sync_ptr_not_null()
         c_state = c.obx_sync_state(self.__c_sync_client_ptr)
         if c_state == c.SyncState.CREATED:
             return SyncState.CREATED
@@ -237,18 +245,23 @@ def get_sync_state(self) -> SyncState:
             return SyncState.UNKNOWN
 
     def start(self):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_start(self.__c_sync_client_ptr)
 
     def stop(self):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_stop(self.__c_sync_client_ptr)
 
     def trigger_reconnect(self) -> bool:
+        self.__check_sync_ptr_not_null()
         return c.check_obx_success(c.obx_sync_trigger_reconnect(self.__c_sync_client_ptr))
 
     def request_updates(self, subscribe_for_future_pushes: bool) -> bool:
+        self.__check_sync_ptr_not_null()
         return c.check_obx_success(c.obx_sync_updates_request(self.__c_sync_client_ptr, subscribe_for_future_pushes))
 
     def cancel_updates(self) -> bool:
+        self.__check_sync_ptr_not_null()
         return c.check_obx_success(c.obx_sync_updates_cancel(self.__c_sync_client_ptr))
 
     @staticmethod
@@ -266,6 +279,7 @@ def is_closed(self) -> bool:
         return self.__c_sync_client_ptr is None
 
     def set_login_listener(self, login_listener: SyncLoginListener):
+        self.__check_sync_ptr_not_null()
         self.__c_login_listener = c.OBX_sync_listener_login(lambda arg: login_listener.on_logged_in())
         self.__c_login_failure_listener = c.OBX_sync_listener_login_failure(
             lambda arg, sync_login_code: login_listener.on_login_failed(sync_login_code))
@@ -281,6 +295,7 @@ def set_login_listener(self, login_listener: SyncLoginListener):
         )
 
     def set_connection_listener(self, connection_listener: SyncConnectionListener):
+        self.__check_sync_ptr_not_null()
         self.__c_connect_listener = c.OBX_sync_listener_connect(lambda arg: connection_listener.on_connected())
         self.__c_disconnect_listener = c.OBX_sync_listener_disconnect(lambda arg: connection_listener.on_disconnected())
         c.obx_sync_listener_connect(
@@ -295,6 +310,7 @@ def set_connection_listener(self, connection_listener: SyncConnectionListener):
         )
 
     def set_error_listener(self, error_listener: SyncErrorListener):
+        self.__check_sync_ptr_not_null()
         self.__c_error_listener = c.OBX_sync_listener_error(
             lambda arg, sync_error_code: error_listener.on_error(sync_error_code))
         c.obx_sync_listener_error(
@@ -304,18 +320,23 @@ def set_error_listener(self, error_listener: SyncErrorListener):
         )
 
     def wait_for_logged_in_state(self, timeout_millis: int):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_wait_for_logged_in_state(self.__c_sync_client_ptr, timeout_millis)
 
     def add_filter_variable(self, name: str, value: str):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_filter_variables_put(self.__c_sync_client_ptr, name.encode('utf-8'), value.encode('utf-8'))
 
     def remove_filter_variable(self, name: str):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_filter_variables_remove(self.__c_sync_client_ptr, name.encode('utf-8'))
 
     def remove_all_filter_variables(self):
+        self.__check_sync_ptr_not_null()
         c.obx_sync_filter_variables_remove_all(self.__c_sync_client_ptr)
 
     def get_outgoing_message_count(self, limit: int = 0) -> int:
+        self.__check_sync_ptr_not_null()
         outgoing_message_count = ctypes.c_uint64(0)
         c.obx_sync_outgoing_message_count(self.__c_sync_client_ptr, limit, ctypes.byref(outgoing_message_count))
         return outgoing_message_count.value

tests/test_sync.py

@@ -1,3 +1,4 @@
+from collections.abc import Callable
 from time import sleep
 
 import pytest
@@ -104,3 +105,32 @@ def test_client_closed_when_store_closed(test_store):
     assert not client.is_closed()
     test_store.close()
     assert 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()
+
+    assert 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: client.set_credentials(SyncCredentials.google_auth("token_google")))
+    assert_raises_value_error(message=match_error, fn=lambda: 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))