Does this help you?

import unittest
from unittest.mock import MagicMock, patch

class TestGatttoolInteraction(unittest.TestCase):
    """
    Test suite for the gatttool interaction functions.
    Mocks pexpect.spawn to avoid actual external process calls.
    """

    @patch('pexpect.spawn') # Patch pexpect.spawn globally for all tests in this class
    def test_connect_success(self, mock_spawn):
        """
        Tests that the connect function correctly spawns gatttool,
        sends the connect command, and expects success.
        """
        # Configure the mock pexpect.spawn object.
        # When mock_spawn() is called, it returns a mock object (mock_gatt).
        mock_gatt = MagicMock()
        mock_spawn.return_value = mock_gatt

        # Simulate gatttool's response to the connect command.
        # When mock_gatt.expect is called, we want it to succeed without error.
        # We don't need to specify return value for expect if it just needs to not raise.
        mock_gatt.expect.return_value = 0 # A common return for success in pexpect

        # Call the function under test
        connect()

        # Assertions to verify correct behavior:

        # 1. Verify pexpect.spawn was called with the correct command
        mock_spawn.assert_called_once_with("sudo gatttool -I")

        # 2. Verify the correct connect command was sent
        mock_gatt.sendline.assert_any_call("connect " + MAC)

        # 3. Verify 'Connection successful' was expected
        mock_gatt.expect.assert_called_once_with("Connection successful")

        # 4. Verify the global 'gatt' variable was set to the mock object
        self.assertIs(gatt, mock_gatt)


    @patch('pexpect.spawn')
    def test_connect_failure(self, mock_spawn):
        """
        Tests that connect raises an exception if 'Connection successful'
        is not found, simulating a connection failure.
        """
        mock_gatt = MagicMock()
        mock_spawn.return_value = mock_gatt

        # Configure expect to raise an exception, simulating failure to find expected text
        mock_gatt.expect.side_effect = pexpect.exceptions.TIMEOUT('Timeout waiting for "Connection successful"')

        # Assert that the function raises the expected pexpect exception
        with self.assertRaises(pexpect.exceptions.TIMEOUT):
            connect()

        mock_spawn.assert_called_once_with("sudo gatttool -I")
        mock_gatt.sendline.assert_called_once_with("connect " + MAC)
        mock_gatt.expect.assert_called_once_with("Connection successful")


    @patch('pexpect.spawn') # Patch pexpect.spawn for this test
    def test_send_success(self, mock_spawn):
        """
        Tests that the send function correctly calls connect(),
        sends the char-write-req command, and expects success.
        """
        mock_gatt_instance = MagicMock()
        # Ensure that each call to pexpect.spawn() (e.g., from connect())
        # returns the same mock object in this test context.
        mock_spawn.return_value = mock_gatt_instance

        # Simulate successful responses for both connect() and send() operations
        # expect() should not raise an error
        mock_gatt_instance.expect.return_value = 0

        test_value = "ab"
        send(test_value)

        # Assertions:

        # 1. Verify pexpect.spawn was called twice (once by connect() inside send(), then again by connect() in the second call)
        # However, because send() calls connect() which *re-spawns* and overwrites 'gatt',
        # we only care about the state after the final connect().
        # The important thing is that gatt.sendline and gatt.expect are called correctly on the *final* gatt object.
        # Since connect() is called, pexpect.spawn will be called once.
        mock_spawn.assert_called_once_with("sudo gatttool -I")

        # 2. Verify the connect command was sent by connect()
        mock_gatt_instance.sendline.assert_any_call("connect " + MAC)

        # 3. Verify 'Connection successful' was expected by connect()
        mock_gatt_instance.expect.assert_any_call("Connection successful")

        # 4. Verify the characteristic write command was sent
        expected_write_command = f"char-write-req 0x000c {test_value}0"
        mock_gatt_instance.sendline.assert_any_call(expected_write_command)

        # 5. Verify 'Characteristic value was written successfully' was expected
        mock_gatt_instance.expect.assert_any_call("Characteristic value was written successfully")

        # Ensure gatt.sendline and gatt.expect were called for both operations
        # We use call_count to ensure both connect and send operations occurred on the mock
        self.assertEqual(mock_gatt_instance.sendline.call_count, 2)
        self.assertEqual(mock_gatt_instance.expect.call_count, 2)

    @patch('pexpect.spawn')
    def test_send_write_failure(self, mock_spawn):
        """
        Tests that send raises an exception if 'Characteristic value was written successfully'
        is not found, simulating a write failure.
        """
        mock_gatt_instance = MagicMock()
        mock_spawn.return_value = mock_gatt_instance

        # Set up expect to succeed for the 'connect' call
        mock_gatt_instance.expect.side_effect = [
            0, # Success for "Connection successful"
            pexpect.exceptions.TIMEOUT('Timeout waiting for "Characteristic value was written successfully"') # Failure for the write
        ]

        test_value = "1a"
        with self.assertRaises(pexpect.exceptions.TIMEOUT):
            send(test_value)

        mock_spawn.assert_called_once_with("sudo gatttool -I")
        mock_gatt_instance.sendline.assert_any_call("connect " + MAC)
        mock_gatt_instance.expect.assert_any_call("Connection successful")
        mock_gatt_instance.sendline.assert_any_call(f"char-write-req 0x000c {test_value}0")
        mock_gatt_instance.expect.assert_any_call("Characteristic value was written successfully")
        self.assertEqual(mock_gatt_instance.sendline.call_count, 2)
        self.assertEqual(mock_gatt_instance.expect.call_count, 2)


if __name__ == '__main__':
    unittest.main(argv=['first-arg-is-ignored'], exit=False) # exit=False prevents sys.exit()