Merge pull request #1771 from gruntwork-io/feat/aws-acm-mock-tests

test(aws): add mock-based unit tests for 6 previously-untested modules

Author: james00012

modules/aws/acm.go

@@ -9,6 +9,13 @@ import (
 	"github.com/gruntwork-io/terratest/modules/testing"
 )
 
+// AcmAPI is the subset of *acm.Client operations used by the helpers in this file.
+// It is declared as an interface so tests can substitute a mock without an AWS
+// account. A real *acm.Client satisfies this interface automatically.
+type AcmAPI interface {
+	ListCertificates(ctx context.Context, params *acm.ListCertificatesInput, optFns ...func(*acm.Options)) (*acm.ListCertificatesOutput, error)
+}
+
 // GetAcmCertificateArnContextE gets the ACM certificate for the given domain name in the given region.
 // The ctx parameter supports cancellation and timeouts.
 func GetAcmCertificateArnContextE(t testing.TestingT, ctx context.Context, awsRegion string, certDomainName string) (string, error) {
@@ -17,7 +24,15 @@ func GetAcmCertificateArnContextE(t testing.TestingT, ctx context.Context, awsRe
 		return "", err
 	}
 
-	result, err := acmClient.ListCertificates(ctx, &acm.ListCertificatesInput{})
+	return GetAcmCertificateArnWithClientContextE(t, ctx, acmClient, certDomainName)
+}
+
+// GetAcmCertificateArnWithClientContextE gets the ACM certificate for the given domain name using
+// the provided ACM client. Useful when a pre-configured client is available or in unit tests with
+// a mock.
+// The ctx parameter supports cancellation and timeouts.
+func GetAcmCertificateArnWithClientContextE(t testing.TestingT, ctx context.Context, client AcmAPI, certDomainName string) (string, error) {
+	result, err := client.ListCertificates(ctx, &acm.ListCertificatesInput{})
 	if err != nil {
 		return "", err
 	}

modules/aws/acm_test.go

@@ -0,0 +1,95 @@
+package aws_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	awsSDK "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/acm"
+	"github.com/aws/aws-sdk-go-v2/service/acm/types"
+	"github.com/stretchr/testify/require"
+
+	aws "github.com/gruntwork-io/terratest/modules/aws"
+)
+
+// mockAcmClient is a test double for aws.AcmAPI that returns canned responses.
+type mockAcmClient struct {
+	ListCertificatesOutput *acm.ListCertificatesOutput
+	ListCertificatesErr    error
+}
+
+func (m *mockAcmClient) ListCertificates(_ context.Context, _ *acm.ListCertificatesInput, _ ...func(*acm.Options)) (*acm.ListCertificatesOutput, error) {
+	if m.ListCertificatesErr != nil {
+		return nil, m.ListCertificatesErr
+	}
+
+	return m.ListCertificatesOutput, nil
+}
+
+func TestGetAcmCertificateArnWithClientContextE(t *testing.T) {
+	t.Parallel()
+
+	const (
+		arn1    = "arn:aws:acm:us-east-1:123456789012:certificate/cert-1"
+		arn2    = "arn:aws:acm:us-east-1:123456789012:certificate/cert-2"
+		domain1 = "foo.example.com"
+		domain2 = "bar.example.com"
+	)
+
+	twoCerts := &acm.ListCertificatesOutput{
+		CertificateSummaryList: []types.CertificateSummary{
+			{DomainName: awsSDK.String(domain1), CertificateArn: awsSDK.String(arn1)},
+			{DomainName: awsSDK.String(domain2), CertificateArn: awsSDK.String(arn2)},
+		},
+	}
+
+	tests := map[string]struct {
+		client      *mockAcmClient
+		query       string
+		expectedArn string
+		expectErr   bool
+	}{
+		"returns arn when domain matches": {
+			client:      &mockAcmClient{ListCertificatesOutput: twoCerts},
+			query:       domain2,
+			expectedArn: arn2,
+		},
+		"returns first match when listed first": {
+			client:      &mockAcmClient{ListCertificatesOutput: twoCerts},
+			query:       domain1,
+			expectedArn: arn1,
+		},
+		"returns empty string when no domain matches": {
+			client:      &mockAcmClient{ListCertificatesOutput: twoCerts},
+			query:       "nonexistent.example.com",
+			expectedArn: "",
+		},
+		"returns empty string on empty list": {
+			client:      &mockAcmClient{ListCertificatesOutput: &acm.ListCertificatesOutput{}},
+			query:       domain1,
+			expectedArn: "",
+		},
+		"propagates api error": {
+			client:    &mockAcmClient{ListCertificatesErr: errors.New("AccessDenied")},
+			query:     domain1,
+			expectErr: true,
+		},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			arn, err := aws.GetAcmCertificateArnWithClientContextE(t, context.Background(), tc.client, tc.query)
+			if tc.expectErr {
+				require.Error(t, err)
+
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expectedArn, arn)
+		})
+	}
+}

