columba/python/test_wrapper_initialization.py

"""
Test suite for ReticulumWrapper initialization methods

Tests initialization, configuration, bridge setters, callbacks, and cleanup.
"""

import sys
import os
import unittest
import json
import socket
import tempfile
import shutil
from unittest.mock import Mock, MagicMock, patch, mock_open, call

# Add parent directory to path to import reticulum_wrapper
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

# Mock RNS and LXMF before importing reticulum_wrapper
sys.modules['RNS'] = MagicMock()
sys.modules['RNS.vendor'] = MagicMock()
sys.modules['RNS.vendor.platformutils'] = MagicMock()
sys.modules['LXMF'] = MagicMock()

# Now import after mocking
import reticulum_wrapper


class TestInit(unittest.TestCase):
    """Test __init__ method - state initialization and announce handler setup"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_init_sets_storage_path(self):
        """Test that __init__ correctly stores the storage path"""
        wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)
        self.assertEqual(wrapper.storage_path, self.temp_dir)

    def test_init_state_initialization(self):
        """Test that __init__ initializes all required state variables"""
        wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

        # Core state
        self.assertIsNone(wrapper.reticulum)
        self.assertIsNone(wrapper.router)
        self.assertFalse(wrapper.initialized)

        # Collections
        self.assertEqual(wrapper.message_callbacks, [])
        self.assertEqual(wrapper.announce_callbacks, [])
        self.assertEqual(wrapper.link_callbacks, [])
        self.assertEqual(wrapper.destinations, {})
        self.assertEqual(wrapper.failed_interfaces, [])
        self.assertEqual(wrapper.pending_announces, [])
        self.assertEqual(wrapper.seen_message_hashes, set())
        self.assertEqual(wrapper.seen_announce_hashes, set())
        self.assertEqual(wrapper.identities, {})

        # Thread tracking
        self.assertIsNone(wrapper.rns_thread)

        # Bridge references (should be None until set)
        self.assertIsNone(wrapper.kotlin_ble_bridge)
        self.assertIsNone(wrapper.kotlin_rnode_bridge)
        self.assertIsNone(wrapper.kotlin_reticulum_bridge)
        self.assertIsNone(wrapper.kotlin_delivery_status_callback)
        self.assertIsNone(wrapper.kotlin_message_received_callback)

        # Shared instance state
        self.assertFalse(wrapper.is_shared_instance)

    def test_init_creates_announce_handlers(self):
        """Test that __init__ creates announce handlers for all required aspects"""
        wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

        # Verify all expected aspects have handlers
        expected_aspects = ["lxmf.delivery", "lxmf.propagation", "call.audio", "nomadnetwork.node"]

        for aspect in expected_aspects:
            self.assertIn(aspect, wrapper._announce_handlers)
            handler = wrapper._announce_handlers[aspect]
            self.assertIsInstance(handler, reticulum_wrapper.AnnounceHandler)
            self.assertEqual(handler.aspect_filter, aspect)

    def test_init_sets_global_wrapper_instance(self):
        """Test that __init__ sets the global wrapper instance"""
        wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)
        self.assertEqual(reticulum_wrapper._global_wrapper_instance, wrapper)

    def test_init_does_not_initialize_reticulum(self):
        """Test that __init__ does not automatically initialize Reticulum"""
        wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)
        self.assertFalse(wrapper.initialized)
        self.assertIsNone(wrapper.reticulum)


class TestBridgeSetters(unittest.TestCase):
    """Test set_ble_bridge, set_rnode_bridge, set_reticulum_bridge methods"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_set_ble_bridge(self):
        """Test that set_ble_bridge stores the BLE bridge instance"""
        mock_bridge = Mock()
        mock_bridge.name = "TestBLEBridge"

        self.wrapper.set_ble_bridge(mock_bridge)

        self.assertEqual(self.wrapper.kotlin_ble_bridge, mock_bridge)

    def test_set_ble_bridge_overwrites_previous(self):
        """Test that set_ble_bridge can overwrite a previous bridge"""
        first_bridge = Mock()
        second_bridge = Mock()

        self.wrapper.set_ble_bridge(first_bridge)
        self.assertEqual(self.wrapper.kotlin_ble_bridge, first_bridge)

        self.wrapper.set_ble_bridge(second_bridge)
        self.assertEqual(self.wrapper.kotlin_ble_bridge, second_bridge)

    def test_set_rnode_bridge(self):
        """Test that set_rnode_bridge stores the RNode bridge instance"""
        mock_bridge = Mock()
        mock_bridge.name = "TestRNodeBridge"

        self.wrapper.set_rnode_bridge(mock_bridge)

        self.assertEqual(self.wrapper.kotlin_rnode_bridge, mock_bridge)

    def test_set_rnode_bridge_overwrites_previous(self):
        """Test that set_rnode_bridge can overwrite a previous bridge"""
        first_bridge = Mock()
        second_bridge = Mock()

        self.wrapper.set_rnode_bridge(first_bridge)
        self.assertEqual(self.wrapper.kotlin_rnode_bridge, first_bridge)

        self.wrapper.set_rnode_bridge(second_bridge)
        self.assertEqual(self.wrapper.kotlin_rnode_bridge, second_bridge)

    def test_set_reticulum_bridge(self):
        """Test that set_reticulum_bridge stores the Reticulum bridge instance"""
        mock_bridge = Mock()
        mock_bridge.name = "TestReticulumBridge"

        self.wrapper.set_reticulum_bridge(mock_bridge)

        self.assertEqual(self.wrapper.kotlin_reticulum_bridge, mock_bridge)

    def test_set_reticulum_bridge_overwrites_previous(self):
        """Test that set_reticulum_bridge can overwrite a previous bridge"""
        first_bridge = Mock()
        second_bridge = Mock()

        self.wrapper.set_reticulum_bridge(first_bridge)
        self.assertEqual(self.wrapper.kotlin_reticulum_bridge, first_bridge)

        self.wrapper.set_reticulum_bridge(second_bridge)
        self.assertEqual(self.wrapper.kotlin_reticulum_bridge, second_bridge)


