runCommand("-a", "the-org")
orgGuid, _ := userRepo.ListUsersInOrgForRoleArgsForCall(0)
Expect(orgGuid).To(Equal("the-org-guid"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Getting users in org", "the-org", "my-user"},
[]string{"USERS"},
[]string{"user1"},
[]string{"user2"},
))
})
})
Context("when cc api verson is >= 2.21.0", func() {
It("calls ListUsersInOrgForRoleWithNoUAA()", func() {
configRepo.SetApiVersion("2.22.0")
runCommand("the-org")
Expect(userRepo.ListUsersInOrgForRoleWithNoUAACallCount()).To(BeNumerically(">=", 1))
Expect(userRepo.ListUsersInOrgForRoleCallCount()).To(Equal(0))
})
})
Context("when cc api verson is < 2.21.0", func() {
It("calls ListUsersInOrgForRole()", func() {
configRepo.SetApiVersion("2.20.0")
runCommand("the-org")
Expect(userRepo.ListUsersInOrgForRoleWithNoUAACallCount()).To(Equal(0))
Expect(userRepo.ListUsersInOrgForRoleCallCount()).To(BeNumerically(">=", 1))
})
Expect(actualRequirements).To(ContainElement(loginRequirement))
})
It("returns an OrgRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
Expect(factory.NewOrganizationRequirementCallCount()).To(Equal(1))
Expect(factory.NewOrganizationRequirementArgsForCall(0)).To(Equal("the-org-name"))
Expect(actualRequirements).To(ContainElement(organizationRequirement))
})
Context("when the config version is >=2.37.0", func() {
BeforeEach(func() {
configRepo.SetApiVersion("2.37.0")
})
It("requests the set_roles_by_username flag", func() {
cmd.Requirements(factory, flagContext)
Expect(flagRepo.FindByNameCallCount()).To(Equal(1))
Expect(flagRepo.FindByNameArgsForCall(0)).To(Equal("unset_roles_by_username"))
})
Context("when the set_roles_by_username flag exists and is enabled", func() {
BeforeEach(func() {
flagRepo.FindByNameReturns(models.FeatureFlag{Enabled: true}, nil)
})
It("returns a UserRequirement", func() {
actualRequirements, err := cmd.Requirements(factory, flagContext)
requirement requirements.MinAPIVersionRequirement
)
BeforeEach(func() {
ui = new(testterm.FakeUI)
config = testconfig.NewRepository()
requiredVersion, err := semver.Make("1.2.3")
Expect(err).NotTo(HaveOccurred())
requirement = requirements.NewMinAPIVersionRequirement(ui, config, "command-name", requiredVersion)
})
Context("Execute", func() {
Context("when the config's api version is greater than the required version", func() {
BeforeEach(func() {
config.SetApiVersion("1.2.4")
})
It("returns true", func() {
Expect(requirement.Execute()).To(BeTrue())
})
It("does not print anything", func() {
requirement.Execute()
Expect(ui.Outputs).To(BeEmpty())
})
})
Context("when the config's api version is equal to the required version", func() {
BeforeEach(func() {
config.SetApiVersion("1.2.3")
offering1 models.ServiceOffering
deps command_registry.Dependency
)
updateCommandDependency := func(pluginCall bool) {
deps.Ui = ui
deps.RepoLocator = deps.RepoLocator.SetServiceRepository(serviceRepo)
deps.Config = config
deps.PlanBuilder = planBuilder
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("update-service").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
config.SetApiVersion("2.26.0")
requirementsFactory = &testreq.FakeReqFactory{LoginSuccess: true, TargetedSpaceSuccess: true}
serviceRepo = &testapi.FakeServiceRepository{}
planBuilder = &testplanbuilder.FakePlanBuilder{}
offering1 = models.ServiceOffering{}
offering1.Label = "cleardb"
offering1.Plans = []models.ServicePlanFields{{
Name: "spark",
Guid: "cleardb-spark-guid",
}, {
Name: "flare",
Guid: "cleardb-flare-guid",
},
}
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("doppler-endpoint-sample"))
})
})
Context(".ApiEndpoint, .ApiVersion and .HasAPIEndpoint", func() {
BeforeEach(func() {
rpcService, err = NewRpcService(nil, nil, nil, config)
err := rpcService.Start()
Expect(err).ToNot(HaveOccurred())
pingCli(rpcService.Port())
})
It("returns the ApiEndpoint(), ApiVersion() and HasAPIEndpoint() setting in config", func() {
config.SetApiVersion("v1.1.1")
config.SetApiEndpoint("www.fake-domain.com")
client, err = rpc.Dial("tcp", "127.0.0.1:"+rpcService.Port())
Expect(err).ToNot(HaveOccurred())
var result string
err = client.Call("CliRpcCmd.ApiEndpoint", "", &result)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("www.fake-domain.com"))
err = client.Call("CliRpcCmd.ApiVersion", "", &result)
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("v1.1.1"))
var exists bool
close(finishReadCh)
}()
Consistently(finishSaveCh).ShouldNot(BeClosed())
Consistently(finishReadCh).ShouldNot(BeClosed())
performSaveCh <- struct{}{}
Eventually(finishReadCh).Should(BeClosed())
})
It("has acccessor methods for all config fields", func() {
config.SetApiEndpoint("http://api.the-endpoint")
Expect(config.ApiEndpoint()).To(Equal("http://api.the-endpoint"))
config.SetApiVersion("3")
Expect(config.ApiVersion()).To(Equal("3"))
config.SetAuthenticationEndpoint("http://auth.the-endpoint")
Expect(config.AuthenticationEndpoint()).To(Equal("http://auth.the-endpoint"))
config.SetLoggregatorEndpoint("http://loggregator.the-endpoint")
Expect(config.LoggregatorEndpoint()).To(Equal("http://loggregator.the-endpoint"))
config.SetDopplerEndpoint("http://doppler.the-endpoint")
Expect(config.DopplerEndpoint()).To(Equal("http://doppler.the-endpoint"))
config.SetUaaEndpoint("http://uaa.the-endpoint")
Expect(config.UaaEndpoint()).To(Equal("http://uaa.the-endpoint"))
config.SetAccessToken("the-token")
endpointRepo.UpdateEndpointError = errors.NewInvalidSSLCert("https://buttontomatoes.org", "why? no. go away")
callApi([]string{"https://buttontomatoes.org"}, config, endpointRepo)
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"FAILED"},
[]string{"SSL Cert", "https://buttontomatoes.org"},
[]string{"TIP", "--skip-ssl-validation"},
))
})
})
Context("when the user does not provide an endpoint", func() {
Context("when the endpoint is set in the config", func() {
BeforeEach(func() {
config.SetApiEndpoint("https://api.run.pivotal.io")
config.SetApiVersion("2.0")
config.SetSSLDisabled(true)
})
It("prints out the api endpoint and appropriately sets the config", func() {
callApi([]string{}, config, endpointRepo)
Expect(ui.Outputs).To(ContainSubstrings([]string{"https://api.run.pivotal.io", "2.0"}))
Expect(config.IsSSLDisabled()).To(BeTrue())
})
Context("when the --unset flag is passed", func() {
It("unsets the ApiEndpoint", func() {
callApi([]string{"--unset"}, config, endpointRepo)
Expect(ui.Outputs).To(ContainSubstrings(
var _ = Describe("CcApiVersion", func() {
var (
ui *testterm.FakeUI
config core_config.Repository
req CCApiVersionRequirement
)
BeforeEach(func() {
ui = new(testterm.FakeUI)
config = testconfig.NewRepository()
})
Describe("success", func() {
Describe("when the cc api version has only major version", func() {
BeforeEach(func() {
config.SetApiVersion("1")
req = NewCCApiVersionRequirement(ui, config, "command-name", 1, 0, 0)
})
It("should pass", func() {
Expect(req.Execute()).To(BeTrue())
})
})
Describe("when the cc api version has only major and minor versions", func() {
BeforeEach(func() {
config.SetApiVersion("1.1")
req = NewCCApiVersionRequirement(ui, config, "command-name", 1, 1, 0)
})
It("should pass", func() {
deps.Config = config
//inject fake 'command dependency' into registry
command_registry.Register(orgRoleSetter)
command_registry.Commands.SetCommand(command_registry.Commands.FindCommand("create-org").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
orgRepo = &test_org.FakeOrganizationRepository{}
quotaRepo = &test_quota.FakeQuotaRepository{}
flagRepo = &fakeflag.FakeFeatureFlagRepository{}
config.SetApiVersion("2.36.9")
orgRoleSetter = &userCmdFakes.FakeOrgRoleSetter{}
//setup fakes to correctly interact with command_registry
orgRoleSetter.SetDependencyStub = func(_ command_registry.Dependency, _ bool) command_registry.Command {
return orgRoleSetter
}
orgRoleSetter.MetaDataReturns(command_registry.CommandMetadata{Name: "set-org-role"})
//save original command and restore later
OriginalCommand = command_registry.Commands.FindCommand("set-org-role")
})
AfterEach(func() {
command_registry.Register(OriginalCommand)
})
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Service offering does not exist"},
))
})
It("does not try to purge the service offering", func() {
cmd.Execute(flagContext)
Expect(serviceRepo.PurgeServiceOfferingCallCount()).To(BeZero())
})
})
Context("when the -p flag is passed", func() {
var origAPIVersion string
BeforeEach(func() {
origAPIVersion = configRepo.ApiVersion()
configRepo.SetApiVersion("2.46.0")
flagContext = flags.NewFlagContext(cmd.MetaData().Flags)
err := flagContext.Parse("service-name", "-p", "provider-name")
Expect(err).NotTo(HaveOccurred())
_, err = cmd.Requirements(factory, flagContext)
Expect(err).NotTo(HaveOccurred())
})
AfterEach(func() {
configRepo.SetApiVersion(origAPIVersion)
})
It("tries to find the service offering by label and provider", func() {
ui.Inputs = []string{"n"}
cmd.Execute(flagContext)