github.com/chalford/terraform@v0.3.7-0.20150113080010-a78c69a8c81f/command/meta_test.go (about) 1 package command 2 3 import ( 4 "io/ioutil" 5 "os" 6 "path/filepath" 7 "reflect" 8 "testing" 9 10 "github.com/hashicorp/terraform/remote" 11 "github.com/hashicorp/terraform/terraform" 12 ) 13 14 func TestMetaColorize(t *testing.T) { 15 var m *Meta 16 var args, args2 []string 17 18 // Test basic, color 19 m = new(Meta) 20 m.Color = true 21 args = []string{"foo", "bar"} 22 args2 = []string{"foo", "bar"} 23 args = m.process(args, false) 24 if !reflect.DeepEqual(args, args2) { 25 t.Fatalf("bad: %#v", args) 26 } 27 if m.Colorize().Disable { 28 t.Fatal("should not be disabled") 29 } 30 31 // Test basic, no change 32 m = new(Meta) 33 args = []string{"foo", "bar"} 34 args2 = []string{"foo", "bar"} 35 args = m.process(args, false) 36 if !reflect.DeepEqual(args, args2) { 37 t.Fatalf("bad: %#v", args) 38 } 39 if !m.Colorize().Disable { 40 t.Fatal("should be disabled") 41 } 42 43 // Test disable #1 44 m = new(Meta) 45 m.Color = true 46 args = []string{"foo", "-no-color", "bar"} 47 args2 = []string{"foo", "bar"} 48 args = m.process(args, false) 49 if !reflect.DeepEqual(args, args2) { 50 t.Fatalf("bad: %#v", args) 51 } 52 if !m.Colorize().Disable { 53 t.Fatal("should be disabled") 54 } 55 } 56 57 func TestMetaInputMode(t *testing.T) { 58 test = false 59 defer func() { test = true }() 60 61 m := new(Meta) 62 args := []string{} 63 64 fs := m.flagSet("foo") 65 if err := fs.Parse(args); err != nil { 66 t.Fatalf("err: %s", err) 67 } 68 69 if m.InputMode() != terraform.InputModeStd { 70 t.Fatalf("bad: %#v", m.InputMode()) 71 } 72 } 73 74 func TestMetaInputMode_disable(t *testing.T) { 75 test = false 76 defer func() { test = true }() 77 78 m := new(Meta) 79 args := []string{"-input=false"} 80 81 fs := m.flagSet("foo") 82 if err := fs.Parse(args); err != nil { 83 t.Fatalf("err: %s", err) 84 } 85 86 if m.InputMode() > 0 { 87 t.Fatalf("bad: %#v", m.InputMode()) 88 } 89 } 90 91 func TestMetaInputMode_defaultVars(t *testing.T) { 92 test = false 93 defer func() { test = true }() 94 95 // Create a temporary directory for our cwd 96 d := tempDir(t) 97 if err := os.MkdirAll(d, 0755); err != nil { 98 t.Fatalf("err: %s", err) 99 } 100 cwd, err := os.Getwd() 101 if err != nil { 102 t.Fatalf("err: %s", err) 103 } 104 if err := os.Chdir(d); err != nil { 105 t.Fatalf("err: %s", err) 106 } 107 defer os.Chdir(cwd) 108 109 // Create the default vars file 110 err = ioutil.WriteFile( 111 filepath.Join(d, DefaultVarsFilename), 112 []byte(""), 113 0644) 114 if err != nil { 115 t.Fatalf("err: %s", err) 116 } 117 118 m := new(Meta) 119 args := []string{} 120 args = m.process(args, true) 121 122 fs := m.flagSet("foo") 123 if err := fs.Parse(args); err != nil { 124 t.Fatalf("err: %s", err) 125 } 126 127 if m.InputMode()&terraform.InputModeVar != 0 { 128 t.Fatalf("bad: %#v", m.InputMode()) 129 } 130 } 131 132 func TestMetaInputMode_vars(t *testing.T) { 133 test = false 134 defer func() { test = true }() 135 136 m := new(Meta) 137 args := []string{"-var", "foo=bar"} 138 139 fs := m.flagSet("foo") 140 if err := fs.Parse(args); err != nil { 141 t.Fatalf("err: %s", err) 142 } 143 144 if m.InputMode()&terraform.InputModeVar != 0 { 145 t.Fatalf("bad: %#v", m.InputMode()) 146 } 147 } 148 149 func TestMeta_initStatePaths(t *testing.T) { 150 m := new(Meta) 151 m.initStatePaths() 152 153 if m.statePath != DefaultStateFilename { 154 t.Fatalf("bad: %#v", m) 155 } 156 if m.stateOutPath != DefaultStateFilename { 157 t.Fatalf("bad: %#v", m) 158 } 159 if m.backupPath != DefaultStateFilename+DefaultBackupExtention { 160 t.Fatalf("bad: %#v", m) 161 } 162 163 m = new(Meta) 164 m.statePath = "foo" 165 m.initStatePaths() 166 167 if m.stateOutPath != "foo" { 168 t.Fatalf("bad: %#v", m) 169 } 170 if m.backupPath != "foo"+DefaultBackupExtention { 171 t.Fatalf("bad: %#v", m) 172 } 173 174 m = new(Meta) 175 m.stateOutPath = "foo" 176 m.initStatePaths() 177 178 if m.statePath != DefaultStateFilename { 179 t.Fatalf("bad: %#v", m) 180 } 181 if m.backupPath != "foo"+DefaultBackupExtention { 182 t.Fatalf("bad: %#v", m) 183 } 184 } 185 186 func TestMeta_persistLocal(t *testing.T) { 187 tmp, cwd := testCwd(t) 188 defer testFixCwd(t, tmp, cwd) 189 190 m := new(Meta) 191 s := terraform.NewState() 192 if err := m.persistLocalState(s); err != nil { 193 t.Fatalf("err: %v", err) 194 } 195 196 exists, err := remote.ExistsFile(m.stateOutPath) 197 if err != nil { 198 t.Fatalf("err: %v", err) 199 } 200 if !exists { 201 t.Fatalf("state should exist") 202 } 203 204 // Write again, shoudl backup 205 if err := m.persistLocalState(s); err != nil { 206 t.Fatalf("err: %v", err) 207 } 208 209 exists, err = remote.ExistsFile(m.backupPath) 210 if err != nil { 211 t.Fatalf("err: %v", err) 212 } 213 if !exists { 214 t.Fatalf("backup should exist") 215 } 216 } 217 218 func TestMeta_persistRemote(t *testing.T) { 219 tmp, cwd := testCwd(t) 220 defer testFixCwd(t, tmp, cwd) 221 222 err := remote.EnsureDirectory() 223 if err != nil { 224 t.Fatalf("err: %v", err) 225 } 226 227 s := terraform.NewState() 228 conf, srv := testRemoteState(t, s, 200) 229 s.Remote = conf 230 defer srv.Close() 231 232 m := new(Meta) 233 if err := m.persistRemoteState(s); err != nil { 234 t.Fatalf("err: %v", err) 235 } 236 237 local, _, err := remote.ReadLocalState() 238 if err != nil { 239 t.Fatalf("err: %v", err) 240 } 241 if local == nil { 242 t.Fatalf("state should exist") 243 } 244 245 if err := m.persistRemoteState(s); err != nil { 246 t.Fatalf("err: %v", err) 247 } 248 249 backup := remote.LocalDirectory + "/" + remote.BackupHiddenStateFile 250 exists, err := remote.ExistsFile(backup) 251 if err != nil { 252 t.Fatalf("err: %v", err) 253 } 254 if !exists { 255 t.Fatalf("backup should exist") 256 } 257 } 258 259 func TestMeta_loadState_remote(t *testing.T) { 260 tmp, cwd := testCwd(t) 261 defer testFixCwd(t, tmp, cwd) 262 263 err := remote.EnsureDirectory() 264 if err != nil { 265 t.Fatalf("err: %v", err) 266 } 267 268 s := terraform.NewState() 269 s.Serial = 1000 270 conf, srv := testRemoteState(t, s, 200) 271 s.Remote = conf 272 defer srv.Close() 273 274 s.Serial = 500 275 if err := remote.PersistState(s); err != nil { 276 t.Fatalf("err: %v", err) 277 } 278 279 m := new(Meta) 280 s1, err := m.loadState() 281 if err != nil { 282 t.Fatalf("err: %v", err) 283 } 284 if s1.Serial < 1000 { 285 t.Fatalf("Bad: %#v", s1) 286 } 287 288 if !m.useRemoteState { 289 t.Fatalf("should enable remote") 290 } 291 } 292 293 func TestMeta_loadState_statePath(t *testing.T) { 294 tmp, cwd := testCwd(t) 295 defer testFixCwd(t, tmp, cwd) 296 297 m := new(Meta) 298 299 s := terraform.NewState() 300 s.Serial = 1000 301 if err := m.persistLocalState(s); err != nil { 302 t.Fatalf("err: %v", err) 303 } 304 305 s1, err := m.loadState() 306 if err != nil { 307 t.Fatalf("err: %v", err) 308 } 309 if s1.Serial < 1000 { 310 t.Fatalf("Bad: %#v", s1) 311 } 312 } 313 314 func TestMeta_loadState_conflict(t *testing.T) { 315 tmp, cwd := testCwd(t) 316 defer testFixCwd(t, tmp, cwd) 317 318 err := remote.EnsureDirectory() 319 if err != nil { 320 t.Fatalf("err: %v", err) 321 } 322 323 m := new(Meta) 324 325 s := terraform.NewState() 326 if err := remote.PersistState(s); err != nil { 327 t.Fatalf("err: %v", err) 328 } 329 if err := m.persistLocalState(s); err != nil { 330 t.Fatalf("err: %v", err) 331 } 332 333 _, err = m.loadState() 334 if err == nil { 335 t.Fatalf("should error with conflict") 336 } 337 }