github.com/daniellockard/packer@v0.7.6-0.20141210173435-5a9390934716/packer/environment_test.go (about) 1 package packer 2 3 import ( 4 "bytes" 5 "errors" 6 "io/ioutil" 7 "log" 8 "os" 9 "testing" 10 ) 11 12 func init() { 13 // Disable log output for tests 14 log.SetOutput(ioutil.Discard) 15 } 16 17 func testComponentFinder() *ComponentFinder { 18 builderFactory := func(n string) (Builder, error) { return new(MockBuilder), nil } 19 ppFactory := func(n string) (PostProcessor, error) { return new(TestPostProcessor), nil } 20 provFactory := func(n string) (Provisioner, error) { return new(MockProvisioner), nil } 21 return &ComponentFinder{ 22 Builder: builderFactory, 23 PostProcessor: ppFactory, 24 Provisioner: provFactory, 25 } 26 } 27 28 func testEnvironment() Environment { 29 config := DefaultEnvironmentConfig() 30 config.Ui = &BasicUi{ 31 Reader: new(bytes.Buffer), 32 Writer: new(bytes.Buffer), 33 ErrorWriter: new(bytes.Buffer), 34 } 35 36 env, err := NewEnvironment(config) 37 if err != nil { 38 panic(err) 39 } 40 41 return env 42 } 43 44 func TestEnvironment_DefaultConfig_Ui(t *testing.T) { 45 config := DefaultEnvironmentConfig() 46 if config.Ui == nil { 47 t.Fatal("config.Ui should not be nil") 48 } 49 50 rwUi, ok := config.Ui.(*BasicUi) 51 if !ok { 52 t.Fatal("default UI should be BasicUi") 53 } 54 if rwUi.Writer != os.Stdout { 55 t.Fatal("default UI should go to stdout") 56 } 57 if rwUi.Reader != os.Stdin { 58 t.Fatal("default UI reader should go to stdin") 59 } 60 } 61 62 func TestNewEnvironment_NoConfig(t *testing.T) { 63 env, err := NewEnvironment(nil) 64 if env != nil { 65 t.Fatal("env should be nil") 66 } 67 if err == nil { 68 t.Fatal("should have error") 69 } 70 } 71 72 func TestEnvironment_NilComponents(t *testing.T) { 73 config := DefaultEnvironmentConfig() 74 config.Components = *new(ComponentFinder) 75 76 env, err := NewEnvironment(config) 77 if err != nil { 78 t.Fatalf("err: %s", err) 79 } 80 81 // All of these should not cause panics... so we don't assert 82 // anything but if there is a panic in the test then yeah, something 83 // went wrong. 84 env.Builder("foo") 85 env.Hook("foo") 86 env.PostProcessor("foo") 87 env.Provisioner("foo") 88 } 89 90 func TestEnvironment_Builder(t *testing.T) { 91 builder := &MockBuilder{} 92 builders := make(map[string]Builder) 93 builders["foo"] = builder 94 95 config := DefaultEnvironmentConfig() 96 config.Components.Builder = func(n string) (Builder, error) { return builders[n], nil } 97 98 env, _ := NewEnvironment(config) 99 returnedBuilder, err := env.Builder("foo") 100 if err != nil { 101 t.Fatalf("err: %s", err) 102 } 103 if returnedBuilder != builder { 104 t.Fatalf("bad: %#v", returnedBuilder) 105 } 106 } 107 108 func TestEnvironment_Builder_NilError(t *testing.T) { 109 config := DefaultEnvironmentConfig() 110 config.Components.Builder = func(n string) (Builder, error) { return nil, nil } 111 112 env, _ := NewEnvironment(config) 113 returnedBuilder, err := env.Builder("foo") 114 if err == nil { 115 t.Fatal("should have error") 116 } 117 if returnedBuilder != nil { 118 t.Fatalf("bad: %#v", returnedBuilder) 119 } 120 } 121 122 func TestEnvironment_Builder_Error(t *testing.T) { 123 config := DefaultEnvironmentConfig() 124 config.Components.Builder = func(n string) (Builder, error) { return nil, errors.New("foo") } 125 126 env, _ := NewEnvironment(config) 127 returnedBuilder, err := env.Builder("foo") 128 if err == nil { 129 t.Fatal("should have error") 130 } 131 if err.Error() != "foo" { 132 t.Fatalf("bad err: %s", err) 133 } 134 if returnedBuilder != nil { 135 t.Fatalf("should be nil: %#v", returnedBuilder) 136 } 137 } 138 139 func TestEnvironment_Cache(t *testing.T) { 140 config := DefaultEnvironmentConfig() 141 env, _ := NewEnvironment(config) 142 if env.Cache() == nil { 143 t.Fatal("cache should not be nil") 144 } 145 } 146 147 func TestEnvironment_Hook(t *testing.T) { 148 hook := &MockHook{} 149 hooks := make(map[string]Hook) 150 hooks["foo"] = hook 151 152 config := DefaultEnvironmentConfig() 153 config.Components.Hook = func(n string) (Hook, error) { return hooks[n], nil } 154 155 env, _ := NewEnvironment(config) 156 returned, err := env.Hook("foo") 157 if err != nil { 158 t.Fatalf("err: %s", err) 159 } 160 if returned != hook { 161 t.Fatalf("bad: %#v", returned) 162 } 163 } 164 165 func TestEnvironment_Hook_NilError(t *testing.T) { 166 config := DefaultEnvironmentConfig() 167 config.Components.Hook = func(n string) (Hook, error) { return nil, nil } 168 169 env, _ := NewEnvironment(config) 170 returned, err := env.Hook("foo") 171 if err == nil { 172 t.Fatal("should have error") 173 } 174 if returned != nil { 175 t.Fatalf("bad: %#v", returned) 176 } 177 } 178 179 func TestEnvironment_Hook_Error(t *testing.T) { 180 config := DefaultEnvironmentConfig() 181 config.Components.Hook = func(n string) (Hook, error) { return nil, errors.New("foo") } 182 183 env, _ := NewEnvironment(config) 184 returned, err := env.Hook("foo") 185 if err == nil { 186 t.Fatal("should have error") 187 } 188 if err.Error() != "foo" { 189 t.Fatalf("err: %s", err) 190 } 191 if returned != nil { 192 t.Fatalf("bad: %#v", returned) 193 } 194 } 195 196 func TestEnvironment_PostProcessor(t *testing.T) { 197 pp := &TestPostProcessor{} 198 pps := make(map[string]PostProcessor) 199 pps["foo"] = pp 200 201 config := DefaultEnvironmentConfig() 202 config.Components.PostProcessor = func(n string) (PostProcessor, error) { return pps[n], nil } 203 204 env, _ := NewEnvironment(config) 205 returned, err := env.PostProcessor("foo") 206 if err != nil { 207 t.Fatalf("err: %s", err) 208 } 209 if returned != pp { 210 t.Fatalf("bad: %#v", returned) 211 } 212 } 213 214 func TestEnvironment_PostProcessor_NilError(t *testing.T) { 215 config := DefaultEnvironmentConfig() 216 config.Components.PostProcessor = func(n string) (PostProcessor, error) { return nil, nil } 217 218 env, _ := NewEnvironment(config) 219 returned, err := env.PostProcessor("foo") 220 if err == nil { 221 t.Fatal("should have error") 222 } 223 if returned != nil { 224 t.Fatalf("bad: %#v", returned) 225 } 226 } 227 228 func TestEnvironment_PostProcessor_Error(t *testing.T) { 229 config := DefaultEnvironmentConfig() 230 config.Components.PostProcessor = func(n string) (PostProcessor, error) { return nil, errors.New("foo") } 231 232 env, _ := NewEnvironment(config) 233 returned, err := env.PostProcessor("foo") 234 if err == nil { 235 t.Fatal("should be an error") 236 } 237 if err.Error() != "foo" { 238 t.Fatalf("bad err: %s", err) 239 } 240 if returned != nil { 241 t.Fatalf("bad: %#v", returned) 242 } 243 } 244 245 func TestEnvironmentProvisioner(t *testing.T) { 246 p := &MockProvisioner{} 247 ps := make(map[string]Provisioner) 248 ps["foo"] = p 249 250 config := DefaultEnvironmentConfig() 251 config.Components.Provisioner = func(n string) (Provisioner, error) { return ps[n], nil } 252 253 env, _ := NewEnvironment(config) 254 returned, err := env.Provisioner("foo") 255 if err != nil { 256 t.Fatalf("err: %s", err) 257 } 258 if returned != p { 259 t.Fatalf("bad: %#v", returned) 260 } 261 } 262 263 func TestEnvironmentProvisioner_NilError(t *testing.T) { 264 config := DefaultEnvironmentConfig() 265 config.Components.Provisioner = func(n string) (Provisioner, error) { return nil, nil } 266 267 env, _ := NewEnvironment(config) 268 returned, err := env.Provisioner("foo") 269 if err == nil { 270 t.Fatal("should have error") 271 } 272 if returned != nil { 273 t.Fatalf("bad: %#v", returned) 274 } 275 } 276 277 func TestEnvironmentProvisioner_Error(t *testing.T) { 278 config := DefaultEnvironmentConfig() 279 config.Components.Provisioner = func(n string) (Provisioner, error) { 280 return nil, errors.New("foo") 281 } 282 283 env, _ := NewEnvironment(config) 284 returned, err := env.Provisioner("foo") 285 if err == nil { 286 t.Fatal("should have error") 287 } 288 if err.Error() != "foo" { 289 t.Fatalf("err: %s", err) 290 } 291 if returned != nil { 292 t.Fatalf("bad: %#v", returned) 293 } 294 } 295 296 func TestEnvironment_SettingUi(t *testing.T) { 297 ui := &BasicUi{ 298 Reader: new(bytes.Buffer), 299 Writer: new(bytes.Buffer), 300 } 301 302 config := &EnvironmentConfig{} 303 config.Ui = ui 304 305 env, _ := NewEnvironment(config) 306 307 if env.Ui() != ui { 308 t.Fatalf("UI should be equal: %#v", env.Ui()) 309 } 310 }