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)
})
})
Context("when the doppler endpoint does not exist", func() {
It("should regex the loggregator endpoint value", func() {
config.SetLoggregatorEndpoint("http://loggregator.the-endpointffff")
config.SetDopplerEndpoint("http://doppler.the-endpoint")
Expect(config.DopplerEndpoint()).To(Equal("http://doppler.the-endpoint"))
})
})
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.SetUaaEndpoint("http://uaa.the-endpoint")
Expect(config.UaaEndpoint()).To(Equal("http://uaa.the-endpoint"))
config.SetAccessToken("the-token")
Expect(config.AccessToken()).To(Equal("the-token"))
config.SetSSHOAuthClient("oauth-client-id")
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))
})
//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 = new(requirementsfakes.FakeFactory)
requirementsFactory.NewLoginRequirementReturns(requirements.Passing{})
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)
})
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.MaxAPIVersionRequirement
)
BeforeEach(func() {
config = testconfig.NewRepository()
maximumVersion, err := semver.Make("1.2.3")
Expect(err).NotTo(HaveOccurred())
requirement = requirements.NewMaxAPIVersionRequirement(config, "version-restricted-feature", maximumVersion)
})
Context("Execute", func() {
Context("when the config's api version is less than the maximum version", func() {
BeforeEach(func() {
config.SetAPIVersion("1.2.2")
})
It("succeeds", func() {
err := requirement.Execute()
Expect(err).NotTo(HaveOccurred())
})
})
Context("when the config's api version is equal to the maximum version", func() {
BeforeEach(func() {
config.SetAPIVersion("1.2.3")
})
It("succeeds", func() {
err := requirement.Execute()
[]string{"Service offering does not exist"},
))
})
It("does not try to purge the service offering", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
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)
ui.Inputs = []string{"n"}
})
AfterEach(func() {
configRepo.SetAPIVersion(origAPIVersion)
})
It("tries to find the service offering by label and provider", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
Expect(serviceRepo.FindServiceOfferingByLabelAndProviderCallCount()).To(Equal(1))
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(