added unit tests!

tests.py

@@ -0,0 +1,230 @@
+import unittest
+import uuid
+import time
+from io import BytesIO
+from unittest.mock import patch
+from MicroPie import Server
+
+
+class TestMicroPie(unittest.TestCase):
+    def setUp(self):
+        """
+        Create a fresh instance of the Server for each test and define some
+        sample endpoints on the fly.
+        """
+        self.server = Server()
+
+        # Define a simple default endpoint
+        def index():
+            return "Hello from index!"
+
+        # Define an endpoint that greets the user by name
+        def greet(name="World"):
+            return f"Hello, {name}!"
+
+        # Define an endpoint that triggers a redirect
+        def go_away():
+            return self.server.redirect("/gone")
+
+        # Define an endpoint for testing template rendering (requires a
+        # templates/greet.html file in your project for a real test).
+        def greet_template(name="World"):
+            return self.server.render_template("greet.html", name=name)
+
+        # Attach the functions to the server instance
+        self.server.index = index
+        self.server.greet = greet
+        self.server.go_away = go_away
+        self.server.greet_template = greet_template
+
+    def _start_response(self, status, headers):
+        """
+        Helper method to capture the status and headers from wsgi_app calls.
+        """
+        self._wsgi_status = status
+        self._wsgi_headers = headers
+
+    def test_index_get(self):
+        """
+        Ensure that accessing '/' via GET calls the 'index' function and
+        returns the correct body.
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/",           # Access root
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "200 OK")
+        self.assertIn("Hello from index!", body)
+
+    def test_custom_endpoint_get(self):
+        """
+        Ensure that a custom endpoint (greet) can accept query parameters
+        through GET and return the correct response.
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/greet",
+            "QUERY_STRING": "name=Alice",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "200 OK")
+        self.assertIn("Hello, Alice!", body)
+
+    def test_custom_endpoint_path_param(self):
+        """
+        Test that path parameters are used if present. For example, accessing
+        '/greet/Bob' should call greet("Bob").
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/greet/Bob",
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "200 OK")
+        self.assertIn("Hello, Bob!", body)
+
+    def test_endpoint_not_found(self):
+        """
+        Access a path that does not map to a defined method. Expect 404.
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/does_not_exist",
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "404 Not Found")
+        self.assertIn("404 Not Found", body)
+
+    def test_post_request(self):
+        """
+        Test handling of a POST request with form data in the body.
+        """
+        post_body = "name=Charlie"
+        environ = {
+            "REQUEST_METHOD": "POST",
+            "PATH_INFO": "/greet",
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(post_body.encode("utf-8")),
+            "CONTENT_LENGTH": str(len(post_body)),
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "200 OK")
+        self.assertIn("Hello, Charlie!", body)
+
+    def test_redirect(self):
+        """
+        Test that an endpoint can return a 302 redirect.
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/go_away",   # Calls the go_away function
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        # MicroPie returns (302, <html>...) so we expect status to be "302 Found"
+        self.assertEqual(self._wsgi_status, "302 Found")
+        self.assertIn("url=/gone", body)   # Basic check that the redirect body is correct
+
+    def test_session_creation(self):
+        """
+        Test that a session is created if no session cookie is present.
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/",
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+            # No HTTP_COOKIE -> expect new session
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        _ = b"".join(response).decode()
+
+        # Find the Set-Cookie header among the WSGI headers
+        set_cookie_headers = [h for h in self._wsgi_headers if h[0] == 'Set-Cookie']
+        self.assertTrue(set_cookie_headers, "Expected a Set-Cookie header for new session.")
+
+        # The session should be stored in self.server.sessions
+        cookie_value = set_cookie_headers[0][1]
+        session_id = cookie_value.split("=")[1].split(";")[0]
+        self.assertIn(session_id, self.server.sessions)
+
+    def test_session_usage(self):
+        """
+        Test that an existing session is reused if a valid session_id is provided.
+        """
+        # Create a session manually
+        session_id = str(uuid.uuid4())
+        self.server.sessions[session_id] = {"last_access": time.time()}
+
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/",
+            "QUERY_STRING": "",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+            "HTTP_COOKIE": f"session_id={session_id}",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        _ = b"".join(response).decode()
+
+        # We should not receive a new Set-Cookie; we should reuse existing one.
+        set_cookie_headers = [h for h in self._wsgi_headers if h[0] == 'Set-Cookie']
+        self.assertFalse(set_cookie_headers, "Did not expect a new Set-Cookie header.")
+
+        # Ensure we didn't lose the session
+        self.assertIn(session_id, self.server.sessions, "Existing session should still be present.")
+
+    @unittest.skip("Requires a valid 'greet.html' in the 'templates' folder to work.")
+    def test_template_rendering(self):
+        """
+        Optional test for verifying a Jinja2 template render. This test will
+        require a 'templates/greet.html' file that references a variable 'name'.
+
+        Example 'greet.html' content:
+
+            <h1>Hello {{ name }}!</h1>
+        """
+        environ = {
+            "REQUEST_METHOD": "GET",
+            "PATH_INFO": "/greet_template",
+            "QUERY_STRING": "name=Tester",
+            "wsgi.input": BytesIO(b""),
+            "CONTENT_LENGTH": "0",
+        }
+        response = self.server.wsgi_app(environ, self._start_response)
+        body = b"".join(response).decode()
+
+        self.assertEqual(self._wsgi_status, "200 OK")
+        self.assertIn("<h1>Hello Tester!</h1>", body)
+
+
+if __name__ == '__main__':
+    unittest.main()
+