class TestCallbackSetters(unittest.TestCase):
    """Test set_delivery_status_callback and set_message_received_callback methods"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_set_delivery_status_callback(self):
        """Test that set_delivery_status_callback stores the callback"""
        mock_callback = Mock()

        self.wrapper.set_delivery_status_callback(mock_callback)

        self.assertEqual(self.wrapper.kotlin_delivery_status_callback, mock_callback)

    def test_set_delivery_status_callback_overwrites_previous(self):
        """Test that set_delivery_status_callback can overwrite a previous callback"""
        first_callback = Mock()
        second_callback = Mock()

        self.wrapper.set_delivery_status_callback(first_callback)
        self.assertEqual(self.wrapper.kotlin_delivery_status_callback, first_callback)

        self.wrapper.set_delivery_status_callback(second_callback)
        self.assertEqual(self.wrapper.kotlin_delivery_status_callback, second_callback)

    def test_set_message_received_callback(self):
        """Test that set_message_received_callback stores the callback"""
        mock_callback = Mock()

        self.wrapper.set_message_received_callback(mock_callback)

        self.assertEqual(self.wrapper.kotlin_message_received_callback, mock_callback)

    def test_set_message_received_callback_overwrites_previous(self):
        """Test that set_message_received_callback can overwrite a previous callback"""
        first_callback = Mock()
        second_callback = Mock()

        self.wrapper.set_message_received_callback(first_callback)
        self.assertEqual(self.wrapper.kotlin_message_received_callback, first_callback)

        self.wrapper.set_message_received_callback(second_callback)
        self.assertEqual(self.wrapper.kotlin_message_received_callback, second_callback)


class TestCheckSharedInstanceAvailable(unittest.TestCase):
    """Test check_shared_instance_available method"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    @patch('socket.socket')
    def test_shared_instance_available(self, mock_socket_class):
        """Test detecting an available shared instance"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket

        # Simulate successful connection (connect_ex returns 0 on success)
        mock_socket.connect_ex.return_value = 0

        result = self.wrapper.check_shared_instance_available()

        self.assertTrue(result)
        mock_socket.connect_ex.assert_called_once_with(("127.0.0.1", 37428))
        mock_socket.close.assert_called_once()

    @patch('socket.socket')
    def test_shared_instance_not_available_connection_refused(self, mock_socket_class):
        """Test when no shared instance is available (connection refused)"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket

        # Simulate connection refused (connect_ex returns non-zero on failure)
        mock_socket.connect_ex.return_value = 111  # ECONNREFUSED

        result = self.wrapper.check_shared_instance_available()

        self.assertFalse(result)
        mock_socket.close.assert_called_once()

    @patch('socket.socket')
    def test_shared_instance_timeout(self, mock_socket_class):
        """Test when connection times out"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket

        # Simulate timeout (connect_ex can raise timeout)
        mock_socket.connect_ex.side_effect = socket.timeout()

        result = self.wrapper.check_shared_instance_available()

        self.assertFalse(result)

    @patch('socket.socket')
    def test_shared_instance_custom_host_port(self, mock_socket_class):
        """Test checking shared instance with custom host and port"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket
        mock_socket.connect_ex.return_value = 0

        result = self.wrapper.check_shared_instance_available(host="192.168.1.100", port=9999)

        self.assertTrue(result)
        mock_socket.connect_ex.assert_called_once_with(("192.168.1.100", 9999))

    @patch('socket.socket')
    def test_shared_instance_custom_timeout(self, mock_socket_class):
        """Test checking shared instance with custom timeout"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket
        mock_socket.connect_ex.return_value = 0

        result = self.wrapper.check_shared_instance_available(timeout=5.0)

        self.assertTrue(result)
        mock_socket.settimeout.assert_called_once_with(5.0)

    @patch('socket.socket')
    def test_shared_instance_generic_exception(self, mock_socket_class):
        """Test handling of unexpected exceptions"""
        mock_socket = MagicMock()
        mock_socket_class.return_value = mock_socket

        # Simulate unexpected exception
        mock_socket.connect_ex.side_effect = Exception("Unexpected error")

        result = self.wrapper.check_shared_instance_available()

        self.assertFalse(result)


class TestCreateConfigFile(unittest.TestCase):
    """Test _create_config_file method"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_create_config_file_standalone_mode_empty_interfaces(self):
        """Test creating config file in standalone mode with no interfaces"""
        interfaces = []

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        # Verify config file was created
        config_path = os.path.join(self.temp_dir, "config")
        self.assertTrue(os.path.exists(config_path))

        # Verify content
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("enable_transport = yes", content)
        self.assertIn("share_instance = no", content)
        self.assertIn("[interfaces]", content)

    def test_create_config_file_standalone_mode_auto_interface(self):
        """Test creating config file with AutoInterface"""
        interfaces = [{
            "type": "AutoInterface",
            "name": "AutoInterface WiFi",
            "group_id": "test_group",
            "discovery_scope": "link",
            "mode": "full"
        }]

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("[[AutoInterface WiFi]]", content)
        self.assertIn("type = AutoInterface", content)
        self.assertIn("enabled = yes", content)
        self.assertIn("group_id = test_group", content)

    def test_create_config_file_standalone_mode_tcp_client(self):
        """Test creating config file with TCPClientInterface"""
        interfaces = [{
            "type": "TCPClient",
            "name": "TCP Client",
            "target_host": "192.168.1.100",
            "target_port": 4242,
            "kiss_framing": True,
            "mode": "full"
        }]

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("[[TCP Client]]", content)
        self.assertIn("type = TCPClientInterface", content)
        self.assertIn("target_host = 192.168.1.100", content)
        self.assertIn("target_port = 4242", content)
        self.assertIn("kiss_framing = True", content)

    def test_create_config_file_standalone_mode_tcp_server(self):
        """Test creating config file with TCPServerInterface"""
        interfaces = [{
            "type": "TCPServer",
            "name": "TCP Server",
            "listen_ip": "0.0.0.0",
            "listen_port": 4242,
            "mode": "gateway"
        }]

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("[[TCP Server]]", content)
        self.assertIn("type = TCPServerInterface", content)
        self.assertIn("listen_ip = 0.0.0.0", content)
        self.assertIn("listen_port = 4242", content)
        self.assertIn("mode = gateway", content)

    def test_create_config_file_standalone_mode_android_ble(self):
        """Test creating config file with AndroidBLE interface"""
        interfaces = [{
            "type": "AndroidBLE",
            "name": "BLE Interface",
            "device_name": "Columba-Test",
            "max_connections": 5,
            "mode": "full"
        }]

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("[[BLE Interface]]", content)
        self.assertIn("type = AndroidBLE", content)
        self.assertIn("device_name = Columba-Test", content)
        self.assertIn("max_connections = 5", content)

    def test_create_config_file_standalone_mode_rnode(self):
        """Test creating config file with RNode interface (stored separately)"""
        interfaces = [{
            "type": "RNode",
            "name": "RNode LoRa",
            "target_device_name": "RNode ABC",
            "connection_mode": "ble",
            "frequency": 868000000,
            "bandwidth": 125000,
            "tx_power": 7,
            "spreading_factor": 8,
            "coding_rate": 5,
            "mode": "full"
        }]

        # Verify _pending_rnode_config is None before test
        self.assertIsNone(self.wrapper._pending_rnode_config)

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertTrue(result)

        # RNode config should have the section header but no body in the config file
        # (The header is added before the type check, then continue skips the body)
        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("[[RNode LoRa]]", content)
        # But should NOT have actual RNode-specific parameters
        self.assertNotIn("type = RNode", content)
        self.assertNotIn("frequency", content)

        # Config should be stored in _pending_rnode_config instead
        self.assertIsNotNone(self.wrapper._pending_rnode_config)
        self.assertEqual(self.wrapper._pending_rnode_config["name"], "RNode LoRa")
        self.assertEqual(self.wrapper._pending_rnode_config["frequency"], 868000000)

    def test_create_config_file_shared_instance_mode(self):
        """Test creating config file in shared instance mode"""
        interfaces = []  # Interfaces ignored in shared mode

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=True)

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn("SHARED INSTANCE MODE", content)
        self.assertIn("enable_transport = yes", content)
        self.assertIn("share_instance = yes", content)
        self.assertIn("shared_instance_type = tcp", content)
        self.assertIn("shared_instance_port = 37428", content)

    def test_create_config_file_shared_instance_with_rpc_key(self):
        """Test creating config file in shared instance mode with RPC key"""
        interfaces = []
        rpc_key = "abc123def456"

        result = self.wrapper._create_config_file(
            interfaces,
            use_shared_instance=True,
            rpc_key=rpc_key
        )

        self.assertTrue(result)

        config_path = os.path.join(self.temp_dir, "config")
        with open(config_path, 'r') as f:
            content = f.read()

        self.assertIn(f"rpc_key = {rpc_key}", content)

    def test_create_config_file_creates_directory(self):
        """Test that _create_config_file creates storage directory if missing"""
        # Use a non-existent subdirectory
        new_dir = os.path.join(self.temp_dir, "new_storage")
        wrapper = reticulum_wrapper.ReticulumWrapper(new_dir)

        self.assertFalse(os.path.exists(new_dir))

        result = wrapper._create_config_file([], use_shared_instance=False)

        self.assertTrue(result)
        self.assertTrue(os.path.exists(new_dir))

    def test_create_config_file_unknown_interface_type(self):
        """Test handling of unknown interface type"""
        interfaces = [{
            "type": "UnknownInterface",
            "name": "Unknown"
        }]

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        # Should still succeed (unknown interface just skipped)
        self.assertTrue(result)

    @patch('builtins.open', side_effect=IOError("Permission denied"))
    def test_create_config_file_write_error(self, mock_file):
        """Test handling of file write errors"""
        interfaces = []

        result = self.wrapper._create_config_file(interfaces, use_shared_instance=False)

        self.assertFalse(result)


