Rename ServerConnector interface to Connector ¯\_(ツ)_/¯

tfw/internals/event_handling/event_handler.py

@@ -1,17 +1,17 @@
 class EventHandler:
     _instances = set()
 
-    def __init__(self, server_connector):
+    def __init__(self, connector):
         type(self)._instances.add(self)
-        self.server_connector = server_connector
+        self.connector = connector
 
     def start(self):
-        self.server_connector.register_callback(self._event_callback)
+        self.connector.register_callback(self._event_callback)
 
     def _event_callback(self, message):
-        self.handle_event(message, self.server_connector)
+        self.handle_event(message, self.connector)
 
-    def handle_event(self, message, server_connector):
+    def handle_event(self, message, connector):
         raise NotImplementedError()
 
     @classmethod
@@ -20,7 +20,7 @@ class EventHandler:
             instance.stop()
 
     def stop(self):
-        self.server_connector.close()
+        self.connector.close()
         self.cleanup()
 
     def cleanup(self):

tfw/internals/event_handling/event_handler_factory_base.py

@@ -6,15 +6,15 @@ from .event_handler import EventHandler
 class EventHandlerFactoryBase:
     def build(self, handler_stub, *, keys=None, event_handler_type=EventHandler):
         builder = EventHandlerBuilder(handler_stub, keys, event_handler_type)
-        server_connector = self._build_server_connector()
-        event_handler = builder.build(server_connector)
-        handler_stub.server_connector = server_connector
+        connector = self._build_connector()
+        event_handler = builder.build(connector)
+        handler_stub.connector = connector
         with suppress(AttributeError):
             handler_stub.start()
         event_handler.start()
         return event_handler
 
-    def _build_server_connector(self):
+    def _build_connector(self):
         raise NotImplementedError()
 
 
@@ -23,9 +23,9 @@ class EventHandlerBuilder:
         self._analyzer = HandlerStubAnalyzer(event_handler, supplied_keys)
         self._event_handler_type = event_handler_type
 
-    def build(self, server_connector):
-        event_handler = self._event_handler_type(server_connector)
-        server_connector.subscribe(*self._try_get_keys(event_handler))
+    def build(self, connector):
+        event_handler = self._event_handler_type(connector)
+        connector.subscribe(*self._try_get_keys(event_handler))
         event_handler.handle_event = self._analyzer.handle_event
         with suppress(AttributeError):
             event_handler.cleanup = self._analyzer.cleanup

tfw/internals/event_handling/fsm_aware_event_handler.py

