github.com/dougneal/terraform@v0.6.15-0.20170330092735-b6a3840768a4/command/meta_test.go (about) 1 package command 2 3 import ( 4 "flag" 5 "io/ioutil" 6 "os" 7 "path/filepath" 8 "reflect" 9 "testing" 10 11 "github.com/hashicorp/terraform/backend" 12 "github.com/hashicorp/terraform/terraform" 13 ) 14 15 func TestMetaColorize(t *testing.T) { 16 var m *Meta 17 var args, args2 []string 18 19 // Test basic, color 20 m = new(Meta) 21 m.Color = true 22 args = []string{"foo", "bar"} 23 args2 = []string{"foo", "bar"} 24 args = m.process(args, false) 25 if !reflect.DeepEqual(args, args2) { 26 t.Fatalf("bad: %#v", args) 27 } 28 if m.Colorize().Disable { 29 t.Fatal("should not be disabled") 30 } 31 32 // Test basic, no change 33 m = new(Meta) 34 args = []string{"foo", "bar"} 35 args2 = []string{"foo", "bar"} 36 args = m.process(args, false) 37 if !reflect.DeepEqual(args, args2) { 38 t.Fatalf("bad: %#v", args) 39 } 40 if !m.Colorize().Disable { 41 t.Fatal("should be disabled") 42 } 43 44 // Test disable #1 45 m = new(Meta) 46 m.Color = true 47 args = []string{"foo", "-no-color", "bar"} 48 args2 = []string{"foo", "bar"} 49 args = m.process(args, false) 50 if !reflect.DeepEqual(args, args2) { 51 t.Fatalf("bad: %#v", args) 52 } 53 if !m.Colorize().Disable { 54 t.Fatal("should be disabled") 55 } 56 } 57 58 func TestMetaInputMode(t *testing.T) { 59 test = false 60 defer func() { test = true }() 61 62 m := new(Meta) 63 args := []string{} 64 65 fs := m.flagSet("foo") 66 if err := fs.Parse(args); err != nil { 67 t.Fatalf("err: %s", err) 68 } 69 70 if m.InputMode() != terraform.InputModeStd|terraform.InputModeVarUnset { 71 t.Fatalf("bad: %#v", m.InputMode()) 72 } 73 } 74 75 func TestMetaInputMode_envVar(t *testing.T) { 76 test = false 77 defer func() { test = true }() 78 old := os.Getenv(InputModeEnvVar) 79 defer os.Setenv(InputModeEnvVar, old) 80 81 m := new(Meta) 82 args := []string{} 83 84 fs := m.flagSet("foo") 85 if err := fs.Parse(args); err != nil { 86 t.Fatalf("err: %s", err) 87 } 88 89 off := terraform.InputMode(0) 90 on := terraform.InputModeStd | terraform.InputModeVarUnset 91 cases := []struct { 92 EnvVar string 93 Expected terraform.InputMode 94 }{ 95 {"false", off}, 96 {"0", off}, 97 {"true", on}, 98 {"1", on}, 99 } 100 101 for _, tc := range cases { 102 os.Setenv(InputModeEnvVar, tc.EnvVar) 103 if m.InputMode() != tc.Expected { 104 t.Fatalf("expected InputMode: %#v, got: %#v", tc.Expected, m.InputMode()) 105 } 106 } 107 } 108 109 func TestMetaInputMode_disable(t *testing.T) { 110 test = false 111 defer func() { test = true }() 112 113 m := new(Meta) 114 args := []string{"-input=false"} 115 116 fs := m.flagSet("foo") 117 if err := fs.Parse(args); err != nil { 118 t.Fatalf("err: %s", err) 119 } 120 121 if m.InputMode() > 0 { 122 t.Fatalf("bad: %#v", m.InputMode()) 123 } 124 } 125 126 func TestMetaInputMode_defaultVars(t *testing.T) { 127 test = false 128 defer func() { test = true }() 129 130 // Create a temporary directory for our cwd 131 d := tempDir(t) 132 if err := os.MkdirAll(d, 0755); err != nil { 133 t.Fatalf("err: %s", err) 134 } 135 cwd, err := os.Getwd() 136 if err != nil { 137 t.Fatalf("err: %s", err) 138 } 139 if err := os.Chdir(d); err != nil { 140 t.Fatalf("err: %s", err) 141 } 142 defer os.Chdir(cwd) 143 144 // Create the default vars file 145 err = ioutil.WriteFile( 146 filepath.Join(d, DefaultVarsFilename), 147 []byte(""), 148 0644) 149 if err != nil { 150 t.Fatalf("err: %s", err) 151 } 152 153 m := new(Meta) 154 args := []string{} 155 args = m.process(args, true) 156 157 fs := m.flagSet("foo") 158 if err := fs.Parse(args); err != nil { 159 t.Fatalf("err: %s", err) 160 } 161 162 if m.InputMode()&terraform.InputModeVar == 0 { 163 t.Fatalf("bad: %#v", m.InputMode()) 164 } 165 } 166 167 func TestMetaInputMode_vars(t *testing.T) { 168 test = false 169 defer func() { test = true }() 170 171 m := new(Meta) 172 args := []string{"-var", "foo=bar"} 173 174 fs := m.flagSet("foo") 175 if err := fs.Parse(args); err != nil { 176 t.Fatalf("err: %s", err) 177 } 178 179 if m.InputMode()&terraform.InputModeVar == 0 { 180 t.Fatalf("bad: %#v", m.InputMode()) 181 } 182 183 if m.InputMode()&terraform.InputModeVarUnset == 0 { 184 t.Fatalf("bad: %#v", m.InputMode()) 185 } 186 } 187 188 func TestMeta_initStatePaths(t *testing.T) { 189 m := new(Meta) 190 m.initStatePaths() 191 192 if m.statePath != DefaultStateFilename { 193 t.Fatalf("bad: %#v", m) 194 } 195 if m.stateOutPath != DefaultStateFilename { 196 t.Fatalf("bad: %#v", m) 197 } 198 if m.backupPath != DefaultStateFilename+DefaultBackupExtension { 199 t.Fatalf("bad: %#v", m) 200 } 201 202 m = new(Meta) 203 m.statePath = "foo" 204 m.initStatePaths() 205 206 if m.stateOutPath != "foo" { 207 t.Fatalf("bad: %#v", m) 208 } 209 if m.backupPath != "foo"+DefaultBackupExtension { 210 t.Fatalf("bad: %#v", m) 211 } 212 213 m = new(Meta) 214 m.stateOutPath = "foo" 215 m.initStatePaths() 216 217 if m.statePath != DefaultStateFilename { 218 t.Fatalf("bad: %#v", m) 219 } 220 if m.backupPath != "foo"+DefaultBackupExtension { 221 t.Fatalf("bad: %#v", m) 222 } 223 } 224 225 func TestMeta_addModuleDepthFlag(t *testing.T) { 226 old := os.Getenv(ModuleDepthEnvVar) 227 defer os.Setenv(ModuleDepthEnvVar, old) 228 229 cases := map[string]struct { 230 EnvVar string 231 Args []string 232 Expected int 233 }{ 234 "env var sets value when no flag present": { 235 EnvVar: "4", 236 Args: []string{}, 237 Expected: 4, 238 }, 239 "flag overrides envvar": { 240 EnvVar: "4", 241 Args: []string{"-module-depth=-1"}, 242 Expected: -1, 243 }, 244 "negative envvar works": { 245 EnvVar: "-1", 246 Args: []string{}, 247 Expected: -1, 248 }, 249 "invalid envvar is ignored": { 250 EnvVar: "-#", 251 Args: []string{}, 252 Expected: ModuleDepthDefault, 253 }, 254 "empty envvar is okay too": { 255 EnvVar: "", 256 Args: []string{}, 257 Expected: ModuleDepthDefault, 258 }, 259 } 260 261 for tn, tc := range cases { 262 m := new(Meta) 263 var moduleDepth int 264 flags := flag.NewFlagSet("test", flag.ContinueOnError) 265 os.Setenv(ModuleDepthEnvVar, tc.EnvVar) 266 m.addModuleDepthFlag(flags, &moduleDepth) 267 err := flags.Parse(tc.Args) 268 if err != nil { 269 t.Fatalf("%s: err: %#v", tn, err) 270 } 271 if moduleDepth != tc.Expected { 272 t.Fatalf("%s: expected: %#v, got: %#v", tn, tc.Expected, moduleDepth) 273 } 274 } 275 } 276 277 func TestMeta_Env(t *testing.T) { 278 td := tempDir(t) 279 os.MkdirAll(td, 0755) 280 defer os.RemoveAll(td) 281 defer testChdir(t, td)() 282 283 m := new(Meta) 284 285 env := m.Env() 286 287 if env != backend.DefaultStateName { 288 t.Fatalf("expected env %q, got env %q", backend.DefaultStateName, env) 289 } 290 291 testEnv := "test_env" 292 if err := m.SetEnv(testEnv); err != nil { 293 t.Fatal("error setting env:", err) 294 } 295 296 env = m.Env() 297 if env != testEnv { 298 t.Fatalf("expected env %q, got env %q", testEnv, env) 299 } 300 301 if err := m.SetEnv(backend.DefaultStateName); err != nil { 302 t.Fatal("error setting env:", err) 303 } 304 305 env = m.Env() 306 if env != backend.DefaultStateName { 307 t.Fatalf("expected env %q, got env %q", backend.DefaultStateName, env) 308 } 309 }