Moved wscomms -> comms/websocket

docs/dev/api/wscomms/wsclientcomms.rst

@@ -1,7 +1,7 @@
-WSClientComms
+WebsocketClientComms
 -------------
 
 .. module:: malcolm.wscomms.wsclientcomms
 
-.. autoclass:: WSClientComms
+.. autoclass:: WebsocketClientComms
     :members:

docs/dev/api/wscomms/wsservercomms.rst

@@ -1,7 +1,7 @@
-WSServerComms
+WebsocketServerComms
 -------------
 
 .. module:: malcolm.wscomms.wsservercomms
 
-.. autoclass:: WSServerComms
+.. autoclass:: WebsocketServerComms
     :members:

malcolm/comms/websocket/__init__.py

@@ -0,0 +1,2 @@
+from malcolm.comms.websocket.websocketclientcomms import WebsocketClientComms
+from malcolm.comms.websocket.websocketservercomms import WebsocketServerComms

malcolm/wscomms/wsclientcomms.py → malcolm/comms/websocket/websocketclientcomms.py

@@ -9,7 +9,7 @@
 from malcolm.core.serializable import Serializable
 
 
-class WSClientComms(ClientComms):
+class WebsocketClientComms(ClientComms):
     """A class for a client to communicate with the server"""
 
     def __init__(self, name, process, url):
