Golang FakeAppExaminer.AppStatusReturns方法代碼示例

		fakeExitHandler = &fake_exit_handler.FakeExitHandler{}
		fakeAppExaminer = &fake_app_examiner.FakeAppExaminer{}
		fakeSSH = &mocks.FakeSSH{}
	})

	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() {

			fakeDockerMetadataFetcher.FetchMetadataReturns(&docker_metadata_fetcher.ImageMetadata{
				Env: []string{"TIMEZONE=PST", "DOCKER=ME"},
			}, nil)
		})

		It("creates a Docker based app as specified in the command via the AppRunner", func() {
			fakeAppExaminer.RunningAppInstancesInfoReturns(22, false, nil)
			fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{
				Routes: route_helpers.Routes{
					AppRoutes: []route_helpers.AppRoute{
						{
							Hostnames: []string{"route-3000-yay.192.168.11.11.xip.io"},
							Port:      8080,
						},
						{
							Hostnames: []string{"route-1111-wahoo.192.168.11.11.xip.io"},
							Port:      1111,
						},
						{
							Hostnames: []string{"route-1111-me-too.192.168.11.11.xip.io"},
							Port:      1111,
						},
					},
				},
			}, nil)

			args := []string{
				"--cpu-weight=57",
				"--memory-mb=12",
				"--disk-mb=12",
				"--user=some-user",
				"--working-dir=/applications",

			})
		})
	})

	Describe("UpdateCommand", func() {
		var updateCommand cli.Command

		BeforeEach(func() {
			appRunnerCommandFactoryConfig = command_factory.AppRunnerCommandFactoryConfig{
				AppRunner:   fakeAppRunner,
				AppExaminer: fakeAppExaminer,
				UI:          terminalUI,
				ExitHandler: fakeExitHandler,
			}

			fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{}, nil)
			commandFactory := command_factory.NewAppRunnerCommandFactory(appRunnerCommandFactoryConfig)
			updateCommand = commandFactory.MakeUpdateCommand()
		})

		Context("when only http routes are passed", func() {
			It("updates the http routes and removes any tcp routes", func() {
				expectedRouteOverrides := app_runner.RouteOverrides{
					{HostnamePrefix: "foo.com", Port: 8080},
					{HostnamePrefix: "bar.com", Port: 9090},
				}

				fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{Ports: []uint16{8080, 2222}}, nil)

				args := []string{
					"cool-web-app",

				Expect(outputBuffer).To(test_helpers.SayLine("Incorrect Usage: Unable to parse routes"))
				Expect(outputBuffer).To(test_helpers.SayLine("  Pass multiple --tcp-route flags instead of comma-delimiting.  See help page for details."))
				Expect(fakeDropletRunner.LaunchDropletCallCount()).To(Equal(0))
				Expect(fakeExitHandler.ExitCalledWith).To(Equal([]int{exit_codes.InvalidSyntax}))
			})
		})

		It("launches the specified droplet with tcp routes", func() {
			fakeAppExaminer.RunningAppInstancesInfoReturns(1, false, nil)
			fakeAppExaminer.AppStatusReturns(app_examiner.AppInfo{
				Routes: route_helpers.Routes{
					AppRoutes: []route_helpers.AppRoute{
						{
							Hostnames: []string{"ninetyninety.192.168.11.11.xip.io"},
							Port:      4444,
						},
						{
							Hostnames: []string{"fourtyfourfourtyfour.192.168.11.11.xip.io"},
							Port:      9090,
						},
					},
				},
			}, nil)

			args := []string{
				"--ports=4444",
				"--http-route=ninetyninety",
				"--http-route=fourtyfourfourtyfour:9090",
				"--tcp-route=50000",
				"--tcp-route=50001:5223",
				"droppy",
				"droplet-name",

						CrashCount:     2,
						HasMetrics:     false,
					},
					app_examiner.InstanceInfo{
						Index:      5,
						State:      "CRASHED",
						CrashCount: 7,
					},
				},
			}

			fakeTerm.GetWindowWidthReturns(9999, nil)
		})

		It("emits a pretty representation of the DesiredLRP", func() {
			fakeAppExaminer.AppStatusReturns(sampleAppInfo, nil)

			test_helpers.ExecuteCommandWithArgs(statusCommand, []string{"wompy-app"})

			Expect(fakeAppExaminer.AppStatusCallCount()).To(Equal(1))
			Expect(fakeAppExaminer.AppStatusArgsForCall(0)).To(Equal("wompy-app"))

			Expect(outputBuffer).To(test_helpers.Say("Instance"))
			Expect(outputBuffer).To(test_helpers.Say("State"))
			Expect(outputBuffer).To(test_helpers.Say("Crashes"))
			Expect(outputBuffer).To(test_helpers.Say("CPU"))
			Expect(outputBuffer).To(test_helpers.Say("Memory"))
			Expect(outputBuffer).To(test_helpers.Say("Uptime"))
			Expect(outputBuffer).To(test_helpers.SayNewLine())

			Expect(outputBuffer).To(test_helpers.Say("3"))