package schema import ( "encoding/json" "fmt" "reflect" "strconv" "testing" "time" "github.com/google/go-cmp/cmp" "github.com/hashicorp/terraform/internal/configs/hcl2shim" "github.com/hashicorp/terraform/internal/legacy/terraform" "github.com/zclconf/go-cty/cty" ctyjson "github.com/zclconf/go-cty/cty/json" ) func TestResourceApply_create(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } called := false r.Create = func(d *ResourceData, m interface{}) error { called = true d.SetId("foo") return nil } var s *terraform.InstanceState = nil d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "42", }, }, } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } if !called { t.Fatal("not called") } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "42", }, Meta: map[string]interface{}{ "schema_version": "2", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad: %#v", actual) } } func TestResourceApply_Timeout_state(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, Timeouts: &ResourceTimeout{ Create: DefaultTimeout(40 * time.Minute), Update: DefaultTimeout(80 * time.Minute), Delete: DefaultTimeout(40 * time.Minute), }, } called := false r.Create = func(d *ResourceData, m interface{}) error { called = true d.SetId("foo") return nil } var s *terraform.InstanceState = nil d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "42", }, }, } diffTimeout := &ResourceTimeout{ Create: DefaultTimeout(40 * time.Minute), Update: DefaultTimeout(80 * time.Minute), Delete: DefaultTimeout(40 * time.Minute), } if err := diffTimeout.DiffEncode(d); err != nil { t.Fatalf("Error encoding timeout to diff: %s", err) } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } if !called { t.Fatal("not called") } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "42", }, Meta: map[string]interface{}{ "schema_version": "2", TimeoutKey: expectedForValues(40, 0, 80, 40, 0), }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("Not equal in Timeout State:\n\texpected: %#v\n\tactual: %#v", expected.Meta, actual.Meta) } } // Regression test to ensure that the meta data is read from state, if a // resource is destroyed and the timeout meta is no longer available from the // config func TestResourceApply_Timeout_destroy(t *testing.T) { timeouts := &ResourceTimeout{ Create: DefaultTimeout(40 * time.Minute), Update: DefaultTimeout(80 * time.Minute), Delete: DefaultTimeout(40 * time.Minute), } r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, Timeouts: timeouts, } called := false var delTimeout time.Duration r.Delete = func(d *ResourceData, m interface{}) error { delTimeout = d.Timeout(TimeoutDelete) called = true return nil } s := &terraform.InstanceState{ ID: "bar", } if err := timeouts.StateEncode(s); err != nil { t.Fatalf("Error encoding to state: %s", err) } d := &terraform.InstanceDiff{ Destroy: true, } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } if !called { t.Fatal("delete not called") } if *timeouts.Delete != delTimeout { t.Fatalf("timeouts don't match, expected (%#v), got (%#v)", timeouts.Delete, delTimeout) } if actual != nil { t.Fatalf("bad: %#v", actual) } } func TestResourceDiff_Timeout_diff(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, Timeouts: &ResourceTimeout{ Create: DefaultTimeout(40 * time.Minute), Update: DefaultTimeout(80 * time.Minute), Delete: DefaultTimeout(40 * time.Minute), }, } r.Create = func(d *ResourceData, m interface{}) error { d.SetId("foo") return nil } conf := terraform.NewResourceConfigRaw( map[string]interface{}{ "foo": 42, TimeoutsConfigKey: map[string]interface{}{ "create": "2h", }, }, ) var s *terraform.InstanceState actual, err := r.Diff(s, conf, nil) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "42", }, }, } diffTimeout := &ResourceTimeout{ Create: DefaultTimeout(120 * time.Minute), Update: DefaultTimeout(80 * time.Minute), Delete: DefaultTimeout(40 * time.Minute), } if err := diffTimeout.DiffEncode(expected); err != nil { t.Fatalf("Error encoding timeout to diff: %s", err) } if !reflect.DeepEqual(actual, expected) { t.Fatalf("Not equal Meta in Timeout Diff:\n\texpected: %#v\n\tactual: %#v", expected.Meta, actual.Meta) } } func TestResourceDiff_CustomizeFunc(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } var called bool r.CustomizeDiff = func(d *ResourceDiff, m interface{}) error { called = true return nil } conf := terraform.NewResourceConfigRaw( map[string]interface{}{ "foo": 42, }, ) var s *terraform.InstanceState _, err := r.Diff(s, conf, nil) if err != nil { t.Fatalf("err: %s", err) } if !called { t.Fatalf("diff customization not called") } } func TestResourceApply_destroy(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } called := false r.Delete = func(d *ResourceData, m interface{}) error { called = true return nil } s := &terraform.InstanceState{ ID: "bar", } d := &terraform.InstanceDiff{ Destroy: true, } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } if !called { t.Fatal("delete not called") } if actual != nil { t.Fatalf("bad: %#v", actual) } } func TestResourceApply_destroyCreate(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, "tags": &Schema{ Type: TypeMap, Optional: true, Computed: true, }, }, } change := false r.Create = func(d *ResourceData, m interface{}) error { change = d.HasChange("tags") d.SetId("foo") return nil } r.Delete = func(d *ResourceData, m interface{}) error { return nil } var s *terraform.InstanceState = &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "bar", "tags.Name": "foo", }, } d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "42", RequiresNew: true, }, "tags.Name": &terraform.ResourceAttrDiff{ Old: "foo", New: "foo", RequiresNew: true, }, }, } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } if !change { t.Fatal("should have change") } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "42", "tags.%": "1", "tags.Name": "foo", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad: %#v", actual) } } func TestResourceApply_destroyPartial(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, SchemaVersion: 3, } r.Delete = func(d *ResourceData, m interface{}) error { d.Set("foo", 42) return fmt.Errorf("some error") } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "12", }, } d := &terraform.InstanceDiff{ Destroy: true, } actual, err := r.Apply(s, d, nil) if err == nil { t.Fatal("should error") } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "foo": "42", }, Meta: map[string]interface{}{ "schema_version": "3", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("expected:\n%#v\n\ngot:\n%#v", expected, actual) } } func TestResourceApply_update(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Update = func(d *ResourceData, m interface{}) error { d.Set("foo", 42) return nil } s := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "foo": "12", }, } d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "13", }, }, } actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "42", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad: %#v", actual) } } func TestResourceApply_updateNoCallback(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Update = nil s := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "foo": "12", }, } d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "13", }, }, } actual, err := r.Apply(s, d, nil) if err == nil { t.Fatal("should error") } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "foo": "12", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad: %#v", actual) } } func TestResourceApply_isNewResource(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeString, Optional: true, }, }, } updateFunc := func(d *ResourceData, m interface{}) error { d.Set("foo", "updated") if d.IsNewResource() { d.Set("foo", "new-resource") } return nil } r.Create = func(d *ResourceData, m interface{}) error { d.SetId("foo") d.Set("foo", "created") return updateFunc(d, m) } r.Update = updateFunc d := &terraform.InstanceDiff{ Attributes: map[string]*terraform.ResourceAttrDiff{ "foo": &terraform.ResourceAttrDiff{ New: "bla-blah", }, }, } // positive test var s *terraform.InstanceState = nil actual, err := r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "new-resource", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("actual: %#v\nexpected: %#v", actual, expected) } // negative test s = &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "new-resource", }, } actual, err = r.Apply(s, d, nil) if err != nil { t.Fatalf("err: %s", err) } expected = &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "updated", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("actual: %#v\nexpected: %#v", actual, expected) } } func TestResourceInternalValidate(t *testing.T) { cases := []struct { In *Resource Writable bool Err bool }{ 0: { nil, true, true, }, // No optional and no required 1: { &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, Required: true, }, }, }, true, true, }, // Update undefined for non-ForceNew field 2: { &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "boo": &Schema{ Type: TypeInt, Optional: true, }, }, }, true, true, }, // Update defined for ForceNew field 3: { &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, ForceNew: true, }, }, }, true, true, }, // non-writable doesn't need Update, Create or Delete 4: { &Resource{ Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, }, false, false, }, // non-writable *must not* have Create 5: { &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, }, false, true, }, // writable must have Read 6: { &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Delete: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, }, true, true, }, // writable must have Delete 7: { &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Read: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, }, true, true, }, 8: { // Reserved name at root should be disallowed &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Read: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Delete: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "count": { Type: TypeInt, Optional: true, }, }, }, true, true, }, 9: { // Reserved name at nested levels should be allowed &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Read: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Delete: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "parent_list": &Schema{ Type: TypeString, Optional: true, Elem: &Resource{ Schema: map[string]*Schema{ "provisioner": { Type: TypeString, Optional: true, }, }, }, }, }, }, true, false, }, 10: { // Provider reserved name should be allowed in resource &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Read: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Delete: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "alias": &Schema{ Type: TypeString, Optional: true, }, }, }, true, false, }, 11: { // ID should be allowed in data source &Resource{ Read: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "id": &Schema{ Type: TypeString, Optional: true, }, }, }, false, false, }, 12: { // Deprecated ID should be allowed in resource &Resource{ Create: func(d *ResourceData, meta interface{}) error { return nil }, Read: func(d *ResourceData, meta interface{}) error { return nil }, Update: func(d *ResourceData, meta interface{}) error { return nil }, Delete: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "id": &Schema{ Type: TypeString, Optional: true, Deprecated: "Use x_id instead", }, }, }, true, false, }, 13: { // non-writable must not define CustomizeDiff &Resource{ Read: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, CustomizeDiff: func(*ResourceDiff, interface{}) error { return nil }, }, false, true, }, 14: { // Deprecated resource &Resource{ Read: func(d *ResourceData, meta interface{}) error { return nil }, Schema: map[string]*Schema{ "goo": &Schema{ Type: TypeInt, Optional: true, }, }, DeprecationMessage: "This resource has been deprecated.", }, true, true, }, } for i, tc := range cases { t.Run(fmt.Sprintf("#%d", i), func(t *testing.T) { sm := schemaMap{} if tc.In != nil { sm = schemaMap(tc.In.Schema) } err := tc.In.InternalValidate(sm, tc.Writable) if err != nil && !tc.Err { t.Fatalf("%d: expected validation to pass: %s", i, err) } if err == nil && tc.Err { t.Fatalf("%d: expected validation to fail", i) } }) } } func TestResourceRefresh(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { if m != 42 { return fmt.Errorf("meta not passed") } return d.Set("foo", d.Get("foo").(int)+1) } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "12", }, } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "foo": "13", }, Meta: map[string]interface{}{ "schema_version": "2", }, } actual, err := r.Refresh(s, 42) if err != nil { t.Fatalf("err: %s", err) } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad: %#v", actual) } } func TestResourceRefresh_blankId(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { d.SetId("foo") return nil } s := &terraform.InstanceState{ ID: "", Attributes: map[string]string{}, } actual, err := r.Refresh(s, 42) if err != nil { t.Fatalf("err: %s", err) } if actual != nil { t.Fatalf("bad: %#v", actual) } } func TestResourceRefresh_delete(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { d.SetId("") return nil } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "12", }, } actual, err := r.Refresh(s, 42) if err != nil { t.Fatalf("err: %s", err) } if actual != nil { t.Fatalf("bad: %#v", actual) } } func TestResourceRefresh_existsError(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Exists = func(*ResourceData, interface{}) (bool, error) { return false, fmt.Errorf("error") } r.Read = func(d *ResourceData, m interface{}) error { panic("shouldn't be called") } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "12", }, } actual, err := r.Refresh(s, 42) if err == nil { t.Fatalf("should error") } if !reflect.DeepEqual(actual, s) { t.Fatalf("bad: %#v", actual) } } func TestResourceRefresh_noExists(t *testing.T) { r := &Resource{ Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Exists = func(*ResourceData, interface{}) (bool, error) { return false, nil } r.Read = func(d *ResourceData, m interface{}) error { panic("shouldn't be called") } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "foo": "12", }, } actual, err := r.Refresh(s, 42) if err != nil { t.Fatalf("err: %s", err) } if actual != nil { t.Fatalf("should have no state") } } func TestResourceRefresh_needsMigration(t *testing.T) { // Schema v2 it deals only in newfoo, which tracks foo as an int r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { return d.Set("newfoo", d.Get("newfoo").(int)+1) } r.MigrateState = func( v int, s *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) { // Real state migration functions will probably switch on this value, // but we'll just assert on it for now. if v != 1 { t.Fatalf("Expected StateSchemaVersion to be 1, got %d", v) } if meta != 42 { t.Fatal("Expected meta to be passed through to the migration function") } oldfoo, err := strconv.ParseFloat(s.Attributes["oldfoo"], 64) if err != nil { t.Fatalf("err: %#v", err) } s.Attributes["newfoo"] = strconv.Itoa(int(oldfoo * 10)) delete(s.Attributes, "oldfoo") return s, nil } // State is v1 and deals in oldfoo, which tracked foo as a float at 1/10th // the scale of newfoo s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "oldfoo": "1.2", }, Meta: map[string]interface{}{ "schema_version": "1", }, } actual, err := r.Refresh(s, 42) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "newfoo": "13", }, Meta: map[string]interface{}{ "schema_version": "2", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad:\n\nexpected: %#v\ngot: %#v", expected, actual) } } func TestResourceRefresh_noMigrationNeeded(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { return d.Set("newfoo", d.Get("newfoo").(int)+1) } r.MigrateState = func( v int, s *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) { t.Fatal("Migrate function shouldn't be called!") return nil, nil } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "newfoo": "12", }, Meta: map[string]interface{}{ "schema_version": "2", }, } actual, err := r.Refresh(s, nil) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "newfoo": "13", }, Meta: map[string]interface{}{ "schema_version": "2", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad:\n\nexpected: %#v\ngot: %#v", expected, actual) } } func TestResourceRefresh_stateSchemaVersionUnset(t *testing.T) { r := &Resource{ // Version 1 > Version 0 SchemaVersion: 1, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { return d.Set("newfoo", d.Get("newfoo").(int)+1) } r.MigrateState = func( v int, s *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) { s.Attributes["newfoo"] = s.Attributes["oldfoo"] return s, nil } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "oldfoo": "12", }, } actual, err := r.Refresh(s, nil) if err != nil { t.Fatalf("err: %s", err) } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "newfoo": "13", }, Meta: map[string]interface{}{ "schema_version": "1", }, } if !reflect.DeepEqual(actual, expected) { t.Fatalf("bad:\n\nexpected: %#v\ngot: %#v", expected, actual) } } func TestResourceRefresh_migrateStateErr(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.Read = func(d *ResourceData, m interface{}) error { t.Fatal("Read should never be called!") return nil } r.MigrateState = func( v int, s *terraform.InstanceState, meta interface{}) (*terraform.InstanceState, error) { return s, fmt.Errorf("triggering an error") } s := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "oldfoo": "12", }, } _, err := r.Refresh(s, nil) if err == nil { t.Fatal("expected error, but got none!") } } func TestResourceData(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } state := &terraform.InstanceState{ ID: "foo", Attributes: map[string]string{ "id": "foo", "foo": "42", }, } data := r.Data(state) if data.Id() != "foo" { t.Fatalf("err: %s", data.Id()) } if v := data.Get("foo"); v != 42 { t.Fatalf("bad: %#v", v) } // Set expectations state.Meta = map[string]interface{}{ "schema_version": "2", } result := data.State() if !reflect.DeepEqual(result, state) { t.Fatalf("bad: %#v", result) } } func TestResourceData_blank(t *testing.T) { r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, } data := r.Data(nil) if data.Id() != "" { t.Fatalf("err: %s", data.Id()) } if v := data.Get("foo"); v != 0 { t.Fatalf("bad: %#v", v) } } func TestResourceData_timeouts(t *testing.T) { one := 1 * time.Second two := 2 * time.Second three := 3 * time.Second four := 4 * time.Second five := 5 * time.Second timeouts := &ResourceTimeout{ Create: &one, Read: &two, Update: &three, Delete: &four, Default: &five, } r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "foo": &Schema{ Type: TypeInt, Optional: true, }, }, Timeouts: timeouts, } data := r.Data(nil) if data.Id() != "" { t.Fatalf("err: %s", data.Id()) } if !reflect.DeepEqual(timeouts, data.timeouts) { t.Fatalf("incorrect ResourceData timeouts: %#v\n", *data.timeouts) } } func TestResource_UpgradeState(t *testing.T) { // While this really only calls itself and therefore doesn't test any of // the Resource code directly, it still serves as an example of registering // a StateUpgrader. r := &Resource{ SchemaVersion: 2, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } r.StateUpgraders = []StateUpgrader{ { Version: 1, Type: cty.Object(map[string]cty.Type{ "id": cty.String, "oldfoo": cty.Number, }), Upgrade: func(m map[string]interface{}, meta interface{}) (map[string]interface{}, error) { oldfoo, ok := m["oldfoo"].(float64) if !ok { t.Fatalf("expected 1.2, got %#v", m["oldfoo"]) } m["newfoo"] = int(oldfoo * 10) delete(m, "oldfoo") return m, nil }, }, } oldStateAttrs := map[string]string{ "id": "bar", "oldfoo": "1.2", } // convert the legacy flatmap state to the json equivalent ty := r.StateUpgraders[0].Type val, err := hcl2shim.HCL2ValueFromFlatmap(oldStateAttrs, ty) if err != nil { t.Fatal(err) } js, err := ctyjson.Marshal(val, ty) if err != nil { t.Fatal(err) } // unmarshal the state using the json default types var m map[string]interface{} if err := json.Unmarshal(js, &m); err != nil { t.Fatal(err) } actual, err := r.StateUpgraders[0].Upgrade(m, nil) if err != nil { t.Fatalf("err: %s", err) } expected := map[string]interface{}{ "id": "bar", "newfoo": 12, } if !reflect.DeepEqual(expected, actual) { t.Fatalf("expected: %#v\ngot: %#v\n", expected, actual) } } func TestResource_ValidateUpgradeState(t *testing.T) { r := &Resource{ SchemaVersion: 3, Schema: map[string]*Schema{ "newfoo": &Schema{ Type: TypeInt, Optional: true, }, }, } if err := r.InternalValidate(nil, true); err != nil { t.Fatal(err) } r.StateUpgraders = append(r.StateUpgraders, StateUpgrader{ Version: 2, Type: cty.Object(map[string]cty.Type{ "id": cty.String, }), Upgrade: func(m map[string]interface{}, _ interface{}) (map[string]interface{}, error) { return m, nil }, }) if err := r.InternalValidate(nil, true); err != nil { t.Fatal(err) } // check for missing type r.StateUpgraders[0].Type = cty.Type{} if err := r.InternalValidate(nil, true); err == nil { t.Fatal("StateUpgrader must have type") } r.StateUpgraders[0].Type = cty.Object(map[string]cty.Type{ "id": cty.String, }) // check for missing Upgrade func r.StateUpgraders[0].Upgrade = nil if err := r.InternalValidate(nil, true); err == nil { t.Fatal("StateUpgrader must have an Upgrade func") } r.StateUpgraders[0].Upgrade = func(m map[string]interface{}, _ interface{}) (map[string]interface{}, error) { return m, nil } // check for skipped version r.StateUpgraders[0].Version = 0 r.StateUpgraders = append(r.StateUpgraders, StateUpgrader{ Version: 2, Type: cty.Object(map[string]cty.Type{ "id": cty.String, }), Upgrade: func(m map[string]interface{}, _ interface{}) (map[string]interface{}, error) { return m, nil }, }) if err := r.InternalValidate(nil, true); err == nil { t.Fatal("StateUpgraders cannot skip versions") } // add the missing version, but fail because it's still out of order r.StateUpgraders = append(r.StateUpgraders, StateUpgrader{ Version: 1, Type: cty.Object(map[string]cty.Type{ "id": cty.String, }), Upgrade: func(m map[string]interface{}, _ interface{}) (map[string]interface{}, error) { return m, nil }, }) if err := r.InternalValidate(nil, true); err == nil { t.Fatal("upgraders must be defined in order") } r.StateUpgraders[1], r.StateUpgraders[2] = r.StateUpgraders[2], r.StateUpgraders[1] if err := r.InternalValidate(nil, true); err != nil { t.Fatal(err) } // can't add an upgrader for a schema >= the current version r.StateUpgraders = append(r.StateUpgraders, StateUpgrader{ Version: 3, Type: cty.Object(map[string]cty.Type{ "id": cty.String, }), Upgrade: func(m map[string]interface{}, _ interface{}) (map[string]interface{}, error) { return m, nil }, }) if err := r.InternalValidate(nil, true); err == nil { t.Fatal("StateUpgraders cannot have a version >= current SchemaVersion") } } // The legacy provider will need to be able to handle both types of schema // transformations, which has been retrofitted into the Refresh method. func TestResource_migrateAndUpgrade(t *testing.T) { r := &Resource{ SchemaVersion: 4, Schema: map[string]*Schema{ "four": { Type: TypeInt, Required: true, }, }, // this MigrateState will take the state to version 2 MigrateState: func(v int, is *terraform.InstanceState, _ interface{}) (*terraform.InstanceState, error) { switch v { case 0: _, ok := is.Attributes["zero"] if !ok { return nil, fmt.Errorf("zero not found in %#v", is.Attributes) } is.Attributes["one"] = "1" delete(is.Attributes, "zero") fallthrough case 1: _, ok := is.Attributes["one"] if !ok { return nil, fmt.Errorf("one not found in %#v", is.Attributes) } is.Attributes["two"] = "2" delete(is.Attributes, "one") default: return nil, fmt.Errorf("invalid schema version %d", v) } return is, nil }, } r.Read = func(d *ResourceData, m interface{}) error { return d.Set("four", 4) } r.StateUpgraders = []StateUpgrader{ { Version: 2, Type: cty.Object(map[string]cty.Type{ "id": cty.String, "two": cty.Number, }), Upgrade: func(m map[string]interface{}, meta interface{}) (map[string]interface{}, error) { _, ok := m["two"].(float64) if !ok { return nil, fmt.Errorf("two not found in %#v", m) } m["three"] = float64(3) delete(m, "two") return m, nil }, }, { Version: 3, Type: cty.Object(map[string]cty.Type{ "id": cty.String, "three": cty.Number, }), Upgrade: func(m map[string]interface{}, meta interface{}) (map[string]interface{}, error) { _, ok := m["three"].(float64) if !ok { return nil, fmt.Errorf("three not found in %#v", m) } m["four"] = float64(4) delete(m, "three") return m, nil }, }, } testStates := []*terraform.InstanceState{ { ID: "bar", Attributes: map[string]string{ "id": "bar", "zero": "0", }, Meta: map[string]interface{}{ "schema_version": "0", }, }, { ID: "bar", Attributes: map[string]string{ "id": "bar", "one": "1", }, Meta: map[string]interface{}{ "schema_version": "1", }, }, { ID: "bar", Attributes: map[string]string{ "id": "bar", "two": "2", }, Meta: map[string]interface{}{ "schema_version": "2", }, }, { ID: "bar", Attributes: map[string]string{ "id": "bar", "three": "3", }, Meta: map[string]interface{}{ "schema_version": "3", }, }, { ID: "bar", Attributes: map[string]string{ "id": "bar", "four": "4", }, Meta: map[string]interface{}{ "schema_version": "4", }, }, } for i, s := range testStates { t.Run(fmt.Sprintf("%d", i), func(t *testing.T) { newState, err := r.Refresh(s, nil) if err != nil { t.Fatal(err) } expected := &terraform.InstanceState{ ID: "bar", Attributes: map[string]string{ "id": "bar", "four": "4", }, Meta: map[string]interface{}{ "schema_version": "4", }, } if !cmp.Equal(expected, newState, equateEmpty) { t.Fatal(cmp.Diff(expected, newState, equateEmpty)) } }) } }