func (s *addSuite) TestAddBadArgs(c *gc.C) {
addCmd := cloud.NewAddCloudCommand()
_, err := testing.RunCommand(c, addCmd)
c.Assert(err, gc.ErrorMatches, "Usage: juju add-cloud <cloud name> <cloud definition file>")
_, err = testing.RunCommand(c, addCmd, "cloud", "cloud.yaml", "extra")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["extra"\]`)
}
func (s *removeSuite) TestRemoveBadArgs(c *gc.C) {
cmd := cloud.NewRemoveCloudCommand()
_, err := testing.RunCommand(c, cmd)
c.Assert(err, gc.ErrorMatches, "Usage: juju remove-cloud <cloud name>")
_, err = testing.RunCommand(c, cmd, "cloud", "extra")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["extra"\]`)
}
// In the case where we cannot examine an environment, we want the
// error to propagate back up to the user.
func (s *BootstrapSuite) TestBootstrapPropagatesEnvErrors(c *gc.C) {
//TODO(bogdanteleaga): fix this for windows once permissions are fixed
if runtime.GOOS == "windows" {
c.Skip("bug 1403084: this is very platform specific. When/if we will support windows state machine, this will probably be rewritten.")
}
const envName = "devenv"
env := resetJujuHome(c, envName)
defaultSeriesVersion := version.Current
defaultSeriesVersion.Series = config.PreferredSeries(env.Config())
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
defaultSeriesVersion.Build = 1234
s.PatchValue(&version.Current, defaultSeriesVersion)
s.PatchValue(&environType, func(string) (string, error) { return "", nil })
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, jc.ErrorIsNil)
// Change permissions on the jenv file to simulate some kind of
// unexpected error when trying to read info from the environment
jenvFile := gitjujutesting.HomePath(".juju", "environments", envName+".jenv")
err = os.Chmod(jenvFile, os.FileMode(0200))
c.Assert(err, jc.ErrorIsNil)
// The second bootstrap should fail b/c of the propogated error
_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, gc.ErrorMatches, "there was an issue examining the environment: .*")
}
// In the case where we cannot examine an environment, we want the
// error to propagate back up to the user.
func (s *BootstrapSuite) TestBootstrapPropagatesEnvErrors(c *gc.C) {
env := resetJujuHome(c)
defaultSeriesVersion := version.Current
defaultSeriesVersion.Series = config.PreferredSeries(env.Config())
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
defaultSeriesVersion.Build = 1234
s.PatchValue(&version.Current, defaultSeriesVersion)
const envName = "peckham"
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, gc.IsNil)
// Change permissions on the jenv file to simulate some kind of
// unexpected error when trying to read info from the environment
jenvFile := gitjujutesting.HomePath(".juju", "environments", envName+".jenv")
err = os.Chmod(jenvFile, os.FileMode(0200))
c.Assert(err, gc.IsNil)
// The second bootstrap should fail b/c of the propogated error
_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", envName)
c.Assert(err, gc.ErrorMatches, "there was an issue examining the environment: .*")
}
func (s *SSHSuite) testSSHCommandHostAddressRetry(c *gc.C, proxy bool) {
m := s.Factory.MakeMachine(c, nil)
s.setKeys(c, m)
called := 0
attemptStarter := &callbackAttemptStarter{next: func() bool {
called++
return called < 2
}}
s.PatchValue(&sshHostFromTargetAttemptStrategy, attemptStarter)
// Ensure that the ssh command waits for a public address, or the attempt
// strategy's Done method returns false.
args := []string{"--proxy=" + fmt.Sprint(proxy), "0"}
_, err := coretesting.RunCommand(c, newSSHCommand(), args...)
c.Assert(err, gc.ErrorMatches, "no .+ address")
c.Assert(called, gc.Equals, 2)
called = 0
attemptStarter.next = func() bool {
called++
if called > 1 {
s.setAddresses(c, m)
}
return true
}
_, err = coretesting.RunCommand(c, newSSHCommand(), args...)
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, gc.Equals, 2)
}
func (s *defaultCredentialSuite) TestBadArgs(c *gc.C) {
cmd := cloud.NewSetDefaultCredentialCommand()
_, err := testing.RunCommand(c, cmd)
c.Assert(err, gc.ErrorMatches, "Usage: juju set-default-credential <cloud-name> <credential-name>")
_, err = testing.RunCommand(c, cmd, "cloud", "credential", "extra")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["extra"\]`)
}
func (s *defaultRegionSuite) TestBadArgs(c *gc.C) {
cmd := cloud.NewSetDefaultRegionCommand()
_, err := testing.RunCommand(c, cmd)
c.Assert(err, gc.ErrorMatches, "Usage: juju set-default-region <cloud-name> <region>")
_, err = testing.RunCommand(c, cmd, "cloud", "region", "extra")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["extra"\]`)
}
func (s *cmdMetricsCommandSuite) TestUnits(c *gc.C) {
meteredCharm := s.Factory.MakeCharm(c, &factory.CharmParams{Name: "metered", URL: "local:quantal/metered"})
meteredService := s.Factory.MakeApplication(c, &factory.ApplicationParams{Charm: meteredCharm})
unit := s.Factory.MakeUnit(c, &factory.UnitParams{Application: meteredService, SetCharmURL: true})
unit2 := s.Factory.MakeUnit(c, &factory.UnitParams{Application: meteredService, SetCharmURL: true})
newTime1 := time.Now().Round(time.Second)
newTime2 := newTime1.Add(time.Second)
metricA := state.Metric{"pings", "5", newTime1}
metricB := state.Metric{"pings", "10.5", newTime2}
s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit, Metrics: []state.Metric{metricA}})
s.Factory.MakeMetric(c, &factory.MetricParams{Unit: unit2, Metrics: []state.Metric{metricA, metricB}})
ctx, err := coretesting.RunCommand(c, metricsdebug.New(), "metered/1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals,
formatTabular(metric{
Unit: unit2.Name(),
Timestamp: newTime2,
Metric: "pings",
Value: "10.5",
}),
)
ctx, err = coretesting.RunCommand(c, metricsdebug.New(), "metered/0")
c.Assert(err, jc.ErrorIsNil)
c.Assert(cmdtesting.Stdout(ctx), gc.Equals,
formatTabular(metric{
Unit: unit.Name(),
Timestamp: newTime1,
Metric: "pings",
Value: "5",
}),
)
}
func (*jenvSuite) TestSuccess(c *gc.C) {
// Create a jenv file.
contents := makeJenvContents("who", "Secret!", "env-UUID", testing.CACert, "1.2.3.4:17070")
f := openJenvFile(c, contents)
defer f.Close()
// Import the newly created jenv file.
jenvCmd := &environment.JenvCommand{}
ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
c.Assert(err, jc.ErrorIsNil)
// The jenv file has been properly imported.
assertJenvContents(c, contents, "testing")
// The default environment is now the newly imported one, and the output
// reflects the change.
c.Assert(envcmd.ReadCurrentEnvironment(), gc.Equals, "testing")
c.Assert(testing.Stdout(ctx), gc.Equals, "erewhemos -> testing\n")
// Trying to import the jenv with the same name a second time raises an
// error.
jenvCmd = &environment.JenvCommand{}
ctx, err = testing.RunCommand(c, jenvCmd, f.Name())
c.Assert(err, gc.ErrorMatches, `an environment named "testing" already exists: you can provide a second parameter to rename the environment`)
// Overriding the environment name solves the problem.
jenvCmd = &environment.JenvCommand{}
ctx, err = testing.RunCommand(c, jenvCmd, f.Name(), "another")
c.Assert(err, jc.ErrorIsNil)
assertJenvContents(c, contents, "another")
c.Assert(envcmd.ReadCurrentEnvironment(), gc.Equals, "another")
c.Assert(testing.Stdout(ctx), gc.Equals, "testing -> another\n")
}
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) {
const envName = "devenv"
s.patchVersionAndSeries(c, envName)
_, err := coretesting.RunCommand(c, newBootstrapCommand(), "-e", envName, "--auto-upgrade")
c.Assert(err, jc.ErrorIsNil)
_, err = coretesting.RunCommand(c, newBootstrapCommand(), "-e", envName, "--auto-upgrade")
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
}
func (s *SetEnvironmentSuite) TestChangeAsCommandPair(c *gc.C) {
_, err := testing.RunCommand(c, envcmd.Wrap(&SetEnvironmentCommand{}), "default-series=raring")
c.Assert(err, gc.IsNil)
context, err := testing.RunCommand(c, envcmd.Wrap(&GetEnvironmentCommand{}), "default-series")
c.Assert(err, gc.IsNil)
output := strings.TrimSpace(testing.Stdout(context))
c.Assert(output, gc.Equals, "raring")
}
func (s *BootstrapSuite) TestBootstrapTwice(c *gc.C) {
const controllerName = "dev"
s.patchVersionAndSeries(c, "raring")
_, err := coretesting.RunCommand(c, s.newBootstrapCommand(), controllerName, "dummy", "--auto-upgrade")
c.Assert(err, jc.ErrorIsNil)
_, err = coretesting.RunCommand(c, s.newBootstrapCommand(), controllerName, "dummy", "--auto-upgrade")
c.Assert(err, gc.ErrorMatches, `controller "local.dev" already exists`)
}
func (s *restoreSuite) TestRestoreArgs(c *gc.C) {
_, err := testing.RunCommand(c, s.command, "restore")
c.Assert(err, gc.ErrorMatches, "you must specify either a file or a backup id.")
_, err = testing.RunCommand(c, s.command, "restore", "--id", "anid", "--file", "afile")
c.Assert(err, gc.ErrorMatches, "you must specify either a file or a backup id but not both.")
_, err = testing.RunCommand(c, s.command, "restore", "--id", "anid", "-b")
c.Assert(err, gc.ErrorMatches, "it is not possible to rebootstrap and restore from an id.")
}
func (s *EndpointSuite) TestNoEndpoints(c *gc.C) {
// Run command once to create store in test.
_, err := coretesting.RunCommand(c, envcmd.Wrap(&EndpointCommand{}))
c.Assert(err, gc.IsNil)
info := s.APIInfo(c)
s.setAPIAddresses(c)
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&EndpointCommand{}))
c.Assert(err, gc.IsNil)
c.Assert(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
output := string(ctx.Stdout.(*bytes.Buffer).Bytes())
c.Assert(output, gc.Equals, fmt.Sprintf("%s\n", info.Addrs[0]))
}
func (s *updateCredentialSuite) TestBadArgs(c *gc.C) {
store := &jujuclienttesting.MemStore{
Controllers: map[string]jujuclient.ControllerDetails{
"controller": {},
},
CurrentControllerName: "controller",
}
cmd := cloud.NewUpdateCredentialCommandForTest(store, nil)
_, err := testing.RunCommand(c, cmd)
c.Assert(err, gc.ErrorMatches, "Usage: juju update-credential <cloud-name> <credential-name>")
_, err = testing.RunCommand(c, cmd, "cloud", "credential", "extra")
c.Assert(err, gc.ErrorMatches, `unrecognized args: \["extra"\]`)
}
func (s *createSuite) TestNoArgs(c *gc.C) {
client := s.BaseBackupsSuite.setDownload()
_, err := testing.RunCommand(c, s.wrappedCommand, "--quiet")
c.Assert(err, jc.ErrorIsNil)
client.Check(c, s.metaresult.ID, "", "Create", "Download")
}
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,
"failed to bootstrap environment: Juju cannot bootstrap because no tools are available for your environment(.|\n)*")
}
func (s *cmdJujuSuite) TestServiceGet(c *gc.C) {
expected := `charm: dummy
service: dummy-service
settings:
outlook:
default: true
description: No default outlook.
type: string
skill-level:
default: true
description: A number indicating skill.
type: int
title:
default: true
description: A descriptive title used for the service.
type: string
value: My Title
username:
default: true
description: The name of the initial account (given admin permissions).
type: string
value: admin001
`
ch := s.AddTestingCharm(c, "dummy")
s.AddTestingService(c, "dummy-service", ch)
context, err := testing.RunCommand(c, service.NewGetCommand(), "dummy-service")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, expected)
}
func (s *BootstrapSuite) TestBootstrapTwice(c *gc.C) {
env := resetJujuHome(c, "devenv")
defaultSeriesVersion := version.Current
defaultSeriesVersion.Series = config.PreferredSeries(env.Config())
// Force a dev version by having a non zero build number.
// This is because we have not uploaded any tools and auto
// upload is only enabled for dev versions.
defaultSeriesVersion.Build = 1234
s.PatchValue(&version.Current, defaultSeriesVersion)
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", "devenv")
c.Assert(err, jc.ErrorIsNil)
_, err = coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}), "-e", "devenv")
c.Assert(err, gc.ErrorMatches, "environment is already bootstrapped")
}
func (s *BootstrapSuite) TestMissingToolsError(c *gc.C) {
s.setupAutoUploadTest(c, "1.8.3", "precise")
_, err := coretesting.RunCommand(c, newBootstrapCommand())
c.Assert(err, gc.ErrorMatches,
"failed to bootstrap model: Juju cannot bootstrap because no tools are available for your model(.|\n)*")
}
func (s *BlockCommandSuite) TestBlockCmdMoreArgs(c *gc.C) {
_, err := testing.RunCommand(c, envcmd.Wrap(&block.DestroyCommand{}), "change", "too much")
c.Assert(
err,
gc.ErrorMatches,
`.*can only specify block message.*`)
}
func (s *BootstrapSuite) TestRunEnvNameMissing(c *gc.C) {
s.PatchValue(&getEnvName, func(*BootstrapCommand) string { return "" })
_, err := coretesting.RunCommand(c, envcmd.Wrap(&BootstrapCommand{}))
c.Check(err, gc.ErrorMatches, "the name of the environment must be specified")
}
func (s *KillSuite) TestKillEarlyAPIConnectionTimeout(c *gc.C) {
stop := make(chan struct{})
defer close(stop)
testDialer := func(sysName string) (*api.State, error) {
<-stop
return nil, errors.New("kill command waited too long")
}
done := make(chan struct{})
go func() {
defer close(done)
cmd := system.NewKillCommand(nil, nil, nil, testDialer)
ctx, err := testing.RunCommand(c, cmd, "test1", "-y")
c.Check(err, jc.ErrorIsNil)
c.Check(testing.Stderr(ctx), jc.Contains, "Unable to open API: connection to state server timed out")
c.Check(s.api.ignoreBlocks, jc.IsFalse)
c.Check(s.api.destroyAll, jc.IsFalse)
checkSystemRemovedFromStore(c, "test1", s.store)
}()
select {
case <-done:
case <-time.After(1 * time.Minute):
c.Fatalf("Kill command waited too long to open the API")
}
}
func (s *DeploySuite) TestAddMetricCredentialsHttp(c *gc.C) {
handler := &testMetricsRegistrationHandler{}
server := httptest.NewServer(handler)
defer server.Close()
var called bool
setter := &testMetricCredentialsSetter{
assert: func(serviceName string, data []byte) {
called = true
c.Assert(serviceName, gc.DeepEquals, "metered")
var b []byte
err := json.Unmarshal(data, &b)
c.Assert(err, gc.IsNil)
c.Assert(string(b), gc.Equals, "hello registration")
},
}
cleanup := jujutesting.PatchValue(&getMetricCredentialsAPI, func(_ api.Connection) (metricCredentialsAPI, error) {
return setter, nil
})
defer cleanup()
testcharms.Repo.ClonedDirPath(s.SeriesPath, "metered")
_, err := coretesting.RunCommand(c, envcmd.Wrap(&deployCommand{RegisterURL: server.URL}), "local:quantal/metered-1")
c.Assert(err, jc.ErrorIsNil)
curl := charm.MustParseURL("local:quantal/metered-1")
s.AssertService(c, "metered", curl, 1, 0)
c.Assert(called, jc.IsTrue)
c.Assert(handler.registrationCalls, gc.HasLen, 1)
c.Assert(handler.registrationCalls[0].CharmURL, gc.DeepEquals, "local:quantal/metered-1")
c.Assert(handler.registrationCalls[0].ServiceName, gc.DeepEquals, "metered")
}
func (s *DeployCharmStoreSuite) TestDeployAuthorization(c *gc.C) {
// Upload the two charms required to upload the bundle.
testcharms.UploadCharm(c, s.client, "trusty/mysql-0", "mysql")
testcharms.UploadCharm(c, s.client, "trusty/wordpress-1", "wordpress")
// Run the tests.
for i, test := range deployAuthorizationTests {
c.Logf("test %d: %s", i, test.about)
// Upload the charm or bundle under test.
url := charm.MustParseURL(test.uploadURL)
if url.Series == "bundle" {
url, _ = testcharms.UploadBundle(c, s.client, test.uploadURL, "wordpress-simple")
} else {
url, _ = testcharms.UploadCharm(c, s.client, test.uploadURL, "wordpress")
}
// Change the ACL of the uploaded entity if required in this case.
if test.readPermUser != "" {
s.changeReadPerm(c, url, test.readPermUser)
}
ctx, err := coretesting.RunCommand(c, envcmd.Wrap(&deployCommand{}), test.deployURL, fmt.Sprintf("wordpress%d", i))
if test.expectError != "" {
c.Assert(err, gc.ErrorMatches, test.expectError)
continue
}
c.Assert(err, jc.ErrorIsNil)
output := strings.Trim(coretesting.Stderr(ctx), "\n")
c.Assert(output, gc.Equals, strings.TrimSpace(test.expectOutput))
}
}
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, jc.ErrorIsNil)
context, err := testing.RunCommand(c, newRunCommand(), "--format=json", "--all", "hostname")
c.Assert(err, jc.ErrorIsNil)
c.Check(testing.Stdout(context), gc.Equals, string(jsonFormatted)+"\n")
}
func (s *StatusSuite) runTestCase(c *gc.C, tc statusTestCase) {
fakeClient := makeFakeClient(
0*time.Second, // No API delay
5*time.Second, // 5 second test timeout
tc.tags,
tc.results,
"", // No API error
)
restore := s.patchAPIClient(fakeClient)
defer restore()
s.subcommand = &action.StatusCommand{}
ctx, err := testing.RunCommand(c, s.subcommand, tc.args...)
if tc.expectError == "" {
c.Check(err, jc.ErrorIsNil)
} else {
c.Check(err, gc.ErrorMatches, tc.expectError)
}
if len(tc.results) > 0 {
buf, err := cmd.DefaultFormatters["yaml"](action.ActionResultsToMap(tc.results))
c.Check(err, jc.ErrorIsNil)
c.Check(ctx.Stdout.(*bytes.Buffer).String(), gc.Equals, string(buf)+"\n")
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
}
}
func (s *MachineShowCommandSuite) TestShowJsonMachine(c *gc.C) {
context, err := testing.RunCommand(c, newMachineShowCommand(), "--format", "json", "0", "1")
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, ""+
"{\"model\":\"dummyenv\",\"machines\":{\"0\":{\"agent-state\":\"started\",\"dns-name\":\"10.0.0.1\",\"instance-id\":\"juju-dummy-machine-0\",\"series\":\"trusty\",\"hardware\":\"availability-zone=us-east-1\"},\"1\":{\"agent-state\":\"pending\",\"dns-name\":\"10.0.0.2\",\"instance-id\":\"juju-dummy-machine-1\",\"series\":\"trusty\"}}}\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, jc.ErrorIsNil)
context, err := testing.RunCommand(c, newRunCommand(),
"--format=json", "--machine=0", "--unit=unit/0", "hostname",
)
c.Assert(err, jc.ErrorIsNil)
c.Check(testing.Stdout(context), gc.Equals, string(jsonFormatted)+"\n")
}