org.testcontainers.containers.localstack.LocalStackContainer Java Examples

static AmazonDynamoDB getDynamoDBClient() {
  // Note: each test case got to have their own dynamo client obj, can't be shared
  // Otherwise will run into connection pool issue
  return AmazonDynamoDBClientBuilder.standard()
      .withEndpointConfiguration(
          localStackContainer.getEndpointConfiguration(LocalStackContainer.Service.DYNAMODB))
      .withCredentials(localStackContainer.getDefaultCredentialsProvider())
      .build();
}
 

@Override
public AmazonS3 getClient() {
    ClientConfiguration clientConfiguration = new ClientConfiguration();
    clientConfiguration.setProtocol(Protocol.HTTP);

    return AmazonS3ClientBuilder
            .standard()
            .withEndpointConfiguration(getContainer().getEndpointConfiguration(LocalStackContainer.Service.S3))
            .withCredentials(getContainer().getDefaultCredentialsProvider())
            .withClientConfiguration(clientConfiguration)
            .build();
}
 

static void startServerClient() {
  localStackContainer.start();

  if (dynamoDBClient == null) {
    dynamoDBClient =
        AmazonDynamoDBClientBuilder.standard()
            .withEndpointConfiguration(
                localStackContainer.getEndpointConfiguration(
                    LocalStackContainer.Service.DYNAMODB))
            .withCredentials(localStackContainer.getDefaultCredentialsProvider())
            .build();
  }
}
 

@Override
public Map<String, String> start() {
    DockerClientFactory.instance().client();
    String queueUrl;
    try {
        services = new LocalStackContainer("0.11.1").withServices(Service.SQS);
        services.start();
        StaticCredentialsProvider staticCredentials = StaticCredentialsProvider
            .create(AwsBasicCredentials.create("accesskey", "secretKey"));

        client = SqsClient.builder()
            .endpointOverride(new URI(endpoint()))
            .credentialsProvider(staticCredentials)
            .httpClientBuilder(UrlConnectionHttpClient.builder())
            .region(Region.US_EAST_1).build();

        queueUrl = client.createQueue(q -> q.queueName(QUEUE_NAME)).queueUrl();
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException("Could not start localstack server", e);
    }

    Map<String, String> properties = new HashMap<>();
    properties.put("quarkus.sqs.endpoint-override", endpoint());
    properties.put("quarkus.sqs.aws.region", "us-east-1");
    properties.put("quarkus.sqs.aws.credentials.type", "static");
    properties.put("quarkus.sqs.aws.credentials.static-provider.access-key-id", "accessKey");
    properties.put("quarkus.sqs.aws.credentials.static-provider.secret-access-key", "secretKey");
    properties.put("queue.url", queueUrl);

    return properties;
}
 

@Override
public AWSSQSClient getClient() {
    AmazonSQS sqs = AmazonSQSClientBuilder
            .standard()
            .withEndpointConfiguration(getContainer()
                    .getEndpointConfiguration(LocalStackContainer.Service.SQS))
            .withCredentials(getContainer().getDefaultCredentialsProvider())
            .build();

    return new AWSSQSClient(sqs);
}
 

@Override
public Map<String, String> start() {
    DockerClientFactory.instance().client();
    try {
        dynamodb = new LocalStackContainer().withServices(Service.DYNAMODB);
        dynamodb.start();

        client = DynamoDbClient.builder()
            .endpointOverride(new URI(endpoint()))
            .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create("accesskey", "secretKey")))
            .httpClientBuilder(UrlConnectionHttpClient.builder())
            .region(Region.US_EAST_1).build();

        client.createTable(tableRequest ->
            tableRequest.tableName(TABLE_NAME)
                .keySchema(keySchema -> keySchema.attributeName("fruitName").keyType(KeyType.HASH))
                .attributeDefinitions(attrDef -> attrDef.attributeName("fruitName").attributeType(ScalarAttributeType.S))
                .provisionedThroughput(throughput -> throughput.writeCapacityUnits(1L).readCapacityUnits(1L)));
    } catch (Exception e) {
        throw new RuntimeException("Could not start Dynamodb localstack server", e);
    }

    Map<String, String> properties = new HashMap<>();
    properties.put("quarkus.dynamodb.endpoint-override", endpoint());
    properties.put("quarkus.dynamodb.aws.region", "us-east-1");
    properties.put("quarkus.dynamodb.aws.credentials.type", "static");
    properties.put("quarkus.dynamodb.aws.credentials.static-provider.access-key-id", "accessKey");
    properties.put("quarkus.dynamodb.aws.credentials.static-provider.secret-access-key", "secretKey");

    return properties;
}
 

@Override
public Map<String, String> start() {
    DockerClientFactory.instance().client();
    try {
        services = new LocalStackContainer("0.11.1").withServices(Service.SES);
        services.start();
        StaticCredentialsProvider staticCredentials = StaticCredentialsProvider
            .create(AwsBasicCredentials.create("accesskey", "secretKey"));

        client = SesClient.builder()
            .endpointOverride(new URI(endpoint()))
            .credentialsProvider(staticCredentials)
            .httpClientBuilder(UrlConnectionHttpClient.builder())
            .region(Region.US_EAST_1).build();

        client.verifyEmailIdentity(req -> req.emailAddress(FROM_EMAIL));
        client.verifyEmailIdentity(req -> req.emailAddress(TO_EMAIL));

    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException("Could not start localstack server", e);
    }

    Map<String, String> properties = new HashMap<>();
    properties.put("quarkus.ses.endpoint-override", endpoint());
    properties.put("quarkus.ses.aws.region", "us-east-1");
    properties.put("quarkus.ses.aws.credentials.type", "static");
    properties.put("quarkus.ses.aws.credentials.static-provider.access-key-id", "accessKey");
    properties.put("quarkus.ses.aws.credentials.static-provider.secret-access-key", "secretKey");

    return properties;
}
 

