github.com/ns1/terraform@v0.7.10-0.20161109153551-8949419bef40/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 if m.InputMode()&terraform.InputModeVarUnset == 0 { 183 t.Fatalf("bad: %#v", m.InputMode()) 184 } 185 } 186 187 func TestMeta_initStatePaths(t *testing.T) { 188 m := new(Meta) 189 m.initStatePaths() 190 191 if m.statePath != DefaultStateFilename { 192 t.Fatalf("bad: %#v", m) 193 } 194 if m.stateOutPath != DefaultStateFilename { 195 t.Fatalf("bad: %#v", m) 196 } 197 if m.backupPath != DefaultStateFilename+DefaultBackupExtension { 198 t.Fatalf("bad: %#v", m) 199 } 200 201 m = new(Meta) 202 m.statePath = "foo" 203 m.initStatePaths() 204 205 if m.stateOutPath != "foo" { 206 t.Fatalf("bad: %#v", m) 207 } 208 if m.backupPath != "foo"+DefaultBackupExtension { 209 t.Fatalf("bad: %#v", m) 210 } 211 212 m = new(Meta) 213 m.stateOutPath = "foo" 214 m.initStatePaths() 215 216 if m.statePath != DefaultStateFilename { 217 t.Fatalf("bad: %#v", m) 218 } 219 if m.backupPath != "foo"+DefaultBackupExtension { 220 t.Fatalf("bad: %#v", m) 221 } 222 } 223 224 func TestMeta_addModuleDepthFlag(t *testing.T) { 225 old := os.Getenv(ModuleDepthEnvVar) 226 defer os.Setenv(ModuleDepthEnvVar, old) 227 228 cases := map[string]struct { 229 EnvVar string 230 Args []string 231 Expected int 232 }{ 233 "env var sets value when no flag present": { 234 EnvVar: "4", 235 Args: []string{}, 236 Expected: 4, 237 }, 238 "flag overrides envvar": { 239 EnvVar: "4", 240 Args: []string{"-module-depth=-1"}, 241 Expected: -1, 242 }, 243 "negative envvar works": { 244 EnvVar: "-1", 245 Args: []string{}, 246 Expected: -1, 247 }, 248 "invalid envvar is ignored": { 249 EnvVar: "-#", 250 Args: []string{}, 251 Expected: ModuleDepthDefault, 252 }, 253 "empty envvar is okay too": { 254 EnvVar: "", 255 Args: []string{}, 256 Expected: ModuleDepthDefault, 257 }, 258 } 259 260 for tn, tc := range cases { 261 m := new(Meta) 262 var moduleDepth int 263 flags := flag.NewFlagSet("test", flag.ContinueOnError) 264 os.Setenv(ModuleDepthEnvVar, tc.EnvVar) 265 m.addModuleDepthFlag(flags, &moduleDepth) 266 err := flags.Parse(tc.Args) 267 if err != nil { 268 t.Fatalf("%s: err: %#v", tn, err) 269 } 270 if moduleDepth != tc.Expected { 271 t.Fatalf("%s: expected: %#v, got: %#v", tn, tc.Expected, moduleDepth) 272 } 273 } 274 }