field_ios

In-the-field app for Radroots on iOS
git clone https://radroots.dev/git/field_ios.git
Log | Files | Refs | README | LICENSE

test_local_social_relay.py (4458B)


      1 """Real socket checks for idle versus incomplete fixture WebSocket frames."""
      2 
      3 import importlib.util
      4 import json
      5 import select
      6 import socket
      7 import threading
      8 import unittest
      9 from contextlib import contextmanager
     10 from pathlib import Path
     11 from unittest import mock
     12 
     13 SPEC = importlib.util.spec_from_file_location(
     14     "local_social_relay_fixture", Path(__file__).with_name("local-social-fixture.py")
     15 )
     16 assert SPEC is not None and SPEC.loader is not None
     17 fixture = importlib.util.module_from_spec(SPEC)
     18 SPEC.loader.exec_module(fixture)
     19 
     20 
     21 def masked_frame(opcode, payload):
     22     assert len(payload) < 126
     23     mask = b"test"
     24     body = bytes(byte ^ mask[index % 4] for index, byte in enumerate(payload))
     25     return bytes([0x80 | opcode, 0x80 | len(payload)]) + mask + body
     26 
     27 
     28 @contextmanager
     29 def relay_socket(wait):
     30     client, server = socket.socketpair()
     31     errors = []
     32     finished = threading.Event()
     33     state = mock.Mock()
     34     state.query.return_value = []
     35 
     36     class ScaledReadSocket:
     37         def settimeout(self, value):
     38             assert 0 < value <= 15
     39             server.settimeout(0.05)
     40 
     41         def recv(self, length):
     42             return server.recv(length)
     43 
     44         def sendall(self, value):
     45             server.sendall(value)
     46 
     47         def fileno(self):
     48             return server.fileno()
     49 
     50     handler = type("RelaySocketTestHandler", (fixture.RelayHandler,), {"state": state})
     51 
     52     def serve():
     53         try:
     54             handler(ScaledReadSocket(), ("127.0.0.1", 0), None)
     55         except (ConnectionError, OSError) as error:
     56             errors.append(type(error))
     57         finally:
     58             server.close()
     59             finished.set()
     60 
     61     with mock.patch.object(fixture, "select", mock.Mock(select=wait), create=True):
     62         thread = threading.Thread(target=serve)
     63         thread.start()
     64         client.settimeout(1)
     65         try:
     66             client.sendall(
     67                 b"GET / HTTP/1.1\r\nUpgrade: websocket\r\n"
     68                 b"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n\r\n"
     69             )
     70             response = client.recv(4096)
     71             assert response.startswith(b"HTTP/1.1 101")
     72             yield client, state, finished, errors
     73         finally:
     74             client.close()
     75             thread.join(1)
     76             assert not thread.is_alive(), "Fixture handler leaked after peer close"
     77 
     78 
     79 class LocalSocialRelaySocketTests(unittest.TestCase):
     80     def test_idle_connection_survives_timeout_then_answers_exact_subscription(self):
     81         idle = threading.Event()
     82         calls = []
     83 
     84         def wait(read, write, error, timeout):
     85             self.assertEqual(timeout, 15)
     86             calls.append(timeout)
     87             if len(calls) == 1:
     88                 result = select.select(read, write, error, 0.05)
     89                 self.assertFalse(result[0])
     90                 idle.set()
     91                 return result
     92             return select.select(read, write, error, 1)
     93 
     94         with relay_socket(wait) as (client, state, finished, errors):
     95             self.assertTrue(idle.wait(1), "Idle frame boundary was not reached")
     96             self.assertFalse(finished.is_set(), "Healthy idle connection was closed")
     97             state.query.assert_not_called()
     98             client.sendall(masked_frame(1, b'["REQ","idle-read",{"limit":1}]'))
     99             first, second = fixture.read_exact(client, 2)
    100             self.assertEqual(first, 0x81)
    101             self.assertLess(second, 126)
    102             payload = fixture.read_exact(client, second)
    103             self.assertEqual(json.loads(payload), ["EOSE", "idle-read"])
    104             state.query.assert_called_once_with([{"limit": 1}])
    105             state.publish.assert_not_called()
    106             client.sendall(masked_frame(8, b""))
    107             self.assertTrue(finished.wait(1))
    108             self.assertEqual(errors, [])
    109         self.assertGreaterEqual(len(calls), 2)
    110 
    111     def test_partial_frame_still_expires_without_query_or_publication(self):
    112         def wait(read, write, error, timeout):
    113             self.assertEqual(timeout, 15)
    114             return select.select(read, write, error, 1)
    115 
    116         with relay_socket(wait) as (client, state, finished, errors):
    117             client.sendall(b"\x81")
    118             self.assertTrue(finished.wait(1), "Partial frame read deadline was lost")
    119             self.assertEqual(client.recv(1), b"")
    120             state.query.assert_not_called()
    121             state.publish.assert_not_called()
    122             self.assertEqual(errors, [])
    123 
    124 
    125 if __name__ == "__main__":
    126     unittest.main()