github.com/peterbale/terraform@v0.9.0-beta2.0.20170315142748-5723acd55547/command/env_command_test.go (about) 1 package command 2 3 import ( 4 "io/ioutil" 5 "os" 6 "path/filepath" 7 "strings" 8 "testing" 9 10 "github.com/hashicorp/terraform/backend" 11 "github.com/hashicorp/terraform/backend/local" 12 "github.com/hashicorp/terraform/state" 13 "github.com/hashicorp/terraform/terraform" 14 "github.com/mitchellh/cli" 15 ) 16 17 func TestEnv_createAndChange(t *testing.T) { 18 // Create a temporary working directory that is empty 19 td := tempDir(t) 20 os.MkdirAll(td, 0755) 21 defer os.RemoveAll(td) 22 defer testChdir(t, td)() 23 24 newCmd := &EnvNewCommand{} 25 26 current := newCmd.Env() 27 if current != backend.DefaultStateName { 28 t.Fatal("current env should be 'default'") 29 } 30 31 args := []string{"test"} 32 ui := new(cli.MockUi) 33 newCmd.Meta = Meta{Ui: ui} 34 if code := newCmd.Run(args); code != 0 { 35 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter) 36 } 37 38 current = newCmd.Env() 39 if current != "test" { 40 t.Fatalf("current env should be 'test', got %q", current) 41 } 42 43 selCmd := &EnvSelectCommand{} 44 args = []string{backend.DefaultStateName} 45 ui = new(cli.MockUi) 46 selCmd.Meta = Meta{Ui: ui} 47 if code := selCmd.Run(args); code != 0 { 48 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter) 49 } 50 51 current = newCmd.Env() 52 if current != backend.DefaultStateName { 53 t.Fatal("current env should be 'default'") 54 } 55 56 } 57 58 // Create some environments and test the list output. 59 // This also ensures we switch to the correct env after each call 60 func TestEnv_createAndList(t *testing.T) { 61 // Create a temporary working directory that is empty 62 td := tempDir(t) 63 os.MkdirAll(td, 0755) 64 defer os.RemoveAll(td) 65 defer testChdir(t, td)() 66 67 // make sure a vars file doesn't interfere 68 err := ioutil.WriteFile( 69 DefaultVarsFilename, 70 []byte(`foo = "bar"`), 71 0644, 72 ) 73 if err != nil { 74 t.Fatal(err) 75 } 76 77 newCmd := &EnvNewCommand{} 78 79 envs := []string{"test_a", "test_b", "test_c"} 80 81 // create multiple envs 82 for _, env := range envs { 83 ui := new(cli.MockUi) 84 newCmd.Meta = Meta{Ui: ui} 85 if code := newCmd.Run([]string{env}); code != 0 { 86 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter) 87 } 88 } 89 90 listCmd := &EnvListCommand{} 91 ui := new(cli.MockUi) 92 listCmd.Meta = Meta{Ui: ui} 93 94 if code := listCmd.Run(nil); code != 0 { 95 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter) 96 } 97 98 actual := strings.TrimSpace(ui.OutputWriter.String()) 99 expected := "default\n test_a\n test_b\n* test_c" 100 101 if actual != expected { 102 t.Fatalf("\nexpcted: %q\nactual: %q", expected, actual) 103 } 104 } 105 106 func TestEnv_createWithState(t *testing.T) { 107 td := tempDir(t) 108 os.MkdirAll(td, 0755) 109 defer os.RemoveAll(td) 110 defer testChdir(t, td)() 111 112 // create a non-empty state 113 originalState := &terraform.State{ 114 Modules: []*terraform.ModuleState{ 115 &terraform.ModuleState{ 116 Path: []string{"root"}, 117 Resources: map[string]*terraform.ResourceState{ 118 "test_instance.foo": &terraform.ResourceState{ 119 Type: "test_instance", 120 Primary: &terraform.InstanceState{ 121 ID: "bar", 122 }, 123 }, 124 }, 125 }, 126 }, 127 } 128 129 err := (&state.LocalState{Path: "test.tfstate"}).WriteState(originalState) 130 if err != nil { 131 t.Fatal(err) 132 } 133 134 args := []string{"-state", "test.tfstate", "test"} 135 ui := new(cli.MockUi) 136 newCmd := &EnvNewCommand{ 137 Meta: Meta{Ui: ui}, 138 } 139 if code := newCmd.Run(args); code != 0 { 140 t.Fatalf("bad: %d\n\n%s", code, ui.ErrorWriter) 141 } 142 143 newPath := filepath.Join(local.DefaultEnvDir, "test", DefaultStateFilename) 144 envState := state.LocalState{Path: newPath} 145 err = envState.RefreshState() 146 if err != nil { 147 t.Fatal(err) 148 } 149 150 newState := envState.State() 151 if !originalState.Equal(newState) { 152 t.Fatalf("states not equal\norig: %s\nnew: %s", originalState, newState) 153 } 154 } 155 156 func TestEnv_delete(t *testing.T) { 157 td := tempDir(t) 158 os.MkdirAll(td, 0755) 159 defer os.RemoveAll(td) 160 defer testChdir(t, td)() 161 162 // create the env directories 163 if err := os.MkdirAll(filepath.Join(local.DefaultEnvDir, "test"), 0755); err != nil { 164 t.Fatal(err) 165 } 166 167 // create the environment file 168 if err := os.MkdirAll(DefaultDataDir, 0755); err != nil { 169 t.Fatal(err) 170 } 171 if err := ioutil.WriteFile(filepath.Join(DefaultDataDir, local.DefaultEnvFile), []byte("test"), 0644); err != nil { 172 t.Fatal(err) 173 } 174 175 ui := new(cli.MockUi) 176 delCmd := &EnvDeleteCommand{ 177 Meta: Meta{Ui: ui}, 178 } 179 180 current := delCmd.Env() 181 if current != "test" { 182 t.Fatal("wrong env:", current) 183 } 184 185 // we can't delete out current environment 186 args := []string{"test"} 187 if code := delCmd.Run(args); code == 0 { 188 t.Fatal("expected error deleting current env") 189 } 190 191 // change back to default 192 if err := delCmd.SetEnv(backend.DefaultStateName); err != nil { 193 t.Fatal(err) 194 } 195 196 // try the delete again 197 ui = new(cli.MockUi) 198 delCmd.Meta.Ui = ui 199 if code := delCmd.Run(args); code != 0 { 200 t.Fatalf("error deleting env: %s", ui.ErrorWriter) 201 } 202 203 current = delCmd.Env() 204 if current != backend.DefaultStateName { 205 t.Fatalf("wrong env: %q", current) 206 } 207 } 208 func TestEnv_deleteWithState(t *testing.T) { 209 td := tempDir(t) 210 os.MkdirAll(td, 0755) 211 defer os.RemoveAll(td) 212 defer testChdir(t, td)() 213 214 // create the env directories 215 if err := os.MkdirAll(filepath.Join(local.DefaultEnvDir, "test"), 0755); err != nil { 216 t.Fatal(err) 217 } 218 219 // create a non-empty state 220 originalState := &terraform.State{ 221 Modules: []*terraform.ModuleState{ 222 &terraform.ModuleState{ 223 Path: []string{"root"}, 224 Resources: map[string]*terraform.ResourceState{ 225 "test_instance.foo": &terraform.ResourceState{ 226 Type: "test_instance", 227 Primary: &terraform.InstanceState{ 228 ID: "bar", 229 }, 230 }, 231 }, 232 }, 233 }, 234 } 235 236 envStatePath := filepath.Join(local.DefaultEnvDir, "test", DefaultStateFilename) 237 err := (&state.LocalState{Path: envStatePath}).WriteState(originalState) 238 if err != nil { 239 t.Fatal(err) 240 } 241 242 ui := new(cli.MockUi) 243 delCmd := &EnvDeleteCommand{ 244 Meta: Meta{Ui: ui}, 245 } 246 args := []string{"test"} 247 if code := delCmd.Run(args); code == 0 { 248 t.Fatalf("expected failure without -force.\noutput: %s", ui.OutputWriter) 249 } 250 251 ui = new(cli.MockUi) 252 delCmd.Meta.Ui = ui 253 254 args = []string{"-force", "test"} 255 if code := delCmd.Run(args); code != 0 { 256 t.Fatalf("failure: %s", ui.ErrorWriter) 257 } 258 259 if _, err := os.Stat(filepath.Join(local.DefaultEnvDir, "test")); !os.IsNotExist(err) { 260 t.Fatal("env 'test' still exists!") 261 } 262 }