github.com/rothwerx/packer@v0.9.0/builder/digitalocean/builder_test.go (about) 1 package digitalocean 2 3 import ( 4 "strconv" 5 "testing" 6 "time" 7 8 "github.com/mitchellh/packer/packer" 9 ) 10 11 func testConfig() map[string]interface{} { 12 return map[string]interface{}{ 13 "api_token": "bar", 14 "region": "nyc2", 15 "size": "512mb", 16 "image": "foo", 17 } 18 } 19 20 func TestBuilder_ImplementsBuilder(t *testing.T) { 21 var raw interface{} 22 raw = &Builder{} 23 if _, ok := raw.(packer.Builder); !ok { 24 t.Fatalf("Builder should be a builder") 25 } 26 } 27 28 func TestBuilder_Prepare_BadType(t *testing.T) { 29 b := &Builder{} 30 c := map[string]interface{}{ 31 "api_key": []string{}, 32 } 33 34 warnings, err := b.Prepare(c) 35 if len(warnings) > 0 { 36 t.Fatalf("bad: %#v", warnings) 37 } 38 if err == nil { 39 t.Fatalf("prepare should fail") 40 } 41 } 42 43 func TestBuilderPrepare_InvalidKey(t *testing.T) { 44 var b Builder 45 config := testConfig() 46 47 // Add a random key 48 config["i_should_not_be_valid"] = true 49 warnings, err := b.Prepare(config) 50 if len(warnings) > 0 { 51 t.Fatalf("bad: %#v", warnings) 52 } 53 if err == nil { 54 t.Fatal("should have error") 55 } 56 } 57 58 func TestBuilderPrepare_Region(t *testing.T) { 59 var b Builder 60 config := testConfig() 61 62 // Test default 63 delete(config, "region") 64 warnings, err := b.Prepare(config) 65 if len(warnings) > 0 { 66 t.Fatalf("bad: %#v", warnings) 67 } 68 if err == nil { 69 t.Fatalf("should error") 70 } 71 72 expected := "sfo1" 73 74 // Test set 75 config["region"] = expected 76 b = Builder{} 77 warnings, err = b.Prepare(config) 78 if len(warnings) > 0 { 79 t.Fatalf("bad: %#v", warnings) 80 } 81 if err != nil { 82 t.Fatalf("should not have error: %s", err) 83 } 84 85 if b.config.Region != expected { 86 t.Errorf("found %s, expected %s", b.config.Region, expected) 87 } 88 } 89 90 func TestBuilderPrepare_Size(t *testing.T) { 91 var b Builder 92 config := testConfig() 93 94 // Test default 95 delete(config, "size") 96 warnings, err := b.Prepare(config) 97 if len(warnings) > 0 { 98 t.Fatalf("bad: %#v", warnings) 99 } 100 if err == nil { 101 t.Fatalf("should error") 102 } 103 104 expected := "1024mb" 105 106 // Test set 107 config["size"] = expected 108 b = Builder{} 109 warnings, err = b.Prepare(config) 110 if len(warnings) > 0 { 111 t.Fatalf("bad: %#v", warnings) 112 } 113 if err != nil { 114 t.Fatalf("should not have error: %s", err) 115 } 116 117 if b.config.Size != expected { 118 t.Errorf("found %s, expected %s", b.config.Size, expected) 119 } 120 } 121 122 func TestBuilderPrepare_Image(t *testing.T) { 123 var b Builder 124 config := testConfig() 125 126 // Test default 127 delete(config, "image") 128 warnings, err := b.Prepare(config) 129 if len(warnings) > 0 { 130 t.Fatalf("bad: %#v", warnings) 131 } 132 if err == nil { 133 t.Fatal("should error") 134 } 135 136 expected := "ubuntu-14-04-x64" 137 138 // Test set 139 config["image"] = expected 140 b = Builder{} 141 warnings, err = b.Prepare(config) 142 if len(warnings) > 0 { 143 t.Fatalf("bad: %#v", warnings) 144 } 145 if err != nil { 146 t.Fatalf("should not have error: %s", err) 147 } 148 149 if b.config.Image != expected { 150 t.Errorf("found %s, expected %s", b.config.Image, expected) 151 } 152 } 153 154 func TestBuilderPrepare_SSHUsername(t *testing.T) { 155 var b Builder 156 config := testConfig() 157 158 // Test default 159 warnings, err := b.Prepare(config) 160 if len(warnings) > 0 { 161 t.Fatalf("bad: %#v", warnings) 162 } 163 if err != nil { 164 t.Fatalf("should not have error: %s", err) 165 } 166 167 if b.config.Comm.SSHUsername != "root" { 168 t.Errorf("invalid: %s", b.config.Comm.SSHUsername) 169 } 170 171 // Test set 172 config["ssh_username"] = "foo" 173 b = Builder{} 174 warnings, err = b.Prepare(config) 175 if len(warnings) > 0 { 176 t.Fatalf("bad: %#v", warnings) 177 } 178 if err != nil { 179 t.Fatalf("should not have error: %s", err) 180 } 181 182 if b.config.Comm.SSHUsername != "foo" { 183 t.Errorf("invalid: %s", b.config.Comm.SSHUsername) 184 } 185 } 186 187 func TestBuilderPrepare_StateTimeout(t *testing.T) { 188 var b Builder 189 config := testConfig() 190 191 // Test default 192 warnings, err := b.Prepare(config) 193 if len(warnings) > 0 { 194 t.Fatalf("bad: %#v", warnings) 195 } 196 if err != nil { 197 t.Fatalf("should not have error: %s", err) 198 } 199 200 if b.config.StateTimeout != 6*time.Minute { 201 t.Errorf("invalid: %s", b.config.StateTimeout) 202 } 203 204 // Test set 205 config["state_timeout"] = "5m" 206 b = Builder{} 207 warnings, err = b.Prepare(config) 208 if len(warnings) > 0 { 209 t.Fatalf("bad: %#v", warnings) 210 } 211 if err != nil { 212 t.Fatalf("should not have error: %s", err) 213 } 214 215 // Test bad 216 config["state_timeout"] = "tubes" 217 b = Builder{} 218 warnings, err = b.Prepare(config) 219 if len(warnings) > 0 { 220 t.Fatalf("bad: %#v", warnings) 221 } 222 if err == nil { 223 t.Fatal("should have error") 224 } 225 226 } 227 228 func TestBuilderPrepare_PrivateNetworking(t *testing.T) { 229 var b Builder 230 config := testConfig() 231 232 // Test default 233 warnings, err := b.Prepare(config) 234 if len(warnings) > 0 { 235 t.Fatalf("bad: %#v", warnings) 236 } 237 if err != nil { 238 t.Fatalf("should not have error: %s", err) 239 } 240 241 if b.config.PrivateNetworking != false { 242 t.Errorf("invalid: %t", b.config.PrivateNetworking) 243 } 244 245 // Test set 246 config["private_networking"] = true 247 b = Builder{} 248 warnings, err = b.Prepare(config) 249 if len(warnings) > 0 { 250 t.Fatalf("bad: %#v", warnings) 251 } 252 if err != nil { 253 t.Fatalf("should not have error: %s", err) 254 } 255 256 if b.config.PrivateNetworking != true { 257 t.Errorf("invalid: %t", b.config.PrivateNetworking) 258 } 259 } 260 261 func TestBuilderPrepare_SnapshotName(t *testing.T) { 262 var b Builder 263 config := testConfig() 264 265 // Test default 266 warnings, err := b.Prepare(config) 267 if len(warnings) > 0 { 268 t.Fatalf("bad: %#v", warnings) 269 } 270 if err != nil { 271 t.Fatalf("should not have error: %s", err) 272 } 273 274 if b.config.SnapshotName == "" { 275 t.Errorf("invalid: %s", b.config.SnapshotName) 276 } 277 278 // Test set 279 config["snapshot_name"] = "foobarbaz" 280 b = Builder{} 281 warnings, err = b.Prepare(config) 282 if len(warnings) > 0 { 283 t.Fatalf("bad: %#v", warnings) 284 } 285 if err != nil { 286 t.Fatalf("should not have error: %s", err) 287 } 288 289 // Test set with template 290 config["snapshot_name"] = "{{timestamp}}" 291 b = Builder{} 292 warnings, err = b.Prepare(config) 293 if len(warnings) > 0 { 294 t.Fatalf("bad: %#v", warnings) 295 } 296 if err != nil { 297 t.Fatalf("should not have error: %s", err) 298 } 299 300 _, err = strconv.ParseInt(b.config.SnapshotName, 0, 0) 301 if err != nil { 302 t.Fatalf("failed to parse int in template: %s", err) 303 } 304 305 } 306 307 func TestBuilderPrepare_DropletName(t *testing.T) { 308 var b Builder 309 config := testConfig() 310 311 // Test default 312 warnings, err := b.Prepare(config) 313 if len(warnings) > 0 { 314 t.Fatalf("bad: %#v", warnings) 315 } 316 if err != nil { 317 t.Fatalf("should not have error: %s", err) 318 } 319 320 if b.config.DropletName == "" { 321 t.Errorf("invalid: %s", b.config.DropletName) 322 } 323 324 // Test normal set 325 config["droplet_name"] = "foobar" 326 b = Builder{} 327 warnings, err = b.Prepare(config) 328 if len(warnings) > 0 { 329 t.Fatalf("bad: %#v", warnings) 330 } 331 if err != nil { 332 t.Fatalf("should not have error: %s", err) 333 } 334 335 // Test with template 336 config["droplet_name"] = "foobar-{{timestamp}}" 337 b = Builder{} 338 warnings, err = b.Prepare(config) 339 if len(warnings) > 0 { 340 t.Fatalf("bad: %#v", warnings) 341 } 342 if err != nil { 343 t.Fatalf("should not have error: %s", err) 344 } 345 346 // Test with bad template 347 config["droplet_name"] = "foobar-{{" 348 b = Builder{} 349 warnings, err = b.Prepare(config) 350 if len(warnings) > 0 { 351 t.Fatalf("bad: %#v", warnings) 352 } 353 if err == nil { 354 t.Fatal("should have error") 355 } 356 357 }