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 *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)
}
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 *fakeHomeSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
}
func (s *JujuOSEnvSuite) TearDownTest(c *gc.C) {
for name, value := range s.oldEnvironment {
os.Setenv(name, value)
}
err := utils.SetHome(s.oldHomeEnv)
c.Assert(err, jc.ErrorIsNil)
}
func (s *TestingBaseSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_HOME", jujuHome)
osenv.SetJujuHome(jujuHome)
s.BaseSuite.SetUpTest(c)
}
func (s *ConfigSuite) TearDownTest(c *gc.C) {
utils.SetHome(s.savedHome)
os.Setenv("AWS_ACCESS_KEY_ID", s.savedAccessKey)
os.Setenv("AWS_SECRET_ACCESS_KEY", s.savedSecretKey)
delete(aws.Regions, "configtest")
s.BaseSuite.TearDownTest(c)
}
func (s *fakeHomeSuite) SetUpTest(c *gc.C) {
utils.SetHome("/home/eric")
os.Setenv("JUJU_HOME", "/home/eric/juju")
osenv.SetJujuHome("/home/eric/juju")
s.FakeJujuHomeSuite.SetUpTest(c)
}
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 *TestingBaseSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.BaseSuite.SetUpTest(c)
}
func (s *fakeHomeSuite) SetUpTest(c *gc.C) {
utils.SetHome(home)
os.Setenv("JUJU_HOME", jujuHome)
osenv.SetJujuHome(jujuHome)
s.FakeJujuHomeSuite.SetUpTest(c)
}
func (s *JujuOSEnvSuite) TearDownTest(c *gc.C) {
for name, value := range s.oldEnvironment {
os.Setenv(name, value)
}
utils.SetHome(s.oldHomeEnv)
osenv.SetJujuHome(s.oldJujuHome)
}
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)
}
// Create a home directory and Juju data home for user username.
// This is used by setUpConn to create the 'ubuntu' user home, after RootDir,
// and may be used again later for other users.
func (s *JujuConnSuite) CreateUserHome(c *gc.C, params *UserHomeParams) {
if s.RootDir == "" {
c.Fatal("JujuConnSuite.setUpConn required first for RootDir")
}
c.Assert(params.Username, gc.Not(gc.Equals), "")
home := filepath.Join(s.RootDir, "home", params.Username)
err := os.MkdirAll(home, 0777)
c.Assert(err, jc.ErrorIsNil)
err = utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
jujuHome := filepath.Join(home, ".local", "share")
err = os.MkdirAll(filepath.Join(home, ".local", "share"), 0777)
c.Assert(err, jc.ErrorIsNil)
previousJujuXDGDataHome := osenv.SetJujuXDGDataHome(jujuHome)
if params.SetOldHome {
s.oldJujuXDGDataHome = previousJujuXDGDataHome
}
err = os.MkdirAll(s.DataDir(), 0777)
c.Assert(err, jc.ErrorIsNil)
jujuModelEnvKey := "JUJU_MODEL"
if params.ModelEnvKey != "" {
jujuModelEnvKey = params.ModelEnvKey
}
s.PatchEnvironment(osenv.JujuModelEnvKey, jujuModelEnvKey)
s.ControllerStore = jujuclient.NewFileClientStore()
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
serverAlive := gitjujutesting.MgoServer.Addr() != ""
// Bootstrap will set the admin password, and render non-authorized use
// impossible. s.State may still hold the right password, so try to reset
// the password so that the MgoSuite soft-resetting works. If that fails,
// it will still work, but it will take a while since it has to kill the
// whole database and start over.
if err := s.State.SetAdminMongoPassword(""); err != nil && serverAlive {
c.Logf("cannot reset admin password: %v", err)
}
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
}
err := s.Conn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
err = s.APIConn.Close()
if serverAlive {
c.Assert(err, gc.IsNil)
}
dummy.Reset()
s.apiStates = nil
s.Conn = nil
s.State = nil
utils.SetHome(s.oldHome)
osenv.SetJujuHome(s.oldJujuHome)
s.oldHome = ""
s.RootDir = ""
}
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 *fakeHomeSuite) SetUpTest(c *gc.C) {
err := utils.SetHome(home)
c.Assert(err, jc.ErrorIsNil)
os.Setenv("JUJU_DATA", jujuXDGDataHome)
osenv.SetJujuXDGDataHome(jujuXDGDataHome)
s.FakeJujuXDGDataHomeSuite.SetUpTest(c)
}
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 *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 (s *credentialsSuite) TestDetectCredentialsEnvironmentVariables(c *gc.C) {
home := utils.Home()
dir := c.MkDir()
utils.SetHome(dir)
s.AddCleanup(func(*gc.C) {
utils.SetHome(home)
})
s.PatchEnvironment("USER", "fred")
s.PatchEnvironment("AWS_ACCESS_KEY_ID", "key-id")
s.PatchEnvironment("AWS_SECRET_ACCESS_KEY", "secret-access-key")
credentials, err := s.provider.DetectCredentials()
c.Assert(err, jc.ErrorIsNil)
expected := cloud.NewCredential(
cloud.AccessKeyAuthType, map[string]string{
"access-key": "key-id",
"secret-key": "secret-access-key",
},
)
expected.Label = `aws credential "fred"`
c.Assert(credentials.AuthCredentials["fred"], jc.DeepEquals, expected)
}
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 *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 *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 MakeFakeHome(c *gc.C) *FakeHome {
fakeHome := c.MkDir()
utils.SetHome(fakeHome)
sshPath := filepath.Join(fakeHome, ".ssh")
err := os.Mkdir(sshPath, 0777)
c.Assert(err, gc.IsNil)
err = ioutil.WriteFile(filepath.Join(sshPath, "id_rsa.pub"), []byte("auth key\n"), 0666)
c.Assert(err, gc.IsNil)
return &FakeHome{
files: []TestFile{},
}
}
func (*fileSuite) TestNormalizePath(c *gc.C) {
home := filepath.FromSlash(c.MkDir())
err := utils.SetHome(home)
c.Assert(err, gc.IsNil)
// TODO (frankban) bug 1324841: improve the isolation of this suite.
currentUser, err := user.Current()
c.Assert(err, gc.IsNil)
for i, test := range []struct {
path string
expected string
err string
}{{
path: filepath.FromSlash("/var/lib/juju"),
expected: filepath.FromSlash("/var/lib/juju"),
}, {
path: "~/foo",
expected: filepath.Join(home, "foo"),
}, {
path: "~/foo//../bar",
expected: filepath.Join(home, "bar"),
}, {
path: "~",
expected: home,
}, {
path: "~" + currentUser.Username,
expected: currentUser.HomeDir,
}, {
path: "~" + currentUser.Username + "/foo",
expected: filepath.Join(currentUser.HomeDir, "foo"),
}, {
path: "~" + currentUser.Username + "/foo//../bar",
expected: filepath.Join(currentUser.HomeDir, "bar"),
}, {
path: filepath.FromSlash("foo~bar/baz"),
expected: filepath.FromSlash("foo~bar/baz"),
}, {
path: "~foobar/path",
err: ".*" + utils.NoSuchUserErrRegexp,
}} {
c.Logf("test %d: %s", i, test.path)
actual, err := utils.NormalizePath(test.path)
if test.err != "" {
c.Check(err, gc.ErrorMatches, test.err)
} else {
c.Check(err, gc.IsNil)
c.Check(actual, gc.Equals, test.expected)
}
}
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
testServer := gitjujutesting.MgoServer.Addr()
serverAlive := testServer != ""
// Bootstrap will set the admin password, and render non-authorized use
// impossible. s.State may still hold the right password, so try to reset
// the password so that the MgoSuite soft-resetting works. If that fails,
// it will still work, but it will take a while since it has to kill the
// whole database and start over.
if s.State != nil {
if err := s.State.SetAdminMongoPassword(""); err != nil && serverAlive {
c.Logf("cannot reset admin password: %v", err)
}
err := s.State.Close()
if serverAlive {
// This happens way too often with failing tests,
// so add some context in case of an error.
c.Check(
err,
gc.IsNil,
gc.Commentf("closing state failed, testing server %q is alive", testServer),
)
}
s.State = nil
}
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Check(err, gc.IsNil)
}
}
s.apiStates = nil
if s.APIState != nil {
err := s.APIState.Close()
s.APIState = nil
if serverAlive {
c.Check(err, gc.IsNil)
}
}
dummy.Reset()
utils.SetHome(s.oldHome)
osenv.SetJujuHome(s.oldJujuHome)
s.oldHome = ""
s.RootDir = ""
}
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)
}
func (s *JujuConnSuite) tearDownConn(c *gc.C) {
testServer := gitjujutesting.MgoServer.Addr()
serverAlive := testServer != ""
// Close any api connections we know about first.
for _, st := range s.apiStates {
err := st.Close()
if serverAlive {
c.Check(err, jc.ErrorIsNil)
}
}
s.apiStates = nil
if s.APIState != nil {
err := s.APIState.Close()
s.APIState = nil
if serverAlive {
c.Check(err, gc.IsNil,
gc.Commentf("closing api state failed\n%s\n", errors.ErrorStack(err)),
)
}
}
// Close state.
if s.State != nil {
err := s.State.Close()
if serverAlive {
// This happens way too often with failing tests,
// so add some context in case of an error.
c.Check(err, gc.IsNil,
gc.Commentf("closing state failed\n%s\n", errors.ErrorStack(err)),
)
}
s.State = nil
}
dummy.Reset(c)
err := utils.SetHome(s.oldHome)
c.Assert(err, jc.ErrorIsNil)
osenv.SetJujuXDGDataHome(s.oldJujuXDGDataHome)
s.oldHome = ""
s.RootDir = ""
}
func (s *fakeHomeSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
utils.SetHome("/tmp/tests")
}
