func (s *ImageMetadataSuite) env(c *gc.C, imageMetadataURL, stream string) environs.Environ {
attrs := dummy.SampleConfig()
if stream != "" {
attrs = attrs.Merge(testing.Attrs{
"image-stream": stream,
})
}
if imageMetadataURL != "" {
attrs = attrs.Merge(testing.Attrs{
"image-metadata-url": imageMetadataURL,
})
}
env, err := bootstrap.Prepare(
envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: testing.FakeControllerConfig(),
ControllerName: attrs["name"].(string),
ModelConfig: attrs,
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
return env
}
func (s *NewAPIClientSuite) bootstrapModel(c *gc.C) (environs.Environ, jujuclient.ClientStore) {
const controllerName = "local.my-controller"
store := jujuclienttesting.NewMemStore()
ctx := envtesting.BootstrapContext(c)
env, err := environs.Prepare(ctx, store, environs.PrepareParams{
ControllerName: controllerName,
BaseConfig: dummy.SampleConfig(),
CloudName: "dummy",
})
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, "released", "released")
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{})
c.Assert(err, jc.ErrorIsNil)
return env, store
}
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 *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.AddCleanup(dummy.Reset)
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"name": "erewhemos",
"type": "dummy",
"uuid": coretesting.ModelTag.Id(),
"controller-uuid": coretesting.ControllerTag.Id(),
"conroller": true,
})
c.Assert(err, jc.ErrorIsNil)
env, err := bootstrap.Prepare(
modelcmd.BootstrapContextNoVerify(coretesting.Context(c)),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: coretesting.FakeControllerConfig(),
ControllerName: cfg.Name(),
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
s.env = env
loggo.GetLogger("").SetLogLevel(loggo.INFO)
// Switch the default tools location.
s.publicStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.publicStorageDir)
}
func (s *ListControllersSuite) TestListControllersEmptyStore(c *gc.C) {
s.store = jujuclienttesting.NewMemStore()
context, err := s.runListControllers(c)
c.Assert(err, jc.ErrorIsNil)
c.Check(testing.Stdout(context), gc.Equals, "")
c.Check(testing.Stderr(context), gc.Equals, modelcmd.ErrNoControllersDefined.Error())
}
func (s *credentialsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.cloud = cloud.Cloud{
Type: "fake",
Regions: []cloud.Region{
{Name: "first-region"},
{Name: "second-region"},
},
}
dir := c.MkDir()
keyFile := filepath.Join(dir, "keyfile")
err := ioutil.WriteFile(keyFile, []byte("value"), 0600)
c.Assert(err, jc.ErrorIsNil)
s.store = jujuclienttesting.NewMemStore()
s.store.Credentials["cloud"] = cloud.CloudCredential{
DefaultRegion: "second-region",
AuthCredentials: map[string]cloud.Credential{
"interactive": cloud.NewCredential("interactive", map[string]string{
"username": "******",
}),
"secrets": cloud.NewCredential(cloud.UserPassAuthType, map[string]string{
"username": "******",
"password": "******",
"key-file": keyFile,
}),
},
}
}
func (s *credentialsSuite) assertGetCredentials(c *gc.C, region string) {
dir := c.MkDir()
keyFile := filepath.Join(dir, "keyfile")
err := ioutil.WriteFile(keyFile, []byte("value"), 0600)
c.Assert(err, jc.ErrorIsNil)
store := jujuclienttesting.NewMemStore()
store.Credentials["cloud"] = cloud.CloudCredential{
DefaultRegion: "default-region",
AuthCredentials: map[string]cloud.Credential{
"secrets": cloud.NewCredential(cloud.UserPassAuthType, map[string]string{
"username": "******",
"password": "******",
"key-file": keyFile,
}),
},
}
credential, credentialName, regionName, err := modelcmd.GetCredentials(
store, region, "secrets", "cloud", "fake",
)
c.Assert(err, jc.ErrorIsNil)
expectedRegion := region
if expectedRegion == "" {
expectedRegion = "default-region"
}
c.Assert(regionName, gc.Equals, expectedRegion)
c.Assert(credentialName, gc.Equals, "secrets")
c.Assert(credential.Attributes(), jc.DeepEquals, map[string]string{
"key": "value",
"username": "******",
"password": "******",
})
}
func (s *SwitchSimpleSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.Stub.ResetCalls()
s.store = jujuclienttesting.NewMemStore()
s.stubStore = jujuclienttesting.WrapClientStore(s.store)
s.onRefresh = nil
}
func (s *BootstrapSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.MgoSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
// Set jujuversion.Current to a known value, for which we
// will make tools available. Individual tests may
// override this.
s.PatchValue(&jujuversion.Current, v100p64.Number)
s.PatchValue(&arch.HostArch, func() string { return v100p64.Arch })
s.PatchValue(&series.HostSeries, func() string { return v100p64.Series })
s.PatchValue(&jujuos.HostOS, func() jujuos.OSType { return jujuos.Ubuntu })
// Set up a local source with tools.
sourceDir := createToolsSource(c, vAll)
s.PatchValue(&envtools.DefaultBaseURL, sourceDir)
s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c))
s.PatchValue(&waitForAgentInitialisation, func(*cmd.Context, *modelcmd.ModelCommandBase, string) error {
return nil
})
// TODO(wallyworld) - add test data when tests are improved
s.store = jujuclienttesting.NewMemStore()
}
func (t *localNonUSEastSuite) SetUpTest(c *gc.C) {
t.BaseSuite.SetUpTest(c)
t.srv.config = &s3test.Config{
Send409Conflict: true,
}
t.srv.startServer(c)
env, err := environs.Prepare(
envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
BaseConfig: localConfigAttrs,
Credential: cloud.NewCredential(
cloud.AccessKeyAuthType,
map[string]string{
"access-key": "x",
"secret-key": "x",
},
),
ControllerName: localConfigAttrs["name"].(string),
CloudName: "ec2",
CloudRegion: "test",
},
)
c.Assert(err, jc.ErrorIsNil)
t.env = env
}
func (s *AddModelSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.fakeAddModelAPI = &fakeAddClient{
model: base.ModelInfo{
Name: "test",
UUID: "fake-model-uuid",
Owner: "ignored-for-now",
},
}
s.fakeCloudAPI = &fakeCloudAPI{}
// Set up the current controller, and write just enough info
// so we don't try to refresh
controllerName := "test-master"
s.store = jujuclienttesting.NewMemStore()
s.store.CurrentControllerName = controllerName
s.store.Controllers[controllerName] = jujuclient.ControllerDetails{}
s.store.Accounts[controllerName] = jujuclient.AccountDetails{
User: "******",
}
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 (*OpenSuite) TestDestroy(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(
testing.Attrs{
"name": "erewhemos",
},
))
c.Assert(err, jc.ErrorIsNil)
store := jujuclienttesting.NewMemStore()
// Prepare the environment and sanity-check that
// the config storage info has been made.
controllerCfg := testing.FakeControllerConfig()
ctx := envtesting.BootstrapContext(c)
e, err := bootstrap.Prepare(ctx, store, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: "controller-name",
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
_, err = store.ControllerByName("controller-name")
c.Assert(err, jc.ErrorIsNil)
err = environs.Destroy("controller-name", e, store)
c.Assert(err, jc.ErrorIsNil)
// Check that the environment has actually been destroyed
// and that the controller details been removed too.
_, err = e.ControllerInstances(controllerCfg.ControllerUUID())
c.Assert(err, gc.ErrorMatches, "model is not prepared")
_, err = store.ControllerByName("controller-name")
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
// newClientStore returns a client store that contains information
// based on the given controller namd and info.
func newClientStore(c *gc.C, controllerName string) *jujuclienttesting.MemStore {
store := jujuclienttesting.NewMemStore()
err := store.UpdateController(controllerName, jujuclient.ControllerDetails{
ControllerUUID: fakeUUID,
CACert: "certificate",
APIEndpoints: []string{"foo.invalid"},
})
c.Assert(err, jc.ErrorIsNil)
err = store.UpdateModel(controllerName, "admin@local", "admin", jujuclient.ModelDetails{
fakeUUID,
})
c.Assert(err, jc.ErrorIsNil)
// Models belong to accounts, so we must have an account even
// if "creds" is not initialised. If it is, it may overwrite
// this one.
err = store.UpdateAccount(controllerName, "admin@local", jujuclient.AccountDetails{
User: "******",
Password: "******",
})
c.Assert(err, jc.ErrorIsNil)
err = store.SetCurrentAccount(controllerName, "admin@local")
c.Assert(err, jc.ErrorIsNil)
return store
}
func (s *funcSuite) SetUpTest(c *gc.C) {
s.baseImageMetadataSuite.SetUpTest(c)
var err error
s.env, err = environs.Prepare(
envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
ControllerName: "dummycontroller",
BaseConfig: mockConfig(),
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
s.state = s.constructState(s.env.Config())
s.expected = cloudimagemetadata.Metadata{
cloudimagemetadata.MetadataAttributes{
Stream: "released",
Source: "custom",
Series: config.LatestLtsSeries(),
Arch: "amd64",
Region: "dummy_region",
},
0,
"",
}
}
func (s *OpenSuite) TestUpdateEnvInfo(c *gc.C) {
store := jujuclienttesting.NewMemStore()
ctx := envtesting.BootstrapContext(c)
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"type": "dummy",
"name": "admin-model",
"controller-uuid": utils.MustNewUUID().String(),
"uuid": utils.MustNewUUID().String(),
})
c.Assert(err, jc.ErrorIsNil)
_, err = environs.Prepare(ctx, store, environs.PrepareParams{
ControllerName: "controller-name",
BaseConfig: cfg.AllAttrs(),
CloudName: "dummy",
})
c.Assert(err, jc.ErrorIsNil)
foundController, err := store.ControllerByName("controller-name")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundController.ControllerUUID, gc.Equals, cfg.ControllerUUID())
c.Assert(foundController.CACert, gc.Not(gc.Equals), "")
foundModel, err := store.ModelByName("controller-name", "admin@local", "admin-model")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundModel, jc.DeepEquals, &jujuclient.ModelDetails{
ModelUUID: cfg.UUID(),
})
}
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 *RegisterSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.apiOpenError = nil
s.httpHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
s.server = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.httpHandler.ServeHTTP(w, r)
}))
serverURL, err := url.Parse(s.server.URL)
c.Assert(err, jc.ErrorIsNil)
s.apiConnection = &mockAPIConnection{
controllerTag: names.NewControllerTag(mockControllerUUID),
addr: serverURL.Host,
}
s.listModelsControllerName = ""
s.listModelsUserName = ""
s.listModels = func(_ jujuclient.ClientStore, controllerName, userName string) ([]base.UserModel, error) {
s.listModelsControllerName = controllerName
s.listModelsUserName = userName
return nil, nil
}
s.store = jujuclienttesting.NewMemStore()
}
func (s *macaroonLoginSuite) SetUpTest(c *gc.C) {
s.MacaroonSuite.SetUpTest(c)
s.MacaroonSuite.AddModelUser(c, testUser)
s.controllerName = "my-controller"
s.accountName = "my@account"
s.modelName = "my-model"
modelTag := names.NewModelTag(s.State.ModelUUID())
apiInfo := s.APIInfo(c)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers[s.controllerName] = jujuclient.ControllerDetails{
APIEndpoints: apiInfo.Addrs,
ControllerUUID: apiInfo.ModelTag.Id(),
CACert: apiInfo.CACert,
}
s.store.Accounts[s.controllerName] = &jujuclient.ControllerAccounts{
Accounts: map[string]jujuclient.AccountDetails{
// Empty password forces use of macaroons.
s.accountName: {User: s.accountName},
},
CurrentAccount: s.accountName,
}
s.store.Models[s.controllerName] = jujuclient.ControllerAccountModels{
AccountModels: map[string]*jujuclient.AccountModels{
s.accountName: {
Models: map[string]jujuclient.ModelDetails{
s.modelName: {modelTag.Id()},
},
},
},
}
}
func (s *OpenSuite) TestNewDummyEnviron(c *gc.C) {
s.PatchValue(&jujuversion.Current, testing.FakeVersionNumber)
// matches *Settings.Map()
cfg, err := config.New(config.NoDefaults, dummySampleConfig())
c.Assert(err, jc.ErrorIsNil)
ctx := envtesting.BootstrapContext(c)
cache := jujuclienttesting.NewMemStore()
controllerCfg := testing.FakeControllerConfig()
env, err := bootstrap.Prepare(ctx, cache, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: cfg.Name(),
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
storageDir := c.MkDir()
s.PatchValue(&envtools.DefaultBaseURL, storageDir)
stor, err := filestorage.NewFileStorageWriter(storageDir)
c.Assert(err, jc.ErrorIsNil)
envtesting.UploadFakeTools(c, stor, cfg.AgentStream(), cfg.AgentStream())
err = bootstrap.Bootstrap(ctx, env, bootstrap.BootstrapParams{
ControllerConfig: controllerCfg,
AdminSecret: "admin-secret",
CAPrivateKey: testing.CAKey,
})
c.Assert(err, jc.ErrorIsNil)
// New controller should have been added to collection.
foundController, err := cache.ControllerByName(cfg.Name())
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundController.ControllerUUID, gc.DeepEquals, controllerCfg.ControllerUUID())
}
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 := "test-master"
s.store = jujuclienttesting.NewMemStore()
s.store.CurrentControllerName = controllerName
s.store.Controllers[controllerName] = jujuclient.ControllerDetails{}
s.store.Accounts[controllerName] = jujuclient.AccountDetails{
User: "******",
}
s.store.Models = map[string]*jujuclient.ControllerModels{
controllerName: {
Models: map[string]jujuclient.ModelDetails{
"bob/foo": jujuclient.ModelDetails{fooModelUUID},
"bob/bar": jujuclient.ModelDetails{barModelUUID},
"bob/baz": jujuclient.ModelDetails{bazModelUUID},
"bob/model1": jujuclient.ModelDetails{model1ModelUUID},
"bob/model2": jujuclient.ModelDetails{model2ModelUUID},
},
},
}
}
func (s *OpenSuite) TestUpdateEnvInfo(c *gc.C) {
store := jujuclienttesting.NewMemStore()
ctx := envtesting.BootstrapContext(c)
uuid := utils.MustNewUUID().String()
cfg, err := config.New(config.UseDefaults, map[string]interface{}{
"type": "dummy",
"name": "admin-model",
"uuid": uuid,
})
c.Assert(err, jc.ErrorIsNil)
controllerCfg := testing.FakeControllerConfig()
_, err = bootstrap.Prepare(ctx, store, bootstrap.PrepareParams{
ControllerConfig: controllerCfg,
ControllerName: "controller-name",
ModelConfig: cfg.AllAttrs(),
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
})
c.Assert(err, jc.ErrorIsNil)
foundController, err := store.ControllerByName("controller-name")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundController.ControllerUUID, gc.Not(gc.Equals), "")
c.Assert(foundController.CACert, gc.Not(gc.Equals), "")
foundModel, err := store.ModelByName("controller-name", "admin/admin-model")
c.Assert(err, jc.ErrorIsNil)
c.Assert(foundModel, jc.DeepEquals, &jujuclient.ModelDetails{
ModelUUID: cfg.UUID(),
})
}
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 *SwitchSimpleSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.Stub.ResetCalls()
s.store = jujuclienttesting.NewMemStore()
s.currentController = ""
s.onRefresh = nil
}
func (s *macaroonLoginSuite) SetUpTest(c *gc.C) {
s.MacaroonSuite.SetUpTest(c)
s.MacaroonSuite.AddModelUser(c, testUser)
s.MacaroonSuite.AddControllerUser(c, testUser, permission.LoginAccess)
s.controllerName = "my-controller"
s.modelName = testUser + "/my-model"
modelTag := names.NewModelTag(s.State.ModelUUID())
apiInfo := s.APIInfo(c)
s.store = jujuclienttesting.NewMemStore()
s.store.Controllers[s.controllerName] = jujuclient.ControllerDetails{
APIEndpoints: apiInfo.Addrs,
ControllerUUID: s.State.ControllerUUID(),
CACert: apiInfo.CACert,
}
s.store.Accounts[s.controllerName] = jujuclient.AccountDetails{
// External user forces use of macaroons.
User: "******",
}
s.store.Models[s.controllerName] = &jujuclient.ControllerModels{
Models: map[string]jujuclient.ModelDetails{
s.modelName: {modelTag.Id()},
},
}
}
func (s *ModelsSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
models := []base.UserModel{
{
Name: "test-model1",
Owner: "admin",
UUID: "test-model1-UUID",
}, {
Name: "test-model2",
Owner: "carlotta",
UUID: "test-model2-UUID",
}, {
Name: "test-model3",
Owner: "daiwik@external",
UUID: "test-model3-UUID",
},
}
s.api = &fakeModelMgrAPIClient{
models: models,
user: "******",
}
s.store = jujuclienttesting.NewMemStore()
s.store.CurrentControllerName = "fake"
s.store.Controllers["fake"] = jujuclient.ControllerDetails{}
s.store.Models["fake"] = &jujuclient.ControllerModels{
CurrentModel: "admin/test-model1",
}
s.store.Accounts["fake"] = jujuclient.AccountDetails{
User: "******",
Password: "******",
}
}
func (s *Suite) SetUpTest(c *gc.C) {
// Set up InitialConfig with a dummy provider configuration. This
// is required to allow model import test to work.
env, err := environs.Prepare(
modelcmd.BootstrapContext(testing.Context(c)),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
ControllerName: "dummycontroller",
BaseConfig: dummy.SampleConfig(),
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
s.InitialConfig = testing.CustomModelConfig(c, env.Config().AllAttrs())
// The call up to StateSuite's SetUpTest uses s.InitialConfig so
// it has to happen here.
s.StateSuite.SetUpTest(c)
s.resources = common.NewResources()
s.AddCleanup(func(*gc.C) { s.resources.StopAll() })
s.authorizer = apiservertesting.FakeAuthorizer{
Tag: s.Owner,
}
}
func (s *RegisterSuite) SetUpTest(c *gc.C) {
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
s.apiOpenError = nil
s.httpHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})
s.server = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
s.httpHandler.ServeHTTP(w, r)
}))
serverURL, err := url.Parse(s.server.URL)
c.Assert(err, jc.ErrorIsNil)
s.apiConnection = &mockAPIConnection{
controllerTag: testing.ModelTag,
addr: serverURL.Host,
}
s.refreshModelsControllerName = ""
s.refreshModelsAccountName = ""
s.refreshModels = func(store jujuclient.ClientStore, controllerName, accountName string) error {
s.refreshModelsControllerName = controllerName
s.refreshModelsAccountName = accountName
return nil
}
s.store = jujuclienttesting.NewMemStore()
}
func (s *enableDestroyControllerSuite) SetUpTest(c *gc.C) {
s.baseControllerSuite.SetUpTest(c)
s.api = &fakeRemoveBlocksAPI{}
s.store = jujuclienttesting.NewMemStore()
s.store.CurrentControllerName = "fake"
s.store.Controllers["fake"] = jujuclient.ControllerDetails{}
}
func (s *removeCredentialSuite) TestBadCloudName(c *gc.C) {
cmd := cloud.NewRemoveCredentialCommandForTest(jujuclienttesting.NewMemStore())
ctx, err := testing.RunCommand(c, cmd, "somecloud", "foo")
c.Assert(err, jc.ErrorIsNil)
output := testing.Stderr(ctx)
output = strings.Replace(output, "\n", "", -1)
c.Assert(output, gc.Equals, `No credentials exist for cloud "somecloud"`)
}
func (s *controllerSuite) TestWaitForAgentAPIReadyWaitsForSpaceDiscovery(c *gc.C) {
s.mockBlockClient.discoveringSpacesError = 2
cmd := &modelcmd.ModelCommandBase{}
cmd.SetClientStore(jujuclienttesting.NewMemStore())
err := WaitForAgentInitialisation(cmdtesting.NullContext(c), cmd, "controller", "default")
c.Assert(err, jc.ErrorIsNil)
c.Assert(s.mockBlockClient.discoveringSpacesError, gc.Equals, 0)
}