// MakeConfig creates a functional environConfig for a test.
func MakeConfig(c *gc.C, attrs testing.Attrs) *environConfig {
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, testing.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
return env.(*joyentEnviron).Ecfg()
}
func (s *configSuite) TestBootstrapAsRoot(c *gc.C) {
s.PatchValue(local.CheckIfRoot, func() bool { return true })
env, err := local.Provider.Prepare(testing.Context(c), minimalConfig(c))
c.Assert(err, gc.IsNil)
err = env.Bootstrap(testing.Context(c), environs.BootstrapParams{})
c.Assert(err, gc.ErrorMatches, "bootstrapping a local environment must not be done as root")
}
// If the environment is configured not to require a public IP address for nodes,
// bootstrapping and starting an instance should occur without any attempt to
// allocate a public address.
func (s *localServerSuite) TestStartInstanceWithoutPublicIP(c *gc.C) {
cleanup := s.srv.Service.Nova.RegisterControlPoint(
"addFloatingIP",
func(sc hook.ServiceControl, args ...interface{}) error {
return fmt.Errorf("add floating IP should not have been called")
},
)
defer cleanup()
cleanup = s.srv.Service.Nova.RegisterControlPoint(
"addServerFloatingIP",
func(sc hook.ServiceControl, args ...interface{}) error {
return fmt.Errorf("add server floating IP should not have been called")
},
)
defer cleanup()
cfg, err := config.New(config.NoDefaults, s.TestConfig.Merge(coretesting.Attrs{
"use-floating-ip": false,
}))
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), s.ConfigStore)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := testing.AssertStartInstance(c, env, "100")
err = env.StopInstances(inst.Id())
c.Assert(err, gc.IsNil)
}
func (s *bootstrapSuite) TestBootstrapNeedsSettings(c *gc.C) {
env := newEnviron("bar", noKeysDefined, nil)
s.setDummyStorage(c, env)
fixEnv := func(key string, value interface{}) {
cfg, err := env.Config().Apply(map[string]interface{}{
key: value,
})
c.Assert(err, gc.IsNil)
env.cfg = cfg
}
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.ErrorMatches, "environment configuration has no admin-secret")
fixEnv("admin-secret", "whatever")
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.ErrorMatches, "environment configuration has no ca-cert")
fixEnv("ca-cert", coretesting.CACert)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.ErrorMatches, "environment configuration has no ca-private-key")
fixEnv("ca-private-key", coretesting.CAKey)
uploadTools(c, env)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
}
func (t *LiveTests) TestBootstrapWithDefaultSeries(c *gc.C) {
if !t.HasProvisioner {
c.Skip("HasProvisioner is false; cannot test deployment")
}
current := version.Current
other := current
other.Series = "quantal"
if current == other {
other.Series = "precise"
}
dummyCfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(coretesting.Attrs{
"state-server": false,
"name": "dummy storage",
}))
dummyenv, err := environs.Prepare(dummyCfg, coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
defer dummyenv.Destroy()
t.Destroy(c)
attrs := t.TestConfig.Merge(coretesting.Attrs{"default-series": other.Series})
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
env, err := environs.Prepare(cfg, coretesting.Context(c), t.ConfigStore)
c.Assert(err, gc.IsNil)
defer environs.Destroy(env, t.ConfigStore)
currentName := envtools.StorageName(current)
otherName := envtools.StorageName(other)
envStorage := env.Storage()
dummyStorage := dummyenv.Storage()
defer envStorage.Remove(otherName)
_, err = sync.Upload(dummyStorage, ¤t.Number)
c.Assert(err, gc.IsNil)
// This will only work while cross-compiling across releases is safe,
// which depends on external elements. Tends to be safe for the last
// few releases, but we may have to refactor some day.
err = storageCopy(dummyStorage, currentName, envStorage, otherName)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
st := t.Env.(testing.GetStater).GetStateInAPIServer()
// Wait for machine agent to come up on the bootstrap
// machine and ensure it deployed the proper series.
m0, err := st.Machine("0")
c.Assert(err, gc.IsNil)
mw0 := newMachineToolWaiter(m0)
defer mw0.Stop()
waitAgentTools(c, mw0, other)
}
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)
}
}
}
func (s *suite) bootstrapTestEnviron(c *gc.C) environs.Environ {
cfg, err := config.New(config.NoDefaults, s.TestConfig)
c.Assert(err, gc.IsNil)
e, err := environs.Prepare(cfg, testing.Context(c), s.ConfigStore)
c.Assert(err, gc.IsNil, gc.Commentf("preparing environ %#v", s.TestConfig))
c.Assert(e, gc.NotNil)
envtesting.UploadFakeTools(c, e.Storage())
err = bootstrap.EnsureNotBootstrapped(e)
c.Assert(err, gc.IsNil)
err = bootstrap.Bootstrap(testing.Context(c), e, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
return e
}
func (s *ActionGetSuite) TestHelp(c *gc.C) {
hctx := &actionGetContext{}
com, err := jujuc.NewCommand(hctx, cmdString("action-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stdout), gc.Equals, `Usage: action-get [options] [<key>[.<key>.<key>...]]
Summary:
get action parameters
Options:
--format (= smart)
Specify output format (json|smart|yaml)
-o, --output (= "")
Specify an output file
Details:
action-get will print the value of the parameter at the given key, serialized
as YAML. If multiple keys are passed, action-get will recurse into the param
map as needed.
`)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (s *SSHSuite) testSSHCommandHostAddressRetry(c *gc.C, proxy bool) {
m := s.makeMachines(1, c, false)
ctx := coretesting.Context(c)
var called int
next := func() bool {
called++
return called < 2
}
attemptStarter := &callbackAttemptStarter{next: next}
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"}
code := cmd.Main(newSSHCommand(), ctx, args)
c.Check(code, gc.Equals, 1)
c.Assert(called, gc.Equals, 2)
called = 0
attemptStarter.next = func() bool {
called++
if called > 1 {
s.setAddresses(m[0], c)
}
return true
}
code = cmd.Main(newSSHCommand(), ctx, args)
c.Check(code, gc.Equals, 0)
c.Assert(called, gc.Equals, 2)
}
func (s *SSHSuite) TestSSHCommand(c *gc.C) {
m := s.makeMachines(3, c, true)
ch := testcharms.Repo.CharmDir("dummy")
curl := charm.MustParseURL(
fmt.Sprintf("local:quantal/%s-%d", ch.Meta().Name, ch.Revision()),
)
info := state.CharmInfo{
Charm: ch,
ID: curl,
StoragePath: "dummy-path",
SHA256: "dummy-1-sha256",
}
dummy, err := s.State.AddCharm(info)
c.Assert(err, jc.ErrorIsNil)
srv := s.AddTestingService(c, "mysql", dummy)
s.addUnit(srv, m[0], c)
srv = s.AddTestingService(c, "mongodb", dummy)
s.addUnit(srv, m[1], c)
s.addUnit(srv, m[2], c)
for i, t := range sshTests {
c.Logf("test %d: %s -> %s", i, t.about, t.args)
ctx := coretesting.Context(c)
jujucmd := cmd.NewSuperCommand(cmd.SuperCommandParams{})
jujucmd.Register(newSSHCommand())
code := cmd.Main(jujucmd, ctx, t.args)
c.Check(code, gc.Equals, 0)
c.Check(ctx.Stderr.(*bytes.Buffer).String(), gc.Equals, "")
c.Check(strings.TrimRight(ctx.Stdout.(*bytes.Buffer).String(), "\r\n"), gc.Equals, t.result)
}
}
func (s *BootstrapSuite) TestKeepBrokenDoesNoStop(c *gc.C) {
innerStorage := newStorage(s, c)
stor := &mockStorage{Storage: innerStorage}
checkHardware := instance.MustParseHardware("arch=ppc64el mem=2T")
startInstance := func(
_ string, _ constraints.Value, _ []string, _ tools.List, mcfg *cloudinit.MachineConfig,
) (
instance.Instance, *instance.HardwareCharacteristics, []network.Info, error,
) {
stor.putErr = fmt.Errorf("suddenly a wild blah")
return &mockInstance{id: "i-blah"}, &checkHardware, nil, nil
}
stopInstances := func(instances []instance.Id) error {
c.Errorf("unexpected call to StopInstances")
return nil
}
env := &mockEnviron{
storage: stor,
startInstance: startInstance,
stopInstances: stopInstances,
config: configGetter(c),
}
ctx := coretesting.Context(c)
_, _, _, err := common.Bootstrap(ctx, env, environs.BootstrapParams{
KeepBroken: true,
AvailableTools: tools.List{&tools.Tools{Version: version.Current}},
})
c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
}
// TODO (wallyworld) - this test was copied from the ec2 provider.
// It should be moved to environs.jujutests.Tests.
func (s *localServerSuite) TestBootstrapInstanceUserDataAndState(c *gc.C) {
env := s.Prepare(c)
err := bootstrap.Bootstrap(coretesting.Context(c), env, environs.BootstrapParams{})
c.Assert(err, gc.IsNil)
// check that the state holds the id of the bootstrap machine.
stateData, err := bootstrap.LoadState(env.Storage())
c.Assert(err, gc.IsNil)
c.Assert(stateData.StateInstances, gc.HasLen, 1)
insts, err := env.AllInstances()
c.Assert(err, gc.IsNil)
c.Assert(insts, gc.HasLen, 1)
c.Check(insts[0].Id(), gc.Equals, stateData.StateInstances[0])
addresses, err := insts[0].Addresses()
c.Assert(err, gc.IsNil)
c.Assert(addresses, gc.Not(gc.HasLen), 0)
// TODO(wallyworld) - 2013-03-01 bug=1137005
// The nova test double needs to be updated to support retrieving instance userData.
// Until then, we can't check the cloud init script was generated correctly.
// When we can, we should also check cloudinit for a non-manager node (as in the
// ec2 tests).
}
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 *statusGetSuite) TestHelp(c *gc.C) {
hctx := s.GetStatusHookContext(c)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--help"})
c.Assert(code, gc.Equals, 0)
expectedHelp := "" +
"Usage: status-get [options] [--include-data] [--service]\n" +
"\n" +
"Summary:\n" +
"print status information\n" +
"\n" +
"Options:\n" +
"--format (= smart)\n" +
" Specify output format (json|smart|yaml)\n" +
"--include-data (= false)\n" +
" print all status data\n" +
"-o, --output (= \"\")\n" +
" Specify an output file\n" +
"--service (= false)\n" +
" print status for all units of this service if this unit is the leader\n" +
"\n" +
"Details:\n" +
"By default, only the status value is printed.\n" +
"If the --include-data flag is passed, the associated data are printed also.\n"
c.Assert(bufferString(ctx.Stdout), gc.Equals, expectedHelp)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
}
func (*OpenSuite) TestDestroy(c *gc.C) {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig().Merge(
testing.Attrs{
"state-server": false,
"name": "erewhemos",
},
))
c.Assert(err, gc.IsNil)
store := configstore.NewMem()
// Prepare the environment and sanity-check that
// the config storage info has been made.
ctx := testing.Context(c)
e, err := environs.Prepare(cfg, ctx, store)
c.Assert(err, gc.IsNil)
_, err = store.ReadInfo(e.Config().Name())
c.Assert(err, gc.IsNil)
err = environs.Destroy(e, store)
c.Assert(err, gc.IsNil)
// Check that the environment has actually been destroyed
// and that the config info has been destroyed too.
_, err = e.StateServerInstances()
c.Assert(err, gc.ErrorMatches, "environment has been destroyed")
_, err = store.ReadInfo(e.Config().Name())
c.Assert(err, jc.Satisfies, errors.IsNotFound)
}
func (*OpenSuite) TestPrepareGeneratesDifferentAdminSecrets(c *gc.C) {
baselineAttrs := dummy.SampleConfig().Merge(testing.Attrs{
"state-server": false,
"name": "erewhemos",
}).Delete(
"admin-secret",
)
cfg, err := config.New(config.NoDefaults, baselineAttrs)
c.Assert(err, gc.IsNil)
ctx := testing.Context(c)
env0, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
adminSecret0 := env0.Config().AdminSecret()
c.Assert(adminSecret0, gc.HasLen, 32)
c.Assert(adminSecret0, gc.Matches, "^[0-9a-f]*$")
env1, err := environs.Prepare(cfg, ctx, configstore.NewMem())
c.Assert(err, gc.IsNil)
adminSecret1 := env1.Config().AdminSecret()
c.Assert(adminSecret1, gc.HasLen, 32)
c.Assert(adminSecret1, gc.Matches, "^[0-9a-f]*$")
c.Assert(adminSecret1, gc.Not(gc.Equals), adminSecret0)
}
func (s *cmdControllerSuite) run(c *gc.C, args ...string) *cmd.Context {
context := testing.Context(c)
command := commands.NewJujuCommand(context)
c.Assert(testing.InitCommand(command, args), jc.ErrorIsNil)
c.Assert(command.Run(context), jc.ErrorIsNil)
return context
}
func (s *unregisterSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
s.stub = &testing.Stub{}
s.compCtx = &stubUnregisterContext{stub: s.stub}
s.ctx = coretesting.Context(c)
}
// mockTestingEnvConfig prepares an environment configuration using
// the mock provider which does not support networking.
func mockTestingEnvConfig(c *gc.C) *config.Config {
cfg, err := config.New(config.NoDefaults, mockConfig())
c.Assert(err, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, modelcmd.BootstrapContext(coretesting.Context(c)), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
return env.Config()
}
// testingEnvConfig prepares an environment configuration using
// the dummy provider.
func testingEnvConfig(c *gc.C) *config.Config {
cfg, err := config.New(config.NoDefaults, dummy.SampleConfig())
c.Assert(err, jc.ErrorIsNil)
env, err := environs.Prepare(cfg, envcmd.BootstrapContext(testing.Context(c)), configstore.NewMem())
c.Assert(err, jc.ErrorIsNil)
return env.Config()
}
func (s *statusGetSuite) TestServiceStatus(c *gc.C) {
expected := map[string]interface{}{
"service-status": map[interface{}]interface{}{
"status-data": map[interface{}]interface{}{},
"units": map[interface{}]interface{}{
"": map[interface{}]interface{}{
"message": "this is a unit status",
"status": "active",
"status-data": map[interface{}]interface{}{},
},
},
"message": "this is a service status",
"status": "active"},
}
hctx := s.GetStatusHookContext(c)
setFakeServiceStatus(hctx)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, []string{"--format", "json", "--include-data", "--service"})
c.Assert(code, gc.Equals, 0)
var out map[string]interface{}
c.Assert(goyaml.Unmarshal(bufferBytes(ctx.Stdout), &out), gc.IsNil)
c.Assert(out, gc.DeepEquals, expected)
}
func (s *LoginCommandSuite) run(c *gc.C, stdin string, args ...string) (*cmd.Context, juju.NewAPIConnectionParams, error) {
var argsOut juju.NewAPIConnectionParams
cmd, _ := user.NewLoginCommandForTest(func(args juju.NewAPIConnectionParams) (user.LoginAPI, user.ConnectionAPI, error) {
argsOut = args
// The account details are modified in place, so take a copy.
accountDetails := *argsOut.AccountDetails
argsOut.AccountDetails = &accountDetails
if s.loginErr != nil {
err := s.loginErr
s.loginErr = nil
return nil, nil, err
}
return s.mockAPI, s.mockAPI, nil
}, s.store)
ctx := coretesting.Context(c)
if stdin == "" {
stdin = "sekrit\n"
}
ctx.Stdin = strings.NewReader(stdin)
err := coretesting.InitCommand(cmd, args)
if err != nil {
return nil, argsOut, err
}
err = cmd.Run(ctx)
return ctx, argsOut, err
}
func (s *statusGetSuite) TestOutputFormatJustStatus(c *gc.C) {
for i, t := range statusGetTests {
c.Logf("test %d: %#v", i, t.args)
hctx := s.GetStatusHookContext(c)
setFakeStatus(hctx)
com, err := jujuc.NewCommand(hctx, cmdString("status-get"))
c.Assert(err, jc.ErrorIsNil)
ctx := testing.Context(c)
code := cmd.Main(com, ctx, t.args)
c.Assert(code, gc.Equals, 0)
c.Assert(bufferString(ctx.Stderr), gc.Equals, "")
var out interface{}
var outMap map[string]interface{}
switch t.format {
case formatYaml:
c.Check(goyaml.Unmarshal(bufferBytes(ctx.Stdout), &outMap), gc.IsNil)
out = outMap
case formatJson:
c.Check(json.Unmarshal(bufferBytes(ctx.Stdout), &outMap), gc.IsNil)
out = outMap
default:
out = string(bufferBytes(ctx.Stdout))
}
c.Check(out, gc.DeepEquals, t.out)
}
}
func (t *localServerSuite) TestAddresses(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(err, gc.IsNil)
addrs, err := inst.Addresses()
c.Assert(err, gc.IsNil)
// Expected values use Address type but really contain a regexp for
// the value rather than a valid ip or hostname.
expected := []network.Address{{
Value: "*.testing.invalid",
Type: network.HostName,
Scope: network.ScopePublic,
}, {
Value: "*.internal.invalid",
Type: network.HostName,
Scope: network.ScopeCloudLocal,
}, {
Value: "8.0.0.*",
Type: network.IPv4Address,
Scope: network.ScopePublic,
}, {
Value: "127.0.0.*",
Type: network.IPv4Address,
Scope: network.ScopeCloudLocal,
}}
c.Assert(addrs, gc.HasLen, len(expected))
for i, addr := range addrs {
c.Check(addr.Value, gc.Matches, expected[i].Value)
c.Check(addr.Type, gc.Equals, expected[i].Type)
c.Check(addr.Scope, gc.Equals, expected[i].Scope)
}
}
func (s *ToolsMetadataSuite) TestGenerateWithMirrors(c *gc.C) {
metadataDir := c.MkDir()
toolstesting.MakeTools(c, metadataDir, "released", versionStrings)
ctx := coretesting.Context(c)
code := cmd.Main(newToolsMetadataCommand(), ctx, []string{"--public", "-d", metadataDir, "--stream", "released"})
c.Assert(code, gc.Equals, 0)
output := ctx.Stdout.(*bytes.Buffer).String()
mirrosTmpl := expectedOutputCommon + `
.*Writing tools/streams/v1/index2\.json
.*Writing tools/streams/v1/index\.json
.*Writing tools/streams/v1/com\.ubuntu\.juju-{{.Stream}}-tools\.json
.*Writing tools/streams/v1/mirrors\.json
`
expectedOutput := makeExpectedOutput(mirrosTmpl, "released", "released")
c.Check(output, gc.Matches, expectedOutput)
metadata := toolstesting.ParseMetadataFromDir(c, metadataDir, "released", true)
c.Check(metadata, gc.HasLen, len(versionStrings))
obtainedVersionStrings := make([]string, len(versionStrings))
for i, metadata := range metadata {
s := fmt.Sprintf("%s-%s-%s", metadata.Version, metadata.Release, metadata.Arch)
obtainedVersionStrings[i] = s
}
c.Assert(obtainedVersionStrings, gc.DeepEquals, versionStrings)
}
func (s *BootstrapSuite) TestCannotRecordStartedInstance(c *gc.C) {
innerStorage := newStorage(s, c)
stor := &mockStorage{Storage: innerStorage}
startInstance := func(
_ string, _ constraints.Value, _ []string, _ tools.List, _ *cloudinit.MachineConfig,
) (
instance.Instance, *instance.HardwareCharacteristics, []network.Info, error,
) {
stor.putErr = fmt.Errorf("suddenly a wild blah")
return &mockInstance{id: "i-blah"}, nil, nil, nil
}
var stopped []instance.Id
stopInstances := func(ids []instance.Id) error {
stopped = append(stopped, ids...)
return nil
}
env := &mockEnviron{
storage: stor,
startInstance: startInstance,
stopInstances: stopInstances,
config: configGetter(c),
}
ctx := coretesting.Context(c)
err := common.Bootstrap(ctx, env, environs.BootstrapParams{})
c.Assert(err, gc.ErrorMatches, "cannot save state: suddenly a wild blah")
c.Assert(stopped, gc.HasLen, 1)
c.Assert(stopped[0], gc.Equals, instance.Id("i-blah"))
}
func (s *ConfigSuite) TestFirewallMode(c *gc.C) {
for i, test := range firewallModeTests {
c.Logf("test %d: %s", i, test.configFirewallMode)
attrs := dummy.SampleConfig()
if test.configFirewallMode != "" {
attrs = attrs.Merge(testing.Attrs{
"firewall-mode": test.configFirewallMode,
})
}
cfg, err := config.New(config.NoDefaults, attrs)
if err != nil {
c.Assert(err, gc.ErrorMatches, test.errorMsg)
continue
}
ctx := testing.Context(c)
env, err := environs.Prepare(cfg, ctx, configstore.NewMem())
if test.errorMsg != "" {
c.Assert(err, gc.ErrorMatches, test.errorMsg)
continue
}
c.Assert(err, gc.IsNil)
defer env.Destroy()
firewallMode := env.Config().FirewallMode()
c.Assert(firewallMode, gc.Equals, test.firewallMode)
s.TearDownTest(c)
}
}
func (s *BootstrapSuite) TestCannotStartInstance(c *gc.C) {
checkPlacement := "directive"
checkCons := constraints.MustParse("mem=8G")
startInstance := func(
placement string, cons constraints.Value, _ []string, possibleTools tools.List, mcfg *cloudinit.MachineConfig,
) (
instance.Instance, *instance.HardwareCharacteristics, []network.Info, error,
) {
c.Assert(placement, gc.DeepEquals, checkPlacement)
c.Assert(cons, gc.DeepEquals, checkCons)
c.Assert(mcfg, gc.DeepEquals, environs.NewBootstrapMachineConfig(mcfg.SystemPrivateSSHKey))
return nil, nil, nil, fmt.Errorf("meh, not started")
}
env := &mockEnviron{
storage: newStorage(s, c),
startInstance: startInstance,
config: configGetter(c),
}
ctx := coretesting.Context(c)
err := common.Bootstrap(ctx, env, environs.BootstrapParams{
Constraints: checkCons,
Placement: checkPlacement,
})
c.Assert(err, gc.ErrorMatches, "cannot start bootstrap instance: meh, not started")
}
func (t *localServerSuite) TestStartInstanceAvailZoneOneConstrained(c *gc.C) {
env := t.Prepare(c)
envtesting.UploadFakeTools(c, env.Storage())
err := bootstrap.Bootstrap(coretesting.Context(c), env, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
mock := mockAvailabilityZoneAllocations{
result: []common.AvailabilityZoneInstances{
{ZoneName: "az1"}, {ZoneName: "az2"},
},
}
t.PatchValue(ec2.AvailabilityZoneAllocations, mock.AvailabilityZoneAllocations)
// The first call to RunInstances fails with an error indicating the AZ
// is constrained. The second attempt succeeds, and so allocates to az2.
var azArgs []string
realRunInstances := *ec2.RunInstances
t.PatchValue(ec2.RunInstances, func(e *amzec2.EC2, ri *amzec2.RunInstances) (*amzec2.RunInstancesResp, error) {
azArgs = append(azArgs, ri.AvailZone)
if len(azArgs) == 1 {
return nil, azConstrainedErr
}
return realRunInstances(e, ri)
})
inst, _ := testing.AssertStartInstance(c, env, "1")
c.Assert(azArgs, gc.DeepEquals, []string{"az1", "az2"})
c.Assert(ec2.InstanceEC2(inst).AvailZone, gc.Equals, "az2")
}
func (s *RelationSetSuite) TestRun(c *gc.C) {
hctx, info := s.newHookContext(0, "")
for i, t := range relationSetRunTests {
c.Logf("test %d", i)
pristine := jujuctesting.Settings{"pristine": "untouched"}
info.rels[0].Units["u/0"] = pristine
basic := jujuctesting.Settings{"base": "value"}
info.rels[1].Units["u/0"] = basic
// Run the command.
com, err := jujuc.NewCommand(hctx, cmdString("relation-set"))
c.Assert(err, jc.ErrorIsNil)
rset := com.(*jujuc.RelationSetCommand)
rset.RelationId = 1
rset.Settings = t.change
ctx := testing.Context(c)
err = com.Run(ctx)
c.Assert(err, jc.ErrorIsNil)
// Check changes.
c.Assert(info.rels[0].Units["u/0"], gc.DeepEquals, pristine)
c.Assert(info.rels[1].Units["u/0"], gc.DeepEquals, t.expect)
}
}
