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