github.com/peterbale/terraform@v0.9.0-beta2.0.20170315142748-5723acd55547/builtin/providers/fastly/resource_fastly_service_v1_test.go (about) 1 package fastly 2 3 import ( 4 "fmt" 5 "reflect" 6 "testing" 7 8 "github.com/hashicorp/terraform/helper/acctest" 9 "github.com/hashicorp/terraform/helper/resource" 10 "github.com/hashicorp/terraform/terraform" 11 gofastly "github.com/sethvargo/go-fastly" 12 ) 13 14 func TestResourceFastlyFlattenDomains(t *testing.T) { 15 cases := []struct { 16 remote []*gofastly.Domain 17 local []map[string]interface{} 18 }{ 19 { 20 remote: []*gofastly.Domain{ 21 &gofastly.Domain{ 22 Name: "test.notexample.com", 23 Comment: "not comment", 24 }, 25 }, 26 local: []map[string]interface{}{ 27 map[string]interface{}{ 28 "name": "test.notexample.com", 29 "comment": "not comment", 30 }, 31 }, 32 }, 33 { 34 remote: []*gofastly.Domain{ 35 &gofastly.Domain{ 36 Name: "test.notexample.com", 37 }, 38 }, 39 local: []map[string]interface{}{ 40 map[string]interface{}{ 41 "name": "test.notexample.com", 42 "comment": "", 43 }, 44 }, 45 }, 46 } 47 48 for _, c := range cases { 49 out := flattenDomains(c.remote) 50 if !reflect.DeepEqual(out, c.local) { 51 t.Fatalf("Error matching:\nexpected: %#v\ngot: %#v", c.local, out) 52 } 53 } 54 } 55 56 func TestResourceFastlyFlattenBackend(t *testing.T) { 57 cases := []struct { 58 remote []*gofastly.Backend 59 local []map[string]interface{} 60 }{ 61 { 62 remote: []*gofastly.Backend{ 63 &gofastly.Backend{ 64 Name: "test.notexample.com", 65 Address: "www.notexample.com", 66 Port: uint(80), 67 AutoLoadbalance: true, 68 BetweenBytesTimeout: uint(10000), 69 ConnectTimeout: uint(1000), 70 ErrorThreshold: uint(0), 71 FirstByteTimeout: uint(15000), 72 MaxConn: uint(200), 73 RequestCondition: "", 74 SSLCheckCert: true, 75 SSLHostname: "", 76 SSLCertHostname: "", 77 SSLSNIHostname: "", 78 Shield: "New York", 79 Weight: uint(100), 80 }, 81 }, 82 local: []map[string]interface{}{ 83 map[string]interface{}{ 84 "name": "test.notexample.com", 85 "address": "www.notexample.com", 86 "port": 80, 87 "auto_loadbalance": gofastly.CBool(true), 88 "between_bytes_timeout": 10000, 89 "connect_timeout": 1000, 90 "error_threshold": 0, 91 "first_byte_timeout": 15000, 92 "max_conn": 200, 93 "request_condition": "", 94 "ssl_check_cert": gofastly.CBool(true), 95 "ssl_hostname": "", 96 "ssl_cert_hostname": "", 97 "ssl_sni_hostname": "", 98 "shield": "New York", 99 "weight": 100, 100 }, 101 }, 102 }, 103 } 104 105 for _, c := range cases { 106 out := flattenBackends(c.remote) 107 if !reflect.DeepEqual(out, c.local) { 108 t.Fatalf("Error matching:\nexpected: %#v\ngot: %#v", c.local, out) 109 } 110 } 111 } 112 113 func TestAccFastlyServiceV1_updateDomain(t *testing.T) { 114 var service gofastly.ServiceDetail 115 name := fmt.Sprintf("tf-test-%s", acctest.RandString(10)) 116 nameUpdate := fmt.Sprintf("tf-test-%s", acctest.RandString(10)) 117 domainName1 := fmt.Sprintf("%s.notadomain.com", acctest.RandString(10)) 118 domainName2 := fmt.Sprintf("%s.notadomain.com", acctest.RandString(10)) 119 120 resource.Test(t, resource.TestCase{ 121 PreCheck: func() { testAccPreCheck(t) }, 122 Providers: testAccProviders, 123 CheckDestroy: testAccCheckServiceV1Destroy, 124 Steps: []resource.TestStep{ 125 resource.TestStep{ 126 Config: testAccServiceV1Config(name, domainName1), 127 Check: resource.ComposeTestCheckFunc( 128 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 129 testAccCheckFastlyServiceV1Attributes(&service, name, []string{domainName1}), 130 resource.TestCheckResourceAttr( 131 "fastly_service_v1.foo", "name", name), 132 resource.TestCheckResourceAttr( 133 "fastly_service_v1.foo", "active_version", "1"), 134 resource.TestCheckResourceAttr( 135 "fastly_service_v1.foo", "domain.#", "1"), 136 ), 137 }, 138 139 resource.TestStep{ 140 Config: testAccServiceV1Config_domainUpdate(nameUpdate, domainName1, domainName2), 141 Check: resource.ComposeTestCheckFunc( 142 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 143 testAccCheckFastlyServiceV1Attributes(&service, nameUpdate, []string{domainName1, domainName2}), 144 resource.TestCheckResourceAttr( 145 "fastly_service_v1.foo", "name", nameUpdate), 146 resource.TestCheckResourceAttr( 147 "fastly_service_v1.foo", "active_version", "2"), 148 resource.TestCheckResourceAttr( 149 "fastly_service_v1.foo", "domain.#", "2"), 150 ), 151 }, 152 }, 153 }) 154 } 155 156 func TestAccFastlyServiceV1_updateBackend(t *testing.T) { 157 var service gofastly.ServiceDetail 158 name := fmt.Sprintf("tf-test-%s", acctest.RandString(10)) 159 backendName := fmt.Sprintf("%s.aws.amazon.com", acctest.RandString(3)) 160 backendName2 := fmt.Sprintf("%s.aws.amazon.com", acctest.RandString(3)) 161 162 resource.Test(t, resource.TestCase{ 163 PreCheck: func() { testAccPreCheck(t) }, 164 Providers: testAccProviders, 165 CheckDestroy: testAccCheckServiceV1Destroy, 166 Steps: []resource.TestStep{ 167 resource.TestStep{ 168 Config: testAccServiceV1Config_backend(name, backendName), 169 Check: resource.ComposeTestCheckFunc( 170 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 171 testAccCheckFastlyServiceV1Attributes_backends(&service, name, []string{backendName}), 172 ), 173 }, 174 175 resource.TestStep{ 176 Config: testAccServiceV1Config_backend_update(name, backendName, backendName2), 177 Check: resource.ComposeTestCheckFunc( 178 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 179 testAccCheckFastlyServiceV1Attributes_backends(&service, name, []string{backendName, backendName2}), 180 resource.TestCheckResourceAttr( 181 "fastly_service_v1.foo", "active_version", "2"), 182 resource.TestCheckResourceAttr( 183 "fastly_service_v1.foo", "backend.#", "2"), 184 ), 185 }, 186 }, 187 }) 188 } 189 190 func TestAccFastlyServiceV1_basic(t *testing.T) { 191 var service gofastly.ServiceDetail 192 name := fmt.Sprintf("tf-test-%s", acctest.RandString(10)) 193 domainName := fmt.Sprintf("%s.notadomain.com", acctest.RandString(10)) 194 195 resource.Test(t, resource.TestCase{ 196 PreCheck: func() { testAccPreCheck(t) }, 197 Providers: testAccProviders, 198 CheckDestroy: testAccCheckServiceV1Destroy, 199 Steps: []resource.TestStep{ 200 resource.TestStep{ 201 Config: testAccServiceV1Config(name, domainName), 202 Check: resource.ComposeTestCheckFunc( 203 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 204 testAccCheckFastlyServiceV1Attributes(&service, name, []string{domainName}), 205 resource.TestCheckResourceAttr( 206 "fastly_service_v1.foo", "name", name), 207 resource.TestCheckResourceAttr( 208 "fastly_service_v1.foo", "active_version", "1"), 209 resource.TestCheckResourceAttr( 210 "fastly_service_v1.foo", "domain.#", "1"), 211 ), 212 }, 213 }, 214 }) 215 } 216 217 // ServiceV1_disappears – test that a non-empty plan is returned when a Fastly 218 // Service is destroyed outside of Terraform, and can no longer be found, 219 // correctly clearing the ID field and generating a new plan 220 func TestAccFastlyServiceV1_disappears(t *testing.T) { 221 var service gofastly.ServiceDetail 222 name := fmt.Sprintf("tf-test-%s", acctest.RandString(10)) 223 domainName := fmt.Sprintf("%s.notadomain.com", acctest.RandString(10)) 224 225 testDestroy := func(*terraform.State) error { 226 // reach out and DELETE the service 227 conn := testAccProvider.Meta().(*FastlyClient).conn 228 // deactivate active version to destoy 229 _, err := conn.DeactivateVersion(&gofastly.DeactivateVersionInput{ 230 Service: service.ID, 231 Version: service.ActiveVersion.Number, 232 }) 233 if err != nil { 234 return err 235 } 236 237 // delete service 238 err = conn.DeleteService(&gofastly.DeleteServiceInput{ 239 ID: service.ID, 240 }) 241 242 if err != nil { 243 return err 244 } 245 246 return nil 247 } 248 249 resource.Test(t, resource.TestCase{ 250 PreCheck: func() { testAccPreCheck(t) }, 251 Providers: testAccProviders, 252 CheckDestroy: testAccCheckServiceV1Destroy, 253 Steps: []resource.TestStep{ 254 resource.TestStep{ 255 Config: testAccServiceV1Config(name, domainName), 256 Check: resource.ComposeTestCheckFunc( 257 testAccCheckServiceV1Exists("fastly_service_v1.foo", &service), 258 testDestroy, 259 ), 260 ExpectNonEmptyPlan: true, 261 }, 262 }, 263 }) 264 } 265 266 func testAccCheckServiceV1Exists(n string, service *gofastly.ServiceDetail) resource.TestCheckFunc { 267 return func(s *terraform.State) error { 268 rs, ok := s.RootModule().Resources[n] 269 if !ok { 270 return fmt.Errorf("Not found: %s", n) 271 } 272 273 if rs.Primary.ID == "" { 274 return fmt.Errorf("No Service ID is set") 275 } 276 277 conn := testAccProvider.Meta().(*FastlyClient).conn 278 latest, err := conn.GetServiceDetails(&gofastly.GetServiceInput{ 279 ID: rs.Primary.ID, 280 }) 281 282 if err != nil { 283 return err 284 } 285 286 *service = *latest 287 288 return nil 289 } 290 } 291 292 func testAccCheckFastlyServiceV1Attributes(service *gofastly.ServiceDetail, name string, domains []string) resource.TestCheckFunc { 293 return func(s *terraform.State) error { 294 295 if service.Name != name { 296 return fmt.Errorf("Bad name, expected (%s), got (%s)", name, service.Name) 297 } 298 299 conn := testAccProvider.Meta().(*FastlyClient).conn 300 domainList, err := conn.ListDomains(&gofastly.ListDomainsInput{ 301 Service: service.ID, 302 Version: service.ActiveVersion.Number, 303 }) 304 305 if err != nil { 306 return fmt.Errorf("[ERR] Error looking up Domains for (%s), version (%s): %s", service.Name, service.ActiveVersion.Number, err) 307 } 308 309 expected := len(domains) 310 for _, d := range domainList { 311 for _, e := range domains { 312 if d.Name == e { 313 expected-- 314 } 315 } 316 } 317 318 if expected > 0 { 319 return fmt.Errorf("Domain count mismatch, expected: %#v, got: %#v", domains, domainList) 320 } 321 322 return nil 323 } 324 } 325 326 func testAccCheckFastlyServiceV1Attributes_backends(service *gofastly.ServiceDetail, name string, backends []string) resource.TestCheckFunc { 327 return func(s *terraform.State) error { 328 329 if service.Name != name { 330 return fmt.Errorf("Bad name, expected (%s), got (%s)", name, service.Name) 331 } 332 333 conn := testAccProvider.Meta().(*FastlyClient).conn 334 backendList, err := conn.ListBackends(&gofastly.ListBackendsInput{ 335 Service: service.ID, 336 Version: service.ActiveVersion.Number, 337 }) 338 339 if err != nil { 340 return fmt.Errorf("[ERR] Error looking up Backends for (%s), version (%s): %s", service.Name, service.ActiveVersion.Number, err) 341 } 342 343 expected := len(backendList) 344 for _, b := range backendList { 345 for _, e := range backends { 346 if b.Address == e { 347 expected-- 348 } 349 } 350 } 351 352 if expected > 0 { 353 return fmt.Errorf("Backend count mismatch, expected: %#v, got: %#v", backends, backendList) 354 } 355 356 return nil 357 } 358 } 359 360 func testAccCheckServiceV1Destroy(s *terraform.State) error { 361 for _, rs := range s.RootModule().Resources { 362 if rs.Type != "fastly_service_v1" { 363 continue 364 } 365 366 conn := testAccProvider.Meta().(*FastlyClient).conn 367 l, err := conn.ListServices(&gofastly.ListServicesInput{}) 368 if err != nil { 369 return fmt.Errorf("[WARN] Error listing servcies when deleting Fastly Service (%s): %s", rs.Primary.ID, err) 370 } 371 372 for _, s := range l { 373 if s.ID == rs.Primary.ID { 374 // service still found 375 return fmt.Errorf("[WARN] Tried deleting Service (%s), but was still found", rs.Primary.ID) 376 } 377 } 378 } 379 return nil 380 } 381 382 func testAccServiceV1Config(name, domain string) string { 383 return fmt.Sprintf(` 384 resource "fastly_service_v1" "foo" { 385 name = "%s" 386 387 domain { 388 name = "%s" 389 comment = "tf-testing-domain" 390 } 391 392 backend { 393 address = "aws.amazon.com" 394 name = "amazon docs" 395 } 396 397 force_destroy = true 398 }`, name, domain) 399 } 400 401 func testAccServiceV1Config_domainUpdate(name, domain1, domain2 string) string { 402 return fmt.Sprintf(` 403 resource "fastly_service_v1" "foo" { 404 name = "%s" 405 406 domain { 407 name = "%s" 408 comment = "tf-testing-domain" 409 } 410 411 domain { 412 name = "%s" 413 comment = "tf-testing-other-domain" 414 } 415 416 backend { 417 address = "aws.amazon.com" 418 name = "amazon docs" 419 } 420 421 force_destroy = true 422 }`, name, domain1, domain2) 423 } 424 425 func testAccServiceV1Config_backend(name, backend string) string { 426 return fmt.Sprintf(` 427 resource "fastly_service_v1" "foo" { 428 name = "%s" 429 430 domain { 431 name = "test.notadomain.com" 432 comment = "tf-testing-domain" 433 } 434 435 backend { 436 address = "%s" 437 name = "tf -test backend" 438 } 439 440 force_destroy = true 441 }`, name, backend) 442 } 443 444 func testAccServiceV1Config_backend_update(name, backend, backend2 string) string { 445 return fmt.Sprintf(` 446 resource "fastly_service_v1" "foo" { 447 name = "%s" 448 449 default_ttl = 3400 450 451 domain { 452 name = "test.notadomain.com" 453 comment = "tf-testing-domain" 454 } 455 456 backend { 457 address = "%s" 458 name = "tf-test-backend" 459 } 460 461 backend { 462 address = "%s" 463 name = "tf-test-backend-other" 464 } 465 466 force_destroy = true 467 }`, name, backend, backend2) 468 }