targetedOrganizationReq := new(requirementsfakes.FakeTargetedOrgRequirement)
targetedOrganizationReq.ExecuteReturns(errors.New("not targeted"))
requirementsFactory.NewTargetedOrgRequirementReturns(targetedOrganizationReq)
Expect(runCommand("foo.com")).To(BeFalse())
})
})
Context("when the domain is owned", func() {
BeforeEach(func() {
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
requirementsFactory.NewTargetedOrgRequirementReturns(new(requirementsfakes.FakeTargetedOrgRequirement))
domainRepo.FindByNameInOrgReturns(
models.DomainFields{
Name: "foo1.com",
GUID: "foo1-guid",
Shared: false,
}, nil)
})
It("informs the user that the domain is not shared", func() {
runCommand("foo1.com")
Expect(domainRepo.DeleteSharedDomainCallCount()).To(BeZero())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"domain"},
[]string{"foo1.com"},
[]string{"is an owned domain, not a shared domain."},
[]string{"TIP"},
[]string{"Use `cf delete-domain` to delete owned domains."},
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("DomainRequirement", func() {
var config coreconfig.ReadWriter
BeforeEach(func() {
config = testconfig.NewRepository()
config.SetOrganizationFields(models.OrganizationFields{GUID: "the-org-guid"})
})
It("succeeds when the domain is found", func() {
domain := models.DomainFields{Name: "example.com", GUID: "domain-guid"}
domainRepo := new(apifakes.FakeDomainRepository)
domainRepo.FindByNameInOrgReturns(domain, nil)
domainReq := NewDomainRequirement("example.com", config, domainRepo)
err := domainReq.Execute()
Expect(err).NotTo(HaveOccurred())
orgName, orgGUID := domainRepo.FindByNameInOrgArgsForCall(0)
Expect(orgName).To(Equal("example.com"))
Expect(orgGUID).To(Equal("the-org-guid"))
Expect(domainReq.GetDomain()).To(Equal(domain))
})
It("fails when the domain is not found", func() {
domainRepo := new(apifakes.FakeDomainRepository)
domainRepo.FindByNameInOrgReturns(models.DomainFields{}, errors.NewModelNotFoundError("Domain", ""))
domainReq := NewDomainRequirement("example.com", config, domainRepo)
Expect(runCommand("foo.com")).To(BeFalse())
})
It("fails when the an org is not targetted", func() {
requirementsFactory.TargetedOrgSuccess = false
Expect(runCommand("foo.com")).To(BeFalse())
})
})
Context("when the domain is shared", func() {
BeforeEach(func() {
domainRepo.FindByNameInOrgReturns(
models.DomainFields{
Name: "foo1.com",
GUID: "foo1-guid",
Shared: true,
}, nil)
})
It("informs the user that the domain is shared", func() {
runCommand("foo1.com")
Expect(domainRepo.DeleteCallCount()).To(BeZero())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"domain"},
[]string{"foo1.com"},
[]string{"is a shared domain, not an owned domain."},
[]string{"TIP"},
[]string{"Use `cf delete-shared-domain` to delete shared domains."},
))
Expect(domainRepo.FindByNameInOrgCallCount()).To(Equal(1))
domainName, orgGUID := domainRepo.FindByNameInOrgArgsForCall(0)
Expect(domainName).To(Equal("domain-name"))
Expect(orgGUID).To(Equal("fake-org-guid"))
})
Context("when it finds the domain successfully", func() {
var actualDomain models.DomainFields
BeforeEach(func() {
actualDomain = models.DomainFields{
GUID: "domain-guid",
Name: "domain-name",
}
domainRepo.FindByNameInOrgReturns(actualDomain, nil)
})
It("checks if the route exists", func() {
Expect(err).NotTo(HaveOccurred())
Expect(routeRepo.CheckIfExistsCallCount()).To(Equal(1))
hostName, domain, path := routeRepo.CheckIfExistsArgsForCall(0)
Expect(hostName).To(Equal("host-name"))
Expect(actualDomain).To(Equal(domain))
Expect(path).To(Equal(""))
})
Context("when a path is passed", func() {
BeforeEach(func() {
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
err := flagContext.Parse("hostname", "domain-name", "--path", "the-path")