github.com/ajcrowe/terraform@v0.6.8-0.20151125090328-164fb7c49b28/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/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|terraform.InputModeVarUnset { 70 t.Fatalf("bad: %#v", m.InputMode()) 71 } 72 } 73 74 func TestMetaInputMode_envVar(t *testing.T) { 75 test = false 76 defer func() { test = true }() 77 old := os.Getenv(InputModeEnvVar) 78 defer os.Setenv(InputModeEnvVar, old) 79 80 m := new(Meta) 81 args := []string{} 82 83 fs := m.flagSet("foo") 84 if err := fs.Parse(args); err != nil { 85 t.Fatalf("err: %s", err) 86 } 87 88 off := terraform.InputMode(0) 89 on := terraform.InputModeStd | terraform.InputModeVarUnset 90 cases := []struct { 91 EnvVar string 92 Expected terraform.InputMode 93 }{ 94 {"false", off}, 95 {"0", off}, 96 {"true", on}, 97 {"1", on}, 98 } 99 100 for _, tc := range cases { 101 os.Setenv(InputModeEnvVar, tc.EnvVar) 102 if m.InputMode() != tc.Expected { 103 t.Fatalf("expected InputMode: %#v, got: %#v", tc.Expected, m.InputMode()) 104 } 105 } 106 } 107 108 func TestMetaInputMode_disable(t *testing.T) { 109 test = false 110 defer func() { test = true }() 111 112 m := new(Meta) 113 args := []string{"-input=false"} 114 115 fs := m.flagSet("foo") 116 if err := fs.Parse(args); err != nil { 117 t.Fatalf("err: %s", err) 118 } 119 120 if m.InputMode() > 0 { 121 t.Fatalf("bad: %#v", m.InputMode()) 122 } 123 } 124 125 func TestMetaInputMode_defaultVars(t *testing.T) { 126 test = false 127 defer func() { test = true }() 128 129 // Create a temporary directory for our cwd 130 d := tempDir(t) 131 if err := os.MkdirAll(d, 0755); err != nil { 132 t.Fatalf("err: %s", err) 133 } 134 cwd, err := os.Getwd() 135 if err != nil { 136 t.Fatalf("err: %s", err) 137 } 138 if err := os.Chdir(d); err != nil { 139 t.Fatalf("err: %s", err) 140 } 141 defer os.Chdir(cwd) 142 143 // Create the default vars file 144 err = ioutil.WriteFile( 145 filepath.Join(d, DefaultVarsFilename), 146 []byte(""), 147 0644) 148 if err != nil { 149 t.Fatalf("err: %s", err) 150 } 151 152 m := new(Meta) 153 args := []string{} 154 args = m.process(args, true) 155 156 fs := m.flagSet("foo") 157 if err := fs.Parse(args); err != nil { 158 t.Fatalf("err: %s", err) 159 } 160 161 if m.InputMode()&terraform.InputModeVar == 0 { 162 t.Fatalf("bad: %#v", m.InputMode()) 163 } 164 } 165 166 func TestMetaInputMode_vars(t *testing.T) { 167 test = false 168 defer func() { test = true }() 169 170 m := new(Meta) 171 args := []string{"-var", "foo=bar"} 172 173 fs := m.flagSet("foo") 174 if err := fs.Parse(args); err != nil { 175 t.Fatalf("err: %s", err) 176 } 177 178 if m.InputMode()&terraform.InputModeVar != 0 { 179 t.Fatalf("bad: %#v", m.InputMode()) 180 } 181 } 182 183 func TestMeta_initStatePaths(t *testing.T) { 184 m := new(Meta) 185 m.initStatePaths() 186 187 if m.statePath != DefaultStateFilename { 188 t.Fatalf("bad: %#v", m) 189 } 190 if m.stateOutPath != DefaultStateFilename { 191 t.Fatalf("bad: %#v", m) 192 } 193 if m.backupPath != DefaultStateFilename+DefaultBackupExtension { 194 t.Fatalf("bad: %#v", m) 195 } 196 197 m = new(Meta) 198 m.statePath = "foo" 199 m.initStatePaths() 200 201 if m.stateOutPath != "foo" { 202 t.Fatalf("bad: %#v", m) 203 } 204 if m.backupPath != "foo"+DefaultBackupExtension { 205 t.Fatalf("bad: %#v", m) 206 } 207 208 m = new(Meta) 209 m.stateOutPath = "foo" 210 m.initStatePaths() 211 212 if m.statePath != DefaultStateFilename { 213 t.Fatalf("bad: %#v", m) 214 } 215 if m.backupPath != "foo"+DefaultBackupExtension { 216 t.Fatalf("bad: %#v", m) 217 } 218 } 219 220 func TestMeta_addModuleDepthFlag(t *testing.T) { 221 old := os.Getenv(ModuleDepthEnvVar) 222 defer os.Setenv(ModuleDepthEnvVar, old) 223 224 cases := map[string]struct { 225 EnvVar string 226 Args []string 227 Expected int 228 }{ 229 "env var sets value when no flag present": { 230 EnvVar: "4", 231 Args: []string{}, 232 Expected: 4, 233 }, 234 "flag overrides envvar": { 235 EnvVar: "4", 236 Args: []string{"-module-depth=-1"}, 237 Expected: -1, 238 }, 239 "negative envvar works": { 240 EnvVar: "-1", 241 Args: []string{}, 242 Expected: -1, 243 }, 244 "invalid envvar is ignored": { 245 EnvVar: "-#", 246 Args: []string{}, 247 Expected: 0, 248 }, 249 "empty envvar is okay too": { 250 EnvVar: "", 251 Args: []string{}, 252 Expected: 0, 253 }, 254 } 255 256 for tn, tc := range cases { 257 m := new(Meta) 258 var moduleDepth int 259 flags := flag.NewFlagSet("test", flag.ContinueOnError) 260 os.Setenv(ModuleDepthEnvVar, tc.EnvVar) 261 m.addModuleDepthFlag(flags, &moduleDepth) 262 err := flags.Parse(tc.Args) 263 if err != nil { 264 t.Fatalf("%s: err: %#v", tn, err) 265 } 266 if moduleDepth != tc.Expected { 267 t.Fatalf("%s: expected: %#v, got: %#v", tn, tc.Expected, moduleDepth) 268 } 269 } 270 }