HTTP protocol tests

daphne/http_protocol.py

@@ -127,12 +127,7 @@ def process(self):
                 # Remove our HTTP reply channel association
                 logger.debug("Upgraded connection %s to WebSocket", self.client_addr)
                 # Resume the producer so we keep getting data, if it's available as a method
-                # 17.1 version
-                if hasattr(self.channel, "_networkProducer"):
-                    self.channel._networkProducer.resumeProducing()
-                # 16.x version
-                elif hasattr(self.channel, "resumeProducing"):
-                    self.channel.resumeProducing()
+                self.channel._networkProducer.resumeProducing()
 
             # Boring old HTTP.
             else:

daphne/server.py

@@ -106,6 +106,12 @@ def run(self):
         reactor.addSystemEventTrigger("before", "shutdown", self.kill_all_applications)
         reactor.run(installSignalHandlers=self.signal_handlers)
 
+    def stop(self):
+        """
+        Force-stops the server.
+        """
+        reactor.stop()
+
     ### Protocol handling
 
     def add_protocol(self, protocol):
@@ -159,16 +165,20 @@ def application_checker(self):
             if application_instance.done():
                 exception = application_instance.exception()
                 if exception:
-                    logging.error(
-                        "Exception inside application: {}\n{}{}".format(
-                            exception,
-                            "".join(traceback.format_tb(
-                                exception.__traceback__,
-                            )),
-                            "  {}".format(exception),
+                    if isinstance(exception, KeyboardInterrupt):
+                        # Protocol is asking the server to exit (likely during test)
+                        self.stop()
+                    else:
+                        logging.error(
+                            "Exception inside application: {}\n{}{}".format(
+                                exception,
+                                "".join(traceback.format_tb(
+                                    exception.__traceback__,
+                                )),
+                                "  {}".format(exception),
+                            )
                         )
-                    )
-                    protocol.handle_exception(exception)
+                        protocol.handle_exception(exception)
                 try:
                     del self.application_instances[protocol]
                 except KeyError:

daphne/test_utils.py

@@ -0,0 +1,86 @@
+import msgpack
+import os
+import tempfile
+
+
+class TestApplication:
+    """
+    An application that receives one or more messages, sends a response,
+    and then quits the server. For testing.
+    """
+
+    setup_storage = os.path.join(tempfile.gettempdir(), "setup.testio")
+    result_storage = os.path.join(tempfile.gettempdir(), "result.testio")
+
+    def __init__(self, scope):
+        self.scope = scope
+        self.messages = []
+
+    async def __call__(self, send, receive):
+        # Load setup info
+        setup = self.load_setup()
+        try:
+            for _ in range(setup["receive_messages"]):
+                self.messages.append(await receive())
+            for message in setup["response_messages"]:
+                await send(message)
+        finally:
+            self.save_result()
+
+    @classmethod
+    def save_setup(cls, response_messages, receive_messages=1):
+        """
+        Stores setup information.
+        """
+        with open(cls.setup_storage, "wb") as fh:
+            fh.write(msgpack.packb(
+                {
+                    "response_messages": response_messages,
+                    "receive_messages": receive_messages,
+                },
+                use_bin_type=True,
+            ))
+
+    @classmethod
+    def load_setup(cls):
+        """
+        Returns setup details.
+        """
+        with open(cls.setup_storage, "rb") as fh:
+            return msgpack.unpackb(fh.read(), encoding="utf-8")
+
+    def save_result(self):
+        """
+        Saves details of what happened to the result storage.
+        We could use pickle here, but that seems wrong, still, somehow.
+        """
+        with open(self.result_storage, "wb") as fh:
+            fh.write(msgpack.packb(
+                {
+                    "scope": self.scope,
+                    "messages": self.messages,
+                },
+                use_bin_type=True,
+            ))
+
+    @classmethod
+    def load_result(cls):
+        """
+        Returns result details.
+        """
+        with open(cls.result_storage, "rb") as fh:
+            return msgpack.unpackb(fh.read(), encoding="utf-8")
+
+    @classmethod
+    def clear_storage(cls):
+        """
+        Clears storage files.
+        """
+        try:
+            os.unlink(cls.setup_storage)
+        except OSError:
+            pass
+        try:
+            os.unlink(cls.result_storage)
+        except OSError:
+            pass