@Override
public AWSSQSClient getClient() {
    AmazonSQS sqs = AmazonSQSClientBuilder
            .standard()
            .withEndpointConfiguration(getContainer()
                    .getEndpointConfiguration(LocalStackContainer.Service.SQS))
            .withCredentials(getContainer().getDefaultCredentialsProvider())
            .build();

    return new AWSSQSClient(sqs);
}
 

@Override
public Map<String, String> start() {
    DockerClientFactory.instance().client();
    try {
        s3 = new LocalStackContainer().withServices(Service.S3);
        s3.start();

        client = S3Client.builder()
            .endpointOverride(new URI(endpoint()))
            .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create("accesskey", "secretKey")))
            .httpClientBuilder(UrlConnectionHttpClient.builder())
            .region(Region.US_EAST_1).build();

        client.createBucket(b -> b.bucket(BUCKET_NAME));
    } catch (Exception e) {
        throw new RuntimeException("Could not start S3 localstack server", e);
    }

    Map<String, String> properties = new HashMap<>();
    properties.put("quarkus.s3.endpoint-override", endpoint());
    properties.put("quarkus.s3.aws.region", "us-east-1");
    properties.put("quarkus.s3.aws.credentials.type", "static");
    properties.put("quarkus.s3.aws.credentials.static-provider.access-key-id", "accessKey");
    properties.put("quarkus.s3.aws.credentials.static-provider.secret-access-key", "secretKey");
    properties.put("bucket.name", BUCKET_NAME);

    return properties;
}
 

@Override
public Map<String, String> start() {
    DockerClientFactory.instance().client();
    String topicArn;
    try {
        services = new LocalStackContainer("0.11.1").withServices(Service.SNS);
        services.start();
        StaticCredentialsProvider staticCredentials = StaticCredentialsProvider
            .create(AwsBasicCredentials.create("accesskey", "secretKey"));

        client = SnsClient.builder()
            .endpointOverride(new URI(endpoint()))
            .credentialsProvider(staticCredentials)
            .httpClientBuilder(UrlConnectionHttpClient.builder())
            .region(Region.US_EAST_1).build();

        topicArn = client.createTopic(t -> t.name(TOPIC_NAME)).topicArn();
    } catch (Exception e) {
        e.printStackTrace();
        throw new RuntimeException("Could not start ocalstack server", e);
    }

    Map<String, String> properties = new HashMap<>();
    properties.put("quarkus.sns.endpoint-override", endpoint());
    properties.put("quarkus.sns.aws.region", "us-east-1");
    properties.put("quarkus.sns.aws.credentials.type", "static");
    properties.put("quarkus.sns.aws.credentials.static-provider.access-key-id", "accessKey");
    properties.put("quarkus.sns.aws.credentials.static-provider.secret-access-key", "secretKey");
    properties.put("topic.arn", topicArn);

    return properties;
}
 

@Override
public AmazonKinesis getClient() {
    ClientConfiguration clientConfiguration = new ClientConfiguration();
    clientConfiguration.setProtocol(Protocol.HTTP);

    return AmazonKinesisClientBuilder
            .standard()
            .withEndpointConfiguration(getContainer().getEndpointConfiguration(LocalStackContainer.Service.KINESIS))
            .withCredentials(getContainer().getDefaultCredentialsProvider())
            .withClientConfiguration(clientConfiguration)
            .build();
}
 

protected String getServiceEndpoint(LocalStackContainer.Service service) {
    return container
            .getEndpointConfiguration(service)
            .getServiceEndpoint();
}
 

@Override
public String getServiceEndpoint() {
    return super.getServiceEndpoint(LocalStackContainer.Service.KINESIS);
}
 

public AWSKinesisLocalContainerService() {
    super(LocalStackContainer.Service.KINESIS);
}
 

public AWSS3LocalContainerService() {
    super(LocalStackContainer.Service.S3);
}
 

protected LocalStackContainer getContainer() {
    return container;
}
 

public AWSLocalContainerService(LocalStackContainer.Service...services) {
    this.container = new LocalStackContainer().withServices(services);

    container.start();
}
 

@Override
public String getServiceEndpoint() {
    return super.getServiceEndpoint(LocalStackContainer.Service.SNS);
}
 

public AWSSNSLocalContainerService() {
    super(LocalStackContainer.Service.SQS,
            LocalStackContainer.Service.SNS);
}
 

@Override
public String getServiceEndpoint() {
    return super.getServiceEndpoint(LocalStackContainer.Service.SQS);
}
 

public AWSSQSLocalContainerService() {
    super(LocalStackContainer.Service.SQS);
}
 

@Override
public String getServiceEndpoint() {
    return super.getServiceEndpoint(LocalStackContainer.Service.S3);
}