class TestInitialize(unittest.TestCase):
    """Test initialize method"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

        # Mock RETICULUM_AVAILABLE to True
        reticulum_wrapper.RETICULUM_AVAILABLE = True

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_initialize_already_initialized(self):
        """Test that initialize fails if already initialized"""
        self.wrapper.initialized = True

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG"
        }

        result = self.wrapper.initialize(json.dumps(config))

        self.assertFalse(result["success"])
        self.assertIn("Already initialized", result["error"])

    # NOTE: test_initialize_reticulum_not_available is difficult to test properly
    # because RNS/LXMF are mocked at the module level before reticulum_wrapper
    # is imported. The RETICULUM_AVAILABLE flag is tested indirectly through
    # other initialization tests and real-world usage.

    def test_initialize_invalid_json(self):
        """Test that initialize handles invalid JSON"""
        invalid_json = "not valid json {{"

        # The implementation catches the exception and returns error dict
        result = self.wrapper.initialize(invalid_json)

        self.assertFalse(result["success"])
        self.assertIn("error", result)
        # Error message should mention JSON or parsing
        self.assertTrue("Expecting value" in result["error"] or "JSON" in result["error"])

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    def test_initialize_config_file_creation_fails(self, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize fails when config file creation fails"""
        mock_create_config.return_value = False

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG"
        }

        result = self.wrapper.initialize(json.dumps(config))

        self.assertFalse(result["success"])
        self.assertIn("Failed to create config file", result["error"])

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    @patch.object(reticulum_wrapper.ReticulumWrapper, 'check_shared_instance_available')
    def test_initialize_uses_shared_instance_when_available(self, mock_check, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize uses shared instance when available and preferred"""
        mock_check.return_value = True
        mock_create_config.return_value = True

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG",
            "prefer_own_instance": False
        }

        # Don't actually complete initialization, just check shared instance logic
        self.wrapper.initialize(json.dumps(config))

        # Should have checked for shared instance
        mock_check.assert_called_once()
        # Should have created config with shared instance mode
        mock_create_config.assert_called_once()
        call_args = mock_create_config.call_args
        self.assertTrue(call_args[1]['use_shared_instance'])

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    @patch.object(reticulum_wrapper.ReticulumWrapper, 'check_shared_instance_available')
    def test_initialize_prefers_own_instance(self, mock_check, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize skips shared instance check when user prefers own"""
        mock_create_config.return_value = True

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG",
            "prefer_own_instance": True
        }

        self.wrapper.initialize(json.dumps(config))

        # Should NOT have checked for shared instance
        mock_check.assert_not_called()
        # Should have created config without shared instance mode
        mock_create_config.assert_called_once()
        call_args = mock_create_config.call_args
        self.assertFalse(call_args[1]['use_shared_instance'])

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    def test_initialize_sets_log_level(self, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize sets the RNS log level"""
        mock_create_config.return_value = True
        mock_rns.LOG_DEBUG = 4

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG"
        }

        # Don't complete full initialization
        try:
            self.wrapper.initialize(json.dumps(config))
        except:
            pass

        # Verify log level was set
        self.assertEqual(mock_rns.loglevel, 4)

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    def test_initialize_with_identity_file_path(self, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize accepts identity_file_path parameter"""
        mock_create_config.return_value = True

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG"
        }

        identity_path = os.path.join(self.temp_dir, "custom_identity")

        # Don't complete full initialization
        try:
            self.wrapper.initialize(json.dumps(config), identity_file_path=identity_path)
        except:
            pass

        # Just verify it doesn't crash with the parameter

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    def test_initialize_with_identity_file_path_in_config(self, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize can extract identity_file_path from config JSON"""
        mock_create_config.return_value = True

        identity_path = os.path.join(self.temp_dir, "custom_identity")

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG",
            "identity_file_path": identity_path
        }

        # Don't complete full initialization
        try:
            self.wrapper.initialize(json.dumps(config))
        except:
            pass

        # Just verify it doesn't crash

    @patch('reticulum_wrapper.RNS')
    @patch('reticulum_wrapper.LXMF')
    @patch.object(reticulum_wrapper.ReticulumWrapper, '_create_config_file')
    def test_initialize_with_rpc_key(self, mock_create_config, mock_lxmf, mock_rns):
        """Test that initialize passes RPC key to config file creation"""
        mock_create_config.return_value = True

        rpc_key = "test_rpc_key_123"

        config = {
            "storagePath": self.temp_dir,
            "enabledInterfaces": [],
            "logLevel": "DEBUG",
            "rpc_key": rpc_key
        }

        try:
            self.wrapper.initialize(json.dumps(config))
        except:
            pass

        # Verify RPC key was passed to config creation
        mock_create_config.assert_called_once()
        call_args = mock_create_config.call_args
        self.assertEqual(call_args[1]['rpc_key'], rpc_key)


class TestShutdown(unittest.TestCase):
    """Test shutdown method"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_shutdown_not_initialized(self):
        """Test that shutdown succeeds when not initialized"""
        self.wrapper.initialized = False
        # Add announce_app_data attribute to prevent AttributeError
        self.wrapper.announce_app_data = {}

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])

    @patch('reticulum_wrapper.RNS')
    def test_shutdown_deregisters_announce_handlers(self, mock_rns):
        """Test that shutdown deregisters announce handlers"""
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        # Verify deregister was called for each handler
        expected_calls = len(self.wrapper._announce_handlers)
        self.assertEqual(mock_rns.Transport.deregister_announce_handler.call_count, expected_calls)

    def test_shutdown_clears_router(self):
        """Test that shutdown clears LXMF router"""
        self.wrapper.initialized = True
        self.wrapper.router = Mock()
        self.wrapper.announce_app_data = {}

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        self.assertIsNone(self.wrapper.router)

    @patch('reticulum_wrapper.RNS')
    def test_shutdown_detaches_interfaces(self, mock_rns):
        """Test that shutdown detaches RNS interfaces"""
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        # Create mock interfaces
        mock_iface1 = Mock()
        mock_iface2 = Mock()
        mock_rns.Transport.interfaces = [mock_iface1, mock_iface2]

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        mock_iface1.detach.assert_called_once()
        mock_iface2.detach.assert_called_once()

    @patch('reticulum_wrapper.RNS')
    def test_shutdown_clears_rns_singleton(self, mock_rns):
        """Test that shutdown clears RNS singleton instance"""
        reticulum_wrapper.RETICULUM_AVAILABLE = True
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        # Set up mock singleton
        mock_rns.Reticulum._Reticulum__instance = Mock()

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        self.assertIsNone(mock_rns.Reticulum._Reticulum__instance)

    @patch('reticulum_wrapper.RNS')
    def test_shutdown_clears_transport_state(self, mock_rns):
        """Test that shutdown clears RNS Transport global state"""
        reticulum_wrapper.RETICULUM_AVAILABLE = True
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        # Set up mock Transport state with MagicMock lists that have clear() method
        mock_rns.Transport.owner = Mock()
        mock_interfaces = MagicMock(spec=list)
        mock_interfaces.__iter__ = Mock(return_value=iter([Mock(), Mock()]))
        mock_rns.Transport.interfaces = mock_interfaces

        mock_local_client_interfaces = MagicMock(spec=list)
        mock_rns.Transport.local_client_interfaces = mock_local_client_interfaces

        mock_destinations = MagicMock(spec=list)
        mock_rns.Transport.destinations = mock_destinations

        mock_destination_table = MagicMock(spec=dict)
        mock_rns.Transport.destination_table = mock_destination_table

        mock_announce_table = MagicMock(spec=dict)
        mock_rns.Transport.announce_table = mock_announce_table

        mock_held_announces = MagicMock(spec=list)
        mock_rns.Transport.held_announces = mock_held_announces

        mock_announce_handlers = MagicMock(spec=list)
        mock_rns.Transport.announce_handlers = mock_announce_handlers

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        self.assertIsNone(mock_rns.Transport.owner)
        mock_interfaces.clear.assert_called()
        mock_local_client_interfaces.clear.assert_called()
        mock_destinations.clear.assert_called()
        mock_destination_table.clear.assert_called()
        mock_announce_table.clear.assert_called()

    def test_shutdown_clears_wrapper_state(self):
        """Test that shutdown clears wrapper internal state"""
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        # Populate state
        self.wrapper.announce_callbacks.append(Mock())
        self.wrapper.message_callbacks.append(Mock())
        self.wrapper.link_callbacks.append(Mock())
        self.wrapper.destinations["test"] = Mock()
        self.wrapper.identities["test"] = Mock()
        self.wrapper.pending_announces.append("announce")
        self.wrapper.seen_announce_hashes.add("hash")
        self.wrapper.seen_message_hashes.add("hash")

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        self.assertFalse(self.wrapper.initialized)
        self.assertIsNone(self.wrapper.reticulum)
        self.assertEqual(len(self.wrapper.announce_callbacks), 0)
        self.assertEqual(len(self.wrapper.message_callbacks), 0)
        self.assertEqual(len(self.wrapper.link_callbacks), 0)
        self.assertEqual(len(self.wrapper.destinations), 0)
        self.assertEqual(len(self.wrapper.identities), 0)
        self.assertEqual(len(self.wrapper.pending_announces), 0)
        self.assertEqual(len(self.wrapper.seen_announce_hashes), 0)
        self.assertEqual(len(self.wrapper.seen_message_hashes), 0)

    @patch('reticulum_wrapper.RNS')
    @patch('gc.collect')
    def test_shutdown_runs_garbage_collection(self, mock_gc_collect, mock_rns):
        """Test that shutdown runs garbage collection"""
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        result = self.wrapper.shutdown()

        self.assertTrue(result["success"])
        mock_gc_collect.assert_called_once()

    @patch('reticulum_wrapper.RNS')
    def test_shutdown_handles_exception_gracefully(self, mock_rns):
        """Test that shutdown handles exceptions and returns error"""
        self.wrapper.initialized = True
        self.wrapper.reticulum = Mock()
        self.wrapper.announce_app_data = {}

        # Make deregister raise an exception
        mock_rns.Transport.deregister_announce_handler.side_effect = Exception("Test error")

        result = self.wrapper.shutdown()

        # Should still succeed (exceptions are caught)
        self.assertTrue(result["success"])


