func TestAccAWSALBListener_basic(t *testing.T) {
var conf elbv2.Listener
albName := fmt.Sprintf("testlistener-basic-%s", acctest.RandStringFromCharSet(13, acctest.CharSetAlphaNum))
targetGroupName := fmt.Sprintf("testtargetgroup-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_alb_listener.front_end",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSALBListenerDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSALBListenerConfig_basic(albName, targetGroupName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSALBListenerExists("aws_alb_listener.front_end", &conf),
resource.TestCheckResourceAttrSet("aws_alb_listener.front_end", "load_balancer_arn"),
resource.TestCheckResourceAttrSet("aws_alb_listener.front_end", "arn"),
resource.TestCheckResourceAttr("aws_alb_listener.front_end", "protocol", "HTTP"),
resource.TestCheckResourceAttr("aws_alb_listener.front_end", "port", "80"),
resource.TestCheckResourceAttr("aws_alb_listener.front_end", "default_action.#", "1"),
resource.TestCheckResourceAttr("aws_alb_listener.front_end", "default_action.0.type", "forward"),
resource.TestCheckResourceAttrSet("aws_alb_listener.front_end", "default_action.0.target_group_arn"),
),
},
},
})
}
func TestAccAWSAPIGatewayApiKey_basic(t *testing.T) {
var conf apigateway.ApiKey
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAPIGatewayApiKeyDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSAPIGatewayApiKeyConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayApiKeyExists("aws_api_gateway_api_key.test", &conf),
testAccCheckAWSAPIGatewayApiKeyStageKeyAttribute(&conf),
resource.TestCheckResourceAttr(
"aws_api_gateway_api_key.test", "name", "foo"),
resource.TestCheckResourceAttr(
"aws_api_gateway_api_key.test", "description", "Managed by Terraform"),
resource.TestCheckResourceAttrSet(
"aws_api_gateway_api_key.test", "created_date"),
resource.TestCheckResourceAttrSet(
"aws_api_gateway_api_key.test", "last_updated_date"),
),
},
},
})
}
func TestAccAWSAccessKey_encrypted(t *testing.T) {
var conf iam.AccessKeyMetadata
rName := fmt.Sprintf("test-user-%d", acctest.RandInt())
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAccessKeyDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSAccessKeyConfig_encrypted(rName, testPubAccessKey1),
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAccessKeyExists("aws_iam_access_key.a_key", &conf),
testAccCheckAWSAccessKeyAttributes(&conf),
testDecryptSecretKeyAndTest("aws_iam_access_key.a_key", testPrivKey1),
resource.TestCheckResourceAttr(
"aws_iam_access_key.a_key", "secret", ""),
resource.TestCheckResourceAttrSet(
"aws_iam_access_key.a_key", "encrypted_secret"),
resource.TestCheckResourceAttrSet(
"aws_iam_access_key.a_key", "key_fingerprint"),
),
},
},
})
}
func TestAccAWSALBListenerRule_basic(t *testing.T) {
var conf elbv2.Rule
albName := fmt.Sprintf("testrule-basic-%s", acctest.RandStringFromCharSet(13, acctest.CharSetAlphaNum))
targetGroupName := fmt.Sprintf("testtargetgroup-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_alb_listener_rule.static",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSALBListenerRuleDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSALBListenerRuleConfig_basic(albName, targetGroupName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSALBListenerRuleExists("aws_alb_listener_rule.static", &conf),
resource.TestCheckResourceAttrSet("aws_alb_listener_rule.static", "arn"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "priority", "100"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "action.#", "1"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "action.0.type", "forward"),
resource.TestCheckResourceAttrSet("aws_alb_listener_rule.static", "action.0.target_group_arn"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "condition.#", "1"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "condition.0.field", "path-pattern"),
resource.TestCheckResourceAttr("aws_alb_listener_rule.static", "condition.0.values.#", "1"),
resource.TestCheckResourceAttrSet("aws_alb_listener_rule.static", "condition.0.values.0"),
),
},
},
})
}
func TestAccDataSourceAWSALBListener_https(t *testing.T) {
albName := fmt.Sprintf("testlistener-https-%s", acctest.RandStringFromCharSet(13, acctest.CharSetAlphaNum))
targetGroupName := fmt.Sprintf("testtargetgroup-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
{
Config: testAccDataSourceAWSALBListenerConfigHTTPS(albName, targetGroupName),
Check: resource.ComposeAggregateTestCheckFunc(
resource.TestCheckResourceAttrSet("data.aws_alb_listener.front_end", "load_balancer_arn"),
resource.TestCheckResourceAttrSet("data.aws_alb_listener.front_end", "arn"),
resource.TestCheckResourceAttr("data.aws_alb_listener.front_end", "protocol", "HTTPS"),
resource.TestCheckResourceAttr("data.aws_alb_listener.front_end", "port", "443"),
resource.TestCheckResourceAttr("data.aws_alb_listener.front_end", "default_action.#", "1"),
resource.TestCheckResourceAttr("data.aws_alb_listener.front_end", "default_action.0.type", "forward"),
resource.TestCheckResourceAttrSet("data.aws_alb_listener.front_end", "default_action.0.target_group_arn"),
resource.TestCheckResourceAttrSet("data.aws_alb_listener.front_end", "certificate_arn"),
resource.TestCheckResourceAttr("data.aws_alb_listener.front_end", "ssl_policy", "ELBSecurityPolicy-2015-05"),
),
},
},
})
}
func TestAccAWSALB_basic(t *testing.T) {
var conf elbv2.LoadBalancer
albName := fmt.Sprintf("testaccawsalb-basic-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_alb.alb_test",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSALBDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSALBConfig_basic(albName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSALBExists("aws_alb.alb_test", &conf),
resource.TestCheckResourceAttr("aws_alb.alb_test", "name", albName),
resource.TestCheckResourceAttr("aws_alb.alb_test", "internal", "false"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "subnets.#", "2"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "security_groups.#", "1"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.%", "1"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "tags.TestName", "TestAccAWSALB_basic"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "enable_deletion_protection", "false"),
resource.TestCheckResourceAttr("aws_alb.alb_test", "idle_timeout", "30"),
resource.TestCheckResourceAttrSet("aws_alb.alb_test", "vpc_id"),
resource.TestCheckResourceAttrSet("aws_alb.alb_test", "zone_id"),
resource.TestCheckResourceAttrSet("aws_alb.alb_test", "dns_name"),
resource.TestCheckResourceAttrSet("aws_alb.alb_test", "arn"),
),
},
},
})
}
func TestAccScalewayServer_Volumes(t *testing.T) {
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckScalewayServerDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccCheckScalewayServerVolumeConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckScalewayServerExists("scaleway_server.base"),
testAccCheckScalewayServerAttributes("scaleway_server.base"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "type", "C1"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "volume.#", "2"),
resource.TestCheckResourceAttrSet(
"scaleway_server.base", "volume.0.volume_id"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "volume.0.type", "l_ssd"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "volume.0.size_in_gb", "20"),
resource.TestCheckResourceAttrSet(
"scaleway_server.base", "volume.1.volume_id"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "volume.1.type", "l_ssd"),
resource.TestCheckResourceAttr(
"scaleway_server.base", "volume.1.size_in_gb", "30"),
),
},
},
})
}
func TestAccAWSDBInstance_basic(t *testing.T) {
var v rds.DBInstance
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSDBInstanceDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSDBInstanceConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSDBInstanceExists("aws_db_instance.bar", &v),
testAccCheckAWSDBInstanceAttributes(&v),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "allocated_storage", "10"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "engine", "mysql"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "license_model", "general-public-license"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "instance_class", "db.t1.micro"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "name", "baz"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "username", "foo"),
resource.TestCheckResourceAttr(
"aws_db_instance.bar", "parameter_group_name", "default.mysql5.6"),
resource.TestCheckResourceAttrSet("aws_db_instance.bar", "hosted_zone_id"),
),
},
},
})
}
func TestAccAWSElasticacheReplicationGroup_redisClusterInVpc2(t *testing.T) {
var rg elasticache.ReplicationGroup
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSElasticacheReplicationDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSElasticacheReplicationGroupRedisClusterInVPCConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSElasticacheReplicationGroupExists("aws_elasticache_replication_group.bar", &rg),
resource.TestCheckResourceAttr(
"aws_elasticache_replication_group.bar", "number_cache_clusters", "2"),
resource.TestCheckResourceAttr(
"aws_elasticache_replication_group.bar", "automatic_failover_enabled", "true"),
resource.TestCheckResourceAttr(
"aws_elasticache_replication_group.bar", "snapshot_window", "02:00-03:00"),
resource.TestCheckResourceAttr(
"aws_elasticache_replication_group.bar", "snapshot_retention_limit", "7"),
resource.TestCheckResourceAttrSet(
"aws_elasticache_replication_group.bar", "configuration_endpoint_address"),
),
},
},
})
}
func TestAccAWSAPIGatewayDeployment_basic(t *testing.T) {
var conf apigateway.Deployment
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAPIGatewayDeploymentDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSAPIGatewayDeploymentConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayDeploymentExists("aws_api_gateway_deployment.test", &conf),
resource.TestCheckResourceAttr(
"aws_api_gateway_deployment.test", "stage_name", "test"),
resource.TestCheckResourceAttr(
"aws_api_gateway_deployment.test", "description", "This is a test"),
resource.TestCheckResourceAttr(
"aws_api_gateway_deployment.test", "variables.a", "2"),
resource.TestCheckResourceAttrSet(
"aws_api_gateway_deployment.test", "created_date"),
),
},
},
})
}
func TestAccAWSAPIGatewayRestApi_basic(t *testing.T) {
var conf apigateway.RestApi
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAPIGatewayRestAPIDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSAPIGatewayRestAPIConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayRestAPIExists("aws_api_gateway_rest_api.test", &conf),
testAccCheckAWSAPIGatewayRestAPINameAttribute(&conf, "bar"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "name", "bar"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "description", ""),
resource.TestCheckResourceAttrSet(
"aws_api_gateway_rest_api.test", "created_date"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "binary_media_types", ""),
),
},
{
Config: testAccAWSAPIGatewayRestAPIUpdateConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayRestAPIExists("aws_api_gateway_rest_api.test", &conf),
testAccCheckAWSAPIGatewayRestAPINameAttribute(&conf, "test"),
testAccCheckAWSAPIGatewayRestAPIDescriptionAttribute(&conf, "test"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "name", "test"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "description", "test"),
resource.TestCheckResourceAttrSet(
"aws_api_gateway_rest_api.test", "created_date"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "binary_media_types.#", "1"),
resource.TestCheckResourceAttr(
"aws_api_gateway_rest_api.test", "binary_media_types.0", "application/octet-stream"),
),
},
},
})
}
func TestAccAWSDataSourceIAMServerCertificate_basic(t *testing.T) {
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckIAMServerCertificateDestroy,
Steps: []resource.TestStep{
{
Config: testAccAwsDataIAMServerCertConfig,
Check: resource.ComposeTestCheckFunc(
resource.TestCheckResourceAttrSet("aws_iam_server_certificate.test_cert", "arn"),
resource.TestCheckResourceAttrSet("data.aws_iam_server_certificate.test", "arn"),
resource.TestCheckResourceAttrSet("data.aws_iam_server_certificate.test", "name"),
resource.TestCheckResourceAttrSet("data.aws_iam_server_certificate.test", "path"),
),
},
},
})
}
func TestAccScalewayDataSourceImage_Basic(t *testing.T) {
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccCheckScalewayImageConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckImageID("data.scaleway_image.ubuntu"),
resource.TestCheckResourceAttr("data.scaleway_image.ubuntu", "architecture", "arm"),
resource.TestCheckResourceAttr("data.scaleway_image.ubuntu", "public", "true"),
resource.TestCheckResourceAttrSet("data.scaleway_image.ubuntu", "organization"),
resource.TestCheckResourceAttrSet("data.scaleway_image.ubuntu", "creation_date"),
),
},
},
})
}
func TestAccAWSLightsailKeyPair_nameprefix(t *testing.T) {
var conf1, conf2 lightsail.KeyPair
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSLightsailKeyPairDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSLightsailKeyPairConfig_prefixed(),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSLightsailKeyPairExists("aws_lightsail_key_pair.lightsail_key_pair_test_omit", &conf1),
testAccCheckAWSLightsailKeyPairExists("aws_lightsail_key_pair.lightsail_key_pair_test_prefixed", &conf2),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test_omit", "name"),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test_prefixed", "name"),
),
},
},
})
}
func TestAccAWSUserLoginProfile_keybase(t *testing.T) {
var conf iam.GetLoginProfileOutput
username := fmt.Sprintf("test-user-%d", acctest.RandInt())
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSUserLoginProfileDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSUserLoginProfileConfig(username, "/", "keybase:terraformacctest"),
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSUserLoginProfileExists("aws_iam_user_login_profile.user", &conf),
resource.TestCheckResourceAttrSet("aws_iam_user_login_profile.user", "encrypted_password"),
resource.TestCheckResourceAttrSet("aws_iam_user_login_profile.user", "key_fingerprint"),
),
},
},
})
}
func TestAccAWSElasticacheCluster_basic(t *testing.T) {
var ec elasticache.CacheCluster
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSElasticacheClusterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSElasticacheClusterConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSElasticacheSecurityGroupExists("aws_elasticache_security_group.bar"),
testAccCheckAWSElasticacheClusterExists("aws_elasticache_cluster.bar", &ec),
resource.TestCheckResourceAttr(
"aws_elasticache_cluster.bar", "cache_nodes.0.id", "0001"),
resource.TestCheckResourceAttrSet("aws_elasticache_cluster.bar", "configuration_endpoint"),
resource.TestCheckResourceAttrSet("aws_elasticache_cluster.bar", "cluster_address"),
),
},
},
})
}
func TestAccAWSAPIGatewayDomainName_basic(t *testing.T) {
var conf apigateway.DomainName
// Our test cert is for a wildcard on this domain
uniqueId := resource.UniqueId()
name := fmt.Sprintf("%s.tf-acc.invalid", uniqueId)
nameModified := fmt.Sprintf("test-acc.%s.tf-acc.invalid", uniqueId)
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAPIGatewayDomainNameDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSAPIGatewayDomainNameConfigCreate(name),
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayDomainNameExists("aws_api_gateway_domain_name.test", &conf),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_body", testAccAWSAPIGatewayCertBody),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_chain", testAccAWSAPIGatewayCertChain),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_name", "tf-acc-apigateway-domain-name"),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_private_key", testAccAWSAPIGatewayCertPrivateKey),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "domain_name", name),
resource.TestCheckResourceAttrSet("aws_api_gateway_domain_name.test", "certificate_upload_date"),
),
},
{
Config: testAccAWSAPIGatewayDomainNameConfigUpdate(name),
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSAPIGatewayDomainNameExists("aws_api_gateway_domain_name.test", &conf),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_body", testAccAWSAPIGatewayCertBody),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_chain", testAccAWSAPIGatewayCertChain),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_name", "tf-acc-apigateway-domain-name"),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "certificate_private_key", testAccAWSAPIGatewayCertPrivateKey),
resource.TestCheckResourceAttr("aws_api_gateway_domain_name.test", "domain_name", nameModified),
resource.TestCheckResourceAttrSet("aws_api_gateway_domain_name.test", "certificate_upload_date"),
),
},
},
})
}
func TestAccAWSLightsailKeyPair_basic(t *testing.T) {
var conf lightsail.KeyPair
lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSLightsailKeyPairDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSLightsailKeyPairConfig_basic(lightsailName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSLightsailKeyPairExists("aws_lightsail_key_pair.lightsail_key_pair_test", &conf),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test", "arn"),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test", "fingerprint"),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test", "public_key"),
resource.TestCheckResourceAttrSet("aws_lightsail_key_pair.lightsail_key_pair_test", "private_key"),
),
},
},
})
}
func TestAccAWSALBTargetGroup_basic(t *testing.T) {
var conf elbv2.TargetGroup
targetGroupName := fmt.Sprintf("test-target-group-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_alb_target_group.test",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSALBTargetGroupDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSALBTargetGroupConfig_basic(targetGroupName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSALBTargetGroupExists("aws_alb_target_group.test", &conf),
resource.TestCheckResourceAttrSet("aws_alb_target_group.test", "arn"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "name", targetGroupName),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "port", "443"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "protocol", "HTTPS"),
resource.TestCheckResourceAttrSet("aws_alb_target_group.test", "vpc_id"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "deregistration_delay", "200"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "stickiness.#", "1"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "stickiness.0.enabled", "true"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "stickiness.0.type", "lb_cookie"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "stickiness.0.cookie_duration", "10000"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.#", "1"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.path", "/health"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.interval", "60"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.port", "8081"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.protocol", "HTTP"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.timeout", "3"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.healthy_threshold", "3"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.unhealthy_threshold", "3"),
resource.TestCheckResourceAttr("aws_alb_target_group.test", "health_check.0.matcher", "200-299"),
),
},
},
})
}
func TestAccAWSLightsailInstance_basic(t *testing.T) {
var conf lightsail.Instance
lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_lightsail_instance.lightsail_instance_test",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSLightsailInstanceDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSLightsailInstanceConfig_basic(lightsailName),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),
resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),
resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),
resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),
resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),
),
},
},
})
}
func TestAccAWSALB_generatedName(t *testing.T) {
var conf elbv2.LoadBalancer
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
IDRefreshName: "aws_alb.alb_test",
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSALBDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSALBConfig_generatedName(),
Check: resource.ComposeAggregateTestCheckFunc(
testAccCheckAWSALBExists("aws_alb.alb_test", &conf),
resource.TestCheckResourceAttrSet("aws_alb.alb_test", "name"),
),
},
},
})
}
func TestAccPostgresqlDatabase_DefaultOwner(t *testing.T) {
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckPostgresqlDatabaseDestroy,
Steps: []resource.TestStep{
{
Config: testAccPostgreSQLDatabaseConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckPostgresqlDatabaseExists("postgresql_database.mydb_default_owner"),
resource.TestCheckResourceAttr(
"postgresql_database.mydb_default_owner", "name", "mydb_default_owner"),
resource.TestCheckResourceAttrSet(
"postgresql_database.mydb_default_owner", "owner"),
),
},
},
})
}
func TestAccAWSAutoScalingGroup_autoGeneratedName(t *testing.T) {
asgNameRegexp := regexp.MustCompile("^tf-asg-")
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSAutoScalingGroupDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSAutoScalingGroupConfig_autoGeneratedName,
Check: resource.ComposeTestCheckFunc(
resource.TestMatchResourceAttr(
"aws_autoscaling_group.bar", "name", asgNameRegexp),
resource.TestCheckResourceAttrSet(
"aws_autoscaling_group.bar", "arn"),
),
},
},
})
}
func TestAccAWSRole_basic(t *testing.T) {
var conf iam.GetRoleOutput
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSRoleDestroy,
Steps: []resource.TestStep{
{
Config: testAccAWSRoleConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSRoleExists("aws_iam_role.role", &conf),
testAccCheckAWSRoleAttributes(&conf),
resource.TestCheckResourceAttrSet(
"aws_iam_role.role", "create_date",
),
),
},
},
})
}
func TestAccAWSVpc_basic(t *testing.T) {
var vpc ec2.Vpc
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckVpcDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccVpcConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckVpcExists("aws_vpc.foo", &vpc),
testAccCheckVpcCidr(&vpc, "10.1.0.0/16"),
resource.TestCheckResourceAttr(
"aws_vpc.foo", "cidr_block", "10.1.0.0/16"),
resource.TestCheckResourceAttrSet(
"aws_vpc.foo", "default_route_table_id"),
),
},
},
})
}
func TestAccAWSRDSCluster_basic(t *testing.T) {
var v rds.DBCluster
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckAWSClusterDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccAWSClusterConfig(acctest.RandInt()),
Check: resource.ComposeTestCheckFunc(
testAccCheckAWSClusterExists("aws_rds_cluster.default", &v),
resource.TestCheckResourceAttr(
"aws_rds_cluster.default", "storage_encrypted", "false"),
resource.TestCheckResourceAttr(
"aws_rds_cluster.default", "db_cluster_parameter_group_name", "default.aurora5.6"),
resource.TestCheckResourceAttrSet(
"aws_rds_cluster.default", "reader_endpoint"),
),
},
},
})
}
func TestAccRancherRegistrationToken(t *testing.T) {
var registrationToken rancherClient.RegistrationToken
resource.Test(t, resource.TestCase{
PreCheck: func() { testAccPreCheck(t) },
Providers: testAccProviders,
CheckDestroy: testAccCheckRancherRegistrationTokenDestroy,
Steps: []resource.TestStep{
resource.TestStep{
Config: testAccRancherRegistrationTokenConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckRancherRegistrationTokenExists("rancher_registration_token.foo", ®istrationToken),
resource.TestCheckResourceAttr(
"rancher_registration_token.foo", "name", "foo"),
resource.TestCheckResourceAttr(
"rancher_registration_token.foo", "description", "Terraform acc test group"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "command"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "registration_url"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "token"),
),
},
resource.TestStep{
Config: testAccRancherRegistrationTokenUpdateConfig,
Check: resource.ComposeTestCheckFunc(
testAccCheckRancherRegistrationTokenExists("rancher_registration_token.foo", ®istrationToken),
resource.TestCheckResourceAttr(
"rancher_registration_token.foo", "name", "foo-u"),
resource.TestCheckResourceAttr(
"rancher_registration_token.foo", "description", "Terraform acc test group-u"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "command"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "registration_url"),
resource.TestCheckResourceAttrSet("rancher_registration_token.foo", "token"),
),
},
},
})
}