"port": "3306",
"database": "fake-db-name",
"uri": "mysql://*****:*****@fake-host:3306/fake-db-name",
},
}
})
It("deletes service key successfully when '-f' option is provided", func() {
Expect(callDeleteServiceKey([]string{"fake-service-instance", "fake-service-key", "-f"})).To(BeTrue())
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Deleting key", "fake-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
[]string{"OK"}))
})
It("deletes service key successfully when '-f' option is not provided and confirmed 'yes'", func() {
ui.Inputs = append(ui.Inputs, "yes")
Expect(callDeleteServiceKey([]string{"fake-service-instance", "fake-service-key"})).To(BeTrue())
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete the service key", "fake-service-key"}))
Expect(ui.Outputs()).To(ContainSubstrings(
[]string{"Deleting key", "fake-service-key", "for service instance", "fake-service-instance", "as", "my-user"},
[]string{"OK"}))
})
It("skips to delete service key when '-f' option is not provided and confirmed 'no'", func() {
ui.Inputs = append(ui.Inputs, "no")
Expect(callDeleteServiceKey([]string{"fake-service-instance", "fake-service-key"})).To(BeTrue())
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete the service key", "fake-service-key"}))
Expect(ui.Outputs()).To(BeEmpty())
})
})
It("tries to create the user provided service instance with the credentials", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
Expect(serviceInstanceRepo.CreateCallCount()).To(Equal(1))
_, _, _, credentialsMap := serviceInstanceRepo.CreateArgsForCall(0)
Expect(credentialsMap).To(Equal(map[string]interface{}{
"some": "json",
}))
})
})
Context("when the -p flag is passed with inline JSON", func() {
BeforeEach(func() {
flagContext.Parse("service-instance", "-p", `key1,key2`)
ui.Inputs = []string{"value1", "value2"}
})
It("prompts the user for the values", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
Expect(ui.Prompts).To(ContainSubstrings(
[]string{"key1"},
[]string{"key2"},
))
})
It("tries to create the user provided service instance with the credentials", func() {
Expect(runCLIErr).NotTo(HaveOccurred())
Expect(serviceInstanceRepo.CreateCallCount()).To(Equal(1))
_, _, _, credentialsMap := serviceInstanceRepo.CreateArgsForCall(0)
It("deletes a user with the given name", func() {
runCommand("user-name")
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete the user user-name"}))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting user", "user-name", "admin-user"},
[]string{"OK"},
))
Expect(userRepo.FindByUsernameArgsForCall(0)).To(Equal("user-name"))
Expect(userRepo.DeleteArgsForCall(0)).To(Equal("user-guid"))
})
It("does not delete the user when no confirmation is given", func() {
ui.Inputs = []string{"nope"}
runCommand("user")
Expect(ui.Prompts).To(ContainSubstrings([]string{"Really delete"}))
Expect(userRepo.FindByUsernameCallCount()).To(BeZero())
Expect(userRepo.DeleteCallCount()).To(BeZero())
})
It("deletes without confirmation when the -f flag is given", func() {
ui.Inputs = []string{}
runCommand("-f", "user-name")
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting user", "user-name"},
[]string{"OK"},
))
Expect(requirementsFactory.ServiceInstanceName).To(Equal("service-name"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Updating user provided service", "service-name", "my-org", "my-space", "my-user"},
[]string{"OK"},
[]string{"TIP"},
))
Expect(serviceRepo.UpdateArgsForCall(0).Name).To(Equal("service-name"))
Expect(serviceRepo.UpdateArgsForCall(0).Params).To(Equal(map[string]interface{}{"foo": "bar"}))
Expect(serviceRepo.UpdateArgsForCall(0).SysLogDrainUrl).To(Equal("syslog://example.com"))
})
})
It("accepts service parameters interactively", func() {
ui.Inputs = []string{"foo value", "bar value", "baz value"}
runCommand("-p", "foo, bar, baz", "my-custom-service")
Expect(ui.Prompts).To(ContainSubstrings(
[]string{"foo"},
[]string{"bar"},
[]string{"baz"},
))
Expect(serviceRepo.UpdateCallCount()).To(Equal(1))
serviceInstanceFields := serviceRepo.UpdateArgsForCall(0)
Expect(serviceInstanceFields.Params).To(Equal(map[string]interface{}{
"foo": "foo value",
"bar": "bar value",
"baz": "baz value",
}))
Expect(ui.Prompts).To(BeEmpty())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting service broker", "service-broker-to-delete", "my-user"},
[]string{"OK"},
))
})
})
Context("when the service broker does not exist", func() {
BeforeEach(func() {
brokerRepo.FindByNameReturns(models.ServiceBroker{}, errors.NewModelNotFoundError("Service Broker", "service-broker-to-delete"))
})
It("warns the user", func() {
ui.Inputs = []string{}
runCommand("-f", "service-broker-to-delete")
Expect(brokerRepo.FindByNameCallCount()).To(Equal(1))
Expect(brokerRepo.FindByNameArgsForCall(0)).To(Equal("service-broker-to-delete"))
Expect(brokerRepo.DeleteCallCount()).To(BeZero())
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting service broker", "service-broker-to-delete"},
[]string{"OK"},
))
Expect(ui.WarnOutputs).To(ContainSubstrings([]string{"service-broker-to-delete", "does not exist"}))
})
})
})
It("fails requirements when called without a quota name", func() {
runCommand()
Expect(ui.FailedWithUsage).To(BeTrue())
})
Context("When the quota provided exists", func() {
BeforeEach(func() {
quota := models.QuotaFields{}
quota.Name = "my-quota"
quota.Guid = "my-quota-guid"
quotaRepo.FindByNameReturns.Quota = quota
})
It("deletes a quota with a given name when the user confirms", func() {
ui.Inputs = []string{"y"}
runCommand("my-quota")
Expect(quotaRepo.DeleteCalledWith.Guid).To(Equal("my-quota-guid"))
Expect(ui.Prompts).To(ContainSubstrings(
[]string{"Really delete the quota", "my-quota"},
))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting quota", "my-quota", "my-user"},
[]string{"OK"},
))
})
It("does not prompt when the -f flag is provided", func() {
orgRepo.ListOrgsReturns([]models.Organization{org1, org2}, nil)
spaceRepo.ListSpacesStub = listSpacesStub([]models.Space{space1, space2})
spaceRepo.FindByNameStub = func(name string) (models.Space, error) {
m := map[string]models.Space{
space1.Name: space1,
space2.Name: space2,
}
return m[name], nil
}
})
It("lets the user select an org and space by number", func() {
orgRepo.FindByNameReturns(org2, nil)
OUT_OF_RANGE_CHOICE := "3"
ui.Inputs = []string{"api.example.com", "*****@*****.**", "password", OUT_OF_RANGE_CHOICE, "2", OUT_OF_RANGE_CHOICE, "1"}
testcmd.RunCLICommand("login", Flags, nil, updateCommandDependency, false)
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Select an org"},
[]string{"1. some-org"},
[]string{"2. my-new-org"},
[]string{"Select a space"},
[]string{"1. my-space"},
[]string{"2. some-space"},
))
Expect(Config.OrganizationFields().GUID).To(Equal("my-new-org-guid"))
Expect(Config.SpaceFields().GUID).To(Equal("my-space-guid"))
Expect(Config.AccessToken()).To(Equal("my_access_token"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Showing", "my-app", "my-org", "my-space", "my-user"},
[]string{"OK"},
[]string{"memory", "256M"},
[]string{"disk", "1G"},
[]string{"instances", "42"},
))
Expect(ui.Outputs).ToNot(ContainSubstrings([]string{"Scaling", "my-app", "my-org", "my-space", "my-user"}))
})
})
Context("when the user does not confirm 'yes'", func() {
It("does not restart the app", func() {
ui.Inputs = []string{"whatever"}
testcmd.RunCommand(cmd, []string{"-i", "5", "-m", "512M", "-k", "2G", "my-app"}, requirementsFactory)
Expect(restarter.ApplicationRestartCallCount()).To(Equal(0))
})
})
Context("when the user provides the -f flag", func() {
It("does not prompt the user", func() {
testcmd.RunCommand(cmd, []string{"-f", "-i", "5", "-m", "512M", "-k", "2G", "my-app"}, requirementsFactory)
application, orgName, spaceName := restarter.ApplicationRestartArgsForCall(0)
Expect(application).To(Equal(app))
Expect(orgName).To(Equal(config.OrganizationFields().Name))
Expect(spaceName).To(Equal(config.SpaceFields().Name))
})
runCommand("foo.com")
Expect(domainRepo.DeleteDomainGuid).To(Equal("foo-guid"))
Expect(ui.Outputs).To(ContainSubstrings(
[]string{"Deleting domain", "foo.com"},
[]string{"FAILED"},
[]string{"foo.com"},
[]string{"failed badly"},
))
})
})
Context("when the user does not confirm", func() {
BeforeEach(func() {
ui.Inputs = []string{"no"}
})
It("does nothing", func() {
runCommand("foo.com")
Expect(domainRepo.DeleteDomainGuid).To(Equal(""))
Expect(ui.Prompts).To(ContainSubstrings([]string{"delete", "foo.com"}))
Expect(ui.Outputs).To(BeEmpty())
})
})
Context("when the user provides the -f flag", func() {
BeforeEach(func() {
Describe("requirements", func() {
It("requires you to be logged in", func() {
Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("requires five arguments to run", func() {
args = []string{"one", "two", "three"}
Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("requires CC API version 2.47 or greater", func() {
requirementsFactory.MaxAPIVersionSuccess = false
requirementsFactory.LoginSuccess = true
args = []string{"one", "two", "three", "four", "five"}
ui.Inputs = append(ui.Inputs, "no")
Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeFalse())
})
It("passes requirements if user is logged in and provided five args to run", func() {
requirementsFactory.MaxAPIVersionSuccess = true
requirementsFactory.LoginSuccess = true
args = []string{"one", "two", "three", "four", "five"}
ui.Inputs = append(ui.Inputs, "no")
Expect(testcmd.RunCLICommand("migrate-service-instances", args, requirementsFactory, updateCommandDependency, false)).To(BeTrue())
})
})
Describe("migrating service instances", func() {
space = maker.NewSpace(maker.Overrides{
"name": "space-to-delete",
"guid": "space-to-delete-guid",
})
requirementsFactory = &testreq.FakeReqFactory{
LoginSuccess: true,
TargetedOrgSuccess: true,
Space: space,
}
})
Describe("requirements", func() {
BeforeEach(func() {
ui.Inputs = []string{"y"}
})
It("fails when not logged in", func() {
requirementsFactory.LoginSuccess = false
Expect(runCommand("my-space")).To(BeFalse())
})
It("fails when not targeting a space", func() {
requirementsFactory.TargetedOrgSuccess = false
Expect(runCommand("my-space")).To(BeFalse())
})
})
It("deletes a space, given its name", func() {