github.com/cloudfoundry-attic/cli-with-i18n@v6.32.1-0.20171002233121-7401370d3b85+incompatible/actor/v2action/domain_test.go (about) 1 package v2action_test 2 3 import ( 4 "errors" 5 6 . "code.cloudfoundry.org/cli/actor/v2action" 7 "code.cloudfoundry.org/cli/actor/v2action/v2actionfakes" 8 "code.cloudfoundry.org/cli/api/cloudcontroller/ccerror" 9 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2" 10 "code.cloudfoundry.org/cli/api/cloudcontroller/ccv2/constant" 11 . "github.com/onsi/ginkgo" 12 . "github.com/onsi/ginkgo/extensions/table" 13 . "github.com/onsi/gomega" 14 ) 15 16 var _ = Describe("Domain Actions", func() { 17 var ( 18 actor *Actor 19 fakeCloudControllerClient *v2actionfakes.FakeCloudControllerClient 20 ) 21 22 BeforeEach(func() { 23 fakeCloudControllerClient = new(v2actionfakes.FakeCloudControllerClient) 24 actor = NewActor(fakeCloudControllerClient, nil, nil) 25 }) 26 27 Describe("Domain", func() { 28 var domain Domain 29 Describe("IsHTTP", func() { 30 Context("when the RouterGroupType = 'http'", func() { 31 BeforeEach(func() { 32 domain.RouterGroupType = constant.HTTPRouterGroup 33 }) 34 35 It("returns true", func() { 36 Expect(domain.IsHTTP()).To(BeTrue()) 37 }) 38 }) 39 40 Context("when the RouterGroupType is anything other than 'tcp'", func() { 41 BeforeEach(func() { 42 domain.RouterGroupType = "" 43 }) 44 45 It("returns true", func() { 46 Expect(domain.IsHTTP()).To(BeTrue()) 47 }) 48 }) 49 50 Context("when the RouterGroupType = 'http'", func() { 51 BeforeEach(func() { 52 domain.RouterGroupType = constant.TCPRouterGroup 53 }) 54 55 It("returns false", func() { 56 Expect(domain.IsHTTP()).To(BeFalse()) 57 }) 58 }) 59 }) 60 61 Describe("IsTCP", func() { 62 Context("when the RouterGroupType = 'tcp'", func() { 63 BeforeEach(func() { 64 domain.RouterGroupType = constant.TCPRouterGroup 65 }) 66 67 It("returns true", func() { 68 Expect(domain.IsTCP()).To(BeTrue()) 69 }) 70 }) 71 72 Context("when the RouterGroupType is anything else", func() { 73 BeforeEach(func() { 74 domain.RouterGroupType = constant.HTTPRouterGroup 75 }) 76 77 It("returns false", func() { 78 Expect(domain.IsTCP()).To(BeFalse()) 79 }) 80 }) 81 }) 82 }) 83 84 Describe("DomainNotFoundError", func() { 85 var err DomainNotFoundError 86 Context("when the name is provided", func() { 87 BeforeEach(func() { 88 err = DomainNotFoundError{Name: "some-domain-name"} 89 }) 90 91 It("returns the correct message", func() { 92 Expect(err.Error()).To(Equal("Domain some-domain-name not found")) 93 }) 94 }) 95 96 Context("when the name is not provided but the guid is", func() { 97 BeforeEach(func() { 98 err = DomainNotFoundError{GUID: "some-domain-guid"} 99 }) 100 101 It("returns the correct message", func() { 102 Expect(err.Error()).To(Equal("Domain with GUID some-domain-guid not found")) 103 }) 104 }) 105 106 Context("when neither the name nor the guid is provided", func() { 107 BeforeEach(func() { 108 err = DomainNotFoundError{} 109 }) 110 111 It("returns the correct message", func() { 112 Expect(err.Error()).To(Equal("Domain not found")) 113 }) 114 }) 115 }) 116 117 Describe("GetDomain", func() { 118 Context("when the domain exists and is a shared domain", func() { 119 var expectedDomain ccv2.Domain 120 121 BeforeEach(func() { 122 expectedDomain = ccv2.Domain{ 123 GUID: "shared-domain-guid", 124 Name: "shared-domain", 125 } 126 fakeCloudControllerClient.GetSharedDomainReturns(expectedDomain, ccv2.Warnings{"get-domain-warning"}, nil) 127 }) 128 129 It("returns the shared domain", func() { 130 domain, warnings, err := actor.GetDomain("shared-domain-guid") 131 Expect(err).NotTo(HaveOccurred()) 132 Expect(warnings).To(Equal(Warnings{"get-domain-warning"})) 133 Expect(domain).To(Equal(Domain(expectedDomain))) 134 135 Expect(fakeCloudControllerClient.GetSharedDomainCallCount()).To(Equal(1)) 136 Expect(fakeCloudControllerClient.GetSharedDomainArgsForCall(0)).To(Equal("shared-domain-guid")) 137 }) 138 }) 139 140 Context("when the domain exists and is a private domain", func() { 141 var expectedDomain ccv2.Domain 142 143 BeforeEach(func() { 144 expectedDomain = ccv2.Domain{ 145 GUID: "private-domain-guid", 146 Name: "private-domain", 147 } 148 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, nil, ccerror.ResourceNotFoundError{}) 149 fakeCloudControllerClient.GetPrivateDomainReturns(expectedDomain, nil, nil) 150 }) 151 152 It("returns the private domain", func() { 153 domain, _, err := actor.GetDomain("private-domain-guid") 154 Expect(err).NotTo(HaveOccurred()) 155 Expect(domain).To(Equal(Domain(expectedDomain))) 156 157 Expect(fakeCloudControllerClient.GetSharedDomainCallCount()).To(Equal(1)) 158 Expect(fakeCloudControllerClient.GetSharedDomainArgsForCall(0)).To(Equal("private-domain-guid")) 159 Expect(fakeCloudControllerClient.GetPrivateDomainCallCount()).To(Equal(1)) 160 Expect(fakeCloudControllerClient.GetPrivateDomainArgsForCall(0)).To(Equal("private-domain-guid")) 161 }) 162 }) 163 164 Context("when the domain does not exist", func() { 165 var expectedErr DomainNotFoundError 166 167 BeforeEach(func() { 168 expectedErr = DomainNotFoundError{GUID: "private-domain-guid"} 169 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, nil, ccerror.ResourceNotFoundError{}) 170 fakeCloudControllerClient.GetPrivateDomainReturns(ccv2.Domain{}, nil, ccerror.ResourceNotFoundError{}) 171 }) 172 173 It("returns a DomainNotFoundError", func() { 174 domain, _, err := actor.GetDomain("private-domain-guid") 175 Expect(err).To(MatchError(expectedErr)) 176 Expect(domain).To(Equal(Domain(ccv2.Domain{}))) 177 }) 178 }) 179 180 DescribeTable("when there are warnings and errors", func( 181 stubGetSharedDomain func(), 182 stubGetPrivateDomain func(), 183 expectedDomain Domain, 184 expectedWarnings Warnings, 185 expectingError bool, 186 expectedErr error, 187 ) { 188 stubGetSharedDomain() 189 stubGetPrivateDomain() 190 domain, warnings, err := actor.GetDomain("some-domain-guid") 191 Expect(domain).To(Equal(expectedDomain)) 192 Expect(warnings).To(ConsistOf(expectedWarnings)) 193 if expectingError { 194 Expect(err).To(MatchError(expectedErr)) 195 } else { 196 Expect(err).To(Not(HaveOccurred())) 197 } 198 }, 199 200 Entry( 201 "shared domain warning and error", 202 func() { 203 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, []string{"shared-domain-warning"}, errors.New("shared domain error")) 204 }, 205 func() { fakeCloudControllerClient.GetPrivateDomainReturns(ccv2.Domain{}, nil, nil) }, 206 Domain{}, 207 Warnings{"shared-domain-warning"}, 208 true, 209 errors.New("shared domain error"), 210 ), 211 212 Entry( 213 "shared domain warning and resource not found; private domain warning & error", 214 func() { 215 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, []string{"shared-domain-warning"}, ccerror.ResourceNotFoundError{}) 216 }, 217 func() { 218 fakeCloudControllerClient.GetPrivateDomainReturns(ccv2.Domain{}, []string{"private-domain-warning"}, errors.New("private domain error")) 219 }, 220 Domain{}, 221 Warnings{"shared-domain-warning", "private-domain-warning"}, 222 true, 223 errors.New("private domain error"), 224 ), 225 ) 226 }) 227 228 Describe("GetDomainsByNameAndOrganization", func() { 229 var ( 230 domainNames []string 231 orgGUID string 232 233 domains []Domain 234 warnings Warnings 235 executeErr error 236 ) 237 238 BeforeEach(func() { 239 domainNames = []string{"domain-1", "domain-2", "domain-3"} 240 orgGUID = "some-org-guid" 241 }) 242 243 JustBeforeEach(func() { 244 domains, warnings, executeErr = actor.GetDomainsByNameAndOrganization(domainNames, orgGUID) 245 }) 246 247 Context("when looking up the shared domains is successful", func() { 248 var sharedDomains []ccv2.Domain 249 250 BeforeEach(func() { 251 sharedDomains = []ccv2.Domain{ 252 {Name: "domain-1", GUID: "shared-domain-1"}, 253 } 254 fakeCloudControllerClient.GetSharedDomainsReturns(sharedDomains, ccv2.Warnings{"shared-warning-1", "shared-warning-2"}, nil) 255 }) 256 257 Context("when looking up the private domains is successful", func() { 258 var privateDomains []ccv2.Domain 259 260 BeforeEach(func() { 261 privateDomains = []ccv2.Domain{ 262 {Name: "domain-2", GUID: "private-domain-2"}, 263 {Name: "domain-3", GUID: "private-domain-3"}, 264 } 265 fakeCloudControllerClient.GetOrganizationPrivateDomainsReturns(privateDomains, ccv2.Warnings{"private-warning-1", "private-warning-2"}, nil) 266 }) 267 268 It("returns the domains and warnings", func() { 269 Expect(executeErr).ToNot(HaveOccurred()) 270 Expect(warnings).To(ConsistOf("shared-warning-1", "shared-warning-2", "private-warning-1", "private-warning-2")) 271 Expect(domains).To(ConsistOf( 272 Domain{Name: "domain-1", GUID: "shared-domain-1"}, 273 Domain{Name: "domain-2", GUID: "private-domain-2"}, 274 Domain{Name: "domain-3", GUID: "private-domain-3"}, 275 )) 276 277 Expect(fakeCloudControllerClient.GetSharedDomainsCallCount()).To(Equal(1)) 278 Expect(fakeCloudControllerClient.GetSharedDomainsArgsForCall(0)).To(ConsistOf(ccv2.Query{ 279 Filter: ccv2.NameFilter, 280 Operator: ccv2.InOperator, 281 Values: domainNames, 282 })) 283 284 Expect(fakeCloudControllerClient.GetOrganizationPrivateDomainsCallCount()).To(Equal(1)) 285 passedOrgGUID, queries := fakeCloudControllerClient.GetOrganizationPrivateDomainsArgsForCall(0) 286 Expect(queries).To(ConsistOf(ccv2.Query{ 287 Filter: ccv2.NameFilter, 288 Operator: ccv2.InOperator, 289 Values: domainNames, 290 })) 291 Expect(passedOrgGUID).To(Equal(orgGUID)) 292 }) 293 }) 294 295 Context("when looking up the private domains errors", func() { 296 var expectedErr error 297 298 BeforeEach(func() { 299 expectedErr = errors.New("foobar") 300 fakeCloudControllerClient.GetOrganizationPrivateDomainsReturns(nil, ccv2.Warnings{"private-warning-1", "private-warning-2"}, expectedErr) 301 }) 302 303 It("returns errors and warnings", func() { 304 Expect(executeErr).To(MatchError(expectedErr)) 305 Expect(warnings).To(ConsistOf("shared-warning-1", "shared-warning-2", "private-warning-1", "private-warning-2")) 306 }) 307 }) 308 }) 309 310 Context("when no domains are provided", func() { 311 BeforeEach(func() { 312 domainNames = nil 313 }) 314 315 It("immediately returns", func() { 316 Expect(executeErr).ToNot(HaveOccurred()) 317 Expect(warnings).To(BeEmpty()) 318 Expect(domains).To(BeEmpty()) 319 320 Expect(fakeCloudControllerClient.GetSharedDomainsCallCount()).To(Equal(0)) 321 Expect(fakeCloudControllerClient.GetOrganizationPrivateDomainsCallCount()).To(Equal(0)) 322 }) 323 }) 324 325 Context("when looking up the shared domains errors", func() { 326 var expectedErr error 327 328 BeforeEach(func() { 329 expectedErr = errors.New("foobar") 330 fakeCloudControllerClient.GetSharedDomainsReturns(nil, ccv2.Warnings{"shared-warning-1", "shared-warning-2"}, expectedErr) 331 }) 332 333 It("returns errors and warnings", func() { 334 Expect(executeErr).To(MatchError(expectedErr)) 335 Expect(warnings).To(ConsistOf("shared-warning-1", "shared-warning-2")) 336 }) 337 }) 338 }) 339 340 Describe("GetSharedDomain", func() { 341 Context("when the shared domain exists", func() { 342 var expectedDomain ccv2.Domain 343 344 BeforeEach(func() { 345 expectedDomain = ccv2.Domain{ 346 GUID: "shared-domain-guid", 347 Name: "shared-domain", 348 } 349 fakeCloudControllerClient.GetSharedDomainReturns(expectedDomain, ccv2.Warnings{"shared domain warning"}, nil) 350 }) 351 352 It("returns the shared domain and all warnings", func() { 353 domain, warnings, err := actor.GetSharedDomain("shared-domain-guid") 354 Expect(err).NotTo(HaveOccurred()) 355 Expect(domain).To(Equal(Domain(expectedDomain))) 356 Expect(warnings).To(ConsistOf("shared domain warning")) 357 358 Expect(fakeCloudControllerClient.GetSharedDomainCallCount()).To(Equal(1)) 359 Expect(fakeCloudControllerClient.GetSharedDomainArgsForCall(0)).To(Equal("shared-domain-guid")) 360 }) 361 362 Context("when the domain has been looked up multiple times", func() { 363 It("caches the domain", func() { 364 domain, warnings, err := actor.GetSharedDomain("shared-domain-guid") 365 Expect(err).NotTo(HaveOccurred()) 366 Expect(domain).To(Equal(Domain(expectedDomain))) 367 Expect(warnings).To(ConsistOf("shared domain warning")) 368 369 domain, warnings, err = actor.GetSharedDomain("shared-domain-guid") 370 Expect(err).NotTo(HaveOccurred()) 371 Expect(domain).To(Equal(Domain(expectedDomain))) 372 Expect(warnings).To(BeEmpty()) 373 374 Expect(fakeCloudControllerClient.GetSharedDomainCallCount()).To(Equal(1)) 375 }) 376 }) 377 }) 378 379 Context("when the API returns a not found error", func() { 380 var expectedErr DomainNotFoundError 381 382 BeforeEach(func() { 383 expectedErr = DomainNotFoundError{GUID: "shared-domain-guid"} 384 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, ccv2.Warnings{"shared domain warning"}, ccerror.ResourceNotFoundError{}) 385 }) 386 387 It("returns a DomainNotFoundError and all warnings", func() { 388 domain, warnings, err := actor.GetSharedDomain("shared-domain-guid") 389 Expect(err).To(MatchError(expectedErr)) 390 Expect(domain).To(Equal(Domain{})) 391 Expect(warnings).To(ConsistOf("shared domain warning")) 392 }) 393 }) 394 395 Context("when the API returns any other error", func() { 396 var expectedErr error 397 398 BeforeEach(func() { 399 expectedErr = errors.New("shared domain error") 400 fakeCloudControllerClient.GetSharedDomainReturns(ccv2.Domain{}, ccv2.Warnings{"shared domain warning"}, expectedErr) 401 }) 402 403 It("returns the same error and all warnings", func() { 404 domain, warnings, err := actor.GetSharedDomain("shared-domain-guid") 405 Expect(err).To(MatchError(expectedErr)) 406 Expect(domain).To(Equal(Domain{})) 407 Expect(warnings).To(ConsistOf("shared domain warning")) 408 }) 409 }) 410 }) 411 412 Describe("GetPrivateDomain", func() { 413 Context("when the private domain exists", func() { 414 var expectedDomain ccv2.Domain 415 416 BeforeEach(func() { 417 expectedDomain = ccv2.Domain{ 418 GUID: "private-domain-guid", 419 Name: "private-domain", 420 } 421 fakeCloudControllerClient.GetPrivateDomainReturns(expectedDomain, ccv2.Warnings{"private domain warning"}, nil) 422 }) 423 424 It("returns the private domain and all warnings", func() { 425 domain, warnings, err := actor.GetPrivateDomain("private-domain-guid") 426 Expect(err).NotTo(HaveOccurred()) 427 Expect(domain).To(Equal(Domain(expectedDomain))) 428 Expect(warnings).To(ConsistOf("private domain warning")) 429 430 Expect(fakeCloudControllerClient.GetPrivateDomainCallCount()).To(Equal(1)) 431 Expect(fakeCloudControllerClient.GetPrivateDomainArgsForCall(0)).To(Equal("private-domain-guid")) 432 }) 433 434 Context("when the domain has been looked up multiple times", func() { 435 It("caches the domain", func() { 436 domain, warnings, err := actor.GetPrivateDomain("private-domain-guid") 437 Expect(err).NotTo(HaveOccurred()) 438 Expect(domain).To(Equal(Domain(expectedDomain))) 439 Expect(warnings).To(ConsistOf("private domain warning")) 440 441 domain, warnings, err = actor.GetPrivateDomain("private-domain-guid") 442 Expect(err).NotTo(HaveOccurred()) 443 Expect(domain).To(Equal(Domain(expectedDomain))) 444 Expect(warnings).To(BeEmpty()) 445 446 Expect(fakeCloudControllerClient.GetPrivateDomainCallCount()).To(Equal(1)) 447 }) 448 }) 449 }) 450 451 Context("when the API returns a not found error", func() { 452 var expectedErr DomainNotFoundError 453 454 BeforeEach(func() { 455 expectedErr = DomainNotFoundError{GUID: "private-domain-guid"} 456 fakeCloudControllerClient.GetPrivateDomainReturns(ccv2.Domain{}, ccv2.Warnings{"private domain warning"}, ccerror.ResourceNotFoundError{}) 457 }) 458 459 It("returns a DomainNotFoundError and all warnings", func() { 460 domain, warnings, err := actor.GetPrivateDomain("private-domain-guid") 461 Expect(err).To(MatchError(expectedErr)) 462 Expect(domain).To(Equal(Domain{})) 463 Expect(warnings).To(ConsistOf("private domain warning")) 464 }) 465 }) 466 467 Context("when the API returns any other error", func() { 468 var expectedErr error 469 470 BeforeEach(func() { 471 expectedErr = errors.New("private domain error") 472 fakeCloudControllerClient.GetPrivateDomainReturns(ccv2.Domain{}, ccv2.Warnings{"private domain warning"}, expectedErr) 473 }) 474 475 It("returns the same error and all warnings", func() { 476 domain, warnings, err := actor.GetPrivateDomain("private-domain-guid") 477 Expect(err).To(MatchError(expectedErr)) 478 Expect(domain).To(Equal(Domain{})) 479 Expect(warnings).To(ConsistOf("private domain warning")) 480 }) 481 }) 482 }) 483 484 Describe("GetOrganizationDomains", func() { 485 Context("when the organization has both shared and private domains", func() { 486 BeforeEach(func() { 487 sharedDomain := ccv2.Domain{ 488 Name: "some-shared-domain", 489 } 490 privateDomain := ccv2.Domain{ 491 Name: "some-private-domain", 492 } 493 otherPrivateDomain := ccv2.Domain{ 494 Name: "some-other-private-domain", 495 } 496 497 fakeCloudControllerClient.GetSharedDomainsReturns([]ccv2.Domain{sharedDomain}, ccv2.Warnings{"shared domains warning"}, nil) 498 fakeCloudControllerClient.GetOrganizationPrivateDomainsReturns([]ccv2.Domain{privateDomain, otherPrivateDomain}, ccv2.Warnings{"private domains warning"}, nil) 499 }) 500 501 It("returns a concatenated slice with private then shared domains", func() { 502 domains, warnings, err := actor.GetOrganizationDomains("some-org-guid") 503 Expect(err).NotTo(HaveOccurred()) 504 Expect(domains).To(Equal([]Domain{ 505 {Name: "some-shared-domain"}, 506 {Name: "some-private-domain"}, 507 {Name: "some-other-private-domain"}, 508 })) 509 Expect(warnings).To(ConsistOf("shared domains warning", "private domains warning")) 510 511 Expect(fakeCloudControllerClient.GetSharedDomainsCallCount()).To(Equal(1)) 512 513 Expect(fakeCloudControllerClient.GetOrganizationPrivateDomainsCallCount()).To(Equal(1)) 514 orgGUID, query := fakeCloudControllerClient.GetOrganizationPrivateDomainsArgsForCall(0) 515 Expect(orgGUID).To(Equal("some-org-guid")) 516 Expect(query).To(BeEmpty()) 517 }) 518 }) 519 520 Context("when get shared domains returns an error", func() { 521 var expectedErr error 522 523 BeforeEach(func() { 524 expectedErr = errors.New("shared domains error") 525 fakeCloudControllerClient.GetSharedDomainsReturns([]ccv2.Domain{}, ccv2.Warnings{"shared domains warning"}, expectedErr) 526 }) 527 528 It("returns that error", func() { 529 domains, warnings, err := actor.GetOrganizationDomains("some-org-guid") 530 Expect(err).To(MatchError(expectedErr)) 531 Expect(domains).To(Equal([]Domain{})) 532 Expect(warnings).To(ConsistOf("shared domains warning")) 533 }) 534 }) 535 536 Context("when get organization private domains returns an error", func() { 537 var expectedErr error 538 539 BeforeEach(func() { 540 expectedErr = errors.New("private domains error") 541 fakeCloudControllerClient.GetOrganizationPrivateDomainsReturns([]ccv2.Domain{}, ccv2.Warnings{"private domains warning"}, expectedErr) 542 }) 543 544 It("returns that error", func() { 545 domains, warnings, err := actor.GetOrganizationDomains("some-org-guid") 546 Expect(err).To(MatchError(expectedErr)) 547 Expect(domains).To(Equal([]Domain{})) 548 Expect(warnings).To(ConsistOf("private domains warning")) 549 }) 550 }) 551 }) 552 })