testing: remove need to pass viceroy_server around

We hide the viceroy_server by making it be an autouse
fixture on the class which lets us clean things up a fair bit.
It stands to reason that all viceroy based tests will want
a server.

Author: posborne

fastly_compute/testing.py

@@ -45,13 +45,14 @@ class ViceroyTestBase:
         @pytest.mark.integration
         class TestMyService(ViceroyTestBase):
             def test_my_endpoint(self, viceroy_server):
-                response = self.get("/my-endpoint", viceroy_server)
+                response = self.get("/my-endpoint")
                 assert response.status_code == 200
         ```
     """
 
     REQUEST_TIMEOUT = 10
     WASM_FILE = "app.wasm"  # Override this in subclasses if needed
+    server: ViceroyServer = None  # Will be set by the fixture
 
     @staticmethod
     def _find_free_port() -> int:
@@ -61,8 +62,9 @@ def _find_free_port() -> int:
             port = s.getsockname()[1]
         return port
 
-    @pytest.fixture(scope="class")
-    def viceroy_server(self) -> ViceroyServer:
+    @pytest.fixture(scope="class", autouse=True)
+    @classmethod
+    def viceroy_server(cls) -> ViceroyServer:
         """Start viceroy server for the duration of the test class.
 
         Note: This assumes the WASM file already exists. Use your build system
@@ -74,22 +76,22 @@ def viceroy_server(self) -> ViceroyServer:
         print("Starting viceroy server...")
 
         # Check if WASM file exists
-        wasm_path = Path(self.WASM_FILE)
+        wasm_path = Path(cls.WASM_FILE)
         if not wasm_path.exists():
             pytest.fail(
-                f"WASM file '{self.WASM_FILE}' not found. Please build it first."
+                f"WASM file '{cls.WASM_FILE}' not found. Please build it first."
             )
 
         # Find an available port
-        port = self._find_free_port()
+        port = cls._find_free_port()
         base_url = f"http://127.0.0.1:{port}"
         output_lines = []  # Capture all output for debugging
         output_lock = threading.Lock()
         stop_capture = threading.Event()
 
         # Start viceroy process
         process = subprocess.Popen(
-            ["viceroy", "serve", self.WASM_FILE, "--addr", f"127.0.0.1:{port}", "-v"],
+            ["viceroy", "serve", cls.WASM_FILE, "--addr", f"127.0.0.1:{port}", "-v"],
             stdout=subprocess.PIPE,
             stderr=subprocess.STDOUT,
             text=True,
@@ -147,6 +149,9 @@ def capture_output_thread():
             process=process, base_url=base_url, output_lines=output_lines
         )
 
+        # Set the server as a class attribute so methods can access it
+        cls.server = server
+
         yield server
 
         # Cleanup: stop output capture and terminate the process
@@ -159,52 +164,51 @@ def capture_output_thread():
             process.kill()
             process.wait()
 
-    def get(self, path: str, server: ViceroyServer, **kwargs) -> requests.Response:
+    def get(self, path: str, **kwargs) -> requests.Response:
         """Make a GET request to the viceroy server.
 
         Args:
             path: URL path to request
-            server: ViceroyServer instance from fixture
             **kwargs: Additional arguments passed to requests.get()
 
         Returns:
             requests.Response: The HTTP response
         """
         timeout = kwargs.pop("timeout", self.REQUEST_TIMEOUT)
-        response = requests.get(f"{server.base_url}{path}", timeout=timeout, **kwargs)
+        response = requests.get(
+            f"{self.server.base_url}{path}", timeout=timeout, **kwargs
+        )
         return response
 
-    def post(self, path: str, server: ViceroyServer, **kwargs) -> requests.Response:
+    def post(self, path: str, **kwargs) -> requests.Response:
         """Make a POST request to the viceroy server.
 
         Args:
             path: URL path to request
-            server: ViceroyServer instance from fixture
             **kwargs: Additional arguments passed to requests.post()
 
         Returns:
             requests.Response: The HTTP response
         """
         timeout = kwargs.pop("timeout", self.REQUEST_TIMEOUT)
-        response = requests.post(f"{server.base_url}{path}", timeout=timeout, **kwargs)
+        response = requests.post(
+            f"{self.server.base_url}{path}", timeout=timeout, **kwargs
+        )
         return response
 
-    def request(
-        self, method: str, path: str, server: ViceroyServer, **kwargs
-    ) -> requests.Response:
+    def request(self, method: str, path: str, **kwargs) -> requests.Response:
         """Make an HTTP request to the viceroy server.
 
         Args:
             method: HTTP method (GET, POST, PUT, DELETE, etc.)
             path: URL path to request
-            server: ViceroyServer instance from fixture
             **kwargs: Additional arguments passed to requests.request()
 
         Returns:
             requests.Response: The HTTP response
         """
         timeout = kwargs.pop("timeout", self.REQUEST_TIMEOUT)
         response = requests.request(
-            method, f"{server.base_url}{path}", timeout=timeout, **kwargs
+            method, f"{self.server.base_url}{path}", timeout=timeout, **kwargs
         )
         return response

tests/README.md

@@ -11,18 +11,18 @@ from fastly_compute.testing import ViceroyTestBase
 
 @pytest.mark.integration
 class TestMyService(ViceroyTestBase):
-    def test_endpoint(self, viceroy_server):
-        response = self.get("/test", viceroy_server)
+    def test_endpoint(self):
+        response = self.get("/test")
         assert response.status_code == 200
 ```
 
 **Prerequisites**: WASM file must exist (handled by your build system).
 
 ## Available Methods
 
