func (s *fakeHomeSuite) TestHomeCreated(c *gc.C) {
// A fake home is created and set.
s.fakeHomeSuite.SetUpTest(c)
home := utils.Home()
c.Assert(home, gc.Not(gc.Equals), "/tmp/tests")
c.Assert(home, jc.IsDirectory)
s.fakeHomeSuite.TearDownTest(c)
// The original home has been restored.
c.Assert(utils.Home(), gc.Equals, "/tmp/tests")
}
func (s *filestorageSuite) TestPathRelativeToHome(c *gc.C) {
homeDir := utils.Home()
tempDir, err := ioutil.TempDir(homeDir, "")
c.Assert(err, jc.ErrorIsNil)
defer os.RemoveAll(tempDir)
dirName := strings.Replace(tempDir, homeDir, "", -1)
reader, err := filestorage.NewFileStorageReader(filepath.Join(utils.Home(), dirName))
c.Assert(err, jc.ErrorIsNil)
url, err := reader.URL("")
c.Assert(err, jc.ErrorIsNil)
c.Assert(url, gc.Equals, utils.MakeFileURL(filepath.Join(homeDir, dirName)))
}
func (s *fakeHomeSuite) TestHomeCreated(c *gc.C) {
// A fake home is created and set.
s.fakeHomeSuite.SetUpTest(c)
home := utils.Home()
c.Assert(home, gc.Not(gc.Equals), "/tmp/tests")
c.Assert(home, jc.IsDirectory)
s.fakeHomeSuite.TearDownTest(c)
// The original home has been restored.
switch runtime.GOOS {
case "windows":
c.Assert(utils.Home(), jc.SamePath, "C:/tmp/tests")
default:
c.Assert(utils.Home(), jc.SamePath, "/tmp/tests")
}
}
func (s *credentialsSuite) TestDetectCredentialsNovarc(c *gc.C) {
if runtime.GOOS != "linux" {
c.Skip("not running linux")
}
home := utils.Home()
dir := c.MkDir()
utils.SetHome(dir)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
content := `
# Some secrets
export OS_TENANT_NAME=gary
EXPORT OS_USERNAME=bob
export OS_PASSWORD = dobbs
OS_REGION_NAME=region
`[1:]
novarc := filepath.Join(dir, ".novarc")
err := ioutil.WriteFile(novarc, []byte(content), 0600)
credentials, err := s.provider.DetectCredentials()
c.Assert(err, jc.ErrorIsNil)
c.Assert(credentials.DefaultRegion, gc.Equals, "region")
expected := cloud.NewCredential(
cloud.UserPassAuthType, map[string]string{
"username": "******",
"password": "******",
"tenant-name": "gary",
"domain-name": "",
},
)
expected.Label = `openstack region "region" project "gary" user "bob"`
c.Assert(credentials.AuthCredentials["bob"], jc.DeepEquals, expected)
}
func (s *JujuOSEnvSuite) SetUpTest(c *gc.C) {
s.oldEnvironment = make(map[string]string)
for _, name := range []string{
osenv.JujuXDGDataHomeEnvKey,
osenv.JujuModelEnvKey,
osenv.JujuLoggingConfigEnvKey,
osenv.JujuFeatureFlagEnvKey,
osenv.XDGDataHome,
} {
s.oldEnvironment[name] = os.Getenv(name)
os.Setenv(name, "")
}
s.oldHomeEnv = utils.Home()
s.oldJujuXDGDataHome = osenv.SetJujuXDGDataHome("")
utils.SetHome("")
// Update the feature flag set to be the requested initial set.
// This works for both windows and unix, even though normally
// the feature flags on windows are determined using the registry.
// For tests, setting with the environment variable isolates us
// from a single resource that was hitting contention during parallel
// test runs.
os.Setenv(osenv.JujuFeatureFlagEnvKey, s.initialFeatureFlags)
featureflag.SetFlagsFromEnvironment(osenv.JujuFeatureFlagEnvKey)
}
func (s *DeploySuite) TestRelativeConfigPath(c *gc.C) {
testcharms.Repo.CharmArchivePath(s.SeriesPath, "dummy")
// Putting a config file in home is okay as $HOME is set to a tempdir
setupConfigFile(c, utils.Home())
err := runDeploy(c, "local:dummy", "dummy-service", "--config", "~/testconfig.yaml")
c.Assert(err, jc.ErrorIsNil)
}
func (s *TestingBaseSuite) TearDownTest(c *gc.C) {
s.BaseSuite.TearDownTest(c)
// Test that the environment is restored.
c.Assert(utils.Home(), gc.Equals, home)
c.Assert(os.Getenv("JUJU_HOME"), gc.Equals, jujuHome)
}
// oldJujuHomeLinux returns the directory where juju 1.x stored
// application-specific files on Linux.
func oldJujuHomeLinux() string {
home := utils.Home()
if home == "" {
return ""
}
return filepath.Join(home, ".juju")
}
func (s *makeFakeHomeSuite) TestAddFiles(c *gc.C) {
// Files are correctly added to the fake home.
expectedPath := filepath.Join(utils.Home(), "testfile-name")
contents, err := ioutil.ReadFile(expectedPath)
c.Assert(err, gc.IsNil)
c.Assert(string(contents), gc.Equals, "testfile-data")
}
func (s *cmdLoginSuite) TestLoginCommand(c *gc.C) {
s.createTestUser(c)
// logout "admin" first; we'll need to give it
// a non-random password before we can do so.
s.changeUserPassword(c, "admin", "hunter2")
s.run(c, nil, "logout")
// TODO(axw) 2016-09-08 #1621375
// "juju logout" should clear the cookies for the controller.
os.Remove(filepath.Join(utils.Home(), ".go-cookies"))
context := s.run(c, strings.NewReader("hunter2\nhunter2\n"), "login", "test")
c.Assert(testing.Stdout(context), gc.Equals, "")
c.Assert(testing.Stderr(context), gc.Equals, `
please enter password for test@local on kontroll:
You are now logged in to "kontroll" as "test@local".
`[1:])
// We should have a macaroon, but no password, in the client store.
store := jujuclient.NewFileClientStore()
accountDetails, err := store.AccountDetails("kontroll")
c.Assert(err, jc.ErrorIsNil)
c.Assert(accountDetails.Password, gc.Equals, "")
// We should be able to login with the macaroon.
s.run(c, nil, "status")
}
func wellKnownCredentialsFile() string {
const f = "application_default_credentials.json"
if runtime.GOOS == "windows" {
return filepath.Join(os.Getenv("APPDATA"), "gcloud", f)
}
return filepath.Join(utils.Home(), ".config", "gcloud", f)
}
func (s *JujuConnSuite) setUpConn(c *gc.C) {
if s.RootDir != "" {
panic("JujuConnSuite.setUpConn without teardown")
}
s.RootDir = c.MkDir()
s.oldHome = utils.Home()
home := filepath.Join(s.RootDir, "/home/ubuntu")
err := os.MkdirAll(home, 0777)
c.Assert(err, gc.IsNil)
utils.SetHome(home)
s.oldJujuHome = osenv.SetJujuHome(filepath.Join(home, ".juju"))
err = os.Mkdir(osenv.JujuHome(), 0777)
c.Assert(err, gc.IsNil)
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, gc.IsNil)
s.PatchEnvironment(osenv.JujuEnvEnvKey, "")
// TODO(rog) remove these files and add them only when
// the tests specifically need them (in cmd/juju for example)
s.writeSampleConfig(c, osenv.JujuHomePath("environments.yaml"))
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-cert.pem"), []byte(testing.CACert), 0666)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(osenv.JujuHomePath("dummyenv-private-key.pem"), []byte(testing.CAKey), 0600)
c.Assert(err, gc.IsNil)
store, err := configstore.Default()
c.Assert(err, gc.IsNil)
s.ConfigStore = store
ctx := testing.Context(c)
environ, err := environs.PrepareFromName("dummyenv", ctx, s.ConfigStore)
c.Assert(err, gc.IsNil)
// sanity check we've got the correct environment.
c.Assert(environ.Config().Name(), gc.Equals, "dummyenv")
s.PatchValue(&dummy.DataDir, s.DataDir())
s.LogDir = c.MkDir()
s.PatchValue(&dummy.LogDir, s.LogDir)
versions := PreferredDefaultVersions(environ.Config(), version.Binary{Number: version.Current.Number, Series: "precise", Arch: "amd64"})
versions = append(versions, version.Current)
// Upload tools for both preferred and fake default series
envtesting.MustUploadFakeToolsVersions(environ.Storage(), versions...)
err = bootstrap.Bootstrap(ctx, environ, bootstrap.BootstrapParams{})
c.Assert(err, gc.IsNil)
s.BackingState = environ.(GetStater).GetStateInAPIServer()
s.State, err = newState(environ, s.BackingState.MongoConnectionInfo())
c.Assert(err, gc.IsNil)
s.APIState, err = juju.NewAPIState(environ, api.DialOpts{})
c.Assert(err, gc.IsNil)
s.Environ = environ
}
func (s *configSuite) TestValidateConfigWithTildeInRootDir(c *gc.C) {
valid := localConfig(c, map[string]interface{}{
"root-dir": "~/.juju/foo",
})
expectedRootDir := filepath.Join(utils.Home(), ".juju", "foo")
unknownAttrs := valid.UnknownAttrs()
c.Assert(unknownAttrs["root-dir"], gc.Equals, expectedRootDir)
}
func (s *fakeHomeSuite) TearDownTest(c *gc.C) {
s.FakeJujuHomeSuite.TearDownTest(c)
// Test that the environment is restored.
c.Assert(utils.Home(), gc.Equals, jujuHome)
c.Assert(os.Getenv("JUJU_HOME"), gc.Equals, jujuHome)
c.Assert(osenv.JujuHome(), gc.Equals, jujuHome)
}
func (s *FakeHomeSuite) SetUpTest(c *gc.C) {
s.CleanupSuite.SetUpTest(c)
s.LoggingSuite.SetUpTest(c)
home := utils.Home()
s.Home = MakeFakeHome(c)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
}
func (s *AuthKeysSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
old := utils.Home()
newhome := c.MkDir()
utils.SetHome(newhome)
s.AddCleanup(func(*gc.C) { utils.SetHome(old) })
s.dotssh = filepath.Join(newhome, ".ssh")
err := os.Mkdir(s.dotssh, 0755)
c.Assert(err, gc.IsNil)
}
// jujuXDGDataHomeLinux returns the directory where juju should store application-specific files on Linux.
func jujuXDGDataHomeLinux() string {
xdgConfig := os.Getenv(XDGDataHome)
if xdgConfig != "" {
return filepath.Join(xdgConfig, "juju")
}
// If xdg config home is not defined, the standard indicates that its default value
// is $HOME/.local/share
home := utils.Home()
return filepath.Join(home, ".local/share", "juju")
}
func (s *FakeHomeSuite) SetUpTest(c *gc.C) {
s.CleanupSuite.SetUpTest(c)
s.LoggingSuite.SetUpTest(c)
home := utils.Home()
s.Home = MakeFakeHome(c)
s.AddCleanup(func(*gc.C) {
err := utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
})
}
func (h *FakeHome) AddFiles(c *gc.C, files ...TestFile) {
for _, f := range files {
path := filepath.Join(utils.Home(), f.Name)
err := os.MkdirAll(filepath.Dir(path), 0700)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(path, []byte(f.Data), 0666)
c.Assert(err, gc.IsNil)
h.files = append(h.files, f)
}
}
func (s *FileVarSuite) TestTildeFileVar(c *gc.C) {
path := filepath.Join(utils.Home(), "config.yaml")
err := ioutil.WriteFile(path, []byte("abc"), 0644)
c.Assert(err, gc.IsNil)
var config cmd.FileVar
config.Set("~/config.yaml")
file, err := config.Read(s.ctx)
c.Assert(err, gc.IsNil)
c.Assert(string(file), gc.Equals, "abc")
}
func (s *FileVarSuite) TestOpenTilde(c *gc.C) {
path := filepath.Join(utils.Home(), "config.yaml")
err := ioutil.WriteFile(path, []byte("abc"), 0644)
c.Assert(err, gc.IsNil)
var config cmd.FileVar
config.Set("~/config.yaml")
file, err := config.Open(s.ctx)
c.Assert(err, gc.IsNil)
s.checkOpen(c, file, "abc")
}
func (s *credentialsSuite) TestDetectCredentialsKnownLocationUnix(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("skipping on Windows")
}
home := utils.Home()
dir := c.MkDir()
utils.SetHome(dir)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
s.assertDetectCredentialsKnownLocation(c, dir)
}
func (s *homeSuite) TestHome(c *gc.C) {
s.PatchEnvironment("HOMEPATH", "")
s.PatchEnvironment("HOMEDRIVE", "")
drive := "P:"
path := `\home\foo\bar`
h := drive + path
utils.SetHome(h)
c.Check(os.Getenv("HOMEPATH"), gc.Equals, path)
c.Check(os.Getenv("HOMEDRIVE"), gc.Equals, drive)
c.Check(utils.Home(), gc.Equals, h)
// now test that if we only set the path, we don't mess with the drive
path2 := `\home\someotherfoo\bar`
utils.SetHome(path2)
c.Check(os.Getenv("HOMEPATH"), gc.Equals, path2)
c.Check(os.Getenv("HOMEDRIVE"), gc.Equals, drive)
c.Check(utils.Home(), gc.Equals, drive+path2)
}
func (s *JujuOSEnvSuite) SetUpTest(c *gc.C) {
s.oldEnvironment = make(map[string]string)
for _, name := range []string{
osenv.JujuHomeEnvKey,
osenv.JujuEnvEnvKey,
osenv.JujuLoggingConfigEnvKey,
} {
s.oldEnvironment[name] = os.Getenv(name)
os.Setenv(name, "")
}
s.oldHomeEnv = utils.Home()
utils.SetHome("")
}
func (s *ConfigSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.savedHome = utils.Home()
home := c.MkDir()
sshDir := filepath.Join(home, ".ssh")
err := os.Mkdir(sshDir, 0777)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(filepath.Join(sshDir, "id_rsa.pub"), []byte("sshkey\n"), 0666)
c.Assert(err, jc.ErrorIsNil)
err = utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
}
func (s *PublishSuite) SetUpTest(c *gc.C) {
s.FakeJujuHomeSuite.SetUpTest(c)
s.HTTPSuite.SetUpTest(c)
s.PatchEnvironment("BZR_HOME", utils.Home())
s.FakeJujuHomeSuite.Home.AddFiles(c, gitjujutesting.TestFile{
Name: bzrHomeFile,
Data: "[DEFAULT]\nemail = Test <*****@*****.**>\n",
})
s.dir = c.MkDir()
s.branch = bzr.New(s.dir)
err := s.branch.Init()
c.Assert(err, jc.ErrorIsNil)
}
func newHTTPClient() (*cookiejar.Jar, *http.Client, error) {
cookieFile := path.Join(utils.Home(), ".go-cookies")
jar, err := cookiejar.New(&cookiejar.Options{
PublicSuffixList: publicsuffix.List,
})
if err != nil {
panic(err)
}
if err := jar.Load(cookieFile); err != nil {
return nil, nil, err
}
client := httpbakery.NewHTTPClient()
client.Jar = jar
return jar, client, nil
}
func (s *credentialsSuite) TestDetectCredentialsKnownLocationUnix(c *gc.C) {
if runtime.GOOS == "windows" {
c.Skip("skipping on Windows")
}
home := utils.Home()
dir := c.MkDir()
utils.SetHome(dir)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
path := filepath.Join(dir, ".config", "gcloud")
err := os.MkdirAll(path, 0700)
c.Assert(err, jc.ErrorIsNil)
jsonpath := createCredsFile(c, filepath.Join(path, "application_default_credentials.json"))
s.assertDetectCredentialsKnownLocation(c, jsonpath)
}
func (s *ConfigSuite) SetUpTest(c *gc.C) {
s.BaseSuite.SetUpTest(c)
s.savedHome = utils.Home()
s.savedAccessKey = os.Getenv("AWS_ACCESS_KEY_ID")
s.savedSecretKey = os.Getenv("AWS_SECRET_ACCESS_KEY")
home := c.MkDir()
sshDir := filepath.Join(home, ".ssh")
err := os.Mkdir(sshDir, 0777)
c.Assert(err, jc.ErrorIsNil)
err = ioutil.WriteFile(filepath.Join(sshDir, "id_rsa.pub"), []byte("sshkey\n"), 0666)
c.Assert(err, jc.ErrorIsNil)
utils.SetHome(home)
os.Setenv("AWS_ACCESS_KEY_ID", testAuth.AccessKey)
os.Setenv("AWS_SECRET_ACCESS_KEY", testAuth.SecretKey)
aws.Regions["configtest"] = configTestRegion
}
func (s *JujuOSEnvSuite) SetUpTest(c *gc.C) {
s.oldEnvironment = make(map[string]string)
for _, name := range []string{
osenv.JujuHomeEnvKey,
osenv.JujuEnvEnvKey,
osenv.JujuLoggingConfigEnvKey,
osenv.JujuFeatureFlagEnvKey,
} {
s.oldEnvironment[name] = os.Getenv(name)
os.Setenv(name, "")
}
s.oldHomeEnv = utils.Home()
s.oldJujuHome = osenv.SetJujuHome("")
utils.SetHome("")
// Update the feature flag set to be the requested initial set.
s.setUpFeatureFlags(c)
}