Skip to content

Mocking AWS Services with Moto

Moto is a library that allows you to easily mock out AWS services for better unit testing. It's incredibly useful when you want to test code that interacts with AWS, without actually making calls to live AWS services. This allows tests to be isolated, deterministic, fast, and cost-effective.

Why Use Moto?

While developing applications that interact with AWS services, it's often impractical to continuously hit live services for several reasons:

  1. Cost: Some AWS services can incur costs, even when used minimally during testing phases.
  2. Speed: Unit tests should be fast, but network calls are slow.
  3. Isolation: Tests should not depend on the state of external services.
  4. Deterministic: Tests should produce the same results given the same input. With moto, you can mock AWS services, making it appear as though your code is interacting with a real AWS service, while actually interacting with a mock service that moto provides. This means your tests will be faster, won't cost you anything, and won't fail due to network issues or changes in live AWS services.

Installation

To install moto, use pip: 

pip install moto

Example: Testing S3 Functionality

Here's a simple example of how you can use moto to test functionality that involves AWS S3: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
import boto3
import moto
import pytest

def test_s3_bucket_creation():
    with moto.mock_s3():
        # Given
        s3 = boto3.client("s3", region_name="us-east-1")
        bucket_name = "my-bucket"

        # When
        s3.create_bucket(Bucket=bucket_name)

        # Then
        response = s3.list_buckets()
        bucket_names = [bucket["Name"] for bucket in response["Buckets"]]
        assert bucket_name in bucket_names
In this example, we're using moto to mock the S3 service. The s3.create_bucket() call doesn't actually create a bucket in live AWS S3, but in the mocked S3 service that moto provides. Then, when we call s3.list_buckets(), it returns the bucket we just created.

This test is fast, doesn't cost anything, and doesn't require a network connection or a live AWS S3 service to run.

As you can see, moto can be a powerful tool for testing AWS service interactions in your applications.

Mocking constructs

There are generally two ways to use moto to mock AWS services: using a context manager (with) or using decorators. Here's a brief explanation and example of each:

Using a Context Manager

You can use Python's with keyword to create a context in which AWS services are mocked. When the context is exited, the mocks are automatically cleaned up. Here's an example: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import boto3
import moto

def test_s3_bucket_creation():
    with moto.mock_s3():
        s3 = boto3.client('s3', region_name='us-east-1')
        bucket_name = 'my-test-bucket'
        s3.create_bucket(Bucket=bucket_name)

        response = s3.list_buckets()
        bucket_names = [bucket['Name'] for bucket in response['Buckets']]
        assert bucket_name in bucket_names
In this example, moto.mock_s3() returns a context manager that mocks the S3 service. The with keyword starts the context, and everything indented under the with statement is within the context. AWS calls within this context are to the mock service, not the live service.

Using Decorators

You can also use moto as a decorator to mock AWS services for a specific function. Here's an example: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
import boto3
import moto

@moto.mock_s3
def test_s3_bucket_creation():
    s3 = boto3.client('s3', region_name='us-east-1')
    bucket_name = 'my-test-bucket'
    s3.create_bucket(Bucket=bucket_name)

    response = s3.list_buckets()
    bucket_names = [bucket['Name'] for bucket in response['Buckets']]
    assert bucket_name in bucket_names
In this example, the @moto.mock_s3 decorator is applied to the test_s3_bucket_creation function. This means that the S3 service is mocked for the entire duration of this function. The mock is automatically cleaned up when the function exits.

Both methods work well and can be used interchangeably. The best one to use depends on the specific needs of your test code.