-- `self.get(path, viceroy_server, **kwargs)` - GET request
-- `self.post(path, viceroy_server, **kwargs)` - POST request  
-- `self.request(method, path, viceroy_server, **kwargs)` - Any HTTP method
+- `self.get(path, **kwargs)` - GET request
+- `self.post(path, **kwargs)` - POST request  
+- `self.request(method, path, **kwargs)` - Any HTTP method
 
 ## Configuration
 

tests/test_app.py

@@ -9,23 +9,23 @@
 class TestFastlyComputeApp(ViceroyTestBase):
     """Integration tests for the Fastly Compute service functionality."""
 
-    def test_hello_endpoint(self, viceroy_server):
+    def test_hello_endpoint(self):
         """Test the hello endpoint returns expected content."""
-        response = self.get("/hello/test", viceroy_server)
+        response = self.get("/hello/test")
 
         assert response.status_code == 200
         assert response.text == "Hello test!"
 
-    def test_hello_endpoint_with_different_name(self, viceroy_server):
+    def test_hello_endpoint_with_different_name(self):
         """Test the hello endpoint with a different name parameter."""
-        response = self.get("/hello/world", viceroy_server)
+        response = self.get("/hello/world")
 
         assert response.status_code == 200
         assert response.text == "Hello world!"
 
-    def test_info_endpoint(self, viceroy_server):
+    def test_info_endpoint(self):
         """Test the info endpoint returns expected JSON with WIT data."""
-        response = self.get("/info", viceroy_server)
+        response = self.get("/info")
 
         assert response.status_code == 200
         assert response.headers.get("content-type", "").startswith("application/json")
@@ -45,27 +45,27 @@ def test_info_endpoint(self, viceroy_server):
         assert data["request_method"] == "GET"
         assert data["path_info"] == "/info"
 
-    def test_nonexistent_endpoint(self, viceroy_server):
+    def test_nonexistent_endpoint(self):
         """Test that nonexistent endpoints return 404."""
-        response = self.get("/nonexistent", viceroy_server)
+        response = self.get("/nonexistent")
 
         assert response.status_code == 404
 
-    def test_post_request_handling(self, viceroy_server):
+    def test_post_request_handling(self):
         """Test that POST requests are handled correctly."""
         # Current app.py doesn't handle POST to /api/data, so expect 404
-        response = self.post("/api/data", viceroy_server, json={"key": "value"})
+        response = self.post("/api/data", json={"key": "value"})
         assert response.status_code == 404
 
-    def test_custom_headers(self, viceroy_server):
+    def test_custom_headers(self):
         """Test requests with custom headers are processed."""
         headers = {"X-Custom-Header": "test-value"}
-        response = self.get("/info", viceroy_server, headers=headers)
+        response = self.get("/info", headers=headers)
         assert response.status_code == 200
 
-    def test_error_endpoint_handling(self, viceroy_server):
+    def test_error_endpoint_handling(self):
         """Test that the error endpoint returns 500 and triggers viceroy output display."""
-        response = self.get("/error", viceroy_server)
+        response = self.get("/error")
 
         # The endpoint should return a 500 error due to the exception
         assert response.status_code == 500

tests/test_testing.py

@@ -10,67 +10,67 @@
 class TestViceroyTestingFramework(ViceroyTestBase):
     """Tests that verify the testing framework itself works correctly."""
 
-    def test_viceroy_server_fixture_provides_server_info(self, viceroy_server):
+    def test_viceroy_server_fixture_provides_server_info(self):
         """Test that the viceroy_server fixture provides expected attributes."""
-        # Check that the fixture returns a ViceroyServer with expected attributes
-        assert hasattr(viceroy_server, "process")
-        assert hasattr(viceroy_server, "base_url")
-        assert hasattr(viceroy_server, "output_lines")
+        # Check that the fixture sets up a ViceroyServer with expected attributes
+        assert hasattr(self.server, "process")
+        assert hasattr(self.server, "base_url")
+        assert hasattr(self.server, "output_lines")
 
         # Check that base_url is properly formatted
-        assert viceroy_server.base_url.startswith("http://127.0.0.1:")
+        assert self.server.base_url.startswith("http://127.0.0.1:")
 
         # Check that output_lines contains viceroy startup output
-        assert len(viceroy_server.output_lines) > 0
+        assert len(self.server.output_lines) > 0
         listening_lines = [
-            line for line in viceroy_server.output_lines if "Listening on" in line
+            line for line in self.server.output_lines if "Listening on" in line
         ]
         assert len(listening_lines) > 0
 
-    def test_get_method_works(self, viceroy_server):
+    def test_get_method_works(self):
         """Test that the get() helper method works correctly."""
-        response = self.get("/info", viceroy_server)
+        response = self.get("/info")
 
         # Verify it returns a requests.Response object
         assert isinstance(response, requests.Response)
         assert response.status_code == 200
 
-    def test_post_method_works(self, viceroy_server):
+    def test_post_method_works(self):
         """Test that the post() helper method works correctly."""
-        response = self.post("/nonexistent", viceroy_server, json={"test": "data"})
+        response = self.post("/nonexistent", json={"test": "data"})
 
         # Verify it returns a requests.Response object
         assert isinstance(response, requests.Response)
         # POST to nonexistent endpoint should return 404
         assert response.status_code == 404
 
-    def test_request_method_works(self, viceroy_server):
+    def test_request_method_works(self):
         """Test that the request() helper method works correctly."""
-        response = self.request("GET", "/info", viceroy_server)
+        response = self.request("GET", "/info")
 
         # Verify it returns a requests.Response object
         assert isinstance(response, requests.Response)
         assert response.status_code == 200
 
-    def test_request_timeout_handling(self, viceroy_server):
+    def test_request_timeout_handling(self):
         """Test that request timeouts work correctly."""
         # Test that normal requests work with reasonable timeout
-        response = self.get("/info", viceroy_server, timeout=5.0)
+        response = self.get("/info", timeout=5.0)
         assert response.status_code == 200
 
         # Test that very short timeouts raise TimeoutError
         with pytest.raises(requests.exceptions.ReadTimeout):
-            self.get("/info", viceroy_server, timeout=0.001)
+            self.get("/info", timeout=0.001)
 
-    def test_custom_request_timeout_setting(self, viceroy_server):
+    def test_custom_request_timeout_setting(self):
         """Test that custom REQUEST_TIMEOUT class attribute works."""
         # Temporarily change the timeout
         original_timeout = self.REQUEST_TIMEOUT
         self.REQUEST_TIMEOUT = 1
 
         try:
             # This should work with 1 second timeout
-            response = self.get("/info", viceroy_server)
+            response = self.get("/info")
             assert response.status_code == 200
         finally:
             # Restore original timeout