status-im
diff --git a/‎tests-functional/clients/services/settings.py‎
Lines changed: 128 additions & 4 deletions b/‎tests-functional/clients/services/settings.py‎
Lines changed: 128 additions & 4 deletions
diff --git a/‎tests-functional/clients/status_backend.py‎
Lines changed: 7 additions & 1 deletion b/‎tests-functional/clients/status_backend.py‎
Lines changed: 7 additions & 1 deletion
diff --git a/‎tests-functional/tests/conftest.py‎
Lines changed: 3 additions & 3 deletions b/‎tests-functional/tests/conftest.py‎
Lines changed: 3 additions & 3 deletions
diff --git a/‎tests-functional/tests/settings/test_backup.py‎
Lines changed: 48 additions & 0 deletions b/‎tests-functional/tests/settings/test_backup.py‎
Lines changed: 48 additions & 0 deletions
diff --git a/‎tests-functional/tests/settings/test_general.py‎
Lines changed: 73 additions & 0 deletions b/‎tests-functional/tests/settings/test_general.py‎
Lines changed: 73 additions & 0 deletions
diff --git a/‎tests-functional/tests/settings/test_node_config.py‎
Lines changed: 35 additions & 0 deletions b/‎tests-functional/tests/settings/test_node_config.py‎
Lines changed: 35 additions & 0 deletions
@@ -6,11 +6,135 @@ class SettingsService(Service):
     def __init__(self, client: RpcClient):
         super().__init__(client, "settings")
 
+    # Base settings
     def get_settings(self):
-        response = self.rpc_request("getSettings")
-        return response
+        return self.rpc_request("getSettings")
 
     def save_setting(self, key, value):
         params = [key, value]
