Expect(factory.NewLoginRequirementCallCount()).To(Equal(1))
Expect(actualRequirements).To(ContainElement(loginRequirement))
})
It("returns an OrgRequirement", func() {
actualRequirements := cmd.Requirements(factory, flagContext)
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 unset_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 unset_roles_by_username flag exists and is enabled", func() {
BeforeEach(func() {
flagRepo.FindByNameReturns(models.FeatureFlag{Enabled: true}, nil)
})
It("returns a UserRequirement", func() {
actualRequirements := cmd.Requirements(factory, flagContext)
Expect(ui.Outputs).To(BeInDisplayOrder(
[]string{"Getting users in org", "Org1", "Space1", "my-user"},
[]string{"SPACE MANAGER"},
[]string{"user1"},
[]string{"user2"},
[]string{"SPACE DEVELOPER"},
[]string{"user4"},
[]string{"SPACE AUDITOR"},
[]string{"user3"},
))
})
Context("when cc api verson is >= 2.21.0", func() {
BeforeEach(func() {
configRepo.SetAPIVersion("2.22.0")
})
It("calls ListUsersInSpaceForRoleWithNoUAA()", func() {
runCommand("my-org", "my-sapce")
Expect(userRepo.ListUsersInSpaceForRoleWithNoUAACallCount()).To(BeNumerically(">=", 1))
Expect(userRepo.ListUsersInSpaceForRoleCallCount()).To(Equal(0))
})
It("fails with an error when user network call fails", func() {
userRepo.ListUsersInSpaceForRoleWithNoUAAStub = func(_ string, role models.Role) ([]models.UserFields, error) {
if role == models.RoleSpaceManager {
return []models.UserFields{}, errors.New("internet badness occurred")
}
return []models.UserFields{}, nil
Expect(err).ToNot(HaveOccurred())
Expect(result).To(Equal("doppler-endpoint-sample"))
})
})
Context(".ApiEndpoint, .ApiVersion and .HasAPIEndpoint", func() {
BeforeEach(func() {
rpcService, err = NewRpcService(nil, nil, config, api.RepositoryLocator{}, nil, nil, nil, rpc.DefaultServer)
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
config coreconfig.Repository
requirement requirements.MinAPIVersionRequirement
)
BeforeEach(func() {
config = testconfig.NewRepository()
requiredVersion, err := semver.Make("1.2.3")
Expect(err).NotTo(HaveOccurred())
requirement = requirements.NewMinAPIVersionRequirement(config, "version-restricted-feature", 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("succeeds", func() {
err := requirement.Execute()
Expect(err).NotTo(HaveOccurred())
})
})
Context("when the config's api version is equal to the required version", func() {
BeforeEach(func() {
config.SetAPIVersion("1.2.3")
})
It("succeeds", func() {
err := requirement.Execute()
It("warns the user and prints out a tip", func() {
endpointRepo.GetCCInfoReturns(nil, "", errors.NewInvalidSSLCert("https://buttontomatoes.org", "why? no. go away"))
callApi([]string{"https://buttontomatoes.org"})
Expect(runCLIErr).To(HaveOccurred())
Expect(runCLIErr.Error()).To(ContainSubstring("Invalid SSL Cert for https://buttontomatoes.org"))
Expect(runCLIErr.Error()).To(ContainSubstring("TIP"))
Expect(runCLIErr.Error()).To(ContainSubstring("--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{})
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"})
Expect(ui.Outputs()).To(ContainSubstrings(
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())
cmd.Requirements(factory, flagContext)
})
AfterEach(func() {
configRepo.SetAPIVersion(origAPIVersion)
})
It("tries to find the service offering by label and provider", func() {
ui.Inputs = []string{"n"}
cmd.Execute(flagContext)
Expect(serviceRepo.FindServiceOfferingByLabelAndProviderCallCount()).To(Equal(1))
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")
deps.Config = config
//inject fake 'command dependency' into registry
commandregistry.Register(orgRoleSetter)
commandregistry.Commands.SetCommand(commandregistry.Commands.FindCommand("create-org").SetDependency(deps, pluginCall))
}
BeforeEach(func() {
ui = &testterm.FakeUI{}
config = testconfig.NewRepositoryWithDefaults()
requirementsFactory = &testreq.FakeReqFactory{}
orgRepo = new(organizationsfakes.FakeOrganizationRepository)
quotaRepo = new(quotasfakes.FakeQuotaRepository)
flagRepo = new(featureflagsfakes.FakeFeatureFlagRepository)
config.SetAPIVersion("2.36.9")
orgRoleSetter = new(userfakes.FakeOrgRoleSetter)
//setup fakes to correctly interact with commandregistry
orgRoleSetter.SetDependencyStub = func(_ commandregistry.Dependency, _ bool) commandregistry.Command {
return orgRoleSetter
}
orgRoleSetter.MetaDataReturns(commandregistry.CommandMetadata{Name: "set-org-role"})
//save original command and restore later
OriginalCommand = commandregistry.Commands.FindCommand("set-org-role")
})
AfterEach(func() {
commandregistry.Register(OriginalCommand)
})