func (s *JujuConnSuite) tearDownConn(c *gc.C) {
serverAlive := gitjujutesting.MgoServer.Addr() != ""
// Bootstrap will set the admin password, and render non-authorized use
// impossible. s.State may still hold the right password, so try to reset
// the password so that the MgoSuite soft-resetting works. If that fails,
// it will still work, but it will take a while since it has to kill the
// whole database and start over.
if err := s.State.SetAdminMongoPassword(""); err != nil && serverAlive {
c.Logf("cannot reset admin password: %v", err)
}
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
}
err := s.Conn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
err = s.APIConn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
dummy.Reset()
s.apiStates = nil
s.Conn = nil
s.State = nil
utils.SetHome(s.oldHome)
osenv.SetJujuHome(s.oldJujuHome)
s.oldHome = ""
s.RootDir = ""
}
func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) {
for i, t := range errTests {
c.Logf("test: %d", i)
_, err := runImageMetadata(c, s.store, t.args...)
c.Check(err, gc.NotNil, gc.Commentf("test %d: %s", i, t.args))
dummy.Reset(c)
}
}
func (s *SimpleStreamsToolsSuite) resetEnv(c *gc.C, attrs map[string]interface{}) {
version.Current = s.origCurrentVersion
dummy.Reset()
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(attrs))
c.Assert(err, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, envtesting.BootstrapContext(c), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
s.env = env
s.removeTools(c)
}
func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) {
testing.MakeSampleJujuHome(c)
s.AddCleanup(func(*gc.C) {
dummy.Reset()
})
for i, t := range errTests {
c.Logf("test: %d", i)
ctx := testing.Context(c)
code := cmd.Main(envcmd.Wrap(&ImageMetadataCommand{}), ctx, t.args)
c.Check(code, gc.Equals, 1)
}
}
func (s *bootstrapSuite) TestBootstrapTools(c *gc.C) {
s.PatchValue(&envtools.BundleTools, toolstesting.GetMockBundleTools(c))
allTests := append(envtesting.BootstrapToolsTests, bootstrapSetAgentVersionTests...)
// version.Current is set in the loop so ensure it is restored later.
s.PatchValue(&version.Current, version.Current)
for i, test := range allTests {
c.Logf("\ntest %d: %s", i, test.Info)
dummy.Reset()
attrs := dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"development": test.Development,
"default-series": test.DefaultSeries,
})
if test.AgentVersion != version.Zero {
attrs["agent-version"] = test.AgentVersion.String()
}
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, env)
version.Current = test.CliVersion
envtesting.AssertUploadFakeToolsVersions(c, env.Storage(), test.Available...)
// Remove the default tools URL from the search path, just look in cloud storage.
s.PatchValue(&envtools.DefaultBaseURL, "")
cons := constraints.Value{}
if test.Arch != "" {
cons = constraints.MustParse("arch=" + test.Arch)
}
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{Constraints: cons})
if test.Err != "" {
c.Check(err, gc.NotNil)
if err != nil {
stripped := strings.Replace(err.Error(), "\n", "", -1)
c.Check(stripped, gc.Matches, ".*"+stripped)
}
continue
} else {
c.Check(err, gc.IsNil)
}
unique := map[version.Number]bool{}
for _, expected := range test.Expect {
unique[expected.Number] = true
}
for expectAgentVersion := range unique {
agentVersion, ok := env.Config().AgentVersion()
c.Check(ok, gc.Equals, true)
c.Check(agentVersion, gc.Equals, expectAgentVersion)
}
}
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C, envName string) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, jc.ErrorIsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, jc.ErrorIsNil)
env, err := environs.PrepareFromName(envName, envcmd.BootstrapContext(cmdtesting.NullContext(c)), store)
c.Assert(err, jc.ErrorIsNil)
return env
}
// resetJujuHome restores an new, clean Juju home environment without tools.
func resetJujuHome(c *gc.C) environs.Environ {
jenvDir := gitjujutesting.HomePath(".juju", "environments")
err := os.RemoveAll(jenvDir)
c.Assert(err, gc.IsNil)
coretesting.WriteEnvironments(c, envConfig)
dummy.Reset()
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
env, err := environs.PrepareFromName("peckham", cmdtesting.NullContext(c), store)
c.Assert(err, gc.IsNil)
envtesting.RemoveAllTools(c, env)
return env
}
func (s *ConnSuite) TearDownTest(c *gc.C) {
if s.conn == nil {
return
}
err := s.conn.State.SetAdminMongoPassword("")
c.Assert(err, gc.IsNil)
err = s.conn.Environ.Destroy()
c.Check(err, gc.IsNil)
assertClose(c, s.conn)
s.conn = nil
dummy.Reset()
s.ToolsFixture.TearDownTest(c)
s.MgoSuite.TearDownTest(c)
s.BaseSuite.TearDownTest(c)
}
func (s *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.AddCleanup(func(*gc.C) {
dummy.Reset()
loggo.ResetLoggers()
})
env, err := environs.PrepareFromName(
"erewhemos", envcmd.BootstrapContextNoVerify(coretesting.Context(c)), configstore.NewMem())
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 *SimpleStreamsToolsSuite) resetEnv(c *gc.C, attrs map[string]interface{}) {
jujuversion.Current = s.origCurrentVersion
dummy.Reset(c)
attrs = dummy.SampleConfig().Merge(attrs)
env, err := environs.Prepare(envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
environs.PrepareParams{
ControllerName: attrs["name"].(string),
BaseConfig: attrs,
CloudName: "dummy",
},
)
c.Assert(err, jc.ErrorIsNil)
s.env = env
s.removeTools(c)
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
testServer := gitjujutesting.MgoServer.Addr()
serverAlive := testServer != ""
// Bootstrap will set the admin password, and render non-authorized use
// impossible. s.State may still hold the right password, so try to reset
// the password so that the MgoSuite soft-resetting works. If that fails,
// it will still work, but it will take a while since it has to kill the
// whole database and start over.
if s.State != nil {
if err := s.State.SetAdminMongoPassword(""); err != nil && serverAlive {
c.Logf("cannot reset admin password: %v", err)
}
err := s.State.Close()
if serverAlive {
// This happens way too often with failing tests,
// so add some context in case of an error.
c.Check(
err,
gc.IsNil,
gc.Commentf("closing state failed, testing server %q is alive", testServer),
)
}
s.State = nil
}
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Check(err, gc.IsNil)
}
}
s.apiStates = nil
if s.APIState != nil {
err := s.APIState.Close()
s.APIState = nil
if serverAlive {
c.Check(err, gc.IsNil)
}
}
dummy.Reset()
utils.SetHome(s.oldHome)
osenv.SetJujuHome(s.oldJujuHome)
s.oldHome = ""
s.RootDir = ""
}
func (s *SimpleStreamsToolsSuite) resetEnv(c *gc.C, attrs map[string]interface{}) {
jujuversion.Current = s.origCurrentVersion
dummy.Reset(c)
attrs = dummy.SampleConfig().Merge(attrs)
env, err := bootstrap.Prepare(envtesting.BootstrapContext(c),
jujuclienttesting.NewMemStore(),
bootstrap.PrepareParams{
ControllerConfig: coretesting.FakeControllerConfig(),
ControllerName: attrs["name"].(string),
ModelConfig: attrs,
Cloud: dummy.SampleCloudSpec(),
AdminSecret: "admin-secret",
},
)
c.Assert(err, jc.ErrorIsNil)
s.env = env
s.removeTools(c)
}
func (s *BootstrapSuite) TestBootstrapAPIReadyRetries(c *gc.C) {
s.PatchValue(&bootstrapReadyPollDelay, 1*time.Millisecond)
s.PatchValue(&bootstrapReadyPollCount, 5)
defaultSeriesVersion := jujuversion.Current
// 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(&jujuversion.Current, defaultSeriesVersion)
for _, t := range []struct {
numRetries int
err error
}{
{0, nil}, // agent ready immediately
{2, nil}, // agent ready after 2 polls
{6, &rpc.RequestError{
Message: params.CodeUpgradeInProgress,
Code: params.CodeUpgradeInProgress,
}}, // agent ready after 6 polls but that's too long
{-1, errOther}, // another error is returned
} {
resetJujuXDGDataHome(c)
dummy.Reset(c)
s.store = jujuclienttesting.NewMemStore()
s.mockBlockClient.numRetries = t.numRetries
s.mockBlockClient.retryCount = 0
_, err := coretesting.RunCommand(
c, s.newBootstrapCommand(),
"devcontroller", "dummy", "--auto-upgrade",
)
c.Check(errors.Cause(err), gc.DeepEquals, t.err)
expectedRetries := t.numRetries
if t.numRetries <= 0 {
expectedRetries = 1
}
// Only retry maximum of bootstrapReadyPollCount times.
if expectedRetries > 5 {
expectedRetries = 5
}
c.Check(s.mockBlockClient.retryCount, gc.Equals, expectedRetries)
}
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
testServer := gitjujutesting.MgoServer.Addr()
serverAlive := testServer != ""
// Close any api connections we know about first.
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Check(err, jc.ErrorIsNil)
}
}
s.apiStates = nil
if s.APIState != nil {
err := s.APIState.Close()
s.APIState = nil
if serverAlive {
c.Check(err, gc.IsNil,
gc.Commentf("closing api state failed\n%s\n", errors.ErrorStack(err)),
)
}
}
// Close state.
if s.State != nil {
err := s.State.Close()
if serverAlive {
// This happens way too often with failing tests,
// so add some context in case of an error.
c.Check(err, gc.IsNil,
gc.Commentf("closing state failed\n%s\n", errors.ErrorStack(err)),
)
}
s.State = nil
}
dummy.Reset(c)
err := utils.SetHome(s.oldHome)
c.Assert(err, jc.ErrorIsNil)
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
s.oldHome = ""
s.RootDir = ""
}
func (s *APIEndpointForEnvSuite) TestAPIEndpointNotCached(c *gc.C) {
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
ctx := coretesting.Context(c)
env, err := environs.PrepareFromName("erewhemos", ctx, store)
c.Assert(err, gc.IsNil)
defer dummy.Reset()
envtesting.UploadFakeTools(c, env.Storage())
err = bootstrap.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// Note: if we get Bootstrap to start caching the API endpoint
// immediately, we'll still want to have this test for compatibility.
// We can just write blank info instead of reading and checking it is empty.
savedInfo, err := store.ReadInfo("erewhemos")
c.Assert(err, gc.IsNil)
// Ensure that the data isn't cached
c.Check(savedInfo.APIEndpoint().Addresses, gc.HasLen, 0)
called := 0
expectState := mockedAPIState(true, true)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, "user-admin")
c.Check(string(apiInfo.CACert), gc.Equals, coretesting.CACert)
c.Check(apiInfo.Password, gc.Equals, coretesting.DefaultMongoPassword)
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
// we didn't know about it when connecting
c.Check(apiInfo.EnvironTag, gc.Equals, "")
called++
return expectState, nil
}
endpoint, err := juju.APIEndpointInStore("erewhemos", false, store, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(called, gc.Equals, 1)
c.Check(endpoint.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
c.Check(endpoint.EnvironUUID, gc.Equals, "fake-uuid")
}
func (s *syncSuite) tearDownTest(c *gc.C) {
dummy.Reset()
version.Current = s.origVersion
s.ToolsFixture.TearDownTest(c)
s.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *BootstrapSuite) TearDownSuite(c *gc.C) {
s.MgoSuite.TearDownSuite(c)
s.BaseSuite.TearDownSuite(c)
dummy.Reset()
}
func (s *uploadSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.ToolsFixture.TearDownTest(c)
s.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *badBuildSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.ToolsFixture.TearDownTest(c)
s.LoggingSuite.TearDownTest(c)
s.CleanupSuite.TearDownTest(c)
}
func (s *SimpleStreamsToolsSuite) TearDownTest(c *gc.C) {
dummy.Reset()
version.Current = s.origCurrentVersion
s.ToolsFixture.TearDownTest(c)
s.BaseSuite.TearDownTest(c)
}
func (cs *NewAPIClientSuite) TearDownTest(c *gc.C) {
dummy.Reset()
cs.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *URLsSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.BaseSuite.TearDownTest(c)
}
func (s *BootstrapSuite) TearDownTest(c *gc.C) {
s.ToolsFixture.TearDownTest(c)
s.MgoSuite.TearDownTest(c)
s.FakeJujuHomeSuite.TearDownTest(c)
dummy.Reset()
}
func (cs *NewAPIStateSuite) TearDownTest(c *gc.C) {
dummy.Reset()
cs.ToolsFixture.TearDownTest(c)
cs.MgoSuite.TearDownTest(c)
cs.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *AddresserSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.BaseSuite.TearDownTest(c)
}
func (s *ConfigSuite) TearDownTest(c *gc.C) {
s.BaseSuite.TearDownTest(c)
dummy.Reset()
}
func (s *OpenSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *checkEnvironmentSuite) TearDownTest(c *gc.C) {
dummy.Reset()
s.FakeJujuHomeSuite.TearDownTest(c)
}
func (s *suite) TearDownTest(c *gc.C) {
s.Tests.TearDownTest(c)
dummy.Reset()
s.BaseSuite.TearDownTest(c)
}
func (s *syncToolsSuite) TearDownTest(c *gc.C) {
syncTools = s.origSyncTools
dummy.Reset()
s.FakeJujuHomeSuite.TearDownTest(c)
}