spoof 2.2.2__tar.gz → 2.3.1__tar.gz

{spoof-2.2.2 → spoof-2.3.1}/CHANGELOG.rst

@@ -1,3 +1,25 @@
+2.3.1 (2026-05-01)
+==================
+
+- Return ``self`` for ``.restart()`` method
+- Update tests
+- Update docs
+
+2.3.0 (2026-04-27)
+==================
+
+- Add ``.restart()`` convenience method
+- Add ``.serverAddress`` property to allow setting the server address
+  (requires restart after setting)
+- Add ``.sslContext`` property to allow setting the sslContext
+  (requires restart after setting)
+- Return ``None`` for server address, port, and URL if not started
+- Return ``self`` for ``.start()`` method
+- Apply least permission to GitHub Actions workflows
+- Cleanup code
+- Update tests
+- Update docs
+
 2.2.2 (2026-04-21)
 ==================
 

{spoof-2.2.2 → spoof-2.3.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: spoof
-Version: 2.2.2
-Summary: HTTP server for testing environments
+Version: 2.3.1
+Summary: A simple HTTP server for test environments
 Author-email: Lex Scarisbrick <lex@scarisbrick.org>
 License-Expression: MIT
 Project-URL: Documentation, https://spoof.readthedocs.io/en/latest/
@@ -19,6 +19,7 @@ Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Mocking
 Classifier: Topic :: Software Development :: Testing :: Traffic Generation
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
@@ -56,10 +57,10 @@ Spoof 👻
 
 A test interface for HTTP
 =========================
-Spoof lets you easily create HTTP servers listening on real network
-sockets. Designed for test environments, what responses to send can be
-configured anytime, including while an HTTP server is running. Requests
-can be inspected live or after a response is sent.
+Spoof lets you easily create HTTP servers on real network sockets.
+Designed for test environments, what responses to send can be configured
+anytime, including while an HTTP server is running. Requests can be
+inspected live or after a response is sent.
 
 Unlike a conventional HTTP server, where specific methods and paths are
 configured in advance, Spoof accepts and records *all* requests, sending
@@ -72,7 +73,13 @@ HTTP client code. Have you ever felt icky patching a client library to
 write tests? Ever been burned by this? Ever wanted to refactor a client
 library, but had no way to verify behavior apart from doing live
 integration testing? Ever wanted mock for HTTP? If you answered yes to
-any of the above, Spoof might be for you.
+any of the above, Spoof might be for you. Some key features:
+
+* Decoupled requests and responses
+* SSL/TLS with PQC
+* HTTP/S proxy via CONNECT
+* IPv6
+* Live request debugging
 
 Installation and Compatibility
 ==============================
@@ -84,7 +91,8 @@ Spoof is available on PyPI:
 
 Spoof is tested on Python 3.10 to 3.14, leverages the ``http.server`` module
 included in the Python standard library, and has no external dependencies.
-It may work on older versions of Python, but this is not supported.
+It may work on older versions of Python, but this is
+`not supported <https://devguide.python.org/versions/>`__.
 
 Multiple Spoof HTTP servers can be run concurrently, and by default, the port
 number is the next available unused port. With OpenSSL installed, Spoof can
@@ -107,7 +115,7 @@ Spoof expects responses to have the following syntax:
    # bytes content
    [200, [("Content-Type", "application/json")], b'{"success": true }']
 
-   # responses can also be a callback
+   # responses can also be a callback, with request as the only argument
    def callback(request):
        return [200, [], request.path]
 
@@ -175,8 +183,8 @@ Request history
 Spoof records each request and appends it to the ``.requests`` property,
 which is backed by a
 `deque <https://docs.python.org/3/library/collections.html#collections.deque>`__
-instance, the same as the ``.responses`` property. Think of it like a pre-parsed access log. Example
-using request history:
+instance, the same as the ``.responses`` property. Think of it like a structured
+access log. Example using request history:
 
 .. code-block:: python
 

{spoof-2.2.2 → spoof-2.3.1}/README.rst

@@ -29,10 +29,10 @@ Spoof 👻
 
 A test interface for HTTP
 =========================
-Spoof lets you easily create HTTP servers listening on real network
-sockets. Designed for test environments, what responses to send can be
-configured anytime, including while an HTTP server is running. Requests
-can be inspected live or after a response is sent.
+Spoof lets you easily create HTTP servers on real network sockets.
+Designed for test environments, what responses to send can be configured
+anytime, including while an HTTP server is running. Requests can be
+inspected live or after a response is sent.
 
 Unlike a conventional HTTP server, where specific methods and paths are
 configured in advance, Spoof accepts and records *all* requests, sending
@@ -45,7 +45,13 @@ HTTP client code. Have you ever felt icky patching a client library to
 write tests? Ever been burned by this? Ever wanted to refactor a client
 library, but had no way to verify behavior apart from doing live
 integration testing? Ever wanted mock for HTTP? If you answered yes to
-any of the above, Spoof might be for you.
+any of the above, Spoof might be for you. Some key features:
+
+* Decoupled requests and responses
+* SSL/TLS with PQC
+* HTTP/S proxy via CONNECT
+* IPv6
+* Live request debugging
 
 Installation and Compatibility
 ==============================
@@ -57,7 +63,8 @@ Spoof is available on PyPI:
 
 Spoof is tested on Python 3.10 to 3.14, leverages the ``http.server`` module
 included in the Python standard library, and has no external dependencies.
-It may work on older versions of Python, but this is not supported.
+It may work on older versions of Python, but this is
+`not supported <https://devguide.python.org/versions/>`__.
 
 Multiple Spoof HTTP servers can be run concurrently, and by default, the port
 number is the next available unused port. With OpenSSL installed, Spoof can
@@ -80,7 +87,7 @@ Spoof expects responses to have the following syntax:
    # bytes content
    [200, [("Content-Type", "application/json")], b'{"success": true }']
 
-   # responses can also be a callback
+   # responses can also be a callback, with request as the only argument
    def callback(request):
        return [200, [], request.path]
 
@@ -148,8 +155,8 @@ Request history
 Spoof records each request and appends it to the ``.requests`` property,
 which is backed by a
 `deque <https://docs.python.org/3/library/collections.html#collections.deque>`__
-instance, the same as the ``.responses`` property. Think of it like a pre-parsed access log. Example
-using request history:
+instance, the same as the ``.responses`` property. Think of it like a structured
+access log. Example using request history:
 
 .. code-block:: python
 

{spoof-2.2.2 → spoof-2.3.1}/pyproject.toml

@@ -7,7 +7,7 @@ name = "spoof"
 dynamic = ["version"]
 requires-python = ">=3.10"
 dependencies = []
-description = "HTTP server for testing environments"
+description = "A simple HTTP server for test environments"
 readme = "README.rst"
 authors = [
     {"name" = "Lex Scarisbrick", "email" = "lex@scarisbrick.org"},
@@ -25,6 +25,7 @@ classifiers = [
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Software Development :: Quality Assurance",
     "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: Mocking",
     "Topic :: Software Development :: Testing :: Traffic Generation",
 ]
 
@@ -44,7 +45,6 @@ py-modules = ["spoof"]
 [tool.setuptools.packages.find]
 where = ["src"]
 include = ["spoof*"]
-#exclude = [".github*", "tests*", "dist*", "build*", "*.egg-info*", "src/docs*"]
 
 [tool.setuptools_scm]
 # https://setuptools-scm.readthedocs.io/en/latest/extending/#setuptools_scmversion_scheme

{spoof-2.2.2 → spoof-2.3.1}/src/spoof.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: spoof
-Version: 2.2.2
-Summary: HTTP server for testing environments
+Version: 2.3.1
+Summary: A simple HTTP server for test environments
 Author-email: Lex Scarisbrick <lex@scarisbrick.org>
 License-Expression: MIT
 Project-URL: Documentation, https://spoof.readthedocs.io/en/latest/
@@ -19,6 +19,7 @@ Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Testing :: Mocking
 Classifier: Topic :: Software Development :: Testing :: Traffic Generation
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
@@ -56,10 +57,10 @@ Spoof 👻
 
 A test interface for HTTP
 =========================
-Spoof lets you easily create HTTP servers listening on real network
-sockets. Designed for test environments, what responses to send can be
-configured anytime, including while an HTTP server is running. Requests
-can be inspected live or after a response is sent.
+Spoof lets you easily create HTTP servers on real network sockets.
+Designed for test environments, what responses to send can be configured
+anytime, including while an HTTP server is running. Requests can be
+inspected live or after a response is sent.
 
 Unlike a conventional HTTP server, where specific methods and paths are
 configured in advance, Spoof accepts and records *all* requests, sending
@@ -72,7 +73,13 @@ HTTP client code. Have you ever felt icky patching a client library to
 write tests? Ever been burned by this? Ever wanted to refactor a client
 library, but had no way to verify behavior apart from doing live
 integration testing? Ever wanted mock for HTTP? If you answered yes to
-any of the above, Spoof might be for you.
+any of the above, Spoof might be for you. Some key features:
+
+* Decoupled requests and responses
+* SSL/TLS with PQC
+* HTTP/S proxy via CONNECT
+* IPv6
+* Live request debugging
 
 Installation and Compatibility
 ==============================
@@ -84,7 +91,8 @@ Spoof is available on PyPI:
 
 Spoof is tested on Python 3.10 to 3.14, leverages the ``http.server`` module
 included in the Python standard library, and has no external dependencies.
-It may work on older versions of Python, but this is not supported.
+It may work on older versions of Python, but this is
+`not supported <https://devguide.python.org/versions/>`__.
 
 Multiple Spoof HTTP servers can be run concurrently, and by default, the port
 number is the next available unused port. With OpenSSL installed, Spoof can
@@ -107,7 +115,7 @@ Spoof expects responses to have the following syntax:
    # bytes content
    [200, [("Content-Type", "application/json")], b'{"success": true }']
 
-   # responses can also be a callback
+   # responses can also be a callback, with request as the only argument
    def callback(request):
        return [200, [], request.path]
 
@@ -175,8 +183,8 @@ Request history
 Spoof records each request and appends it to the ``.requests`` property,
 which is backed by a
 `deque <https://docs.python.org/3/library/collections.html#collections.deque>`__
-instance, the same as the ``.responses`` property. Think of it like a pre-parsed access log. Example
-using request history:
+instance, the same as the ``.responses`` property. Think of it like a structured
+access log. Example using request history:
 
 .. code-block:: python
 

{spoof-2.2.2 → spoof-2.3.1}/src/spoof.py

@@ -21,11 +21,11 @@ URI_QUERY_SEPARATOR = "?"
 MEGABYTE = 2**20
 
 
-class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler, object):
-    """Provides HTTP handler for use with `BaseHTTPServer.HTTPServer`
-    compatible class server. Because the class is passed directly
-    instead of an instance of the class, the `*Queue` class attributes
-    must be set before passing to the HTTP server.
+class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler):
+    """Provides HTTP handler for use with ``http.server`` compatible class
+    server. Because the class is passed directly instead of an instance of
+    the class, the `*Queue` class attributes must be set before passing to
+    the HTTP server.
     """
 
     debug = False
@@ -33,7 +33,7 @@ class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler, object):
     errorResponse = [
         HTTP_SERVICE_UNAVAILABLE,
         [],
-        "No responses queued and no default response set\n\n",
+        "The .responses queue is empty and .defaultResponse is None\n\n",
     ]
     maxRequestLength = 1 * MEGABYTE
     proxyRequestGen = collections.namedtuple("SpoofProxyRequest", "thread run")
@@ -85,18 +85,21 @@ class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler, object):
                 response = self.errorResponse
         return response
 
-    def sendResponse(self, response):
-        """Sends response to HTTP client."""
-        statusCode, headers, content = response
-
+    def encodeResponseContent(self, content):
         if content and isinstance(content, str):
             content = content.encode(RESPONSE_ENCODING)
-        contentLength = len(content) if content else 0
+
+        return content
+
+    def sendResponse(self, response):
+        """Sends response to HTTP client."""
+        statusCode, headers, rawContent = response
+        content = self.encodeResponseContent(rawContent)
 
         self.send_response(statusCode)
 
         if content is not None:
-            self.send_header("Content-Length", contentLength)
+            self.send_header("Content-Length", len(content))
         for header in headers:
             self.send_header(*header)
         self.end_headers()
@@ -151,7 +154,7 @@ class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler, object):
     def _proxyRequest(self, run):
         downstream = self.request
         upstream = socket.create_connection(
-            self.server.upstream.serverAddress, self.server.upstream.timeout
+            (self.server.upstream.address, self.server.upstream.port), self.server.upstream.timeout
         )
         writer = {downstream: upstream, upstream: downstream}
 
@@ -176,7 +179,7 @@ class HTTPRequestHandler(BaseHTTPServer.BaseHTTPRequestHandler, object):
             super(HTTPRequestHandler, self).log_message(*args, **kwargs)
 
 
-class HTTPServer(object):
+class HTTPServer:
     """Provides a single-threaded HTTP testing server.
 
     Class attributes:
@@ -199,53 +202,57 @@ class HTTPServer(object):
         """
         self._requests = collections.deque()
         self._responses = collections.deque()
-        self._sslContext = sslContext
+        self._serverAddress = None
         self._upstream = None
-        self.handlerClass = self.configureHandlerClass(self.handlerClass)
+        self.handlerClass = self.configureHandlerClass()
         self.proxyMode = proxy
         self.proxyThreads = []
         self.recvSize = 4096
         self.selectTimeout = 0.1
         self.server = None
         self.serverAddress = (host, port)
-        if ":" in str(host):
-            self.serverClass = HTTPServer6.configureServerClass(host)
-        else:
-            self.serverClass = self.configureServerClass(host)
-        self.serverClass.timeout = timeout
-        self.serverClass.sslContext = sslContext
+        self.sslContext = sslContext
         self.thread = None
+        self.timeout = timeout
 
         if self.proxyMode:
-            self.upstream = type(self)(host="localhost", port=0, sslContext=sslContext, proxy=False)
-            self.defaultResponse = [200, [], None]
+            self.setupDefaultUpstream()
+
+    @property
+    def serverAddress(self):
+        """Returns address to bind for HTTP server."""
+        return self._serverAddress
+
+    @serverAddress.setter
+    def serverAddress(self, address):
+        """Sets address to bind for HTTP server and setup server classes."""
+        self._serverAddress = address
+        self.serverClass = self.configureServerClass(address[0])
 
     @property
     def address(self):
-        """Returns server IP/IPv6 address."""
-        return self.serverAddress[0]
+        """Returns bound server IP/IPv6 address or ``None`` if unbound."""
+        return None if self.server is None else self.server.server_address[0]
 
     @property
     def port(self):
-        """Returns server TCP port."""
-        return self.serverAddress[1]
+        """Returns bound server TCP port or ``None`` if unbound."""
+        return None if self.server is None else self.server.server_address[1]
 
     @property
     def url(self):
-        """Returns URL string to connect to this server instance."""
-        protocol = "http" if self.sslContext is None else "https"
-        address = "[{0}]".format(self.address) if ":" in self.address else self.address
-        return "{0}://{1}:{2}".format(protocol, address, self.port)
-
-    @property
-    def sslContext(self):
-        """Returns `ssl.SSLContext` instance."""
-        return self._sslContext
+        """Returns URL string for server instance or ``None`` if unbound."""
+        url = None
+        if self.server is not None:
+            protocol = "http" if self.sslContext is None else "https"
+            address = "[{0}]".format(self.address) if ":" in self.address else self.address
+            url = "{0}://{1}:{2}".format(protocol, address, self.port)
+        return url
 
     @property
     def timeout(self):
         """Returns HTTP server timeout."""
-        timeout = self.serverClass.timeout
+        timeout = self._timeout
         if self.server is not None:
             timeout = self.server.timeout
         return timeout
@@ -253,7 +260,7 @@ class HTTPServer(object):
     @timeout.setter
     def timeout(self, value):
         """Sets HTTP server timeout."""
-        self.serverClass.timeout = value
+        self._timeout = value
         if self.server is not None:
             self.server.timeout = value
 
@@ -272,36 +279,47 @@ class HTTPServer(object):
         if self.server is not None:
             self.server.upstream = value
 
-    @classmethod
-    def configureServerClass(cls, host):
-        """Reloads and configures server class. This is necessary, because of
+    def configureServerClass(self, host):
+        """Reloads and configures server class. This is necessary because of
         the use of class attributes.  If more than one address family is used
         concurrently (e.g. IPv4 _and_ IPv6), one will overwrite the other, as
         the default behavior is for a class to be loaded once and only once,
         including attributes. Using `type()` effectively creates a new class
-        with _discrete_ attributes. This is a class method, because it is
-        called outside of the scope of an initialized class instance.
-
-        :host: hostname string of server
+        with _discrete_ attributes.
         """
-        sourceClass = cls.serverClass
+        sourceClass = type(self).serverClass
         serverClass = type(sourceClass.__name__, (sourceClass, object), dict())
-        serverClass.address_family = cls.addressFamily
+        serverClass.address_family = socket.AF_INET6 if host.count(":") > 1 else self.addressFamily
         serverClass.serverName = host
         return serverClass
 
-    def configureHandlerClass(self, sourceClass):
+    def configureHandlerClass(self):
         """Reloads and configures handler class. This is necessary because of
         the use of class attributes, which are necessary because the handler
         class is instantiated anew to handle each request by `BaseServer`.
         To keep the handler class unique to each `Spoof` instance, `type()` is
         used to effectively create a discrete handler class and attributes.
         """
+        sourceClass = type(self).handlerClass
         handlerClass = type(sourceClass.__name__, (sourceClass, object), dict())
         handlerClass.responseContentQueue = self._responses
         handlerClass.requestReportQueue = self._requests
         return handlerClass
 
+    def setupDefaultUpstream(self):
+        """Configures ready-to-use default upstream HTTP server."""
+        self.upstream = type(self)(
+            host="localhost", port=0, sslContext=self.sslContext, proxy=False
+        )
+        # RFC 7231, Section 4.3.6, "A server MUST NOT send any Transfer-Encoding or
+        # Content-Length header fields in a 2xx (Successful) response to CONNECT."
+        self.defaultResponse = [200, [], None]
+
+    def restart(self):
+        """Stops and starts HTTP server."""
+        self.stop()
+        return self.start()
+
     def start(self):
         """Starts HTTP server thread(s)."""
         if self.server is not None:
@@ -311,15 +329,15 @@ class HTTPServer(object):
             self.upstream.start()
 
         self.server = self.serverClass(self.serverAddress, self.handlerClass)
-        self.serverAddress = self.server.server_address
-        self.server.upstream = self.upstream
-        if self.server.sslContext is not None:
-            self.server.socket = self.server.sslContext.wrap_socket(
-                self.server.socket, server_side=True
-            )
+        self.server.timeout = self._timeout
+        self.server.upstream = self._upstream
+        if self.sslContext is not None:
+            self.server.socket = self.sslContext.wrap_socket(self.server.socket, server_side=True)
+
         name = getattr(type(self), "__name__")
         self.thread = threading.Thread(target=self.server.serve_forever, name=name)
         self.thread.start()
+        return self
 
     def stop(self):
         """Stops HTTP server thread(s) and closes socket(s)."""
@@ -340,19 +358,15 @@ class HTTPServer(object):
         self.thread = None
 
     def __enter__(self):
-        """Starts HTTP server and returns `Spoof` instance when invoked as a
-        context manager (with/as)."""
-        self.start()
-        return self
+        """Starts and returns HTTP server instance when invoked as a context manager (with/as)."""
+        return self.start()
 
     def __exit__(self, exceptionType, exceptionValue, traceback):
-        """Destroys HTTP server instance when context manager block finishes.
-        If context block ends normally, all arguments will be `None`.
-        """
+        """Stops HTTP server instance when context manager block exits."""
         self.stop()
 
     def __del__(self):
-        """Closes HTTP server socket when instance goes out of scope."""
+        """Stops HTTP server when instance goes out of scope."""
         if getattr(self, "server", None) is not None:
             self.stop()
 
@@ -468,7 +482,7 @@ class HTTPServer6(HTTPServer):
     addressFamily = socket.AF_INET6
 
 
-class SSLContext(object):
+class SSLContext:
     """Provides methods to create SSL context for use with `HTTPServer`."""
 
     @staticmethod

{spoof-2.2.2 → spoof-2.3.1}/tests/test_spoof_functional.py

@@ -1,6 +1,8 @@
+import itertools
 import json
 import os
 import random
+import socket
 import ssl
 import unittest
 
@@ -21,10 +23,8 @@ class TestRequest(BaseMixin):
     def setUpClass(cls):
         cls.selfSigned = spoof.SelfSignedSSLContext()
         cls.sslContext = cls.selfSigned.sslContext
-        cls.httpd = spoof.HTTPServer(sslContext=cls.sslContext)
-        cls.httpd6 = spoof.HTTPServer6("::1", sslContext=cls.sslContext)
-        cls.httpd.start()
-        cls.httpd6.start()
+        cls.httpd = spoof.HTTPServer(sslContext=cls.sslContext).start()
+        cls.httpd6 = spoof.HTTPServer6(sslContext=cls.sslContext).start()
 
     @classmethod
     def tearDownClass(cls):
@@ -146,10 +146,13 @@ class TestRequest(BaseMixin):
         self.assertEqual(request.status_code, errorResponse[0])
 
     def test_spoof_selfSigned_raises_exception_on_connect(self):
-        sslContext = spoof.SSLContext.selfSigned()
-        httpd = spoof.HTTPServer(sslContext=sslContext)
-        with self.assertRaises(requests.ConnectionError):
-            self.session.get(httpd.url + "/random")
+        # this kind of ssl http server setup has no way to access the underlying
+        # certificate and key files. the intent is to provide a real ssl context
+        # that is untrusted and kicked back as invalid, potentially to test out
+        # implementations that trust ssl connections that should not be trusted.
+        with spoof.HTTPServer(sslContext=spoof.SSLContext.selfSigned()) as httpd:
+            with self.assertRaises(requests.exceptions.SSLError):
+                self.session.get(httpd.url)
 
     def test_spoof_allows_callable_defaultResponse(self):
         status_code = random.randint(205, 299)
@@ -213,6 +216,75 @@ class TestRequest(BaseMixin):
         self.assertEqual(expected_path, response.text)
         self.assertEqual(expected_path, self.httpd.requests[-1].path)
 
+    def test_large_batch_queued_responses(self):
+        batchSize = 1_000
+        responses = [
+            [200, [("Content-Type", "application/json")], f'{{"seq": {seq}}}']
+            for seq in range(batchSize)
+        ]
+        with spoof.HTTPServer() as httpd:
+            httpd.responses.extend(responses)
+            for seq in range(batchSize):
+                self.assertEqual({"seq": seq}, requests.get(httpd.url).json())
+            self.assertEqual(batchSize, len(httpd.requests))
+
+    def test_large_batch_generated_responses(self):
+        def responseGenerator():
+            for seq in itertools.count():
+                yield [200, [("Content-Type", "application/json")], json.dumps({"seq": seq})]
+
+        with spoof.HTTPServer() as httpd:
+            batchSize = 1_000
+            response = responseGenerator()
+            httpd.defaultResponse = lambda request: next(response)
+            for seq in range(batchSize):
+                self.assertEqual({"seq": seq}, self.session.get(httpd.url).json())
+            self.assertEqual(batchSize, len(httpd.requests))
+
+    def test_attrs_return_None_if_server_is_unbound(self):
+        httpd = spoof.HTTPServer()
+        self.assertIsNone(httpd.server)
+        self.assertIsNone(httpd.address)
+        self.assertIsNone(httpd.port)
+        self.assertIsNone(httpd.url)
+
+    def test_changing_sslContext_and_restarting(self):
+        expected = "set-sslcontext-live"
+        httpd = spoof.HTTPServer(sslContext=spoof.SSLContext.selfSigned()).start()
+        httpd.defaultResponse = [200, [], expected]
+        with self.assertRaises(requests.exceptions.SSLError):
+            requests.get(httpd.url)
+
+        httpd.sslContext = self.selfSigned.sslContext
+        httpd.restart()
+        result = requests.get(httpd.url, verify=self.selfSigned.certFile).text
+        self.assertTrue(httpd.url.startswith("https"))
+        self.assertEqual(expected, result)
+
+    def test_changing_serverAddress_and_restarting(self):
+        httpd = spoof.HTTPServer(host="127.0.0.1").start()
+        httpd.defaultResponse = lambda request: [200, [], request.serverName]
+
+        httpd.serverAddress = ("::1", 0)
+        httpd.restart()
+        self.assertEqual(requests.get(httpd.url).text, "::1")
+        self.assertEqual(httpd.server.socket.family, socket.AF_INET6)
+
+        httpd.serverAddress = ("127.0.0.1", 0)
+        httpd.restart()
+        self.assertEqual(requests.get(httpd.url).text, "127.0.0.1")
+        self.assertEqual(httpd.server.socket.family, socket.AF_INET)
+
+    def test_restart_returns_spoof_instance(self):
+        expected = httpd = spoof.HTTPServer()
+        result = httpd.restart()
+        self.assertEqual(expected, result)
+
+    def test_start_returns_spoof_instance(self):
+        expected = httpd = spoof.HTTPServer()
+        result = httpd.start()
+        self.assertEqual(expected, result)
+
 
 class TestProxy(BaseMixin):
     @classmethod
@@ -224,8 +296,7 @@ class TestProxy(BaseMixin):
         cls.unlink(cls.cert, cls.key)
 
     def setUp(self):
-        self.httpd = spoof.HTTPServer()
-        self.httpd.start()
+        self.httpd = spoof.HTTPServer().start()
         self.session = requests.Session()
         self.session.verify = self.cert
         self.sslContext = spoof.SSLContext.fromCertChain(self.cert, self.key)
@@ -265,16 +336,14 @@ class TestProxy(BaseMixin):
         self.assertEqual(expected, result)
 
     def test_spoof_https_site_through_https_proxy(self):
-        # https proxies for https supported in requests v2.25.0 / urllib3 v1.26
         expected = upstream_content = b"octet-comeback-squirmy"
-        httpd = spoof.HTTPServer(sslContext=self.sslContext)
+        httpd = spoof.HTTPServer(sslContext=self.sslContext).start()
         httpd.defaultResponse = [200, [], None]
-        httpd.start()
-        httpd.upstream = spoof.HTTPServer(sslContext=self.sslContext)
+        httpd.upstream = spoof.HTTPServer(sslContext=self.sslContext).start()
         httpd.upstream.defaultResponse = [200, [], upstream_content]
-        httpd.upstream.start()
-        proxies = {"https": httpd.url}
-        result = self.session.get(httpd.upstream.url, proxies=proxies).content
+
+        # https proxies for https supported in requests v2.25.0 / urllib3 v1.26
+        result = self.session.get(httpd.upstream.url, proxies={"https": httpd.url}).content
         self.assertTrue(httpd.upstream.url.startswith("https"))
         self.assertTrue(httpd.url.startswith("https"))
         self.assertEqual(expected, result)