class TestGetStatus(unittest.TestCase):
    """Test get_status method"""

    def setUp(self):
        """Set up test fixtures"""
        self.temp_dir = tempfile.mkdtemp()
        self.wrapper = reticulum_wrapper.ReticulumWrapper(self.temp_dir)

    def tearDown(self):
        """Clean up test fixtures"""
        if os.path.exists(self.temp_dir):
            shutil.rmtree(self.temp_dir)

    def test_get_status_not_initialized(self):
        """Test get_status returns SHUTDOWN when not initialized"""
        self.wrapper.reticulum = None

        status = self.wrapper.get_status()

        self.assertEqual(status, "SHUTDOWN")

    def test_get_status_reticulum_not_available(self):
        """Test get_status returns SHUTDOWN when Reticulum not available"""
        original_available = reticulum_wrapper.RETICULUM_AVAILABLE
        reticulum_wrapper.RETICULUM_AVAILABLE = False

        status = self.wrapper.get_status()

        self.assertEqual(status, "SHUTDOWN")

        # Restore
        reticulum_wrapper.RETICULUM_AVAILABLE = original_available

    def test_get_status_ready(self):
        """Test get_status returns READY when initialized"""
        reticulum_wrapper.RETICULUM_AVAILABLE = True
        self.wrapper.reticulum = Mock()

        status = self.wrapper.get_status()

        self.assertEqual(status, "READY")


