aws_test.go

// +build Aws all

package test

import (
	"encoding/base64"
	"fmt"
	"net/url"
	"path"
	"strings"
	"testing"
	"time"

	"github.com/aws/aws-sdk-go/aws"
	"github.com/aws/aws-sdk-go/aws/session"
	"github.com/aws/aws-sdk-go/service/ec2"
	"github.com/pulumi/pulumi/pkg/v3/testing/integration"
	"github.com/pulumi/pulumi/sdk/v3/go/common/resource"
	"github.com/stretchr/testify/assert"
)

func TestAccAwsGoAssumeRole(t *testing.T) {
	nanos := time.Now().UnixNano()
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-assume-role", "create-role"),
			Config: map[string]string{
				"create-role:unprivilegedUsername": fmt.Sprintf("unpriv-go-%d", nanos),
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoEks(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-eks"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["url"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello Kubernetes bootcamp!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoFargate(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-fargate"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["url"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Welcome to nginx!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoS3FolderComponent(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-s3-folder-component"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["websiteUrl"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello, world!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoWebserver(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-webserver"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["publicIp"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello, World!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsCsAssumeRole(t *testing.T) {
	nanos := time.Now().UnixNano()
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-cs-assume-role", "create-role"),
			Config: map[string]string{
				"create-role:unprivilegedUsername": fmt.Sprintf("unpriv-cs-%d", nanos),
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsJsContainers(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-js-containers"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["frontendURL"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello, Pulumi!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsJsS3FolderComponent(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-js-s3-folder-component"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				assertHTTPResult(t, stack.Outputs["websiteUrl"].(string), nil, func(body string) bool {
					return assert.Contains(t, body, "Hello, Pulumi!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsJsSqsSlack(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-js-sqs-slack"),
			Config: map[string]string{
				"slackToken": "token",
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsJsWebserver(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-js-webserver"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				assertHTTPHelloWorld(t, stack.Outputs["publicHostName"], nil)
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsJsWebserverComponent(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-js-webserver-component"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				assertHTTPHelloWorld(t, stack.Outputs["webUrl"], nil)
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsPyAppSync(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-py-appsync"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoAppSync(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-appsync"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 8 * time.Minute

				endpoint := stack.Outputs["endpoint"].(string)
				mutation := "mutation AddTenant { addTenant(id: \"123\", name: \"FirstCorp\") { id name } }"

				finalURL := fmt.Sprintf("%s?query=%s", endpoint, url.QueryEscape(mutation))

				key := stack.Outputs["key"].(string)
				headersMap := map[string]string{
					"Content-Type": "application/graphql",
					"x-api-key":    key,
				}

				assertHTTPResultShapeWithRetry(t, finalURL, headersMap, maxWait, func(body string) bool {
					return !strings.Contains(body, "AccessDeniedException")
				}, func(body string) bool {
					return assert.Contains(t, body, "FirstCorp")
				})
			},
		})
	integration.ProgramTest(t, &test)
}

func TestAccAwsPyAssumeRole(t *testing.T) {
	nanos := time.Now().UnixNano()
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-py-assume-role", "create-role"),
			Config: map[string]string{
				"create-role:unprivilegedUsername": fmt.Sprintf("unpriv-py-%d", nanos),
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsPyResources(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-py-resources"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsGoResources(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-go-resources"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsPyStepFunctions(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-py-stepfunctions"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsPyWebserver(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-py-webserver"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				assertHTTPResult(t, "http:https://"+stack.Outputs["public_dns"].(string), nil, func(body string) bool {
					return assert.Contains(t, body, "Hello, World!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsAirflow(t *testing.T) {
	t.Skip("Skip due to failures initializing 20(!) instances")
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-airflow"),
			Config: map[string]string{
				"airflow:dbPassword": "secretP4ssword",
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsApiGateway(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-apigateway"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["endpoint"].(string)
				assertHTTPResultWithRetry(t, endpoint+"hello", nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "route")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsAppSync(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-appsync"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsAssumeRole(t *testing.T) {
	nanos := time.Now().UnixNano()
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-assume-role", "create-role"),
			Config: map[string]string{
				"create-role:unprivilegedUsername": fmt.Sprintf("unpriv-%d", nanos),
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsContainers(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-containers"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 15 * time.Minute
				endpoint := stack.Outputs["frontendURL"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello, Pulumi!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsEc2Provisioners(t *testing.T) {
	sess, err := session.NewSession(&aws.Config{
		Region: aws.String(getAwsRegion())},
	)
	assert.NoError(t, err)
	svc := ec2.New(sess)
	keyName, err := resource.NewUniqueHex("test-keyname", 8, 20)
	assert.NoError(t, err)
	t.Logf("Creating keypair %s.\n", keyName)
	key, err := svc.CreateKeyPair(&ec2.CreateKeyPairInput{
		KeyName: aws.String(keyName),
	})
	assert.NoError(t, err)
	defer func() {
		t.Logf("Deleting keypair %s.\n", keyName)
		_, err := svc.DeleteKeyPair(&ec2.DeleteKeyPairInput{
			KeyName: aws.String(keyName),
		})
		assert.NoError(t, err)
	}()
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-ec2-provisioners"),
			Config: map[string]string{
				"keyName": aws.StringValue(key.KeyName),
			},
			Secrets: map[string]string{
				"privateKey": base64.StdEncoding.EncodeToString([]byte(aws.StringValue(key.KeyMaterial))),
			},
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				catConfigStdout := stack.Outputs["catConfigStdout"].(string)
				assert.Equal(t, "[test]\nx = 42\n", catConfigStdout)
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsEks(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-eks"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsEksHelloWorld(t *testing.T) {
	t.Skip("Skip due to frequent failures: `timeout while waiting for state to become 'ACTIVE'`")
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-eks-hello-world"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["serviceHostname"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Welcome to nginx")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsHelloFargate(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-hello-fargate"),
			ExtraRuntimeValidation: func(t *testing.T, stack integration.RuntimeValidationStackInfo) {
				maxWait := 10 * time.Minute
				endpoint := stack.Outputs["url"].(string)
				assertHTTPResultWithRetry(t, endpoint, nil, maxWait, func(body string) bool {
					return assert.Contains(t, body, "Hello World!")
				})
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsPulumiWebhooks(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-pulumi-webhooks"),
			Config: map[string]string{
				"cloud:provider":                      "aws",
				"aws-ts-pulumi-webhooks:slackChannel": "general",
				"aws-ts-pulumi-webhooks:slackWebhook": "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX",
			},
			// TODO[pulumi/examples#859]: Currently this examples leads to a no-op preview diff of:
			//   ~  aws:apigateway:RestApi pulumi-webhook-handler update [diff: ~binaryMediaTypes]
			//   ++ aws:apigateway:Deployment pulumi-webhook-handler create replacement [diff: ~variables]
			//   +- aws:apigateway:Deployment pulumi-webhook-handler replace [diff: ~variables]
			//   ++ aws:lambda:Permission pulumi-webhook-handler-fa520765 create replacement [diff: ~sourceArn]
			//   +- aws:lambda:Permission pulumi-webhook-handler-fa520765 replace [diff: ~sourceArn]
			//   ++ aws:lambda:Permission pulumi-webhook-handler-c171fd88 create replacement [diff: ~sourceArn]
			//   +- aws:lambda:Permission pulumi-webhook-handler-c171fd88 replace [diff: ~sourceArn]
			//   ~  aws:apigateway:Stage pulumi-webhook-handler update [diff: ~deployment]
			//   -- aws:lambda:Permission pulumi-webhook-handler-fa520765 delete original [diff: ~sourceArn]
			//   -- aws:lambda:Permission pulumi-webhook-handler-c171fd88 delete original [diff: ~sourceArn]
			//   -- aws:apigateway:Deployment pulumi-webhook-handler delete original [diff: ~variables]
			AllowEmptyPreviewChanges: true,
			AllowEmptyUpdateChanges:  true,
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsPulumiMiniflux(t *testing.T) {
	t.Skip("Skip until ECS Service supports custom timeouts")
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-pulumi-miniflux"),
			Config: map[string]string{
				"aws-ts-pulumi-miniflux:db_name":        "miniflux",
				"aws-ts-pulumi-miniflux:db_username":    "minifluxuser",
				"aws-ts-pulumi-miniflux:db_password":    "2Password2",
				"aws-ts-pulumi-miniflux:admin_username": "adminuser",
				"aws-ts-pulumi-miniflux:admin_password": "2Password2",
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsResources(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-resources"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsS3LambdaCopyZip(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-s3-lambda-copyzip"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsSlackbot(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-slackbot"),
			Config: map[string]string{
				"mentionbot:slackToken":        "XXX",
				"mentionbot:verificationToken": "YYY",
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsStepFunctions(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-stepfunctions"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsThumbnailer(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-thumbnailer"),
			// TODO[pulumi/examples#859]: Currently this examples leads to a no-op preview diff of:
			//  ~  aws:lambda:Function onNewVideo update [diff: ~code]
			AllowEmptyPreviewChanges: true,
			AllowEmptyUpdateChanges:  true,
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsLambdaThumbnailer(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-lambda-thumbnailer"),
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsTwitterAthena(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-twitter-athena"),
			Config: map[string]string{
				"aws-ts-twitter-athena:twitterConsumerKey":       "12345",
				"aws-ts-twitter-athena:twitterConsumerSecret":    "xyz",
				"aws-ts-twitter-athena:twitterAccessTokenKey":    "12345",
				"aws-ts-twitter-athena:twitterAccessTokenSecret": "xyz",
				"aws-ts-twitter-athena:twitterQuery":             "smurfs",
			},
		})

	integration.ProgramTest(t, &test)
}

func TestAccAwsTsLambdaEfs(t *testing.T) {
	test := getAWSBase(t).
		With(integration.ProgramTestOptions{
			Dir: path.Join(getCwd(t), "..", "..", "aws-ts-lambda-efs"),
			// TODO[pulumi/examples#859]: Currently this examples leads to a no-op preview diff of:
			//  ++ aws:ecs:TaskDefinition nginx create replacement [diff: ~volumes]
			//  +- aws:ecs:TaskDefinition nginx replace [diff: ~volumes]
			//  ~  aws:ecs:Service nginx update [diff: ~taskDefinition]
			//  -- aws:ecs:TaskDefinition nginx delete original [diff: ~volumes]
			AllowEmptyPreviewChanges: true,
			AllowEmptyUpdateChanges:  true,
		})

	integration.ProgramTest(t, &test)
}