barebones version complete

Author: RabidSheep55

.gitignore

@@ -7,3 +7,6 @@
 
 # Remove python caching
 __pycache__
+
+# Custom local build and test scripts
+test.bat

app/algorithm.py

@@ -19,4 +19,27 @@ def grading_function(body: dict) -> dict:
     to output the grading response.
     """
 
-    return {"is_correct": True, "received_body": body}
+    type_dict = {"float": float, "int": int, "str": str, "dict": dict}
+    req_type = body["params"]["type"]
+
+    # Try cast each of the inputs to their requested type:
+    errors = []
+    try:
+        res = type_dict[req_type](body["response"])
+    except ValueError as e:
+        errors += [
+            {"description": f"Could not cast `response` parameter to {req_type}"}
+        ]
+
+    try:
+        ans = type_dict[req_type](body["answer"])
+    except ValueError as e:
+        errors += [{"description": f"Could not cast `answer` parameter to {req_type}"}]
+
+    if errors:
+        return {"error": errors}
+
+    # Are they equaL?
+    is_exact_equal = res == ans
+
+    return {"is_correct": is_exact_equal}

app/schema.json

@@ -1,10 +1,18 @@
 {
-    "$schema": "http://json-schema.org/draft/2019-09/schema#",
-    "title": "Generic schema for the data passed to a grading cloud function.",
-    "type": "object",
-    "properties": {
-        "example": {"const": "property"}
-    },
-    "required": ["example"],
-    "additionalProperties": false
-}
+  "$schema": "http://json-schema.org/draft/2019-09/schema#",
+  "title": "Generic schema for the data passed to a grading cloud function.",
+  "type": "object",
+  "properties": {
+    "answer": {},
+    "response": {},
+    "params": {
+      "type": "object",
+      "properties": {
+        "type": { "enum": ["int", "float", "str", "dict"] }
+      },
+      "required": ["type"]
+    }
+  },
+  "required": ["answer", "response", "params"],
+  "additionalProperties": true
+}

app/tests/grading.py

@@ -2,30 +2,91 @@
 
 from ..algorithm import grading_function
 
+
 class TestGradingFunction(unittest.TestCase):
     """
-        TestCase Class used to test the algorithm.
-        ---
-        Tests are used here to check that the algorithm written 
-        is working as it should. 
-        
-        It's best practise to write these tests first to get a 
-        kind of 'specification' for how your algorithm should 
-        work, and you should run these tests before committing 
-        your code to AWS.
-
-        Read the docs on how to use unittest here:
-        https://docs.python.org/3/library/unittest.html
-
-        Use grading_function() to check your algorithm works 
-        as it should.
+    TestCase Class used to test the algorithm.
+    ---
+    Tests are used here to check that the algorithm written
+    is working as it should.
+
+    It's best practise to write these tests first to get a
+    kind of 'specification' for how your algorithm should
+    work, and you should run these tests before committing
+    your code to AWS.
+
+    Read the docs on how to use unittest here:
+    https://docs.python.org/3/library/unittest.html
+
+    Use grading_function() to check your algorithm works
+    as it should.
     """
-    def test_returns_is_correct_true(self):
-        body = {}
+
+    def test_evaluate_as_int(self):
+        body = {"answer": "45", "response": "45", "params": {"type": "int"}}
 
         response = grading_function(body)
 
         self.assertEqual(response.get("is_correct"), True)
+        self.assertEqual(response.get("error", False), False)
+
+    def test_invalid_int(self):
+        body = {"answer": "0", "response": "1.0", "params": {"type": "int"}}
+
+        response = grading_function(body)
+
+        self.assertIsNotNone(response.get("error", None))
+
+    def test_evaluate_as_float(self):
+        body = {"answer": "4.80", "response": "4.8", "params": {"type": "float"}}
+
+        response = grading_function(body)
+
+        self.assertEqual(response.get("is_correct"), True)
+        self.assertEqual(response.get("error", False), False)
+
+    def test_invalid_float(self):
+        body = {"answer": "abc", "response": "1", "params": {"type": "int"}}
+
+        response = grading_function(body)
+
+        self.assertIsNotNone(response.get("error", None))
+
+    def test_evaluate_as_string(self):
+        body = {
+            "answer": "dogs",
+            "response": "dogs",
+            "params": {"type": "str"},
+        }
+
+        response = grading_function(body)
+
+        self.assertEqual(response.get("is_correct"), True)
+        self.assertEqual(response.get("error", False), False)
+
+    def test_evaluate_as_string_incorrect(self):
+        body = {
+            "answer": "1.0",
+            "response": "1",
+            "params": {"type": "str"},
+        }
+
+        response = grading_function(body)
+
+        self.assertEqual(response.get("is_correct"), False)
+
+    def test_evaluate_as_dict(self):
+        body = {
+            "answer": {"a": 1, "b": 2},
+            "response": {"b": 2, "a": 1},
+            "params": {"type": "dict"},
+        }
+
+        response = grading_function(body)
+
+        self.assertEqual(response.get("is_correct"), True)
+        self.assertEqual(response.get("error", False), False)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

app/tests/validation.py

@@ -2,47 +2,61 @@
 
 from ..tools.validate import validate_request
 
+
 class TestSchemaValidation(unittest.TestCase):
     """
-        TestCase Class used to test the schema.
-        ---
-        Tests are used here to check that the schema is able to 
-        validate and reject request bodies that would otherwise 
-        cause the program to crash.
-        
-        It's best practise to write these tests first to get a 
-        kind of 'specification' for what your schema should 
-        accept or reject, and you should run these tests before 
-        committing your code to git.
-
-        Read the docs on how to use unittest here:
-        https://docs.python.org/3/library/unittest.html
-
-        Use validate_request() to check your schema works as 
-        it should.
+    TestCase Class used to test the schema.
+    ---
+    Tests are used here to check that the schema is able to
+    validate and reject request bodies that would otherwise
+    cause the program to crash.
+
+    It's best practise to write these tests first to get a
+    kind of 'specification' for what your schema should
+    accept or reject, and you should run these tests before
+    committing your code to git.
+
+    Read the docs on how to use unittest here:
+    https://docs.python.org/3/library/unittest.html
+
+    Use validate_request() to check your schema works as
+    it should.
     """
+
     def test_empty_request_body(self):
         body = {}
 
         validation_error = validate_request(body)
 
         self.assertNotEqual(validation_error, None)
-        self.assertEqual(validation_error.get("message"), "Schema threw an error when validating the request body.")
+        self.assertEqual(
+            validation_error.get("message"),
+            "Schema threw an error when validating the request body.",
+        )
 
     def test_invalid_grading_data(self):
         body = {"hello": "world"}
 
         validation_error = validate_request(body)
 
         self.assertNotEqual(validation_error, None)
-        self.assertEqual(validation_error.get("message"), "Schema threw an error when validating the request body.")
+        self.assertEqual(
+            validation_error.get("message"),
+            "Schema threw an error when validating the request body.",
+        )
 
     def test_valid_grading_data(self):
-        body = {"example": "property"}
+        # This body will throw an error when grading, but is valid according to the schema
+        body = {
+            "answer": "1.0",
+            "response": "1",
+            "params": {"type": "int"},
+        }
 
         validation_error = validate_request(body)
 
         self.assertEqual(validation_error, None)
 
+
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()