class TestAnnounceHandlerClass(unittest.TestCase):
    """Test AnnounceHandler wrapper class"""

    def test_announce_handler_has_aspect_filter(self):
        """Test that AnnounceHandler stores aspect_filter"""
        callback = Mock()
        handler = reticulum_wrapper.AnnounceHandler("test.aspect", callback)

        self.assertEqual(handler.aspect_filter, "test.aspect")

    def test_announce_handler_has_callback(self):
        """Test that AnnounceHandler stores callback"""
        callback = Mock()
        handler = reticulum_wrapper.AnnounceHandler("test.aspect", callback)

        self.assertEqual(handler.callback, callback)

    def test_announce_handler_received_announce_calls_callback(self):
        """Test that received_announce invokes the callback"""
        callback = Mock()
        handler = reticulum_wrapper.AnnounceHandler("test.aspect", callback)

        dest_hash = b'test_dest'
        identity = Mock()
        app_data = b'test_data'
        announce_hash = b'test_hash'

        handler.received_announce(dest_hash, identity, app_data, announce_hash)

        callback.assert_called_once_with(
            "test.aspect",
            dest_hash,
            identity,
            app_data,
            announce_hash
        )

    def test_announce_handler_none_aspect_filter(self):
        """Test that AnnounceHandler accepts None as aspect_filter (all announces)"""
        callback = Mock()
        handler = reticulum_wrapper.AnnounceHandler(None, callback)

        self.assertIsNone(handler.aspect_filter)


if __name__ == '__main__':
    # Run tests with verbose output
    unittest.main(verbosity=2)