How to use test method of instance Package

Best Syzkaller code snippet using instance.test

resource_aws_instance_test.go

Source:resource_aws_instance_test.go

...5	"reflect"6	"regexp"7	"strconv"8	"strings"9	"testing"10	"time"11	"github.com/aws/aws-sdk-go/aws"12	"github.com/aws/aws-sdk-go/aws/endpoints"13	"github.com/aws/aws-sdk-go/aws/request"14	"github.com/aws/aws-sdk-go/aws/session"15	"github.com/aws/aws-sdk-go/service/ec2"16	multierror "github.com/hashicorp/go-multierror"17	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"18	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"19	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"20	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"21)22func init() {23	RegisterServiceErrorCheckFunc(ec2.EndpointsID, testAccErrorCheckSkipEC2)24	resource.AddTestSweepers("aws_instance", &resource.Sweeper{25		Name: "aws_instance",26		F:    testSweepInstances,27		Dependencies: []string{28			"aws_autoscaling_group",29			"aws_spot_fleet_request",30		},31	})32}33func testAccErrorCheckSkipEC2(t *testing.T) resource.ErrorCheckFunc {34	return testAccErrorCheckSkipMessagesContaining(t,35		"VolumeTypeNotAvailableInRegion",36		"Invalid value specified for Phase",37	)38}39func testSweepInstances(region string) error {40	client, err := sharedClientForRegion(region)41	if err != nil {42		return fmt.Errorf("error getting client: %s", err)43	}44	conn := client.(*AWSClient).ec2conn45	sweepResources := make([]*testSweepResource, 0)46	var errs *multierror.Error47	err = conn.DescribeInstancesPages(&ec2.DescribeInstancesInput{}, func(page *ec2.DescribeInstancesOutput, lastPage bool) bool {48		if page == nil {49			return !lastPage50		}51		for _, reservation := range page.Reservations {52			if reservation == nil {53				continue54			}55			for _, instance := range reservation.Instances {56				id := aws.StringValue(instance.InstanceId)57				if instance.State != nil && aws.StringValue(instance.State.Name) == ec2.InstanceStateNameTerminated {58					log.Printf("[INFO] Skipping terminated EC2 Instance: %s", id)59					continue60				}61				r := resourceAwsInstance()62				d := r.Data(nil)63				d.SetId(id)64				d.Set("disable_api_termination", false)65				sweepResources = append(sweepResources, NewTestSweepResource(r, d, client))66			}67		}68		return !lastPage69	})70	if err != nil {71		errs = multierror.Append(errs, fmt.Errorf("error describing EC2 Instances for %s: %w", region, err))72	}73	if err = testSweepResourceOrchestrator(sweepResources); err != nil {74		errs = multierror.Append(errs, fmt.Errorf("error sweeping EC2 Instances for %s: %w", region, err))75	}76	if testSweepSkipSweepError(errs.ErrorOrNil()) {77		log.Printf("[WARN] Skipping EC2 Instance sweep for %s: %s", region, errs)78		return nil79	}80	return errs.ErrorOrNil()81}82func TestFetchRootDevice(t *testing.T) {83	cases := []struct {84		label  string85		images []*ec2.Image86		name   string87	}{88		{89			"device name in mappings",90			[]*ec2.Image{{91				RootDeviceType: aws.String("ebs"),92				RootDeviceName: aws.String("/dev/xvda"),93				BlockDeviceMappings: []*ec2.BlockDeviceMapping{94					{DeviceName: aws.String("/dev/xvdb")},95					{DeviceName: aws.String("/dev/xvda")},96				},97			}},98			"/dev/xvda",99		},100		{101			"device name not in mappings",102			[]*ec2.Image{{103				RootDeviceType: aws.String("ebs"),104				RootDeviceName: aws.String("/dev/xvda"),105				BlockDeviceMappings: []*ec2.BlockDeviceMapping{106					{DeviceName: aws.String("/dev/xvdb")},107					{DeviceName: aws.String("/dev/xvdc")},108				},109			}},110			"/dev/xvdb",111		},112		{113			"no images",114			[]*ec2.Image{},115			"",116		},117	}118	sess, err := session.NewSession(nil)119	if err != nil {120		t.Errorf("Error new session: %s", err)121	}122	conn := ec2.New(sess)123	for _, tc := range cases {124		t.Run(fmt.Sprintf(tc.label), func(t *testing.T) {125			conn.Handlers.Clear()126			conn.Handlers.Send.PushBack(func(r *request.Request) {127				data := r.Data.(*ec2.DescribeImagesOutput)128				data.Images = tc.images129			})130			name, _ := fetchRootDeviceName("ami-123", conn)131			if tc.name != aws.StringValue(name) {132				t.Errorf("Expected name %s, got %s", tc.name, aws.StringValue(name))133			}134		})135	}136}137func TestAccAWSInstance_inDefaultVpcBySgName(t *testing.T) {138	var v ec2.Instance139	resourceName := "aws_instance.test"140	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))141	resource.ParallelTest(t, resource.TestCase{142		PreCheck:     func() { testAccPreCheck(t) },143		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),144		Providers:    testAccProviders,145		CheckDestroy: testAccCheckInstanceDestroy,146		Steps: []resource.TestStep{147			{148				Config: testAccInstanceConfigInDefaultVpcBySgName(rName),149				Check: resource.ComposeTestCheckFunc(150					testAccCheckInstanceExists(resourceName, &v),151				),152			},153			{154				ResourceName:      resourceName,155				ImportState:       true,156				ImportStateVerify: true,157			},158		},159	})160}161func TestAccAWSInstance_inDefaultVpcBySgId(t *testing.T) {162	var v ec2.Instance163	resourceName := "aws_instance.test"164	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))165	resource.ParallelTest(t, resource.TestCase{166		PreCheck:     func() { testAccPreCheck(t) },167		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),168		Providers:    testAccProviders,169		CheckDestroy: testAccCheckInstanceDestroy,170		Steps: []resource.TestStep{171			{172				Config: testAccInstanceConfigInDefaultVpcBySgId(rName),173				Check: resource.ComposeTestCheckFunc(174					testAccCheckInstanceExists(resourceName, &v),175				),176			},177			{178				ResourceName:      resourceName,179				ImportState:       true,180				ImportStateVerify: true,181			},182		},183	})184}185func TestAccAWSInstance_inEc2Classic(t *testing.T) {186	resourceName := "aws_instance.test"187	var v ec2.Instance188	resource.ParallelTest(t, resource.TestCase{189		PreCheck:          func() { testAccPreCheck(t); testAccEC2ClassicPreCheck(t) },190		ErrorCheck:        testAccErrorCheck(t, ec2.EndpointsID),191		ProviderFactories: testAccProviderFactories,192		CheckDestroy:      testAccCheckInstanceDestroy,193		Steps: []resource.TestStep{194			{195				Config: testAccInstanceConfigInEc2Classic(),196				Check: resource.ComposeTestCheckFunc(197					testAccCheckInstanceEc2ClassicExists(resourceName, &v),198				),199			},200			{201				Config:                  testAccInstanceConfigInEc2Classic(),202				ResourceName:            resourceName,203				ImportState:             true,204				ImportStateVerify:       true,205				ImportStateVerifyIgnore: []string{"network_interface", "source_dest_check"},206			},207		},208	})209}210func TestAccAWSInstance_basic(t *testing.T) {211	var v ec2.Instance212	resourceName := "aws_instance.test"213	resource.ParallelTest(t, resource.TestCase{214		// No subnet_id specified requires default VPC with default subnets or EC2-Classic.215		PreCheck: func() {216			testAccPreCheck(t)217			testAccPreCheckEc2ClassicOrHasDefaultVpcWithDefaultSubnets(t)218		},219		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),220		Providers:    testAccProviders,221		CheckDestroy: testAccCheckInstanceDestroy,222		Steps: []resource.TestStep{223			{224				Config: testAccInstanceConfigBasic(),225				Check: resource.ComposeTestCheckFunc(226					testAccCheckInstanceExists(resourceName, &v),227					testAccMatchResourceAttrRegionalARN(resourceName, "arn", "ec2", regexp.MustCompile(`instance/i-[a-z0-9]+`)),228					resource.TestCheckResourceAttr(resourceName, "instance_initiated_shutdown_behavior", "stop"),229				),230			},231			{232				ResourceName:      resourceName,233				ImportState:       true,234				ImportStateVerify: true,235				// Required for EC2-Classic.236				ImportStateVerifyIgnore: []string{"source_dest_check"},237			},238		},239	})240}241func TestAccAWSInstance_atLeastOneOtherEbsVolume(t *testing.T) {242	var v ec2.Instance243	resourceName := "aws_instance.test"244	rName := acctest.RandomWithPrefix("tf-acc-test")245	resource.ParallelTest(t, resource.TestCase{246		PreCheck:     func() { testAccPreCheck(t) },247		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),248		Providers:    testAccProviders,249		CheckDestroy: testAccCheckInstanceDestroy,250		Steps: []resource.TestStep{251			{252				Config: testAccInstanceConfigAtLeastOneOtherEbsVolume(rName),253				Check: resource.ComposeTestCheckFunc(254					testAccCheckInstanceExists(resourceName, &v),255					resource.TestCheckResourceAttr(resourceName, "user_data", "3dc39dda39be1205215e776bad998da361a5955d"),256					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "0"), // This is an instance store AMI257					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "0"),258					resource.TestCheckResourceAttr(resourceName, "outpost_arn", ""),259					testAccMatchResourceAttrRegionalARN(resourceName, "arn", "ec2", regexp.MustCompile(`instance/i-[a-z0-9]+`)),260				),261			},262			{263				ResourceName:      resourceName,264				ImportState:       true,265				ImportStateVerify: true,266			},267			// We repeat the exact same test so that we can be sure268			// that the user data hash stuff is working without generating269			// an incorrect diff.270			{271				Config: testAccInstanceConfigAtLeastOneOtherEbsVolume(rName),272				Check: resource.ComposeTestCheckFunc(273					testAccCheckInstanceExists(resourceName, &v),274					resource.TestCheckResourceAttr(resourceName, "user_data", "3dc39dda39be1205215e776bad998da361a5955d"),275					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "0"),276				),277			},278		},279	})280}281func TestAccAWSInstance_EbsBlockDevice_KmsKeyArn(t *testing.T) {282	var instance ec2.Instance283	kmsKeyResourceName := "aws_kms_key.test"284	resourceName := "aws_instance.test"285	resource.ParallelTest(t, resource.TestCase{286		PreCheck:     func() { testAccPreCheck(t) },287		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),288		Providers:    testAccProviders,289		CheckDestroy: testAccCheckInstanceDestroy,290		Steps: []resource.TestStep{291			{292				Config: testAccInstanceConfigEbsBlockDeviceKmsKeyArn(),293				Check: resource.ComposeTestCheckFunc(294					testAccCheckInstanceExists(resourceName, &instance),295					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "1"),296					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{297						"encrypted": "true",298					}),299					resource.TestCheckTypeSetElemAttrPair(resourceName, "ebs_block_device.*.kms_key_id", kmsKeyResourceName, "arn"),300				),301			},302		},303	})304}305// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/12667306func TestAccAWSInstance_EbsBlockDevice_InvalidIopsForVolumeType(t *testing.T) {307	resource.ParallelTest(t, resource.TestCase{308		PreCheck:     func() { testAccPreCheck(t) },309		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),310		Providers:    testAccProviders,311		CheckDestroy: testAccCheckInstanceDestroy,312		Steps: []resource.TestStep{313			{314				Config:      testAccInstanceConfigEBSBlockDeviceInvalidIops,315				ExpectError: regexp.MustCompile(`error creating resource: iops attribute not supported for ebs_block_device with volume_type gp2`),316			},317		},318	})319}320func TestAccAWSInstance_EbsBlockDevice_InvalidThroughputForVolumeType(t *testing.T) {321	resource.ParallelTest(t, resource.TestCase{322		PreCheck:     func() { testAccPreCheck(t) },323		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),324		Providers:    testAccProviders,325		CheckDestroy: testAccCheckInstanceDestroy,326		Steps: []resource.TestStep{327			{328				Config:      testAccInstanceConfigEBSBlockDeviceInvalidThroughput,329				ExpectError: regexp.MustCompile(`error creating resource: throughput attribute not supported for ebs_block_device with volume_type gp2`),330			},331		},332	})333}334func TestAccAWSInstance_RootBlockDevice_KmsKeyArn(t *testing.T) {335	var instance ec2.Instance336	kmsKeyResourceName := "aws_kms_key.test"337	resourceName := "aws_instance.test"338	rName := acctest.RandomWithPrefix("tf-acc-test")339	resource.ParallelTest(t, resource.TestCase{340		PreCheck:     func() { testAccPreCheck(t) },341		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),342		Providers:    testAccProviders,343		CheckDestroy: testAccCheckInstanceDestroy,344		Steps: []resource.TestStep{345			{346				Config: testAccInstanceConfigRootBlockDeviceKmsKeyArn(rName),347				Check: resource.ComposeTestCheckFunc(348					testAccCheckInstanceExists(resourceName, &instance),349					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),350					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.encrypted", "true"),351					resource.TestCheckResourceAttrPair(resourceName, "root_block_device.0.kms_key_id", kmsKeyResourceName, "arn"),352				),353			},354			{355				ResourceName:      resourceName,356				ImportState:       true,357				ImportStateVerify: true,358			},359		},360	})361}362func TestAccAWSInstance_userDataBase64(t *testing.T) {363	var v ec2.Instance364	resourceName := "aws_instance.test"365	rName := acctest.RandomWithPrefix("tf-acc-test")366	resource.ParallelTest(t, resource.TestCase{367		PreCheck:     func() { testAccPreCheck(t) },368		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),369		Providers:    testAccProviders,370		CheckDestroy: testAccCheckInstanceDestroy,371		Steps: []resource.TestStep{372			{373				Config: testAccInstanceConfigWithUserDataBase64(rName),374				Check: resource.ComposeTestCheckFunc(375					testAccCheckInstanceExists(resourceName, &v),376					resource.TestCheckResourceAttr(resourceName, "user_data_base64", "aGVsbG8gd29ybGQ="),377				),378			},379			{380				ResourceName:            resourceName,381				ImportState:             true,382				ImportStateVerify:       true,383				ImportStateVerifyIgnore: []string{"user_data"},384			},385		},386	})387}388func TestAccAWSInstance_GP2IopsDevice(t *testing.T) {389	var v ec2.Instance390	resourceName := "aws_instance.test"391	testCheck := func() resource.TestCheckFunc {392		return func(*terraform.State) error {393			// Map out the block devices by name, which should be unique.394			blockDevices := make(map[string]*ec2.InstanceBlockDeviceMapping)395			for _, blockDevice := range v.BlockDeviceMappings {396				blockDevices[*blockDevice.DeviceName] = blockDevice397			}398			// Check if the root block device exists.399			if _, ok := blockDevices["/dev/xvda"]; !ok {400				return fmt.Errorf("block device doesn't exist: /dev/xvda")401			}402			return nil403		}404	}405	resource.ParallelTest(t, resource.TestCase{406		PreCheck:     func() { testAccPreCheck(t) },407		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),408		Providers:    testAccProviders,409		CheckDestroy: testAccCheckInstanceDestroy,410		Steps: []resource.TestStep{411			{412				Config: testAccInstanceGP2IopsDevice(),413				Check: resource.ComposeTestCheckFunc(414					testAccCheckInstanceExists(resourceName, &v),415					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),416					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", "11"),417					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", "gp2"),418					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", "100"),419					testCheck(),420				),421			},422			{423				ResourceName:      resourceName,424				ImportState:       true,425				ImportStateVerify: true,426			},427		},428	})429}430// TestAccAWSInstance_GP2WithIopsValue updated in v3.0.0431// to account for apply-time validation of the root_block_device.iops attribute for supported volume types432// Reference: https://github.com/hashicorp/terraform-provider-aws/pull/14310433func TestAccAWSInstance_GP2WithIopsValue(t *testing.T) {434	resource.ParallelTest(t, resource.TestCase{435		PreCheck:     func() { testAccPreCheck(t) },436		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),437		Providers:    testAccProviders,438		CheckDestroy: testAccCheckInstanceDestroy,439		Steps: []resource.TestStep{440			{441				Config:      testAccInstanceGP2WithIopsValue(),442				ExpectError: regexp.MustCompile(`error creating resource: iops attribute not supported for root_block_device with volume_type gp2`),443			},444		},445	})446}447func TestAccAWSInstance_blockDevices(t *testing.T) {448	var v ec2.Instance449	resourceName := "aws_instance.test"450	testCheck := func() resource.TestCheckFunc {451		return func(*terraform.State) error {452			// Map out the block devices by name, which should be unique.453			blockDevices := make(map[string]*ec2.InstanceBlockDeviceMapping)454			for _, blockDevice := range v.BlockDeviceMappings {455				blockDevices[*blockDevice.DeviceName] = blockDevice456			}457			// Check if the root block device exists.458			if _, ok := blockDevices["/dev/xvda"]; !ok {459				return fmt.Errorf("block device doesn't exist: /dev/xvda")460			}461			// Check if the secondary block device exists.462			if _, ok := blockDevices["/dev/sdb"]; !ok {463				return fmt.Errorf("block device doesn't exist: /dev/sdb")464			}465			// Check if the third block device exists.466			if _, ok := blockDevices["/dev/sdc"]; !ok {467				return fmt.Errorf("block device doesn't exist: /dev/sdc")468			}469			// Check if the encrypted block device exists470			if _, ok := blockDevices["/dev/sdd"]; !ok {471				return fmt.Errorf("block device doesn't exist: /dev/sdd")472			}473			if _, ok := blockDevices["/dev/sdf"]; !ok {474				return fmt.Errorf("block device doesn't exist: /dev/sdf")475			}476			if _, ok := blockDevices["/dev/sdg"]; !ok {477				return fmt.Errorf("block device doesn't exist: /dev/sdg")478			}479			return nil480		}481	}482	rootVolumeSize := "11"483	resource.ParallelTest(t, resource.TestCase{484		PreCheck:     func() { testAccPreCheck(t) },485		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),486		Providers:    testAccProviders,487		CheckDestroy: testAccCheckInstanceDestroy,488		Steps: []resource.TestStep{489			{490				Config: testAccAwsEc2InstanceConfigBlockDevices(rootVolumeSize),491				Check: resource.ComposeTestCheckFunc(492					testAccCheckInstanceExists(resourceName, &v),493					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),494					resource.TestMatchResourceAttr(resourceName, "root_block_device.0.volume_id", regexp.MustCompile("vol-[a-z0-9]+")),495					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", rootVolumeSize),496					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", "gp2"),497					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "5"),498					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{499						"device_name": "/dev/sdb",500						"volume_size": "9",501						"volume_type": "gp2",502					}),503					resource.TestMatchTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]*regexp.Regexp{504						"volume_id": regexp.MustCompile("vol-[a-z0-9]+"),505					}),506					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{507						"device_name": "/dev/sdc",508						"volume_size": "10",509						"volume_type": "io1",510						"iops":        "100",511					}),512					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{513						"device_name": "/dev/sdf",514						"volume_size": "10",515						"volume_type": "gp3",516						"throughput":  "300",517					}),518					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{519						"device_name": "/dev/sdg",520						"volume_size": "10",521						"volume_type": "gp3",522						"throughput":  "300",523						"iops":        "4000",524					}),525					resource.TestMatchTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]*regexp.Regexp{526						"volume_id": regexp.MustCompile("vol-[a-z0-9]+"),527					}),528					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{529						"device_name": "/dev/sdd",530						"encrypted":   "true",531						"volume_size": "12",532					}),533					resource.TestMatchTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]*regexp.Regexp{534						"volume_id": regexp.MustCompile("vol-[a-z0-9]+"),535					}),536					resource.TestCheckResourceAttr(resourceName, "ephemeral_block_device.#", "1"),537					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ephemeral_block_device.*", map[string]string{538						"device_name":  "/dev/sde",539						"virtual_name": "ephemeral0",540					}),541					testCheck(),542				),543			},544			{545				ResourceName:            resourceName,546				ImportState:             true,547				ImportStateVerify:       true,548				ImportStateVerifyIgnore: []string{"ephemeral_block_device"},549			},550		},551	})552}553func TestAccAWSInstance_rootInstanceStore(t *testing.T) {554	var v ec2.Instance555	resourceName := "aws_instance.test"556	resource.ParallelTest(t, resource.TestCase{557		PreCheck:     func() { testAccPreCheck(t) },558		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),559		Providers:    testAccProviders,560		CheckDestroy: testAccCheckInstanceDestroy,561		Steps: []resource.TestStep{562			{563				Config: testAccInstanceConfigRootInstanceStore(),564				Check: resource.ComposeTestCheckFunc(565					testAccCheckInstanceExists(resourceName, &v),566					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "0"),567					resource.TestCheckResourceAttr(resourceName, "ebs_optimized", "false"),568					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "0"),569				),570			},571			{572				ResourceName:      resourceName,573				ImportState:       true,574				ImportStateVerify: true,575			},576		},577	})578}579func TestAccAWSInstance_noAMIEphemeralDevices(t *testing.T) {580	var v ec2.Instance581	resourceName := "aws_instance.test"582	testCheck := func() resource.TestCheckFunc {583		return func(*terraform.State) error {584			// Map out the block devices by name, which should be unique.585			blockDevices := make(map[string]*ec2.InstanceBlockDeviceMapping)586			for _, blockDevice := range v.BlockDeviceMappings {587				blockDevices[*blockDevice.DeviceName] = blockDevice588			}589			// Check if the root block device exists.590			if _, ok := blockDevices["/dev/xvda"]; !ok {591				return fmt.Errorf("block device doesn't exist: /dev/xvda")592			}593			// Check if the secondary block not exists.594			if _, ok := blockDevices["/dev/sdb"]; ok {595				return fmt.Errorf("block device exist: /dev/sdb")596			}597			// Check if the third block device not exists.598			if _, ok := blockDevices["/dev/sdc"]; ok {599				return fmt.Errorf("block device exist: /dev/sdc")600			}601			return nil602		}603	}604	resource.ParallelTest(t, resource.TestCase{605		PreCheck:     func() { testAccPreCheck(t) },606		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),607		Providers:    testAccProviders,608		CheckDestroy: testAccCheckInstanceDestroy,609		Steps: []resource.TestStep{610			{611				Config: testAccInstanceConfigNoAMIEphemeralDevices(),612				Check: resource.ComposeTestCheckFunc(613					testAccCheckInstanceExists(resourceName, &v),614					resource.TestCheckResourceAttr(resourceName, "ebs_optimized", "false"),615					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),616					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", "11"),617					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", "gp2"),618					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "0"),619					resource.TestCheckResourceAttr(resourceName, "ephemeral_block_device.#", "2"),620					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ephemeral_block_device.*", map[string]string{621						"device_name": "/dev/sdb",622						"no_device":   "true",623					}),624					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ephemeral_block_device.*", map[string]string{625						"device_name": "/dev/sdc",626						"no_device":   "true",627					}),628					testCheck(),629				),630			},631			{632				ResourceName:            resourceName,633				ImportState:             true,634				ImportStateVerify:       true,635				ImportStateVerifyIgnore: []string{"ephemeral_block_device"},636			},637		},638	})639}640func TestAccAWSInstance_sourceDestCheck(t *testing.T) {641	var v ec2.Instance642	resourceName := "aws_instance.test"643	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))644	testCheck := func(enabled bool) resource.TestCheckFunc {645		return func(*terraform.State) error {646			if v.SourceDestCheck == nil {647				return fmt.Errorf("bad source_dest_check: got nil")648			}649			if *v.SourceDestCheck != enabled {650				return fmt.Errorf("bad source_dest_check: %#v", *v.SourceDestCheck)651			}652			return nil653		}654	}655	resource.ParallelTest(t, resource.TestCase{656		PreCheck:     func() { testAccPreCheck(t) },657		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),658		Providers:    testAccProviders,659		CheckDestroy: testAccCheckInstanceDestroy,660		Steps: []resource.TestStep{661			{662				Config: testAccInstanceConfigSourceDestDisable(rName),663				Check: resource.ComposeTestCheckFunc(664					testAccCheckInstanceExists(resourceName, &v),665					testCheck(false),666				),667			},668			{669				ResourceName:      resourceName,670				ImportState:       true,671				ImportStateVerify: true,672			},673			{674				Config: testAccInstanceConfigSourceDestEnable(rName),675				Check: resource.ComposeTestCheckFunc(676					testAccCheckInstanceExists(resourceName, &v),677					testCheck(true),678				),679			},680			{681				Config: testAccInstanceConfigSourceDestDisable(rName),682				Check: resource.ComposeTestCheckFunc(683					testAccCheckInstanceExists(resourceName, &v),684					testCheck(false),685				),686			},687		},688	})689}690func TestAccAWSInstance_disableApiTermination(t *testing.T) {691	var v ec2.Instance692	resourceName := "aws_instance.test"693	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))694	checkDisableApiTermination := func(expected bool) resource.TestCheckFunc {695		return func(*terraform.State) error {696			conn := testAccProvider.Meta().(*AWSClient).ec2conn697			r, err := conn.DescribeInstanceAttribute(&ec2.DescribeInstanceAttributeInput{698				InstanceId: v.InstanceId,699				Attribute:  aws.String("disableApiTermination"),700			})701			if err != nil {702				return err703			}704			got := *r.DisableApiTermination.Value705			if got != expected {706				return fmt.Errorf("expected: %t, got: %t", expected, got)707			}708			return nil709		}710	}711	resource.ParallelTest(t, resource.TestCase{712		PreCheck:     func() { testAccPreCheck(t) },713		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),714		Providers:    testAccProviders,715		CheckDestroy: testAccCheckInstanceDestroy,716		Steps: []resource.TestStep{717			{718				Config: testAccInstanceConfigDisableAPITermination(rName, true),719				Check: resource.ComposeTestCheckFunc(720					testAccCheckInstanceExists(resourceName, &v),721					checkDisableApiTermination(true),722				),723			},724			{725				ResourceName:      resourceName,726				ImportState:       true,727				ImportStateVerify: true,728			},729			{730				Config: testAccInstanceConfigDisableAPITermination(rName, false),731				Check: resource.ComposeTestCheckFunc(732					testAccCheckInstanceExists(resourceName, &v),733					checkDisableApiTermination(false),734				),735			},736		},737	})738}739func TestAccAWSInstance_dedicatedInstance(t *testing.T) {740	var v ec2.Instance741	resourceName := "aws_instance.test"742	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))743	resource.ParallelTest(t, resource.TestCase{744		PreCheck:     func() { testAccPreCheck(t) },745		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),746		Providers:    testAccProviders,747		CheckDestroy: testAccCheckInstanceDestroy,748		Steps: []resource.TestStep{749			{750				Config: testAccEc2InstanceConfigDedicatedInstance(rName),751				Check: resource.ComposeTestCheckFunc(752					testAccCheckInstanceExists(resourceName, &v),753					resource.TestCheckResourceAttr(resourceName, "tenancy", "dedicated"),754					resource.TestCheckResourceAttr(resourceName, "user_data", "562a3e32810edf6ff09994f050f12e799452379d"),755				),756			},757			{758				ResourceName:            resourceName,759				ImportState:             true,760				ImportStateVerify:       true,761				ImportStateVerifyIgnore: []string{"associate_public_ip_address", "user_data"},762			},763		},764	})765}766func TestAccAWSInstance_outpost(t *testing.T) {767	var v ec2.Instance768	outpostDataSourceName := "data.aws_outposts_outpost.test"769	resourceName := "aws_instance.test"770	resource.ParallelTest(t, resource.TestCase{771		PreCheck:     func() { testAccPreCheck(t); testAccPreCheckAWSOutpostsOutposts(t) },772		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),773		Providers:    testAccProviders,774		CheckDestroy: testAccCheckInstanceDestroy,775		Steps: []resource.TestStep{776			{777				Config: testAccInstanceConfigOutpost(),778				Check: resource.ComposeTestCheckFunc(779					testAccCheckInstanceExists(resourceName, &v),780					resource.TestCheckResourceAttrPair(resourceName, "outpost_arn", outpostDataSourceName, "arn"),781				),782			},783			{784				ResourceName:      resourceName,785				ImportState:       true,786				ImportStateVerify: true,787			},788		},789	})790}791func TestAccAWSInstance_placementGroup(t *testing.T) {792	var v ec2.Instance793	resourceName := "aws_instance.test"794	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))795	resource.ParallelTest(t, resource.TestCase{796		PreCheck:     func() { testAccPreCheck(t) },797		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),798		Providers:    testAccProviders,799		CheckDestroy: testAccCheckInstanceDestroy,800		Steps: []resource.TestStep{801			{802				Config: testAccInstanceConfigPlacementGroup(rName),803				Check: resource.ComposeTestCheckFunc(804					testAccCheckInstanceExists(resourceName, &v),805					resource.TestCheckResourceAttr(resourceName, "placement_group", rName),806				),807			},808			{809				ResourceName:      resourceName,810				ImportState:       true,811				ImportStateVerify: true,812			},813		},814	})815}816func TestAccAWSInstance_ipv6_supportAddressCount(t *testing.T) {817	var v ec2.Instance818	resourceName := "aws_instance.test"819	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))820	resource.ParallelTest(t, resource.TestCase{821		PreCheck:     func() { testAccPreCheck(t) },822		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),823		Providers:    testAccProviders,824		CheckDestroy: testAccCheckInstanceDestroy,825		Steps: []resource.TestStep{826			{827				Config: testAccInstanceConfigIpv6Support(rName),828				Check: resource.ComposeTestCheckFunc(829					testAccCheckInstanceExists(resourceName, &v),830					resource.TestCheckResourceAttr(resourceName, "ipv6_address_count", "1"),831				),832			},833			{834				ResourceName:      resourceName,835				ImportState:       true,836				ImportStateVerify: true,837			},838		},839	})840}841func TestAccAWSInstance_ipv6AddressCountAndSingleAddressCausesError(t *testing.T) {842	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))843	resource.ParallelTest(t, resource.TestCase{844		PreCheck:     func() { testAccPreCheck(t) },845		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),846		Providers:    testAccProviders,847		CheckDestroy: testAccCheckInstanceDestroy,848		Steps: []resource.TestStep{849			{850				Config:      testAccInstanceConfigIpv6ErrorConfig(rName),851				ExpectError: regexp.MustCompile("Only 1 of `ipv6_address_count` or `ipv6_addresses` can be specified"),852			},853		},854	})855}856func TestAccAWSInstance_ipv6_supportAddressCountWithIpv4(t *testing.T) {857	var v ec2.Instance858	resourceName := "aws_instance.test"859	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))860	resource.ParallelTest(t, resource.TestCase{861		PreCheck:     func() { testAccPreCheck(t) },862		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),863		Providers:    testAccProviders,864		CheckDestroy: testAccCheckInstanceDestroy,865		Steps: []resource.TestStep{866			{867				Config: testAccInstanceConfigIpv6SupportWithIpv4(rName),868				Check: resource.ComposeTestCheckFunc(869					testAccCheckInstanceExists(resourceName, &v),870					resource.TestCheckResourceAttr(resourceName, "ipv6_address_count", "1"),871				),872			},873			{874				ResourceName:      resourceName,875				ImportState:       true,876				ImportStateVerify: true,877			},878		},879	})880}881func TestAccAWSInstance_NetworkInstanceSecurityGroups(t *testing.T) {882	var v ec2.Instance883	resourceName := "aws_instance.test"884	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))885	resource.ParallelTest(t, resource.TestCase{886		PreCheck:     func() { testAccPreCheck(t) },887		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),888		Providers:    testAccProviders,889		CheckDestroy: testAccCheckInstanceDestroy,890		Steps: []resource.TestStep{891			{892				Config: testAccInstanceNetworkInstanceSecurityGroups(rName),893				Check: resource.ComposeTestCheckFunc(894					testAccCheckInstanceExists(resourceName, &v),895				),896			},897			{898				ResourceName:      resourceName,899				ImportState:       true,900				ImportStateVerify: true,901			},902		},903	})904}905func TestAccAWSInstance_NetworkInstanceRemovingAllSecurityGroups(t *testing.T) {906	var v ec2.Instance907	resourceName := "aws_instance.test"908	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))909	resource.ParallelTest(t, resource.TestCase{910		PreCheck:     func() { testAccPreCheck(t) },911		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),912		Providers:    testAccProviders,913		CheckDestroy: testAccCheckInstanceDestroy,914		Steps: []resource.TestStep{915			{916				Config: testAccInstanceNetworkInstanceVPCSecurityGroupIDs(rName),917				Check: resource.ComposeTestCheckFunc(918					testAccCheckInstanceExists(resourceName, &v),919					resource.TestCheckResourceAttr(resourceName, "security_groups.#", "0"),920					resource.TestCheckResourceAttr(resourceName, "vpc_security_group_ids.#", "1"),921				),922			},923			{924				ResourceName:      resourceName,925				ImportState:       true,926				ImportStateVerify: true,927			},928			{929				Config: testAccInstanceNetworkInstanceVPCRemoveSecurityGroupIDs(rName),930				Check: resource.ComposeTestCheckFunc(931					testAccCheckInstanceExists(resourceName, &v),932					resource.TestCheckResourceAttr(resourceName, "security_groups.#", "0"),933					resource.TestCheckResourceAttr(resourceName, "vpc_security_group_ids.#", "1"),934				),935				ExpectError: regexp.MustCompile(`VPC-based instances require at least one security group to be attached`),936			},937		},938	})939}940func TestAccAWSInstance_NetworkInstanceVPCSecurityGroupIDs(t *testing.T) {941	var v ec2.Instance942	resourceName := "aws_instance.test"943	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))944	resource.ParallelTest(t, resource.TestCase{945		PreCheck:     func() { testAccPreCheck(t) },946		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),947		Providers:    testAccProviders,948		CheckDestroy: testAccCheckInstanceDestroy,949		Steps: []resource.TestStep{950			{951				Config: testAccInstanceNetworkInstanceVPCSecurityGroupIDs(rName),952				Check: resource.ComposeTestCheckFunc(953					testAccCheckInstanceExists(resourceName, &v),954					resource.TestCheckResourceAttr(resourceName, "security_groups.#", "0"),955					resource.TestCheckResourceAttr(resourceName, "vpc_security_group_ids.#", "1"),956				),957			},958			{959				ResourceName:      resourceName,960				ImportState:       true,961				ImportStateVerify: true,962			},963		},964	})965}966func TestAccAWSInstance_tags(t *testing.T) {967	var v ec2.Instance968	resourceName := "aws_instance.test"969	resource.ParallelTest(t, resource.TestCase{970		PreCheck:     func() { testAccPreCheck(t) },971		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),972		Providers:    testAccProviders,973		CheckDestroy: testAccCheckInstanceDestroy,974		Steps: []resource.TestStep{975			{976				Config: testAccInstanceConfigTags(),977				Check: resource.ComposeTestCheckFunc(978					testAccCheckInstanceExists(resourceName, &v),979					resource.TestCheckResourceAttr(resourceName, "tags.%", "1"),980					resource.TestCheckResourceAttr(resourceName, "tags.test", "test2"),981				),982			},983			{984				ResourceName:      resourceName,985				ImportState:       true,986				ImportStateVerify: true,987			},988			{989				Config: testAccInstanceConfigTagsUpdate(),990				Check: resource.ComposeTestCheckFunc(991					testAccCheckInstanceExists(resourceName, &v),992					resource.TestCheckResourceAttr(resourceName, "tags.%", "1"),993					resource.TestCheckResourceAttr(resourceName, "tags.test2", "test3"),994				),995			},996		},997	})998}999func TestAccAWSInstance_blockDeviceTags_volumeTags(t *testing.T) {1000	var v ec2.Instance1001	resourceName := "aws_instance.test"1002	resource.ParallelTest(t, resource.TestCase{1003		PreCheck:     func() { testAccPreCheck(t) },1004		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1005		Providers:    testAccProviders,1006		CheckDestroy: testAccCheckInstanceDestroy,1007		Steps: []resource.TestStep{1008			{1009				Config: testAccInstanceConfigBlockDeviceTagsNoVolumeTags(),1010				Check: resource.ComposeTestCheckFunc(1011					testAccCheckInstanceExists(resourceName, &v),1012					resource.TestCheckNoResourceAttr(resourceName, "volume_tags"),1013				),1014			},1015			{1016				ResourceName:            resourceName,1017				ImportState:             true,1018				ImportStateVerify:       true,1019				ImportStateVerifyIgnore: []string{"ephemeral_block_device"},1020			},1021			{1022				Config: testAccInstanceConfigBlockDeviceTagsVolumeTags(),1023				Check: resource.ComposeTestCheckFunc(1024					testAccCheckInstanceExists(resourceName, &v),1025					resource.TestCheckResourceAttr(resourceName, "volume_tags.%", "1"),1026					resource.TestCheckResourceAttr(resourceName, "volume_tags.Name", "acceptance-test-volume-tag"),1027				),1028			},1029			{1030				Config: testAccInstanceConfigBlockDeviceTagsVolumeTagsUpdate(),1031				Check: resource.ComposeTestCheckFunc(1032					testAccCheckInstanceExists(resourceName, &v),1033					resource.TestCheckResourceAttr(resourceName, "volume_tags.%", "2"),1034					resource.TestCheckResourceAttr(resourceName, "volume_tags.Name", "acceptance-test-volume-tag"),1035					resource.TestCheckResourceAttr(resourceName, "volume_tags.Environment", "dev"),1036				),1037			},1038			{1039				Config: testAccInstanceConfigBlockDeviceTagsNoVolumeTags(),1040				Check: resource.ComposeTestCheckFunc(1041					testAccCheckInstanceExists(resourceName, &v),1042					resource.TestCheckNoResourceAttr(resourceName, "volume_tags"),1043				),1044			},1045		},1046	})1047}1048func TestAccAWSInstance_blockDeviceTags_withAttachedVolume(t *testing.T) {1049	var v ec2.Instance1050	resourceName := "aws_instance.test"1051	ebsVolumeName := "aws_ebs_volume.test"1052	rName := acctest.RandomWithPrefix("tf-acc-test")1053	resource.ParallelTest(t, resource.TestCase{1054		PreCheck:     func() { testAccPreCheck(t) },1055		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1056		Providers:    testAccProviders,1057		CheckDestroy: testAccCheckInstanceDestroy,1058		Steps: []resource.TestStep{1059			{1060				Config: testAccInstanceConfigBlockDeviceTagsAttachedVolumeWithTags(rName),1061				Check: resource.ComposeTestCheckFunc(1062					testAccCheckInstanceExists(resourceName, &v),1063					resource.TestCheckResourceAttr(ebsVolumeName, "tags.%", "2"),1064					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Name", rName),1065					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Factum", "PerAsperaAdAstra"),1066				),1067			},1068			{1069				//https://github.com/hashicorp/terraform-provider-aws/issues/170741070				Config: testAccInstanceConfigBlockDeviceTagsAttachedVolumeWithTags(rName),1071				Check: resource.ComposeTestCheckFunc(1072					testAccCheckInstanceExists(resourceName, &v),1073					resource.TestCheckResourceAttr(ebsVolumeName, "tags.%", "2"),1074					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Name", rName),1075					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Factum", "PerAsperaAdAstra"),1076				),1077			},1078			{1079				Config: testAccInstanceConfigBlockDeviceTagsAttachedVolumeWithTagsUpdate(rName),1080				Check: resource.ComposeTestCheckFunc(1081					testAccCheckInstanceExists(resourceName, &v),1082					resource.TestCheckResourceAttr(ebsVolumeName, "tags.%", "2"),1083					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Name", rName),1084					resource.TestCheckResourceAttr(ebsVolumeName, "tags.Factum", "VincitQuiSeVincit"),1085				),1086			},1087			{1088				ResourceName:      resourceName,1089				ImportState:       true,1090				ImportStateVerify: true,1091			},1092		},1093	})1094}1095func TestAccAWSInstance_blockDeviceTags_ebsAndRoot(t *testing.T) {1096	var v ec2.Instance1097	resourceName := "aws_instance.test"1098	rName := acctest.RandomWithPrefix("tf-acc-test")1099	resource.ParallelTest(t, resource.TestCase{1100		PreCheck:     func() { testAccPreCheck(t) },1101		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1102		Providers:    testAccProviders,1103		CheckDestroy: testAccCheckInstanceDestroy,1104		Steps: []resource.TestStep{1105			{1106				Config:      testAccInstanceConfigBlockDeviceTagsRootTagsConflict(),1107				ExpectError: regexp.MustCompile(`"root_block_device\.0\.tags": conflicts with volume_tags`),1108			},1109			{1110				Config:      testAccInstanceConfigBlockDeviceTagsEBSTagsConflict(),1111				ExpectError: regexp.MustCompile(`"ebs_block_device\.0\.tags": conflicts with volume_tags`),1112			},1113			{1114				Config: testAccInstanceConfigBlockDeviceTagsEBSTags(rName),1115				Check: resource.ComposeTestCheckFunc(1116					testAccCheckInstanceExists(resourceName, &v),1117					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.%", "0"),1118					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.0.tags.%", "1"),1119					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.0.tags.Name", rName),1120					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.1.tags.%", "0"),1121				),1122			},1123			{1124				Config: testAccInstanceConfigBlockDeviceTagsEBSAndRootTags(rName),1125				Check: resource.ComposeTestCheckFunc(1126					testAccCheckInstanceExists(resourceName, &v),1127					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.%", "2"),1128					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.Name", rName),1129					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.Purpose", "test"),1130				),1131			},1132			{1133				Config: testAccInstanceConfigBlockDeviceTagsEBSAndRootTagsUpdate(rName),1134				Check: resource.ComposeTestCheckFunc(1135					testAccCheckInstanceExists(resourceName, &v),1136					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.%", "2"),1137					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.Name", rName),1138					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.tags.Env", "dev"),1139				),1140			},1141			{1142				ResourceName:            resourceName,1143				ImportState:             true,1144				ImportStateVerify:       true,1145				ImportStateVerifyIgnore: []string{"ephemeral_block_device"},1146			},1147		},1148	})1149}1150func TestAccAWSInstance_instanceProfileChange(t *testing.T) {1151	var v ec2.Instance1152	resourceName := "aws_instance.test"1153	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1154	rName2 := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1155	testCheckInstanceProfile := func() resource.TestCheckFunc {1156		return func(*terraform.State) error {1157			if v.IamInstanceProfile == nil {1158				return fmt.Errorf("Instance Profile is nil - we expected an InstanceProfile associated with the Instance")1159			}1160			return nil1161		}1162	}1163	resource.ParallelTest(t, resource.TestCase{1164		PreCheck:     func() { testAccPreCheck(t) },1165		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1166		Providers:    testAccProviders,1167		CheckDestroy: testAccCheckInstanceDestroy,1168		Steps: []resource.TestStep{1169			{1170				Config: testAccInstanceConfigWithoutInstanceProfile(rName),1171				Check: resource.ComposeTestCheckFunc(1172					testAccCheckInstanceExists(resourceName, &v),1173				),1174			},1175			{1176				ResourceName:      resourceName,1177				ImportState:       true,1178				ImportStateVerify: true,1179			},1180			{1181				Config: testAccInstanceConfigWithInstanceProfile(rName),1182				Check: resource.ComposeTestCheckFunc(1183					testAccCheckInstanceExists(resourceName, &v),1184					testCheckInstanceProfile(),1185				),1186			},1187			{1188				Config: testAccInstanceConfigWithInstanceProfile(rName),1189				Check: resource.ComposeTestCheckFunc(1190					testAccCheckStopInstance(&v), // GH-8262: Error on EC2 instance role change when stopped1191				),1192			},1193			{1194				Config: testAccInstanceConfigWithInstanceProfile(rName2),1195				Check: resource.ComposeTestCheckFunc(1196					testAccCheckInstanceExists(resourceName, &v),1197					testCheckInstanceProfile(),1198				),1199			},1200		},1201	})1202}1203func TestAccAWSInstance_withIamInstanceProfile(t *testing.T) {1204	var v ec2.Instance1205	resourceName := "aws_instance.test"1206	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1207	testCheckInstanceProfile := func() resource.TestCheckFunc {1208		return func(*terraform.State) error {1209			if v.IamInstanceProfile == nil {1210				return fmt.Errorf("Instance Profile is nil - we expected an InstanceProfile associated with the Instance")1211			}1212			return nil1213		}1214	}1215	resource.ParallelTest(t, resource.TestCase{1216		PreCheck:     func() { testAccPreCheck(t) },1217		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1218		Providers:    testAccProviders,1219		CheckDestroy: testAccCheckInstanceDestroy,1220		Steps: []resource.TestStep{1221			{1222				Config: testAccInstanceConfigWithInstanceProfile(rName),1223				Check: resource.ComposeTestCheckFunc(1224					testAccCheckInstanceExists(resourceName, &v),1225					testCheckInstanceProfile(),1226				),1227			},1228			{1229				ResourceName:      resourceName,1230				ImportState:       true,1231				ImportStateVerify: true,1232			},1233		},1234	})1235}1236// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/177191237func TestAccAWSInstance_withIamInstanceProfilePath(t *testing.T) {1238	var instance ec2.Instance1239	resourceName := "aws_instance.test"1240	rName := acctest.RandomWithPrefix("tf-acc-test")1241	resource.ParallelTest(t, resource.TestCase{1242		PreCheck:     func() { testAccPreCheck(t) },1243		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1244		Providers:    testAccProviders,1245		CheckDestroy: testAccCheckInstanceDestroy,1246		Steps: []resource.TestStep{1247			{1248				Config: testAccInstanceConfigWithInstanceProfilePath(rName),1249				Check: resource.ComposeTestCheckFunc(1250					testAccCheckInstanceExists(resourceName, &instance),1251				),1252			},1253			{1254				ResourceName:      resourceName,1255				ImportState:       true,1256				ImportStateVerify: true,1257			},1258		},1259	})1260}1261func TestAccAWSInstance_privateIP(t *testing.T) {1262	var v ec2.Instance1263	resourceName := "aws_instance.test"1264	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1265	testCheckPrivateIP := func() resource.TestCheckFunc {1266		return func(*terraform.State) error {1267			if *v.PrivateIpAddress != "10.1.1.42" {1268				return fmt.Errorf("bad private IP: %s", *v.PrivateIpAddress)1269			}1270			return nil1271		}1272	}1273	resource.ParallelTest(t, resource.TestCase{1274		PreCheck:     func() { testAccPreCheck(t) },1275		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1276		Providers:    testAccProviders,1277		CheckDestroy: testAccCheckInstanceDestroy,1278		Steps: []resource.TestStep{1279			{1280				Config: testAccInstanceConfigPrivateIP(rName),1281				Check: resource.ComposeTestCheckFunc(1282					testAccCheckInstanceExists(resourceName, &v),1283					testCheckPrivateIP(),1284				),1285			},1286			{1287				ResourceName:      resourceName,1288				ImportState:       true,1289				ImportStateVerify: true,1290			},1291		},1292	})1293}1294func TestAccAWSInstance_associatePublicIPAndPrivateIP(t *testing.T) {1295	var v ec2.Instance1296	resourceName := "aws_instance.test"1297	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1298	testCheckPrivateIP := func() resource.TestCheckFunc {1299		return func(*terraform.State) error {1300			if *v.PrivateIpAddress != "10.1.1.42" {1301				return fmt.Errorf("bad private IP: %s", *v.PrivateIpAddress)1302			}1303			return nil1304		}1305	}1306	resource.ParallelTest(t, resource.TestCase{1307		PreCheck:     func() { testAccPreCheck(t) },1308		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1309		Providers:    testAccProviders,1310		CheckDestroy: testAccCheckInstanceDestroy,1311		Steps: []resource.TestStep{1312			{1313				Config: testAccInstanceConfigAssociatePublicIPAndPrivateIP(rName),1314				Check: resource.ComposeTestCheckFunc(1315					testAccCheckInstanceExists(resourceName, &v),1316					testCheckPrivateIP(),1317				),1318			},1319			{1320				ResourceName:      resourceName,1321				ImportState:       true,1322				ImportStateVerify: true,1323			},1324		},1325	})1326}1327// Allow Empty Private IP1328// https://github.com/hashicorp/terraform-provider-aws/issues/136261329func TestAccAWSInstance_Empty_PrivateIP(t *testing.T) {1330	var v ec2.Instance1331	resourceName := "aws_instance.test"1332	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1333	testCheckPrivateIP := func() resource.TestCheckFunc {1334		return func(*terraform.State) error {1335			if aws.StringValue(v.PrivateIpAddress) == "" {1336				return fmt.Errorf("bad computed private IP: %s", aws.StringValue(v.PrivateIpAddress))1337			}1338			return nil1339		}1340	}1341	resource.ParallelTest(t, resource.TestCase{1342		PreCheck:     func() { testAccPreCheck(t) },1343		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1344		Providers:    testAccProviders,1345		CheckDestroy: testAccCheckInstanceDestroy,1346		Steps: []resource.TestStep{1347			{1348				Config: testAccInstanceConfigEmptyPrivateIP(rName),1349				Check: resource.ComposeTestCheckFunc(1350					testAccCheckInstanceExists(resourceName, &v),1351					testCheckPrivateIP(),1352				),1353			},1354			{1355				ResourceName:      resourceName,1356				ImportState:       true,1357				ImportStateVerify: true,1358			},1359		},1360	})1361}1362// Guard against regression with KeyPairs1363// https://github.com/hashicorp/terraform/issues/23021364func TestAccAWSInstance_keyPairCheck(t *testing.T) {1365	var v ec2.Instance1366	resourceName := "aws_instance.test"1367	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1368	testCheckKeyPair := func(keyName string) resource.TestCheckFunc {1369		return func(*terraform.State) error {1370			if v.KeyName == nil {1371				return fmt.Errorf("No Key Pair found, expected(%s)", keyName)1372			}1373			if v.KeyName != nil && *v.KeyName != keyName {1374				return fmt.Errorf("Bad key name, expected (%s), got (%s)", keyName, *v.KeyName)1375			}1376			return nil1377		}1378	}1379	resource.ParallelTest(t, resource.TestCase{1380		PreCheck:     func() { testAccPreCheck(t) },1381		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1382		Providers:    testAccProviders,1383		CheckDestroy: testAccCheckInstanceDestroy,1384		Steps: []resource.TestStep{1385			{1386				Config: testAccInstanceConfigKeyPair(rName),1387				Check: resource.ComposeTestCheckFunc(1388					testAccCheckInstanceExists(resourceName, &v),1389					testCheckKeyPair(rName),1390				),1391			},1392		},1393	})1394}1395func TestAccAWSInstance_rootBlockDeviceMismatch(t *testing.T) {1396	var v ec2.Instance1397	resourceName := "aws_instance.test"1398	rName := acctest.RandomWithPrefix("tf-acc-test")1399	resource.ParallelTest(t, resource.TestCase{1400		PreCheck:     func() { testAccPreCheck(t); testAccRegionPreCheck(t, endpoints.UsWest2RegionID) },1401		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1402		Providers:    testAccProviders,1403		CheckDestroy: testAccCheckInstanceDestroy,1404		Steps: []resource.TestStep{1405			{1406				Config: testAccInstanceConfigRootBlockDeviceMismatch(rName),1407				Check: resource.ComposeTestCheckFunc(1408					testAccCheckInstanceExists(resourceName, &v),1409					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", "13"),1410				),1411			},1412			{1413				ResourceName:            resourceName,1414				ImportState:             true,1415				ImportStateVerify:       true,1416				ImportStateVerifyIgnore: []string{"root_block_device"},1417			},1418		},1419	})1420}1421// This test reproduces the bug here:1422//   https://github.com/hashicorp/terraform/issues/17521423//1424// I wish there were a way to exercise resources built with helper.Schema in a1425// unit context, in which case this test could be moved there, but for now this1426// will cover the bugfix.1427//1428// The following triggers "diffs didn't match during apply" without the fix in to1429// set NewRemoved on the .# field when it changes to 0.1430func TestAccAWSInstance_forceNewAndTagsDrift(t *testing.T) {1431	var v ec2.Instance1432	resourceName := "aws_instance.test"1433	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1434	resource.ParallelTest(t, resource.TestCase{1435		PreCheck:     func() { testAccPreCheck(t) },1436		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1437		Providers:    testAccProviders,1438		CheckDestroy: testAccCheckInstanceDestroy,1439		Steps: []resource.TestStep{1440			{1441				Config: testAccInstanceConfigForceNewAndTagsDrift(rName),1442				Check: resource.ComposeTestCheckFunc(1443					testAccCheckInstanceExists(resourceName, &v),1444					driftTags(&v),1445				),1446				ExpectNonEmptyPlan: true,1447			},1448			{1449				Config: testAccInstanceConfigForceNewAndTagsDrift_Update(rName),1450				Check: resource.ComposeTestCheckFunc(1451					testAccCheckInstanceExists(resourceName, &v),1452				),1453			},1454			{1455				ResourceName:      resourceName,1456				ImportState:       true,1457				ImportStateVerify: true,1458			},1459		},1460	})1461}1462func TestAccAWSInstance_changeInstanceType(t *testing.T) {1463	var before ec2.Instance1464	var after ec2.Instance1465	resourceName := "aws_instance.test"1466	rName := acctest.RandomWithPrefix("tf-acc-test")1467	resource.ParallelTest(t, resource.TestCase{1468		PreCheck:     func() { testAccPreCheck(t) },1469		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1470		Providers:    testAccProviders,1471		CheckDestroy: testAccCheckInstanceDestroy,1472		Steps: []resource.TestStep{1473			{1474				Config: testAccInstanceConfigWithSmallInstanceType(rName),1475				Check: resource.ComposeTestCheckFunc(1476					testAccCheckInstanceExists(resourceName, &before),1477					resource.TestCheckResourceAttr(resourceName, "instance_type", "t2.medium"),1478				),1479			},1480			{1481				ResourceName:      resourceName,1482				ImportState:       true,1483				ImportStateVerify: true,1484			},1485			{1486				Config: testAccInstanceConfigUpdateInstanceType(rName),1487				Check: resource.ComposeTestCheckFunc(1488					testAccCheckInstanceExists(resourceName, &after),1489					testAccCheckInstanceNotRecreated(&before, &after),1490					resource.TestCheckResourceAttr(resourceName, "instance_type", "t2.large"),1491				),1492			},1493		},1494	})1495}1496func TestAccAWSInstance_EbsRootDevice_basic(t *testing.T) {1497	var instance ec2.Instance1498	resourceName := "aws_instance.test"1499	resource.ParallelTest(t, resource.TestCase{1500		PreCheck:     func() { testAccPreCheck(t) },1501		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1502		Providers:    testAccProviders,1503		CheckDestroy: testAccCheckInstanceDestroy,1504		Steps: []resource.TestStep{1505			{1506				Config: testAccAwsEc2InstanceEbsRootDeviceBasic(),1507				Check: resource.ComposeTestCheckFunc(1508					testAccCheckInstanceExists(resourceName, &instance),1509					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),1510					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.delete_on_termination"),1511					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.encrypted"),1512					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.iops"),1513					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.volume_size"),1514					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.volume_type"),1515					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.volume_id"),1516					resource.TestCheckResourceAttrSet(resourceName, "root_block_device.0.device_name"),1517				),1518			},1519		},1520	})1521}1522func TestAccAWSInstance_EbsRootDevice_ModifySize(t *testing.T) {1523	var original ec2.Instance1524	var updated ec2.Instance1525	resourceName := "aws_instance.test"1526	deleteOnTermination := "true"1527	volumeType := "gp2"1528	originalSize := "30"1529	updatedSize := "32"1530	resource.ParallelTest(t, resource.TestCase{1531		PreCheck:     func() { testAccPreCheck(t) },1532		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1533		Providers:    testAccProviders,1534		CheckDestroy: testAccCheckInstanceDestroy,1535		Steps: []resource.TestStep{1536			{1537				Config: testAccAwsEc2InstanceRootBlockDevice(originalSize, deleteOnTermination, volumeType),1538				Check: resource.ComposeTestCheckFunc(1539					testAccCheckInstanceExists(resourceName, &original),1540					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", originalSize),1541					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1542					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1543				),1544			},1545			{1546				Config: testAccAwsEc2InstanceRootBlockDevice(updatedSize, deleteOnTermination, volumeType),1547				Check: resource.ComposeTestCheckFunc(1548					testAccCheckInstanceExists(resourceName, &updated),1549					testAccCheckInstanceNotRecreated(&original, &updated),1550					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", updatedSize),1551					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1552					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1553				),1554			},1555		},1556	})1557}1558func TestAccAWSInstance_EbsRootDevice_ModifyType(t *testing.T) {1559	var original ec2.Instance1560	var updated ec2.Instance1561	resourceName := "aws_instance.test"1562	volumeSize := "30"1563	deleteOnTermination := "true"1564	originalType := "gp2"1565	updatedType := "standard"1566	resource.ParallelTest(t, resource.TestCase{1567		PreCheck:     func() { testAccPreCheck(t) },1568		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1569		Providers:    testAccProviders,1570		CheckDestroy: testAccCheckInstanceDestroy,1571		Steps: []resource.TestStep{1572			{1573				Config: testAccAwsEc2InstanceRootBlockDevice(volumeSize, deleteOnTermination, originalType),1574				Check: resource.ComposeTestCheckFunc(1575					testAccCheckInstanceExists(resourceName, &original),1576					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1577					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1578					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", originalType),1579				),1580			},1581			{1582				Config: testAccAwsEc2InstanceRootBlockDevice(volumeSize, deleteOnTermination, updatedType),1583				Check: resource.ComposeTestCheckFunc(1584					testAccCheckInstanceExists(resourceName, &updated),1585					testAccCheckInstanceNotRecreated(&original, &updated),1586					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1587					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1588					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", updatedType),1589				),1590			},1591		},1592	})1593}1594func TestAccAWSInstance_EbsRootDevice_ModifyIOPS_Io1(t *testing.T) {1595	var original ec2.Instance1596	var updated ec2.Instance1597	resourceName := "aws_instance.test"1598	volumeSize := "30"1599	deleteOnTermination := "true"1600	volumeType := "io1"1601	originalIOPS := "100"1602	updatedIOPS := "200"1603	resource.ParallelTest(t, resource.TestCase{1604		PreCheck:     func() { testAccPreCheck(t) },1605		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1606		Providers:    testAccProviders,1607		CheckDestroy: testAccCheckInstanceDestroy,1608		Steps: []resource.TestStep{1609			{1610				Config: testAccAwsEc2InstanceRootBlockDeviceWithIOPS(volumeSize, deleteOnTermination, volumeType, originalIOPS),1611				Check: resource.ComposeTestCheckFunc(1612					testAccCheckInstanceExists(resourceName, &original),1613					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1614					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1615					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1616					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", originalIOPS),1617				),1618			},1619			{1620				Config: testAccAwsEc2InstanceRootBlockDeviceWithIOPS(volumeSize, deleteOnTermination, volumeType, updatedIOPS),1621				Check: resource.ComposeTestCheckFunc(1622					testAccCheckInstanceExists(resourceName, &updated),1623					testAccCheckInstanceNotRecreated(&original, &updated),1624					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1625					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1626					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1627					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", updatedIOPS),1628				),1629			},1630		},1631	})1632}1633func TestAccAWSInstance_EbsRootDevice_ModifyIOPS_Io2(t *testing.T) {1634	var original ec2.Instance1635	var updated ec2.Instance1636	resourceName := "aws_instance.test"1637	volumeSize := "30"1638	deleteOnTermination := "true"1639	volumeType := "io2"1640	originalIOPS := "100"1641	updatedIOPS := "200"1642	resource.ParallelTest(t, resource.TestCase{1643		PreCheck:     func() { testAccPreCheck(t) },1644		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1645		Providers:    testAccProviders,1646		CheckDestroy: testAccCheckInstanceDestroy,1647		Steps: []resource.TestStep{1648			{1649				Config: testAccAwsEc2InstanceRootBlockDeviceWithIOPS(volumeSize, deleteOnTermination, volumeType, originalIOPS),1650				Check: resource.ComposeTestCheckFunc(1651					testAccCheckInstanceExists(resourceName, &original),1652					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1653					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1654					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1655					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", originalIOPS),1656				),1657			},1658			{1659				Config: testAccAwsEc2InstanceRootBlockDeviceWithIOPS(volumeSize, deleteOnTermination, volumeType, updatedIOPS),1660				Check: resource.ComposeTestCheckFunc(1661					testAccCheckInstanceExists(resourceName, &updated),1662					testAccCheckInstanceNotRecreated(&original, &updated),1663					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1664					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1665					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1666					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", updatedIOPS),1667				),1668			},1669		},1670	})1671}1672func TestAccAWSInstance_EbsRootDevice_ModifyThroughput_Gp3(t *testing.T) {1673	var original ec2.Instance1674	var updated ec2.Instance1675	resourceName := "aws_instance.test"1676	volumeSize := "30"1677	deleteOnTermination := "true"1678	volumeType := "gp3"1679	originalThroughput := "250"1680	updatedThroughput := "300"1681	resource.ParallelTest(t, resource.TestCase{1682		PreCheck:     func() { testAccPreCheck(t) },1683		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1684		Providers:    testAccProviders,1685		CheckDestroy: testAccCheckInstanceDestroy,1686		Steps: []resource.TestStep{1687			{1688				Config: testAccAwsEc2InstanceRootBlockDeviceWithThroughput(volumeSize, deleteOnTermination, volumeType, originalThroughput),1689				Check: resource.ComposeTestCheckFunc(1690					testAccCheckInstanceExists(resourceName, &original),1691					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1692					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1693					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1694					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.throughput", originalThroughput),1695				),1696			},1697			{1698				Config: testAccAwsEc2InstanceRootBlockDeviceWithThroughput(volumeSize, deleteOnTermination, volumeType, updatedThroughput),1699				Check: resource.ComposeTestCheckFunc(1700					testAccCheckInstanceExists(resourceName, &updated),1701					testAccCheckInstanceNotRecreated(&original, &updated),1702					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1703					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", deleteOnTermination),1704					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1705					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.throughput", updatedThroughput),1706				),1707			},1708		},1709	})1710}1711func TestAccAWSInstance_EbsRootDevice_ModifyDeleteOnTermination(t *testing.T) {1712	var original ec2.Instance1713	var updated ec2.Instance1714	resourceName := "aws_instance.test"1715	volumeSize := "30"1716	volumeType := "gp2"1717	originalDeleteOnTermination := "false"1718	updatedDeleteOnTermination := "true"1719	resource.ParallelTest(t, resource.TestCase{1720		PreCheck:     func() { testAccPreCheck(t) },1721		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1722		Providers:    testAccProviders,1723		CheckDestroy: testAccCheckInstanceDestroy,1724		Steps: []resource.TestStep{1725			{1726				Config: testAccAwsEc2InstanceRootBlockDevice(volumeSize, originalDeleteOnTermination, volumeType),1727				Check: resource.ComposeTestCheckFunc(1728					testAccCheckInstanceExists(resourceName, &original),1729					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1730					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", originalDeleteOnTermination),1731					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1732				),1733			},1734			{1735				Config: testAccAwsEc2InstanceRootBlockDevice(volumeSize, updatedDeleteOnTermination, volumeType),1736				Check: resource.ComposeTestCheckFunc(1737					testAccCheckInstanceExists(resourceName, &updated),1738					testAccCheckInstanceNotRecreated(&original, &updated),1739					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", volumeSize),1740					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", updatedDeleteOnTermination),1741					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", volumeType),1742				),1743			},1744		},1745	})1746}1747func TestAccAWSInstance_EbsRootDevice_ModifyAll(t *testing.T) {1748	var original ec2.Instance1749	var updated ec2.Instance1750	resourceName := "aws_instance.test"1751	originalSize := "30"1752	updatedSize := "32"1753	originalType := "gp2"1754	updatedType := "io1"1755	updatedIOPS := "200"1756	originalDeleteOnTermination := "false"1757	updatedDeleteOnTermination := "true"1758	resource.ParallelTest(t, resource.TestCase{1759		PreCheck:     func() { testAccPreCheck(t) },1760		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1761		Providers:    testAccProviders,1762		CheckDestroy: testAccCheckInstanceDestroy,1763		Steps: []resource.TestStep{1764			{1765				Config: testAccAwsEc2InstanceRootBlockDevice(originalSize, originalDeleteOnTermination, originalType),1766				Check: resource.ComposeTestCheckFunc(1767					testAccCheckInstanceExists(resourceName, &original),1768					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", originalSize),1769					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", originalDeleteOnTermination),1770					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", originalType),1771				),1772			},1773			{1774				Config: testAccAwsEc2InstanceRootBlockDeviceWithIOPS(updatedSize, updatedDeleteOnTermination, updatedType, updatedIOPS),1775				Check: resource.ComposeTestCheckFunc(1776					testAccCheckInstanceExists(resourceName, &updated),1777					testAccCheckInstanceNotRecreated(&original, &updated),1778					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", updatedSize),1779					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", updatedDeleteOnTermination),1780					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", updatedType),1781					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", updatedIOPS),1782				),1783			},1784		},1785	})1786}1787func TestAccAWSInstance_EbsRootDevice_MultipleBlockDevices_ModifySize(t *testing.T) {1788	var before ec2.Instance1789	var after ec2.Instance1790	resourceName := "aws_instance.test"1791	deleteOnTermination := "true"1792	originalRootVolumeSize := "10"1793	updatedRootVolumeSize := "14"1794	resource.ParallelTest(t, resource.TestCase{1795		PreCheck:     func() { testAccPreCheck(t) },1796		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1797		Providers:    testAccProviders,1798		CheckDestroy: testAccCheckInstanceDestroy,1799		Steps: []resource.TestStep{1800			{1801				Config: testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(originalRootVolumeSize, deleteOnTermination),1802				Check: resource.ComposeTestCheckFunc(1803					testAccCheckInstanceExists(resourceName, &before),1804					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", originalRootVolumeSize),1805					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1806						"volume_size": "9",1807					}),1808					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1809						"volume_size": "10",1810					}),1811					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1812						"volume_size": "12",1813					}),1814				),1815			},1816			{1817				Config: testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(updatedRootVolumeSize, deleteOnTermination),1818				Check: resource.ComposeTestCheckFunc(1819					testAccCheckInstanceExists(resourceName, &after),1820					testAccCheckInstanceNotRecreated(&before, &after),1821					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", updatedRootVolumeSize),1822					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1823						"volume_size": "9",1824					}),1825					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1826						"volume_size": "10",1827					}),1828					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1829						"volume_size": "12",1830					}),1831				),1832			},1833		},1834	})1835}1836func TestAccAWSInstance_EbsRootDevice_MultipleBlockDevices_ModifyDeleteOnTermination(t *testing.T) {1837	var before ec2.Instance1838	var after ec2.Instance1839	resourceName := "aws_instance.test"1840	rootVolumeSize := "10"1841	originalDeleteOnTermination := "false"1842	updatedDeleteOnTermination := "true"1843	resource.ParallelTest(t, resource.TestCase{1844		PreCheck:     func() { testAccPreCheck(t) },1845		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1846		Providers:    testAccProviders,1847		CheckDestroy: testAccCheckInstanceDestroy,1848		Steps: []resource.TestStep{1849			{1850				Config: testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(rootVolumeSize, originalDeleteOnTermination),1851				Check: resource.ComposeTestCheckFunc(1852					testAccCheckInstanceExists(resourceName, &before),1853					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", rootVolumeSize),1854					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", originalDeleteOnTermination),1855					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1856						"volume_size": "9",1857					}),1858					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1859						"volume_size": "10",1860					}),1861					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1862						"volume_size": "12",1863					}),1864				),1865			},1866			{1867				Config: testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(rootVolumeSize, updatedDeleteOnTermination),1868				Check: resource.ComposeTestCheckFunc(1869					testAccCheckInstanceExists(resourceName, &after),1870					testAccCheckInstanceNotRecreated(&before, &after),1871					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", rootVolumeSize),1872					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.delete_on_termination", updatedDeleteOnTermination),1873					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1874						"volume_size": "9",1875					}),1876					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1877						"volume_size": "10",1878					}),1879					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1880						"volume_size": "12",1881					}),1882				),1883			},1884		},1885	})1886}1887// Test to validate fix for GH-ISSUE #1318 (dynamic ebs_block_devices forcing replacement after state refresh)1888func TestAccAWSInstance_EbsRootDevice_MultipleDynamicEBSBlockDevices(t *testing.T) {1889	var instance ec2.Instance1890	resourceName := "aws_instance.test"1891	resource.ParallelTest(t, resource.TestCase{1892		PreCheck:     func() { testAccPreCheck(t) },1893		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1894		Providers:    testAccProviders,1895		CheckDestroy: testAccCheckInstanceDestroy,1896		Steps: []resource.TestStep{1897			{1898				Config: testAccAwsEc2InstanceConfigDynamicEBSBlockDevices(),1899				Check: resource.ComposeTestCheckFunc(1900					testAccCheckInstanceExists(resourceName, &instance),1901					resource.TestCheckResourceAttr(resourceName, "ebs_block_device.#", "3"),1902					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1903						"delete_on_termination": "true",1904						"device_name":           "/dev/sdc",1905						"encrypted":             "false",1906						"iops":                  "100",1907						"volume_size":           "10",1908						"volume_type":           "gp2",1909					}),1910					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1911						"delete_on_termination": "true",1912						"device_name":           "/dev/sdb",1913						"encrypted":             "false",1914						"iops":                  "100",1915						"volume_size":           "10",1916						"volume_type":           "gp2",1917					}),1918					resource.TestCheckTypeSetElemNestedAttrs(resourceName, "ebs_block_device.*", map[string]string{1919						"delete_on_termination": "true",1920						"device_name":           "/dev/sda",1921						"encrypted":             "false",1922						"iops":                  "100",1923						"volume_size":           "10",1924						"volume_type":           "gp2",1925					}),1926				),1927			},1928			{1929				ResourceName:      resourceName,1930				ImportState:       true,1931				ImportStateVerify: true,1932			},1933		},1934	})1935}1936func TestAccAWSInstance_primaryNetworkInterface(t *testing.T) {1937	var instance ec2.Instance1938	var eni ec2.NetworkInterface1939	resourceName := "aws_instance.test"1940	eniResourceName := "aws_network_interface.test"1941	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1942	resource.ParallelTest(t, resource.TestCase{1943		PreCheck:     func() { testAccPreCheck(t) },1944		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1945		Providers:    testAccProviders,1946		CheckDestroy: testAccCheckInstanceDestroy,1947		Steps: []resource.TestStep{1948			{1949				Config: testAccInstanceConfigPrimaryNetworkInterface(rName),1950				Check: resource.ComposeTestCheckFunc(1951					testAccCheckInstanceExists(resourceName, &instance),1952					testAccCheckAWSENIExists(eniResourceName, &eni),1953					resource.TestCheckResourceAttr(resourceName, "network_interface.#", "1"),1954				),1955			},1956			{1957				ResourceName:            resourceName,1958				ImportState:             true,1959				ImportStateVerify:       true,1960				ImportStateVerifyIgnore: []string{"network_interface"},1961			},1962		},1963	})1964}1965func TestAccAWSInstance_primaryNetworkInterfaceSourceDestCheck(t *testing.T) {1966	var instance ec2.Instance1967	var eni ec2.NetworkInterface1968	resourceName := "aws_instance.test"1969	eniResourceName := "aws_network_interface.test"1970	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))1971	resource.ParallelTest(t, resource.TestCase{1972		PreCheck:     func() { testAccPreCheck(t) },1973		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),1974		Providers:    testAccProviders,1975		CheckDestroy: testAccCheckInstanceDestroy,1976		Steps: []resource.TestStep{1977			{1978				Config: testAccInstanceConfigPrimaryNetworkInterfaceSourceDestCheck(rName),1979				Check: resource.ComposeTestCheckFunc(1980					testAccCheckInstanceExists(resourceName, &instance),1981					testAccCheckAWSENIExists(eniResourceName, &eni),1982					resource.TestCheckResourceAttr(resourceName, "source_dest_check", "false"),1983				),1984			},1985			{1986				ResourceName:            resourceName,1987				ImportState:             true,1988				ImportStateVerify:       true,1989				ImportStateVerifyIgnore: []string{"network_interface"},1990			},1991		},1992	})1993}1994func TestAccAWSInstance_addSecondaryInterface(t *testing.T) {1995	var before ec2.Instance1996	var after ec2.Instance1997	var eniPrimary ec2.NetworkInterface1998	var eniSecondary ec2.NetworkInterface1999	resourceName := "aws_instance.test"2000	eniPrimaryResourceName := "aws_network_interface.primary"2001	eniSecondaryResourceName := "aws_network_interface.secondary"2002	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2003	resource.ParallelTest(t, resource.TestCase{2004		PreCheck:     func() { testAccPreCheck(t) },2005		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2006		Providers:    testAccProviders,2007		CheckDestroy: testAccCheckInstanceDestroy,2008		Steps: []resource.TestStep{2009			{2010				Config: testAccInstanceConfigAddSecondaryNetworkInterfaceBefore(rName),2011				Check: resource.ComposeTestCheckFunc(2012					testAccCheckInstanceExists(resourceName, &before),2013					testAccCheckAWSENIExists(eniPrimaryResourceName, &eniPrimary),2014					resource.TestCheckResourceAttr(resourceName, "network_interface.#", "1"),2015				),2016			},2017			{2018				ResourceName:            resourceName,2019				ImportState:             true,2020				ImportStateVerify:       true,2021				ImportStateVerifyIgnore: []string{"network_interface"},2022			},2023			{2024				Config: testAccInstanceConfigAddSecondaryNetworkInterfaceAfter(rName),2025				Check: resource.ComposeTestCheckFunc(2026					testAccCheckInstanceExists(resourceName, &after),2027					testAccCheckAWSENIExists(eniSecondaryResourceName, &eniSecondary),2028					resource.TestCheckResourceAttr(resourceName, "network_interface.#", "1"),2029				),2030			},2031		},2032	})2033}2034// https://github.com/hashicorp/terraform/issues/32052035func TestAccAWSInstance_addSecurityGroupNetworkInterface(t *testing.T) {2036	var before ec2.Instance2037	var after ec2.Instance2038	resourceName := "aws_instance.test"2039	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2040	resource.ParallelTest(t, resource.TestCase{2041		PreCheck:     func() { testAccPreCheck(t) },2042		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2043		Providers:    testAccProviders,2044		CheckDestroy: testAccCheckInstanceDestroy,2045		Steps: []resource.TestStep{2046			{2047				Config: testAccInstanceConfigAddSecurityGroupBefore(rName),2048				Check: resource.ComposeTestCheckFunc(2049					testAccCheckInstanceExists(resourceName, &before),2050					resource.TestCheckResourceAttr(resourceName, "vpc_security_group_ids.#", "1"),2051				),2052			},2053			{2054				ResourceName:      resourceName,2055				ImportState:       true,2056				ImportStateVerify: true,2057			},2058			{2059				Config: testAccInstanceConfigAddSecurityGroupAfter(rName),2060				Check: resource.ComposeTestCheckFunc(2061					testAccCheckInstanceExists(resourceName, &after),2062					resource.TestCheckResourceAttr(resourceName, "vpc_security_group_ids.#", "2"),2063				),2064			},2065		},2066	})2067}2068// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/70632069func TestAccAWSInstance_NewNetworkInterface_PublicIPAndSecondaryPrivateIPs(t *testing.T) {2070	var v ec2.Instance2071	resourceName := "aws_instance.test"2072	rName := acctest.RandomWithPrefix("tf-acc-test")2073	resource.ParallelTest(t, resource.TestCase{2074		PreCheck:     func() { testAccPreCheck(t) },2075		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2076		Providers:    testAccProviders,2077		CheckDestroy: testAccCheckInstanceDestroy,2078		Steps: []resource.TestStep{2079			{2080				Config: testAccInstanceConfigPublicAndPrivateSecondaryIPs(rName, true),2081				Check: resource.ComposeTestCheckFunc(2082					testAccCheckInstanceExists(resourceName, &v),2083					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "true"),2084					resource.TestCheckResourceAttrSet(resourceName, "public_ip"),2085					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2086				),2087			},2088			{2089				Config: testAccInstanceConfigPublicAndPrivateSecondaryIPs(rName, false),2090				Check: resource.ComposeTestCheckFunc(2091					testAccCheckInstanceExists(resourceName, &v),2092					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "false"),2093					resource.TestCheckResourceAttr(resourceName, "public_ip", ""),2094					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2095				),2096			},2097			{2098				ResourceName:      resourceName,2099				ImportState:       true,2100				ImportStateVerify: true,2101			},2102		},2103	})2104}2105// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/70632106func TestAccAWSInstance_NewNetworkInterface_EmptyPrivateIPAndSecondaryPrivateIPs(t *testing.T) {2107	var v ec2.Instance2108	resourceName := "aws_instance.test"2109	rName := acctest.RandomWithPrefix("tf-acc-test")2110	secondaryIPs := fmt.Sprintf("%q, %q", "10.1.1.42", "10.1.1.43")2111	resource.ParallelTest(t, resource.TestCase{2112		PreCheck:     func() { testAccPreCheck(t) },2113		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2114		Providers:    testAccProviders,2115		CheckDestroy: testAccCheckInstanceDestroy,2116		Steps: []resource.TestStep{2117			{2118				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, "", secondaryIPs),2119				Check: resource.ComposeTestCheckFunc(2120					testAccCheckInstanceExists(resourceName, &v),2121					resource.TestCheckResourceAttrSet(resourceName, "private_ip"),2122					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2123				),2124			},2125			{2126				ResourceName:      resourceName,2127				ImportState:       true,2128				ImportStateVerify: true,2129			},2130		},2131	})2132}2133// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/70632134func TestAccAWSInstance_NewNetworkInterface_EmptyPrivateIPAndSecondaryPrivateIPsUpdate(t *testing.T) {2135	var v ec2.Instance2136	resourceName := "aws_instance.test"2137	rName := acctest.RandomWithPrefix("tf-acc-test")2138	secondaryIP := fmt.Sprintf("%q", "10.1.1.42")2139	secondaryIPs := fmt.Sprintf("%s, %q", secondaryIP, "10.1.1.43")2140	resource.ParallelTest(t, resource.TestCase{2141		PreCheck:     func() { testAccPreCheck(t) },2142		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2143		Providers:    testAccProviders,2144		CheckDestroy: testAccCheckInstanceDestroy,2145		Steps: []resource.TestStep{2146			{2147				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, "", secondaryIPs),2148				Check: resource.ComposeTestCheckFunc(2149					testAccCheckInstanceExists(resourceName, &v),2150					resource.TestCheckResourceAttrSet(resourceName, "private_ip"),2151					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2152				),2153			},2154			{2155				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, "", ""),2156				Check: resource.ComposeTestCheckFunc(2157					testAccCheckInstanceExists(resourceName, &v),2158					resource.TestCheckResourceAttrSet(resourceName, "private_ip"),2159					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "0"),2160				),2161			},2162			{2163				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, "", secondaryIP),2164				Check: resource.ComposeTestCheckFunc(2165					testAccCheckInstanceExists(resourceName, &v),2166					resource.TestCheckResourceAttrSet(resourceName, "private_ip"),2167					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "1"),2168				),2169			},2170			{2171				ResourceName:      resourceName,2172				ImportState:       true,2173				ImportStateVerify: true,2174			},2175		},2176	})2177}2178// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/70632179func TestAccAWSInstance_NewNetworkInterface_PrivateIPAndSecondaryPrivateIPs(t *testing.T) {2180	var v ec2.Instance2181	resourceName := "aws_instance.test"2182	rName := acctest.RandomWithPrefix("tf-acc-test")2183	privateIP := "10.1.1.42"2184	secondaryIPs := fmt.Sprintf("%q, %q", "10.1.1.43", "10.1.1.44")2185	resource.ParallelTest(t, resource.TestCase{2186		PreCheck:     func() { testAccPreCheck(t) },2187		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2188		Providers:    testAccProviders,2189		CheckDestroy: testAccCheckInstanceDestroy,2190		Steps: []resource.TestStep{2191			{2192				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, privateIP, secondaryIPs),2193				Check: resource.ComposeTestCheckFunc(2194					testAccCheckInstanceExists(resourceName, &v),2195					resource.TestCheckResourceAttr(resourceName, "private_ip", privateIP),2196					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2197				),2198			},2199			{2200				ResourceName:      resourceName,2201				ImportState:       true,2202				ImportStateVerify: true,2203			},2204		},2205	})2206}2207// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/70632208func TestAccAWSInstance_NewNetworkInterface_PrivateIPAndSecondaryPrivateIPsUpdate(t *testing.T) {2209	var v ec2.Instance2210	resourceName := "aws_instance.test"2211	rName := acctest.RandomWithPrefix("tf-acc-test")2212	privateIP := "10.1.1.42"2213	secondaryIP := fmt.Sprintf("%q", "10.1.1.43")2214	secondaryIPs := fmt.Sprintf("%s, %q", secondaryIP, "10.1.1.44")2215	resource.ParallelTest(t, resource.TestCase{2216		PreCheck:     func() { testAccPreCheck(t) },2217		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2218		Providers:    testAccProviders,2219		CheckDestroy: testAccCheckInstanceDestroy,2220		Steps: []resource.TestStep{2221			{2222				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, privateIP, secondaryIPs),2223				Check: resource.ComposeTestCheckFunc(2224					testAccCheckInstanceExists(resourceName, &v),2225					resource.TestCheckResourceAttr(resourceName, "private_ip", privateIP),2226					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "2"),2227				),2228			},2229			{2230				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, privateIP, ""),2231				Check: resource.ComposeTestCheckFunc(2232					testAccCheckInstanceExists(resourceName, &v),2233					resource.TestCheckResourceAttrSet(resourceName, "private_ip"),2234					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "0"),2235				),2236			},2237			{2238				Config: testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, privateIP, secondaryIP),2239				Check: resource.ComposeTestCheckFunc(2240					testAccCheckInstanceExists(resourceName, &v),2241					resource.TestCheckResourceAttr(resourceName, "private_ip", privateIP),2242					resource.TestCheckResourceAttr(resourceName, "secondary_private_ips.#", "1"),2243				),2244			},2245			{2246				ResourceName:      resourceName,2247				ImportState:       true,2248				ImportStateVerify: true,2249			},2250		},2251	})2252}2253// https://github.com/hashicorp/terraform-provider-aws/issues/2272254func TestAccAWSInstance_associatePublic_defaultPrivate(t *testing.T) {2255	var v ec2.Instance2256	resourceName := "aws_instance.test"2257	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2258	resource.ParallelTest(t, resource.TestCase{2259		PreCheck:     func() { testAccPreCheck(t) },2260		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2261		Providers:    testAccProviders,2262		CheckDestroy: testAccCheckInstanceDestroy,2263		Steps: []resource.TestStep{2264			{2265				Config: testAccInstanceConfig_associatePublic_defaultPrivate(rName),2266				Check: resource.ComposeTestCheckFunc(2267					testAccCheckInstanceExists(resourceName, &v),2268					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "false"),2269					resource.TestCheckResourceAttr(resourceName, "public_ip", ""),2270				),2271			},2272			{2273				ResourceName:      resourceName,2274				ImportState:       true,2275				ImportStateVerify: true,2276			},2277		},2278	})2279}2280// https://github.com/hashicorp/terraform-provider-aws/issues/2272281func TestAccAWSInstance_associatePublic_defaultPublic(t *testing.T) {2282	var v ec2.Instance2283	resourceName := "aws_instance.test"2284	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2285	resource.ParallelTest(t, resource.TestCase{2286		PreCheck:     func() { testAccPreCheck(t) },2287		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2288		Providers:    testAccProviders,2289		CheckDestroy: testAccCheckInstanceDestroy,2290		Steps: []resource.TestStep{2291			{2292				Config: testAccInstanceConfig_associatePublic_defaultPublic(rName),2293				Check: resource.ComposeTestCheckFunc(2294					testAccCheckInstanceExists(resourceName, &v),2295					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "true"),2296					resource.TestCheckResourceAttrSet(resourceName, "public_ip"),2297				),2298			},2299			{2300				ResourceName:      resourceName,2301				ImportState:       true,2302				ImportStateVerify: true,2303			},2304		},2305	})2306}2307// https://github.com/hashicorp/terraform-provider-aws/issues/2272308func TestAccAWSInstance_associatePublic_explicitPublic(t *testing.T) {2309	var v ec2.Instance2310	resourceName := "aws_instance.test"2311	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2312	resource.ParallelTest(t, resource.TestCase{2313		PreCheck:     func() { testAccPreCheck(t) },2314		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2315		Providers:    testAccProviders,2316		CheckDestroy: testAccCheckInstanceDestroy,2317		Steps: []resource.TestStep{2318			{2319				Config: testAccInstanceConfig_associatePublic_explicitPublic(rName),2320				Check: resource.ComposeTestCheckFunc(2321					testAccCheckInstanceExists(resourceName, &v),2322					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "true"),2323					resource.TestCheckResourceAttrSet(resourceName, "public_ip"),2324				),2325			},2326			{2327				ResourceName:      resourceName,2328				ImportState:       true,2329				ImportStateVerify: true,2330			},2331		},2332	})2333}2334// https://github.com/hashicorp/terraform-provider-aws/issues/2272335func TestAccAWSInstance_associatePublic_explicitPrivate(t *testing.T) {2336	var v ec2.Instance2337	resourceName := "aws_instance.test"2338	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2339	resource.ParallelTest(t, resource.TestCase{2340		PreCheck:     func() { testAccPreCheck(t) },2341		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2342		Providers:    testAccProviders,2343		CheckDestroy: testAccCheckInstanceDestroy,2344		Steps: []resource.TestStep{2345			{2346				Config: testAccInstanceConfig_associatePublic_explicitPrivate(rName),2347				Check: resource.ComposeTestCheckFunc(2348					testAccCheckInstanceExists(resourceName, &v),2349					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "false"),2350					resource.TestCheckResourceAttr(resourceName, "public_ip", ""),2351				),2352			},2353			{2354				ResourceName:      resourceName,2355				ImportState:       true,2356				ImportStateVerify: true,2357			},2358		},2359	})2360}2361// https://github.com/hashicorp/terraform-provider-aws/issues/2272362func TestAccAWSInstance_associatePublic_overridePublic(t *testing.T) {2363	var v ec2.Instance2364	resourceName := "aws_instance.test"2365	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2366	resource.ParallelTest(t, resource.TestCase{2367		PreCheck:     func() { testAccPreCheck(t) },2368		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2369		Providers:    testAccProviders,2370		CheckDestroy: testAccCheckInstanceDestroy,2371		Steps: []resource.TestStep{2372			{2373				Config: testAccInstanceConfig_associatePublic_overridePublic(rName),2374				Check: resource.ComposeTestCheckFunc(2375					testAccCheckInstanceExists(resourceName, &v),2376					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "true"),2377					resource.TestCheckResourceAttrSet(resourceName, "public_ip"),2378				),2379			},2380			{2381				ResourceName:      resourceName,2382				ImportState:       true,2383				ImportStateVerify: true,2384			},2385		},2386	})2387}2388// https://github.com/hashicorp/terraform-provider-aws/issues/2272389func TestAccAWSInstance_associatePublic_overridePrivate(t *testing.T) {2390	var v ec2.Instance2391	resourceName := "aws_instance.test"2392	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2393	resource.ParallelTest(t, resource.TestCase{2394		PreCheck:     func() { testAccPreCheck(t) },2395		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2396		Providers:    testAccProviders,2397		CheckDestroy: testAccCheckInstanceDestroy,2398		Steps: []resource.TestStep{2399			{2400				Config: testAccInstanceConfig_associatePublic_overridePrivate(rName),2401				Check: resource.ComposeTestCheckFunc(2402					testAccCheckInstanceExists(resourceName, &v),2403					resource.TestCheckResourceAttr(resourceName, "associate_public_ip_address", "false"),2404					resource.TestCheckResourceAttr(resourceName, "public_ip", ""),2405				),2406			},2407			{2408				ResourceName:      resourceName,2409				ImportState:       true,2410				ImportStateVerify: true,2411			},2412		},2413	})2414}2415func TestAccAWSInstance_getPasswordData_falseToTrue(t *testing.T) {2416	var before, after ec2.Instance2417	resourceName := "aws_instance.test"2418	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2419	resource.ParallelTest(t, resource.TestCase{2420		PreCheck:     func() { testAccPreCheck(t) },2421		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2422		Providers:    testAccProviders,2423		CheckDestroy: testAccCheckInstanceDestroy,2424		Steps: []resource.TestStep{2425			{2426				Config: testAccInstanceConfig_getPasswordData(rName, false),2427				Check: resource.ComposeTestCheckFunc(2428					testAccCheckInstanceExists(resourceName, &before),2429					resource.TestCheckResourceAttr(resourceName, "get_password_data", "false"),2430					resource.TestCheckResourceAttr(resourceName, "password_data", ""),2431				),2432			},2433			{2434				ResourceName:      resourceName,2435				ImportState:       true,2436				ImportStateVerify: true,2437			},2438			{2439				Config: testAccInstanceConfig_getPasswordData(rName, true),2440				Check: resource.ComposeTestCheckFunc(2441					testAccCheckInstanceExists(resourceName, &after),2442					testAccCheckInstanceNotRecreated(&before, &after),2443					resource.TestCheckResourceAttr(resourceName, "get_password_data", "true"),2444					resource.TestCheckResourceAttrSet(resourceName, "password_data"),2445				),2446			},2447		},2448	})2449}2450func TestAccAWSInstance_getPasswordData_trueToFalse(t *testing.T) {2451	var before, after ec2.Instance2452	resourceName := "aws_instance.test"2453	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2454	resource.ParallelTest(t, resource.TestCase{2455		PreCheck:     func() { testAccPreCheck(t) },2456		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2457		Providers:    testAccProviders,2458		CheckDestroy: testAccCheckInstanceDestroy,2459		Steps: []resource.TestStep{2460			{2461				Config: testAccInstanceConfig_getPasswordData(rName, true),2462				Check: resource.ComposeTestCheckFunc(2463					testAccCheckInstanceExists(resourceName, &before),2464					resource.TestCheckResourceAttr(resourceName, "get_password_data", "true"),2465					resource.TestCheckResourceAttrSet(resourceName, "password_data"),2466				),2467			},2468			{2469				ResourceName:            resourceName,2470				ImportState:             true,2471				ImportStateVerify:       true,2472				ImportStateVerifyIgnore: []string{"password_data", "get_password_data"},2473			},2474			{2475				Config: testAccInstanceConfig_getPasswordData(rName, false),2476				Check: resource.ComposeTestCheckFunc(2477					testAccCheckInstanceExists(resourceName, &after),2478					testAccCheckInstanceNotRecreated(&before, &after),2479					resource.TestCheckResourceAttr(resourceName, "get_password_data", "false"),2480					resource.TestCheckResourceAttr(resourceName, "password_data", ""),2481				),2482			},2483		},2484	})2485}2486func TestAccAWSInstance_CreditSpecification_Empty_NonBurstable(t *testing.T) {2487	var v ec2.Instance2488	resourceName := "aws_instance.test"2489	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2490	resource.ParallelTest(t, resource.TestCase{2491		PreCheck:     func() { testAccPreCheck(t) },2492		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2493		Providers:    testAccProviders,2494		CheckDestroy: testAccCheckInstanceDestroy,2495		Steps: []resource.TestStep{2496			{2497				Config: testAccInstanceConfig_CreditSpecification_Empty_NonBurstable(rName),2498				Check: resource.ComposeTestCheckFunc(2499					testAccCheckInstanceExists(resourceName, &v),2500				),2501			},2502			{2503				ResourceName:            resourceName,2504				ImportState:             true,2505				ImportStateVerify:       true,2506				ImportStateVerifyIgnore: []string{"credit_specification"},2507			},2508		},2509	})2510}2511// Reference: https://github.com/hashicorp/terraform-provider-aws/issues/102032512func TestAccAWSInstance_CreditSpecification_UnspecifiedToEmpty_NonBurstable(t *testing.T) {2513	var instance ec2.Instance2514	resourceName := "aws_instance.test"2515	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2516	resource.ParallelTest(t, resource.TestCase{2517		PreCheck:     func() { testAccPreCheck(t) },2518		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2519		Providers:    testAccProviders,2520		CheckDestroy: testAccCheckInstanceDestroy,2521		Steps: []resource.TestStep{2522			{2523				Config: testAccInstanceConfig_CreditSpecification_Unspecified_NonBurstable(rName),2524				Check: resource.ComposeTestCheckFunc(2525					testAccCheckInstanceExists(resourceName, &instance),2526				),2527			},2528			{2529				ResourceName:      resourceName,2530				ImportState:       true,2531				ImportStateVerify: true,2532			},2533			{2534				Config: testAccInstanceConfig_CreditSpecification_Empty_NonBurstable(rName),2535				Check: resource.ComposeTestCheckFunc(2536					testAccCheckInstanceExists(resourceName, &instance),2537				),2538			},2539		},2540	})2541}2542func TestAccAWSInstance_creditSpecification_unspecifiedDefaultsToStandard(t *testing.T) {2543	var v ec2.Instance2544	resourceName := "aws_instance.test"2545	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2546	resource.ParallelTest(t, resource.TestCase{2547		PreCheck:     func() { testAccPreCheck(t) },2548		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2549		Providers:    testAccProviders,2550		CheckDestroy: testAccCheckInstanceDestroy,2551		Steps: []resource.TestStep{2552			{2553				Config: testAccInstanceConfig_creditSpecification_unspecified(rName),2554				Check: resource.ComposeTestCheckFunc(2555					testAccCheckInstanceExists(resourceName, &v),2556					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2557					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2558				),2559			},2560			{2561				ResourceName:      resourceName,2562				ImportState:       true,2563				ImportStateVerify: true,2564			},2565		},2566	})2567}2568func TestAccAWSInstance_creditSpecification_standardCpuCredits(t *testing.T) {2569	var first, second ec2.Instance2570	resourceName := "aws_instance.test"2571	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2572	resource.ParallelTest(t, resource.TestCase{2573		PreCheck:     func() { testAccPreCheck(t) },2574		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2575		Providers:    testAccProviders,2576		CheckDestroy: testAccCheckInstanceDestroy,2577		Steps: []resource.TestStep{2578			{2579				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits(rName),2580				Check: resource.ComposeTestCheckFunc(2581					testAccCheckInstanceExists(resourceName, &first),2582					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2583					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2584				),2585			},2586			{2587				ResourceName:      resourceName,2588				ImportState:       true,2589				ImportStateVerify: true,2590			},2591			{2592				Config: testAccInstanceConfig_creditSpecification_unspecified(rName),2593				Check: resource.ComposeTestCheckFunc(2594					testAccCheckInstanceExists(resourceName, &second),2595					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2596					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2597				),2598			},2599		},2600	})2601}2602func TestAccAWSInstance_creditSpecification_unlimitedCpuCredits(t *testing.T) {2603	var first, second ec2.Instance2604	resourceName := "aws_instance.test"2605	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2606	resource.ParallelTest(t, resource.TestCase{2607		PreCheck:     func() { testAccPreCheck(t) },2608		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2609		Providers:    testAccProviders,2610		CheckDestroy: testAccCheckInstanceDestroy,2611		Steps: []resource.TestStep{2612			{2613				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits(rName),2614				Check: resource.ComposeTestCheckFunc(2615					testAccCheckInstanceExists(resourceName, &first),2616					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2617					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2618				),2619			},2620			{2621				ResourceName:      resourceName,2622				ImportState:       true,2623				ImportStateVerify: true,2624			},2625			{2626				Config: testAccInstanceConfig_creditSpecification_unspecified(rName),2627				Check: resource.ComposeTestCheckFunc(2628					testAccCheckInstanceExists(resourceName, &second),2629					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2630					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2631				),2632			},2633		},2634	})2635}2636func TestAccAWSInstance_creditSpecification_unknownCpuCredits_t2(t *testing.T) {2637	var v ec2.Instance2638	resourceName := "aws_instance.test"2639	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2640	resource.ParallelTest(t, resource.TestCase{2641		PreCheck:     func() { testAccPreCheck(t) },2642		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2643		Providers:    testAccProviders,2644		CheckDestroy: testAccCheckInstanceDestroy,2645		Steps: []resource.TestStep{2646			{2647				Config: testAccInstanceConfig_creditSpecification_unknownCpuCredits(rName, "t2.micro"),2648				Check: resource.ComposeTestCheckFunc(2649					testAccCheckInstanceExists(resourceName, &v),2650					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2651					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2652				),2653			},2654			{2655				ResourceName:      resourceName,2656				ImportState:       true,2657				ImportStateVerify: true,2658			},2659		},2660	})2661}2662func TestAccAWSInstance_creditSpecification_unknownCpuCredits_t3(t *testing.T) {2663	var v ec2.Instance2664	resourceName := "aws_instance.test"2665	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2666	resource.ParallelTest(t, resource.TestCase{2667		PreCheck:     func() { testAccPreCheck(t) },2668		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2669		Providers:    testAccProviders,2670		CheckDestroy: testAccCheckInstanceDestroy,2671		Steps: []resource.TestStep{2672			{2673				Config: testAccInstanceConfig_creditSpecification_unknownCpuCredits(rName, "t3.micro"),2674				Check: resource.ComposeTestCheckFunc(2675					testAccCheckInstanceExists(resourceName, &v),2676					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2677					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2678				),2679			},2680			{2681				ResourceName:      resourceName,2682				ImportState:       true,2683				ImportStateVerify: true,2684			},2685		},2686	})2687}2688func TestAccAWSInstance_creditSpecification_updateCpuCredits(t *testing.T) {2689	var first, second, third ec2.Instance2690	resourceName := "aws_instance.test"2691	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2692	resource.ParallelTest(t, resource.TestCase{2693		PreCheck:     func() { testAccPreCheck(t) },2694		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2695		Providers:    testAccProviders,2696		CheckDestroy: testAccCheckInstanceDestroy,2697		Steps: []resource.TestStep{2698			{2699				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits(rName),2700				Check: resource.ComposeTestCheckFunc(2701					testAccCheckInstanceExists(resourceName, &first),2702					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2703					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2704				),2705			},2706			{2707				ResourceName:      resourceName,2708				ImportState:       true,2709				ImportStateVerify: true,2710			},2711			{2712				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits(rName),2713				Check: resource.ComposeTestCheckFunc(2714					testAccCheckInstanceExists(resourceName, &second),2715					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2716					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2717				),2718			},2719			{2720				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits(rName),2721				Check: resource.ComposeTestCheckFunc(2722					testAccCheckInstanceExists(resourceName, &third),2723					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2724					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2725				),2726			},2727		},2728	})2729}2730func TestAccAWSInstance_creditSpecification_isNotAppliedToNonBurstable(t *testing.T) {2731	var v ec2.Instance2732	resourceName := "aws_instance.test"2733	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2734	resource.ParallelTest(t, resource.TestCase{2735		PreCheck:     func() { testAccPreCheck(t) },2736		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2737		Providers:    testAccProviders,2738		CheckDestroy: testAccCheckInstanceDestroy,2739		Steps: []resource.TestStep{2740			{2741				Config: testAccInstanceConfig_creditSpecification_isNotAppliedToNonBurstable(rName),2742				Check: resource.ComposeTestCheckFunc(2743					testAccCheckInstanceExists(resourceName, &v),2744				),2745			},2746			{2747				ResourceName:            resourceName,2748				ImportState:             true,2749				ImportStateVerify:       true,2750				ImportStateVerifyIgnore: []string{"credit_specification"},2751			},2752		},2753	})2754}2755func TestAccAWSInstance_creditSpecificationT3_unspecifiedDefaultsToUnlimited(t *testing.T) {2756	var v ec2.Instance2757	resourceName := "aws_instance.test"2758	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2759	resource.ParallelTest(t, resource.TestCase{2760		PreCheck:     func() { testAccPreCheck(t) },2761		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2762		Providers:    testAccProviders,2763		CheckDestroy: testAccCheckInstanceDestroy,2764		Steps: []resource.TestStep{2765			{2766				Config: testAccInstanceConfig_creditSpecification_unspecified_t3(rName),2767				Check: resource.ComposeTestCheckFunc(2768					testAccCheckInstanceExists(resourceName, &v),2769					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2770					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2771				),2772			},2773			{2774				ResourceName:      resourceName,2775				ImportState:       true,2776				ImportStateVerify: true,2777			},2778		},2779	})2780}2781func TestAccAWSInstance_creditSpecificationT3_standardCpuCredits(t *testing.T) {2782	var first, second ec2.Instance2783	resourceName := "aws_instance.test"2784	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2785	resource.ParallelTest(t, resource.TestCase{2786		PreCheck:     func() { testAccPreCheck(t) },2787		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2788		Providers:    testAccProviders,2789		CheckDestroy: testAccCheckInstanceDestroy,2790		Steps: []resource.TestStep{2791			{2792				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits_t3(rName),2793				Check: resource.ComposeTestCheckFunc(2794					testAccCheckInstanceExists(resourceName, &first),2795					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2796					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2797				),2798			},2799			{2800				ResourceName:      resourceName,2801				ImportState:       true,2802				ImportStateVerify: true,2803			},2804			{2805				Config: testAccInstanceConfig_creditSpecification_unspecified_t3(rName),2806				Check: resource.ComposeTestCheckFunc(2807					testAccCheckInstanceExists(resourceName, &second),2808					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2809					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2810				),2811			},2812		},2813	})2814}2815func TestAccAWSInstance_creditSpecificationT3_unlimitedCpuCredits(t *testing.T) {2816	var first, second ec2.Instance2817	resourceName := "aws_instance.test"2818	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2819	resource.ParallelTest(t, resource.TestCase{2820		PreCheck:     func() { testAccPreCheck(t) },2821		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2822		Providers:    testAccProviders,2823		CheckDestroy: testAccCheckInstanceDestroy,2824		Steps: []resource.TestStep{2825			{2826				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits_t3(rName),2827				Check: resource.ComposeTestCheckFunc(2828					testAccCheckInstanceExists(resourceName, &first),2829					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2830					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2831				),2832			},2833			{2834				ResourceName:      resourceName,2835				ImportState:       true,2836				ImportStateVerify: true,2837			},2838			{2839				Config: testAccInstanceConfig_creditSpecification_unspecified_t3(rName),2840				Check: resource.ComposeTestCheckFunc(2841					testAccCheckInstanceExists(resourceName, &second),2842					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2843					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2844				),2845			},2846		},2847	})2848}2849func TestAccAWSInstance_creditSpecificationT3_updateCpuCredits(t *testing.T) {2850	var first, second, third ec2.Instance2851	resourceName := "aws_instance.test"2852	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2853	resource.ParallelTest(t, resource.TestCase{2854		PreCheck:     func() { testAccPreCheck(t) },2855		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2856		Providers:    testAccProviders,2857		CheckDestroy: testAccCheckInstanceDestroy,2858		Steps: []resource.TestStep{2859			{2860				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits_t3(rName),2861				Check: resource.ComposeTestCheckFunc(2862					testAccCheckInstanceExists(resourceName, &first),2863					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2864					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2865				),2866			},2867			{2868				ResourceName:      resourceName,2869				ImportState:       true,2870				ImportStateVerify: true,2871			},2872			{2873				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits_t3(rName),2874				Check: resource.ComposeTestCheckFunc(2875					testAccCheckInstanceExists(resourceName, &second),2876					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2877					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2878				),2879			},2880			{2881				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits_t3(rName),2882				Check: resource.ComposeTestCheckFunc(2883					testAccCheckInstanceExists(resourceName, &third),2884					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2885					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2886				),2887			},2888		},2889	})2890}2891func TestAccAWSInstance_creditSpecification_standardCpuCredits_t2Tot3Taint(t *testing.T) {2892	var before, after ec2.Instance2893	resourceName := "aws_instance.test"2894	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2895	resource.ParallelTest(t, resource.TestCase{2896		PreCheck:     func() { testAccPreCheck(t) },2897		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2898		Providers:    testAccProviders,2899		CheckDestroy: testAccCheckInstanceDestroy,2900		Steps: []resource.TestStep{2901			{2902				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits(rName),2903				Check: resource.ComposeTestCheckFunc(2904					testAccCheckInstanceExists(resourceName, &before),2905					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2906					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2907				),2908			},2909			{2910				ResourceName:      resourceName,2911				ImportState:       true,2912				ImportStateVerify: true,2913			},2914			{2915				Config: testAccInstanceConfig_creditSpecification_standardCpuCredits_t3(rName),2916				Check: resource.ComposeTestCheckFunc(2917					testAccCheckInstanceExists(resourceName, &after),2918					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2919					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "standard"),2920				),2921				Taint: []string{resourceName},2922			},2923		},2924	})2925}2926func TestAccAWSInstance_creditSpecification_unlimitedCpuCredits_t2Tot3Taint(t *testing.T) {2927	var before, after ec2.Instance2928	resourceName := "aws_instance.test"2929	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2930	resource.ParallelTest(t, resource.TestCase{2931		PreCheck:     func() { testAccPreCheck(t) },2932		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2933		Providers:    testAccProviders,2934		CheckDestroy: testAccCheckInstanceDestroy,2935		Steps: []resource.TestStep{2936			{2937				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits(rName),2938				Check: resource.ComposeTestCheckFunc(2939					testAccCheckInstanceExists(resourceName, &before),2940					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2941					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2942				),2943			},2944			{2945				ResourceName:      resourceName,2946				ImportState:       true,2947				ImportStateVerify: true,2948			},2949			{2950				Config: testAccInstanceConfig_creditSpecification_unlimitedCpuCredits_t3(rName),2951				Check: resource.ComposeTestCheckFunc(2952					testAccCheckInstanceExists(resourceName, &after),2953					resource.TestCheckResourceAttr(resourceName, "credit_specification.#", "1"),2954					resource.TestCheckResourceAttr(resourceName, "credit_specification.0.cpu_credits", "unlimited"),2955				),2956				Taint: []string{resourceName},2957			},2958		},2959	})2960}2961func TestAccAWSInstance_disappears(t *testing.T) {2962	var v ec2.Instance2963	resourceName := "aws_instance.test"2964	resource.ParallelTest(t, resource.TestCase{2965		PreCheck:     func() { testAccPreCheck(t) },2966		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2967		Providers:    testAccProviders,2968		CheckDestroy: testAccCheckInstanceDestroy,2969		Steps: []resource.TestStep{2970			{2971				Config: testAccInstanceConfigBasic(),2972				Check: resource.ComposeTestCheckFunc(2973					testAccCheckInstanceExists(resourceName, &v),2974					testAccCheckResourceDisappears(testAccProvider, resourceAwsInstance(), resourceName),2975				),2976				ExpectNonEmptyPlan: true,2977			},2978		},2979	})2980}2981func TestAccAWSInstance_UserData_EmptyStringToUnspecified(t *testing.T) {2982	var v ec2.Instance2983	resourceName := "aws_instance.test"2984	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))2985	resource.ParallelTest(t, resource.TestCase{2986		PreCheck:     func() { testAccPreCheck(t) },2987		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),2988		Providers:    testAccProviders,2989		CheckDestroy: testAccCheckInstanceDestroy,2990		Steps: []resource.TestStep{2991			{2992				Config: testAccInstanceConfig_UserData_EmptyString(rName),2993				Check: resource.ComposeTestCheckFunc(2994					testAccCheckInstanceExists(resourceName, &v),2995				),2996			},2997			{2998				ResourceName:            resourceName,2999				ImportState:             true,3000				ImportStateVerify:       true,3001				ImportStateVerifyIgnore: []string{"user_data"},3002			},3003			// Switching should show no difference3004			{3005				Config:             testAccInstanceConfig_UserData_Unspecified(rName),3006				ExpectNonEmptyPlan: false,3007				PlanOnly:           true,3008			},3009		},3010	})3011}3012func TestAccAWSInstance_UserData_UnspecifiedToEmptyString(t *testing.T) {3013	var v ec2.Instance3014	resourceName := "aws_instance.test"3015	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))3016	resource.ParallelTest(t, resource.TestCase{3017		PreCheck:     func() { testAccPreCheck(t) },3018		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3019		Providers:    testAccProviders,3020		CheckDestroy: testAccCheckInstanceDestroy,3021		Steps: []resource.TestStep{3022			{3023				Config: testAccInstanceConfig_UserData_Unspecified(rName),3024				Check: resource.ComposeTestCheckFunc(3025					testAccCheckInstanceExists(resourceName, &v),3026				),3027			},3028			{3029				ResourceName:      resourceName,3030				ImportState:       true,3031				ImportStateVerify: true,3032			},3033			// Switching should show no difference3034			{3035				Config:             testAccInstanceConfig_UserData_EmptyString(rName),3036				ExpectNonEmptyPlan: false,3037				PlanOnly:           true,3038			},3039		},3040	})3041}3042func TestAccAWSInstance_hibernation(t *testing.T) {3043	var instance1, instance2 ec2.Instance3044	resourceName := "aws_instance.test"3045	resource.ParallelTest(t, resource.TestCase{3046		PreCheck:     func() { testAccPreCheck(t) },3047		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3048		Providers:    testAccProviders,3049		CheckDestroy: testAccCheckInstanceDestroy,3050		Steps: []resource.TestStep{3051			{3052				Config: testAccInstanceConfigHibernation(true),3053				Check: resource.ComposeTestCheckFunc(3054					testAccCheckInstanceExists(resourceName, &instance1),3055					resource.TestCheckResourceAttr(resourceName, "hibernation", "true"),3056				),3057			},3058			{3059				ResourceName:      resourceName,3060				ImportState:       true,3061				ImportStateVerify: true,3062			},3063			{3064				Config: testAccInstanceConfigHibernation(false),3065				Check: resource.ComposeTestCheckFunc(3066					testAccCheckInstanceExists(resourceName, &instance2),3067					testAccCheckInstanceRecreated(&instance1, &instance2),3068					resource.TestCheckResourceAttr(resourceName, "hibernation", "false"),3069				),3070			},3071		},3072	})3073}3074func TestAccAWSInstance_metadataOptions(t *testing.T) {3075	var v ec2.Instance3076	resourceName := "aws_instance.test"3077	rName := acctest.RandomWithPrefix("tf-acc-test")3078	resource.ParallelTest(t, resource.TestCase{3079		PreCheck:     func() { testAccPreCheck(t) },3080		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3081		Providers:    testAccProviders,3082		CheckDestroy: testAccCheckInstanceDestroy,3083		Steps: []resource.TestStep{3084			{3085				Config: testAccInstanceConfigMetadataOptions(rName),3086				Check: resource.ComposeTestCheckFunc(3087					testAccCheckInstanceExists(resourceName, &v),3088					resource.TestCheckResourceAttr(resourceName, "metadata_options.#", "1"),3089					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_endpoint", "disabled"),3090					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_tokens", "optional"),3091					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_put_response_hop_limit", "1"),3092				),3093			},3094			{3095				Config: testAccInstanceConfigMetadataOptionsUpdated(rName),3096				Check: resource.ComposeTestCheckFunc(3097					testAccCheckInstanceExists(resourceName, &v),3098					resource.TestCheckResourceAttr(resourceName, "metadata_options.#", "1"),3099					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_endpoint", "enabled"),3100					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_tokens", "required"),3101					resource.TestCheckResourceAttr(resourceName, "metadata_options.0.http_put_response_hop_limit", "2"),3102				),3103			},3104			{3105				ResourceName:      resourceName,3106				ImportState:       true,3107				ImportStateVerify: true,3108			},3109		},3110	})3111}3112func TestAccAWSInstance_enclaveOptions(t *testing.T) {3113	var instance1, instance2 ec2.Instance3114	resourceName := "aws_instance.test"3115	resource.ParallelTest(t, resource.TestCase{3116		PreCheck:     func() { testAccPreCheck(t) },3117		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3118		Providers:    testAccProviders,3119		CheckDestroy: testAccCheckInstanceDestroy,3120		Steps: []resource.TestStep{3121			{3122				Config: testAccInstanceConfigEnclaveOptions(true),3123				Check: resource.ComposeTestCheckFunc(3124					testAccCheckInstanceExists(resourceName, &instance1),3125					resource.TestCheckResourceAttr(resourceName, "enclave_options.#", "1"),3126					resource.TestCheckResourceAttr(resourceName, "enclave_options.0.enabled", "true"),3127				),3128			},3129			{3130				ResourceName:      resourceName,3131				ImportState:       true,3132				ImportStateVerify: true,3133			},3134			{3135				Config: testAccInstanceConfigEnclaveOptions(false),3136				Check: resource.ComposeTestCheckFunc(3137					testAccCheckInstanceExists(resourceName, &instance2),3138					testAccCheckInstanceRecreated(&instance1, &instance2),3139					resource.TestCheckResourceAttr(resourceName, "enclave_options.#", "1"),3140					resource.TestCheckResourceAttr(resourceName, "enclave_options.0.enabled", "false"),3141				),3142			},3143		},3144	})3145}3146func TestAccAWSInstance_CapacityReservation_unspecifiedDefaultsToOpen(t *testing.T) {3147	var v ec2.Instance3148	resourceName := "aws_instance.test"3149	rName := acctest.RandomWithPrefix("tf-acc-test")3150	resource.ParallelTest(t, resource.TestCase{3151		PreCheck:     func() { testAccPreCheck(t) },3152		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3153		Providers:    testAccProviders,3154		CheckDestroy: testAccCheckInstanceDestroy,3155		Steps: []resource.TestStep{3156			{3157				Config: testAccInstanceConfigCapacityReservationSpecification_unspecified(rName),3158				Check: resource.ComposeTestCheckFunc(3159					testAccCheckInstanceExists(resourceName, &v),3160					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3161					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "open"),3162				),3163			},3164			{3165				ResourceName:      resourceName,3166				ImportState:       true,3167				ImportStateVerify: true,3168			},3169			// Adding 'open' preference should show no difference3170			{3171				Config:             testAccInstanceConfigCapacityReservationSpecification_preference(rName, "open"),3172				ExpectNonEmptyPlan: false,3173				PlanOnly:           true,3174			},3175		},3176	})3177}3178func TestAccAWSInstance_CapacityReservation_Preference_open(t *testing.T) {3179	var v ec2.Instance3180	resourceName := "aws_instance.test"3181	rName := acctest.RandomWithPrefix("tf-acc-test")3182	resource.ParallelTest(t, resource.TestCase{3183		PreCheck:     func() { testAccPreCheck(t) },3184		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3185		Providers:    testAccProviders,3186		CheckDestroy: testAccCheckInstanceDestroy,3187		Steps: []resource.TestStep{3188			{3189				Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "open"),3190				Check: resource.ComposeTestCheckFunc(3191					testAccCheckInstanceExists(resourceName, &v),3192					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3193					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "open"),3194				),3195			},3196			{3197				ResourceName:      resourceName,3198				ImportState:       true,3199				ImportStateVerify: true,3200			},3201		},3202	})3203}3204func TestAccAWSInstance_CapacityReservation_Preference_none(t *testing.T) {3205	var v ec2.Instance3206	resourceName := "aws_instance.test"3207	rName := acctest.RandomWithPrefix("tf-acc-test")3208	resource.ParallelTest(t, resource.TestCase{3209		PreCheck:     func() { testAccPreCheck(t) },3210		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3211		Providers:    testAccProviders,3212		CheckDestroy: testAccCheckInstanceDestroy,3213		Steps: []resource.TestStep{3214			{3215				Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "none"),3216				Check: resource.ComposeTestCheckFunc(3217					testAccCheckInstanceExists(resourceName, &v),3218					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3219					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "none"),3220				),3221			},3222			{3223				ResourceName:      resourceName,3224				ImportState:       true,3225				ImportStateVerify: true,3226			},3227		},3228	})3229}3230func TestAccAWSInstance_CapacityReservation_TargetId(t *testing.T) {3231	var v ec2.Instance3232	resourceName := "aws_instance.test"3233	rName := acctest.RandomWithPrefix("tf-acc-test")3234	resource.ParallelTest(t, resource.TestCase{3235		PreCheck:     func() { testAccPreCheck(t) },3236		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3237		Providers:    testAccProviders,3238		CheckDestroy: testAccCheckInstanceDestroy,3239		Steps: []resource.TestStep{3240			{3241				Config: testAccInstanceConfigCapacityReservationSpecification_targetId(rName),3242				Check: resource.ComposeTestCheckFunc(3243					testAccCheckInstanceExists(resourceName, &v),3244					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_target.#", "1"),3245					resource.TestCheckResourceAttrSet(resourceName, "capacity_reservation_specification.0.capacity_reservation_target.0.capacity_reservation_id"),3246				),3247			},3248			{3249				ResourceName:      resourceName,3250				ImportState:       true,3251				ImportStateVerify: true,3252			},3253		},3254	})3255}3256func TestAccAWSInstance_CapacityReservation_modifyPreference(t *testing.T) {3257	var original ec2.Instance3258	var updated ec2.Instance3259	resourceName := "aws_instance.test"3260	rName := acctest.RandomWithPrefix("tf-acc-test")3261	resource.ParallelTest(t, resource.TestCase{3262		PreCheck:     func() { testAccPreCheck(t) },3263		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3264		Providers:    testAccProviders,3265		CheckDestroy: testAccCheckInstanceDestroy,3266		Steps: []resource.TestStep{3267			{3268				Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "open"),3269				Check: resource.ComposeTestCheckFunc(3270					testAccCheckInstanceExists(resourceName, &original),3271					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3272					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "open"),3273				),3274			},3275			{Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "open"),3276				Check: resource.ComposeTestCheckFunc(3277					testAccCheckStopInstance(&original), // Stop instance to modify capacity reservation3278				),3279			},3280			{3281				Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "none"),3282				Check: resource.ComposeTestCheckFunc(3283					testAccCheckInstanceExists(resourceName, &updated),3284					testAccCheckInstanceNotRecreated(&original, &updated),3285					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3286					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "none"),3287				),3288			},3289		},3290	})3291}3292func TestAccAWSInstance_CapacityReservation_modifyTarget(t *testing.T) {3293	var original ec2.Instance3294	var updated ec2.Instance3295	resourceName := "aws_instance.test"3296	rName := acctest.RandomWithPrefix("tf-acc-test")3297	resource.ParallelTest(t, resource.TestCase{3298		PreCheck:     func() { testAccPreCheck(t) },3299		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3300		Providers:    testAccProviders,3301		CheckDestroy: testAccCheckInstanceDestroy,3302		Steps: []resource.TestStep{3303			{3304				Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "none"),3305				Check: resource.ComposeTestCheckFunc(3306					testAccCheckInstanceExists(resourceName, &original),3307					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.#", "1"),3308					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_preference", "none"),3309				),3310			},3311			{Config: testAccInstanceConfigCapacityReservationSpecification_preference(rName, "none"),3312				Check: resource.ComposeTestCheckFunc(3313					testAccCheckStopInstance(&original), // Stop instance to modify capacity reservation3314				),3315			},3316			{3317				Config: testAccInstanceConfigCapacityReservationSpecification_targetId(rName),3318				Check: resource.ComposeTestCheckFunc(3319					testAccCheckInstanceExists(resourceName, &updated),3320					testAccCheckInstanceNotRecreated(&original, &updated),3321					resource.TestCheckResourceAttr(resourceName, "capacity_reservation_specification.0.capacity_reservation_target.#", "1"),3322					resource.TestCheckResourceAttrSet(resourceName, "capacity_reservation_specification.0.capacity_reservation_target.0.capacity_reservation_id"),3323				),3324			},3325		},3326	})3327}3328func testAccCheckInstanceNotRecreated(before, after *ec2.Instance) resource.TestCheckFunc {3329	return func(s *terraform.State) error {3330		if before, after := aws.StringValue(before.InstanceId), aws.StringValue(after.InstanceId); before != after {3331			return fmt.Errorf("EC2 Instance (%s/%s) recreated", before, after)3332		}3333		return nil3334	}3335}3336func testAccCheckInstanceRecreated(before, after *ec2.Instance) resource.TestCheckFunc {3337	return func(s *terraform.State) error {3338		if before, after := aws.StringValue(before.InstanceId), aws.StringValue(after.InstanceId); before == after {3339			return fmt.Errorf("EC2 Instance (%s) not recreated", before)3340		}3341		return nil3342	}3343}3344func testAccCheckInstanceDestroy(s *terraform.State) error {3345	return testAccCheckInstanceDestroyWithProvider(s, testAccProvider)3346}3347func testAccCheckInstanceDestroyWithProvider(s *terraform.State, provider *schema.Provider) error {3348	conn := provider.Meta().(*AWSClient).ec2conn3349	for _, rs := range s.RootModule().Resources {3350		if rs.Type != "aws_instance" {3351			continue3352		}3353		// Try to find the resource3354		instance, err := resourceAwsInstanceFindByID(conn, rs.Primary.ID)3355		if err == nil {3356			if instance.State != nil && *instance.State.Name != "terminated" {3357				return fmt.Errorf("Found unterminated instance: %s", rs.Primary.ID)3358			}3359		}3360		// Verify the error is what we want3361		if isAWSErr(err, "InvalidInstanceID.NotFound", "") {3362			continue3363		}3364		return err3365	}3366	return nil3367}3368func testAccCheckInstanceExists(n string, i *ec2.Instance) resource.TestCheckFunc {3369	return testAccCheckInstanceExistsWithProvider(n, i, func() *schema.Provider { return testAccProvider })3370}3371func testAccCheckInstanceEc2ClassicExists(n string, i *ec2.Instance) resource.TestCheckFunc {3372	return testAccCheckInstanceExistsWithProvider(n, i, func() *schema.Provider { return testAccProviderEc2Classic })3373}3374func testAccCheckInstanceExistsWithProvider(n string, i *ec2.Instance, providerF func() *schema.Provider) resource.TestCheckFunc {3375	return func(s *terraform.State) error {3376		rs, ok := s.RootModule().Resources[n]3377		if !ok {3378			return fmt.Errorf("Not found: %s", n)3379		}3380		if rs.Primary.ID == "" {3381			return fmt.Errorf("No ID is set")3382		}3383		provider := providerF()3384		conn := provider.Meta().(*AWSClient).ec2conn3385		instance, err := resourceAwsInstanceFindByID(conn, rs.Primary.ID)3386		if err != nil {3387			return err3388		}3389		if instance != nil {3390			*i = *instance3391			return nil3392		}3393		return fmt.Errorf("Instance not found")3394	}3395}3396func testAccCheckStopInstance(instance *ec2.Instance) resource.TestCheckFunc {3397	return func(s *terraform.State) error {3398		conn := testAccProvider.Meta().(*AWSClient).ec2conn3399		params := &ec2.StopInstancesInput{3400			InstanceIds: []*string{instance.InstanceId},3401		}3402		if _, err := conn.StopInstances(params); err != nil {3403			return err3404		}3405		return waitForInstanceStopping(conn, *instance.InstanceId, 10*time.Minute)3406	}3407}3408func TestInstanceHostIDSchema(t *testing.T) {3409	actualSchema := resourceAwsInstance().Schema["host_id"]3410	expectedSchema := &schema.Schema{3411		Type:     schema.TypeString,3412		Optional: true,3413		Computed: true,3414		ForceNew: true,3415	}3416	if !reflect.DeepEqual(actualSchema, expectedSchema) {3417		t.Fatalf(3418			"Got:\n\n%#v\n\nExpected:\n\n%#v\n",3419			actualSchema,3420			expectedSchema)3421	}3422}3423func TestInstanceCpuCoreCountSchema(t *testing.T) {3424	actualSchema := resourceAwsInstance().Schema["cpu_core_count"]3425	expectedSchema := &schema.Schema{3426		Type:     schema.TypeInt,3427		Optional: true,3428		Computed: true,3429		ForceNew: true,3430	}3431	if !reflect.DeepEqual(actualSchema, expectedSchema) {3432		t.Fatalf(3433			"Got:\n\n%#v\n\nExpected:\n\n%#v\n",3434			actualSchema,3435			expectedSchema)3436	}3437}3438func TestInstanceCpuThreadsPerCoreSchema(t *testing.T) {3439	actualSchema := resourceAwsInstance().Schema["cpu_threads_per_core"]3440	expectedSchema := &schema.Schema{3441		Type:     schema.TypeInt,3442		Optional: true,3443		Computed: true,3444		ForceNew: true,3445	}3446	if !reflect.DeepEqual(actualSchema, expectedSchema) {3447		t.Fatalf(3448			"Got:\n\n%#v\n\nExpected:\n\n%#v\n",3449			actualSchema,3450			expectedSchema)3451	}3452}3453func driftTags(instance *ec2.Instance) resource.TestCheckFunc {3454	return func(s *terraform.State) error {3455		conn := testAccProvider.Meta().(*AWSClient).ec2conn3456		_, err := conn.CreateTags(&ec2.CreateTagsInput{3457			Resources: []*string{instance.InstanceId},3458			Tags: []*ec2.Tag{3459				{3460					Key:   aws.String("Drift"),3461					Value: aws.String("Happens"),3462				},3463			},3464		})3465		return err3466	}3467}3468func testAccAvailableAZsNoOptInDefaultExcludeConfig() string {3469	// Exclude usw2-az4 (us-west-2d) as it has limited instance types.3470	return testAccAvailableAZsNoOptInExcludeConfig("usw2-az4", "usgw1-az2")3471}3472func testAccAvailableAZsNoOptInExcludeConfig(excludeZoneIds ...string) string {3473	return fmt.Sprintf(`3474data "aws_availability_zones" "available" {3475  exclude_zone_ids = ["%[1]s"]3476  state            = "available"3477  filter {3478    name   = "opt-in-status"3479    values = ["opt-in-not-required"]3480  }3481}3482`, strings.Join(excludeZoneIds, "\", \""))3483}3484func testAccAvailableAZsNoOptInConfig() string {3485	return `3486data "aws_availability_zones" "available" {3487  state = "available"3488  filter {3489    name   = "opt-in-status"3490    values = ["opt-in-not-required"]3491  }3492}3493`3494}3495func testAccAvailableAZsWavelengthZonesExcludeConfig(excludeZoneIds ...string) string {3496	return fmt.Sprintf(`3497data "aws_availability_zones" "available" {3498  exclude_zone_ids = ["%[1]s"]3499  state            = "available"3500  filter {3501    name   = "zone-type"3502    values = ["wavelength-zone"]3503  }3504  filter {3505    name   = "opt-in-status"3506    values = ["opted-in"]3507  }3508}3509`, strings.Join(excludeZoneIds, "\", \""))3510}3511func testAccAvailableAZsWavelengthZonesDefaultExcludeConfig() string {3512	// Exclude usw2-wl1-den-wlz1 as there may be problems allocating carrier IP addresses.3513	return testAccAvailableAZsWavelengthZonesExcludeConfig("usw2-wl1-den-wlz1")3514}3515func testAccInstanceConfigInDefaultVpcBySgName(rName string) string {3516	return composeConfig(3517		testAccAvailableAZsNoOptInDefaultExcludeConfig(),3518		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3519		fmt.Sprintf(`3520data "aws_vpc" "default" {3521  default = true3522}3523resource "aws_security_group" "test" {3524  name        = %[1]q3525  description = %[1]q3526  vpc_id      = data.aws_vpc.default.id3527}3528resource "aws_instance" "test" {3529  ami               = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3530  instance_type     = "t2.micro"3531  security_groups   = [aws_security_group.test.name]3532  availability_zone = data.aws_availability_zones.available.names[0]3533}3534`, rName))3535}3536func testAccInstanceConfigInDefaultVpcBySgId(rName string) string {3537	return composeConfig(3538		testAccAvailableAZsNoOptInDefaultExcludeConfig(),3539		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3540		fmt.Sprintf(`3541data "aws_vpc" "default" {3542  default = true3543}3544resource "aws_security_group" "test" {3545  name        = %[1]q3546  description = %[1]q3547  vpc_id      = data.aws_vpc.default.id3548}3549resource "aws_instance" "test" {3550  ami                    = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3551  instance_type          = "t2.micro"3552  vpc_security_group_ids = [aws_security_group.test.id]3553  availability_zone      = data.aws_availability_zones.available.names[0]3554}3555`, rName))3556}3557func testAccInstanceConfigInEc2Classic() string {3558	return composeConfig(3559		testAccEc2ClassicRegionProviderConfig(),3560		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3561		testAccAvailableEc2InstanceTypeForRegion("t1.micro", "m3.medium", "m3.large", "c3.large", "r3.large"),3562		`3563resource "aws_instance" "test" {3564  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3565  instance_type = data.aws_ec2_instance_type_offering.available.instance_type3566}3567`)3568}3569func testAccInstanceConfigBasic() string {3570	return composeConfig(3571		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3572		// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-classic-platform.html#ec2-classic-instance-types3573		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro", "t1.micro", "m1.small"),3574		`3575resource "aws_instance" "test" {3576  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3577  instance_type = data.aws_ec2_instance_type_offering.available.instance_type3578  # Explicitly no tags so as to test creation without tags.3579}3580`)3581}3582func testAccInstanceConfigAtLeastOneOtherEbsVolume(rName string) string {3583	return composeConfig(3584		testAccLatestAmazonLinuxHvmInstanceStoreAmiConfig(),3585		testAccAwsInstanceVpcConfig(rName, false),3586		fmt.Sprintf(`3587# Ensure that there is at least 1 EBS volume in the current region.3588# See https://github.com/hashicorp/terraform/issues/1249.3589resource "aws_ebs_volume" "test" {3590  availability_zone = data.aws_availability_zones.available.names[0]3591  size              = 53592  tags = {3593    Name = %[1]q3594  }3595}3596resource "aws_instance" "test" {3597  ami = data.aws_ami.amzn-ami-minimal-hvm-instance-store.id3598  # tflint-ignore: aws_instance_previous_type3599  instance_type = "m1.small"3600  subnet_id     = aws_subnet.test.id3601  user_data     = "foo:-with-character's"3602  tags = {3603    Name = %[1]q3604  }3605  depends_on = [aws_ebs_volume.test]3606}3607`, rName))3608}3609func testAccInstanceConfigWithUserDataBase64(rName string) string {3610	return composeConfig(3611		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3612		testAccAwsInstanceVpcConfig(rName, false),3613		`3614resource "aws_instance" "test" {3615  ami       = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3616  subnet_id = aws_subnet.test.id3617  instance_type    = "t2.small"3618  user_data_base64 = base64encode("hello world")3619}3620`)3621}3622func testAccInstanceConfigWithSmallInstanceType(rName string) string {3623	return composeConfig(3624		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3625		testAccAwsInstanceVpcConfig(rName, false),3626		`3627resource "aws_instance" "test" {3628  ami       = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3629  subnet_id = aws_subnet.test.id3630  instance_type = "t2.medium"3631  tags = {3632    Name = "tf-acctest"3633  }3634}3635`)3636}3637func testAccInstanceConfigUpdateInstanceType(rName string) string {3638	return composeConfig(3639		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3640		testAccAwsInstanceVpcConfig(rName, false),3641		`3642resource "aws_instance" "test" {3643  ami       = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3644  subnet_id = aws_subnet.test.id3645  instance_type = "t2.large"3646  tags = {3647    Name = "tf-acctest"3648  }3649}3650`)3651}3652func testAccInstanceGP2IopsDevice() string {3653	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `3654resource "aws_instance" "test" {3655  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3656  instance_type = "t2.medium"3657  root_block_device {3658    volume_type = "gp2"3659    volume_size = 113660  }3661}3662`)3663}3664func testAccInstanceGP2WithIopsValue() string {3665	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `3666resource "aws_instance" "test" {3667  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3668  instance_type = "t2.medium"3669  root_block_device {3670    volume_type = "gp2"3671    volume_size = 113672    # configured explicitly3673    iops = 103674  }3675}3676`)3677}3678func testAccInstanceConfigRootInstanceStore() string {3679	return composeConfig(testAccLatestAmazonLinuxHvmInstanceStoreAmiConfig(), `3680resource "aws_instance" "test" {3681  ami = data.aws_ami.amzn-ami-minimal-hvm-instance-store.id3682  # Only certain instance types support ephemeral root instance stores.3683  # http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/InstanceStorage.html3684  # tflint-ignore: aws_instance_previous_type3685  instance_type = "m3.medium"3686}3687`)3688}3689func testAccInstanceConfigNoAMIEphemeralDevices() string {3690	return composeConfig(3691		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3692		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro"),3693		`3694resource "aws_instance" "test" {3695  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3696  instance_type = data.aws_ec2_instance_type_offering.available.instance_type3697  root_block_device {3698    volume_type = "gp2"3699    volume_size = 113700  }3701  ephemeral_block_device {3702    device_name = "/dev/sdb"3703    no_device   = true3704  }3705  ephemeral_block_device {3706    device_name = "/dev/sdc"3707    no_device   = true3708  }3709}3710`)3711}3712func testAccAwsEc2InstanceEbsRootDeviceBasic() string {3713	return composeConfig(testAccAwsEc2InstanceAmiWithEbsRootVolume, `3714resource "aws_instance" "test" {3715  ami = data.aws_ami.ami.id3716  instance_type = "t2.medium"3717}3718`)3719}3720func testAccAwsEc2InstanceRootBlockDevice(size, delete, volumeType string) string {3721	return testAccAwsEc2InstanceRootBlockDeviceWithIOPS(size, delete, volumeType, "")3722}3723func testAccAwsEc2InstanceRootBlockDeviceWithIOPS(size, delete, volumeType, iops string) string {3724	if iops == "" {3725		iops = "null"3726	}3727	return composeConfig(testAccAwsEc2InstanceAmiWithEbsRootVolume, fmt.Sprintf(`3728resource "aws_instance" "test" {3729  ami = data.aws_ami.ami.id3730  instance_type = "t2.medium"3731  root_block_device {3732    volume_size           = %[1]s3733    delete_on_termination = %[2]s3734    volume_type           = %[3]q3735    iops                  = %[4]s3736  }3737}3738`, size, delete, volumeType, iops))3739}3740func testAccAwsEc2InstanceRootBlockDeviceWithThroughput(size, delete, volumeType, throughput string) string {3741	if throughput == "" {3742		throughput = "null"3743	}3744	return composeConfig(testAccAwsEc2InstanceAmiWithEbsRootVolume, fmt.Sprintf(`3745resource "aws_instance" "test" {3746  ami = data.aws_ami.ami.id3747  instance_type = "t2.medium"3748  root_block_device {3749    volume_size           = %[1]s3750    delete_on_termination = %[2]s3751    volume_type           = %[3]q3752    throughput            = %[4]s3753  }3754}3755`, size, delete, volumeType, throughput))3756}3757func TestAccAWSInstance_GP3RootBlockDevice(t *testing.T) {3758	var v ec2.Instance3759	resourceName := "aws_instance.test"3760	testCheck := func() resource.TestCheckFunc {3761		return func(*terraform.State) error {3762			// Map out the block devices by name, which should be unique.3763			blockDevices := make(map[string]*ec2.InstanceBlockDeviceMapping)3764			for _, blockDevice := range v.BlockDeviceMappings {3765				blockDevices[*blockDevice.DeviceName] = blockDevice3766			}3767			// Check if the root block device exists.3768			if _, ok := blockDevices["/dev/xvda"]; !ok {3769				return fmt.Errorf("block device doesn't exist: /dev/xvda")3770			}3771			return nil3772		}3773	}3774	resource.ParallelTest(t, resource.TestCase{3775		PreCheck:     func() { testAccPreCheck(t) },3776		ErrorCheck:   testAccErrorCheck(t, ec2.EndpointsID),3777		Providers:    testAccProviders,3778		CheckDestroy: testAccCheckInstanceDestroy,3779		Steps: []resource.TestStep{3780			{3781				Config: testAccInstanceConfigGP3RootBlockDevice(),3782				Check: resource.ComposeTestCheckFunc(3783					testAccCheckInstanceExists(resourceName, &v),3784					resource.TestCheckResourceAttr(resourceName, "root_block_device.#", "1"),3785					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_size", "10"),3786					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.volume_type", "gp3"),3787					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.iops", "4000"),3788					resource.TestCheckResourceAttr(resourceName, "root_block_device.0.throughput", "300"),3789					testCheck(),3790				),3791			},3792			{3793				ResourceName:      resourceName,3794				ImportState:       true,3795				ImportStateVerify: true,3796			},3797		},3798	})3799}3800func testAccInstanceConfigGP3RootBlockDevice() string {3801	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `3802resource "aws_instance" "test" {3803  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3804  instance_type = "t2.medium"3805  root_block_device {3806    volume_size = 103807    volume_type = "gp3"3808    throughput  = 3003809    iops        = 40003810  }3811}3812`)3813}3814const testAccAwsEc2InstanceAmiWithEbsRootVolume = `3815data "aws_ami" "ami" {3816  owners      = ["amazon"]3817  most_recent = true3818  filter {3819    name   = "name"3820    values = ["amzn2-ami-*"]3821  }3822  filter {3823    name   = "root-device-type"3824    values = ["ebs"]3825  }3826  filter {3827    name   = "architecture"3828    values = ["x86_64"]3829  }3830}3831`3832func testAccAwsEc2InstanceConfigBlockDevices(size string) string {3833	return testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(size, "")3834}3835func testAccAwsEc2InstanceConfigBlockDevicesWithDeleteOnTerminate(size, delete string) string {3836	if delete == "" {3837		delete = "null"3838	}3839	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`3840resource "aws_instance" "test" {3841  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3842  instance_type = "t2.medium"3843  root_block_device {3844    volume_type           = "gp2"3845    volume_size           = %[1]s3846    delete_on_termination = %[2]s3847  }3848  ebs_block_device {3849    device_name = "/dev/sdb"3850    volume_size = 93851  }3852  ebs_block_device {3853    device_name = "/dev/sdc"3854    volume_size = 103855    volume_type = "io1"3856    iops        = 1003857  }3858  # Encrypted ebs block device3859  ebs_block_device {3860    device_name = "/dev/sdd"3861    volume_size = 123862    encrypted   = true3863  }3864  ephemeral_block_device {3865    device_name  = "/dev/sde"3866    virtual_name = "ephemeral0"3867  }3868  ebs_block_device {3869    device_name = "/dev/sdf"3870    volume_size = 103871    volume_type = "gp3"3872    throughput  = 3003873  }3874  ebs_block_device {3875    device_name = "/dev/sdg"3876    volume_size = 103877    volume_type = "gp3"3878    throughput  = 3003879    iops        = 40003880  }3881}3882`, size, delete))3883}3884func testAccInstanceConfigSourceDestEnable(rName string) string {3885	return composeConfig(3886		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3887		testAccAwsInstanceVpcConfig(rName, false),3888		`3889resource "aws_instance" "test" {3890  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3891  instance_type = "t2.small"3892  subnet_id     = aws_subnet.test.id3893}3894`)3895}3896func testAccInstanceConfigSourceDestDisable(rName string) string {3897	return composeConfig(3898		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3899		testAccAwsInstanceVpcConfig(rName, false),3900		`3901resource "aws_instance" "test" {3902  ami               = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3903  instance_type     = "t2.small"3904  subnet_id         = aws_subnet.test.id3905  source_dest_check = false3906}3907`)3908}3909func testAccInstanceConfigDisableAPITermination(rName string, val bool) string {3910	return composeConfig(3911		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3912		testAccAwsInstanceVpcConfig(rName, false),3913		fmt.Sprintf(`3914resource "aws_instance" "test" {3915  ami                     = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3916  instance_type           = "t2.small"3917  subnet_id               = aws_subnet.test.id3918  disable_api_termination = %[1]t3919}3920`, val))3921}3922func testAccEc2InstanceConfigDedicatedInstance(rName string) string {3923	return composeConfig(3924		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3925		testAccAwsInstanceVpcConfig(rName, false),3926		`3927resource "aws_instance" "test" {3928  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3929  # tflint-ignore: aws_instance_previous_type3930  instance_type               = "m1.small"3931  subnet_id                   = aws_subnet.test.id3932  associate_public_ip_address = true3933  tenancy                     = "dedicated"3934  # pre-encoded base64 data3935  user_data = "3dc39dda39be1205215e776bad998da361a5955d"3936}3937`)3938}3939func testAccInstanceConfigOutpost() string {3940	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `3941data "aws_outposts_outposts" "test" {}3942data "aws_outposts_outpost" "test" {3943  id = tolist(data.aws_outposts_outposts.test.ids)[0]3944}3945data "aws_outposts_outpost_instance_types" "test" {3946  arn = data.aws_outposts_outpost.test.arn3947}3948resource "aws_vpc" "test" {3949  cidr_block = "10.1.0.0/16"3950}3951resource "aws_subnet" "test" {3952  availability_zone = data.aws_outposts_outpost.test.availability_zone3953  cidr_block        = "10.1.1.0/24"3954  outpost_arn       = data.aws_outposts_outpost.test.arn3955  vpc_id            = aws_vpc.test.id3956}3957resource "aws_instance" "test" {3958  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3959  instance_type = tolist(data.aws_outposts_outpost_instance_types.test.instance_types)[0]3960  subnet_id     = aws_subnet.test.id3961  root_block_device {3962    volume_type = "gp2"3963    volume_size = 83964  }3965}3966`)3967}3968func testAccInstanceConfigPlacementGroup(rName string) string {3969	return composeConfig(3970		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3971		testAccAwsInstanceVpcConfig(rName, false),3972		fmt.Sprintf(`3973resource "aws_placement_group" "test" {3974  name     = %[1]q3975  strategy = "cluster"3976}3977# Limitations: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#concepts-placement-groups3978resource "aws_instance" "test" {3979  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3980  instance_type               = "c5.large"3981  subnet_id                   = aws_subnet.test.id3982  associate_public_ip_address = true3983  placement_group             = aws_placement_group.test.name3984  # pre-encoded base64 data3985  user_data = "3dc39dda39be1205215e776bad998da361a5955d"3986}3987`, rName))3988}3989func testAccInstanceConfigIpv6ErrorConfig(rName string) string {3990	return composeConfig(3991		testAccLatestAmazonLinuxHvmEbsAmiConfig(),3992		testAccAwsInstanceVpcIpv6Config(rName),3993		fmt.Sprintf(`3994resource "aws_instance" "test" {3995  ami                = data.aws_ami.amzn-ami-minimal-hvm-ebs.id3996  instance_type      = "t2.micro"3997  subnet_id          = aws_subnet.test.id3998  ipv6_addresses     = ["2600:1f14:bb2:e501::10"]3999  ipv6_address_count = 14000  tags = {4001    Name = %[1]q4002  }4003}4004`, rName))4005}4006func testAccInstanceConfigIpv6Support(rName string) string {4007	return composeConfig(4008		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4009		testAccAwsInstanceVpcIpv6Config(rName),4010		fmt.Sprintf(`4011resource "aws_instance" "test" {4012  ami                = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4013  instance_type      = "t2.micro"4014  subnet_id          = aws_subnet.test.id4015  ipv6_address_count = 14016  tags = {4017    Name = %[1]q4018  }4019}4020`, rName))4021}4022func testAccInstanceConfigIpv6SupportWithIpv4(rName string) string {4023	return composeConfig(4024		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4025		testAccAwsInstanceVpcIpv6Config(rName),4026		fmt.Sprintf(`4027resource "aws_instance" "test" {4028  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4029  instance_type               = "t2.micro"4030  subnet_id                   = aws_subnet.test.id4031  associate_public_ip_address = true4032  ipv6_address_count          = 14033  tags = {4034    Name = %[1]q4035  }4036}4037`, rName))4038}4039func testAccInstanceConfigTags() string {4040	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4041resource "aws_instance" "test" {4042  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4043  instance_type = "t2.small"4044  tags = {4045    test = "test2"4046  }4047}4048`)4049}4050func testAccInstanceConfigEbsBlockDeviceKmsKeyArn() string {4051	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4052resource "aws_kms_key" "test" {4053  deletion_window_in_days = 74054}4055resource "aws_instance" "test" {4056  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4057  instance_type = "t2.medium"4058  root_block_device {4059    volume_type = "gp2"4060    volume_size = 114061  }4062  # Encrypted ebs block device4063  ebs_block_device {4064    device_name = "/dev/sdd"4065    encrypted   = true4066    kms_key_id  = aws_kms_key.test.arn4067    volume_size = 124068  }4069}4070`)4071}4072func testAccInstanceConfigRootBlockDeviceKmsKeyArn(rName string) string {4073	return composeConfig(4074		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4075		testAccAwsInstanceVpcConfig(rName, false),4076		`4077resource "aws_kms_key" "test" {4078  deletion_window_in_days = 74079}4080resource "aws_instance" "test" {4081  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4082  instance_type = "t3.nano"4083  subnet_id     = aws_subnet.test.id4084  root_block_device {4085    delete_on_termination = true4086    encrypted             = true4087    kms_key_id            = aws_kms_key.test.arn4088  }4089}4090`)4091}4092func testAccInstanceConfigBlockDeviceTagsAttachedVolumeWithTags(rName string) string {4093	// https://github.com/hashicorp/terraform-provider-aws/issues/170744094	return composeConfig(4095		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4096		testAccAvailableAZsNoOptInConfig(),4097		testAccAvailableEc2InstanceTypeForAvailabilityZone("data.aws_availability_zones.available.names[0]", "t3.micro", "t2.micro"),4098		fmt.Sprintf(`4099resource "aws_instance" "test" {4100  ami               = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4101  instance_type     = data.aws_ec2_instance_type_offering.available.instance_type4102  availability_zone = data.aws_availability_zones.available.names[0]4103}4104resource "aws_ebs_volume" "test" {4105  availability_zone = aws_instance.test.availability_zone4106  size              = "10"4107  type              = "gp2"4108  tags = {4109    Name   = %[1]q4110    Factum = "PerAsperaAdAstra"4111  }4112}4113resource "aws_volume_attachment" "test" {4114  device_name = "/dev/xvdg"4115  volume_id   = aws_ebs_volume.test.id4116  instance_id = aws_instance.test.id4117}4118`, rName))4119}4120func testAccInstanceConfigBlockDeviceTagsAttachedVolumeWithTagsUpdate(rName string) string {4121	// https://github.com/hashicorp/terraform-provider-aws/issues/170744122	return composeConfig(4123		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4124		testAccAvailableAZsNoOptInConfig(),4125		testAccAvailableEc2InstanceTypeForAvailabilityZone("data.aws_availability_zones.available.names[0]", "t3.micro", "t2.micro"),4126		fmt.Sprintf(`4127resource "aws_instance" "test" {4128  ami               = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4129  instance_type     = data.aws_ec2_instance_type_offering.available.instance_type4130  availability_zone = data.aws_availability_zones.available.names[0]4131}4132resource "aws_ebs_volume" "test" {4133  availability_zone = aws_instance.test.availability_zone4134  size              = "10"4135  type              = "gp2"4136  tags = {4137    Name   = %[1]q4138    Factum = "VincitQuiSeVincit"4139  }4140}4141resource "aws_volume_attachment" "test" {4142  device_name = "/dev/xvdg"4143  volume_id   = aws_ebs_volume.test.id4144  instance_id = aws_instance.test.id4145}4146`, rName))4147}4148func testAccInstanceConfigBlockDeviceTagsRootTagsConflict() string {4149	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4150resource "aws_instance" "test" {4151  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4152  instance_type = "t2.medium"4153  root_block_device {4154    volume_type = "gp2"4155    volume_size = 114156    tags = {4157      Name = "root-tag"4158    }4159  }4160  ebs_block_device {4161    device_name = "/dev/sdb"4162    volume_size = 94163  }4164  volume_tags = {4165    Name = "volume-tags"4166  }4167}4168`)4169}4170func testAccInstanceConfigBlockDeviceTagsEBSTagsConflict() string {4171	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4172resource "aws_instance" "test" {4173  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4174  instance_type = "t2.medium"4175  root_block_device {4176    volume_type = "gp2"4177    volume_size = 114178  }4179  ebs_block_device {4180    device_name = "/dev/sdb"4181    volume_size = 94182    tags = {4183      Name = "ebs-volume"4184    }4185  }4186  volume_tags = {4187    Name = "volume-tags"4188  }4189}4190`)4191}4192func testAccInstanceConfigBlockDeviceTagsNoVolumeTags() string {4193	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4194resource "aws_instance" "test" {4195  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4196  instance_type = "t2.medium"4197  root_block_device {4198    volume_type = "gp2"4199    volume_size = 114200  }4201  ebs_block_device {4202    device_name = "/dev/sdb"4203    volume_size = 94204  }4205  ebs_block_device {4206    device_name = "/dev/sdc"4207    volume_size = 104208    volume_type = "io1"4209    iops        = 1004210  }4211  ebs_block_device {4212    device_name = "/dev/sdd"4213    volume_size = 124214    encrypted   = true4215  }4216  ephemeral_block_device {4217    device_name  = "/dev/sde"4218    virtual_name = "ephemeral0"4219  }4220}4221`)4222}4223func testAccInstanceConfigBlockDeviceTagsEBSTags(rName string) string {4224	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4225resource "aws_instance" "test" {4226  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4227  instance_type = "t2.medium"4228  root_block_device {4229    volume_type = "gp2"4230  }4231  ebs_block_device {4232    device_name = "/dev/sdb"4233    volume_size = 14234    tags = {4235      Name = %[1]q4236    }4237  }4238  ebs_block_device {4239    device_name = "/dev/sdc"4240    volume_size = 14241  }4242  ephemeral_block_device {4243    device_name  = "/dev/sde"4244    virtual_name = "ephemeral0"4245  }4246}4247`, rName))4248}4249func testAccInstanceConfigBlockDeviceTagsEBSAndRootTags(rName string) string {4250	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4251resource "aws_instance" "test" {4252  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4253  instance_type = "t2.medium"4254  root_block_device {4255    volume_type = "gp2"4256    tags = {4257      Name    = %[1]q4258      Purpose = "test"4259    }4260  }4261  ebs_block_device {4262    device_name = "/dev/sdb"4263    volume_size = 14264    tags = {4265      Name = %[1]q4266    }4267  }4268  ebs_block_device {4269    device_name = "/dev/sdc"4270    volume_size = 14271  }4272  ephemeral_block_device {4273    device_name  = "/dev/sde"4274    virtual_name = "ephemeral0"4275  }4276}4277`, rName))4278}4279func testAccInstanceConfigBlockDeviceTagsEBSAndRootTagsUpdate(rName string) string {4280	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4281resource "aws_instance" "test" {4282  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4283  instance_type = "t2.medium"4284  root_block_device {4285    volume_type = "gp2"4286    tags = {4287      Name = %[1]q4288      Env  = "dev"4289    }4290  }4291  ebs_block_device {4292    device_name = "/dev/sdb"4293    volume_size = 14294    tags = {4295      Name = %[1]q4296    }4297  }4298  ebs_block_device {4299    device_name = "/dev/sdc"4300    volume_size = 14301  }4302  ephemeral_block_device {4303    device_name  = "/dev/sde"4304    virtual_name = "ephemeral0"4305  }4306}4307`, rName))4308}4309var testAccInstanceConfigEBSBlockDeviceInvalidIops = composeConfig(testAccAwsEc2InstanceAmiWithEbsRootVolume, `4310resource "aws_instance" "test" {4311  ami = data.aws_ami.ami.id4312  instance_type = "t2.medium"4313  ebs_block_device {4314    device_name = "/dev/sdc"4315    volume_size = 104316    volume_type = "gp2"4317    iops        = 1004318  }4319}4320`)4321var testAccInstanceConfigEBSBlockDeviceInvalidThroughput = composeConfig(testAccAwsEc2InstanceAmiWithEbsRootVolume, `4322resource "aws_instance" "test" {4323  ami = data.aws_ami.ami.id4324  instance_type = "t2.medium"4325  ebs_block_device {4326    device_name = "/dev/sdc"4327    volume_size = 104328    volume_type = "gp2"4329    throughput  = 3004330  }4331}4332`)4333func testAccInstanceConfigBlockDeviceTagsVolumeTags() string {4334	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4335resource "aws_instance" "test" {4336  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4337  instance_type = "t2.medium"4338  root_block_device {4339    volume_type = "gp2"4340    volume_size = 114341  }4342  ebs_block_device {4343    device_name = "/dev/sdb"4344    volume_size = 94345  }4346  ebs_block_device {4347    device_name = "/dev/sdc"4348    volume_size = 104349    volume_type = "io1"4350    iops        = 1004351  }4352  ebs_block_device {4353    device_name = "/dev/sdd"4354    volume_size = 124355    encrypted   = true4356  }4357  ephemeral_block_device {4358    device_name  = "/dev/sde"4359    virtual_name = "ephemeral0"4360  }4361  volume_tags = {4362    Name = "acceptance-test-volume-tag"4363  }4364}4365`)4366}4367func testAccInstanceConfigBlockDeviceTagsVolumeTagsUpdate() string {4368	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4369resource "aws_instance" "test" {4370  ami = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4371  instance_type = "t2.medium"4372  root_block_device {4373    volume_type = "gp2"4374    volume_size = 114375  }4376  ebs_block_device {4377    device_name = "/dev/sdb"4378    volume_size = 94379  }4380  ebs_block_device {4381    device_name = "/dev/sdc"4382    volume_size = 104383    volume_type = "io1"4384    iops        = 1004385  }4386  ebs_block_device {4387    device_name = "/dev/sdd"4388    volume_size = 124389    encrypted   = true4390  }4391  ephemeral_block_device {4392    device_name  = "/dev/sde"4393    virtual_name = "ephemeral0"4394  }4395  volume_tags = {4396    Name        = "acceptance-test-volume-tag"4397    Environment = "dev"4398  }4399}4400`)4401}4402func testAccInstanceConfigTagsUpdate() string {4403	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), `4404resource "aws_instance" "test" {4405  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4406  instance_type = "t2.small"4407  tags = {4408    test2 = "test3"4409  }4410}4411`)4412}4413func testAccInstanceConfigWithoutInstanceProfile(rName string) string {4414	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4415resource "aws_iam_role" "test" {4416  name = %[1]q4417  assume_role_policy = <<EOF4418{4419  "Version": "2012-10-17",4420  "Statement": [4421    {4422      "Effect": "Allow",4423      "Principal": {4424        "Service": [4425          "ec2.amazonaws.com"4426        ]4427      },4428      "Action": [4429        "sts:AssumeRole"4430      ]4431    }4432  ]4433}4434EOF4435}4436resource "aws_instance" "test" {4437  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4438  instance_type = "t2.small"4439  tags = {4440    Name = %[1]q4441  }4442}4443`, rName))4444}4445func testAccInstanceConfigWithInstanceProfile(rName string) string {4446	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4447resource "aws_iam_role" "test" {4448  name = %[1]q4449  assume_role_policy = <<EOF4450{4451  "Version": "2012-10-17",4452  "Statement": [4453    {4454      "Effect": "Allow",4455      "Principal": {4456        "Service": [4457          "ec2.amazonaws.com"4458        ]4459      },4460      "Action": [4461        "sts:AssumeRole"4462      ]4463    }4464  ]4465}4466EOF4467}4468resource "aws_iam_instance_profile" "test" {4469  name = %[1]q4470  role = aws_iam_role.test.name4471}4472resource "aws_instance" "test" {4473  ami                  = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4474  instance_type        = "t2.small"4475  iam_instance_profile = aws_iam_instance_profile.test.name4476  tags = {4477    Name = %[1]q4478  }4479}4480`, rName))4481}4482func testAccInstanceConfigWithInstanceProfilePath(rName string) string {4483	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4484data "aws_partition" "current" {}4485resource "aws_iam_role" "test" {4486  name = %[1]q4487  assume_role_policy = <<EOF4488{4489  "Version": "2012-10-17",4490  "Statement": [4491    {4492      "Effect": "Allow",4493      "Principal": {4494        "Service": [4495          "ec2.${data.aws_partition.current.dns_suffix}"4496        ]4497      },4498      "Action": [4499        "sts:AssumeRole"4500      ]4501    }4502  ]4503}4504EOF4505}4506resource "aws_iam_instance_profile" "test" {4507  name = %[1]q4508  path = "/test/"4509  role = aws_iam_role.test.name4510}4511resource "aws_instance" "test" {4512  ami                  = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4513  instance_type        = "t2.small"4514  iam_instance_profile = aws_iam_instance_profile.test.name4515  tags = {4516    Name = %[1]q4517  }4518}4519`, rName))4520}4521func testAccInstanceConfigPrivateIP(rName string) string {4522	return composeConfig(4523		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4524		testAccAwsInstanceVpcConfig(rName, false),4525		`4526resource "aws_instance" "test" {4527  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4528  instance_type = "t2.micro"4529  subnet_id     = aws_subnet.test.id4530  private_ip    = "10.1.1.42"4531}4532`)4533}4534func testAccInstanceConfigEmptyPrivateIP(rName string) string {4535	return composeConfig(4536		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4537		testAccAwsInstanceVpcConfig(rName, false),4538		`4539resource "aws_instance" "test" {4540  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4541  instance_type = "t2.micro"4542  subnet_id     = aws_subnet.test.id4543  private_ip    = ""4544}4545`)4546}4547func testAccInstanceConfigAssociatePublicIPAndPrivateIP(rName string) string {4548	return composeConfig(4549		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4550		testAccAwsInstanceVpcConfig(rName, false),4551		`4552resource "aws_instance" "test" {4553  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4554  instance_type               = "t2.micro"4555  subnet_id                   = aws_subnet.test.id4556  associate_public_ip_address = true4557  private_ip                  = "10.1.1.42"4558}4559`)4560}4561func testAccInstanceNetworkInstanceSecurityGroups(rName string) string {4562	return composeConfig(4563		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4564		testAccAwsInstanceVpcConfig(rName, false),4565		testAccAwsInstanceVpcSecurityGroupConfig(rName),4566		`4567resource "aws_instance" "test" {4568  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4569  instance_type               = "t2.micro"4570  vpc_security_group_ids      = [aws_security_group.test.id]4571  subnet_id                   = aws_subnet.test.id4572  associate_public_ip_address = true4573  depends_on                  = [aws_internet_gateway.test]4574}4575resource "aws_eip" "test" {4576  instance   = aws_instance.test.id4577  vpc        = true4578  depends_on = [aws_internet_gateway.test]4579}4580`)4581}4582func testAccInstanceNetworkInstanceVPCSecurityGroupIDs(rName string) string {4583	return composeConfig(4584		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4585		testAccAwsInstanceVpcConfig(rName, false),4586		testAccAwsInstanceVpcSecurityGroupConfig(rName),4587		`4588resource "aws_instance" "test" {4589  ami                    = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4590  instance_type          = "t2.micro"4591  vpc_security_group_ids = [aws_security_group.test.id]4592  subnet_id              = aws_subnet.test.id4593  depends_on             = [aws_internet_gateway.test]4594}4595resource "aws_eip" "test" {4596  instance   = aws_instance.test.id4597  vpc        = true4598  depends_on = [aws_internet_gateway.test]4599}4600`)4601}4602func testAccInstanceNetworkInstanceVPCRemoveSecurityGroupIDs(rName string) string {4603	return composeConfig(4604		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4605		testAccAwsInstanceVpcConfig(rName, false),4606		testAccAwsInstanceVpcSecurityGroupConfig(rName),4607		`4608resource "aws_instance" "test" {4609  ami                    = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4610  instance_type          = "t2.micro"4611  vpc_security_group_ids = []4612  subnet_id              = aws_subnet.test.id4613  depends_on             = [aws_internet_gateway.test]4614}4615resource "aws_eip" "test" {4616  instance   = aws_instance.test.id4617  vpc        = true4618  depends_on = [aws_internet_gateway.test]4619}4620`)4621}4622func testAccInstanceConfigKeyPair(rName string) string {4623	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`4624resource "aws_key_pair" "test" {4625  key_name   = %[1]q4626  public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3F6tyPEFEzV0LX3X8BsXdMsQz1x2cEikKDEY0aIj41qgxMCP/iteneqXSIFZBp5vizPvaoIR3Um9xK7PGoW8giupGn+EPuxIA4cDM4vzOqOkiMPhz5XK0whEjkVzTo4+S0puvDZuwIsdiW9mxhJc7tgBNL0cYlWSYVkz4G/fslNfRPW5mYAM49f4fhtxPb5ok4Q2Lg9dPKVHO/Bgeu5woMc7RY0p1ej6D4CKFE6lymSDJpW0YHX/wqE9+cfEauh7xZcG0q9t2ta6F6fmX0agvpFyZo8aFbXeUBr7osSCJNgvavWbM/06niWrOvYX2xwWdhXmXSrbX8ZbabVohBK41 phodgson@thoughtworks.com"4627}4628resource "aws_instance" "test" {4629  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4630  instance_type = "t2.micro"4631  key_name      = aws_key_pair.test.key_name4632  tags = {4633    Name = %[1]q4634  }4635}4636`, rName))4637}4638func testAccInstanceConfigRootBlockDeviceMismatch(rName string) string {4639	return composeConfig(testAccAwsInstanceVpcConfig(rName, false), `4640resource "aws_instance" "test" {4641  # This is an AMI in UsWest2 with RootDeviceName: "/dev/sda1"; actual root: "/dev/sda"4642  ami = "ami-ef5b69df"4643  # tflint-ignore: aws_instance_previous_type4644  instance_type = "t1.micro"4645  subnet_id     = aws_subnet.test.id4646  root_block_device {4647    volume_size = 134648  }4649}4650`) //lintignore:AWSAT0024651}4652func testAccInstanceConfigForceNewAndTagsDrift(rName string) string {4653	return composeConfig(4654		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4655		testAccAwsInstanceVpcConfig(rName, false),4656		`4657resource "aws_instance" "test" {4658  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4659  instance_type = "t2.nano"4660  subnet_id     = aws_subnet.test.id4661}4662`)4663}4664func testAccInstanceConfigForceNewAndTagsDrift_Update(rName string) string {4665	return composeConfig(4666		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4667		testAccAwsInstanceVpcConfig(rName, false),4668		`4669resource "aws_instance" "test" {4670  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4671  instance_type = "t2.micro"4672  subnet_id     = aws_subnet.test.id4673}4674`)4675}4676func testAccInstanceConfigPrimaryNetworkInterface(rName string) string {4677	return composeConfig(4678		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4679		testAccAwsInstanceVpcConfig(rName, false),4680		fmt.Sprintf(`4681resource "aws_network_interface" "test" {4682  subnet_id   = aws_subnet.test.id4683  private_ips = ["10.1.1.42"]4684  tags = {4685    Name = %[1]q4686  }4687}4688resource "aws_instance" "test" {4689  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4690  instance_type = "t2.micro"4691  network_interface {4692    network_interface_id = aws_network_interface.test.id4693    device_index         = 04694  }4695}4696`, rName))4697}4698func testAccInstanceConfigPrimaryNetworkInterfaceSourceDestCheck(rName string) string {4699	return composeConfig(4700		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4701		testAccAwsInstanceVpcConfig(rName, false),4702		fmt.Sprintf(`4703resource "aws_network_interface" "test" {4704  subnet_id         = aws_subnet.test.id4705  private_ips       = ["10.1.1.42"]4706  source_dest_check = false4707  tags = {4708    Name = %[1]q4709  }4710}4711resource "aws_instance" "test" {4712  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4713  instance_type = "t2.micro"4714  network_interface {4715    network_interface_id = aws_network_interface.test.id4716    device_index         = 04717  }4718}4719`, rName))4720}4721func testAccInstanceConfigAddSecondaryNetworkInterfaceBefore(rName string) string {4722	return composeConfig(4723		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4724		testAccAwsInstanceVpcConfig(rName, false),4725		fmt.Sprintf(`4726resource "aws_network_interface" "primary" {4727  subnet_id   = aws_subnet.test.id4728  private_ips = ["10.1.1.42"]4729  tags = {4730    Name = %[1]q4731  }4732}4733resource "aws_network_interface" "secondary" {4734  subnet_id   = aws_subnet.test.id4735  private_ips = ["10.1.1.43"]4736  tags = {4737    Name = %[1]q4738  }4739}4740resource "aws_instance" "test" {4741  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4742  instance_type = "t2.micro"4743  network_interface {4744    network_interface_id = aws_network_interface.primary.id4745    device_index         = 04746  }4747}4748`, rName))4749}4750func testAccInstanceConfigAddSecondaryNetworkInterfaceAfter(rName string) string {4751	return composeConfig(4752		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4753		testAccAwsInstanceVpcConfig(rName, false),4754		fmt.Sprintf(`4755resource "aws_network_interface" "primary" {4756  subnet_id   = aws_subnet.test.id4757  private_ips = ["10.1.1.42"]4758  tags = {4759    Name = %[1]q4760  }4761}4762# Attach previously created network interface, observe no state diff on instance resource4763resource "aws_network_interface" "secondary" {4764  subnet_id   = aws_subnet.test.id4765  private_ips = ["10.1.1.43"]4766  tags = {4767    Name = %[1]q4768  }4769  attachment {4770    instance     = aws_instance.test.id4771    device_index = 14772  }4773}4774resource "aws_instance" "test" {4775  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4776  instance_type = "t2.micro"4777  network_interface {4778    network_interface_id = aws_network_interface.primary.id4779    device_index         = 04780  }4781}4782`, rName))4783}4784func testAccInstanceConfigAddSecurityGroupBefore(rName string) string {4785	return composeConfig(4786		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4787		testAccAwsInstanceVpcConfig(rName, false),4788		fmt.Sprintf(`4789resource "aws_subnet" "test2" {4790  cidr_block        = "10.1.2.0/24"4791  vpc_id            = aws_vpc.test.id4792  availability_zone = data.aws_availability_zones.available.names[0]4793  tags = {4794    Name = %[1]q4795  }4796}4797resource "aws_security_group" "test" {4798  vpc_id      = aws_vpc.test.id4799  description = "%[1]s_1"4800  name        = "%[1]s_1"4801}4802resource "aws_security_group" "test2" {4803  vpc_id      = aws_vpc.test.id4804  description = "%[1]s_2"4805  name        = "%[1]s_2"4806}4807resource "aws_instance" "test" {4808  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4809  instance_type = "t2.micro"4810  subnet_id     = aws_subnet.test.id4811  associate_public_ip_address = false4812  vpc_security_group_ids = [4813    aws_security_group.test.id,4814  ]4815  tags = {4816    Name = %[1]q4817  }4818}4819resource "aws_network_interface" "test" {4820  subnet_id       = aws_subnet.test.id4821  private_ips     = ["10.1.1.42"]4822  security_groups = [aws_security_group.test.id]4823  attachment {4824    instance     = aws_instance.test.id4825    device_index = 14826  }4827  tags = {4828    Name = %[1]q4829  }4830}4831`, rName))4832}4833func testAccInstanceConfigAddSecurityGroupAfter(rName string) string {4834	return composeConfig(4835		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4836		testAccAwsInstanceVpcConfig(rName, false),4837		fmt.Sprintf(`4838resource "aws_subnet" "test2" {4839  cidr_block        = "10.1.2.0/24"4840  vpc_id            = aws_vpc.test.id4841  availability_zone = data.aws_availability_zones.available.names[0]4842  tags = {4843    Name = %[1]q4844  }4845}4846resource "aws_security_group" "test" {4847  vpc_id      = aws_vpc.test.id4848  description = "%[1]s_1"4849  name        = "%[1]s_1"4850}4851resource "aws_security_group" "test2" {4852  vpc_id      = aws_vpc.test.id4853  description = "%[1]s_2"4854  name        = "%[1]s_2"4855}4856resource "aws_instance" "test" {4857  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4858  instance_type = "t2.micro"4859  subnet_id     = aws_subnet.test.id4860  associate_public_ip_address = false4861  vpc_security_group_ids = [4862    aws_security_group.test.id,4863    aws_security_group.test2.id,4864  ]4865  tags = {4866    Name = %[1]q4867  }4868}4869resource "aws_network_interface" "test" {4870  subnet_id       = aws_subnet.test.id4871  private_ips     = ["10.1.1.42"]4872  security_groups = [aws_security_group.test.id]4873  attachment {4874    instance     = aws_instance.test.id4875    device_index = 14876  }4877  tags = {4878    Name = %[1]q4879  }4880}4881`, rName))4882}4883func testAccInstanceConfigPublicAndPrivateSecondaryIPs(rName string, isPublic bool) string {4884	return composeConfig(4885		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4886		testAccAwsInstanceVpcConfig(rName, false),4887		fmt.Sprintf(`4888resource "aws_security_group" "test" {4889  vpc_id      = aws_vpc.test.id4890  description = "%[1]s"4891  name        = "%[1]s"4892}4893resource "aws_instance" "test" {4894  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4895  instance_type = "t3.small"4896  subnet_id     = aws_subnet.test.id4897  associate_public_ip_address = %[2]t4898  secondary_private_ips = ["10.1.1.42", "10.1.1.43"]4899  vpc_security_group_ids = [4900    aws_security_group.test.id4901  ]4902  tags = {4903    Name = %[1]q4904  }4905}4906`, rName, isPublic))4907}4908func testAccInstanceConfigPrivateIPAndSecondaryIPs(rName, privateIP, secondaryIPs string) string {4909	return composeConfig(4910		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4911		testAccAwsInstanceVpcConfig(rName, false),4912		fmt.Sprintf(`4913resource "aws_security_group" "test" {4914  vpc_id      = aws_vpc.test.id4915  description = "%[1]s"4916  name        = "%[1]s"4917}4918resource "aws_instance" "test" {4919  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4920  instance_type = "t3.small"4921  subnet_id     = aws_subnet.test.id4922  private_ip            = "%[2]s"4923  secondary_private_ips = [%[3]s]4924  vpc_security_group_ids = [4925    aws_security_group.test.id4926  ]4927  tags = {4928    Name = %[1]q4929  }4930}4931`, rName, privateIP, secondaryIPs))4932}4933func testAccInstanceConfig_associatePublic_defaultPrivate(rName string) string {4934	return composeConfig(4935		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4936		testAccAwsInstanceVpcConfig(rName, false),4937		fmt.Sprintf(`4938resource "aws_instance" "test" {4939  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4940  instance_type = "t2.micro"4941  subnet_id     = aws_subnet.test.id4942  tags = {4943    Name = %[1]q4944  }4945}4946`, rName))4947}4948func testAccInstanceConfig_associatePublic_defaultPublic(rName string) string {4949	return composeConfig(4950		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4951		testAccAwsInstanceVpcConfig(rName, true),4952		fmt.Sprintf(`4953resource "aws_instance" "test" {4954  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4955  instance_type = "t2.micro"4956  subnet_id     = aws_subnet.test.id4957  tags = {4958    Name = %[1]q4959  }4960}4961`, rName))4962}4963func testAccInstanceConfig_associatePublic_explicitPublic(rName string) string {4964	return composeConfig(4965		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4966		testAccAwsInstanceVpcConfig(rName, true),4967		fmt.Sprintf(`4968resource "aws_instance" "test" {4969  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4970  instance_type               = "t2.micro"4971  subnet_id                   = aws_subnet.test.id4972  associate_public_ip_address = true4973  tags = {4974    Name = %[1]q4975  }4976}4977`, rName))4978}4979func testAccInstanceConfig_associatePublic_explicitPrivate(rName string) string {4980	return composeConfig(4981		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4982		testAccAwsInstanceVpcConfig(rName, true),4983		fmt.Sprintf(`4984resource "aws_instance" "test" {4985  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id4986  instance_type               = "t2.micro"4987  subnet_id                   = aws_subnet.test.id4988  associate_public_ip_address = false4989  tags = {4990    Name = %[1]q4991  }4992}4993`, rName))4994}4995func testAccInstanceConfig_associatePublic_overridePublic(rName string) string {4996	return composeConfig(4997		testAccLatestAmazonLinuxHvmEbsAmiConfig(),4998		testAccAwsInstanceVpcConfig(rName, false),4999		fmt.Sprintf(`5000resource "aws_instance" "test" {5001  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5002  instance_type               = "t2.micro"5003  subnet_id                   = aws_subnet.test.id5004  associate_public_ip_address = true5005  tags = {5006    Name = %[1]q5007  }5008}5009`, rName))5010}5011func testAccInstanceConfig_associatePublic_overridePrivate(rName string) string {5012	return composeConfig(5013		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5014		testAccAwsInstanceVpcConfig(rName, true),5015		fmt.Sprintf(`5016resource "aws_instance" "test" {5017  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5018  instance_type               = "t2.micro"5019  subnet_id                   = aws_subnet.test.id5020  associate_public_ip_address = false5021  tags = {5022    Name = %[1]q5023  }5024}5025`, rName))5026}5027func testAccInstanceConfig_getPasswordData(rName string, val bool) string {5028	return composeConfig(testAccLatestWindowsServer2016CoreAmiConfig(), fmt.Sprintf(`5029resource "aws_key_pair" "test" {5030  key_name   = %[1]q5031  public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEAq6U3HQYC4g8WzU147gZZ7CKQH8TgYn3chZGRPxaGmHW1RUwsyEs0nmombmIhwxudhJ4ehjqXsDLoQpd6+c7BuLgTMvbv8LgE9LX53vnljFe1dsObsr/fYLvpU9LTlo8HgHAqO5ibNdrAUvV31ronzCZhms/Gyfdaue88Fd0/YnsZVGeOZPayRkdOHSpqme2CBrpa8myBeL1CWl0LkDG4+YCURjbaelfyZlIApLYKy3FcCan9XQFKaL32MJZwCgzfOvWIMtYcU8QtXMgnA3/I3gXk8YDUJv5P4lj0s/PJXuTM8DygVAUtebNwPuinS7wwonm5FXcWMuVGsVpG5K7FGQ== tf-acc-winpasswordtest"5032}5033resource "aws_instance" "test" {5034  ami           = data.aws_ami.win2016core-ami.id5035  instance_type = "t2.medium"5036  key_name      = aws_key_pair.test.key_name5037  get_password_data = %[2]t5038}5039`, rName, val))5040}5041func testAccInstanceConfig_CreditSpecification_Empty_NonBurstable(rName string) string {5042	return composeConfig(5043		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5044		testAccAwsInstanceVpcConfig(rName, false),5045		`5046resource "aws_instance" "test" {5047  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5048  instance_type = "m5.large"5049  subnet_id     = aws_subnet.test.id5050  credit_specification {}5051}5052`)5053}5054func testAccInstanceConfig_CreditSpecification_Unspecified_NonBurstable(rName string) string {5055	return composeConfig(5056		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5057		testAccAwsInstanceVpcConfig(rName, false),5058		`5059resource "aws_instance" "test" {5060  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5061  instance_type = "m5.large"5062  subnet_id     = aws_subnet.test.id5063}5064`)5065}5066func testAccInstanceConfig_creditSpecification_unspecified(rName string) string {5067	return composeConfig(5068		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5069		testAccAwsInstanceVpcConfig(rName, false),5070		`5071resource "aws_instance" "test" {5072  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5073  instance_type = "t2.micro"5074  subnet_id     = aws_subnet.test.id5075}5076`)5077}5078func testAccInstanceConfig_creditSpecification_unspecified_t3(rName string) string {5079	return composeConfig(5080		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5081		testAccAwsInstanceVpcConfig(rName, false),5082		`5083resource "aws_instance" "test" {5084  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5085  instance_type = "t3.micro"5086  subnet_id     = aws_subnet.test.id5087}5088`)5089}5090func testAccInstanceConfig_creditSpecification_standardCpuCredits(rName string) string {5091	return composeConfig(5092		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5093		testAccAwsInstanceVpcConfig(rName, false),5094		`5095resource "aws_instance" "test" {5096  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5097  instance_type = "t2.micro"5098  subnet_id     = aws_subnet.test.id5099  credit_specification {5100    cpu_credits = "standard"5101  }5102}5103`)5104}5105func testAccInstanceConfig_creditSpecification_standardCpuCredits_t3(rName string) string {5106	return composeConfig(5107		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5108		testAccAwsInstanceVpcConfig(rName, false),5109		`5110resource "aws_instance" "test" {5111  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5112  instance_type = "t3.micro"5113  subnet_id     = aws_subnet.test.id5114  credit_specification {5115    cpu_credits = "standard"5116  }5117}5118`)5119}5120func testAccInstanceConfig_creditSpecification_unlimitedCpuCredits(rName string) string {5121	return composeConfig(5122		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5123		testAccAwsInstanceVpcConfig(rName, false),5124		`5125resource "aws_instance" "test" {5126  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5127  instance_type = "t2.micro"5128  subnet_id     = aws_subnet.test.id5129  credit_specification {5130    cpu_credits = "unlimited"5131  }5132}5133`)5134}5135func testAccInstanceConfig_creditSpecification_unlimitedCpuCredits_t3(rName string) string {5136	return composeConfig(5137		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5138		testAccAwsInstanceVpcConfig(rName, false),5139		`5140resource "aws_instance" "test" {5141  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5142  instance_type = "t3.micro"5143  subnet_id     = aws_subnet.test.id5144  credit_specification {5145    cpu_credits = "unlimited"5146  }5147}5148`)5149}5150func testAccInstanceConfig_creditSpecification_isNotAppliedToNonBurstable(rName string) string {5151	return composeConfig(5152		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5153		testAccAwsInstanceVpcConfig(rName, false),5154		`5155resource "aws_instance" "test" {5156  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5157  instance_type = "t2.small"5158  subnet_id     = aws_subnet.test.id5159  credit_specification {5160    cpu_credits = "standard"5161  }5162}5163`)5164}5165func testAccInstanceConfig_creditSpecification_unknownCpuCredits(rName, instanceType string) string {5166	return composeConfig(5167		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5168		testAccAwsInstanceVpcConfig(rName, false),5169		fmt.Sprintf(`5170resource "aws_instance" "test" {5171  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5172  instance_type = %[1]q5173  subnet_id     = aws_subnet.test.id5174  credit_specification {}5175}5176`, instanceType))5177}5178func testAccInstanceConfig_UserData_Unspecified(rName string) string {5179	return composeConfig(5180		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5181		testAccAwsInstanceVpcConfig(rName, false),5182		`5183resource "aws_instance" "test" {5184  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5185  instance_type = "t2.micro"5186  subnet_id     = aws_subnet.test.id5187}5188`)5189}5190func testAccInstanceConfig_UserData_EmptyString(rName string) string {5191	return composeConfig(5192		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5193		testAccAwsInstanceVpcConfig(rName, false),5194		`5195resource "aws_instance" "test" {5196  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5197  instance_type = "t2.micro"5198  subnet_id     = aws_subnet.test.id5199  user_data     = ""5200}5201`)5202}5203// testAccLatestAmazonLinuxHvmEbsAmiConfig returns the configuration for a data source that5204// describes the latest Amazon Linux AMI using HVM virtualization and an EBS root device.5205// The data source is named 'amzn-ami-minimal-hvm-ebs'.5206func testAccLatestAmazonLinuxHvmEbsAmiConfig() string {5207	return `5208data "aws_ami" "amzn-ami-minimal-hvm-ebs" {5209  most_recent = true5210  owners      = ["amazon"]5211  filter {5212    name   = "name"5213    values = ["amzn-ami-minimal-hvm-*"]5214  }5215  filter {5216    name   = "root-device-type"5217    values = ["ebs"]5218  }5219}5220`5221}5222// testAccLatestAmazonLinuxHvmInstanceStoreAmiConfig returns the configuration for a data source that5223// describes the latest Amazon Linux AMI using HVM virtualization and an instance store root device.5224// The data source is named 'amzn-ami-minimal-hvm-instance-store'.5225func testAccLatestAmazonLinuxHvmInstanceStoreAmiConfig() string {5226	return `5227data "aws_ami" "amzn-ami-minimal-hvm-instance-store" {5228  most_recent = true5229  owners      = ["amazon"]5230  filter {5231    name   = "name"5232    values = ["amzn-ami-minimal-hvm-*"]5233  }5234  filter {5235    name   = "root-device-type"5236    values = ["instance-store"]5237  }5238}5239`5240}5241// testAccLatestAmazonLinuxPvEbsAmiConfig returns the configuration for a data source that5242// describes the latest Amazon Linux AMI using PV virtualization and an EBS root device.5243// The data source is named 'amzn-ami-minimal-pv-ebs'.5244func testAccLatestAmazonLinuxPvEbsAmiConfig() string {5245	return `5246data "aws_ami" "amzn-ami-minimal-pv-ebs" {5247  most_recent = true5248  owners      = ["amazon"]5249  filter {5250    name   = "name"5251    values = ["amzn-ami-minimal-pv-*"]5252  }5253  filter {5254    name   = "root-device-type"5255    values = ["ebs"]5256  }5257}5258`5259}5260// testAccLatestAmazonLinuxPvInstanceStoreAmiConfig returns the configuration for a data source that5261// describes the latest Amazon Linux AMI using PV virtualization and an instance store root device.5262// The data source is named 'amzn-ami-minimal-pv-ebs'.5263func testAccLatestAmazonLinuxPvInstanceStoreAmiConfig() string {5264	return `5265data "aws_ami" "amzn-ami-minimal-pv-instance-store" {5266  most_recent = true5267  owners      = ["amazon"]5268  filter {5269    name   = "name"5270    values = ["amzn-ami-minimal-pv-*"]5271  }5272  filter {5273    name   = "root-device-type"5274    values = ["instance-store"]5275  }5276}5277`5278}5279// testAccLatestWindowsServer2016CoreAmiConfig returns the configuration for a data source that5280// describes the latest Microsoft Windows Server 2016 Core AMI.5281// The data source is named 'win2016core-ami'.5282func testAccLatestWindowsServer2016CoreAmiConfig() string {5283	return `5284data "aws_ami" "win2016core-ami" {5285  most_recent = true5286  owners      = ["amazon"]5287  filter {5288    name   = "name"5289    values = ["Windows_Server-2016-English-Core-Base-*"]5290  }5291}5292`5293}5294// testAccAwsInstanceVpcConfig returns the configuration for tests that create5295//   1) a VPC without IPv6 support5296//   2) a subnet in the VPC that optionally assigns public IP addresses to ENIs5297// The resources are named 'test'.5298func testAccAwsInstanceVpcConfig(rName string, mapPublicIpOnLaunch bool) string {5299	return composeConfig(testAccAvailableAZsNoOptInDefaultExcludeConfig(), fmt.Sprintf(`5300resource "aws_vpc" "test" {5301  cidr_block = "10.1.0.0/16"5302  tags = {5303    Name = %[1]q5304  }5305}5306resource "aws_subnet" "test" {5307  cidr_block              = "10.1.1.0/24"5308  vpc_id                  = aws_vpc.test.id5309  availability_zone       = data.aws_availability_zones.available.names[0]5310  map_public_ip_on_launch = %[2]t5311  tags = {5312    Name = %[1]q5313  }5314}5315`, rName, mapPublicIpOnLaunch))5316}5317func testAccAwsInstanceVpcConfigBasic(rName string) string {5318	return composeConfig(testAccAvailableAZsNoOptInConfig(), fmt.Sprintf(`5319resource "aws_vpc" "test" {5320  cidr_block = "10.0.0.0/16"5321  tags = {5322    Name = %[1]q5323  }5324}5325resource "aws_subnet" "test" {5326  availability_zone = data.aws_availability_zones.available.names[0]5327  cidr_block        = "10.0.0.0/24"5328  vpc_id            = aws_vpc.test.id5329  tags = {5330    Name = %[1]q5331  }5332}5333`, rName))5334}5335// testAccAwsInstanceVpcSecurityGroupConfig returns the configuration for tests that create5336//   1) a VPC security group5337//   2) an internet gateway in the VPC5338// The resources are named 'test'.5339func testAccAwsInstanceVpcSecurityGroupConfig(rName string) string {5340	return fmt.Sprintf(`5341resource "aws_internet_gateway" "test" {5342  vpc_id = aws_vpc.test.id5343  tags = {5344    Name = %[1]q5345  }5346}5347resource "aws_security_group" "test" {5348  name        = %[1]q5349  description = "test"5350  vpc_id      = aws_vpc.test.id5351  ingress {5352    protocol    = "icmp"5353    from_port   = -15354    to_port     = -15355    cidr_blocks = ["0.0.0.0/0"]5356  }5357  tags = {5358    Name = %[1]q5359  }5360}5361`, rName)5362}5363// testAccAwsInstanceVpcIpv6Config returns the configuration for tests that create5364//   1) a VPC with IPv6 support5365//   2) a subnet in the VPC with an assigned IPv6 CIDR block5366// The resources are named 'test'.5367func testAccAwsInstanceVpcIpv6Config(rName string) string {5368	return composeConfig(testAccAvailableAZsNoOptInDefaultExcludeConfig(), fmt.Sprintf(`5369resource "aws_vpc" "test" {5370  cidr_block = "10.1.0.0/16"5371  assign_generated_ipv6_cidr_block = true5372  tags = {5373    Name = %[1]q5374  }5375}5376resource "aws_subnet" "test" {5377  cidr_block        = "10.1.1.0/24"5378  vpc_id            = aws_vpc.test.id5379  availability_zone = data.aws_availability_zones.available.names[0]5380  ipv6_cidr_block   = cidrsubnet(aws_vpc.test.ipv6_cidr_block, 8, 1)5381  tags = {5382    Name = %[1]q5383  }5384}5385`, rName))5386}5387func testAccInstanceConfigHibernation(hibernation bool) string {5388	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), fmt.Sprintf(`5389resource "aws_vpc" "test" {5390  cidr_block = "10.1.0.0/16"5391  tags = {5392    Name = "terraform-testacc-instance-hibernation"5393  }5394}5395resource "aws_subnet" "test" {5396  cidr_block = "10.1.1.0/24"5397  vpc_id     = aws_vpc.test.id5398  tags = {5399    Name = "tf-acc-instance-hibernation"5400  }5401}5402# must be >= m3 and have an encrypted root volume to eanble hibernation5403resource "aws_instance" "test" {5404  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5405  hibernation   = %[1]t5406  instance_type = "m5.large"5407  subnet_id     = aws_subnet.test.id5408  root_block_device {5409    encrypted   = true5410    volume_size = 205411  }5412}5413`, hibernation))5414}5415func testAccInstanceConfigMetadataOptions(rName string) string {5416	return composeConfig(5417		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5418		testAccAwsInstanceVpcConfig(rName, false),5419		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro"),5420		fmt.Sprintf(`5421resource "aws_instance" "test" {5422  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5423  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5424  subnet_id     = aws_subnet.test.id5425  tags = {5426    Name = %[1]q5427  }5428  metadata_options {5429    http_endpoint = "disabled"5430  }5431}5432data "aws_instance" "test" {5433  instance_id = aws_instance.test.id5434}5435`, rName))5436}5437func testAccInstanceConfigMetadataOptionsUpdated(rName string) string {5438	return composeConfig(5439		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5440		testAccAwsInstanceVpcConfig(rName, false),5441		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro"),5442		fmt.Sprintf(`5443resource "aws_instance" "test" {5444  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5445  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5446  subnet_id     = aws_subnet.test.id5447  tags = {5448    Name = %[1]q5449  }5450  metadata_options {5451    http_endpoint               = "enabled"5452    http_tokens                 = "required"5453    http_put_response_hop_limit = 25454  }5455}5456`, rName))5457}5458func testAccInstanceConfigEnclaveOptions(enabled bool) string {5459	name := "tf-acc-instance-enclaves"5460	return composeConfig(5461		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5462		testAccAwsInstanceVpcConfig(name, false),5463		testAccAvailableEc2InstanceTypeForRegion("c5a.xlarge", "c5.xlarge"),5464		fmt.Sprintf(`5465resource "aws_instance" "test" {5466  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5467  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5468  subnet_id     = aws_subnet.test.id5469  enclave_options {5470    enabled = %[2]t5471  }5472  tags = {5473    Name = %[1]q5474  }5475}5476`, name, enabled))5477}5478func testAccAwsEc2InstanceConfigDynamicEBSBlockDevices() string {5479	return composeConfig(testAccLatestAmazonLinuxPvEbsAmiConfig(), `5480resource "aws_instance" "test" {5481  ami = data.aws_ami.amzn-ami-minimal-pv-ebs.id5482  # tflint-ignore: aws_instance_previous_type5483  instance_type = "m3.medium"5484  dynamic "ebs_block_device" {5485    for_each = ["a", "b", "c"]5486    iterator = device5487    content {5488      device_name = format("/dev/sd%s", device.value)5489      volume_size = "10"5490      volume_type = "gp2"5491    }5492  }5493}5494`)5495}5496// testAccAvailableEc2InstanceTypeForRegion returns the configuration for a data source that describes5497// the first available EC2 instance type offering in the current region from a list of preferred instance types.5498// The data source is named 'available'.5499func testAccAvailableEc2InstanceTypeForRegion(preferredInstanceTypes ...string) string {5500	return fmt.Sprintf(`5501data "aws_ec2_instance_type_offering" "available" {5502  filter {5503    name   = "instance-type"5504    values = ["%[1]s"]5505  }5506  preferred_instance_types = ["%[1]s"]5507}5508`, strings.Join(preferredInstanceTypes, "\", \""))5509}5510// testAccAvailableEc2InstanceTypeForAvailabilityZone returns the configuration for a data source that describes5511// the first available EC2 instance type offering in the specified availability zone from a list of preferred instance types.5512// The first argument is either an Availability Zone name or Terraform configuration reference to one, e.g.5513//   * data.aws_availability_zones.available.names[0]5514//   * aws_subnet.test.availability_zone5515//   * us-west-2a5516// The data source is named 'available'.5517func testAccAvailableEc2InstanceTypeForAvailabilityZone(availabilityZoneName string, preferredInstanceTypes ...string) string {5518	if !strings.Contains(availabilityZoneName, ".") {5519		availabilityZoneName = strconv.Quote(availabilityZoneName)5520	}5521	return fmt.Sprintf(`5522data "aws_ec2_instance_type_offering" "available" {5523  filter {5524    name   = "instance-type"5525    values = ["%[2]s"]5526  }5527  filter {5528    name   = "location"5529    values = [%[1]s]5530  }5531  location_type            = "availability-zone"5532  preferred_instance_types = ["%[2]s"]5533}5534`, availabilityZoneName, strings.Join(preferredInstanceTypes, "\", \""))5535}5536func testAccInstanceConfigCapacityReservationSpecification_unspecified(rName string) string {5537	return composeConfig(5538		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5539		testAccAvailableEc2InstanceTypeForRegion("t2.micro"),5540		fmt.Sprintf(`5541resource "aws_instance" "test" {5542  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5543  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5544  tags = {5545    Name = %[1]q5546  }5547}5548`, rName))5549}5550func testAccInstanceConfigCapacityReservationSpecification_preference(rName, crPreference string) string {5551	return composeConfig(5552		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5553		testAccAvailableEc2InstanceTypeForRegion("t2.micro"),5554		fmt.Sprintf(`5555resource "aws_instance" "test" {5556  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5557  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5558  capacity_reservation_specification {5559    capacity_reservation_preference = %[2]q5560  }5561  tags = {5562    Name = %[1]q5563  }5564}5565`, rName, crPreference))5566}5567func testAccInstanceConfigCapacityReservationSpecification_targetId(rName string) string {5568	return composeConfig(5569		testAccLatestAmazonLinuxHvmEbsAmiConfig(),5570		testAccAvailableEc2InstanceTypeForRegion("t2.micro"),5571		fmt.Sprintf(`5572resource "aws_instance" "test" {5573  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id5574  instance_type = data.aws_ec2_instance_type_offering.available.instance_type5575  capacity_reservation_specification {5576    capacity_reservation_target {5577      capacity_reservation_id = aws_ec2_capacity_reservation.test.id5578    }5579  }5580  tags = {5581    Name = %[1]q5582  }5583}5584data "aws_availability_zones" "available" {5585  state = "available"5586  filter {5587    name   = "opt-in-status"5588    values = ["opt-in-not-required"]5589  }5590}5591resource "aws_ec2_capacity_reservation" "test" {5592  instance_type     = data.aws_ec2_instance_type_offering.available.instance_type5593  instance_platform = %[2]q5594  availability_zone = data.aws_availability_zones.available.names[0]5595  instance_count    = 105596  tags = {5597    Name = %[1]q5598  }5599}5600`, rName, ec2.CapacityReservationInstancePlatformLinuxUnix))5601}...

data_source_aws_instance_test.go

Source:data_source_aws_instance_test.go

1package aws2import (3	"fmt"4	"testing"5	"github.com/aws/aws-sdk-go/service/ec2"6	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"7	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"8)9func TestAccAWSInstanceDataSource_basic(t *testing.T) {10	resourceName := "aws_instance.test"11	datasourceName := "data.aws_instance.test"12	resource.ParallelTest(t, resource.TestCase{13		PreCheck:   func() { testAccPreCheck(t) },14		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),15		Providers:  testAccProviders,16		Steps: []resource.TestStep{17			{18				Config: testAccInstanceDataSourceConfig,19				Check: resource.ComposeTestCheckFunc(20					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),21					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),22					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),23					resource.TestCheckResourceAttrPair(datasourceName, "arn", resourceName, "arn"),24					resource.TestCheckNoResourceAttr(datasourceName, "user_data_base64"),25					resource.TestCheckResourceAttr(datasourceName, "outpost_arn", ""),26				),27			},28		},29	})30}31func TestAccAWSInstanceDataSource_tags(t *testing.T) {32	rInt := acctest.RandInt()33	resourceName := "aws_instance.test"34	datasourceName := "data.aws_instance.test"35	resource.ParallelTest(t, resource.TestCase{36		PreCheck:   func() { testAccPreCheck(t) },37		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),38		Providers:  testAccProviders,39		Steps: []resource.TestStep{40			{41				Config: testAccInstanceDataSourceConfig_Tags(rInt),42				Check: resource.ComposeTestCheckFunc(43					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),44					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),45					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),46				),47			},48		},49	})50}51func TestAccAWSInstanceDataSource_AzUserData(t *testing.T) {52	resourceName := "aws_instance.test"53	datasourceName := "data.aws_instance.test"54	resource.ParallelTest(t, resource.TestCase{55		PreCheck:   func() { testAccPreCheck(t) },56		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),57		Providers:  testAccProviders,58		Steps: []resource.TestStep{59			{60				Config: testAccInstanceDataSourceConfig_AzUserData,61				Check: resource.ComposeTestCheckFunc(62					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),63					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),64					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),65					resource.TestCheckResourceAttrPair(datasourceName, "availability_zone", resourceName, "availability_zone"),66					resource.TestCheckResourceAttrPair(datasourceName, "user_data", resourceName, "user_data"),67				),68			},69		},70	})71}72func TestAccAWSInstanceDataSource_gp2IopsDevice(t *testing.T) {73	resourceName := "aws_instance.test"74	datasourceName := "data.aws_instance.test"75	resource.ParallelTest(t, resource.TestCase{76		PreCheck:   func() { testAccPreCheck(t) },77		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),78		Providers:  testAccProviders,79		Steps: []resource.TestStep{80			{81				Config: testAccInstanceDataSourceConfig_gp2IopsDevice,82				Check: resource.ComposeTestCheckFunc(83					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),84					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),85					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.#", resourceName, "root_block_device.#"),86					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_size", resourceName, "root_block_device.0.volume_size"),87					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_type", resourceName, "root_block_device.0.volume_type"),88					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.device_name", resourceName, "root_block_device.0.device_name"),89					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.iops", resourceName, "root_block_device.0.iops"),90				),91			},92		},93	})94}95func TestAccAWSInstanceDataSource_gp3ThroughputDevice(t *testing.T) {96	resourceName := "aws_instance.test"97	datasourceName := "data.aws_instance.test"98	resource.ParallelTest(t, resource.TestCase{99		PreCheck:   func() { testAccPreCheck(t) },100		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),101		Providers:  testAccProviders,102		Steps: []resource.TestStep{103			{104				Config: testAccInstanceDataSourceConfig_gp3ThroughputDevice,105				Check: resource.ComposeTestCheckFunc(106					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),107					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),108					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.#", resourceName, "root_block_device.#"),109					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_size", resourceName, "root_block_device.0.volume_size"),110					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_type", resourceName, "root_block_device.0.volume_type"),111					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.device_name", resourceName, "root_block_device.0.device_name"),112					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.throughput", resourceName, "root_block_device.0.throughput"),113				),114			},115		},116	})117}118func TestAccAWSInstanceDataSource_blockDevices(t *testing.T) {119	resourceName := "aws_instance.test"120	datasourceName := "data.aws_instance.test"121	resource.ParallelTest(t, resource.TestCase{122		PreCheck:   func() { testAccPreCheck(t) },123		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),124		Providers:  testAccProviders,125		Steps: []resource.TestStep{126			{127				Config: testAccInstanceDataSourceConfig_blockDevices,128				Check: resource.ComposeTestCheckFunc(129					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),130					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),131					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.#", resourceName, "root_block_device.#"),132					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_size", resourceName, "root_block_device.0.volume_size"),133					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.volume_type", resourceName, "root_block_device.0.volume_type"),134					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.0.device_name", resourceName, "root_block_device.0.device_name"),135					resource.TestCheckResourceAttrPair(datasourceName, "ebs_block_device.#", resourceName, "ebs_block_device.#"),136					//resource.TestCheckResourceAttrPair(datasourceName, "ephemeral_block_device.#", resourceName, "ephemeral_block_device.#"),137					// ephemeral block devices don't get saved properly due to API limitations, so this can't actually be tested right now138				),139			},140		},141	})142}143// Test to verify that ebs_block_device kms_key_id does not elicit a panic144func TestAccAWSInstanceDataSource_EbsBlockDevice_KmsKeyId(t *testing.T) {145	resource.ParallelTest(t, resource.TestCase{146		PreCheck:   func() { testAccPreCheck(t) },147		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),148		Providers:  testAccProviders,149		Steps: []resource.TestStep{150			{151				Config: testAccInstanceDataSourceConfig_EbsBlockDevice_KmsKeyId,152			},153		},154	})155}156// Test to verify that root_block_device kms_key_id does not elicit a panic157func TestAccAWSInstanceDataSource_RootBlockDevice_KmsKeyId(t *testing.T) {158	resource.ParallelTest(t, resource.TestCase{159		PreCheck:   func() { testAccPreCheck(t) },160		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),161		Providers:  testAccProviders,162		Steps: []resource.TestStep{163			{164				Config: testAccInstanceDataSourceConfig_RootBlockDevice_KmsKeyId,165			},166		},167	})168}169func TestAccAWSInstanceDataSource_rootInstanceStore(t *testing.T) {170	resourceName := "aws_instance.test"171	datasourceName := "data.aws_instance.test"172	resource.ParallelTest(t, resource.TestCase{173		PreCheck:   func() { testAccPreCheck(t) },174		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),175		Providers:  testAccProviders,176		Steps: []resource.TestStep{177			{178				Config: testAccInstanceDataSourceConfig_rootInstanceStore,179				Check: resource.ComposeTestCheckFunc(180					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),181					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),182					resource.TestCheckResourceAttrPair(datasourceName, "ebs_block_device.#", resourceName, "ebs_block_device.#"),183					resource.TestCheckResourceAttrPair(datasourceName, "ebs_optimized", resourceName, "ebs_optimized"),184					resource.TestCheckResourceAttrPair(datasourceName, "root_block_device.#", resourceName, "root_block_device.#"),185				),186			},187		},188	})189}190func TestAccAWSInstanceDataSource_privateIP(t *testing.T) {191	resourceName := "aws_instance.test"192	datasourceName := "data.aws_instance.test"193	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))194	resource.ParallelTest(t, resource.TestCase{195		PreCheck:   func() { testAccPreCheck(t) },196		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),197		Providers:  testAccProviders,198		Steps: []resource.TestStep{199			{200				Config: testAccInstanceDataSourceConfig_privateIP(rName),201				Check: resource.ComposeTestCheckFunc(202					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),203					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),204					resource.TestCheckResourceAttrPair(datasourceName, "private_ip", resourceName, "private_ip"),205				),206			},207		},208	})209}210func TestAccAWSInstanceDataSource_secondaryPrivateIPs(t *testing.T) {211	resourceName := "aws_instance.test"212	datasourceName := "data.aws_instance.test"213	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))214	resource.ParallelTest(t, resource.TestCase{215		PreCheck:   func() { testAccPreCheck(t) },216		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),217		Providers:  testAccProviders,218		Steps: []resource.TestStep{219			{220				Config: testAccInstanceDataSourceConfig_secondaryPrivateIPs(rName),221				Check: resource.ComposeTestCheckFunc(222					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),223					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),224					resource.TestCheckResourceAttrPair(datasourceName, "secondary_private_ips", resourceName, "secondary_private_ips"),225				),226			},227		},228	})229}230func TestAccAWSInstanceDataSource_keyPair(t *testing.T) {231	resourceName := "aws_instance.test"232	datasourceName := "data.aws_instance.test"233	rName := fmt.Sprintf("tf-test-key-%d", acctest.RandInt())234	resource.ParallelTest(t, resource.TestCase{235		PreCheck:   func() { testAccPreCheck(t) },236		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),237		Providers:  testAccProviders,238		Steps: []resource.TestStep{239			{240				Config: testAccInstanceDataSourceConfig_keyPair(rName),241				Check: resource.ComposeTestCheckFunc(242					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),243					resource.TestCheckResourceAttrPair(datasourceName, "tags.%", resourceName, "tags.%"),244					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),245					resource.TestCheckResourceAttrPair(datasourceName, "key_name", resourceName, "key_name"),246				),247			},248		},249	})250}251func TestAccAWSInstanceDataSource_VPC(t *testing.T) {252	resourceName := "aws_instance.test"253	datasourceName := "data.aws_instance.test"254	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))255	resource.ParallelTest(t, resource.TestCase{256		PreCheck:   func() { testAccPreCheck(t) },257		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),258		Providers:  testAccProviders,259		Steps: []resource.TestStep{260			{261				Config: testAccInstanceDataSourceConfig_VPC(rName),262				Check: resource.ComposeTestCheckFunc(263					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),264					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),265					resource.TestCheckResourceAttrPair(datasourceName, "user_data", resourceName, "user_data"),266					resource.TestCheckResourceAttrPair(datasourceName, "associate_public_ip_address", resourceName, "associate_public_ip_address"),267					resource.TestCheckResourceAttrPair(datasourceName, "tenancy", resourceName, "tenancy"),268				),269			},270		},271	})272}273func TestAccAWSInstanceDataSource_PlacementGroup(t *testing.T) {274	resourceName := "aws_instance.test"275	datasourceName := "data.aws_instance.test"276	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))277	resource.ParallelTest(t, resource.TestCase{278		PreCheck:   func() { testAccPreCheck(t) },279		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),280		Providers:  testAccProviders,281		Steps: []resource.TestStep{282			{283				Config: testAccInstanceDataSourceConfig_PlacementGroup(rName),284				Check: resource.ComposeTestCheckFunc(285					resource.TestCheckResourceAttrPair(datasourceName, "placement_group", resourceName, "placement_group"),286				),287			},288		},289	})290}291func TestAccAWSInstanceDataSource_SecurityGroups(t *testing.T) {292	rInt := acctest.RandInt()293	resourceName := "aws_instance.test"294	datasourceName := "data.aws_instance.test"295	resource.ParallelTest(t, resource.TestCase{296		PreCheck:   func() { testAccPreCheck(t) },297		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),298		Providers:  testAccProviders,299		Steps: []resource.TestStep{300			{301				Config: testAccInstanceDataSourceConfig_SecurityGroups(rInt),302				Check: resource.ComposeTestCheckFunc(303					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),304					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),305					resource.TestCheckResourceAttrPair(datasourceName, "user_data", resourceName, "user_data"),306					resource.TestCheckResourceAttrPair(datasourceName, "vpc_security_group_ids.#", resourceName, "vpc_security_group_ids.#"),307					resource.TestCheckResourceAttrPair(datasourceName, "security_groups.#", resourceName, "security_groups.#"),308				),309			},310		},311	})312}313func TestAccAWSInstanceDataSource_VPCSecurityGroups(t *testing.T) {314	resourceName := "aws_instance.test"315	datasourceName := "data.aws_instance.test"316	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))317	resource.ParallelTest(t, resource.TestCase{318		PreCheck:   func() { testAccPreCheck(t) },319		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),320		Providers:  testAccProviders,321		Steps: []resource.TestStep{322			{323				Config: testAccInstanceDataSourceConfig_VPCSecurityGroups(rName),324				Check: resource.ComposeTestCheckFunc(325					resource.TestCheckResourceAttrPair(datasourceName, "ami", resourceName, "ami"),326					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),327					resource.TestCheckResourceAttrPair(datasourceName, "vpc_security_group_ids.#", resourceName, "vpc_security_group_ids.#"),328					resource.TestCheckResourceAttrPair(datasourceName, "security_groups.#", resourceName, "security_groups.#"),329				),330			},331		},332	})333}334func TestAccAWSInstanceDataSource_getPasswordData_trueToFalse(t *testing.T) {335	datasourceName := "data.aws_instance.test"336	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))337	resource.ParallelTest(t, resource.TestCase{338		PreCheck:   func() { testAccPreCheck(t) },339		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),340		Providers:  testAccProviders,341		Steps: []resource.TestStep{342			{343				Config: testAccInstanceDataSourceConfig_getPasswordData(rName, true),344				Check: resource.ComposeTestCheckFunc(345					resource.TestCheckResourceAttr(datasourceName, "get_password_data", "true"),346					resource.TestCheckResourceAttrSet(datasourceName, "password_data"),347				),348			},349			{350				Config: testAccInstanceDataSourceConfig_getPasswordData(rName, false),351				Check: resource.ComposeTestCheckFunc(352					resource.TestCheckResourceAttr(datasourceName, "get_password_data", "false"),353					resource.TestCheckNoResourceAttr(datasourceName, "password_data"),354				),355			},356		},357	})358}359func TestAccAWSInstanceDataSource_getPasswordData_falseToTrue(t *testing.T) {360	datasourceName := "data.aws_instance.test"361	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))362	resource.ParallelTest(t, resource.TestCase{363		PreCheck:   func() { testAccPreCheck(t) },364		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),365		Providers:  testAccProviders,366		Steps: []resource.TestStep{367			{368				Config: testAccInstanceDataSourceConfig_getPasswordData(rName, false),369				Check: resource.ComposeTestCheckFunc(370					resource.TestCheckResourceAttr(datasourceName, "get_password_data", "false"),371					resource.TestCheckNoResourceAttr(datasourceName, "password_data"),372				),373			},374			{375				Config: testAccInstanceDataSourceConfig_getPasswordData(rName, true),376				Check: resource.ComposeTestCheckFunc(377					resource.TestCheckResourceAttr(datasourceName, "get_password_data", "true"),378					resource.TestCheckResourceAttrSet(datasourceName, "password_data"),379				),380			},381		},382	})383}384func TestAccAWSInstanceDataSource_GetUserData(t *testing.T) {385	datasourceName := "data.aws_instance.test"386	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))387	resource.ParallelTest(t, resource.TestCase{388		PreCheck:   func() { testAccPreCheck(t) },389		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),390		Providers:  testAccProviders,391		Steps: []resource.TestStep{392			{393				Config: testAccInstanceDataSourceConfigGetUserData(rName, true),394				Check: resource.ComposeTestCheckFunc(395					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "true"),396					resource.TestCheckResourceAttr(datasourceName, "user_data_base64", "IyEvYmluL2Jhc2gKCmVjaG8gImhlbGxvIHdvcmxkIgo="),397				),398			},399			{400				Config: testAccInstanceDataSourceConfigGetUserData(rName, false),401				Check: resource.ComposeTestCheckFunc(402					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "false"),403					resource.TestCheckNoResourceAttr(datasourceName, "user_data_base64"),404				),405			},406			{407				Config: testAccInstanceDataSourceConfigGetUserData(rName, true),408				Check: resource.ComposeTestCheckFunc(409					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "true"),410					resource.TestCheckResourceAttr(datasourceName, "user_data_base64", "IyEvYmluL2Jhc2gKCmVjaG8gImhlbGxvIHdvcmxkIgo="),411				),412			},413		},414	})415}416func TestAccAWSInstanceDataSource_GetUserData_NoUserData(t *testing.T) {417	resourceName := "aws_instance.test"418	datasourceName := "data.aws_instance.test"419	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))420	resource.ParallelTest(t, resource.TestCase{421		PreCheck:   func() { testAccPreCheck(t) },422		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),423		Providers:  testAccProviders,424		Steps: []resource.TestStep{425			{426				Config: testAccInstanceDataSourceConfigGetUserDataNoUserData(rName, true),427				Check: resource.ComposeTestCheckFunc(428					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "true"),429					resource.TestCheckNoResourceAttr(datasourceName, "user_data_base64"),430					resource.TestCheckResourceAttrPair(datasourceName, "user_data_base64", resourceName, "user_data_base64"),431				),432			},433			{434				Config: testAccInstanceDataSourceConfigGetUserDataNoUserData(rName, false),435				Check: resource.ComposeTestCheckFunc(436					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "false"),437					resource.TestCheckNoResourceAttr(datasourceName, "user_data_base64"),438					resource.TestCheckResourceAttrPair(datasourceName, "user_data_base64", resourceName, "user_data_base64"),439				),440			},441			{442				Config: testAccInstanceDataSourceConfigGetUserDataNoUserData(rName, true),443				Check: resource.ComposeTestCheckFunc(444					resource.TestCheckResourceAttr(datasourceName, "get_user_data", "true"),445					resource.TestCheckNoResourceAttr(datasourceName, "user_data_base64"),446					resource.TestCheckResourceAttrPair(datasourceName, "user_data_base64", resourceName, "user_data_base64"),447				),448			},449		},450	})451}452func TestAccAWSInstanceDataSource_creditSpecification(t *testing.T) {453	resourceName := "aws_instance.test"454	datasourceName := "data.aws_instance.test"455	rName := fmt.Sprintf("tf-testacc-instance-%s", acctest.RandString(12))456	resource.ParallelTest(t, resource.TestCase{457		PreCheck:   func() { testAccPreCheck(t) },458		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),459		Providers:  testAccProviders,460		Steps: []resource.TestStep{461			{462				Config: testAccInstanceDataSourceConfig_creditSpecification(rName),463				Check: resource.ComposeTestCheckFunc(464					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),465					resource.TestCheckResourceAttrPair(datasourceName, "credit_specification.#", resourceName, "credit_specification.#"),466					resource.TestCheckResourceAttrPair(datasourceName, "credit_specification.0.cpu_credits", resourceName, "credit_specification.0.cpu_credits"),467				),468			},469		},470	})471}472func TestAccAWSInstanceDataSource_metadataOptions(t *testing.T) {473	resourceName := "aws_instance.test"474	datasourceName := "data.aws_instance.test"475	rName := acctest.RandomWithPrefix("tf-acc-test")476	resource.ParallelTest(t, resource.TestCase{477		PreCheck:   func() { testAccPreCheck(t) },478		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),479		Providers:  testAccProviders,480		Steps: []resource.TestStep{481			{482				Config: testAccInstanceDataSourceConfig_metadataOptions(rName),483				Check: resource.ComposeTestCheckFunc(484					resource.TestCheckResourceAttrPair(datasourceName, "metadata_options.#", resourceName, "metadata_options.#"),485					resource.TestCheckResourceAttrPair(datasourceName, "metadata_options.0.http_endpoint", resourceName, "metadata_options.0.http_endpoint"),486					resource.TestCheckResourceAttrPair(datasourceName, "metadata_options.0.http_tokens", resourceName, "metadata_options.0.http_tokens"),487					resource.TestCheckResourceAttrPair(datasourceName, "metadata_options.0.http_put_response_hop_limit", resourceName, "metadata_options.0.http_put_response_hop_limit"),488				),489			},490		},491	})492}493func TestAccAWSInstanceDataSource_enclaveOptions(t *testing.T) {494	resourceName := "aws_instance.test"495	datasourceName := "data.aws_instance.test"496	rName := acctest.RandomWithPrefix("tf-acc-test")497	resource.ParallelTest(t, resource.TestCase{498		PreCheck:   func() { testAccPreCheck(t) },499		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),500		Providers:  testAccProviders,501		Steps: []resource.TestStep{502			{503				Config: testAccInstanceDataSourceConfig_enclaveOptions(rName),504				Check: resource.ComposeTestCheckFunc(505					resource.TestCheckResourceAttrPair(datasourceName, "enclave_options.#", resourceName, "enclave_options.#"),506					resource.TestCheckResourceAttrPair(datasourceName, "enclave_options.0.enabled", resourceName, "enclave_options.0.enabled"),507				),508			},509		},510	})511}512func TestAccAWSInstanceDataSource_blockDeviceTags(t *testing.T) {513	rName := acctest.RandomWithPrefix("tf-acc-test")514	resourceName := "aws_instance.test"515	datasourceName := "data.aws_instance.test"516	resource.ParallelTest(t, resource.TestCase{517		PreCheck:   func() { testAccPreCheck(t) },518		ErrorCheck: testAccErrorCheck(t, ec2.EndpointsID),519		Providers:  testAccProviders,520		Steps: []resource.TestStep{521			{522				Config: testAccInstanceDataSourceConfig_blockDeviceTags(rName),523				Check: resource.ComposeTestCheckFunc(524					resource.TestCheckResourceAttrPair(datasourceName, "instance_type", resourceName, "instance_type"),525				),526			},527		},528	})529}530// Lookup based on InstanceID531var testAccInstanceDataSourceConfig = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `532resource "aws_instance" "test" {533  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id534  instance_type = "t2.small"535  tags = {536    Name = "HelloWorld"537  }538}539data "aws_instance" "test" {540  filter {541    name   = "instance-id"542    values = [aws_instance.test.id]543  }544}545`546// Use the tags attribute to filter547func testAccInstanceDataSourceConfig_Tags(rInt int) string {548	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + fmt.Sprintf(`549resource "aws_instance" "test" {550  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id551  instance_type = "t2.small"552  tags = {553    Name     = "HelloWorld"554    TestSeed = "%[1]d"555  }556}557data "aws_instance" "test" {558  instance_tags = {559    Name     = aws_instance.test.tags["Name"]560    TestSeed = "%[1]d"561  }562}563`, rInt)564}565// filter on tag, populate more attributes566var testAccInstanceDataSourceConfig_AzUserData = composeConfig(testAccAvailableAZsNoOptInDefaultExcludeConfig(),567	testAccLatestAmazonLinuxHvmEbsAmiConfig(), `568resource "aws_instance" "test" {569  ami               = data.aws_ami.amzn-ami-minimal-hvm-ebs.id570  availability_zone = data.aws_availability_zones.available.names[0]571  instance_type = "t2.micro"572  user_data     = "test:-with-character's"573  tags = {574    TFAccTest = "YesThisIsATest"575  }576}577data "aws_instance" "test" {578  instance_id = aws_instance.test.id579}580`)581// GP2IopsDevice582var testAccInstanceDataSourceConfig_gp2IopsDevice = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `583resource "aws_instance" "test" {584  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id585  instance_type = "t3.medium"586  root_block_device {587    volume_type = "gp2"588    volume_size = 11589  }590}591data "aws_instance" "test" {592  instance_id = aws_instance.test.id593}594`595// GP3ThroughputDevice596var testAccInstanceDataSourceConfig_gp3ThroughputDevice = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `597resource "aws_instance" "test" {598  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id599  instance_type = "t3.medium"600  root_block_device {601    volume_type = "gp3"602    volume_size = 10603    throughput  = 300604  }605}606data "aws_instance" "test" {607  instance_id = aws_instance.test.id608}609`610// Block Device611var testAccInstanceDataSourceConfig_blockDevices = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `612resource "aws_instance" "test" {613  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id614  instance_type = "t3.medium"615  root_block_device {616    volume_type = "gp2"617    volume_size = 11618  }619  ebs_block_device {620    device_name = "/dev/sdb"621    volume_size = 9622  }623  ebs_block_device {624    device_name = "/dev/sdc"625    volume_size = 10626    volume_type = "io1"627    iops        = 100628  }629  # Encrypted ebs block device630  ebs_block_device {631    device_name = "/dev/sdd"632    volume_size = 12633    encrypted   = true634  }635  ephemeral_block_device {636    device_name  = "/dev/sde"637    virtual_name = "ephemeral0"638  }639  ebs_block_device {640    device_name = "/dev/sdf"641    volume_size = 10642    volume_type = "gp3"643    throughput  = 300644  }645}646data "aws_instance" "test" {647  instance_id = aws_instance.test.id648}649`650var testAccInstanceDataSourceConfig_EbsBlockDevice_KmsKeyId = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `651resource "aws_kms_key" "test" {652  deletion_window_in_days = 7653}654resource "aws_instance" "test" {655  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id656  instance_type = "t3.medium"657  root_block_device {658    volume_type = "gp2"659    volume_size = 11660  }661  ebs_block_device {662    device_name = "/dev/sdb"663    encrypted   = true664    kms_key_id  = aws_kms_key.test.arn665    volume_size = 9666  }667}668data "aws_instance" "test" {669  instance_id = aws_instance.test.id670}671`672var testAccInstanceDataSourceConfig_RootBlockDevice_KmsKeyId = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `673resource "aws_kms_key" "test" {674  deletion_window_in_days = 7675}676resource "aws_instance" "test" {677  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id678  instance_type = "t3.medium"679  root_block_device {680    encrypted   = true681    kms_key_id  = aws_kms_key.test.arn682    volume_type = "gp2"683    volume_size = 11684  }685}686data "aws_instance" "test" {687  instance_id = aws_instance.test.id688}689`690var testAccInstanceDataSourceConfig_rootInstanceStore = testAccLatestAmazonLinuxHvmEbsAmiConfig() + `691resource "aws_instance" "test" {692  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id693  instance_type = "t3.medium"694}695data "aws_instance" "test" {696  instance_id = aws_instance.test.id697}698`699func testAccInstanceDataSourceConfig_privateIP(rName string) string {700	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), testAccAwsInstanceVpcConfigBasic(rName), `701resource "aws_instance" "test" {702  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id703  instance_type = "t2.micro"704  subnet_id     = aws_subnet.test.id705  private_ip    = "10.0.0.42"706}707data "aws_instance" "test" {708  instance_id = aws_instance.test.id709}710`)711}712func testAccInstanceDataSourceConfig_secondaryPrivateIPs(rName string) string {713	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), testAccAwsInstanceVpcConfigBasic(rName), `714resource "aws_instance" "test" {715  ami                   = data.aws_ami.amzn-ami-minimal-hvm-ebs.id716  instance_type         = "t2.micro"717  subnet_id             = aws_subnet.test.id718  secondary_private_ips = ["10.0.0.42"]719}720data "aws_instance" "test" {721  instance_id = aws_instance.test.id722}723`)724}725func testAccInstanceDataSourceConfig_keyPair(rName string) string {726	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + fmt.Sprintf(`727resource "aws_key_pair" "test" {728  key_name   = %[1]q729  public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD3F6tyPEFEzV0LX3X8BsXdMsQz1x2cEikKDEY0aIj41qgxMCP/iteneqXSIFZBp5vizPvaoIR3Um9xK7PGoW8giupGn+EPuxIA4cDM4vzOqOkiMPhz5XK0whEjkVzTo4+S0puvDZuwIsdiW9mxhJc7tgBNL0cYlWSYVkz4G/fslNfRPW5mYAM49f4fhtxPb5ok4Q2Lg9dPKVHO/Bgeu5woMc7RY0p1ej6D4CKFE6lymSDJpW0YHX/wqE9+cfEauh7xZcG0q9t2ta6F6fmX0agvpFyZo8aFbXeUBr7osSCJNgvavWbM/06niWrOvYX2xwWdhXmXSrbX8ZbabVohBK41 phodgson@thoughtworks.com"730}731resource "aws_instance" "test" {732  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id733  instance_type = "t2.micro"734  key_name      = aws_key_pair.test.key_name735  tags = {736    Name = %[1]q737  }738}739data "aws_instance" "test" {740  filter {741    name   = "tag:Name"742    values = [%[1]q]743  }744  filter {745    name   = "key-name"746    values = [aws_instance.test.key_name]747  }748}749`, rName)750}751func testAccInstanceDataSourceConfig_VPC(rName string) string {752	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(), testAccAwsInstanceVpcConfigBasic(rName), `753resource "aws_instance" "test" {754  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id755  instance_type               = "t2.small"756  subnet_id                   = aws_subnet.test.id757  associate_public_ip_address = true758  #tenancy                     = "dedicated"759  # pre-encoded base64 data760  user_data = "3dc39dda39be1205215e776bad998da361a5955d"761}762data "aws_instance" "test" {763  instance_id = aws_instance.test.id764}765`)766}767func testAccInstanceDataSourceConfig_PlacementGroup(rName string) string {768	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + testAccAwsInstanceVpcConfigBasic(rName) + fmt.Sprintf(`769resource "aws_placement_group" "test" {770  name     = %[1]q771  strategy = "cluster"772}773# Limitations: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html#concepts-placement-groups774resource "aws_instance" "test" {775  ami                         = data.aws_ami.amzn-ami-minimal-hvm-ebs.id776  instance_type               = "c5.large"777  subnet_id                   = aws_subnet.test.id778  associate_public_ip_address = true779  placement_group             = aws_placement_group.test.name780  # pre-encoded base64 data781  user_data = "3dc39dda39be1205215e776bad998da361a5955d"782}783data "aws_instance" "test" {784  instance_id = aws_instance.test.id785}786`, rName)787}788func testAccInstanceDataSourceConfig_SecurityGroups(rInt int) string {789	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + fmt.Sprintf(`790resource "aws_security_group" "tf_test_foo" {791  name        = "tf_test_foo-%d"792  description = "foo"793  ingress {794    protocol  = "icmp"795    from_port = -1796    to_port   = -1797    self      = true798  }799}800resource "aws_instance" "test" {801  ami             = data.aws_ami.amzn-ami-minimal-hvm-ebs.id802  instance_type   = "t2.small"803  security_groups = [aws_security_group.tf_test_foo.name]804  user_data       = "foo:-with-character's"805}806data "aws_instance" "test" {807  instance_id = aws_instance.test.id808}809`, rInt)810}811func testAccInstanceDataSourceConfig_VPCSecurityGroups(rName string) string {812	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(),813		testAccAwsInstanceVpcConfigBasic(rName),814		testAccAwsInstanceVpcSecurityGroupConfig(rName),815		`816resource "aws_instance" "test" {817  ami                    = data.aws_ami.amzn-ami-minimal-hvm-ebs.id818  instance_type          = "t2.micro"819  vpc_security_group_ids = [aws_security_group.test.id]820  subnet_id              = aws_subnet.test.id821  depends_on             = [aws_internet_gateway.test]822}823data "aws_instance" "test" {824  instance_id = aws_instance.test.id825}826`)827}828func testAccInstanceDataSourceConfig_getPasswordData(rName string, val bool) string {829	return testAccLatestWindowsServer2016CoreAmiConfig() + fmt.Sprintf(`830resource "aws_key_pair" "test" {831  key_name   = %[1]q832  public_key = "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAQEAq6U3HQYC4g8WzU147gZZ7CKQH8TgYn3chZGRPxaGmHW1RUwsyEs0nmombmIhwxudhJ4ehjqXsDLoQpd6+c7BuLgTMvbv8LgE9LX53vnljFe1dsObsr/fYLvpU9LTlo8HgHAqO5ibNdrAUvV31ronzCZhms/Gyfdaue88Fd0/YnsZVGeOZPayRkdOHSpqme2CBrpa8myBeL1CWl0LkDG4+YCURjbaelfyZlIApLYKy3FcCan9XQFKaL32MJZwCgzfOvWIMtYcU8QtXMgnA3/I3gXk8YDUJv5P4lj0s/PJXuTM8DygVAUtebNwPuinS7wwonm5FXcWMuVGsVpG5K7FGQ== tf-acc-winpasswordtest"833}834resource "aws_instance" "test" {835  ami           = data.aws_ami.win2016core-ami.id836  instance_type = "t2.medium"837  key_name      = aws_key_pair.test.key_name838}839data "aws_instance" "test" {840  instance_id = aws_instance.test.id841  get_password_data = %[2]t842}843`, rName, val)844}845func testAccInstanceDataSourceConfigGetUserData(rName string, getUserData bool) string {846	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + testAccAwsInstanceVpcConfigBasic(rName) + fmt.Sprintf(`847resource "aws_instance" "test" {848  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id849  instance_type = "t2.micro"850  subnet_id     = aws_subnet.test.id851  user_data = <<EUD852#!/bin/bash853echo "hello world"854EUD855}856data "aws_instance" "test" {857  get_user_data = %[2]t858  instance_id   = aws_instance.test.id859}860`, rName, getUserData)861}862func testAccInstanceDataSourceConfigGetUserDataNoUserData(rName string, getUserData bool) string {863	return testAccLatestAmazonLinuxHvmEbsAmiConfig() + testAccAwsInstanceVpcConfigBasic(rName) + fmt.Sprintf(`864resource "aws_instance" "test" {865  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id866  instance_type = "t2.micro"867  subnet_id     = aws_subnet.test.id868}869data "aws_instance" "test" {870  get_user_data = %[2]t871  instance_id   = aws_instance.test.id872}873`, rName, getUserData)874}875func testAccInstanceDataSourceConfig_creditSpecification(rName string) string {876	return composeConfig(testAccLatestAmazonLinuxHvmEbsAmiConfig(),877		testAccAwsInstanceVpcConfigBasic(rName), `878resource "aws_instance" "test" {879  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id880  instance_type = "t2.micro"881  subnet_id     = aws_subnet.test.id882  credit_specification {883    cpu_credits = "unlimited"884  }885}886data "aws_instance" "test" {887  instance_id = aws_instance.test.id888}889`)890}891func testAccInstanceDataSourceConfig_metadataOptions(rName string) string {892	return composeConfig(893		testAccLatestAmazonLinuxHvmEbsAmiConfig(),894		testAccAwsInstanceVpcConfig(rName, false),895		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro"),896		fmt.Sprintf(`897resource "aws_instance" "test" {898  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id899  instance_type = data.aws_ec2_instance_type_offering.available.instance_type900  subnet_id     = aws_subnet.test.id901  tags = {902    Name = %[1]q903  }904  metadata_options {905    http_endpoint               = "enabled"906    http_tokens                 = "required"907    http_put_response_hop_limit = 2908  }909}910data "aws_instance" "test" {911  instance_id = aws_instance.test.id912}913`, rName))914}915func testAccInstanceDataSourceConfig_enclaveOptions(rName string) string {916	return composeConfig(917		testAccLatestAmazonLinuxHvmEbsAmiConfig(),918		testAccAwsInstanceVpcConfig(rName, false),919		testAccAvailableEc2InstanceTypeForRegion("c5a.xlarge", "c5.xlarge"),920		fmt.Sprintf(`921resource "aws_instance" "test" {922  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id923  instance_type = data.aws_ec2_instance_type_offering.available.instance_type924  subnet_id     = aws_subnet.test.id925  tags = {926    Name = %[1]q927  }928  enclave_options {929    enabled = true930  }931}932data "aws_instance" "test" {933  instance_id = aws_instance.test.id934}935`, rName))936}937func testAccInstanceDataSourceConfig_blockDeviceTags(rName string) string {938	return composeConfig(939		testAccLatestAmazonLinuxHvmEbsAmiConfig(),940		testAccAvailableEc2InstanceTypeForRegion("t3.micro", "t2.micro"),941		fmt.Sprintf(`942resource "aws_instance" "test" {943  ami           = data.aws_ami.amzn-ami-minimal-hvm-ebs.id944  instance_type = data.aws_ec2_instance_type_offering.available.instance_type945  tags = {946    Name = %[1]q947  }948  ebs_block_device {949    device_name = "/dev/xvdc"950    volume_size = 10951    tags = {952      Name   = %[1]q953      Factum = "SapereAude"954    }955  }956  root_block_device {957    tags = {958      Name   = %[1]q959      Factum = "VincitQuiSeVincit"960    }961  }962}963data "aws_instance" "test" {964  instance_id = aws_instance.test.id965}966`, rName))967}...

resource_aws_lightsail_instance_test.go

Source:resource_aws_lightsail_instance_test.go

...3	"errors"4	"fmt"5	"log"6	"regexp"7	"testing"8	"time"9	"github.com/aws/aws-sdk-go/aws"10	"github.com/aws/aws-sdk-go/aws/awserr"11	"github.com/aws/aws-sdk-go/service/lightsail"12	"github.com/hashicorp/go-multierror"13	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest"14	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource"15	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"16)17func init() {18	resource.AddTestSweepers("aws_lightsail_instance", &resource.Sweeper{19		Name: "aws_lightsail_instance",20		F:    testSweepLightsailInstances,21	})22}23func testSweepLightsailInstances(region string) error {24	client, err := sharedClientForRegion(region)25	if err != nil {26		return fmt.Errorf("Error getting client: %s", err)27	}28	conn := client.(*AWSClient).lightsailconn29	input := &lightsail.GetInstancesInput{}30	var sweeperErrs *multierror.Error31	for {32		output, err := conn.GetInstances(input)33		if testSweepSkipSweepError(err) {34			log.Printf("[WARN] Skipping Lightsail Instance sweep for %s: %s", region, err)35			return nil36		}37		if err != nil {38			return fmt.Errorf("Error retrieving Lightsail Instances: %s", err)39		}40		for _, instance := range output.Instances {41			name := aws.StringValue(instance.Name)42			input := &lightsail.DeleteInstanceInput{43				InstanceName: instance.Name,44			}45			log.Printf("[INFO] Deleting Lightsail Instance: %s", name)46			_, err := conn.DeleteInstance(input)47			if err != nil {48				sweeperErr := fmt.Errorf("error deleting Lightsail Instance (%s): %s", name, err)49				log.Printf("[ERROR] %s", sweeperErr)50				sweeperErrs = multierror.Append(sweeperErrs, sweeperErr)51			}52		}53		if aws.StringValue(output.NextPageToken) == "" {54			break55		}56		input.PageToken = output.NextPageToken57	}58	return sweeperErrs.ErrorOrNil()59}60func TestAccAWSLightsailInstance_basic(t *testing.T) {61	var conf lightsail.Instance62	lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())63	resource.ParallelTest(t, resource.TestCase{64		PreCheck: func() {65			testAccPreCheck(t)66			testAccPartitionHasServicePreCheck(lightsail.EndpointsID, t)67			testAccPreCheckAWSLightsail(t)68		},69		ErrorCheck:   testAccErrorCheck(t, lightsail.EndpointsID),70		Providers:    testAccProviders,71		CheckDestroy: testAccCheckAWSLightsailInstanceDestroy,72		Steps: []resource.TestStep{73			{74				Config: testAccAWSLightsailInstanceConfig_basic(lightsailName),75				Check: resource.ComposeAggregateTestCheckFunc(76					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),77					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),78					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),79					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),80					resource.TestMatchResourceAttr("aws_lightsail_instance.lightsail_instance_test", "ipv6_address", regexp.MustCompile(`([a-f0-9]{1,4}:){7}[a-f0-9]{1,4}`)),81					resource.TestCheckResourceAttr("aws_lightsail_instance.lightsail_instance_test", "ipv6_addresses.#", "1"),82					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),83					resource.TestCheckResourceAttr("aws_lightsail_instance.lightsail_instance_test", "tags.%", "0"),84					resource.TestMatchResourceAttr("aws_lightsail_instance.lightsail_instance_test", "ram_size", regexp.MustCompile(`\d+(.\d+)?`)),85				),86			},87		},88	})89}90func TestAccAWSLightsailInstance_Name(t *testing.T) {91	var conf lightsail.Instance92	lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())93	lightsailNameWithSpaces := fmt.Sprint(lightsailName, "string with spaces")94	lightsailNameWithStartingDigit := fmt.Sprintf("01-%s", lightsailName)95	lightsailNameWithUnderscore := fmt.Sprintf("%s_123456", lightsailName)96	resource.ParallelTest(t, resource.TestCase{97		PreCheck: func() {98			testAccPreCheck(t)99			testAccPartitionHasServicePreCheck(lightsail.EndpointsID, t)100			testAccPreCheckAWSLightsail(t)101		},102		ErrorCheck:   testAccErrorCheck(t, lightsail.EndpointsID),103		Providers:    testAccProviders,104		CheckDestroy: testAccCheckAWSLightsailInstanceDestroy,105		Steps: []resource.TestStep{106			{107				Config:      testAccAWSLightsailInstanceConfig_basic(lightsailNameWithSpaces),108				ExpectError: regexp.MustCompile(`must contain only alphanumeric characters, underscores, hyphens, and dots`),109			},110			{111				Config:      testAccAWSLightsailInstanceConfig_basic(lightsailNameWithStartingDigit),112				ExpectError: regexp.MustCompile(`must begin with an alphabetic character`),113			},114			{115				Config: testAccAWSLightsailInstanceConfig_basic(lightsailName),116				Check: resource.ComposeAggregateTestCheckFunc(117					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),118					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),119					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),120					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),121					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),122				),123			},124			{125				Config: testAccAWSLightsailInstanceConfig_basic(lightsailNameWithUnderscore),126				Check: resource.ComposeAggregateTestCheckFunc(127					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),128					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),129					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),130					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),131					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),132				),133			},134		},135	})136}137func TestAccAWSLightsailInstance_Tags(t *testing.T) {138	var conf lightsail.Instance139	lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())140	resource.ParallelTest(t, resource.TestCase{141		PreCheck: func() {142			testAccPreCheck(t)143			testAccPartitionHasServicePreCheck(lightsail.EndpointsID, t)144			testAccPreCheckAWSLightsail(t)145		},146		ErrorCheck:   testAccErrorCheck(t, lightsail.EndpointsID),147		Providers:    testAccProviders,148		CheckDestroy: testAccCheckAWSLightsailInstanceDestroy,149		Steps: []resource.TestStep{150			{151				Config: testAccAWSLightsailInstanceConfig_tags1(lightsailName),152				Check: resource.ComposeAggregateTestCheckFunc(153					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),154					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),155					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),156					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),157					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),158					resource.TestCheckResourceAttr("aws_lightsail_instance.lightsail_instance_test", "tags.%", "2"),159				),160			},161			{162				Config: testAccAWSLightsailInstanceConfig_tags2(lightsailName),163				Check: resource.ComposeAggregateTestCheckFunc(164					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),165					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "availability_zone"),166					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "blueprint_id"),167					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "bundle_id"),168					resource.TestCheckResourceAttrSet("aws_lightsail_instance.lightsail_instance_test", "key_pair_name"),169					resource.TestCheckResourceAttr("aws_lightsail_instance.lightsail_instance_test", "tags.%", "3"),170				),171			},172		},173	})174}175func TestAccAWSLightsailInstance_disapear(t *testing.T) {176	var conf lightsail.Instance177	lightsailName := fmt.Sprintf("tf-test-lightsail-%d", acctest.RandInt())178	testDestroy := func(*terraform.State) error {179		// reach out and DELETE the Instance180		conn := testAccProvider.Meta().(*AWSClient).lightsailconn181		_, err := conn.DeleteInstance(&lightsail.DeleteInstanceInput{182			InstanceName: aws.String(lightsailName),183		})184		if err != nil {185			return fmt.Errorf("error deleting Lightsail Instance in disappear test")186		}187		// sleep 7 seconds to give it time, so we don't have to poll188		time.Sleep(7 * time.Second)189		return nil190	}191	resource.ParallelTest(t, resource.TestCase{192		PreCheck: func() {193			testAccPreCheck(t)194			testAccPartitionHasServicePreCheck(lightsail.EndpointsID, t)195			testAccPreCheckAWSLightsail(t)196		},197		ErrorCheck:   testAccErrorCheck(t, lightsail.EndpointsID),198		Providers:    testAccProviders,199		CheckDestroy: testAccCheckAWSLightsailInstanceDestroy,200		Steps: []resource.TestStep{201			{202				Config: testAccAWSLightsailInstanceConfig_basic(lightsailName),203				Check: resource.ComposeTestCheckFunc(204					testAccCheckAWSLightsailInstanceExists("aws_lightsail_instance.lightsail_instance_test", &conf),205					testDestroy,206				),207				ExpectNonEmptyPlan: true,208			},209		},210	})211}212func testAccCheckAWSLightsailInstanceExists(n string, res *lightsail.Instance) resource.TestCheckFunc {213	return func(s *terraform.State) error {214		rs, ok := s.RootModule().Resources[n]215		if !ok {216			return fmt.Errorf("Not found: %s", n)217		}218		if rs.Primary.ID == "" {219			return errors.New("No LightsailInstance ID is set")220		}221		conn := testAccProvider.Meta().(*AWSClient).lightsailconn222		respInstance, err := conn.GetInstance(&lightsail.GetInstanceInput{223			InstanceName: aws.String(rs.Primary.Attributes["name"]),224		})225		if err != nil {226			return err227		}228		if respInstance == nil || respInstance.Instance == nil {229			return fmt.Errorf("Instance (%s) not found", rs.Primary.Attributes["name"])230		}231		*res = *respInstance.Instance232		return nil233	}234}235func testAccCheckAWSLightsailInstanceDestroy(s *terraform.State) error {236	for _, rs := range s.RootModule().Resources {237		if rs.Type != "aws_lightsail_instance" {238			continue239		}240		conn := testAccProvider.Meta().(*AWSClient).lightsailconn241		respInstance, err := conn.GetInstance(&lightsail.GetInstanceInput{242			InstanceName: aws.String(rs.Primary.Attributes["name"]),243		})244		if err == nil {245			if respInstance.Instance != nil {246				return fmt.Errorf("LightsailInstance %q still exists", rs.Primary.ID)247			}248		}249		// Verify the error250		if awsErr, ok := err.(awserr.Error); ok {251			if awsErr.Code() == "NotFoundException" {252				return nil253			}254		}255		return err256	}257	return nil258}259func testAccPreCheckAWSLightsail(t *testing.T) {260	conn := testAccProvider.Meta().(*AWSClient).lightsailconn261	input := &lightsail.GetInstancesInput{}262	_, err := conn.GetInstances(input)263	if testAccPreCheckSkipError(err) {264		t.Skipf("skipping acceptance testing: %s", err)265	}266	if err != nil {267		t.Fatalf("unexpected PreCheck error: %s", err)268	}269}270func testAccAWSLightsailInstanceConfig_basic(lightsailName string) string {271	return fmt.Sprintf(`272data "aws_availability_zones" "available" {273  state = "available"274  filter {275    name   = "opt-in-status"276    values = ["opt-in-not-required"]277  }278}279resource "aws_lightsail_instance" "lightsail_instance_test" {280  name              = "%s"281  availability_zone = data.aws_availability_zones.available.names[0]282  blueprint_id      = "amazon_linux"283  bundle_id         = "nano_1_0"284}285`, lightsailName)286}287func testAccAWSLightsailInstanceConfig_tags1(lightsailName string) string {288	return fmt.Sprintf(`289data "aws_availability_zones" "available" {290  state = "available"291  filter {292    name   = "opt-in-status"293    values = ["opt-in-not-required"]294  }295}296resource "aws_lightsail_instance" "lightsail_instance_test" {297  name              = "%s"298  availability_zone = data.aws_availability_zones.available.names[0]299  blueprint_id      = "amazon_linux"300  bundle_id         = "nano_1_0"301  tags = {302    Name       = "tf-test"303    KeyOnlyTag = ""304  }305}306`, lightsailName)307}308func testAccAWSLightsailInstanceConfig_tags2(lightsailName string) string {309	return fmt.Sprintf(`310data "aws_availability_zones" "available" {311  state = "available"312  filter {313    name   = "opt-in-status"314    values = ["opt-in-not-required"]315  }316}317resource "aws_lightsail_instance" "lightsail_instance_test" {318  name              = "%s"319  availability_zone = data.aws_availability_zones.available.names[0]320  blueprint_id      = "amazon_linux"321  bundle_id         = "nano_1_0"322  tags = {323    Name       = "tf-test",324    KeyOnlyTag = ""325    ExtraName  = "tf-test"326  }327}328`, lightsailName)329}...

test

Using AI Code Generation

1import (2type Student struct {3}4func (s *Student) test() {5	fmt.Println("test() Name=", s.Name, "Age=", s.Age)6}7func main() {8	s.test()9}10import (11type Student struct {12}13func (s *Student) test() {14	fmt.Println("test() Name=", s.Name, "Age=", s.Age)15}16func main() {17	var s *Student = &Student{18	}19	s.test()20}21import (22type Student struct {23}24func (s *Student) test() {25	fmt.Println("test() Name=", s.Name, "Age=", s.Age)26}27func main() {28	var s *Student = &Student{29	}30	s.test()31}32import (33type Student struct {34}35func (s *Student) test() {36	fmt.Println("test() Name=", s.Name, "Age=", s.Age)37}38func main() {39	var s *Student = &Student{40	}41	s.test()42}43import (44type Student struct {45}46func (s *Student) test() {47	fmt.Println("test() Name=", s.Name, "Age=", s.Age)48}49func main() {50	var s *Student = &Student{51	}52	s.test()53}54import (55type Student struct {

test

Using AI Code Generation

1import (2type Test struct {3}4func (t Test) test() {5	fmt.Println("test method")6}7func main() {8	t := Test{10}9	t.test()10}11import (12type Test struct {13}14func (t *Test) test() {15	fmt.Println("test method")16}17func main() {18	t := &Test{10}19	t.test()20}21import (22type Test struct {23}24func (t Test) test() {25	fmt.Println("test method")26}27func main() {28	t := Test{10}29	t.test()30}31import (32type Test struct {33}34func (t *Test) test() {35	fmt.Println("test method")36}37func main() {38	t := &Test{10}39	t.test()40}41import (42type Test struct {43}44func (t Test) test() {45	fmt.Println("test method")46}47func main() {48	t := Test{10}49	t.test()50}51import (52type Test struct {53}54func (t *Test) test() {55	fmt.Println("test method")56}57func main() {58	t := &Test{10}59	t.test()60}61import (62type Test struct {63}64func (t Test) test() {65	fmt.Println("test method")66}67func main() {68	t := Test{10}69	t.test()70}71import (72type Test struct {73}74func (t *Test) test() {75	fmt.Println("test method")76}77func main() {78	t := &Test{10}79	t.test()80}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.