func (*suite) TestConfig(c *gc.C) {
defer testing.MakeFakeHomeNoEnvironments(c, "only", "valid", "one", "two").Restore()
for i, t := range configTests {
c.Logf("running test %v", i)
envs, err := environs.ReadEnvironsBytes([]byte(t.env))
c.Assert(err, gc.IsNil)
t.check(c, envs)
}
}
func (*suite) TestInvalidEnv(c *gc.C) {
defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
for i, t := range invalidEnvTests {
c.Logf("running test %v", i)
es, err := environs.ReadEnvironsBytes([]byte(t.env))
c.Check(err, gc.IsNil)
cfg, err := es.Config(t.name)
c.Check(err, gc.ErrorMatches, t.err)
c.Check(cfg, gc.IsNil)
}
}
func (s *MainSuite) TestActualRunJujuArgsAfterCommand(c *gc.C) {
c.Skip("breaks test isolation: lp:1233601")
defer testing.MakeFakeHomeNoEnvironments(c, "one").Restore()
// Check global args work when specified after command
msg := breakJuju(c, "Bootstrap")
logpath := filepath.Join(c.MkDir(), "log")
out := badrun(c, 1, "bootstrap", "--log-file", logpath)
fullmsg := fmt.Sprintf(`(.|\n)*ERROR .*%s\n`, msg)
c.Assert(out, gc.Matches, fullmsg)
content, err := ioutil.ReadFile(logpath)
c.Assert(err, gc.IsNil)
c.Assert(string(content), gc.Matches, fullmsg)
}
func (s *ConfigDeprecationSuite) checkDeprecationWarning(c *gc.C, attrs testing.Attrs, expectedMsg string) {
defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
content := `
environments:
deprecated:
type: dummy
state-server: false
`
restore := s.setupLogger(c)
defer restore()
envs, err := environs.ReadEnvironsBytes([]byte(content))
c.Check(err, gc.IsNil)
environs.UpdateEnvironAttrs(envs, "deprecated", attrs)
_, err = envs.Config("deprecated")
c.Check(err, gc.IsNil)
c.Assert(s.writer.Log, gc.HasLen, 1)
stripped := strings.Replace(s.writer.Log[0].Message, "\n", "", -1)
c.Assert(stripped, gc.Matches, expectedMsg)
}
func (*suite) TestBootstrapConfig(c *gc.C) {
defer testing.MakeFakeHomeNoEnvironments(c, "bladaam").Restore()
attrs := dummySampleConfig().Merge(testing.Attrs{
"agent-version": "1.2.3",
})
c.Assert(inMap(attrs, "secret"), jc.IsTrue)
c.Assert(inMap(attrs, "ca-private-key"), jc.IsTrue)
c.Assert(inMap(attrs, "admin-secret"), jc.IsTrue)
cfg, err := config.New(config.NoDefaults, attrs)
c.Assert(err, gc.IsNil)
c.Assert(err, gc.IsNil)
cfg1, err := environs.BootstrapConfig(cfg)
c.Assert(err, gc.IsNil)
expect := cfg.AllAttrs()
expect["admin-secret"] = ""
expect["ca-private-key"] = ""
c.Assert(cfg1.AllAttrs(), gc.DeepEquals, expect)
}
func (*suite) TestNamedConfigFile(c *gc.C) {
defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
path := filepath.Join(c.MkDir(), "a-file")
outfile, err := environs.WriteEnvirons(path, env)
c.Assert(err, gc.IsNil)
c.Assert(path, gc.Equals, outfile)
envs, err := environs.ReadEnvirons(path)
c.Assert(err, gc.IsNil)
cfg, err := envs.Config("")
c.Assert(err, gc.IsNil)
c.Assert(cfg.Name(), gc.Equals, "only")
}
func (*suite) TestNoWarningForDeprecatedButUnusedEnv(c *gc.C) {
// This tests that a config that has a deprecated field doesn't
// generate a Warning if we don't actually ask for that environment.
// However, we can only really trigger that when we have a deprecated
// field. If support for the field is removed entirely, another
// mechanism will need to be used
defer testing.MakeFakeHomeNoEnvironments(c, "only").Restore()
content := `
environments:
valid:
type: dummy
state-server: false
deprecated:
type: dummy
state-server: false
tools-url: aknowndeprecatedfield
`
tw := &loggo.TestWriter{}
// we only capture Warning or above
c.Assert(loggo.RegisterWriter("invalid-env-tester", tw, loggo.WARNING), gc.IsNil)
defer loggo.RemoveWriter("invalid-env-tester")
envs, err := environs.ReadEnvironsBytes([]byte(content))
c.Check(err, gc.IsNil)
names := envs.Names()
sort.Strings(names)
c.Check(names, gc.DeepEquals, []string{"deprecated", "valid"})
// There should be no warning in the log
c.Check(tw.Log, gc.HasLen, 0)
// Now we actually grab the 'valid' entry
_, err = envs.Config("valid")
c.Check(err, gc.IsNil)
// And still we have no warnings
c.Check(tw.Log, gc.HasLen, 0)
// Only once we grab the deprecated one do we see any warnings
_, err = envs.Config("deprecated")
c.Check(err, gc.IsNil)
c.Check(tw.Log, gc.HasLen, 1)
}
func (*suite) TestNoEnv(c *gc.C) {
defer testing.MakeFakeHomeNoEnvironments(c).Restore()
es, err := environs.ReadEnvirons("")
c.Assert(es, gc.IsNil)
c.Assert(err, jc.Satisfies, environs.IsNoEnv)
}
func (s *baseProviderSuite) SetUpTest(c *gc.C) {
s.TestSuite.SetUpTest(c)
s.home = coretesting.MakeFakeHomeNoEnvironments(c, "test")
loggo.GetLogger("juju.provider.local").SetLogLevel(loggo.TRACE)
s.restore = local.MockAddressForInterface()
}
func (s *bootstrapSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.ToolsFixture.SetUpTest(c)
s.home = coretesting.MakeFakeHomeNoEnvironments(c, "foo")
}