fix

Author: kumarstack55

README.md

@@ -27,7 +27,7 @@ uv run app.py
 ## Running with Modified Error Rates
 
 ```bash
-ERROR_SUCCESS_COUNT=0 ERROR_FAILURE_COUNT=100 uv run app.py
+OK_RATIO=0.9 uv run app.py
 ```
 
 ## Building the Container Image
@@ -39,7 +39,7 @@ docker compose build
 or
 
 ```bash
-docker build -t example-backend .
+docker buildx build -t example-backend .
 ```
 
 ## Running in a Container

app.py

@@ -3,59 +3,68 @@
 import random
 import os
 import logging
+import aiohttp_cors
 
-DEFAULT_ERROR_SUCCESS_COUNT = 90
-DEFAULT_ERROR_FAILURE_COUNT = 10
+DEFAULT_OK_RATIO = 0.6
 DEFAULT_PORT = 8080
 
-logging.basicConfig(level=logging.INFO)
-
 _message_factory = None
 
+logging.basicConfig(level=logging.INFO)
+
 
 class Message:
-    def __init__(self, message: str, success: bool = True):
+    def __init__(self, message: str, ok: bool):
         self._message = message
-        self._success = success
+        self._ok = ok
 
     @property
-    def success(self) -> bool:
-        return self._success
+    def ok(self) -> bool:
+        return self._ok
 
     def to_json(self) -> str:
         return json.dumps({"message": self._message})
 
 
 class MessageFactory:
-    def __init__(self, success_count: int, error_count: int):
-        self._success_rate: float = success_count / (success_count + error_count)
+    def __init__(self, ok_ratio: float):
+        self._ok_ratio: float = ok_ratio
 
     def create_message(self) -> Message:
-        if random.random() < self._success_rate:
-            return Message("ok")
+        if random.random() < self._ok_ratio:
+            return Message("good", ok=True)
         else:
-            return Message("bad", success=False)
+            return Message("bad", ok=False)
 
 
 async def index_handler(request: web.Request) -> web.Response:
     message = _message_factory.create_message()
-    if message.success:
-        return web.Response(text=message.to_json(), content_type="application/json")
-    else:
-        return web.Response(text=message.to_json(), content_type="application/json", status=500)
+    args = {"text": message.to_json()}
+    if not message.ok:
+        args["status"] = 500
+    return web.json_response(**args)
 
 
 def main():
     global _message_factory
 
-    ERROR_SUCCESS_COUNT = int(os.getenv("ERROR_SUCCESS_COUNT", DEFAULT_ERROR_SUCCESS_COUNT))
-    ERROR_FAILURE_COUNT = int(os.getenv("ERROR_FAILURE_COUNT", DEFAULT_ERROR_FAILURE_COUNT))
-    _message_factory = MessageFactory(ERROR_SUCCESS_COUNT, ERROR_FAILURE_COUNT)
+    ok_ratio = float(os.getenv("OK_RATIO", DEFAULT_OK_RATIO))
+    if not (0 <= ok_ratio <= 1):
+        raise ValueError("OK_RATIO should be between 0 and 1: {ok_ratio=}")
+    logging.info(f"{ok_ratio=}")
+    _message_factory = MessageFactory(ok_ratio)
 
     port = int(os.getenv("PORT", DEFAULT_PORT))
+    logging.info(f"{port=}")
 
     app = web.Application()
-    app.router.add_get("/", index_handler)
+    cors = aiohttp_cors.setup(app)
+    resource = cors.add(app.router.add_resource("/"))
+    cors.add(
+        resource.add_route("GET", index_handler),
+        {"*": aiohttp_cors.ResourceOptions(allow_credentials=False)},
+    )
+
     web.run_app(app, host="0.0.0.0", port=port)
 
 

pyproject.toml

@@ -5,6 +5,7 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "aiohttp-cors>=0.8.0",
     "aiohttp[speedups]>=3.11.13",
 ]
 

test_app.py

@@ -4,4 +4,4 @@
 def test_container_response():
     response = requests.get("http://localhost:8080")
     assert response.status_code == 200 or response.status_code == 500
-    assert response.json()["message"] == "ok" or response.json()["message"] == "bad"
+    assert response.json()["message"] == "good" or response.json()["message"] == "bad"

tests/test_message_factory.py

@@ -2,19 +2,19 @@
 
 
 def test_create_message_ok():
-    factory = MessageFactory(success_count=10, error_count=0)
+    factory = MessageFactory(ok_ratio=1.0)
     message = factory.create_message()
-    assert message._message == "ok"
+    assert message._message == "good"
 
 
 def test_create_message_bad():
-    factory = MessageFactory(success_count=0, error_count=10)
+    factory = MessageFactory(ok_ratio=0.0)
     message = factory.create_message()
     assert message._message == "bad"
 
 
 def test_create_message_mixed():
-    factory = MessageFactory(success_count=1, error_count=1)
+    factory = MessageFactory(ok_ratio=0.5)
     messages = [factory.create_message()._message for _ in range(100)]
-    assert "ok" in messages
+    assert "good" in messages
     assert "bad" in messages