Пример #1
0
// The boilerplate is sent to stdout with --show, and the environments.yaml
// is not created.
func (*InitSuite) TestBoilerPlatePrinted(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	ctx := testing.Context(c)
	code := cmd.Main(&initCommand{}, ctx, []string{"--show"})
	c.Check(code, gc.Equals, 0)
	outStr := ctx.Stdout.(*bytes.Buffer).String()
	strippedOut := strings.Replace(outStr, "\n", "", -1)
	c.Check(strippedOut, gc.Matches, ".*# This is the Juju config file, which you can use.*")
	environpath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	_, err = ioutil.ReadFile(environpath)
	c.Assert(err, gc.NotNil)
}
Пример #2
0
func (s *suite) TestConfigPerm(c *gc.C) {
	testing.MakeSampleJujuHome(c)

	path := gitjujutesting.JujuXDGDataHomePath()
	info, err := os.Lstat(path)
	c.Assert(err, jc.ErrorIsNil)
	oldPerm := info.Mode().Perm()
	env := `
environments:
    only:
        type: dummy
        controller: false
        authorized-keys: i-am-a-key
`
	outfile, err := environs.WriteEnvirons("", env)
	c.Assert(err, jc.ErrorIsNil)

	info, err = os.Lstat(outfile)
	c.Assert(err, jc.ErrorIsNil)
	// Windows is not fully POSIX compliant. Normal permission
	// checking will yield unexpected results
	if runtime.GOOS != "windows" {
		c.Assert(info.Mode().Perm(), gc.Equals, os.FileMode(0600))
	}

	info, err = os.Lstat(filepath.Dir(outfile))
	c.Assert(err, jc.ErrorIsNil)
	if runtime.GOOS != "windows" {
		c.Assert(info.Mode().Perm(), gc.Equals, oldPerm)
	}

}
Пример #3
0
func (*SwitchSimpleSuite) TestNoDefaultNoEnvironmentsFile(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	_, err = testing.RunCommand(c, newSwitchCommand())
	c.Assert(err, gc.ErrorMatches, "no currently specified model")
}
Пример #4
0
// The environments.yaml is created by default if it
// does not already exist.
func (*InitSuite) TestBoilerPlateEnvironment(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	ctx := testing.Context(c)
	code := cmd.Main(&initCommand{}, ctx, nil)
	c.Check(code, gc.Equals, 0)
	outStr := ctx.Stdout.(*bytes.Buffer).String()
	strippedOut := strings.Replace(outStr, "\n", "", -1)
	c.Check(strippedOut, gc.Matches, ".*A boilerplate model configuration file has been written.*")
	environpath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	data, err := ioutil.ReadFile(environpath)
	c.Assert(err, jc.ErrorIsNil)
	strippedData := strings.Replace(string(data), "\n", "", -1)
	c.Assert(strippedData, gc.Matches, ".*# This is the Juju config file, which you can use.*")
}
Пример #5
0
func (s *jenvSuite) SetUpTest(c *gc.C) {
	s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
	dir := gitjujutesting.JujuXDGDataHomePath()
	err := os.MkdirAll(dir, 0600)
	c.Check(err, jc.ErrorIsNil)

}
Пример #6
0
func (s *FakeJujuXDGDataHomeSuite) SetUpTest(c *gc.C) {
	s.JujuOSEnvSuite.SetUpTest(c)
	s.FakeHomeSuite.SetUpTest(c)
	jujuXDGDataHome := gitjujutesting.JujuXDGDataHomePath()
	err := os.MkdirAll(jujuXDGDataHome, 0700)
	c.Assert(err, jc.ErrorIsNil)
	s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(jujuXDGDataHome)
}
Пример #7
0
func (s *ModelCommandSuite) TestGetDefaultModelNothingSet(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	env, err := modelcmd.GetDefaultModel()
	c.Assert(env, gc.Equals, "")
	c.Assert(err, jc.ErrorIsNil)
}
Пример #8
0
func (*suite) TestNoEnv(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	es, err := environs.ReadEnvirons("")
	c.Assert(es, gc.IsNil)
	c.Assert(err, jc.Satisfies, environs.IsNoEnv)
}
Пример #9
0
func (s *ControllerCommandSuite) TestControllerCommandInitNoEnvFile(c *gc.C) {
	// Since we ignore the environments.yaml file, we don't care if it isn't
	// there.
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	_, err = initTestControllerCommand(c)
	c.Assert(err, gc.ErrorMatches, "no controller specified")
}
Пример #10
0
func (s *FakeJujuXDGDataHomeSuite) SetUpTest(c *gc.C) {
	s.JujuOSEnvSuite.SetUpTest(c)
	s.FakeHomeSuite.SetUpTest(c)
	jujuXDGDataHome := gitjujutesting.JujuXDGDataHomePath()
	err := os.MkdirAll(jujuXDGDataHome, 0700)
	c.Assert(err, jc.ErrorIsNil)
	s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome(jujuXDGDataHome)
	WriteEnvironments(c, SingleEnvConfig, SampleCertName)
}
Пример #11
0
func (s *SwitchSimpleSuite) TestNoEnvironmentReadsConfigStore(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	s.addTestController(c)
	context, err := testing.RunCommand(c, newSwitchCommand(), "--list")
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(testing.Stdout(context), gc.Equals, "a-controller (controller)\n")
}
Пример #12
0
func (s *SwitchSimpleSuite) TestErrorReadingEnvironmentsFile(c *gc.C) {
	if runtime.GOOS == "windows" {
		c.Skip("bug 1496997: os.Chmod doesn't exist on windows, checking this on one platform is sufficent to test this case")
	}

	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Chmod(envPath, 0)
	c.Assert(err, jc.ErrorIsNil)
	s.addTestController(c)
	_, err = testing.RunCommand(c, newSwitchCommand(), "--list")
	c.Assert(err, gc.ErrorMatches, "couldn't read the model: open .*: permission denied")
}
Пример #13
0
// resetJujuXDGDataHome restores an new, clean Juju home environment without tools.
func resetJujuXDGDataHome(c *gc.C, envName string) environs.Environ {
	jenvDir := testing.JujuXDGDataHomePath("models")
	err := os.RemoveAll(jenvDir)
	c.Assert(err, jc.ErrorIsNil)
	coretesting.WriteEnvironments(c, modelConfig)
	dummy.Reset()
	store, err := configstore.Default()
	c.Assert(err, jc.ErrorIsNil)
	env, err := environs.PrepareFromName(envName, modelcmd.BootstrapContext(cmdtesting.NullContext(c)), store)
	c.Assert(err, jc.ErrorIsNil)
	return env
}
Пример #14
0
// An existing environments.yaml will not be overwritten without
// the explicit -f option.
func (*InitSuite) TestExistingEnvironmentNotOverwritten(c *gc.C) {
	testing.WriteEnvironments(c, existingEnv)

	ctx := testing.Context(c)
	code := cmd.Main(&initCommand{}, ctx, nil)
	c.Check(code, gc.Equals, 1)
	errOut := ctx.Stderr.(*bytes.Buffer).String()
	strippedOut := strings.Replace(errOut, "\n", "", -1)
	c.Check(strippedOut, gc.Matches, ".*A juju model configuration already exists.*")
	environpath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	data, err := ioutil.ReadFile(environpath)
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(string(data), gc.Equals, existingEnv)
}
Пример #15
0
// assertJenvContents checks that the jenv file corresponding to the given
// envName is correctly present in the Juju Home and has the given contents.
func assertJenvContents(c *gc.C, contents []byte, envName string) {
	path := gitjujutesting.JujuXDGDataHomePath("models", envName+".jenv")
	// Ensure the jenv file has been created.
	c.Assert(path, jc.IsNonEmptyFile)

	// Retrieve the jenv file contents.
	b, err := ioutil.ReadFile(path)
	c.Assert(err, jc.ErrorIsNil)

	// Ensure the jenv file reflects the source contents.
	var data map[string]interface{}
	err = yaml.Unmarshal(contents, &data)
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(string(b), jc.YAMLEquals, data)
}
Пример #16
0
// resetJujuXDGDataHome restores an new, clean Juju home environment without tools.
func resetJujuXDGDataHome(c *gc.C) {
	jenvDir := testing.JujuXDGDataHomePath("models")
	err := os.RemoveAll(jenvDir)
	c.Assert(err, jc.ErrorIsNil)

	cloudsPath := cloud.JujuPersonalCloudsPath()
	err = ioutil.WriteFile(cloudsPath, []byte(`
clouds:
    dummy-cloud:
        type: dummy
        regions:
            region-1:
            region-2:
    dummy-cloud-without-regions:
        type: dummy
`[1:]), 0644)
	c.Assert(err, jc.ErrorIsNil)
}
Пример #17
0
func (*jenvSuite) TestSuccessNoJujuEnvironments(c *gc.C) {
	// Create a jenv file.
	contents := makeValidJenvContents()
	f := openJenvFile(c, contents)
	defer f.Close()

	// Remove the Juju environments.yaml file.
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)

	// Importing a jenv does not require having environments already defined.
	jenvCmd := &model.JenvCommand{}
	ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
	c.Assert(err, jc.ErrorIsNil)
	assertJenvContents(c, contents, "testing")
	c.Assert(testing.Stdout(ctx), gc.Equals, "-> testing\n")
}
Пример #18
0
func (*jenvSuite) TestSwitchErrorEnvironmentsNotReadable(c *gc.C) {
	if runtime.GOOS == "windows" {
		c.Skip("Cannot test on windows because it uses chmod")
	}
	// Create a jenv file.
	f := openJenvFile(c, makeValidJenvContents())
	defer f.Close()

	// Remove write permissions to the environments.yaml file.
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Chmod(envPath, 0200)
	c.Assert(err, jc.ErrorIsNil)

	jenvCmd := &model.JenvCommand{}
	ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
	c.Assert(err, gc.ErrorMatches, `cannot switch to the new model "testing": cannot get the default model: .*: permission denied`)
	c.Assert(testing.Stdout(ctx), gc.Equals, "")
}
Пример #19
0
func (*jenvSuite) TestWriteError(c *gc.C) {
	if runtime.GOOS == "windows" {
		c.Skip("Cannot test on windows because it uses chmod")
	}
	// Create a jenv file.
	f := openJenvFile(c, makeValidJenvContents())
	defer f.Close()

	// Create the environments dir without write permissions.
	envsDir := gitjujutesting.JujuXDGDataHomePath("models")
	err := os.Mkdir(envsDir, 0500)
	c.Assert(err, jc.ErrorIsNil)

	jenvCmd := &model.JenvCommand{}
	ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
	c.Assert(err, gc.ErrorMatches, "cannot write the jenv file: cannot write info: .*: permission denied")
	c.Assert(testing.Stdout(ctx), gc.Equals, "")
}
Пример #20
0
func (*jenvSuite) TestConfigStoreError(c *gc.C) {
	if runtime.GOOS == "windows" {
		c.Skip("Cannot test on windows because it uses chmod")
	}
	// Create a jenv file.
	f := openJenvFile(c, nil)
	defer f.Close()

	// Remove Juju home read permissions.
	home := gitjujutesting.JujuXDGDataHomePath()
	err := os.Chmod(home, 0)
	c.Assert(err, jc.ErrorIsNil)
	defer os.Chmod(home, 0700)

	jenvCmd := &model.JenvCommand{}
	ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
	c.Assert(err, gc.ErrorMatches, "cannot get config store: .*: permission denied")
	c.Assert(testing.Stdout(ctx), gc.Equals, "")
}
Пример #21
0
func (*suite) TestDefaultConfigFile(c *gc.C) {
	env := `
environments:
    only:
        type: dummy
        controller: false
        authorized-keys: i-am-a-key
`
	outfile, err := environs.WriteEnvirons("", env)
	c.Assert(err, jc.ErrorIsNil)
	path := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	c.Assert(path, gc.Equals, outfile)

	envs, err := environs.ReadEnvirons("")
	c.Assert(err, jc.ErrorIsNil)
	cfg, err := envs.Config("")
	c.Assert(err, jc.ErrorIsNil)
	c.Assert(cfg.Name(), gc.Equals, "only")
}
Пример #22
0
func (*jenvSuite) TestSwitchErrorCannotWriteCurrentModel(c *gc.C) {
	if runtime.GOOS == "windows" {
		c.Skip("Cannot test on windows because it uses chmod")
	}
	// Create a jenv file.
	f := openJenvFile(c, makeValidJenvContents())
	defer f.Close()

	// Create the current environment file without write permissions.
	currentEnvPath := gitjujutesting.JujuXDGDataHomePath(modelcmd.CurrentModelFilename)
	currentEnvFile, err := os.Create(currentEnvPath)
	c.Assert(err, jc.ErrorIsNil)
	defer currentEnvFile.Close()
	err = currentEnvFile.Chmod(0500)
	c.Assert(err, jc.ErrorIsNil)

	jenvCmd := &model.JenvCommand{}
	ctx, err := testing.RunCommand(c, jenvCmd, f.Name())
	c.Assert(err, gc.ErrorMatches, `cannot switch to the new model "testing": unable to write to the model file: .*: permission denied`)
	c.Assert(testing.Stdout(ctx), gc.Equals, "")
}
Пример #23
0
func (s *BootstrapSuite) TestBootstrapPropagatesEnvErrors(c *gc.C) {
	//TODO(bogdanteleaga): fix this for windows once permissions are fixed
	if runtime.GOOS == "windows" {
		c.Skip("bug 1403084: this is very platform specific. When/if we will support windows state machine, this will probably be rewritten.")
	}

	const envName = "devenv"
	s.patchVersionAndSeries(c, envName)
	s.PatchValue(&environType, func(string) (string, error) { return "", nil })

	_, err := coretesting.RunCommand(c, newBootstrapCommand(), "-m", envName, "--auto-upgrade")
	c.Assert(err, jc.ErrorIsNil)

	// Change permissions on the jenv file to simulate some kind of
	// unexpected error when trying to read info from the environment
	jenvFile := testing.JujuXDGDataHomePath("models", "cache.yaml")
	err = os.Chmod(jenvFile, os.FileMode(0200))
	c.Assert(err, jc.ErrorIsNil)

	// The second bootstrap should fail b/c of the propogated error
	_, err = coretesting.RunCommand(c, newBootstrapCommand(), "-m", envName)
	c.Assert(err, gc.ErrorMatches, "there was an issue examining the model: .*")
}
Пример #24
0
func (s *fakeHomeSuite) TestFakeHomeSetsConfigJujuXDGDataHome(c *gc.C) {
	s.PatchEnvironment(osenv.XDGDataHome, "")
	expected := gitjujutesting.JujuXDGDataHomePath()
	c.Assert(osenv.JujuXDGDataHome(), gc.Equals, expected)
}
Пример #25
0
func (s *fakeHomeSuite) TestFakeHomeSetsUpJujuXDGDataHome(c *gc.C) {
	jujuDir := gitjujutesting.JujuXDGDataHomePath()
	c.Assert(jujuDir, jc.IsDirectory)
}
Пример #26
0
func (s *ModelCommandSuite) TestModelCommandInitNoEnvFile(c *gc.C) {
	envPath := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	err := os.Remove(envPath)
	c.Assert(err, jc.ErrorIsNil)
	testEnsureModelName(c, "")
}
Пример #27
0
func (s *fakeHomeSuite) TestFakeHomeSetsUpJujuXDGDataHome(c *gc.C) {
	jujuDir := gitjujutesting.JujuXDGDataHomePath()
	c.Assert(jujuDir, jc.IsDirectory)
	envFile := gitjujutesting.JujuXDGDataHomePath("environments.yaml")
	c.Assert(envFile, jc.IsNonEmptyFile)
}