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 command exists and the correct flags are passed", 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 any of the command requirements fails", func() {
It("returns an error", func() {
err := NewCommandRunner().Command([]string{"fake-command2"}, deps, false)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(ContainSubstring("Requirement executed and failed"))
})
})
Context("when invalid flags are provided", func() {
Expect(err).NotTo(HaveOccurred())
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")
err := cmd.Execute(flagContext)
Expect(err).NotTo(HaveOccurred())
Expect(fakeUI.SayCallCount()).To(Equal(1))
output, _ := fakeUI.SayArgsForCall(0)
Expect(output).To(ContainSubstring("target - Set or view the targeted org or space"))
})
Context("i18n translations", func() {
var originalT func(string, ...interface{}) string
BeforeEach(func() {
originalT = i18n.T
})
AfterEach(func() {
i18n.T = originalT
})
It("includes ':' in caption translation strings for language like French to be translated correctly", func() {
It("calls Create on the route repo", func() {
routeActor.CreateRandomTCPRoute(expectedDomain)
host, d, path, port, randomPort := fakeRouteRepository.CreateArgsForCall(0)
Expect(host).To(BeEmpty())
Expect(d).To(Equal(expectedDomain))
Expect(path).To(BeEmpty())
Expect(port).To(Equal(0))
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))
b = make([]byte, 1024)
progressReader = NewProgressReader(testFile, ui, 1*time.Millisecond)
progressReader.SetTotalSize(fileStat.Size())
})
It("prints progress while content is being read", func() {
for {
time.Sleep(50 * time.Microsecond)
_, err := progressReader.Read(b)
if err != nil {
break
}
}
Expect(ui.SayCallCount()).To(Equal(1))
Expect(ui.SayArgsForCall(0)).To(ContainSubstring("\rDone "))
Expect(ui.PrintCapturingNoOutputCallCount()).To(BeNumerically(">", 0))
status, _ := ui.PrintCapturingNoOutputArgsForCall(0)
Expect(status).To(ContainSubstring("uploaded..."))
status, _ = ui.PrintCapturingNoOutputArgsForCall(ui.PrintCapturingNoOutputCallCount() - 1)
Expect(status).To(Equal("\r "))
})
It("reads the correct number of bytes", func() {
bytesRead := 0
for {
n, err := progressReader.Read(b)
if err != nil {
break
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() {
