github.com/jaredpalmer/terraform@v1.1.0-alpha20210908.0.20210911170307-88705c943a03/internal/terraform/transform_import_state_test.go (about)

     1  package terraform
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	"github.com/hashicorp/terraform/internal/addrs"
     8  	"github.com/hashicorp/terraform/internal/configs/configschema"
     9  	"github.com/hashicorp/terraform/internal/providers"
    10  	"github.com/hashicorp/terraform/internal/states"
    11  	"github.com/zclconf/go-cty/cty"
    12  )
    13  
    14  func TestGraphNodeImportStateExecute(t *testing.T) {
    15  	state := states.NewState()
    16  	provider := testProvider("aws")
    17  	provider.ImportResourceStateResponse = &providers.ImportResourceStateResponse{
    18  		ImportedResources: []providers.ImportedResource{
    19  			{
    20  				TypeName: "aws_instance",
    21  				State: cty.ObjectVal(map[string]cty.Value{
    22  					"id": cty.StringVal("bar"),
    23  				}),
    24  			},
    25  		},
    26  	}
    27  
    28  	ctx := &MockEvalContext{
    29  		StateState:       state.SyncWrapper(),
    30  		ProviderProvider: provider,
    31  	}
    32  
    33  	// Import a new aws_instance.foo, this time with ID=bar. The original
    34  	// aws_instance.foo object should be removed from state and replaced with
    35  	// the new.
    36  	node := graphNodeImportState{
    37  		Addr: addrs.Resource{
    38  			Mode: addrs.ManagedResourceMode,
    39  			Type: "aws_instance",
    40  			Name: "foo",
    41  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
    42  		ID: "bar",
    43  		ResolvedProvider: addrs.AbsProviderConfig{
    44  			Provider: addrs.NewDefaultProvider("aws"),
    45  			Module:   addrs.RootModule,
    46  		},
    47  	}
    48  
    49  	diags := node.Execute(ctx, walkImport)
    50  	if diags.HasErrors() {
    51  		t.Fatalf("Unexpected error: %s", diags.Err())
    52  	}
    53  
    54  	if len(node.states) != 1 {
    55  		t.Fatalf("Wrong result! Expected one imported resource, got %d", len(node.states))
    56  	}
    57  	// Verify the ID for good measure
    58  	id := node.states[0].State.GetAttr("id")
    59  	if !id.RawEquals(cty.StringVal("bar")) {
    60  		t.Fatalf("Wrong result! Expected id \"bar\", got %q", id.AsString())
    61  	}
    62  }
    63  
    64  func TestGraphNodeImportStateSubExecute(t *testing.T) {
    65  	state := states.NewState()
    66  	provider := testProvider("aws")
    67  	ctx := &MockEvalContext{
    68  		StateState:       state.SyncWrapper(),
    69  		ProviderProvider: provider,
    70  		ProviderSchemaSchema: &ProviderSchema{
    71  			ResourceTypes: map[string]*configschema.Block{
    72  				"aws_instance": {
    73  					Attributes: map[string]*configschema.Attribute{
    74  						"id": {
    75  							Type:     cty.String,
    76  							Computed: true,
    77  						},
    78  					},
    79  				},
    80  			},
    81  		},
    82  	}
    83  
    84  	importedResource := providers.ImportedResource{
    85  		TypeName: "aws_instance",
    86  		State:    cty.ObjectVal(map[string]cty.Value{"id": cty.StringVal("bar")}),
    87  	}
    88  
    89  	node := graphNodeImportStateSub{
    90  		TargetAddr: addrs.Resource{
    91  			Mode: addrs.ManagedResourceMode,
    92  			Type: "aws_instance",
    93  			Name: "foo",
    94  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
    95  		State: importedResource,
    96  		ResolvedProvider: addrs.AbsProviderConfig{
    97  			Provider: addrs.NewDefaultProvider("aws"),
    98  			Module:   addrs.RootModule,
    99  		},
   100  	}
   101  	diags := node.Execute(ctx, walkImport)
   102  	if diags.HasErrors() {
   103  		t.Fatalf("Unexpected error: %s", diags.Err())
   104  	}
   105  
   106  	// check for resource in state
   107  	actual := strings.TrimSpace(state.String())
   108  	expected := `aws_instance.foo:
   109    ID = bar
   110    provider = provider["registry.terraform.io/hashicorp/aws"]`
   111  	if actual != expected {
   112  		t.Fatalf("bad state after import: \n%s", actual)
   113  	}
   114  }
   115  
   116  func TestGraphNodeImportStateSubExecuteNull(t *testing.T) {
   117  	state := states.NewState()
   118  	provider := testProvider("aws")
   119  	provider.ReadResourceFn = func(req providers.ReadResourceRequest) (resp providers.ReadResourceResponse) {
   120  		// return null indicating that the requested resource does not exist
   121  		resp.NewState = cty.NullVal(cty.Object(map[string]cty.Type{
   122  			"id": cty.String,
   123  		}))
   124  		return resp
   125  	}
   126  
   127  	ctx := &MockEvalContext{
   128  		StateState:       state.SyncWrapper(),
   129  		ProviderProvider: provider,
   130  		ProviderSchemaSchema: &ProviderSchema{
   131  			ResourceTypes: map[string]*configschema.Block{
   132  				"aws_instance": {
   133  					Attributes: map[string]*configschema.Attribute{
   134  						"id": {
   135  							Type:     cty.String,
   136  							Computed: true,
   137  						},
   138  					},
   139  				},
   140  			},
   141  		},
   142  	}
   143  
   144  	importedResource := providers.ImportedResource{
   145  		TypeName: "aws_instance",
   146  		State:    cty.ObjectVal(map[string]cty.Value{"id": cty.StringVal("bar")}),
   147  	}
   148  
   149  	node := graphNodeImportStateSub{
   150  		TargetAddr: addrs.Resource{
   151  			Mode: addrs.ManagedResourceMode,
   152  			Type: "aws_instance",
   153  			Name: "foo",
   154  		}.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance),
   155  		State: importedResource,
   156  		ResolvedProvider: addrs.AbsProviderConfig{
   157  			Provider: addrs.NewDefaultProvider("aws"),
   158  			Module:   addrs.RootModule,
   159  		},
   160  	}
   161  	diags := node.Execute(ctx, walkImport)
   162  	if !diags.HasErrors() {
   163  		t.Fatal("expected error for non-existent resource")
   164  	}
   165  }