github.com/eliastor/durgaform@v0.0.0-20220816172711-d0ab2d17673e/internal/durgaform/transform_import_state_test.go (about)

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