@@ -19,7 +19,7 @@ def __init__(self, name, process, url):
             process (Process): Process for primitive creation
             url (str): Url for websocket connection. E.g. ws://localhost:8888/ws
         """
-        super(WSClientComms, self).__init__(name, process)
+        super(WebsocketClientComms, self).__init__(name, process)
         self.url = url
         # TODO: Are we starting one or more IOLoops here?
         self.loop = IOLoop.current()

malcolm/wscomms/wsservercomms.py → malcolm/comms/websocket/websocketservercomms.py

@@ -31,11 +31,11 @@ def on_message(self, message):
         self.servercomms.on_request(request)
 
 
-class WSServerComms(ServerComms):
+class WebsocketServerComms(ServerComms):
     """A class for communication between browser and server"""
 
     def __init__(self, name, process, port):
-        super(WSServerComms, self).__init__(name, process)
+        super(WebsocketServerComms, self).__init__(name, process)
 
         self.name = name
         self.process = process

tests/test_wscomms/test_system_wscomms.py → tests/test_comms/test_websocket/test_system_websocket.py

@@ -1,7 +1,6 @@
 import os
 import sys
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
-import setup_malcolm_paths
 
 import time
 # logging
@@ -19,11 +18,9 @@
 # module imports
 from malcolm.controllers.hellocontroller import HelloController
 from malcolm.controllers.clientcontroller import ClientController
-from malcolm.core.block import Block
 from malcolm.core.process import Process
 from malcolm.core.syncfactory import SyncFactory
-from malcolm.wscomms.wsservercomms import WSServerComms
-from malcolm.wscomms.wsclientcomms import WSClientComms
+from malcolm.comms.websocket import WebsocketServerComms, WebsocketClientComms
 
 
 class TestSystemWSCommsServerOnly(unittest.TestCase):
@@ -33,7 +30,7 @@ def setUp(self):
         self.sf = SyncFactory("sync")
         self.process = Process("proc", self.sf)
         HelloController("hello", self.process)
-        self.sc = WSServerComms("sc", self.process, self.socket)
+        self.sc = WebsocketServerComms("sc", self.process, self.socket)
         self.process.start()
         self.sc.start()
 
@@ -76,13 +73,13 @@ def setUp(self):
         self.sf = SyncFactory("sync")
         self.process = Process("proc", self.sf)
         HelloController("hello", self.process)
-        self.sc = WSServerComms("sc", self.process, self.socket)
+        self.sc = WebsocketServerComms("sc", self.process, self.socket)
         self.process.start()
         self.sc.start()
         self.process2 = Process("proc2", self.sf)
         self.block2 = ClientController('hello', self.process2).block
-        self.cc = WSClientComms("cc", self.process2, "ws://localhost:%s/ws" %
-                                self.socket)
+        self.cc = WebsocketClientComms("cc", self.process2, "ws://localhost:%s/ws" %
+                                       self.socket)
         self.process2.start()
         self.cc.start()
 

tests/test_wscomms/test_wsclientcomms.py → tests/test_comms/test_websocket/test_websocketclientcomms.py

@@ -1,36 +1,35 @@
 import os
 import sys
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
-import setup_malcolm_paths
 
 from collections import OrderedDict
 
 import unittest
 from mock import MagicMock, patch, call
 
-from malcolm.wscomms.wsclientcomms import WSClientComms
+from malcolm.comms.websocket import WebsocketClientComms
 
 
 class TestWSClientComms(unittest.TestCase):
 
     def setUp(self):
         self.p = MagicMock()
 
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_init(self, ioloop_mock, connect_mock):
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
 
         self.assertEqual(self.p, self.WS.process)
         self.assertEqual("test/url", self.WS.url)
         self.assertEqual(ioloop_mock.current(), self.WS.loop)
         connect_mock.assert_called_once_with(self.WS.url, callback=self.WS.subscribe_server_blocks, on_message_callback=self.WS.on_message)
         self.assertEqual(connect_mock(), self.WS.conn)
 
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_subscribe_initial(self, _, _2):
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         self.WS.subscribe_server_blocks("conn")
         self.assertEqual(self.WS.loop.add_callback.call_count, 1)
         request = self.WS.loop.add_callback.call_args[0][1]
@@ -39,12 +38,12 @@ def test_subscribe_initial(self, _, _2):
         self.assertEqual(request.endpoint, [".", "blocks", "value"])
         self.assertEqual(request.delta, False)
 
-    @patch('malcolm.wscomms.wsclientcomms.Serializable')
-    @patch('malcolm.wscomms.wsclientcomms.json')
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.Serializable')
+    @patch('malcolm.comms.websocket.websocketclientcomms.json')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_on_message(self, _, _1, json_mock, serializable_mock):
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
 
         message_dict = dict(name="TestMessage")
         json_mock.loads.return_value = message_dict
@@ -62,11 +61,11 @@ def test_on_message(self, _, _1, json_mock, serializable_mock):
         serializable_mock.from_dict.assert_called_once_with(message_dict)
         request_mock.response_queue.put.assert_called_once_with(response)
 
-    @patch('malcolm.wscomms.wsclientcomms.json')
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.json')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_on_message_logs_exception(self, _, _1, json_mock):
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         self.WS.log_exception = MagicMock()
         exception = Exception()
         json_mock.loads.side_effect = exception
@@ -75,11 +74,11 @@ def test_on_message_logs_exception(self, _, _1, json_mock):
 
         self.WS.log_exception.assert_called_once_with(exception)
 
-    @patch('malcolm.wscomms.wsclientcomms.json')
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.json')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_send_to_server(self, _, connect_mock, json_mock):
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         json_mock.reset_mock()
         result_mock = MagicMock()
         connect_mock().result.return_value = result_mock
@@ -92,39 +91,39 @@ def test_send_to_server(self, _, connect_mock, json_mock):
         json_mock.dumps.assert_called_once_with(request_mock.to_dict())
         result_mock.write_message.assert_called_once_with(dumps_mock)
 
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_start(self, ioloop_mock, _):
         loop_mock = MagicMock()
         ioloop_mock.current.return_value = loop_mock
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         self.WS.process.spawn = MagicMock()
         self.WS.start()
 
         self.assertEqual([call(self.WS.send_loop), call(self.WS.loop.start)],
                          self.WS.process.spawn.call_args_list)
 
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_stop(self, ioloop_mock, _):
         loop_mock = MagicMock()
         ioloop_mock.current.return_value = loop_mock
 
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         self.WS.start()
         self.WS.stop()
 
         loop_mock.add_callback.assert_called_once_with(
             ioloop_mock.current().stop)
         self.WS.process.spawn.return_value.assert_not_called()
 
-    @patch('malcolm.wscomms.wsclientcomms.websocket_connect')
-    @patch('malcolm.wscomms.wsclientcomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketclientcomms.websocket_connect')
+    @patch('malcolm.comms.websocket.websocketclientcomms.IOLoop')
     def test_wait(self, _, _2):
         spawnable_mocks = [MagicMock(), MagicMock()]
         timeout = MagicMock()
 
-        self.WS = WSClientComms("TestWebSocket", self.p, "test/url")
+        self.WS = WebsocketClientComms("TestWebSocket", self.p, "test/url")
         self.WS.process.spawn = MagicMock(side_effect=spawnable_mocks)
         self.WS.start()
         self.WS.wait(timeout)

tests/test_wscomms/test_wsservercomms.py → tests/test_comms/test_websocket/test_websocketservercomms.py

@@ -1,85 +1,84 @@
 import os
 import sys
 sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
-import setup_malcolm_paths
 
 from collections import OrderedDict
 
 import unittest
 from mock import MagicMock, patch, call
 
-from malcolm.wscomms.wsservercomms import WSServerComms
-from malcolm.wscomms.wsservercomms import MalcolmWebSocketHandler
+from malcolm.comms.websocket import WebsocketServerComms
+from malcolm.comms.websocket.websocketservercomms import MalcolmWebSocketHandler
 
 
 class TestWSServerComms(unittest.TestCase):
 
     def setUp(self):
         self.p = MagicMock()
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_init(self, ioloop_mock, server_mock):
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
 
         self.assertEqual("TestWebSocket", self.WS.name)
         self.assertEqual(self.p, self.WS.process)
         self.assertEqual(server_mock(), self.WS.server)
         self.assertEqual(ioloop_mock.current(), self.WS.loop)
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer.listen')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer.listen')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_listen_called(self, ioloop_mock, listen_mock):
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
 
         self.assertEqual(ioloop_mock.current(), self.WS.loop)
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer.listen')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer.listen')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_start(self, _, _2):
         self.p.spawn = MagicMock()
 
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
         self.WS.start()
 
         self.assertEqual([call(self.WS.send_loop), call(self.WS.loop.start)],
                          self.p.spawn.call_args_list)
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_stop(self, ioloop_mock, server_mock):
         loop_mock = MagicMock()
         ioloop_mock.current.return_value = loop_mock
         self.p.spawn = MagicMock()
 
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
         self.WS.start()
         self.WS.stop()
 
         self.assertEqual([call(self.WS.server.stop), call(self.WS.loop.stop)],
                 loop_mock.add_callback.call_args_list)
         self.p.spawn.return_value.wait.assert_not_called()
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_wait(self, ioloop_mock, server_mock):
         spawnable_mocks = [MagicMock(), MagicMock()]
         timeout = MagicMock()
         self.p.spawn = MagicMock(side_effect=spawnable_mocks)
 
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
         self.WS.start()
         self.WS.wait(timeout)
 
         spawnable_mocks[0].wait.assert_called_once_with(timeout=timeout)
         spawnable_mocks[1].wait.assert_called_once_with(timeout=timeout)
 
-    @patch('malcolm.wscomms.wsservercomms.Serializable')
-    @patch('malcolm.wscomms.wsservercomms.json')
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer.listen')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.Serializable')
+    @patch('malcolm.comms.websocket.websocketservercomms.json')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer.listen')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_MWSH_on_message(self, _, _1, json_mock, serializable_mock):
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
 
         message_dict = dict(name="TestMessage")
         json_mock.loads.return_value = message_dict
@@ -98,20 +97,20 @@ def test_MWSH_on_message(self, _, _1, json_mock, serializable_mock):
         serializable_mock.from_dict.assert_called_once_with(message_dict)
         self.p.q.put.assert_called_once_with(request)
 
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_on_request_with_process_name(self, _, _2):
-        self.WS = WSServerComms("ws", self.p, 1)
+        self.WS = WebsocketServerComms("ws", self.p, 1)
         request = MagicMock(fields=dict(endpoint="anything"), endpoint=[".", "blocks"])
         self.WS.on_request(request)
         self.p.q.put.assert_called_once_with(request)
         self.assertEqual(request.endpoint, [self.p.name, "blocks"])
 
-    @patch('malcolm.wscomms.wsservercomms.json')
-    @patch('malcolm.wscomms.wsservercomms.HTTPServer.listen')
-    @patch('malcolm.wscomms.wsservercomms.IOLoop')
+    @patch('malcolm.comms.websocket.websocketservercomms.json')
+    @patch('malcolm.comms.websocket.websocketservercomms.HTTPServer.listen')
+    @patch('malcolm.comms.websocket.websocketservercomms.IOLoop')
     def test_send_to_client(self, _, _2, json_mock):
-        self.WS = WSServerComms("TestWebSocket", self.p, 1)
+        self.WS = WebsocketServerComms("TestWebSocket", self.p, 1)
 
         response_mock = MagicMock()
         self.WS.send_to_client(response_mock)