func (*ImageMetadataSuite) assertCommandOutput(c *gc.C, errOut, series, arch, indexFileName, imageFileName string) {
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, gc.Matches, `Boilerplate image metadata files.*have been written.*Copy the files.*`)
indexpath := testing.HomePath(".juju", indexFileName)
data, err := ioutil.ReadFile(indexpath)
c.Assert(err, gc.IsNil)
var indices interface{}
err = json.Unmarshal(data, &indices)
c.Assert(err, gc.IsNil)
c.Assert(indices.(map[string]interface{})["format"], gc.Equals, "index:1.0")
prodId := fmt.Sprintf("com.ubuntu.cloud:server:%s:%s", seriesVersions[series], arch)
c.Assert(strings.Contains(string(data), prodId), gc.Equals, true)
c.Assert(strings.Contains(string(data), `"region": "region"`), gc.Equals, true)
c.Assert(strings.Contains(string(data), `"endpoint": "endpoint"`), gc.Equals, true)
c.Assert(strings.Contains(string(data), fmt.Sprintf(`"path": "streams/v1/%s"`, imageFileName)), gc.Equals, true)
imagepath := testing.HomePath(".juju", imageFileName)
data, err = ioutil.ReadFile(imagepath)
c.Assert(err, gc.IsNil)
var images interface{}
err = json.Unmarshal(data, &images)
c.Assert(err, gc.IsNil)
c.Assert(images.(map[string]interface{})["format"], gc.Equals, "products:1.0")
c.Assert(strings.Contains(string(data), prodId), gc.Equals, true)
c.Assert(strings.Contains(string(data), `"id": "1234"`), gc.Equals, true)
}
func (suite *PluginSuite) makeFullPlugin(params PluginParams) {
// Create a new template and parse the plugin into it.
t := template.Must(template.New("plugin").Parse(pluginTemplate))
content := &bytes.Buffer{}
filename := testing.HomePath("juju-" + params.Name)
// Create the files in the temp dirs, so we don't pollute the working space
if params.Creates != "" {
params.Creates = testing.HomePath(params.Creates)
}
if params.DependsOn != "" {
params.DependsOn = testing.HomePath(params.DependsOn)
}
t.Execute(content, params)
ioutil.WriteFile(filename, content.Bytes(), 0755)
}
func (suite) TestConfigPerm(c *C) {
defer testing.MakeSampleHome(c).Restore()
path := testing.HomePath(".juju")
info, err := os.Lstat(path)
c.Assert(err, IsNil)
oldPerm := info.Mode().Perm()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
outfile, err := environs.WriteEnvirons("", env)
c.Assert(err, IsNil)
info, err = os.Lstat(outfile)
c.Assert(err, IsNil)
c.Assert(info.Mode().Perm(), Equals, os.FileMode(0600))
info, err = os.Lstat(filepath.Dir(outfile))
c.Assert(err, IsNil)
c.Assert(info.Mode().Perm(), Equals, oldPerm)
}
// The boilerplate is sent to stdout with --show, and the environments.yaml
// is not created.
func (*InitSuite) TestBoilerPlatePrinted(c *C) {
defer testing.MakeEmptyFakeHome(c).Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, []string{"--show"})
c.Check(code, Equals, 0)
outStr := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(outStr, "\n", "", -1)
c.Check(strippedOut, Matches, ".*## This is the Juju config file, which you can use.*")
environpath := testing.HomePath(".juju", "environments.yaml")
_, err := ioutil.ReadFile(environpath)
c.Assert(err, NotNil)
}
// Without the write (-w) option, any existing environmens.yaml file is preserved and the boilerplate is
// written to stdout.
func (*InitSuite) TestPrintBoilerplate(c *C) {
defer testing.MakeFakeHome(c, existingEnv, "existing").Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, nil)
c.Check(code, Equals, 0)
errOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, Matches, ".*## This is the Juju config file, which you can use.*")
environpath := testing.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, existingEnv)
}
func (*InitSuite) TestExistingEnvironmentNotOverwritten(c *C) {
defer testing.MakeFakeHome(c, existingEnv, "existing").Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, []string{"-w"})
c.Check(code, Equals, 0)
errOut := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(errOut, "\n", "", -1)
c.Check(strippedOut, Matches, ".*A juju environment configuration already exists.*")
environpath := testing.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, IsNil)
c.Assert(string(data), Equals, existingEnv)
}
// The environments.yaml is created by default if it
// does not already exist.
func (*InitSuite) TestBoilerPlateEnvironment(c *C) {
defer testing.MakeEmptyFakeHome(c).Restore()
ctx := testing.Context(c)
code := cmd.Main(&InitCommand{}, ctx, nil)
c.Check(code, Equals, 0)
outStr := ctx.Stdout.(*bytes.Buffer).String()
strippedOut := strings.Replace(outStr, "\n", "", -1)
c.Check(strippedOut, Matches, ".*A boilerplate environment configuration file has been written.*")
environpath := testing.HomePath(".juju", "environments.yaml")
data, err := ioutil.ReadFile(environpath)
c.Assert(err, IsNil)
strippedData := strings.Replace(string(data), "\n", "", -1)
c.Assert(strippedData, Matches, ".*## This is the Juju config file, which you can use.*")
}
func (*EnvironsCertSuite) TestEnsureCertificateMissingKey(c *C) {
defer testing.MakeFakeHome(c, testing.SingleEnvConfig).Restore()
envName := testing.SampleEnvName
keyPath := testing.HomePath(".juju", envName+"-cert.pem")
ioutil.WriteFile(keyPath, []byte(testing.CACert), 0600)
// Need to create the environment after the cert has been written.
env, err := environs.NewFromName(envName)
c.Assert(err, IsNil)
writeCalled := false
_, err = environs.EnsureCertificate(env, func(name string, cert, key []byte) error {
writeCalled = true
return nil
})
c.Assert(err, ErrorMatches, "environment configuration with a certificate but no CA private key")
c.Assert(writeCalled, Equals, false)
}
func (suite) TestDefaultConfigFile(c *C) {
defer testing.MakeEmptyFakeHome(c).Restore()
env := `
environments:
only:
type: dummy
state-server: false
authorized-keys: i-am-a-key
`
outfile, err := environs.WriteEnvirons("", env)
c.Assert(err, IsNil)
path := testing.HomePath(".juju", "environments.yaml")
c.Assert(path, Equals, outfile)
es, err := environs.ReadEnvirons("")
c.Assert(err, IsNil)
e, err := es.Open("")
c.Assert(err, IsNil)
c.Assert(e.Name(), Equals, "only")
}
func (suite *PluginSuite) SetUpTest(c *C) {
suite.LoggingSuite.SetUpTest(c)
suite.oldPath = os.Getenv("PATH")
suite.home = testing.MakeSampleHome(c)
os.Setenv("PATH", "/bin:"+testing.HomePath())
}
func (suite *PluginSuite) makeFailingPlugin(name string, exitStatus int) {
content := fmt.Sprintf("#!/bin/bash\necho failing\nexit %d", exitStatus)
filename := testing.HomePath(JujuPluginPrefix + name)
ioutil.WriteFile(filename, []byte(content), 0755)
}
func (suite *PluginSuite) makePlugin(name string, perm os.FileMode) {
content := fmt.Sprintf("#!/bin/bash\necho %s $JUJU_ENV $*", name)
filename := testing.HomePath(JujuPluginPrefix + name)
ioutil.WriteFile(filename, []byte(content), perm)
}