General testing

.github/workflows/nodejs.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       matrix:
         node-version: [ 16.x]
-        directory: ['./amplify/backend/function/checkingUrl/']
+        directory: [ './src/', './amplify/backend/function/checkingUrl/']
 
     steps:
       - uses: actions/checkout@v3

.github/workflows/python-app.yml

@@ -27,16 +27,28 @@ jobs:
         working-directory: ${{ matrix.directory }}
         run: |
           python -m pip install --upgrade pip
-          pip install flake8 pytest
+          pip install flake8 pytest botocore boto3
+
           if [ -f Requirements.txt ]; then pip install -r Requirements.txt; fi
 
+      - name: Set AWS region
+        run: |
+          echo "AWS_DEFAULT_REGION=eu-west-1" >> $GITHUB_ENV
+
       - name: Lint with flake8
         working-directory: ${{ matrix.directory }}
         run: |
           flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
           flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
 
       - name: Test with pytest
+        if: matrix.directory != './amplify/backend/function/getBlogContent/'
         working-directory: ${{ matrix.directory }}
         run: |
           pytest
+
+      - name: Test with unittest
+        if: matrix.directory == './amplify/backend/function/getBlogContent/'
+        working-directory: ${{ matrix.directory }}
+        run: |
+          python -m unittest discover -s tests

amplify/backend/function/checkingUrl/src/__tests__/index.test.js

@@ -1,6 +1,139 @@
+const AWS = require('aws-sdk');
+const lambda = require('../index.js');
 
+jest.mock('aws-sdk');
 
