outputBuffer = gbytes.NewBuffer() terminalUI = terminal.NewUI(nil, outputBuffer, nil) fakeExitHandler = &fake_exit_handler.FakeExitHandler{} fakeSecureShell = &fake_secure_shell.FakeSecureShell{} }) Describe("SSHCommand", func() { var sshCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewSSHCommandFactory(config, terminalUI, fakeExitHandler, fakeSecureShell) sshCommand = commandFactory.MakeSSHCommand() }) It("should ssh to instance 0 given an app name", func() { test_helpers.ExecuteCommandWithArgs(sshCommand, []string{"app-name"}) Expect(outputBuffer).To(test_helpers.SayLine("Connecting to app-name/0 at %s", config.Target())) Expect(fakeSecureShell.ConnectToShellCallCount()).To(Equal(1)) appName, instanceIndex, command, actualConfig := fakeSecureShell.ConnectToShellArgsForCall(0) Expect(appName).To(Equal("app-name")) Expect(instanceIndex).To(Equal(0)) Expect(command).To(BeEmpty()) Expect(actualConfig).To(Equal(config)) }) It("should ssh to instance index specified", func() { test_helpers.ExecuteCommandWithArgs(sshCommand, []string{"--instance", "2", "app-name"}) Expect(outputBuffer).To(test_helpers.SayLine("Connecting to app-name/2 at %s", config.Target()))
}) Describe("TargetBlobCommand", func() { var targetBlobCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewConfigCommandFactory(config, terminalUI, fakeTargetVerifier, fakeExitHandler) targetBlobCommand = commandFactory.MakeTargetBlobCommand() }) Context("displaying the blob target", func() { It("outputs the current target", func() { config.SetBlobTarget("192.168.11.11", 8980, "datkeyyo", "supersecretJKJK", "bucket") config.Save() test_helpers.ExecuteCommandWithArgs(targetBlobCommand, []string{}) Expect(outputBuffer).To(test_helpers.Say("Blob Target:\t192.168.11.11:8980\n")) Expect(outputBuffer).To(test_helpers.Say("Access Key:\tdatkeyyo")) Expect(outputBuffer).To(test_helpers.Say("Secret Key:\tsupersecretJKJK")) Expect(outputBuffer).To(test_helpers.Say("Bucket Name:\tbucket")) }) It("alerts the user if no target is set", func() { config.SetBlobTarget("", 0, "", "", "") config.Save() test_helpers.ExecuteCommandWithArgs(targetBlobCommand, []string{}) Expect(outputBuffer).To(test_helpers.SayLine("Blob target not set")) })
Expect(newConfig.Receptor()).To(Equal("http://*****:*****@receptor.oldtarget.com")) } BeforeEach(func() { commandFactory := command_factory.NewConfigCommandFactory(config, terminalUI, fakeTargetVerifier, fakeBlobStoreVerifier, fakeExitHandler) targetCommand = commandFactory.MakeTargetCommand() config.SetTarget("oldtarget.com") config.SetLogin("olduser", "oldpass") Expect(config.Save()).To(Succeed()) }) Context("displaying the target", func() { JustBeforeEach(func() { test_helpers.ExecuteCommandWithArgs(targetCommand, []string{}) }) It("outputs the current user and target host", func() { Expect(outputBuffer).To(test_helpers.SayLine("Target:\t\[email protected]")) }) Context("when no username is set", func() { BeforeEach(func() { config.SetLogin("", "") Expect(config.Save()).To(Succeed()) }) It("only prints the target", func() { Expect(outputBuffer).To(test_helpers.SayLine("Target:\t\toldtarget.com")) })
var fakeClusterTestRunner *fake_cluster_test_runner.FakeClusterTestRunner BeforeEach(func() { fakeClusterTestRunner = &fake_cluster_test_runner.FakeClusterTestRunner{} }) Describe("MakeClusterTestCommand", func() { var clusterTestCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewClusterTestCommandFactory(fakeClusterTestRunner) clusterTestCommand = commandFactory.MakeClusterTestCommand() }) It("prints the integration test run output and args", func() { test_helpers.ExecuteCommandWithArgs(clusterTestCommand, []string{"--timeout=50s", "--verbose=true"}) Expect(fakeClusterTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg := fakeClusterTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Second * 50)) Expect(verboseArg).To(BeTrue()) }) It("has sane defaults", func() { test_helpers.ExecuteCommandWithArgs(clusterTestCommand, []string{}) Expect(fakeClusterTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg := fakeClusterTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Minute * 2)) Expect(verboseArg).To(BeFalse()) })
prevDir, err = os.Getwd() Expect(err).ToNot(HaveOccurred()) Expect(os.Chdir(tmpDir)).To(Succeed()) fakeCFIgnore.ShouldIgnoreStub = func(path string) bool { return path == "some-ignored-file" } }) AfterEach(func() { Expect(os.Chdir(prevDir)).To(Succeed()) Expect(os.RemoveAll(tmpDir)).To(Succeed()) }) It("tars up current working folder and uploads as the droplet name", func() { test_helpers.ExecuteCommandWithArgs(buildDropletCommand, []string{"droplet-name", "http://some.url/for/buildpack"}) Expect(outputBuffer).To(test_helpers.Say("Submitted build of droplet-name")) Expect(fakeDropletRunner.UploadBitsCallCount()).To(Equal(1)) dropletName, uploadPath := fakeDropletRunner.UploadBitsArgsForCall(0) Expect(dropletName).To(Equal("droplet-name")) Expect(uploadPath).ToNot(BeNil()) Expect(uploadPath).To(HaveSuffix(".tar")) buffer := make([]byte, 12) file, err := os.Open(uploadPath) Expect(err).ToNot(HaveOccurred()) tarReader := tar.NewReader(file) h, err := tarReader.Next()
) BeforeEach(func() { commandRan = false cliCommand = cli.Command{ Name: "exec", Action: func(*cli.Context) { commandRan = true }, } }) Describe("ExecuteCommandWithArgs", func() { It("executes the command", func() { test_helpers.ExecuteCommandWithArgs(cliCommand, []string{}) Expect(commandRan).To(BeTrue()) }) }) Describe("AsyncExecuteCommandWithArgs", func() { It("executes the command", func() { doneChan := test_helpers.AsyncExecuteCommandWithArgs(cliCommand, []string{}) Eventually(doneChan, 3).Should(BeClosed()) Expect(commandRan).To(BeTrue()) }) }) })
Context("when the archive path is a file and exists", func() { var ( tmpFile *os.File err error ) BeforeEach(func() { tmpDir := os.TempDir() tmpFile, err = ioutil.TempFile(tmpDir, "tmp_file") Expect(err).ToNot(HaveOccurred()) }) AfterEach(func() { os.RemoveAll(tmpFile.Name()) }) It("checks the file exists and calls the droplet runner", func() { test_helpers.ExecuteCommandWithArgs(uploadBitsCommand, []string{"droplet-name", tmpFile.Name()}) Expect(outputBuffer).To(test_helpers.Say("Successfully uploaded droplet-name")) Expect(fakeDropletRunner.UploadBitsCallCount()).To(Equal(1)) dropletName, uploadPath := fakeDropletRunner.UploadBitsArgsForCall(0) Expect(dropletName).To(Equal("droplet-name")) Expect(uploadPath).To(Equal(tmpFile.Name())) }) Context("when the droplet runner returns an error", func() { It("prints the error", func() { fakeDropletRunner.UploadBitsReturns(errors.New("uploading bits failed")) test_helpers.ExecuteCommandWithArgs(uploadBitsCommand, []string{"droplet-name", tmpFile.Name()}) Expect(outputBuffer).To(test_helpers.Say("Error uploading to droplet-name: uploading bits failed"))
}) Context("when the json file exists", func() { BeforeEach(func() { tmpDir = os.TempDir() tmpFile, err = ioutil.TempFile(tmpDir, "tmp_json") Expect(err).ToNot(HaveOccurred()) Expect(ioutil.WriteFile(tmpFile.Name(), []byte(`{"Value":"test value"}`), 0700)).To(Succeed()) }) It("creates an app from json", func() { fakeAppRunner.SubmitLrpReturns("my-json-app", nil) args := []string{tmpFile.Name()} test_helpers.ExecuteCommandWithArgs(submitLrpCommand, args) Expect(outputBuffer).To(test_helpers.Say(colors.Green("Successfully submitted my-json-app."))) Expect(outputBuffer).To(test_helpers.Say("To view the status of your application: ltc status my-json-app")) Expect(fakeAppRunner.SubmitLrpCallCount()).To(Equal(1)) Expect(fakeAppRunner.SubmitLrpArgsForCall(0)).To(Equal([]byte(`{"Value":"test value"}`))) }) It("prints an error returned by the app_runner", func() { fakeAppRunner.SubmitLrpReturns("app-that-broke", errors.New("some error")) args := []string{tmpFile.Name()} test_helpers.ExecuteCommandWithArgs(submitLrpCommand, args) Expect(outputBuffer).To(test_helpers.Say("Error creating app-that-broke: some error")) Expect(fakeAppRunner.SubmitLrpCallCount()).To(Equal(1))
fakeAppExaminer = &fake_app_examiner.FakeAppExaminer{} fakeSecureShell = &fake_secure_shell.FakeSecureShell{} }) Describe("SSHCommand", func() { var sshCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewSSHCommandFactory(config, terminalUI, fakeExitHandler, fakeAppExaminer, fakeSecureShell) sshCommand = commandFactory.MakeSSHCommand() }) It("should ssh to instance 0 given an app name", func() { fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{ActualRunningInstances: 1}, nil) test_helpers.ExecuteCommandWithArgs(sshCommand, []string{"app-name"}) Expect(outputBuffer).To(test_helpers.SayLine("Connecting to app-name/0 at %s", config.Target())) Expect(fakeSecureShell.ConnectToShellCallCount()).To(Equal(1)) appName, instanceIndex, command, actualConfig := fakeSecureShell.ConnectToShellArgsForCall(0) Expect(appName).To(Equal("app-name")) Expect(instanceIndex).To(Equal(0)) Expect(command).To(BeEmpty()) Expect(actualConfig).To(Equal(config)) Expect(fakeAppExaminer.AppStatusCallCount()).To(Equal(1)) Expect(fakeAppExaminer.AppStatusArgsForCall(0)).To(Equal("app-name")) }) It("should ssh to instance index specified", func() {
logsCommand = commandFactory.MakeLogsCommand() }) It("tails logs", func() { appExaminer.AppExistsReturns(true, nil) doneChan := test_helpers.AsyncExecuteCommandWithArgs(logsCommand, []string{"my-app-guid"}) Eventually(fakeTailedLogsOutputter.OutputTailedLogsCallCount).Should(Equal(1)) Expect(fakeTailedLogsOutputter.OutputTailedLogsArgsForCall(0)).To(Equal("my-app-guid")) Consistently(doneChan).ShouldNot(BeClosed()) }) It("handles invalid appguids", func() { test_helpers.ExecuteCommandWithArgs(logsCommand, []string{}) Expect(outputBuffer).To(test_helpers.SayIncorrectUsage()) Expect(fakeExitHandler.ExitCalledWith).To(Equal([]int{exit_codes.InvalidSyntax})) }) It("handles non existent application", func() { appExaminer.AppExistsReturns(false, nil) taskExaminer.TaskStatusReturns(task_examiner.TaskInfo{}, errors.New("task not found")) doneChan := test_helpers.AsyncExecuteCommandWithArgs(logsCommand, []string{"non_existent_app"}) Eventually(fakeTailedLogsOutputter.OutputTailedLogsCallCount).Should(Equal(1)) Expect(fakeTailedLogsOutputter.OutputTailedLogsArgsForCall(0)).To(Equal("non_existent_app")) Expect(outputBuffer).To(test_helpers.Say("Application or task non_existent_app not found.")) Expect(outputBuffer).To(test_helpers.Say("Tailing logs and waiting for non_existent_app to appear..."))
BeforeEach(func() { fakeIntegrationTestRunner = fake_integration_test_runner.NewFakeIntegrationTestRunner() }) Describe("MakeIntegrationTestCommand", func() { var integrationTestCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewIntegrationTestCommandFactory(fakeIntegrationTestRunner) integrationTestCommand = commandFactory.MakeIntegrationTestCommand() }) It("prints the integration test run output and args", func() { test_helpers.ExecuteCommandWithArgs(integrationTestCommand, []string{"--timeout=50s", "--verbose=true", "--cli-help"}) Expect(fakeIntegrationTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg, cliHelpArg := fakeIntegrationTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Second * 50)) Expect(verboseArg).To(Equal(true)) Expect(cliHelpArg).To(Equal(true)) }) It("has sane defaults", func() { test_helpers.ExecuteCommandWithArgs(integrationTestCommand, []string{}) Expect(fakeIntegrationTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg, cliHelpArg := fakeIntegrationTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Minute * 2)) Expect(verboseArg).To(BeFalse())
commandFactory := command_factory.NewTaskExaminerCommandFactory(fakeTaskExaminer, terminalUI, fakeExitHandler) taskCommand = commandFactory.MakeTaskCommand() }) It("displays info for a pending task", func() { taskInfo := task_examiner.TaskInfo{ TaskGuid: "boop", State: "PENDING", CellID: "cell-01", Failed: false, FailureReason: "", Result: "", } fakeTaskExaminer.TaskStatusReturns(taskInfo, nil) test_helpers.ExecuteCommandWithArgs(taskCommand, []string{"boop"}) Expect(outputBuffer).To(test_helpers.Say("Task Name")) Expect(outputBuffer).To(test_helpers.Say("boop")) Expect(outputBuffer).To(test_helpers.Say("Cell ID")) Expect(outputBuffer).To(test_helpers.Say("cell-01")) Expect(outputBuffer).To(test_helpers.Say("Status")) Expect(outputBuffer).To(test_helpers.Say(colors.Yellow("PENDING"))) Expect(outputBuffer).NotTo(test_helpers.Say("Result")) Expect(outputBuffer).NotTo(test_helpers.Say("Failure Reason")) Expect(fakeTaskExaminer.TaskStatusCallCount()).To(Equal(1)) Expect(fakeTaskExaminer.TaskStatusArgsForCall(0)).To(Equal("boop")) }) It("displays result for a non-failed completed task", func() {
BeforeEach(func() { fakeClusterTestRunner = &fake_cluster_test_runner.FakeClusterTestRunner{} }) Describe("MakeClusterTestCommand", func() { var clusterTestCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewClusterTestCommandFactory(fakeClusterTestRunner) clusterTestCommand = commandFactory.MakeClusterTestCommand() }) It("prints the integration test run output and args", func() { args := []string{"--timeout=50s", "--verbose=true"} test_helpers.ExecuteCommandWithArgs(clusterTestCommand, args) Expect(fakeClusterTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg := fakeClusterTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Second * 50)) Expect(verboseArg).To(BeTrue()) }) It("has sane defaults", func() { test_helpers.ExecuteCommandWithArgs(clusterTestCommand, []string{}) Expect(fakeClusterTestRunner.RunCallCount()).To(Equal(1)) timeoutArg, verboseArg := fakeClusterTestRunner.GetArgsForRun() Expect(timeoutArg).To(Equal(time.Minute * 2)) Expect(verboseArg).To(BeFalse()) })
buildDropletCommand = commandFactory.MakeBuildDropletCommand() fakeBlobStoreVerifier.VerifyReturns(true, nil) }) Context("when the archive path is a folder and exists", func() { BeforeEach(func() { fakeCFIgnore.ShouldIgnoreStub = func(path string) bool { return path == "some-ignored-file" } }) It("zips up current working folder and uploads as the droplet name", func() { fakeZipper.IsZipFileReturns(false) fakeZipper.ZipReturns("xyz.zip", nil) test_helpers.ExecuteCommandWithArgs(buildDropletCommand, []string{"droplet-name", "http://some.url/for/buildpack"}) Expect(outputBuffer).To(test_helpers.SayLine("Uploading application bits...")) Expect(outputBuffer).To(test_helpers.SayLine("Uploaded.")) Expect(fakeBlobStoreVerifier.VerifyCallCount()).To(Equal(1)) Expect(fakeBlobStoreVerifier.VerifyArgsForCall(0)).To(Equal(config)) Expect(outputBuffer).To(test_helpers.SayLine("Submitted build of droplet-name")) Expect(fakeDropletRunner.UploadBitsCallCount()).To(Equal(1)) dropletName, uploadPath := fakeDropletRunner.UploadBitsArgsForCall(0) Expect(dropletName).To(Equal("droplet-name")) Expect(uploadPath).NotTo(BeNil()) Expect(uploadPath).To(Equal("xyz.zip"))
FailureReason: "No compatible container", Result: "Finished", State: "COMPLETED", }, task_examiner.TaskInfo{ TaskGuid: "task-guid-3", CellID: "", Failed: true, FailureReason: "", Result: "", State: "COMPLETED", }, } fakeTaskExaminer.ListTasksReturns(listTasks, nil) test_helpers.ExecuteCommandWithArgs(listAppsCommand, []string{}) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("App Name"))) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("Instances"))) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("DiskMB"))) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("MemoryMB"))) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("Route"))) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("process1"))) Expect(outputBuffer).To(test_helpers.Say(colors.Red("0/21"))) Expect(outputBuffer).To(test_helpers.Say(colors.NoColor("100"))) Expect(outputBuffer).To(test_helpers.Say(colors.NoColor("50"))) Expect(outputBuffer).To(test_helpers.Say("alldaylong.com => 54321")) Expect(outputBuffer).To(test_helpers.Say(colors.Bold("process2"))) Expect(outputBuffer).To(test_helpers.Say(colors.Yellow("9/8")))
Context("when the json file exists", func() { BeforeEach(func() { tmpDir = os.TempDir() tmpFile, err = ioutil.TempFile(tmpDir, "tmp_json") Expect(err).ToNot(HaveOccurred()) }) It("submits a task from json", func() { jsonContents := []byte(`{"Value":"test value"}`) ioutil.WriteFile(tmpFile.Name(), jsonContents, 0700) args := []string{tmpFile.Name()} fakeTaskRunner.SubmitTaskReturns("some-task", nil) test_helpers.ExecuteCommandWithArgs(submitTaskCommand, args) Expect(outputBuffer).To(test_helpers.Say(colors.Green("Successfully submitted some-task"))) Expect(fakeTaskRunner.SubmitTaskCallCount()).To(Equal(1)) Expect(fakeTaskRunner.SubmitTaskArgsForCall(0)).To(Equal(jsonContents)) }) It("prints an error returned by the task_runner", func() { jsonContents := []byte(`{"Value":"test value"}`) ioutil.WriteFile(tmpFile.Name(), jsonContents, 0700) args := []string{tmpFile.Name()} fakeTaskRunner.SubmitTaskReturns("some-task", errors.New("taskypoo")) test_helpers.ExecuteCommandWithArgs(submitTaskCommand, args) Expect(fakeTaskRunner.SubmitTaskCallCount()).To(Equal(1))
"--run-as-root=true", "--instances=22", "--env=TIMEZONE=CST", `--env=LANG="Chicago English"`, `--env=JAVA_OPTS="-Djava.arg=/dev/urandom"`, "--env=COLOR", "--env=UNSET", "--timeout=28s", "cool-web-app", "superfun/app:mycooltag", "--", "/start-me-please", "AppArg0", `--appFlavor="purple"`, } test_helpers.ExecuteCommandWithArgs(createCommand, args) Expect(fakeDockerMetadataFetcher.FetchMetadataCallCount()).To(Equal(1)) Expect(fakeDockerMetadataFetcher.FetchMetadataArgsForCall(0)).To(Equal("superfun/app:mycooltag")) Expect(fakeAppRunner.CreateAppCallCount()).To(Equal(1)) createAppParams := fakeAppRunner.CreateAppArgsForCall(0) Expect(createAppParams.Name).To(Equal("cool-web-app")) Expect(createAppParams.StartCommand).To(Equal("/start-me-please")) Expect(createAppParams.RootFS).To(Equal("docker:///superfun/app#mycooltag")) Expect(createAppParams.AppArgs).To(Equal([]string{"AppArg0", "--appFlavor=\"purple\""})) Expect(createAppParams.Instances).To(Equal(22)) Expect(createAppParams.EnvironmentVariables).To(Equal(map[string]string{ "DOCKER": "ME", "TIMEZONE": "CST", "LANG": `"Chicago English"`,
}) Describe("SSHCommand", func() { var sshCommand cli.Command BeforeEach(func() { commandFactory := command_factory.NewSSHCommandFactory(config, terminalUI, fakeExitHandler, fakeAppExaminer, fakeSSH) sshCommand = commandFactory.MakeSSHCommand() }) Context("when connecting fails", func() { It("should print an error", func() { fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{ActualRunningInstances: 1}, nil) fakeSSH.ConnectReturns(errors.New("connection failed")) test_helpers.ExecuteCommandWithArgs(sshCommand, []string{"good-name"}) Expect(outputBuffer).To(test_helpers.SayLine("Error connecting to good-name/0: connection failed")) Expect(fakeSSH.ConnectCallCount()).To(Equal(1)) Expect(fakeSSH.ForwardCallCount()).To(Equal(0)) Expect(fakeSSH.ShellCallCount()).To(Equal(0)) Expect(fakeExitHandler.ExitCalledWith).To(Equal([]int{exit_codes.CommandFailed})) }) }) Describe("port forwarding", func() { It("should forward a local port to a remote host and port", func() { fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{ActualRunningInstances: 1}, nil) test_helpers.ExecuteCommandWithArgs(sshCommand, []string{"app-name", "-N", "-L", "mrlocalhost:1234:remotehost:5678"})