func (s *retryProvisioningSuite) TestResolved(c *gc.C) { m, err := s.State.AddOneMachine(state.MachineTemplate{ Series: "quantal", Jobs: []state.MachineJob{state.JobManageEnviron}, }) c.Assert(err, gc.IsNil) err = m.SetStatus(params.StatusError, "broken", nil) c.Assert(err, gc.IsNil) _, err = s.State.AddOneMachine(state.MachineTemplate{ Series: "quantal", Jobs: []state.MachineJob{state.JobHostUnits}, }) c.Assert(err, gc.IsNil) for i, t := range resolvedMachineTests { c.Logf("test %d: %v", i, t.args) context, err := testing.RunCommand(c, &RetryProvisioningCommand{}, t.args) if t.err != "" { c.Check(err, gc.ErrorMatches, t.err) continue } else { c.Check(err, gc.IsNil) } output := testing.Stderr(context) stripped := strings.Replace(output, "\n", "", -1) c.Check(stripped, gc.Equals, t.stdErr) if t.args[0] == "0" { status, info, data, err := m.Status() c.Check(err, gc.IsNil) c.Check(status, gc.Equals, params.StatusError) c.Check(info, gc.Equals, "broken") c.Check(data["transient"], jc.IsTrue) } } }
func (s *BootstrapSuite) TestWaitSSHKilledWaitingForAddresses(c *gc.C) { ctx := coretesting.Context(c) interrupted := make(chan os.Signal, 1) interrupted <- os.Interrupt _, err := common.WaitSSH(ctx, interrupted, ssh.DefaultClient, "/bin/true", neverAddresses{}, testSSHTimeout) c.Check(err, gc.ErrorMatches, "interrupted") c.Check(coretesting.Stderr(ctx), gc.Matches, "Waiting for address\n") }
func (suite *PluginSuite) TestRunPluginWithFailing(c *gc.C) { suite.makeFailingPlugin("foo", 2) ctx := testing.Context(c) err := RunPlugin(ctx, "foo", []string{"some params"}) c.Assert(err, gc.ErrorMatches, "exit status 2") c.Assert(testing.Stdout(ctx), gc.Equals, "failing\n") c.Assert(testing.Stderr(ctx), gc.Equals, "") }
func (suite *PluginSuite) TestRunPluginExising(c *gc.C) { suite.makePlugin("foo", 0755) ctx := testing.Context(c) err := RunPlugin(ctx, "foo", []string{"some params"}) c.Assert(err, gc.IsNil) c.Assert(testing.Stdout(ctx), gc.Equals, "foo some params\n") c.Assert(testing.Stderr(ctx), gc.Equals, "") }
func (s *LogSuite) TestStderr(c *gc.C) { l := &cmd.Log{ShowLog: true, Config: "<root>=INFO"} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) logger.Infof("hello") c.Assert(coretesting.Stderr(ctx), gc.Matches, `^.* INFO .* hello\n`) }
func (s *ImportKeySuite) TestImportKeys(c *gc.C) { key1 := sshtesting.ValidKeyOne.Key + " user@host" s.setAuthorizedKeys(c, key1) context, err := coretesting.RunCommand(c, &ImportKeysCommand{}, []string{"lp:validuser", "invalid-key"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Matches, `cannot import key id "invalid-key".*\n`) s.assertEnvironKeys(c, key1, sshtesting.ValidKeyThree.Key) }
func (s *destroyEnvSuite) TestDestroyEnvironmentCommandEmptyJenv(c *gc.C) { _, err := s.ConfigStore.CreateInfo("emptyenv") c.Assert(err, gc.IsNil) context, err := coretesting.RunCommand(c, new(DestroyEnvironmentCommand), []string{"-e", "emptyenv"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Equals, "removing empty environment file\n") }
func (s *BootstrapSuite) TestWaitSSHTimesOutWaitingForDial(c *gc.C) { ctx := coretesting.Context(c) // 0.x.y.z addresses are always invalid _, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "/bin/true", &neverOpensPort{addr: "0.1.2.3"}, testSSHTimeout) c.Check(err, gc.ErrorMatches, `waited for `+testSSHTimeout.Timeout.String()+` without being able to connect: mock connection failure to 0.1.2.3`) c.Check(coretesting.Stderr(ctx), gc.Matches, "Waiting for address\n"+ "(Attempting to connect to 0.1.2.3:22\n)+") }
func (s *DeploySuite) TestUpgradeReportsDeprecated(c *gc.C) { coretesting.Charms.ClonedDirPath(s.SeriesPath, "dummy") ctx, err := coretesting.RunCommand(c, &DeployCommand{}, []string{"local:dummy", "-u"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stdout(ctx), gc.Equals, "") output := strings.Split(coretesting.Stderr(ctx), "\n") c.Check(output[0], gc.Matches, `Added charm ".*" to the environment.`) c.Check(output[1], gc.Equals, "--upgrade (or -u) is deprecated and ignored; charms are always deployed with a unique revision.") }
func (s *RunTestSuite) TestRunning(c *gc.C) { loggo.GetLogger("worker.uniter").SetLogLevel(loggo.TRACE) s.runListenerForAgent(c, "foo") ctx, err := testing.RunCommand(c, &RunCommand{}, []string{"foo", "bar"}) c.Check(cmd.IsRcPassthroughError(err), jc.IsTrue) c.Assert(err, gc.ErrorMatches, "subprocess encountered error code 42") c.Assert(testing.Stdout(ctx), gc.Equals, "bar stdout") c.Assert(testing.Stderr(ctx), gc.Equals, "bar stderr") }
func (s *LogSuite) TestShowLogSetsLogLevel(c *gc.C) { l := &cmd.Log{ShowLog: true} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) c.Assert(loggo.GetLogger("").LogLevel(), gc.Equals, loggo.INFO) c.Assert(coretesting.Stderr(ctx), gc.Equals, "") c.Assert(coretesting.Stdout(ctx), gc.Equals, "") }
func (s *AddKeySuite) TestAddKey(c *gc.C) { key1 := sshtesting.ValidKeyOne.Key + " user@host" s.setAuthorizedKeys(c, key1) key2 := sshtesting.ValidKeyTwo.Key + " another@host" context, err := coretesting.RunCommand(c, &AddKeysCommand{}, []string{key2, "invalid-key"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Matches, `cannot add key "invalid-key".*\n`) s.assertEnvironKeys(c, key1, key2) }
func (s *RelationSetSuite) TestRunDeprecationWarning(c *gc.C) { hctx := s.GetHookContext(c, 0, "") com, _ := jujuc.NewCommand(hctx, "relation-set") // The rel= is needed to make this a valid command. ctx, err := testing.RunCommand(c, com, []string{"--format", "foo", "rel="}) c.Assert(err, gc.IsNil) c.Assert(testing.Stdout(ctx), gc.Equals, "") c.Assert(testing.Stderr(ctx), gc.Equals, "--format flag deprecated for command \"relation-set\"") }
func (s *LogSuite) TestOutputQuiet(c *gc.C) { l := &cmd.Log{Quiet: true} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) ctx.Infof("Writing info output") ctx.Verbosef("Writing verbose output") c.Assert(coretesting.Stderr(ctx), gc.Equals, "") }
func (s *ImportKeySuite) TestImportKeyNonDefaultUser(c *gc.C) { key1 := sshtesting.ValidKeyOne.Key + " user@host" s.setAuthorizedKeys(c, key1) _, err := s.State.AddUser("fred", "password") c.Assert(err, gc.IsNil) context, err := coretesting.RunCommand(c, &ImportKeysCommand{}, []string{"--user", "fred", "lp:validuser"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Equals, "") s.assertEnvironKeys(c, key1, sshtesting.ValidKeyThree.Key) }
func (s *DeleteKeySuite) TestDeleteKeys(c *gc.C) { key1 := sshtesting.ValidKeyOne.Key + " user@host" key2 := sshtesting.ValidKeyTwo.Key + " another@host" s.setAuthorizedKeys(c, key1, key2) context, err := coretesting.RunCommand( c, &DeleteKeysCommand{}, []string{sshtesting.ValidKeyTwo.Fingerprint, "invalid-key"}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Matches, `cannot delete key id "invalid-key".*\n`) s.assertEnvironKeys(c, key1) }
func (s *SuperCommandSuite) TestMissingCallbackErrors(c *gc.C) { callback := func(ctx *cmd.Context, subcommand string, args []string) error { return fmt.Errorf("command not found %q", subcommand) } ctx := testing.Context(c) code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo"}) c.Assert(code, gc.Equals, 1) c.Assert(testing.Stdout(ctx), gc.Equals, "") c.Assert(testing.Stderr(ctx), gc.Equals, "ERROR command not found \"foo\"\n") }
func (s *LogSuite) TestOutputDebugForcesQuiet(c *gc.C) { l := &cmd.Log{Verbose: true, Debug: true} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) ctx.Infof("Writing info output") ctx.Verbosef("Writing verbose output") c.Assert(coretesting.Stderr(ctx), gc.Matches, `^.*INFO .* Writing info output\n.*INFO .*Writing verbose output\n.*`) }
func (s *RunSuite) TestSingleResponse(c *gc.C) { mock := s.setupMockAPI() mock.setMachinesAlive("0") mockResponse := mockResponse{ stdout: "stdout\n", stderr: "stderr\n", code: 42, machineId: "0", } mock.setResponse("0", mockResponse) unformatted := ConvertRunResults([]params.RunResult{ makeRunResult(mockResponse)}) yamlFormatted, err := cmd.FormatYaml(unformatted) c.Assert(err, gc.IsNil) jsonFormatted, err := cmd.FormatJson(unformatted) c.Assert(err, gc.IsNil) for i, test := range []struct { message string format string stdout string stderr string errorMatch string }{{ message: "smart (default)", stdout: "stdout\n", stderr: "stderr\n", errorMatch: "subprocess encountered error code 42", }, { message: "yaml output", format: "yaml", stdout: string(yamlFormatted) + "\n", }, { message: "json output", format: "json", stdout: string(jsonFormatted) + "\n", }} { c.Log(fmt.Sprintf("%v: %s", i, test.message)) args := []string{} if test.format != "" { args = append(args, "--format", test.format) } args = append(args, "--all", "ignored") context, err := testing.RunCommand(c, &RunCommand{}, args) if test.errorMatch != "" { c.Check(err, gc.ErrorMatches, test.errorMatch) } else { c.Check(err, gc.IsNil) } c.Check(testing.Stdout(context), gc.Equals, test.stdout) c.Check(testing.Stderr(context), gc.Equals, test.stderr) } }
func (s *AddKeySuite) TestAddKeyNonDefaultUser(c *gc.C) { key1 := sshtesting.ValidKeyOne.Key + " user@host" s.setAuthorizedKeys(c, key1) _, err := s.State.AddUser("fred", "password") c.Assert(err, gc.IsNil) key2 := sshtesting.ValidKeyTwo.Key + " another@host" context, err := coretesting.RunCommand(c, &AddKeysCommand{}, []string{"--user", "fred", key2}) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(context), gc.Equals, "") s.assertEnvironKeys(c, key1, key2) }
func (s *LogSuite) TestAbsPathLog(c *gc.C) { path := filepath.Join(c.MkDir(), "foo.log") l := &cmd.Log{Path: path, Config: "<root>=INFO"} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) logger.Infof("hello") c.Assert(coretesting.Stderr(ctx), gc.Equals, "") content, err := ioutil.ReadFile(path) c.Assert(err, gc.IsNil) c.Assert(string(content), gc.Matches, `^.* INFO .* hello\n`) }
func (s *BootstrapSuite) TestWaitSSHKilledWaitingForDial(c *gc.C) { ctx := coretesting.Context(c) timeout := testSSHTimeout timeout.Timeout = 1 * time.Minute interrupted := make(chan os.Signal, 1) _, err := common.WaitSSH(ctx, interrupted, ssh.DefaultClient, "", &interruptOnDial{name: "0.1.2.3", interrupted: interrupted}, timeout) c.Check(err, gc.ErrorMatches, "interrupted") // Exact timing is imprecise but it should have tried a few times before being killed c.Check(coretesting.Stderr(ctx), gc.Matches, "Waiting for address\n"+ "(Attempting to connect to 0.1.2.3:22\n)+") }
func (s *LogSuite) TestLoggingToFileAndStderr(c *gc.C) { l := &cmd.Log{Path: "foo.log", Config: "<root>=INFO", ShowLog: true} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) logger.Infof("hello") content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "foo.log")) c.Assert(err, gc.IsNil) c.Assert(string(content), gc.Matches, `^.* INFO .* hello\n`) c.Assert(coretesting.Stderr(ctx), gc.Matches, `^.* INFO .* hello\n`) c.Assert(coretesting.Stdout(ctx), gc.Equals, "") }
func (s *LogSuite) TestErrorAndWarningLoggingToStderr(c *gc.C) { // Error and warning go to stderr even with ShowLog=false l := &cmd.Log{Config: "<root>=INFO", ShowLog: false} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) logger.Warningf("a warning") logger.Errorf("an error") logger.Infof("an info") c.Assert(coretesting.Stderr(ctx), gc.Matches, `^.*WARNING a warning\n.*ERROR an error\n.*`) c.Assert(coretesting.Stdout(ctx), gc.Equals, "") }
func (s *PortsSuite) TestOpenCloseDeprecation(c *gc.C) { hctx := s.GetHookContext(c, -1, "") for _, t := range portsFormatDeprectaionTests { name := t.cmd[0] com, err := jujuc.NewCommand(hctx, name) c.Assert(err, gc.IsNil) ctx := testing.Context(c) code := cmd.Main(com, ctx, t.cmd[1:]) c.Assert(code, gc.Equals, 0) c.Assert(testing.Stdout(ctx), gc.Equals, "") c.Assert(testing.Stderr(ctx), gc.Equals, "--format flag deprecated for command \""+name+"\"") } }
func (s *SuperCommandSuite) TestMissingCallbackContextWiredIn(c *gc.C) { callback := func(ctx *cmd.Context, subcommand string, args []string) error { fmt.Fprintf(ctx.Stdout, "this is std out") fmt.Fprintf(ctx.Stderr, "this is std err") return nil } ctx := testing.Context(c) code := cmd.Main(NewSuperWithCallback(callback), ctx, []string{"foo", "bar", "baz", "--debug"}) c.Assert(code, gc.Equals, 0) c.Assert(testing.Stdout(ctx), gc.Equals, "this is std out") c.Assert(testing.Stderr(ctx), gc.Equals, "this is std err") }
func (s *DebugLogSuite) TestTailFallback(c *gc.C) { s.PatchValue(&runSSHCommand, func(sshCmd *SSHCommand, ctx *cmd.Context) error { fmt.Fprintf(ctx.Stdout, "%s", sshCmd.Args) return nil }) s.PatchValue(&getDebugLogAPI, func(envName string) (DebugLogAPI, error) { return &fakeDebugLogAPI{err: errors.NotSupportedf("testing")}, nil }) ctx, err := testing.RunCommand(c, &DebugLogCommand{}, []string{"-n", "100"}) c.Assert(err, gc.IsNil) c.Check(testing.Stderr(ctx), gc.Equals, "Server does not support new stream log, falling back to tail\n") c.Check(testing.Stdout(ctx), gc.Equals, "[tail -n -100 -f /var/log/juju/all-machines.log]") }
func (s *LogSuite) TestOutputDefaultLogsVerbose(c *gc.C) { l := &cmd.Log{Path: "foo.log", Config: "<root>=INFO"} ctx := coretesting.Context(c) err := l.Start(ctx) c.Assert(err, gc.IsNil) ctx.Infof("Writing info output") ctx.Verbosef("Writing verbose output") content, err := ioutil.ReadFile(filepath.Join(ctx.Dir, "foo.log")) c.Assert(err, gc.IsNil) c.Assert(coretesting.Stderr(ctx), gc.Equals, "Writing info output\n") c.Assert(string(content), gc.Matches, `^.*INFO .*Writing verbose output\n.*`) }
func (s *BootstrapSuite) TestWaitSSHRefreshAddresses(c *gc.C) { ctx := coretesting.Context(c) _, err := common.WaitSSH(ctx, nil, ssh.DefaultClient, "", &addressesChange{addrs: [][]string{ nil, nil, []string{"0.1.2.3"}, []string{"0.1.2.3"}, nil, []string{"0.1.2.4"}, }}, testSSHTimeout) // Not necessarily the last one in the list, due to scheduling. c.Check(err, gc.ErrorMatches, `waited for `+testSSHTimeout.Timeout.String()+` without being able to connect: mock connection failure to 0.1.2.[34]`) stderr := coretesting.Stderr(ctx) c.Check(stderr, gc.Matches, "Waiting for address\n"+ "(.|\n)*(Attempting to connect to 0.1.2.3:22\n)+(.|\n)*") c.Check(stderr, gc.Matches, "Waiting for address\n"+ "(.|\n)*(Attempting to connect to 0.1.2.4:22\n)+(.|\n)*") }
func (s *BootstrapSuite) TestBootstrapTwice(c *gc.C) { env, fake := makeEmptyFakeHome(c) defer fake.Restore() defaultSeriesVersion := version.Current defaultSeriesVersion.Series = config.PreferredSeries(env.Config()) // Force a dev version by having an odd minor version number. // This is because we have not uploaded any tools and auto // upload is only enabled for dev versions. defaultSeriesVersion.Minor = 11 s.PatchValue(&version.Current, defaultSeriesVersion) ctx := coretesting.Context(c) code := cmd.Main(&BootstrapCommand{}, ctx, nil) c.Check(code, gc.Equals, 0) ctx2 := coretesting.Context(c) code2 := cmd.Main(&BootstrapCommand{}, ctx2, nil) c.Check(code2, gc.Equals, 1) expectedErrText := "error: environment is already bootstrapped\n" c.Check(coretesting.Stderr(ctx2), gc.Equals, expectedErrText) c.Check(coretesting.Stdout(ctx2), gc.Equals, "") }