@@ -8,12 +8,12 @@ class FSMAwareEventHandler(EventHandler, FSMAware):
     Abstract base class for EventHandlers which automatically
     keep track of the state of the TFW FSM.
     """
-    def __init__(self, server_connector):
-        EventHandler.__init__(self, server_connector)
+    def __init__(self, connector):
+        EventHandler.__init__(self, connector)
         FSMAware.__init__(self)
 
     def _event_callback(self, message):
         self.process_message(message)
 
     def handle_fsm_step(self, message):
-        self.handle_event(message, self.server_connector)
+        self.handle_event(message, self.connector)

tfw/internals/event_handling/test_event_handler.py

@@ -9,11 +9,11 @@ from .event_handler import EventHandler
 
 
 class MockEventHandlerFactory(EventHandlerFactoryBase):
-    def _build_server_connector(self):
-        return MockServerConnector()
+    def _build_connector(self):
+        return MockConnector()
 
 
-class MockServerConnector:
+class MockConnector:
     def __init__(self):
         self.keys = []
         self._on_message = None
@@ -40,7 +40,7 @@ class MockServerConnector:
 
 class MockEventHandlerStub:
     def __init__(self):
-        self.server_connector = None
+        self.connector = None
         self.last_message = None
         self.cleaned_up = False
         self.started = False
@@ -54,12 +54,12 @@ class MockEventHandlerStub:
 
 class MockEventHandler(MockEventHandlerStub):
     # pylint: disable=unused-argument
-    def handle_event(self, message, server_connector):
+    def handle_event(self, message, connector):
         self.last_message = message
 
 
 class MockCallable(MockEventHandlerStub):
-    def __call__(self, message, server_connector):
+    def __call__(self, message, connector):
         self.last_message = message
 
 
@@ -78,17 +78,17 @@ def test_keys():
 
 def test_build_from_object(test_keys, test_msg):
     mock_eh = MockEventHandlerStub()
-    def handle_event(message, server_connector):
-        raise RuntimeError(message, server_connector.keys)
+    def handle_event(message, connector):
+        raise RuntimeError(message, connector.keys)
     mock_eh.handle_event = handle_event
 
     assert not mock_eh.started
     eh = MockEventHandlerFactory().build(mock_eh, keys=test_keys)
 
     assert mock_eh.started
-    assert mock_eh.server_connector is eh.server_connector
+    assert mock_eh.connector is eh.connector
     with pytest.raises(RuntimeError) as err:
-        eh.server_connector.simulate_message(test_msg)
+        eh.connector.simulate_message(test_msg)
         msg, keys = err.args
         assert msg == test_msg
         assert keys == test_keys
@@ -104,11 +104,11 @@ def test_build_from_object_with_keys(test_keys, test_msg):
     assert not mock_eh.started
     eh = MockEventHandlerFactory().build(mock_eh)
 
-    assert mock_eh.server_connector.keys == test_keys
-    assert eh.server_connector is mock_eh.server_connector
+    assert mock_eh.connector.keys == test_keys
+    assert eh.connector is mock_eh.connector
     assert mock_eh.started
     assert not mock_eh.last_message
-    eh.server_connector.simulate_message(test_msg)
+    eh.connector.simulate_message(test_msg)
     assert mock_eh.last_message == test_msg
     assert not mock_eh.cleaned_up
     EventHandler.stop_all_instances()
@@ -118,14 +118,14 @@ def test_build_from_object_with_keys(test_keys, test_msg):
 def test_build_from_simple_object(test_keys, test_msg):
     class SimpleMockEventHandler:
         # pylint: disable=no-self-use
-        def handle_event(self, message, server_connector):
-            raise RuntimeError(message, server_connector)
+        def handle_event(self, message, connector):
+            raise RuntimeError(message, connector)
 
     mock_eh = SimpleMockEventHandler()
     eh = MockEventHandlerFactory().build(mock_eh, keys=test_keys)
 
     with pytest.raises(RuntimeError) as err:
-        eh.server_connector.simulate_message(test_msg)
+        eh.connector.simulate_message(test_msg)
         msg, keys = err.args
         assert msg == test_msg
         assert keys == test_keys
@@ -138,10 +138,10 @@ def test_build_from_callable(test_keys, test_msg):
     eh = MockEventHandlerFactory().build(mock_eh, keys=test_keys)
 
     assert mock_eh.started
-    assert mock_eh.server_connector is eh.server_connector
-    assert eh.server_connector.keys == test_keys
+    assert mock_eh.connector is eh.connector
+    assert eh.connector.keys == test_keys
     assert not mock_eh.last_message
-    eh.server_connector.simulate_message(test_msg)
+    eh.connector.simulate_message(test_msg)
     assert mock_eh.last_message == test_msg
     assert not mock_eh.cleaned_up
     eh.stop()
@@ -149,13 +149,13 @@ def test_build_from_callable(test_keys, test_msg):
 
 
 def test_build_from_function(test_keys, test_msg):
-    def some_function(message, server_connector):
-        raise RuntimeError(message, server_connector.keys)
+    def some_function(message, connector):
+        raise RuntimeError(message, connector.keys)
     eh = MockEventHandlerFactory().build(some_function, keys=test_keys)
 
-    assert eh.server_connector.keys == test_keys
+    assert eh.connector.keys == test_keys
     with pytest.raises(RuntimeError) as err:
-        eh.server_connector.simulate_message(test_msg)
+        eh.connector.simulate_message(test_msg)
         msg, keys = err.args
         assert msg == test_msg
         assert keys == test_keys
@@ -166,7 +166,7 @@ def test_build_from_lambda(test_keys, test_msg):
         assert msg == test_msg
     fun = lambda msg, sc: assert_messages_equal(msg)
     eh = MockEventHandlerFactory().build(fun, keys=test_keys)
-    eh.server_connector.simulate_message(test_msg)
+    eh.connector.simulate_message(test_msg)
 
 
 def test_build_raises_if_no_key(test_keys):