modules/aws/cloudwatch.go

@@ -9,6 +9,13 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// CloudWatchLogsAPI is the subset of *cloudwatchlogs.Client operations used by the helpers in this
+// file. Declared as an interface so tests can substitute a mock; a real *cloudwatchlogs.Client
+// satisfies it automatically.
+type CloudWatchLogsAPI interface {
+	GetLogEvents(ctx context.Context, params *cloudwatchlogs.GetLogEventsInput, optFns ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetLogEventsOutput, error)
+}
+
 // GetCloudWatchLogEntriesContextE returns the CloudWatch log messages in the given region for the given log stream and log group.
 // The ctx parameter supports cancellation and timeouts.
 func GetCloudWatchLogEntriesContextE(t testing.TestingT, ctx context.Context, awsRegion string, logStreamName string, logGroupName string) ([]string, error) {
@@ -17,6 +24,13 @@ func GetCloudWatchLogEntriesContextE(t testing.TestingT, ctx context.Context, aw
 		return nil, err
 	}
 
+	return GetCloudWatchLogEntriesWithClientContextE(t, ctx, client, logStreamName, logGroupName)
+}
+
+// GetCloudWatchLogEntriesWithClientContextE returns the CloudWatch log messages for the given log
+// stream and log group using the provided CloudWatch Logs client.
+// The ctx parameter supports cancellation and timeouts.
+func GetCloudWatchLogEntriesWithClientContextE(t testing.TestingT, ctx context.Context, client CloudWatchLogsAPI, logStreamName string, logGroupName string) ([]string, error) {
 	output, err := client.GetLogEvents(ctx, &cloudwatchlogs.GetLogEventsInput{
 		LogGroupName:  aws.String(logGroupName),
 		LogStreamName: aws.String(logStreamName),

modules/aws/cloudwatch_test.go

@@ -0,0 +1,77 @@
+package aws_test
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	awsSDK "github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs"
+	"github.com/aws/aws-sdk-go-v2/service/cloudwatchlogs/types"
+	"github.com/stretchr/testify/require"
+
+	aws "github.com/gruntwork-io/terratest/modules/aws"
+)
+
+// mockCloudWatchLogsClient is a test double for aws.CloudWatchLogsAPI that returns canned responses.
+type mockCloudWatchLogsClient struct {
+	GetLogEventsOutput *cloudwatchlogs.GetLogEventsOutput
+	GetLogEventsErr    error
+}
+
+func (m *mockCloudWatchLogsClient) GetLogEvents(_ context.Context, _ *cloudwatchlogs.GetLogEventsInput, _ ...func(*cloudwatchlogs.Options)) (*cloudwatchlogs.GetLogEventsOutput, error) {
+	if m.GetLogEventsErr != nil {
+		return nil, m.GetLogEventsErr
+	}
+
+	return m.GetLogEventsOutput, nil
+}
+
+func TestGetCloudWatchLogEntriesWithClientContextE(t *testing.T) {
+	t.Parallel()
+
+	tests := map[string]struct {
+		client   *mockCloudWatchLogsClient
+		expected []string
+		wantErr  bool
+	}{
+		"returns messages preserving order": {
+			client: &mockCloudWatchLogsClient{
+				GetLogEventsOutput: &cloudwatchlogs.GetLogEventsOutput{
+					Events: []types.OutputLogEvent{
+						{Message: awsSDK.String("first line")},
+						{Message: awsSDK.String("second line")},
+						{Message: awsSDK.String("third line")},
+					},
+				},
+			},
+			expected: []string{"first line", "second line", "third line"},
+		},
+		"returns nil slice on empty events": {
+			client: &mockCloudWatchLogsClient{
+				GetLogEventsOutput: &cloudwatchlogs.GetLogEventsOutput{},
+			},
+			expected: nil,
+		},
+		"propagates api error": {
+			client:  &mockCloudWatchLogsClient{GetLogEventsErr: errors.New("ResourceNotFoundException")},
+			wantErr: true,
+		},
+	}
+
+	for name, tc := range tests {
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			got, err := aws.GetCloudWatchLogEntriesWithClientContextE(t, context.Background(), tc.client, "stream", "group")
+			if tc.wantErr {
+				require.Error(t, err)
+
+				return
+			}
+
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, got)
+		})
+	}
+}