-// Test that 1 = 1
-test('1 = 1', () => {
-    expect(1).toBe(1);
-})
+describe('Lambda Function', () => {
+  let docClientGetSpy;
+  let s3GetObjectMock;
+
+  beforeEach(() => {
+    docClientGetSpy = jest.spyOn(AWS.DynamoDB.DocumentClient.prototype, 'get').mockImplementation(() => ({
+      promise: jest.fn().mockResolvedValue({}),
+    }));
+
+    s3GetObjectMock = jest.fn().mockImplementation(() => ({
+      promise: jest.fn().mockResolvedValue({
+        Body: Buffer.from('Mocked S3 response', 'utf-8'),
+      }),
+    }));
+
+    AWS.S3.prototype.getObject = s3GetObjectMock;
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('should return expected response when data is not found in DynamoDB', async () => {
+    const event = {
+      url: 'example.com',
+      targetLanguage: { code: 'en' },
+      translationModel: { type: 'type' },
+    };
+    const expectedResponse = {
+      urlPresent: false,
+      url: 'example.com',
+      targetLanguage: { code: 'en' },
+      sourceLanguage: undefined,
+      translationModel: { type: 'type' },
+    };
+
+    docClientGetSpy.mockImplementation(() => ({
+      promise: jest.fn().mockResolvedValue({}),
+    }));
+
+    const response = await lambda.handler(event, {});
+
+    expect(response).toEqual(expectedResponse);
+    expect(docClientGetSpy).toHaveBeenCalledTimes(1);
+    expect(docClientGetSpy).toHaveBeenCalledWith({
+      TableName: process.env.TRANSLATION_TABLE_NAME,
+      Key: { URL: 'example.com[translated]-en-type' },
+    });
+  });
+
+  it('should return expected response when data is found in DynamoDB', async () => {
+    const event = {
+      url: 'example.com',
+      targetLanguage: { code: 'en' },
+      sourceLanguage: { code: 'fr' },
+      translationModel: { type: 'type' },
+    };
+    const data = {
+      Item: {
+        URL: 'example.com[translated]-en-type',
+        LHS_s3_loc: 'https://s3.amazonaws.com/bucket/lhs-key',
+        RHS_s3_loc: 'https://s3.amazonaws.com/bucket/rhs-key',
+      },
+    };
+    const lhsResponse = {
+      Body: Buffer.from('LHS content', 'utf-8'),
+    };
+    const rhsResponse = {
+      Body: Buffer.from('RHS content', 'utf-8'),
+    };
+    const expectedResponse = {
+      statusCode: 200,
+      urlPresent: true,
+      body: { lhs: 'LHS content', rhs: 'RHS content', id: 'example.com[translated]-en-type' },
+    };
+
+    docClientGetSpy.mockImplementation(() => ({
+      promise: jest.fn().mockResolvedValue(data),
+    }));
+    s3GetObjectMock.mockImplementation((params) => ({
+      promise: jest.fn().mockResolvedValue({
+        Body: params.Key === 'lhs-key' ? lhsResponse.Body : rhsResponse.Body,
+      }),
+    }));
+
+    const response = await lambda.handler(event, {});
+
+    expect(response).toEqual(expectedResponse);
+    expect(docClientGetSpy).toHaveBeenCalledTimes(1);
+    expect(docClientGetSpy).toHaveBeenCalledWith({
+      TableName: process.env.TRANSLATION_TABLE_NAME,
+      Key: { URL: 'example.com[translated]-en-type' },
+    });
+    expect(s3GetObjectMock).toHaveBeenCalledTimes(2);
+    expect(s3GetObjectMock).toHaveBeenCalledWith({ Bucket: 'bucket', Key: 'lhs-key' });
+    expect(s3GetObjectMock).toHaveBeenCalledWith({ Bucket: 'bucket', Key: 'rhs-key' });
+  });
+
+  it('should return error response when S3 getObject throws an error', async () => {
+    const event = {
+      url: 'example.com',
+      targetLanguage: { code: 'en' },
+      sourceLanguage: { code: 'fr' },
+      translationModel: { type: 'type' },
+    };
+    const data = {
+      Item: {
+        URL: 'example.com[translated]-en-type',
+        LHS_s3_loc: 'https://s3.amazonaws.com/bucket/lhs-key',
+        RHS_s3_loc: 'https://s3.amazonaws.com/bucket/rhs-key',
+      },
+    };
+    const expectedError = new Error('S3 getObject error');
+
+    docClientGetSpy.mockImplementation(() => ({
+      promise: jest.fn().mockResolvedValue(data),
+    }));
+    s3GetObjectMock.mockImplementation(() => ({
+      promise: jest.fn().mockRejectedValue(expectedError),
+    }));
+
+    const response = await lambda.handler(event, {});
+
+    expect(response.statusCode).toBe(500);
+    expect(response.body).toEqual(JSON.stringify({ error: expectedError.message }));
+    expect(docClientGetSpy).toHaveBeenCalledTimes(1);
+    expect(docClientGetSpy).toHaveBeenCalledWith({
+      TableName: process.env.TRANSLATION_TABLE_NAME,
+      Key: { URL: 'example.com[translated]-en-type' },
+    });
+    expect(s3GetObjectMock).toHaveBeenCalledTimes(1);
+    expect(s3GetObjectMock).toHaveBeenCalledWith({ Bucket: 'bucket', Key: 'lhs-key' });
+  });
+});

amplify/backend/function/getBlogContent/tests/test_module.py

@@ -0,0 +1,74 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import sys
+import os
+
+
+# Navigate to the parent directory
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+
+# Add the 'src' directory to sys.path
+src_dir = os.path.join(parent_dir, 'src')
+sys.path.append(src_dir)
+import app
+
+class TestHandler(unittest.TestCase):
+
+    @patch('app.urlopen')
+    def test_handler(self, mock_urlopen):
+        mock_response = MagicMock()
+        mock_response.status = 200  # mock a successful response
+        mock_response.read.return_value = '<div class="aws-blog-content">Content</div>'  # Mock the HTML content
+        mock_urlopen.return_value = mock_response
+        event = {'url': 'https://aws.amazon.com/blogs/training-and-certification/5-tips-for-a-successful-online-proctored-aws-certification-exam/'}
+        context = {}
+
+        result = app.handler(event, context)
+
+        # assertions will depend on the expected output of your function
+        self.assertEqual(result['statusCode'], 200)
+
+
+class TestGetTitle(unittest.TestCase):
+
+    @patch('app.urlopen')
+    def test_get_title(self, mock_urlopen):
+        # mock the response from urlopen
+        mock_response = MagicMock()
+        mock_response.read.return_value = b'<h1 class="lb-h2 blog-post-title" property="name headline">Accelerate time to business insights with the Amazon SageMaker Data Wrangler direct connection to Snowflake</h1>'
+        mock_urlopen.return_value = mock_response
+
+        title = app.getTitle('https://aws.amazon.com/blogs/machine-learning/accelerate-time-to-business-insights-with-the-amazon-sagemaker-data-wrangler-direct-connection-to-snowflake/')
+
+        self.assertEqual(title, 'Accelerate time to business insights with the Amazon SageMaker Data Wrangler direct connection to Snowflake')
+
+
+class TestGetAuthorNames(unittest.TestCase):
+
+    @patch('app.urlopen')
+    def test_get_author_names(self, mock_urlopen):
+        # mock the response from urlopen
+        mock_response = MagicMock()
+        mock_response.read.return_value = b'<span property="author" typeof="Person"><span property="name">Tingyi Li</span></span> " and " <span property="author" typeof="Person"><span property="name">Demir Catovic</span></span>'
+        mock_urlopen.return_value = mock_response
+
+        author_names = app.getAuthorNames('https://aws.amazon.com/blogs/machine-learning/deploy-a-serverless-ml-inference-endpoint-of-large-language-models-using-fastapi-aws-lambda-and-aws-cdk/')
+
+        self.assertEqual(author_names, ['Tingyi Li', 'Demir Catovic'])
+
+
+class TestParser(unittest.TestCase):
+
+    @patch('app.urlopen')
+    def test_parser(self, mock_urlopen):
+        # mock the response from urlopen
+        mock_response = MagicMock()
+        mock_response.read.return_value = b'<div class="aws-blog-content">Content</div>'
+        mock_urlopen.return_value = mock_response
+
+        content = app.parser('https://aws.amazon.com/blogs/training-and-certification/5-tips-for-a-successful-online-proctored-aws-certification-exam/')
+        self.assertEqual(content, '<div class="aws-blog-content">\n Content\n</div>\n')
+
+
+if __name__ == '__main__':
+    unittest.main()

amplify/backend/function/stepFunctionInvoker/test/test_module.py

@@ -1,5 +1,122 @@
-import pytest
+import json
+from unittest import TestCase, mock
+import os
+import sys
 
+# Navigate to the parent directory
+parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
 
-def test_init():
-    assert pytest.approx(1.0) == 1.00000001
+# Add the 'src' directory to sys.path
+src_dir = os.path.join(parent_dir, 'src')
+sys.path.append(src_dir)
+
+from index import handler
+
+
+class TestLambdaHandler(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.event = {
+            'arguments': {
+                'input': {
+                    'url': 'https://example.com',
+                    'targetLanguage': 'es',
+                    'sourceLanguage': 'en',
+                    'translationModel': 'custom'
+                }
+            }
+        }
+
+    @mock.patch('index.client')
+    def test_handler_successful_execution(self, mock_client):
+        # Mocking start_execution response
+        execution_arn = os.getenv('STEP_FUNCTION_ARN'),
+        mock_client.start_execution.return_value = {'executionArn': execution_arn}
+
+        # Mocking describe_execution response during SUCCEEDED status
+        mock_client.describe_execution.return_value = {
+            'status': 'SUCCEEDED',
+            'output': json.dumps({
+                'body': {
+                    'id': '123',
+                    'lhs': 'left',
+                    'rhs': 'right'
+                }
+            })
+        }
+
+        expected_result = {
+            'id': '123',
+            'lhs': 'left',
+            'rhs': 'right'
+        }
+
+        # Call the handler function
+        result = handler(self.event, None)
+
+        # Assertions
+        mock_client.start_execution.assert_called_once_with(
+            stateMachineArn= os.getenv('STEP_FUNCTION_ARN'),
+            input=json.dumps({
+                'url': self.event['arguments']['input']['url'],
+                'targetLanguage': self.event['arguments']['input']['targetLanguage'],
+                'sourceLanguage': self.event['arguments']['input']['sourceLanguage'],
+                'translationModel': self.event['arguments']['input']['translationModel']
+            })
+        )
+        mock_client.describe_execution.assert_called_once_with(executionArn=execution_arn)
+        self.assertEqual(result, expected_result)
+
+    @mock.patch('index.client')
+    def test_handler_failed_execution(self, mock_client):
+        # Mocking start_execution response
+        execution_arn = os.getenv('STEP_FUNCTION_ARN'),
+        mock_client.start_execution.return_value = {'executionArn': execution_arn}
+
+        # Mocking describe_execution response during FAILED status
+        mock_client.describe_execution.return_value = {'status': 'FAILED'}
+
+        # Call the handler function
+        result = handler(self.event, None)
+
+        # Assertions
+        mock_client.start_execution.assert_called_once_with(
+            stateMachineArn= os.getenv('STEP_FUNCTION_ARN'),
+            input=json.dumps({
+                'url': self.event['arguments']['input']['url'],
+                'targetLanguage': self.event['arguments']['input']['targetLanguage'],
+                'sourceLanguage': self.event['arguments']['input']['sourceLanguage'],
+                'translationModel': self.event['arguments']['input']['translationModel']
+            })
+        )
+        mock_client.describe_execution.assert_called_once_with(executionArn=execution_arn)
+        self.assertEqual(result, {'statusCode': 500, 'body': "'body'"})
+
+    @mock.patch('index.client')
+    def test_handler_client_error(self, mock_client):
+        # Mocking start_execution response without raising an error
+        mock_client.start_execution.return_value = {'executionArn': 'mock-execution-arn'}
+
+        # Mocking describe_execution response to indicate execution is still in progress
+        mock_client.describe_execution.side_effect = [
+            {'status': 'RUNNING'},  # First call returns running status
+            {'status': 'SUCCEEDED'}  # Second call returns succeeded status
+        ]
+
+        # Call the handler function
+        result = handler(self.event, None)
+
+        # Assertions
+        mock_client.start_execution.assert_called_once_with(
+            stateMachineArn=os.getenv('STEP_FUNCTION_ARN'),
+            input=json.dumps({
+                'url': self.event['arguments']['input']['url'],
+                'targetLanguage': self.event['arguments']['input']['targetLanguage'],
+                'sourceLanguage': self.event['arguments']['input']['sourceLanguage'],
+                'translationModel': self.event['arguments']['input']['translationModel']
+            })
+        )
+        mock_client.describe_execution.assert_called_with(
+            executionArn='mock-execution-arn'
+        )
+        self.assertEqual(result, {'statusCode': 500, 'body': "'body'"})