cmd := commandregistry.Commands.FindCommand("fake-command")
commandregistry.Commands.SetCommand(cmd.SetDependency(deps, true))
cmd2 := commandregistry.Commands.FindCommand("fake-command2")
commandregistry.Commands.SetCommand(cmd2.SetDependency(deps, true))
})
Context("when not expecting the command to fail", func() {
BeforeEach(func() {
err := NewCommandRunner().Command([]string{"fake-command"}, deps, false)
Expect(err).NotTo(HaveOccurred())
})
It("should set dependencies, execute requirements, and execute the command", func() {
Expect(ui.SayArgsForCall(0)).To(ContainSubstring("SetDependency() called, pluginCall true"))
Expect(ui.SayArgsForCall(1)).To(ContainSubstring("SetDependency() called, pluginCall false"))
Expect(ui.SayArgsForCall(2)).To(ContainSubstring("Requirement executed"))
Expect(ui.SayArgsForCall(3)).To(ContainSubstring("Command Executed"))
})
})
Context("when expecting the command to fail", func() {
It("returns an error if any of the requirements fail", func() {
err := NewCommandRunner().Command([]string{"fake-command2"}, deps, false)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Requirement executed and failed"))
})
It("returns an error if invalid flag is provided", func() {
err := NewCommandRunner().Command([]string{"fake-command", "-badFlag"}, deps, false)
flagContext.Parse()
cmd.Execute(flagContext)
Eventually(buffer.Contents()).Should(ContainSubstring("A command line tool to interact with Cloud Foundry"))
Eventually(buffer).Should(gbytes.Say("CF_TRACE=true"))
})
})
Context("when a command name is provided as an argument", func() {
Context("When the command exists", func() {
It("prints the usage help for the command", func() {
flagContext.Parse("target")
cmd.Execute(flagContext)
Expect(fakeUI.SayCallCount()).To(Equal(1))
output, _ := fakeUI.SayArgsForCall(0)
Expect(output).To(ContainSubstring("target - Set or view the targeted org or space"))
})
})
Context("When the command does not exists", func() {
It("prints the usage help for the command", func() {
flagContext.Parse("bad-command")
cmd.Execute(flagContext)
Expect(fakeUI.FailedCallCount()).To(Equal(1))
output, _ := fakeUI.FailedArgsForCall(0)
Expect(output).To(ContainSubstring("'bad-command' is not a registered command. See 'cf help'"))
})
})
})
var _ = Describe("Panic Printer", func() {
var (
ui *terminalfakes.FakeUI
panicPrinter PanicPrinter
)
BeforeEach(func() {
ui = new(terminalfakes.FakeUI)
panicPrinter = NewPanicPrinter(ui)
})
Describe("DisplayCrashDialog", func() {
It("includes the error message when given an error", func() {
panicPrinter.DisplayCrashDialog(errors.New("some-error"), "some command", "some trace")
Expect(ui.SayCallCount()).To(Equal(1))
Expect(ui.SayArgsForCall(0)).To(Equal(CrashDialog("some-error", "some command", "some trace")))
})
It("includes the string when given a string that is not terminal.QuietPanic", func() {
panicPrinter.DisplayCrashDialog("some-error", "some command", "some trace")
Expect(ui.SayCallCount()).To(Equal(1))
Expect(ui.SayArgsForCall(0)).To(Equal(CrashDialog("some-error", "some command", "some trace")))
})
It("prints the unexpected error type message when not given a string or an error", func() {
panicPrinter.DisplayCrashDialog(struct{}{}, "some command", "some trace")
Expect(ui.SayCallCount()).To(Equal(1))
Expect(ui.SayArgsForCall(0)).To(ContainSubstring("An unexpected type of error"))
})
It("includes the error message when given an errors.Exception", func() {
It("calls Create on the route repo", func() {
routeActor.CreateRandomTCPRoute(expectedDomain)
host, d, path, randomPort := fakeRouteRepository.CreateArgsForCall(0)
Expect(host).To(BeEmpty())
Expect(d).To(Equal(expectedDomain))
Expect(path).To(BeEmpty())
Expect(randomPort).To(BeTrue())
})
It("states that a route is being created", func() {
routeActor.CreateRandomTCPRoute(expectedDomain)
Expect(fakeUI.SayCallCount()).To(Equal(1))
Expect(fakeUI.SayArgsForCall(0)).To(ContainSubstring("Creating random route for"))
})
It("returns the route retrieved from the repository", func() {
actualRoute, err := routeActor.CreateRandomTCPRoute(expectedDomain)
Expect(err).NotTo(HaveOccurred())
Expect(actualRoute).To(Equal(expectedRoute))
})
It("prints an error when creating the route fails", func() {
expectedError := errors.New("big bad error message")
fakeRouteRepository.CreateReturns(models.Route{}, expectedError)
actualRoute, err := routeActor.CreateRandomTCPRoute(expectedDomain)
Expect(err).To(Equal(expectedError))
It("calls Create on the route repo", func() {
routeActor.CreateRandomTCPRoute(domain)
host, d, path, randomPort := fakeRouteRepository.CreateArgsForCall(0)
Expect(host).To(BeEmpty())
Expect(d).To(Equal(domain))
Expect(path).To(BeEmpty())
Expect(randomPort).To(BeTrue())
})
It("states that a route is being created", func() {
routeActor.CreateRandomTCPRoute(domain)
Expect(fakeUI.SayCallCount()).To(Equal(1))
Expect(fakeUI.SayArgsForCall(0)).To(ContainSubstring("Creating random route for"))
})
It("returns the route retrieved from the repository", func() {
actualRoute, err := routeActor.CreateRandomTCPRoute(domain)
Expect(err).NotTo(HaveOccurred())
Expect(actualRoute).To(Equal(route))
})
It("prints an error when creating the route fails", func() {
expectedError := errors.New("big bad error message")
fakeRouteRepository.CreateReturns(models.Route{}, expectedError)
actualRoute, err := routeActor.CreateRandomTCPRoute(domain)
Expect(err).To(Equal(expectedError))