Initial commit

RabidSheep55 · RabidSheep55 · commit acca9ab46abd · 2021-09-06T17:58:14.000+02:00
diff --git a/.github/workflows/build-base-image.yml b/.github/workflows/build-base-image.yml
@@ -0,0 +1,28 @@
+name: Update Base Image for AWS Lambda and push to DockerHub
+
+on:
+  workflow_dispatch:
+
+jobs:
+      
+  push_to_registry:
+    name: Build and Push to DockerHub Registry
+    runs-on: ubuntu-latest
+    
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+      
+      - name: Build and Push Base Image
+        uses: docker/build-push-action@v2
+        with:
+          file: app/tools/Dockerfile
+          context: app/
+          push: true
+          tags: ${{ secrets.DOCKER_USERNAME }}/python-lambda-question-type:testing
diff --git a/.github/workflows/test-and-deploy.yml b/.github/workflows/test-and-deploy.yml
@@ -0,0 +1,99 @@
+name: Test & Deploy Grading Script to AWS Lambda
+
+on:
+  push:
+    branches:
+    - master
+  workflow_dispatch:
+
+jobs:
+
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [ 3.8 ]
+    
+    defaults:
+      run:
+        working-directory: app/
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+    
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+        
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install flake8 pytest
+        python -m pip install -r tools/tools_requirements.txt
+        python -m pip install -r requirements.txt
+        
+    - name: Lint with flake8
+      run: |
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+        
+    - name: Test Handler functions
+      run: |
+        pytest -v tests/handling.py::TestHandlerFunction
+    - name: Test JSON schema
+      run: |
+        pytest -v tests/validation.py::TestSchemaValidation
+    - name: Test Grading functions
+      run: |
+        pytest -v tests/grading.py::TestGradingFunction
+  
+  
+  deploy:
+    name: Deploy
+    needs: test
+    runs-on: ubuntu-latest
+    environment: production
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Configure AWS credentials
+      uses: aws-actions/configure-aws-credentials@v1
+      with:
+        aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+        aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+        aws-region: eu-west-2
+
+    - name: Login to Amazon ECR
+      id: login-ecr
+      uses: aws-actions/amazon-ecr-login@v1
+
+    - name: Build, tag, and push image to Amazon ECR
+      id: build-image
+      env:
+        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+        ECR_REPOSITORY: test-boilerplate-question-type
+        IMAGE_TAG: latest
+      run: |
+        # Build docker image from algorithm, schema and requirements
+        docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG app/
+        # Push image to ECR
+        docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
+        echo "::set-output name=image::$ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG"
+
+    - name: Update lambda function image
+      env:
+        ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
+        ECR_REPOSITORY: test-boilerplate-question-type
+        LAMBDA_FUNCTION_NAME: test_question_type_boilerplate
+        IMAGE_TAG: latest
+      run: |
+        aws lambda update-function-code --function-name $LAMBDA_FUNCTION_NAME --image-uri $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,9 @@
+
+# Remove all hidden files except for gitgnore and workflow folder
+.*
+
+!.gitignore
+!.github/
+
+# Remove python caching
+__pycache__
diff --git a/app/Dockerfile b/app/Dockerfile
@@ -0,0 +1,24 @@
+# Base image that bundles AWS Lambda Python 3.8 image with some middleware functions
+FROM loumstarlearjet/python-lambda-question-type:testing
+
+# To avoid setting up the app in the global space,
+# everything is package within an /app directory.
+WORKDIR /app
+
+# Copy and install any packages/modules needed for your grading script.
+COPY requirements.txt .
+RUN pip3 install -r requirements.txt
+
+# Copy the schema needed to check the incoming data is valid
+COPY schema.json ./app/
+
+# Copy the grading and testing scripts
+COPY algorithm.py ./app/
+COPY tests/ ./app/tests/
+
+# Set permissions so files and directories can be accessed on AWS
+RUN chmod 644 $(find . -type f)
+RUN chmod 755 $(find . -type d)
+
+# The entrypoint for AWS is to invoke the handler function within the app package
+CMD ["/app/app.handler"]
diff --git a/app/__init__.py b/app/__init__.py
@@ -0,0 +1,2 @@
+from .algorithm import grading_function
+from .tools import handler, validate_request
diff --git a/app/algorithm.py b/app/algorithm.py
@@ -0,0 +1,24 @@
+def grading_function(body: dict) -> dict:
+    """
+    Function used to grade a student response.
+    ---
+    The handler function passes only one argument to grading_function(), 
+    which is a dictionary of the structure of the API request body
+    deserialised from JSON.
+
+    The output of this function is what is returned as the API response 
+    and therefore must be JSON-encodable. This is also subject to 
+    standard response specifications.
+
+    Any standard python library may be used, as well as any package 
+    available on pip (provided it is added to requirements.txt).
+
+    The way you wish to structure you code (all in this function, or 
+    split into many) is entirely up to you. All that matters are the 
+    return types and that grading_function() is the main function used 
+    to output the grading response.
+    """
+
+    return {
+        "is_correct": True
+    }
diff --git a/app/requirements.txt b/app/requirements.txt
diff --git a/app/schema.json b/app/schema.json
@@ -0,0 +1,10 @@
+{
+    "$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
+}
diff --git a/app/tests/__init__.py b/app/tests/__init__.py
@@ -0,0 +1,2 @@
+from .grading import TestGradingFunction
+from .validation import TestSchemaValidation
diff --git a/app/tests/grading.py b/app/tests/grading.py
@@ -0,0 +1,31 @@
+import unittest
+
+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.
+    """
+    def test_returns_is_correct_true(self):
+        body = {}
+
+        response = grading_function(body)
+
+        self.assertEqual(response.get("is_correct"), True)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/app/tests/handling.py b/app/tests/handling.py
@@ -0,0 +1,58 @@
+import unittest, json
+
+from pprint import pprint
+
+from ..tools.handler import handler
+
+class TestHandlerFunction(unittest.TestCase):
+    def __init__(self, methodName: str) -> None:
+        super().__init__(methodName=methodName)
+        self._response = {}
+
+    def tearDown(self) -> None:
+        pprint(self._response)
+
+        return super().tearDown()
+
+    def test_handle_bodyless_event(self):
+        event = {
+            "random": "metadata",
+            "without": "a body"
+        }
+
+        self._response = handler(event)
+        error = self._response.get("error")
+
+        self.assertEqual(error.get("message"), "LookupError: No grading data supplied in request body.")
+
+    def test_non_json_body(self):
+        event = {
+            "random": "metadata",
+            "body": "{}}}{{{[][] this is not json."
+        }
+
+        self._response = handler(event)
+        error = self._response.get("error")
+
+        self.assertEqual(error.get("message"), "JSONDecodeError: Request body is not valid JSON.")
+
+    def test_healthcheck(self):
+        body = {}
+
+        event = {
+            "random": "metadata",
+            "body": json.dumps(body),
+            "headers": {
+                "command": "healthcheck"
+            }
+        }
+
+        self._response = handler(event)
+        self.assertEqual(self._response.get("command"), "healthcheck")
+
+        result = self._response.get("result")
+        self.assertNotEqual(len(result.get("successes")), 0)
+        self.assertTrue(result.get("tests_passed"))
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/app/tests/validation.py b/app/tests/validation.py
@@ -0,0 +1,48 @@
+import unittest
+
+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.
+    """
+    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.")
+
+    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.")
+
+    def test_valid_grading_data(self):
+        body = {"example": "property"}
+
+        validation_error = validate_request(body)
+
+        self.assertEqual(validation_error, None)
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/app/tools/Dockerfile b/app/tools/Dockerfile
@@ -0,0 +1,12 @@
+# Base image is Python 3.8 provided by AWS Lambda in Docker Hub
+FROM public.ecr.aws/lambda/python:3.8
+
+WORKDIR /app
+
+# Copy and install jsonschema package
+COPY tools/tools_requirements.txt .
+RUN pip3 install -r tools_requirements.txt
+
+# Copy the scripts
+COPY __init__.py ./app/
+COPY tools/*.py ./app/tools/
diff --git a/app/tools/__init__.py b/app/tools/__init__.py
@@ -0,0 +1,2 @@
+from .handler import handler
+from .validate import validate_request
diff --git a/app/tools/handler.py b/app/tools/handler.py
diff --git a/app/tools/healthcheck.py b/app/tools/healthcheck.py
diff --git a/app/tools/tools_requirements.txt b/app/tools/tools_requirements.txt
diff --git a/app/tools/validate.py b/app/tools/validate.py
diff --git a/readme.md b/readme.md

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from .algorithm import grading_function`
	`2`	`+from .tools import handler, validate_request`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from .grading import TestGradingFunction`
	`2`	`+from .validation import TestSchemaValidation`