Category: Aws

Mocking AWS SSM with Jest and TypeScript

March 29th, 2023

Reading Time: < 1 minutes

Let’s say you have this code that uses SSM:

import { SSM } from 'aws-sdk';

const getSecureParameter = async (paramName: string): Promise<string | undefined> => {
    if (paramName.startsWith('/wrong')) throw new Error('wrong parameter');
    const ssm = new SSM();
    const secret = await ssm
        .getParameter({
            Name: paramName,
            WithDecryption: true,
        })
        .promise();
    return secret.Parameter ? secret.Parameter.Value : undefined;
};

export const getParam1 = () => getSecureParameter('/ssm/param/name/example');
export const getParam2 = () => getSecureParameter('/wrong/param');
export const getParam3 = () => getSecureParameter('/not/found/param');

To mock AWS SSM with Jest and TypeScript, you can use the AWS SDK’s mock implementation. Here’s how you can set it up:

import AWS from 'aws-sdk';
import { getParam1, getParam2, getParam3 } from '../mock';

jest.mock('aws-sdk');

const mockAws = AWS as jest.Mocked<any>;

const ssmMock = {
    getParameter: (options: AWS.SSM.Types.GetParameterRequest) => {
        return {
            promise: () => {
                switch (options.Name) {
                    case '/not/found/param': {
                        return Promise.reject(new Error('some error'));
                        break;
                    }
                    default: {
                        return Promise.resolve({
                            Parameter: {
                                Value: `mocked secret for ${options.Name}`,
                            },
                        });
                    }
                }
            },
        };
    },
};

describe('AWS SSM mock example tests', () => {
    beforeAll(() => {
        mockAws.SSM.mockImplementation(jest.fn().mockImplementation(() => ssmMock));
    });

    beforeEach(() => {
        //
    });

    it('should success when...', async () => {
        // example
        const result = await getParam1();
        expect(result).toBe('mocked secret for /ssm/param/name/example');
    });

    it('should fail due to some reason...', async () => {
        // example:
        await expect(getParam2()).rejects.toThrow(new Error('wrong parameter'));
    });

    it('should fail due to another reason...', async () => {
        // example:
        await expect(getParam3()).rejects.toThrow(new Error('some error'));
    });
});

How to use Handlebars in an AWS Lambda function

February 14th, 2023
Reading Time: 2 minutes
Handlebars is a popular templating library that can be used to generate dynamic HTML pages. You can use Handlebars in an AWS Lambda function by following these steps:
1. Create an AWS Lambda function: To start, you need to create an AWS Lambda function in which you will write your code.
2. Install Handlebars: To use Handlebars in your Lambda function, you need to install it as a dependency. You can do this by adding handlebars to the dependencies section of your project’s package.json file and running npm install.
3. Load the Handlebars library: In your Lambda function code, you need to load the Handlebars library. You can do this by including the following code:
```
const handlebars = require('handlebars');
```
1. Compile a Handlebars template: To use Handlebars, you first need to compile a Handlebars template that specifies the structure of your HTML page. You can do this by using the following code:
```
const template = handlebars.compile(`
<html>
  <head>
    <title>My Page</title>
  </head>
  <body>
    <h1>Hello, {{name}}!</h1>
  </body>
</html>
`);
```
1. Render the template: To render the template, you need to pass in an object that provides the values for the template’s variables. You can do this by using the following code:
```
const html = template({ name: 'AWS Lambda' });
```
1. Return the generated HTML: Finally, you need to return the generated HTML from your Lambda function. You can do this by including the following code:
```
exports.handler = async (event) => {
  return {
    statusCode: 200,
    headers: { 'Content-Type': 'text/html' },
    body: html,
  };
};
```
1. Deploy the function: After you have written your code, you need to deploy your Lambda function to AWS. You can do this using the AWS CLI or the AWS Management Console.
These are the basic steps for using Handlebars in an AWS Lambda function. You can customize this code to meet the specific needs of your application.
Share this:
Twitter
LinkedIn
Reddit
Email
Telegram
WhatsApp
Like this:
Like Loading…

How to write to S3 bucket from Lambda function

January 29th, 2023

Reading Time: 2 minutes

AWS Lambda functions are a great way to automate certain tasks and processes in the cloud. They can be triggered by events, such as a file upload to an S3 bucket or a message sent to an SNS topic, allowing you to execute some code in response.

In this post, we’ll show you how to write data to an S3 bucket from a Lambda function. This can be useful for a variety of tasks, such as archiving log files or uploading data to a data lake.

S3 (Simple Storage Service) is Amazon’s cloud storage solution that allows you to store and access data from anywhere in the world. Writing to an S3 bucket from a Lambda function is a simple way to store and access data in the cloud.

In this post, I’ll walk you through how to write to an S3 bucket from a Lambda function. We’ll use the AWS SDK for Node.js to access S3.

Take this example as a starting point. This is not a production-ready code, probably some tweaks for permissions will be necessary to meet your requirements.

AWS resources we need

Lambda Function
S3 Bucket
Lambda Role
Bucket Policy

The Lambda function

const AWS = require("aws-sdk");
const s3 = new AWS.S3({
    region: "us-east-1",
});
let response;