-        response = self.rpc_request("saveSetting", params)
-        return response
+        return self.rpc_request("saveSetting", params)
+
+    def get_node_config(self):
+        return self.rpc_request("nodeConfig")
+
+    # Backup Settings
+    def backup_path(self):
+        return self.rpc_request("backupPath")
+
+    def messages_backup_enabled(self):
+        return self.rpc_request("messagesBackupEnabled")
+
+    # Notifications Settings
+    def notifications_get_allow_notifications(self):
+        return self.rpc_request("notificationsGetAllowNotifications")
+
+    def notifications_set_allow_notifications(self, value: bool):
+        params = [value]
+        return self.rpc_request("notificationsSetAllowNotifications", params)
+
+    def notifications_get_one_to_one_chats(self):
+        return self.rpc_request("notificationsGetOneToOneChats")
+
+    def notifications_set_one_to_one_chats(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetOneToOneChats", params)
+
+    def notifications_get_group_chats(self):
+        return self.rpc_request("notificationsGetGroupChats")
+
+    def notifications_set_group_chats(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetGroupChats", params)
+
+    def notifications_get_personal_mentions(self):
+        return self.rpc_request("notificationsGetPersonalMentions")
+
+    def notifications_set_personal_mentions(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetPersonalMentions", params)
+
+    def notifications_get_global_mentions(self):
+        return self.rpc_request("notificationsGetGlobalMentions")
+
+    def notifications_set_global_mentions(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetGlobalMentions", params)
+
+    def notifications_get_all_messages(self):
+        return self.rpc_request("notificationsGetAllMessages")
+
+    def notifications_set_all_messages(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetAllMessages", params)
+
+    def notifications_get_contact_requests(self):
+        return self.rpc_request("notificationsGetContactRequests")
+
+    def notifications_set_contact_requests(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetContactRequests", params)
+
+    def notifications_get_identity_verification_requests(self):
+        return self.rpc_request("notificationsGetIdentityVerificationRequests")
+
+    def notifications_set_identity_verification_requests(self, value: str):
+        params = [value]
+        return self.rpc_request("notificationsSetIdentityVerificationRequests", params)
+
+    def notifications_get_sound_enabled(self):
+        return self.rpc_request("notificationsGetSoundEnabled")
+
+    def notifications_set_sound_enabled(self, value: bool):
+        params = [value]
+        return self.rpc_request("notificationsSetSoundEnabled", params)
+
+    def notifications_get_volume(self):
+        return self.rpc_request("notificationsGetVolume")
+
+    def notifications_set_volume(self, value: int):
+        params = [value]
+        return self.rpc_request("notificationsSetVolume", params)
+
+    def notifications_get_message_preview(self):
+        return self.rpc_request("notificationsGetMessagePreview")
+
+    def notifications_set_message_preview(self, value: int):
+        params = [value]
+        return self.rpc_request("notificationsSetMessagePreview", params)
+
+    def notifications_get_ex_mute_all_messages(self, id: str):
+        params = [id]
+        return self.rpc_request("notificationsGetExMuteAllMessages", params)
+
+    def notifications_get_ex_personal_mentions(self, id: str):
+        params = [id]
+        return self.rpc_request("notificationsGetExPersonalMentions", params)
+
+    def notifications_get_ex_global_mentions(self, id: str):
+        params = [id]
+        return self.rpc_request("notificationsGetExGlobalMentions", params)
+
+    def notifications_get_ex_other_messages(self, id: str):
+        params = [id]
+        return self.rpc_request("notificationsGetExOtherMessages", params)
+
+    def notifications_set_exemptions(self, id: str, mute_all_messages: bool, personal_mentions: str, global_mentions: str, other_messages: str):
+        params = [id, mute_all_messages, personal_mentions, global_mentions, other_messages]
+        return self.rpc_request("notificationsSetExemptions", params)
+
+    def delete_exemptions(self, id: str):
+        params = [id]
+        return self.rpc_request("deleteExemptions", params)
+
+    def set_bio(self, bio: str):
+        params = [bio]
+        return self.rpc_request("setBio", params)
+
+    def mnemonic_was_shown(self):
+        return self.rpc_request("mnemonicWasShown")
+
+    def last_tokens_update(self):
+        return self.rpc_request("lastTokensUpdate")
+
+    def thirdparty_services_enabled(self):
+        return self.rpc_request("thirdpartyServicesEnabled")
@@ -32,6 +32,7 @@
 from utils import fake
 from utils import keys
 from utils.config import Config
+import copy
 
 NANOSECONDS_PER_SECOND = 1_000_000_000
 
@@ -80,7 +81,7 @@ def __init__(self, privileged=False, ipv6=USE_IPV6, **kwargs):
         self.events = Events()
         self.version = "unknown"
         self.network_id = 1
-
+        self._boot_api_config = None
         RpcClient.__init__(self)
         ApiClient.__init__(self, self.api_url)
         SignalClient.__init__(self, self.ws_url)
@@ -295,13 +296,15 @@ def create_account_and_login(self, password: str, **kwargs):
         self._set_display_name(**kwargs)
         method = "CreateAccountAndLogin"
         data = self._create_account_request(password=password, **kwargs)
+        self._boot_api_config = copy.deepcopy(data.get("apiConfig", {}))
         return self.api_request_json(method, data)
 
     def restore_account_and_login(self, user=user_1, **kwargs):
         self._set_display_name(**kwargs)
         method = "RestoreAccountAndLogin"
         data = self._create_account_request(password=user.password, **kwargs)
         data["mnemonic"] = user.passphrase
+        self._boot_api_config = copy.deepcopy(data.get("apiConfig", {}))
         return self.api_request_json(method, data)
 
     def login(self, key_uid, password: str, kdf_iterations=256000):
@@ -472,6 +475,9 @@ def image_server_tls_cert(self):
         response = self.api_request(method, {})
         return response.content.decode("utf-8")
 
+    def get_boot_api_config(self):
+        return self._boot_api_config
+
     def serialize_legacy_key(self, key):
         method = "SerializeLegacyKey"
         # Use client.post directly, because this method is old and has json-incompatible arguments
 
@@ -4,11 +4,11 @@
 import pytest
 from requests import ReadTimeout
 
-from clients.anvil import Anvil
-from clients.contract_deployers.multicall3 import Multicall3Deployer
-from clients.foundry import Foundry
 from clients.status_backend import StatusBackend
 from clients.statusgo_container import StatusGoContainer
+from clients.anvil import Anvil
+from clients.foundry import Foundry
+from clients.contract_deployers.multicall3 import Multicall3Deployer
 from resources.constants import USE_IPV6
 from utils import fake
 
 
@@ -0,0 +1,48 @@
+import pytest
+
+
+@pytest.mark.rpc
+class TestBackupSettings:
+
+    @pytest.fixture(autouse=True)
+    def setup_backends(self, backend_new_profile):
+        self.config = backend_new_profile("sender")
+
+    @pytest.mark.skip(reason="backend currently does not validate backup-path; it is stored verbatim")
+    def test_set_invalid_backup_path(self):
+        invalid_path = "/invalid/path/that/does@$<>not|exist"
+        result = self.config.settings_service.save_setting("backup-path", invalid_path)
+        backup_path = self.config.settings_service.backup_path()
+        assert backup_path != invalid_path, f"Backend incorrectly saved invalid path: {backup_path}"
+        assert result is None or result == "", f"Expected save_setting to fail or return None, got: {result}"
+
+    def test_set_valid_backup_path(self):
+        current_path = self.config.settings_service.backup_path()
+
+        # Verify it is a valid path (not empty and is a string)
+        assert current_path is not None, "Backup path should not be None"
+        assert isinstance(current_path, str), f"Expected string, got {type(current_path)}"
+        assert current_path != "", "Backup path should not be empty"
+
+        # Test setting the same path explicitly (round-trip test)
+        result = self.config.settings_service.save_setting("backup-path", current_path)
+        assert result is None
+        assert self.config.settings_service.backup_path() == current_path
+
+    def test_get_backup_path_type_and_value(self):
+        backup_path = self.config.settings_service.backup_path()
+        assert backup_path is not None, "Expected a non-null backup path"
+        assert isinstance(backup_path, str), f"Expected string, got {type(backup_path)}"
+        assert backup_path != "", "Expected backup path to be non-empty"
+
+    def test_messages_backup_enabled_type(self):
+        result = self.config.settings_service.messages_backup_enabled()
+        assert result is not None, "Expected a non-null result"
+        assert isinstance(result, bool), f"Expected bool, got {type(result)}"
+
+    def test_toggle_messages_backup_enabled(self):
+        value = True
+        self.config.settings_service.save_setting("messages-backup-enabled?", value)
+        result = self.config.settings_service.messages_backup_enabled()
+        assert isinstance(result, bool)
+        assert result is value
@@ -0,0 +1,73 @@
+import datetime
+import time
+
+import pytest
+
+
+@pytest.mark.rpc
+class TestGeneralSettings:
+
+    @pytest.fixture(autouse=True)
+    def setup_backends(self, backend_new_profile):
+        self.config = backend_new_profile("sender")
+
+    def test_thirdparty_services_enabled(self):
+        result = self.config.settings_service.thirdparty_services_enabled()
+        assert result is not None, "Expected a non-null result"
+        assert isinstance(result, bool), f"Expected bool, got {type(result)}"
+        assert result is True, "Expected True"
+
+    def test_last_tokens_update_type_check(self):
+        result = self.config.settings_service.last_tokens_update()
+        assert result is not None, "Expected non-null timestamp"
+        assert isinstance(result, str), f"Expected string, got {type(result)}"
+        assert result != "", "Expected non-empty string"
+
+    def test_last_tokens_update_returns_valid_iso_datetime(self):
+        result = self.config.settings_service.last_tokens_update()
+        try:
+            _ = datetime.datetime.fromisoformat(result.replace("Z", "+00:00"))
+        except Exception as e:
+            pytest.fail(f"Returned value is not a valid ISO datetime string: {result}. Error: {e}")
+
+    def test_last_tokens_update_advances_after_updating_token_preferences(self):
+        dummy_prefs = [{"key": "0x1234567890abcdef1234567890abcdef12345678", "position": 1, "visible": True}]
+        self.config.accounts_service.update_token_preferences(dummy_prefs)
+        t1_raw = self.config.settings_service.last_tokens_update()
+        t1 = datetime.datetime.fromisoformat(t1_raw.replace("Z", "+00:00"))
+        time.sleep(1.2)
+        current_prefs = self.config.accounts_service.get_token_preferences()
+        self.config.accounts_service.update_token_preferences(current_prefs)
+        t2_raw = self.config.settings_service.last_tokens_update()
+        t2 = datetime.datetime.fromisoformat(t2_raw.replace("Z", "+00:00"))
+        assert t2 >= t1, f"Expected last-tokens-update to advance or stay same; got T1={t1} T2={t2}"
+
+    def test_mnemonic_was_shown(self):
+        result = self.config.settings_service.mnemonic_was_shown()
+        assert result is None or result == "", f"Expected no return value, got: {result}"
+
+    def test_set_bio_valid_string(self):
+        valid_bio = "This is a new test bio"
+        result = self.config.settings_service.set_bio(valid_bio)
+        assert result is None or result == "", f"Expected None or empty string, got {result}"
+
+    def test_set_bio_invalid_type(self):
+        invalid_bio = 123
+        try:
+            result = self.config.settings_service.set_bio(invalid_bio)
+            pytest.fail(f"Expected an exception for invalid bio {invalid_bio}, got {result}")
+        except Exception:
+            assert True
+
+    def test_delete_exemptions_valid_id(self):
+        result = self.config.settings_service.delete_exemptions("12345")
+        assert result is None or result == "", f"Expected None or empty string, got {result}"
+
+    @pytest.mark.skip(reason="Pending on issue resolution https://github.com/status-im/status-go/issues/7102")
+    def test_delete_exemptions_invalid_id(self):
+        invalid_id = None
+        try:
+            result = self.config.settings_service.delete_exemptions(invalid_id)
+            pytest.fail(f"Expected exception for invalid id: {invalid_id}, but got {result}")
+        except Exception:
+            assert True
@@ -0,0 +1,35 @@
+import logging
+
+import pytest
+
+logger = logging.getLogger(__name__)
+
+
+@pytest.mark.rpc
+class TestNodeConfig:
+
+    @pytest.fixture(autouse=True)
+    def setup_backends(self, backend_new_profile):
+        self.config = backend_new_profile("sender")
+
+    def test_verify_node_config_stability(self):
+        cfg1 = self.config.settings_service.get_node_config()
+        cfg2 = self.config.settings_service.get_node_config()
+        assert cfg1 == cfg2, "NodeConfig should be stable across calls"
+
+    def test_check_node_config_params(self):
+        cfg = self.config.settings_service.get_node_config()
+        boot_api = self.config.get_boot_api_config()
+        assert cfg["WSEnabled"] == boot_api["wsEnabled"]
+        assert cfg["WSHost"] == boot_api["wsHost"]
+        assert cfg["WSPort"] == boot_api["wsPort"]
+        assert cfg["HTTPEnabled"] == boot_api["httpEnabled"]
+        assert cfg["HTTPPort"] == boot_api["httpPort"]
+
+    def test_verify_node_config_enforce(self, backend_new_profile):
+        forced_network_id = 4242
+        backend = backend_new_profile("forced_network", network_id=forced_network_id)
+        cfg = backend.settings_service.get_node_config()
+        network_id = cfg["NetworkId"]
+        assert network_id is not None, f"NetworkId key missing in node config: {cfg}"
+        assert int(network_id) == forced_network_id, f"Expected NetworkId={forced_network_id}, got {network_id}"