modules/aws/dynamodb.go

@@ -10,15 +10,31 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+// DynamoDBAPI is the subset of *dynamodb.Client operations used by the helpers in this file.
+// Declared as an interface so tests can substitute a mock; a real *dynamodb.Client satisfies it
+// automatically.
+type DynamoDBAPI interface {
+	DescribeTable(ctx context.Context, params *dynamodb.DescribeTableInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DescribeTableOutput, error)
+	DescribeTimeToLive(ctx context.Context, params *dynamodb.DescribeTimeToLiveInput, optFns ...func(*dynamodb.Options)) (*dynamodb.DescribeTimeToLiveOutput, error)
+	ListTagsOfResource(ctx context.Context, params *dynamodb.ListTagsOfResourceInput, optFns ...func(*dynamodb.Options)) (*dynamodb.ListTagsOfResourceOutput, error)
+}
+
 // GetDynamoDBTableTagsContextE fetches resource tags of a specified dynamoDB table.
 // The ctx parameter supports cancellation and timeouts.
 func GetDynamoDBTableTagsContextE(t testing.TestingT, ctx context.Context, region string, tableName string) ([]types.Tag, error) {
-	table, err := GetDynamoDBTableContextE(t, ctx, region, tableName)
+	client, err := NewDynamoDBClientContextE(t, ctx, region)
 	if err != nil {
 		return nil, err
 	}
 
-	client, err := NewDynamoDBClientContextE(t, ctx, region)
+	return GetDynamoDBTableTagsWithClientContextE(t, ctx, client, tableName)
+}
+
+// GetDynamoDBTableTagsWithClientContextE fetches resource tags of a specified dynamoDB table using
+// the provided DynamoDB client.
+// The ctx parameter supports cancellation and timeouts.
+func GetDynamoDBTableTagsWithClientContextE(t testing.TestingT, ctx context.Context, client DynamoDBAPI, tableName string) ([]types.Tag, error) {
+	table, err := GetDynamoDBTableWithClientContextE(t, ctx, client, tableName)
 	if err != nil {
 		return nil, err
 	}
@@ -81,6 +97,13 @@ func GetDynamoDBTableTimeToLiveContextE(t testing.TestingT, ctx context.Context,
 		return nil, err
 	}
 
+	return GetDynamoDBTableTimeToLiveWithClientContextE(t, ctx, client, tableName)
+}
+
+// GetDynamoDBTableTimeToLiveWithClientContextE fetches the TTL configuration of a specified
+// dynamoDB table using the provided DynamoDB client.
+// The ctx parameter supports cancellation and timeouts.
+func GetDynamoDBTableTimeToLiveWithClientContextE(t testing.TestingT, ctx context.Context, client DynamoDBAPI, tableName string) (*types.TimeToLiveDescription, error) {
 	out, err := client.DescribeTimeToLive(ctx, &dynamodb.DescribeTimeToLiveInput{
 		TableName: aws.String(tableName),
 	})
@@ -124,6 +147,13 @@ func GetDynamoDBTableContextE(t testing.TestingT, ctx context.Context, region st
 		return nil, err
 	}
 
+	return GetDynamoDBTableWithClientContextE(t, ctx, client, tableName)
+}
+
+// GetDynamoDBTableWithClientContextE fetches information about the specified dynamoDB table using
+// the provided DynamoDB client.
+// The ctx parameter supports cancellation and timeouts.
+func GetDynamoDBTableWithClientContextE(t testing.TestingT, ctx context.Context, client DynamoDBAPI, tableName string) (*types.TableDescription, error) {
 	out, err := client.DescribeTable(ctx, &dynamodb.DescribeTableInput{
 		TableName: aws.String(tableName),
 	})