func (s *RemoveUserSuite) TestRemoveUser(c *gc.C) {
_, err := testing.RunCommand(c, envcmd.Wrap(&UserAddCommand{}), "foobar")
c.Assert(err, gc.IsNil)
_, err = testing.RunCommand(c, envcmd.Wrap(&RemoveUserCommand{}), "foobar")
c.Assert(err, gc.IsNil)
}
func (s *BootstrapSuite) TestBootstrapTwice(c *gc.C) {
env := resetJujuHome(c)
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)
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}))
c.Assert(err, gc.IsNil)
_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}))
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
}
func (s *RunSuite) TestAllMachines(c *gc.C) {
mock := s.setupMockAPI()
mock.setMachinesAlive("0", "1")
response0 := mockResponse{
stdout: "megatron\n",
machineId: "0",
}
response1 := mockResponse{
error: "command timed out",
machineId: "1",
}
mock.setResponse("0", response0)
unformatted := ConvertRunResults([]params.RunResult{
makeRunResult(response0),
makeRunResult(response1),
})
jsonFormatted, err := cmd.FormatJson(unformatted)
c.Assert(err, gc.IsNil)
context, err := testing.RunCommand(c, &RunCommand{}, "--format=json", "--all", "hostname")
c.Assert(err, gc.IsNil)
c.Check(testing.Stdout(context), gc.Equals, string(jsonFormatted)+"\n")
}
func (s *RunSuite) TestRunForMachineAndUnit(c *gc.C) {
mock := s.setupMockAPI()
machineResponse := mockResponse{
stdout: "megatron\n",
machineId: "0",
}
unitResponse := mockResponse{
stdout: "bumblebee",
machineId: "1",
unitId: "unit/0",
}
mock.setResponse("0", machineResponse)
mock.setResponse("unit/0", unitResponse)
unformatted := ConvertRunResults([]params.RunResult{
makeRunResult(machineResponse),
makeRunResult(unitResponse),
})
jsonFormatted, err := cmd.FormatJson(unformatted)
c.Assert(err, gc.IsNil)
context, err := testing.RunCommand(c, envcmd.Wrap(&RunCommand{}),
"--format=json", "--machine=0", "--unit=unit/0", "hostname",
)
c.Assert(err, gc.IsNil)
c.Check(testing.Stdout(context), gc.Equals, string(jsonFormatted)+"\n")
}
func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {
s.setupAutoUploadTest(c, "1.8.3", "precise")
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}))
c.Assert(err, gc.ErrorMatches, "cannot upload bootstrap tools: Juju "+
"cannot bootstrap because no tools are available for your "+
"environment(.|\n)*")
}
func (s *ImportKeySuite) TestImportKeys(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " user@host"
s.setAuthorizedKeys(c, key1)
context, err := coretesting.RunCommand(c, envcmd.Wrap(&ImportKeysCommand{}), "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), "-e", "emptyenv")
c.Assert(err, gc.IsNil)
c.Assert(coretesting.Stderr(context), gc.Equals, "removing empty environment file\n")
}
func (s *DeploySuite) TestUpgradeReportsDeprecated(c *gc.C) {
coretesting.Charms.ClonedDirPath(s.SeriesPath, "dummy")
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&DeployCommand{}), "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 *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, envcmd.Wrap(&AddKeysCommand{}), 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 *BootstrapSuite) TestMissingToolsUploadFailedError(c *gc.C) {
s.setupAutoUploadTest(c, "1.7.3", "precise")
s.PatchValue(&sync.Upload, uploadToolsAlwaysFails)
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}))
c.Check(coretesting.Stderr(ctx), gc.Matches,
"uploading tools for series \\[precise .* raring\\]\n")
c.Check(err, gc.ErrorMatches, "cannot upload bootstrap tools: an error")
}
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, envcmd.Wrap(&DeleteKeysCommand{}),
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 *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, envcmd.Wrap(&ImportKeysCommand{}), "--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 *ListKeysSuite) TestListFullKeys(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, envcmd.Wrap(&ListKeysCommand{}), "--full")
c.Assert(err, gc.IsNil)
output := strings.TrimSpace(coretesting.Stdout(context))
c.Assert(err, gc.IsNil)
c.Assert(output, gc.Matches, "Keys for user admin:\n.*user@host\n.*another@host")
}
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, envcmd.Wrap(&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 *BootstrapSuite) TestValidateConstraintsCalledWithoutMetadatasource(c *gc.C) {
validateCalled := 0
s.PatchValue(&validateConstraints, func(cons constraints.Value, env environs.Environ) error {
c.Assert(cons, gc.DeepEquals, constraints.MustParse("mem=4G"))
validateCalled++
return nil
})
resetJujuHome(c)
_, err := coretesting.RunCommand(
c, envcmd.Wrap(&BootstrapCommand{}), "--constraints", "mem=4G")
c.Assert(err, gc.IsNil)
c.Assert(validateCalled, gc.Equals, 1)
}
func (s *BootstrapSuite) checkSeriesArg(c *gc.C, argVariant string) *cmd.Context {
_bootstrap := &fakeBootstrapFuncs{}
s.PatchValue(&getBootstrapFuncs, func() BootstrapInterface {
return _bootstrap
})
resetJujuHome(c)
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "--upload-tools", argVariant, "foo,bar")
c.Assert(err, gc.IsNil)
c.Check(_bootstrap.uploadToolsSeries, gc.DeepEquals, []string{"foo", "bar"})
return ctx
}
func (s *DeleteCharmSuite) TestRun(c *gc.C) {
// Derive config file from test mongo port
confDir := c.MkDir()
f, err := os.Create(path.Join(confDir, "charmd.conf"))
c.Assert(err, gc.IsNil)
configPath := f.Name()
{
defer f.Close()
fmt.Fprintf(f, "mongo-url: %s\n", testing.MgoServer.Addr())
}
// Delete charm that does not exist, not found error.
config := &DeleteCharmCommand{}
out, err := testing.RunCommand(c, config, "--config", configPath, "--url", "cs:unreleased/foo")
fmt.Println(out)
c.Assert(err, gc.NotNil)
// Publish that charm now
url := charm.MustParseURL("cs:unreleased/foo")
{
s, err := store.Open(testing.MgoServer.Addr())
defer s.Close()
c.Assert(err, gc.IsNil)
pub, err := s.CharmPublisher([]*charm.URL{url}, "such-digest-much-unique")
c.Assert(err, gc.IsNil)
err = pub.Publish(testing.Charms.ClonedDir(c.MkDir(), "dummy"))
c.Assert(err, gc.IsNil)
}
// Delete charm, should now succeed
_, err = testing.RunCommand(c, config, "--config", configPath, "--url", "cs:unreleased/foo")
c.Assert(err, gc.IsNil)
c.Assert(config.Config, gc.NotNil)
// Confirm that the charm is gone
{
s, err := store.Open(testing.MgoServer.Addr())
defer s.Close()
c.Assert(err, gc.IsNil)
_, err = s.CharmInfo(url)
c.Assert(err, gc.NotNil)
}
}
func (s *DeleteKeySuite) TestDeleteKeyNonDefaultUser(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " user@host"
key2 := sshtesting.ValidKeyTwo.Key + " another@host"
s.setAuthorizedKeys(c, key1, key2)
_, err := s.State.AddUser("fred", "password")
c.Assert(err, gc.IsNil)
context, err := coretesting.RunCommand(c, envcmd.Wrap(&DeleteKeysCommand{}),
"--user", "fred", sshtesting.ValidKeyTwo.Fingerprint)
c.Assert(err, gc.IsNil)
c.Assert(coretesting.Stderr(context), gc.Equals, "")
s.assertEnvironKeys(c, key1)
}
func (s *ListKeysSuite) TestListKeysNonDefaultUser(c *gc.C) {
key1 := sshtesting.ValidKeyOne.Key + " user@host"
key2 := sshtesting.ValidKeyTwo.Key + " another@host"
s.setAuthorizedKeys(c, key1, key2)
_, err := s.State.AddUser("fred", "password")
c.Assert(err, gc.IsNil)
context, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), "--user", "fred")
c.Assert(err, gc.IsNil)
output := strings.TrimSpace(coretesting.Stdout(context))
c.Assert(err, gc.IsNil)
c.Assert(output, gc.Matches, "Keys for user fred:\n.*\\(user@host\\)\n.*\\(another@host\\)")
}
func (s *BootstrapSuite) TestAutoSyncLocalSource(c *gc.C) {
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&version.Current.Number, version.MustParse("1.2.0"))
env := resetJujuHome(c)
// Bootstrap the environment with the valid source.
// The bootstrapping has to show no error, because the tools
// are automatically synchronized.
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "--metadata-source", sourceDir)
c.Assert(err, gc.IsNil)
// Now check the available tools which are the 1.2.0 envtools.
checkTools(c, env, v120All)
}
func (s *BootstrapSuite) TestInvalidLocalSource(c *gc.C) {
s.PatchValue(&version.Current.Number, version.MustParse("1.2.0"))
env := resetJujuHome(c)
// Bootstrap the environment with an invalid source.
// The command returns with an error.
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "--metadata-source", c.MkDir())
c.Check(err, gc.ErrorMatches, "cannot upload bootstrap tools: Juju "+
"cannot bootstrap because no tools are available for your "+
"environment(.|\n)*")
// Now check that there are no tools available.
_, err = envtools.FindTools(
env, version.Current.Major, version.Current.Minor, coretools.Filter{}, envtools.DoNotAllowRetry)
c.Assert(err, gc.FitsTypeOf, errors.NotFoundf(""))
}
func (s *BootstrapSuite) TestUploadLocalImageMetadata(c *gc.C) {
sourceDir, expected := createImageMetadata(c)
env := resetJujuHome(c)
// Bootstrap the environment with the valid source.
// 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.
devVersion := version.Current
devVersion.Minor = 11
s.PatchValue(&version.Current, devVersion)
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "--metadata-source", sourceDir)
c.Assert(err, gc.IsNil)
c.Assert(imagemetadata.DefaultBaseURL, gc.Equals, imagemetadata.UbuntuCloudImagesURL)
// Now check the image metadata has been uploaded.
checkImageMetadata(c, env.Storage(), expected)
}
func (s *BootstrapSuite) TestValidateConstraintsCalledWithMetadatasource(c *gc.C) {
sourceDir, _ := createImageMetadata(c)
resetJujuHome(c)
var calledFuncs []string
s.PatchValue(&uploadCustomMetadata, func(metadataDir string, env environs.Environ) error {
c.Assert(metadataDir, gc.DeepEquals, sourceDir)
calledFuncs = append(calledFuncs, "uploadCustomMetadata")
return nil
})
s.PatchValue(&validateConstraints, func(cons constraints.Value, env environs.Environ) error {
c.Assert(cons, gc.DeepEquals, constraints.MustParse("mem=4G"))
calledFuncs = append(calledFuncs, "validateConstraints")
return nil
})
_, err := coretesting.RunCommand(
c, envcmd.Wrap(&BootstrapCommand{}), "--metadata-source", sourceDir, "--constraints", "mem=4G")
c.Assert(err, gc.IsNil)
c.Assert(calledFuncs, gc.DeepEquals, []string{"uploadCustomMetadata", "validateConstraints"})
}
func (s *UserCommandSuite) TestHelp(c *gc.C) {
// Check the help output
ctx, err := coretesting.RunCommand(c, NewUserCommand(), "--help")
c.Assert(err, gc.IsNil)
c.Assert(coretesting.Stdout(ctx), gc.Matches,
"(?s)usage: user <command> .+"+
userCommandPurpose+".+"+
userCommandDoc+".+")
// Check that we have registered all the sub commands by
// inspecting the help output.
var namesFound []string
commandHelp := strings.SplitAfter(coretesting.Stdout(ctx), "commands:")[1]
commandHelp = strings.TrimSpace(commandHelp)
for _, line := range strings.Split(commandHelp, "\n") {
namesFound = append(namesFound, strings.TrimSpace(strings.Split(line, " - ")[0]))
}
c.Assert(namesFound, gc.DeepEquals, expectedUserCommmandNames)
}
func (*mainSuite) TestRegisteredCommands(c *gc.C) {
expectedSubcommands := []string{
"help",
// TODO: add some as they get registered
}
plugin := local.JujuLocalPlugin()
ctx, err := coretesting.RunCommand(c, plugin, "help", "commands")
c.Assert(err, gc.IsNil)
lines := strings.Split(coretesting.Stdout(ctx), "\n")
var names []string
for _, line := range lines {
f := strings.Fields(line)
if len(f) == 0 {
continue
}
names = append(names, f[0])
}
// The names should be output in alphabetical order, so don't sort.
c.Assert(names, gc.DeepEquals, expectedSubcommands)
}
func runUnexpose(c *gc.C, args ...string) error {
_, err := testing.RunCommand(c, envcmd.Wrap(&UnexposeCommand{}), args...)
return err
}
func runUpgradeCharm(c *gc.C, args ...string) error {
_, err := testing.RunCommand(c, envcmd.Wrap(&UpgradeCharmCommand{}), args...)
return err
}
func runValidateImageMetadata(c *gc.C, args ...string) error {
_, err := coretesting.RunCommand(c, envcmd.Wrap(&ValidateImageMetadataCommand{}), args...)
return err
}
func runSignMetadata(c *gc.C, args ...string) error {
_, err := coretesting.RunCommand(c, &SignMetadataCommand{}, args...)
return err
}
func (s *ListKeysSuite) TestTooManyArgs(c *gc.C) {
_, err := coretesting.RunCommand(c, envcmd.Wrap(&ListKeysCommand{}), "foo")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["foo"\]`)
}