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, "")
}