exports.lambdaHandler = async (event, context) => {
    try {
        console.log(event);
        const params = {
            Bucket: process.env.MY_BUCKET,
            Key: 'test-file.txt',
            Body: "test content"
        }
        console.log('writing to s3', params);
        const result =  await s3.putObject(params).promise();
        console.log(result);

        response = {
            'statusCode': 200,
        }
    } catch (err) {
        console.log(err);
        return err;
    }

    return response
};

The SAM template

For the sake of simplicity, we are going to use Principal: “*” which makes your bucket 100% public!

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >
  Sample SAM Template for Lambda and S3
Parameters:
  Environment:
    Type: String
    Description: Environment name. Example, staging
Resources:
  MyLambda:
    Type: AWS::Serverless::Function
    DependsOn:
      - "MyBucket"
    Properties:
      CodeUri: hello-world/
      Handler: app.lambdaHandler
      Runtime: nodejs12.x
      Environment:
        Variables:
          MY_BUCKET:
            Ref: "MyBucket"
      Role:
        Fn::GetAtt:
          - "MyLambdaRole"
          - "Arn"
    Tags:
      Name: !Sub "${Environment}-my-test-lambda"

  MyBucket:
    Type: AWS::S3::Bucket
    Properties:
      BucketName: !Sub "${Environment}-my-test-bucket"

  MyBucketPolicy:
    Type: AWS::S3::BucketPolicy
    Properties:
      PolicyDocument:
        Id: BucketPolicy
        Version: 2012-10-17
        Statement:
          - Sid: AccessAll
            Action: s3:*
            Effect: Allow
            # Beware: this makes your bucket public!
            Principal: "*"
            Resource: !Join
              - ''
              - - 'arn:aws:s3:::'
                - !Ref MyBucket
                - /*
      Bucket: !Ref MyBucket

  MyLambdaRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Statement:
          - Effect: Allow
            Action: "sts:AssumeRole"
            Principal:
              Service:
                - "lambda.amazonaws.com"
        Version: "2012-10-17"
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: MyLambdaPolicy
          PolicyDocument:
            Statement:
              - Effect: Allow
                Action: "s3:*"
                Resource:
                  - Fn::GetAtt:
                      - "MyBucket"
                      - "Arn"
            Version: "2012-10-17"

As a good practice, always receive the environment as a parameter. This way, all your resources will be easier to identify.

Deploy

Build our lambda and template. This will check also the syntax of your template

$ sam build

Only for the first time run and follow the steps:

$ sam deploy --guided

The second time and so on you can execute:

$ sam deploy --no-confirm-changeset

Clean up your test AWS resources. Delete unused lambdas, buckets, etc to keep your account organized and the most important: no extra costs

Resources

Mock AWS SDK with Jest in TypeScript

January 29th, 2023
Reading Time: 2 minutes

The AWS SDK is an incredibly powerful tool for managing resources in the cloud. But what if you want to use the SDK without having to deploy your code to AWS?

Mocking the SDK with Jest and TypeScript is a great way to quickly and easily test code that interacts with AWS services. By mocking the SDK, you can simulate requests and responses to ensure that everything works as expected.

This tutorial will walk you through how to create a mock of the AWS SDK and how to use it with Jest and TypeScript

When writing automated tests for applications that use Amazon Web Services (AWS) APIs, it can be difficult to test code that interacts with the AWS SDK. In order to make testing easier, you can use Jest in combination with TypeScript to mock the AWS SDK and simulate responses from the AWS service. This makes it possible to create reliable tests for your application without actually calling AWS APIs.

Advantages of mocking the AWS SDK
- Avoid hitting AWS services will make you save so much money, especially if you have thousands of tests. Even if you use Localstack, your project’s configuration from checking out the code until you run it will take more time.
- You tests will run faster
Disadvantages of mocking the AWS SDK
- Slow down development process
- Mocks for almost every scenario, otherwis,e it will call the real code (what we want to avoid)
Let’s see an example of how to mock the AWS SDK with Jest and TypeScript

The following code mocks two methods of SQS: receiveMessage and deleteMessage. If your code uses more methods of the AWS SDK you will have to mock all of them. Otherwise, your tests will call the real code.
```
import AWS from "aws-sdk";
jest.mock("aws-sdk");
const mockAws = AWS as jest.Mocked;

const mySQSMock = {
  receiveMessage: () => {
    return {
      promise: () =>
        Promise.resolve({
          Messages: [{ Body: "test" }],
        }),
    };
  },
  deleteMessage: () => {
    return {
      promise: () => Promise.resolve(),
    };
  },
};

describe("My test suite", () => {
  beforeAll(() => {
    mockAws.SQS.mockImplementation(jest.fn().mockImplementation(() => mySQSMock));
  });

  test("My test", async () => {
    // TBD
  });
});
```
Share this:
Twitter
LinkedIn
Reddit
Email
Telegram
WhatsApp
Like this:
Like Loading…

Category: Aws

Mocking AWS SSM with Jest and TypeScript

Share this:

Like this:

How to use Handlebars in an AWS Lambda function

Share this:

Like this:

How to write to S3 bucket from Lambda function

AWS resources we need

The Lambda function

The SAM template

Deploy

Resources

Share this:

Like this:

Mock AWS SDK with Jest in TypeScript

Advantages of mocking the AWS SDK

Disadvantages of mocking the AWS SDK

Let’s see an example of how to mock the AWS SDK with Jest and TypeScript

Share this:

Like this: