func (s *filesSuite) TestWriteCurrentControllerExistingController(c *gc.C) {
err := modelcmd.WriteCurrentController("fubar")
c.Assert(err, jc.ErrorIsNil)
err = modelcmd.WriteCurrentController("new-sys")
c.Assert(err, jc.ErrorIsNil)
s.assertCurrentController(c, "new-sys")
}
func (s *ModelsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
err := modelcmd.WriteCurrentController("fake")
c.Assert(err, jc.ErrorIsNil)
last1 := time.Date(2015, 3, 20, 0, 0, 0, 0, time.UTC)
last2 := time.Date(2015, 3, 1, 0, 0, 0, 0, time.UTC)
models := []base.UserModel{
{
Name: "test-model1",
Owner: "user-admin@local",
UUID: "test-model1-UUID",
LastConnection: &last1,
}, {
Name: "test-model2",
Owner: "user-admin@local",
UUID: "test-model2-UUID",
LastConnection: &last2,
}, {
Name: "test-model3",
Owner: "user-admin@local",
UUID: "test-model3-UUID",
},
}
s.api = &fakeModelMgrAPIClient{models: models}
s.creds = &configstore.APICredentials{User: "******", Password: "******"}
}
func (s *UsersCommandSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
last1 := time.Date(2015, 3, 20, 0, 0, 0, 0, time.UTC)
last2 := time.Date(2015, 3, 1, 0, 0, 0, 0, time.UTC)
userlist := []params.ModelUserInfo{
{
UserName: "******",
LastConnection: &last1,
Access: "write",
}, {
UserName: "******",
DisplayName: "Bob",
LastConnection: &last2,
Access: "read",
}, {
UserName: "******",
DisplayName: "Charlie",
Access: "read",
},
}
s.fake = &fakeModelUsersClient{users: userlist}
err := modelcmd.WriteCurrentController("testing")
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["testing"] = jujuclient.ControllerDetails{}
s.store.Accounts["testing"] = &jujuclient.ControllerAccounts{
CurrentAccount: "admin@local",
}
}
func (s *ModelCommandSuite) TestModelCommandInitControllerFile(c *gc.C) {
// If there is a current-controller file, error raised.
err := modelcmd.WriteCurrentController("fubar")
c.Assert(err, jc.ErrorIsNil)
_, err = initTestCommand(c)
c.Assert(err, gc.ErrorMatches, `not operating on an model, using controller "fubar"`)
}
func (s *BaseSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
memstore := configstore.NewMem()
s.PatchValue(&configstore.Default, func() (configstore.Storage, error) {
return memstore, nil
})
os.Setenv(osenv.JujuModelEnvKey, "testing")
info := memstore.CreateInfo("testing")
info.SetBootstrapConfig(map[string]interface{}{"random": "extra data"})
info.SetAPIEndpoint(configstore.APIEndpoint{
Addresses: []string{"127.0.0.1:12345"},
Hostnames: []string{"localhost:12345"},
CACert: testing.CACert,
ModelUUID: testing.ModelTag.Id(),
})
info.SetAPICredentials(configstore.APICredentials{
User: "******",
Password: "******",
})
err := info.Write()
c.Assert(err, jc.ErrorIsNil)
s.PatchValue(user.ReadPassword, func() (string, error) {
return "sekrit", nil
})
err = modelcmd.WriteCurrentController("testing")
c.Assert(err, jc.ErrorIsNil)
}
func (s *SwitchSimpleSuite) TestCurrentControllerHasPrecedence(c *gc.C) {
testing.WriteEnvironments(c, testing.MultipleEnvConfig)
modelcmd.WriteCurrentController("fubar")
context, err := testing.RunCommand(c, newSwitchCommand())
c.Assert(err, jc.ErrorIsNil)
c.Assert(testing.Stdout(context), gc.Equals, "fubar (controller)\n")
}
func (s *grantRevokeSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.fake = &fakeGrantRevokeAPI{}
// Set up the current controller, and write just enough info
// so we don't try to refresh
controllerName := "local.test-master"
err := modelcmd.WriteCurrentController(controllerName)
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["local.test-master"] = jujuclient.ControllerDetails{}
s.store.Accounts[controllerName] = &jujuclient.ControllerAccounts{
Accounts: map[string]jujuclient.AccountDetails{
"bob@local": {User: "******"},
},
CurrentAccount: "bob@local",
}
s.store.Models = map[string]jujuclient.ControllerAccountModels{
controllerName: jujuclient.ControllerAccountModels{
AccountModels: map[string]*jujuclient.AccountModels{
"bob@local": &jujuclient.AccountModels{
Models: map[string]jujuclient.ModelDetails{
"foo": jujuclient.ModelDetails{fooModelUUID},
"bar": jujuclient.ModelDetails{barModelUUID},
"baz": jujuclient.ModelDetails{bazModelUUID},
"model1": jujuclient.ModelDetails{model1ModelUUID},
"model2": jujuclient.ModelDetails{model2ModelUUID},
},
},
},
},
}
}
func (s *addSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.fake = &fakeCreateClient{
model: params.Model{
Name: "test",
UUID: "fake-model-uuid",
OwnerTag: "ignored-for-now",
},
}
// Set up the current controller, and write just enough info
// so we don't try to refresh
controllerName := "local.test-master"
err := modelcmd.WriteCurrentController(controllerName)
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["local.test-master"] = jujuclient.ControllerDetails{}
s.store.Accounts[controllerName] = &jujuclient.ControllerAccounts{
Accounts: map[string]jujuclient.AccountDetails{
"bob@local": {User: "******"},
},
CurrentAccount: "bob@local",
}
s.store.Credentials["aws"] = cloud.CloudCredential{
AuthCredentials: map[string]cloud.Credential{
"secrets": cloud.NewCredential(cloud.AccessKeyAuthType, map[string]string{
"access-key": "key",
"secret-key": "sekret",
}),
},
}
}
func (s *ShowControllerSuite) TestShowControllerNoArgsNoCurrent(c *gc.C) {
err := modelcmd.WriteCurrentController("")
c.Assert(err, jc.ErrorIsNil)
s.expectedErr = regexp.QuoteMeta(`there is no active controller`)
s.assertShowControllerFailed(c)
}
func (s *filesSuite) TestWriteControllerAddsNewline(c *gc.C) {
err := modelcmd.WriteCurrentController("fubar")
c.Assert(err, jc.ErrorIsNil)
current, err := ioutil.ReadFile(modelcmd.GetCurrentControllerFilePath())
c.Assert(err, jc.ErrorIsNil)
c.Assert(string(current), gc.Equals, "fubar\n")
}
func (s *filesSuite) TestWriteControllerRemovesEnvironmentFile(c *gc.C) {
err := modelcmd.WriteCurrentModel("fubar")
c.Assert(err, jc.ErrorIsNil)
err = modelcmd.WriteCurrentController("baz")
c.Assert(err, jc.ErrorIsNil)
c.Assert(modelcmd.GetCurrentModelFilePath(), jc.DoesNotExist)
}
func (s *ModelCommandSuite) TestGetCurrentModelNothingSet(c *gc.C) {
err := modelcmd.WriteCurrentController("")
c.Assert(err, jc.ErrorIsNil)
env, err := modelcmd.GetCurrentModel(s.store)
c.Assert(env, gc.Equals, "")
c.Assert(err, jc.ErrorIsNil)
}
func (s *removeBlocksSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
err := modelcmd.WriteCurrentController("fake")
c.Assert(err, jc.ErrorIsNil)
s.api = &fakeRemoveBlocksAPI{}
}
func (s *ControllerCommandSuite) TestControllerCommandInitExplicit(c *gc.C) {
// Take controller name from command line arg, and it trumps the current-
// controller file.
err := modelcmd.WriteCurrentController("fubar")
c.Assert(err, jc.ErrorIsNil)
testEnsureControllerName(c, "explicit", "-c", "explicit")
testEnsureControllerName(c, "explicit", "--controller", "explicit")
}
func (*filesSuite) TestCurrentCommenctionNameController(c *gc.C) {
err := modelcmd.WriteCurrentController("baz")
c.Assert(err, jc.ErrorIsNil)
name, isController, err := modelcmd.CurrentConnectionName()
c.Assert(err, jc.ErrorIsNil)
c.Assert(isController, jc.IsTrue)
c.Assert(name, gc.Equals, "baz")
}
func (s *filesSuite) TestSetCurrentControllerExistingController(c *gc.C) {
err := modelcmd.WriteCurrentController("fubar")
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
err = modelcmd.SetCurrentController(ctx, "new-sys")
c.Assert(err, jc.ErrorIsNil)
s.assertCurrentController(c, "new-sys")
c.Assert(testing.Stderr(ctx), gc.Equals, "fubar (controller) -> new-sys (controller)\n")
}
func (s *removeBlocksSuite) SetUpTest(c *gc.C) {
s.baseControllerSuite.SetUpTest(c)
err := modelcmd.WriteCurrentController("fake")
c.Assert(err, jc.ErrorIsNil)
s.api = &fakeRemoveBlocksAPI{}
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["fake"] = jujuclient.ControllerDetails{}
}
func (s *baseControllerSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.controllersYaml = testControllersYaml
s.modelsYaml = testModelsYaml
s.accountsYaml = testAccountsYaml
s.store = nil
err := modelcmd.WriteCurrentController("local.mallards")
c.Assert(err, jc.ErrorIsNil)
}
func (s *ShowControllerSuite) TestShowControllerNoArgs(c *gc.C) {
s.createTestClientStore(c)
s.expectedOutput = `
{"local.aws-test":{"details":{"uuid":"this-is-the-aws-test-uuid","api-endpoints":["this-is-aws-test-of-many-api-endpoints"],"ca-cert":"this-is-aws-test-ca-cert"},"accounts":{"admin@local":{"user":"******","models":{"admin":{"uuid":"ghi"}},"current-model":"admin"}}}}
`[1:]
err := modelcmd.WriteCurrentController("local.aws-test")
c.Assert(err, jc.ErrorIsNil)
s.assertShowController(c, "--format", "json")
}
func (s *cmdControllerSuite) TestControllerModelsCommand(c *gc.C) {
c.Assert(modelcmd.WriteCurrentController("dummymodel"), jc.ErrorIsNil)
s.createEnv(c, "new-model", false)
context := s.run(c, "list-models")
c.Assert(testing.Stdout(context), gc.Equals, ""+
"NAME OWNER LAST CONNECTION\n"+
"dummymodel dummy-admin@local just now\n"+
"new-model dummy-admin@local never connected\n"+
"\n")
}
func (s *ControllerCommandSuite) TestControllerCommandInitSystemFile(c *gc.C) {
// If there is a current-controller file, use that.
err := modelcmd.WriteCurrentController("foo")
c.Assert(err, jc.ErrorIsNil)
store := jujuclienttesting.NewMemStore()
store.Accounts["foo"] = &jujuclient.ControllerAccounts{
CurrentAccount: "bar@baz",
}
store.Controllers["foo"] = jujuclient.ControllerDetails{}
testEnsureControllerName(c, store, "foo")
}
func (s *cmdControllerSuite) TestRemoveBlocks(c *gc.C) {
c.Assert(modelcmd.WriteCurrentController("dummymodel"), jc.ErrorIsNil)
s.State.SwitchBlockOn(state.DestroyBlock, "TestBlockDestroyModel")
s.State.SwitchBlockOn(state.ChangeBlock, "TestChangeBlock")
s.run(c, "remove-all-blocks")
blocks, err := s.State.AllBlocksForController()
c.Assert(err, jc.ErrorIsNil)
c.Assert(blocks, gc.HasLen, 0)
}
func (s *SubStorageSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
err := modelcmd.WriteCurrentController("testing")
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["testing"] = jujuclient.ControllerDetails{}
s.store.Accounts["testing"] = &jujuclient.ControllerAccounts{
CurrentAccount: "admin@local",
}
}
func (s *cmdControllerSuite) TestListBlocks(c *gc.C) {
c.Assert(modelcmd.WriteCurrentController("dummymodel"), jc.ErrorIsNil)
s.State.SwitchBlockOn(state.DestroyBlock, "TestBlockDestroyModel")
s.State.SwitchBlockOn(state.ChangeBlock, "TestChangeBlock")
ctx := s.run(c, "list-all-blocks", "--format", "json")
expected := fmt.Sprintf(`[{"name":"dummymodel","model-uuid":"%s","owner-tag":"%s","blocks":["BlockDestroy","BlockChange"]}]`,
s.State.ModelUUID(), s.AdminUserTag(c).String())
strippedOut := strings.Replace(testing.Stdout(ctx), "\n", "", -1)
c.Check(strippedOut, gc.Equals, expected)
}
func (s *BaseActionSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.modelFlags = []string{"-m", "--model"}
err := modelcmd.WriteCurrentController("ctrl")
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Accounts["ctrl"] = &jujuclient.ControllerAccounts{
CurrentAccount: "admin@local",
}
}
func (s *ControllerCommandSuite) TestControllerCommandInitExplicit(c *gc.C) {
// Take controller name from command line arg, and it trumps the current-
// controller file.
err := modelcmd.WriteCurrentController("foo")
c.Assert(err, jc.ErrorIsNil)
store := jujuclienttesting.NewMemStore()
store.Accounts["explicit"] = &jujuclient.ControllerAccounts{
CurrentAccount: "bar@baz",
}
store.Controllers["explicit"] = jujuclient.ControllerDetails{}
testEnsureControllerName(c, store, "explicit", "-c", "explicit")
testEnsureControllerName(c, store, "explicit", "--controller", "explicit")
}
func (s *syncToolsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.fakeSyncToolsAPI = &fakeSyncToolsAPI{}
s.PatchValue(&getSyncToolsAPI, func(c *syncToolsCommand) (syncToolsAPI, error) {
return s.fakeSyncToolsAPI, nil
})
err := modelcmd.WriteCurrentController("ctrl")
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Accounts["ctrl"] = &jujuclient.ControllerAccounts{
CurrentAccount: "admin@local",
}
}
func (s *ModelCommandSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.PatchEnvironment("JUJU_CLI_VERSION", "")
err := modelcmd.WriteCurrentController("foo")
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Accounts["foo"] = &jujuclient.ControllerAccounts{
Accounts: map[string]jujuclient.AccountDetails{
"bar@baz": {User: "******", Password: "******"},
},
CurrentAccount: "bar@baz",
}
}
func (s *MigrateSuite) SetUpTest(c *gc.C) {
s.SetInitialFeatureFlags(feature.Migration)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.store = jujuclienttesting.NewMemStore()
// Define the source controller in the config and set it as the default.
err := s.store.UpdateController("source", jujuclient.ControllerDetails{
ControllerUUID: "eeeeeeee-0bad-400d-8000-4b1d0d06f00d",
CACert: "somecert",
})
c.Assert(err, jc.ErrorIsNil)
err = modelcmd.WriteCurrentController("source")
c.Assert(err, jc.ErrorIsNil)
// Define an account for the model in the source controller in the config.
err = s.store.UpdateAccount("source", "source@local", jujuclient.AccountDetails{
User: "******",
})
c.Assert(err, jc.ErrorIsNil)
err = s.store.SetCurrentAccount("source", "source@local")
c.Assert(err, jc.ErrorIsNil)
// Define the model to migrate in the config.
err = s.store.UpdateModel("source", "source@local", "model", jujuclient.ModelDetails{
ModelUUID: modelUUID,
})
c.Assert(err, jc.ErrorIsNil)
// Define the account for the target controller.
err = s.store.UpdateAccount("target", "target@local", jujuclient.AccountDetails{
User: "******",
Password: "******",
})
c.Assert(err, jc.ErrorIsNil)
err = s.store.SetCurrentAccount("target", "target@local")
c.Assert(err, jc.ErrorIsNil)
// Define the target controller in the config.
err = s.store.UpdateController("target", jujuclient.ControllerDetails{
ControllerUUID: targetControllerUUID,
APIEndpoints: []string{"1.2.3.4:5"},
CACert: "cert",
})
c.Assert(err, jc.ErrorIsNil)
s.api = &fakeMigrateAPI{}
}
func (s *ModelsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
err := modelcmd.WriteCurrentController("fake")
c.Assert(err, jc.ErrorIsNil)
last1 := time.Date(2015, 3, 20, 0, 0, 0, 0, time.UTC)
last2 := time.Date(2015, 3, 1, 0, 0, 0, 0, time.UTC)
models := []base.UserModel{
{
Name: "test-model1",
Owner: "user-admin@local",
UUID: "test-model1-UUID",
LastConnection: &last1,
}, {
Name: "test-model2",
Owner: "user-admin@local",
UUID: "test-model2-UUID",
LastConnection: &last2,
}, {
Name: "test-model3",
Owner: "user-admin@local",
UUID: "test-model3-UUID",
},
}
s.api = &fakeModelMgrAPIClient{models: models}
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers["fake"] = jujuclient.ControllerDetails{}
s.store.Models["fake"] = jujuclient.ControllerAccountModels{
AccountModels: map[string]*jujuclient.AccountModels{
"admin@local": {
CurrentModel: "test-model1",
},
},
}
s.store.Accounts["fake"] = &jujuclient.ControllerAccounts{
Accounts: map[string]jujuclient.AccountDetails{
"admin@local": {
User: "******",
Password: "******",
},
},
CurrentAccount: "admin@local",
}
}