Integration testing for dotnet core APIs: Working with AWS flows

    [HttpPost("call-superhero")]
    public async Task<IActionResult> CallSuperHero(string superHeroName)
    {
        // Simulate calling a superhero
        var superHero = await superHeroRepository.GetAllSuperHeroes();
        var hero = superHero.FirstOrDefault(h => h.SuperName.Equals(superHeroName, StringComparison.InvariantCultureIgnoreCase));

        // Publish an SNS notification
        var topicArn = configuration.GetValue<string>("AWS:SnsTopicArn"); // Ensure this is configured in appsettings.json
        var message = $"Calling {hero.SuperName}! They are on their way to save the day!";
        var publishRequest = new Amazon.SimpleNotificationService.Model.PublishRequest
        {
            TopicArn = topicArn,
            Message = message,
            Subject = "Superhero Alert"
        };

        var response = await snsClient.PublishAsync(publishRequest);
        if (response.HttpStatusCode != System.Net.HttpStatusCode.OK)
        {
            return StatusCode((int)response.HttpStatusCode, "Failed to send SNS notification.");
        }

        return Ok($"Calling {hero.SuperName}! They are on their way to save the day!");
    }
    

    {
        "AWS": {
            "Region": "us-east-1",
            "SnsTopicArn": "arn:aws:sns:us-east-1:123456789012:dev-superhero-called"
        }
    }
    

    private readonly LocalStackContainer _localStackContainer =
        new LocalStackBuilder()
            .WithImage("localstack/localstack")
            .WithWaitStrategy(Wait.ForUnixContainer().UntilMessageIsLogged("Ready."))
            .WithCleanUp(true)
            .WithAutoRemove(true)
            .Build();
    

    await _localStackContainer.StartAsync();
    

    private async Task<string?> CreateSnsTopic()
    {
        var createTopicResult = await _localStackContainer.ExecAsync(
        [
            "awslocal", "sns", "create-topic", "--name", "dev-superhero-called"
        ]);

        var createTopicOutput = createTopicResult.Stdout;
        var topicArn = JsonNode.Parse(createTopicOutput)?["TopicArn"]?.ToString();
        if (string.IsNullOrEmpty(topicArn))
        {
            throw new InvalidOperationException("Failed to create SNS topic in LocalStack.");
        }

        return topicArn;
    }
    

    public LocalStackContainer LocalStackContainer => _localStackContainer;
    

    public async Task DisposeAsync()
    {
        await _localStackContainer.DisposeAsync();
    }
    

    builder.ConfigureServices(services =>
    {
        var snsClient = services.SingleOrDefault(d => d.ServiceType == typeof(IAmazonSimpleNotificationService));
        if (snsClient != null)
        {
            services.Remove(snsClient);
        }
        services.AddSingleton(GetSnsClient(new Uri(SharedFixture.LocalStackContainer.GetConnectionString())));
    });
    

    private IAmazonSimpleNotificationService GetSnsClient(Uri serviceUrl)
    {
        var credentials = new BasicAWSCredentials("keyId", "secret");
        var clientConfig = new AmazonSimpleNotificationServiceConfig
        {
            ServiceURL = serviceUrl.ToString()
        };
        return new AmazonSimpleNotificationServiceClient(credentials, clientConfig);
    }
    

    builder.ConfigureAppConfiguration((_, configBuilder) =>
    {
        Console.WriteLine($"SNS topic in config {sharedFixture.SnsTopicArn}");
        configBuilder.AddInMemoryCollection(new Dictionary<string, string>
        {
            ["SuspectServiceUrl"] = sharedFixture.SuspectServiceUrlOverride,
            ["AWS:SnsTopicArn"] = sharedFixture.SnsTopicArn
        }!);
    });
    

    [Fact(DisplayName = "CallSuperHero API raises correct SNS notification using LocalStack")]
    public async Task CallSuperHero_Raises_Correct_SNS_Notification_Using_LocalStack()
    {
        // Arrange
        var superHeroName = "Venom";
        factory.SharedFixture.SuperHeroDbContext.SuperHero.AddRange(new List<SuperHeroApiWith3rdPartyService.Data.Models.SuperHero>()
        {
            new(5, "Venom", "Eddie Brock", "Super strength, Shape-shifting, Healing factor", "San Francisco", 35),
        });
        await factory.SharedFixture.SuperHeroDbContext.SaveChangesAsync();

        // Create SQS queue and subscribe it to the SNS topic
        var queueName = "superhero-called-queue";
        var queue = await factory.SharedFixture.LocalStackContainer.ExecAsync(["awslocal", "sqs", "create-queue", "--queue-name", queueName]);
        var queueUrl = JsonNode.Parse(queue.Stdout)!["QueueUrl"]!.ToString();

        var queueAttributeResult = await factory.SharedFixture.LocalStackContainer.ExecAsync(["awslocal", "sqs", "get-queue-attributes", "--queue-url", queueUrl, "--attribute-names", "All"]);

        // Extract the QueueArn from the queue attributes
        var queueArn = JsonNode.Parse(queueAttributeResult.Stdout)!["Attributes"]!["QueueArn"]!.ToString();

        // Subscribe the SQS queue to the SNS topic
        await factory.SharedFixture.LocalStackContainer.ExecAsync(["awslocal", "sns", "subscribe", "--topic-arn", factory.SharedFixture.SnsTopicArn, "--protocol", "sqs", "--notification-endpoint", queueArn]);

        // Act
        var response = await factory.CreateClient().PostAsJsonAsync($"/SuperHero/call-superhero?superHeroName={superHeroName}", new { });

        // Assert
        response.StatusCode.Should().Be(HttpStatusCode.OK);
        var responseMessage = await response.Content.ReadAsStringAsync();
        responseMessage.Should().Contain($"Calling {superHeroName}! They are on their way to save the day!");

        // Verify SNS message was published
        var messages = await factory.SharedFixture.LocalStackContainer.ExecAsync(
        [
          "awslocal", "sqs", "receive-message", "--queue-url", queueUrl
        ]);
        var sqsMessages = JsonNode.Parse(messages.Stdout);
        var message = sqsMessages!["Messages"]![0]!["Body"]!.ToString();
        message.Should().Contain($"Calling {superHeroName}! They are on their way to save the day!");
    }