| // Copyright (c) The OpenTofu Authors | |
| // SPDX-License-Identifier: MPL-2.0 | |
| // Copyright (c) 2023 HashiCorp, Inc. | |
| // SPDX-License-Identifier: MPL-2.0 | |
| package command | |
| import ( | |
| "fmt" | |
| "os" | |
| "path/filepath" | |
| "strings" | |
| "testing" | |
| "github.com/google/go-cmp/cmp" | |
| "github.com/opentofu/opentofu/internal/command/system" | |
| "github.com/opentofu/opentofu/internal/command/workdir" | |
| "github.com/opentofu/opentofu/internal/tfdiags" | |
| "github.com/opentofu/opentofu/internal/addrs" | |
| "github.com/opentofu/opentofu/internal/states" | |
| ) | |
| func TestStateMv(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| Dependencies: []addrs.ConfigResource{addrs.MustParseResourceAddr("test_instance.foo")}, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("return code: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvOutput) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvOutputOriginal) | |
| view, done = testView(t) | |
| meta.View = view | |
| // Change the single instance to a counted instance | |
| args = []string{ | |
| "-state", statePath, | |
| "test_instance.bar", | |
| "test_instance.bar[0]", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output = done(t) | |
| if code != 0 { | |
| t.Fatalf("return code: %d\n\n%s", code, output.All()) | |
| } | |
| // extract the resource and verify the mode | |
| s := testStateRead(t, statePath) | |
| addr, diags := addrs.ParseAbsResourceStr("test_instance.bar") | |
| if diags.HasErrors() { | |
| t.Fatal(diags.Err()) | |
| } | |
| for key := range s.Resource(addr).Instances { | |
| if _, ok := key.(addrs.IntKey); !ok { | |
| t.Fatalf("expected each mode List, got key %q", key) | |
| } | |
| } | |
| view, done = testView(t) | |
| meta.View = view | |
| // change from list to map | |
| args = []string{ | |
| "-state", statePath, | |
| "test_instance.bar[0]", | |
| "test_instance.bar[\"baz\"]", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output = done(t) | |
| if code != 0 { | |
| t.Fatalf("return code: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // extract the resource and verify the mode | |
| s = testStateRead(t, statePath) | |
| addr, diags = addrs.ParseAbsResourceStr("test_instance.bar") | |
| if diags.HasErrors() { | |
| t.Fatal(diags.Err()) | |
| } | |
| for key := range s.Resource(addr).Instances { | |
| if _, ok := key.(addrs.StringKey); !ok { | |
| t.Fatalf("expected each mode map, found key %q", key) | |
| } | |
| } | |
| view, done = testView(t) | |
| meta.View = view | |
| // change from from map back to single | |
| args = []string{ | |
| "-state", statePath, | |
| "test_instance.bar[\"baz\"]", | |
| "test_instance.bar", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output = done(t) | |
| if code != 0 { | |
| t.Fatalf("return code: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // extract the resource and verify the mode | |
| s = testStateRead(t, statePath) | |
| addr, diags = addrs.ParseAbsResourceStr("test_instance.bar") | |
| if diags.HasErrors() { | |
| t.Fatal(diags.Err()) | |
| } | |
| for key := range s.Resource(addr).Instances { | |
| if key != addrs.NoKey { | |
| t.Fatalf("expected no each mode, found key %q", key) | |
| } | |
| } | |
| } | |
| func TestStateMv_backupAndBackupOutOptionsWithNonLocalBackend(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| t.Run("backup option specified", func(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend-http"), td) | |
| t.Chdir(td) | |
| backupPath := filepath.Join(td, "backup") | |
| // Set up our backend state using mock state | |
| dataState, srv := testBackendState(t, state, 200) | |
| defer srv.Close() | |
| testStateFileRemote(t, dataState) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-backup", backupPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.Stdout()) | |
| } | |
| gotErr := output.Stderr() | |
| wantErr := ` | |
| Error: Invalid command line options: -backup | |
| Command line options -backup and -backup-out are legacy options that operate | |
| on a local state file only. You must specify a local state file with the | |
| -state option or switch to the local backend. | |
| ` | |
| if gotErr != wantErr { | |
| t.Fatalf("expected error\ngot:%s\n\nwant:%s", gotErr, wantErr) | |
| } | |
| }) | |
| t.Run("backup-out option specified", func(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend-http"), td) | |
| t.Chdir(td) | |
| backupOutPath := filepath.Join(td, "backup-out") | |
| // Set up our backend state using mock state | |
| dataState, srv := testBackendState(t, state, 200) | |
| defer srv.Close() | |
| testStateFileRemote(t, dataState) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-backup-out", backupOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.Stdout()) | |
| } | |
| gotErr := output.Stderr() | |
| wantErr := ` | |
| Error: Invalid command line options: -backup-out | |
| Command line options -backup and -backup-out are legacy options that operate | |
| on a local state file only. You must specify a local state file with the | |
| -state option or switch to the local backend. | |
| ` | |
| if gotErr != wantErr { | |
| t.Fatalf("expected error\ngot:%s\n\nwant:%s", gotErr, wantErr) | |
| } | |
| }) | |
| t.Run("backup and backup-out options specified", func(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend-http"), td) | |
| t.Chdir(td) | |
| backupPath := filepath.Join(td, "backup") | |
| backupOutPath := filepath.Join(td, "backup-out") | |
| // Set up our backend state using mock state | |
| dataState, srv := testBackendState(t, state, 200) | |
| defer srv.Close() | |
| testStateFileRemote(t, dataState) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-backup", backupPath, | |
| "-backup-out", backupOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.Stdout()) | |
| } | |
| gotErr := output.Stderr() | |
| wantErr := ` | |
| Error: Invalid command line options: -backup, -backup-out | |
| Command line options -backup and -backup-out are legacy options that operate | |
| on a local state file only. You must specify a local state file with the | |
| -state option or switch to the local backend. | |
| ` | |
| if gotErr != wantErr { | |
| t.Fatalf("expected error\ngot:%s\n\nwant:%s", gotErr, wantErr) | |
| } | |
| }) | |
| t.Run("backup option specified with state option", func(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend-http"), td) | |
| t.Chdir(td) | |
| statePath := testStateFile(t, state) | |
| backupPath := filepath.Join(td, "backup") | |
| // Set up our backend state using mock state | |
| dataState, srv := testBackendState(t, state, 200) | |
| defer srv.Close() | |
| testStateFileRemote(t, dataState) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-backup", backupPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvBackupAndBackupOutOptionsWithNonLocalBackendOutput) | |
| }) | |
| t.Run("backup-out option specified with state option", func(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend-http"), td) | |
| t.Chdir(td) | |
| statePath := testStateFile(t, state) | |
| backupOutPath := filepath.Join(td, "backup-out") | |
| // Set up our backend state using mock state | |
| dataState, srv := testBackendState(t, state, 200) | |
| defer srv.Close() | |
| testStateFileRemote(t, dataState) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-backup-out", backupOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvBackupAndBackupOutOptionsWithNonLocalBackendOutput) | |
| }) | |
| } | |
| func TestStateMv_resourceToInstance(t *testing.T) { | |
| // A single resource (no count defined) | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| Dependencies: []addrs.ConfigResource{addrs.MustParseResourceAddr("test_instance.foo")}, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceProvider( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Absolute(addrs.RootModuleInstance), | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar[0]", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, ` | |
| test_instance.bar.0: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| `) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvOutputOriginal) | |
| } | |
| func TestStateMv_resourceToInstanceErr(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceProvider( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Absolute(addrs.RootModuleInstance), | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar[0]", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.All()) | |
| } | |
| expectedErr := ` | |
| Error: Invalid target address | |
| Cannot move test_instance.foo to test_instance.bar[0]: the source is a whole | |
| resource (not a resource instance) so the target must also be a whole | |
| resource. | |
| ` | |
| errOutput := output.Stderr() | |
| if errOutput != expectedErr { | |
| t.Errorf("wrong output\n%s", cmp.Diff(errOutput, expectedErr)) | |
| } | |
| } | |
| func TestStateMv_resourceToInstanceErrInAutomation(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceProvider( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Absolute(addrs.RootModuleInstance), | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| SystemCfg: system.Config{RunningInAutomation: true}, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar[0]", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.Stdout()) | |
| } | |
| expectedErr := ` | |
| Error: Invalid target address | |
| Cannot move test_instance.foo to test_instance.bar[0]: the source is a whole | |
| resource (not a resource instance) so the target must also be a whole | |
| resource. | |
| ` | |
| errOutput := output.Stderr() | |
| if errOutput != expectedErr { | |
| t.Errorf("Unexpected diff.\ngot:\n%s\nwant:\n%s\n", errOutput, expectedErr) | |
| t.Errorf("%s", cmp.Diff(errOutput, expectedErr)) | |
| } | |
| } | |
| func TestStateMv_instanceToResource(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "test_instance.foo[0]", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| `) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], ` | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.0: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| `) | |
| } | |
| func TestStateMv_instanceToNewResource(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "test_instance.foo[0]", | |
| "test_instance.bar[\"new\"]", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, ` | |
| test_instance.bar["new"]: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| `) | |
| view, done = testView(t) | |
| meta.View = view | |
| // now move the instance to a new resource in a new module | |
| args = []string{ | |
| "-state", statePath, | |
| "test_instance.bar[\"new\"]", | |
| "module.test.test_instance.baz[\"new\"]", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output = done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, ` | |
| <no state> | |
| module.test: | |
| test_instance.baz["new"]: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| `) | |
| } | |
| func TestStateMv_differentResourceTypes(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-no-color", | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_network.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code == 0 { | |
| t.Fatalf("expected error output, got:\n%s", output.Stdout()) | |
| } | |
| gotErr := output.Stderr() | |
| wantErr := ` | |
| Error: Invalid state move request | |
| Cannot move test_instance.foo to test_network.bar: resource types don't | |
| match. | |
| ` | |
| if gotErr != wantErr { | |
| t.Fatalf("expected initialization error\ngot:\n%s\n\nwant:%s", gotErr, wantErr) | |
| } | |
| } | |
| // don't modify backend state is we supply a -state flag | |
| func TestStateMv_explicitWithBackend(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("init-backend"), td) | |
| t.Chdir(td) | |
| backupPath := filepath.Join(td, "backup") | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| // init our backend | |
| initView, initDone := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(testProvider()), | |
| View: initView, | |
| } | |
| args := []string{} | |
| code := RunCommander(t, InitCommander(), meta, args) | |
| initOutput := initDone(t) | |
| if code != 0 { | |
| t.Fatalf("bad: \n%s", initOutput.All()) | |
| } | |
| // only modify statePath | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta = Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args = []string{ | |
| "-backup", backupPath, | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.All()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvOutput) | |
| } | |
| func TestStateMv_backupExplicit(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| Dependencies: []addrs.ConfigResource{addrs.MustParseResourceAddr("test_instance.foo")}, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| backupPath := statePath + ".backup.test" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-backup", backupPath, | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvOutput) | |
| // Test backup | |
| testStateOutput(t, backupPath, testStateMvOutputOriginal) | |
| } | |
| func TestStateMv_stateOutNew(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| stateOutPath := statePath + ".out" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath, testStateMvOutput_stateOut) | |
| testStateOutput(t, statePath, testStateMvOutput_stateOutSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvOutput_stateOutOriginal) | |
| } | |
| func TestStateMv_stateOutExisting(t *testing.T) { | |
| stateSrc := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, stateSrc) | |
| stateDst := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "qux", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| stateOutPath := testStateFile(t, stateDst) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath, testStateMvExisting_stateDst) | |
| testStateOutput(t, statePath, testStateMvExisting_stateSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvExisting_stateSrcOriginal) | |
| backups = testStateBackups(t, filepath.Dir(stateOutPath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvExisting_stateDstOriginal) | |
| } | |
| func TestStateMv_noState(t *testing.T) { | |
| testCwdTemp(t) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{"from", "to"} | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 1 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| } | |
| func TestStateMv_stateOutNew_count(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(1)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| stateOutPath := statePath + ".out" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath, testStateMvCount_stateOut) | |
| testStateOutput(t, statePath, testStateMvCount_stateOutSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvCount_stateOutOriginal) | |
| } | |
| // Modules with more than 10 resources were sorted lexically, causing the | |
| // indexes in the new location to change. | |
| func TestStateMv_stateOutNew_largeCount(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| // test_instance.foo has 11 instances, all the same except for their ids | |
| for i := range 11 { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(i)).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(fmt.Sprintf(`{"id":"foo%d","foo":"value","bar":"value"}`, i)), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| } | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| stateOutPath := statePath + ".out" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath, testStateMvLargeCount_stateOut) | |
| testStateOutput(t, statePath, testStateMvLargeCount_stateOutSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvLargeCount_stateOutOriginal) | |
| } | |
| func TestStateMv_stateOutNew_nestedModule(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance.Child("foo", addrs.NoKey).Child("child1", addrs.NoKey)), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance.Child("foo", addrs.NoKey).Child("child2", addrs.NoKey)), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| stateOutPath := statePath + ".out" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath, | |
| "module.foo", | |
| "module.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath, testStateMvNestedModule_stateOut) | |
| testStateOutput(t, statePath, testStateMvNestedModule_stateOutSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvNestedModule_stateOutOriginal) | |
| } | |
| func TestStateMv_toNewModule(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "bar", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| stateOutPath1 := statePath + ".out1" | |
| stateOutPath2 := statePath + ".out2" | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "-state-out", stateOutPath1, | |
| "test_instance.bar", | |
| "module.bar.test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, stateOutPath1, testStateMvNewModule_stateOut) | |
| testStateOutput(t, statePath, testStateMvNestedModule_stateOutSrc) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvNewModule_stateOutOriginal) | |
| view, done = testView(t) | |
| meta.View = view | |
| // now verify we can move the module itself | |
| args = []string{ | |
| "-state", stateOutPath1, | |
| "-state-out", stateOutPath2, | |
| "module.bar", | |
| "module.foo", | |
| } | |
| code = RunCommander(t, StateMvCommander(), meta, args) | |
| output = done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| testStateOutput(t, stateOutPath2, testStateMvModuleNewModule_stateOut) | |
| } | |
| func TestStateMv_withinBackend(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("backend-unchanged"), td) | |
| t.Chdir(td) | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| Dependencies: []addrs.ConfigResource{addrs.MustParseResourceAddr("test_instance.foo")}, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| // the local backend state file is "foo" | |
| statePath := "local-state.tfstate" | |
| backupPath := "local-state.backup" | |
| f, err := os.Create(statePath) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| defer f.Close() | |
| if err := writeStateForTesting(state, f); err != nil { | |
| t.Fatal(err) | |
| } | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-backup", backupPath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| testStateOutput(t, statePath, testStateMvOutput) | |
| testStateOutput(t, backupPath, testStateMvOutputOriginal) | |
| } | |
| func TestStateMv_fromBackendToLocal(t *testing.T) { | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("backend-unchanged"), td) | |
| t.Chdir(td) | |
| state := states.NewState() | |
| state.Module(addrs.RootModuleInstance).SetResourceInstanceCurrent( | |
| addrs.MustParseResourceAddr("test_instance.foo").Resource.Instance(addrs.NoKey), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| state.Module(addrs.RootModuleInstance).SetResourceInstanceCurrent( | |
| addrs.MustParseResourceAddr("test_instance.baz").Resource.Instance(addrs.NoKey), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| // the local backend state file is "foo" | |
| statePath := "local-state.tfstate" | |
| // real "local" state file | |
| statePathOut := "real-local.tfstate" | |
| f, err := os.Create(statePath) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| defer f.Close() | |
| if err := writeStateForTesting(state, f); err != nil { | |
| t.Fatal(err) | |
| } | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state-out", statePathOut, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| testStateOutput(t, statePathOut, testStateMvCount_stateOutSrc) | |
| // the backend state should be left with only baz | |
| testStateOutput(t, statePath, testStateMvOriginal_backend) | |
| } | |
| // This test covers moving the only resource in a module to a new address in | |
| // that module, which triggers the maybePruneModule functionality. This caused | |
| // a panic report: https://github.com/hashicorp/terraform/issues/25520 | |
| func TestStateMv_onlyResourceInModule(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.IntKey(0)).Absolute(addrs.RootModuleInstance.Child("foo", addrs.NoKey)), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| testStateOutput(t, statePath, testStateMvOnlyResourceInModule_original) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "module.foo.test_instance.foo", | |
| "module.foo.test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 0 { | |
| t.Fatalf("bad: %d\n\n%s", code, output.Stderr()) | |
| } | |
| // Test it is correct | |
| testStateOutput(t, statePath, testStateMvOnlyResourceInModule_output) | |
| // Test we have backups | |
| backups := testStateBackups(t, filepath.Dir(statePath)) | |
| if len(backups) != 1 { | |
| t.Fatalf("bad: %#v", backups) | |
| } | |
| testStateOutput(t, backups[0], testStateMvOnlyResourceInModule_original) | |
| } | |
| func TestStateMvInvalidSourceAddress(t *testing.T) { | |
| state := states.BuildState(func(s *states.SyncState) {}) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "foo.bar1", | |
| "foo.bar2", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 1 { | |
| t.Fatalf("expected error code 1, got:\n%d\n%s", code, output.All()) | |
| } | |
| } | |
| func TestStateMv_checkRequiredVersion(t *testing.T) { | |
| // Create a temporary working directory that is empty | |
| td := t.TempDir() | |
| testCopyDir(t, testFixturePath("command-check-required-version"), td) | |
| t.Chdir(td) | |
| state := states.BuildState(func(s *states.SyncState) { | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "foo", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"bar","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| s.SetResourceInstanceCurrent( | |
| addrs.Resource{ | |
| Mode: addrs.ManagedResourceMode, | |
| Type: "test_instance", | |
| Name: "baz", | |
| }.Instance(addrs.NoKey).Absolute(addrs.RootModuleInstance), | |
| &states.ResourceInstanceObjectSrc{ | |
| AttrsJSON: []byte(`{"id":"foo","foo":"value","bar":"value"}`), | |
| Status: states.ObjectReady, | |
| Dependencies: []addrs.ConfigResource{addrs.MustParseResourceAddr("test_instance.foo")}, | |
| }, | |
| addrs.AbsProviderConfig{ | |
| Provider: addrs.NewDefaultProvider("test"), | |
| Module: addrs.RootModule, | |
| }, | |
| addrs.NoKey, | |
| ) | |
| }) | |
| statePath := testStateFile(t, state) | |
| p := testProvider() | |
| view, done := testView(t) | |
| meta := Meta{ | |
| WorkingDir: workdir.NewDir("."), | |
| testingOverrides: metaOverridesForProvider(p), | |
| View: view, | |
| } | |
| args := []string{ | |
| "-state", statePath, | |
| "test_instance.foo", | |
| "test_instance.bar", | |
| } | |
| code := RunCommander(t, StateMvCommander(), meta, args) | |
| output := done(t) | |
| if code != 1 { | |
| t.Fatalf("got exit status %d; want 1\nstderr:\n%s\n\nstdout:\n%s", code, output.Stderr(), output.Stdout()) | |
| } | |
| // State is unchanged | |
| testStateOutput(t, statePath, testStateMvOutputOriginal) | |
| // Required version diags are correct | |
| errStr := output.Stderr() | |
| if !strings.Contains(errStr, `required_version = "~> 0.9.0"`) { | |
| t.Fatalf("output should point to unmet version constraint, but is:\n\n%s", errStr) | |
| } | |
| if strings.Contains(errStr, `required_version = ">= 0.13.0"`) { | |
| t.Fatalf("output should not point to met version constraint, but is:\n\n%s", errStr) | |
| } | |
| } | |
| func TestValidateResourceMove(t *testing.T) { | |
| var ( | |
| c = &StateMvCommand{} | |
| managedRes = addrs.AbsResource{Resource: addrs.Resource{Mode: addrs.ManagedResourceMode, Type: "test_type", Name: "test_name"}} | |
| dataRes = addrs.AbsResource{Resource: addrs.Resource{Mode: addrs.DataResourceMode, Type: "test_type", Name: "test_name"}} | |
| ephemeralRes = addrs.AbsResource{Resource: addrs.Resource{Mode: addrs.EphemeralResourceMode, Type: "test_type", Name: "test_name"}} | |
| ) | |
| tests := map[string]struct { | |
| src, target addrs.AbsResource | |
| wantDiags tfdiags.Diagnostics | |
| }{ | |
| "resource to resource": { | |
| managedRes, | |
| managedRes, | |
| tfdiags.Diagnostics{}, | |
| }, | |
| "data to data": { | |
| dataRes, | |
| dataRes, | |
| tfdiags.Diagnostics{}, | |
| }, | |
| "ephemeral to ephemeral": { | |
| ephemeralRes, | |
| ephemeralRes, | |
| tfdiags.Diagnostics{tfdiags.Sourceless( | |
| tfdiags.Error, | |
| "Invalid state move request", | |
| "Ephemeral resources cannot be used as sources or targets for the move action. Just update your configuration accordingly.", | |
| )}, | |
| }, | |
| "resource to data": { | |
| managedRes, | |
| dataRes, | |
| tfdiags.Diagnostics{tfdiags.Sourceless( | |
| tfdiags.Error, | |
| "Invalid state move request", | |
| fmt.Sprintf("Cannot move %s to %s: a managed resource can be moved only to another managed resource address.", managedRes, dataRes), | |
| )}, | |
| }, | |
| "resource to ephemeral": { | |
| managedRes, | |
| ephemeralRes, | |
| tfdiags.Diagnostics{tfdiags.Sourceless( | |
| tfdiags.Error, | |
| "Invalid state move request", | |
| "Ephemeral resources cannot be used as sources or targets for the move action. Just update your configuration accordingly.", | |
| )}, | |
| }, | |
| "data to resource": { | |
| dataRes, | |
| managedRes, | |
| tfdiags.Diagnostics{tfdiags.Sourceless( | |
| tfdiags.Error, | |
| "Invalid state move request", | |
| fmt.Sprintf("Cannot move %s to %s: a data resource can be moved only to another data resource address.", dataRes, managedRes), | |
| )}, | |
| }, | |
| "data to ephemeral": { | |
| dataRes, | |
| ephemeralRes, | |
| tfdiags.Diagnostics{tfdiags.Sourceless( | |
| tfdiags.Error, | |
| "Invalid state move request", | |
| "Ephemeral resources cannot be used as sources or targets for the move action. Just update your configuration accordingly.", | |
| )}, | |
| }, | |
| } | |
| for name, tt := range tests { | |
| t.Run(name, func(t *testing.T) { | |
| diags := c.validateResourceMove(tt.src, tt.target) | |
| if got, want := len(diags), len(tt.wantDiags); got != want { | |
| t.Fatalf("expected to have exactly %d diagnostic(s). got: %d", want, got) | |
| } | |
| for i, wantDiag := range tt.wantDiags { | |
| sameDiagnostic(t, diags[i], wantDiag) | |
| } | |
| }) | |
| } | |
| } | |
| func sameDiagnostic(t *testing.T, gotD, wantD tfdiags.Diagnostic) { | |
| if got, want := gotD.Severity(), wantD.Severity(); got != want { | |
| t.Errorf("wrong severity. got %q; want %q", got, want) | |
| } | |
| if got, want := gotD.Description().Address, wantD.Description().Address; got != want { | |
| t.Errorf("wrong description. got %q; want %q", got, want) | |
| } | |
| if got, want := gotD.Description().Detail, wantD.Description().Detail; got != want { | |
| t.Errorf("wrong detail. got %q; want %q", got, want) | |
| } | |
| if got, want := gotD.Description().Summary, wantD.Description().Summary; got != want { | |
| t.Errorf("wrong summary. got %q; want %q", got, want) | |
| } | |
| if got, want := gotD.ExtraInfo(), wantD.ExtraInfo(); got != want { | |
| t.Errorf("wrong extra info. got %q; want %q", got, want) | |
| } | |
| } | |
| const testStateMvOutputOriginal = ` | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| Dependencies: | |
| test_instance.foo | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvOutput = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvBackupAndBackupOutOptionsWithNonLocalBackendOutput = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvCount_stateOut = ` | |
| test_instance.bar.0: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.1: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvCount_stateOutSrc = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvCount_stateOutOriginal = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.0: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.1: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvLargeCount_stateOut = ` | |
| test_instance.bar.0: | |
| ID = foo0 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.1: | |
| ID = foo1 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.2: | |
| ID = foo2 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.3: | |
| ID = foo3 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.4: | |
| ID = foo4 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.5: | |
| ID = foo5 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.6: | |
| ID = foo6 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.7: | |
| ID = foo7 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.8: | |
| ID = foo8 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.9: | |
| ID = foo9 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.bar.10: | |
| ID = foo10 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvLargeCount_stateOutSrc = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvLargeCount_stateOutOriginal = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.0: | |
| ID = foo0 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.1: | |
| ID = foo1 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.2: | |
| ID = foo2 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.3: | |
| ID = foo3 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.4: | |
| ID = foo4 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.5: | |
| ID = foo5 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.6: | |
| ID = foo6 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.7: | |
| ID = foo7 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.8: | |
| ID = foo8 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.9: | |
| ID = foo9 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.foo.10: | |
| ID = foo10 | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvNestedModule_stateOut = ` | |
| <no state> | |
| module.bar.child1: | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| module.bar.child2: | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvNewModule_stateOut = ` | |
| <no state> | |
| module.bar: | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvModuleNewModule_stateOut = ` | |
| <no state> | |
| module.foo: | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvNewModule_stateOutOriginal = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvNestedModule_stateOutSrc = ` | |
| <no state> | |
| ` | |
| const testStateMvNestedModule_stateOutOriginal = ` | |
| <no state> | |
| module.foo.child1: | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| module.foo.child2: | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvOutput_stateOut = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvOutput_stateOutSrc = ` | |
| <no state> | |
| ` | |
| const testStateMvOutput_stateOutOriginal = ` | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvExisting_stateSrc = ` | |
| <no state> | |
| ` | |
| const testStateMvExisting_stateDst = ` | |
| test_instance.bar: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| test_instance.qux: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| ` | |
| const testStateMvExisting_stateSrcOriginal = ` | |
| test_instance.foo: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvExisting_stateDstOriginal = ` | |
| test_instance.qux: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| ` | |
| const testStateMvOriginal_backend = ` | |
| test_instance.baz: | |
| ID = foo | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvOnlyResourceInModule_original = ` | |
| <no state> | |
| module.foo: | |
| test_instance.foo.0: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` | |
| const testStateMvOnlyResourceInModule_output = ` | |
| <no state> | |
| module.foo: | |
| test_instance.bar.0: | |
| ID = bar | |
| provider = provider["registry.opentofu.org/hashicorp/test"] | |
| bar = value | |
| foo = value | |
| ` |