func (suite) TestInvalidConfig(c *C) {
for i, t := range invalidConfigTests {
c.Logf("running test %v", i)
_, err := environs.ReadEnvironsBytes([]byte(t.env))
c.Check(err, ErrorMatches, t.err)
}
}
func (suite) TestConfig(c *C) {
defer testing.MakeFakeHomeNoEnvironments(c, "only", "valid", "one", "two").Restore()
for i, t := range configTests {
c.Logf("running test %v", i)
es, err := environs.ReadEnvironsBytes([]byte(t.env))
c.Assert(err, IsNil)
t.check(c, es)
}
}
func (suite) TestInvalidEnv(c *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, IsNil)
e, err := es.Open(t.name)
c.Check(err, ErrorMatches, t.err)
c.Check(e, IsNil)
}
}
func (s *ConfigSuite) TestDefaultAuthorisationMethod(c *C) {
// Specify a basic configuration without authorization method.
envs := attrs{
"environments": attrs{
"testenv": attrs{
"type": "openstack",
},
},
}
data, err := goyaml.Marshal(envs)
c.Assert(err, IsNil)
s.setupEnvCredentials()
es, err := environs.ReadEnvironsBytes(data)
c.Check(err, IsNil)
e, err := es.Open("testenv")
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.authMethod(), Equals, string(AuthUserPass))
}
func (s *ConfigSuite) TestCredentialsFromEnv(c *C) {
// Specify a basic configuration without credentials.
envs := attrs{
"environments": attrs{
"testenv": attrs{
"type": "openstack",
},
},
}
data, err := goyaml.Marshal(envs)
c.Assert(err, IsNil)
// Poke the credentials into the environment.
s.setupEnvCredentials()
es, err := environs.ReadEnvironsBytes(data)
c.Check(err, IsNil)
e, err := es.Open("testenv")
ecfg := e.(*environ).ecfg()
// The credentials below come from environment variables set during test setup.
c.Assert(ecfg.username(), Equals, "user")
c.Assert(ecfg.password(), Equals, "secret")
c.Assert(ecfg.authURL(), Equals, "http://auth")
c.Assert(ecfg.region(), Equals, "region")
c.Assert(ecfg.tenantName(), Equals, "sometenant")
}
func (t configTest) check(c *C) {
envs := attrs{
"environments": attrs{
"testenv": attrs{
"type": "ec2",
"ca-cert": testing.CACert,
"ca-private-key": testing.CAKey,
},
},
}
testenv := envs["environments"].(attrs)["testenv"].(attrs)
for k, v := range t.config {
testenv[k] = v
}
if _, ok := testenv["control-bucket"]; !ok {
testenv["control-bucket"] = "x"
}
data, err := goyaml.Marshal(envs)
c.Assert(err, IsNil)
es, err := environs.ReadEnvironsBytes(data)
c.Check(err, IsNil)
e, err := es.Open("testenv")
if t.change != nil {
c.Assert(err, IsNil)
// Testing a change in configuration.
var old, changed, valid *config.Config
ec2env := e.(*environ)
old = ec2env.ecfg().Config
changed, err = old.Apply(t.change)
c.Assert(err, IsNil)
// Keep err for validation below.
valid, err = providerInstance.Validate(changed, old)
if err == nil {
err = ec2env.SetConfig(valid)
}
}
if t.err != "" {
c.Check(err, ErrorMatches, t.err)
return
}
c.Assert(err, IsNil)
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.Name(), Equals, "testenv")
c.Assert(ecfg.controlBucket(), Equals, "x")
if t.region != "" {
c.Assert(ecfg.region(), Equals, t.region)
}
if t.pbucket != "" {
c.Assert(ecfg.publicBucket(), Equals, t.pbucket)
}
if t.accessKey != "" {
c.Assert(ecfg.accessKey(), Equals, t.accessKey)
c.Assert(ecfg.secretKey(), Equals, t.secretKey)
expected := map[string]interface{}{
"access-key": t.accessKey,
"secret-key": t.secretKey,
}
c.Assert(err, IsNil)
actual, err := e.Provider().SecretAttrs(ecfg.Config)
c.Assert(err, IsNil)
c.Assert(expected, DeepEquals, actual)
} else {
c.Assert(ecfg.accessKey(), DeepEquals, testAuth.AccessKey)
c.Assert(ecfg.secretKey(), DeepEquals, testAuth.SecretKey)
}
if t.firewallMode != "" {
c.Assert(ecfg.FirewallMode(), Equals, t.firewallMode)
}
// check storage buckets are configured correctly
env := e.(*environ)
c.Assert(env.Storage().(*storage).bucket.Region.Name, Equals, ecfg.region())
c.Assert(env.PublicStorage().(*storage).bucket.Region.Name, Equals, ecfg.publicBucketRegion())
}
func (t configTest) check(c *gc.C) {
envs := attrs{
"environments": attrs{
"testenv": attrs{
"type": "openstack",
"authorized-keys": "fakekey",
},
},
}
testenv := envs["environments"].(attrs)["testenv"].(attrs)
for k, v := range t.config {
testenv[k] = v
}
if _, ok := testenv["control-bucket"]; !ok {
testenv["control-bucket"] = "x"
}
data, err := goyaml.Marshal(envs)
c.Assert(err, gc.IsNil)
es, err := environs.ReadEnvironsBytes(data)
c.Check(err, gc.IsNil)
// Set environment variables if any.
savedVars := make(map[string]string)
if t.envVars != nil {
for k, v := range t.envVars {
savedVars[k] = os.Getenv(k)
os.Setenv(k, v)
}
}
defer restoreEnvVars(savedVars)
e, err := es.Open("testenv")
if t.change != nil {
c.Assert(err, gc.IsNil)
// Testing a change in configuration.
var old, changed, valid *config.Config
osenv := e.(*environ)
old = osenv.ecfg().Config
changed, err = old.Apply(t.change)
c.Assert(err, gc.IsNil)
// Keep err for validation below.
valid, err = providerInstance.Validate(changed, old)
if err == nil {
err = osenv.SetConfig(valid)
}
}
if t.err != "" {
c.Check(err, gc.ErrorMatches, t.err)
return
}
c.Assert(err, gc.IsNil)
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.Name(), gc.Equals, "testenv")
c.Assert(ecfg.controlBucket(), gc.Equals, "x")
if t.region != "" {
c.Assert(ecfg.region(), gc.Equals, t.region)
}
if t.authMode != "" {
c.Assert(ecfg.authMode(), gc.Equals, t.authMode)
}
if t.accessKey != "" {
c.Assert(ecfg.accessKey(), gc.Equals, t.accessKey)
}
if t.secretKey != "" {
c.Assert(ecfg.secretKey(), gc.Equals, t.secretKey)
}
if t.username != "" {
c.Assert(ecfg.username(), gc.Equals, t.username)
c.Assert(ecfg.password(), gc.Equals, t.password)
c.Assert(ecfg.tenantName(), gc.Equals, t.tenantName)
c.Assert(ecfg.authURL(), gc.Equals, t.authURL)
expected := map[string]interface{}{
"username": t.username,
"password": t.password,
"tenant-name": t.tenantName,
}
c.Assert(err, gc.IsNil)
actual, err := e.Provider().SecretAttrs(ecfg.Config)
c.Assert(err, gc.IsNil)
c.Assert(expected, gc.DeepEquals, actual)
}
if t.pbucketURL != "" {
c.Assert(ecfg.publicBucketURL(), gc.Equals, t.pbucketURL)
c.Assert(ecfg.publicBucket(), gc.Equals, t.publicBucket)
}
if t.firewallMode != "" {
c.Assert(ecfg.FirewallMode(), gc.Equals, t.firewallMode)
}
c.Assert(ecfg.useFloatingIP(), gc.Equals, t.useFloatingIP)
for name, expect := range t.expect {
actual, found := ecfg.UnknownAttrs()[name]
c.Check(found, gc.Equals, true)
c.Check(actual, gc.Equals, expect)
}
}
func (*BoilerplateConfigSuite) TestBoilerPlateGeneration(c *C) {
defer config.SetJujuHome(config.SetJujuHome(c.MkDir()))
boilerplate_text := environs.BoilerplateConfig()
_, err := environs.ReadEnvironsBytes([]byte(boilerplate_text))
c.Assert(err, IsNil)
}
func (t configTest) check(c *C) {
envs := attrs{
"environments": attrs{
"testenv": attrs{
"type": "openstack",
},
},
}
testenv := envs["environments"].(attrs)["testenv"].(attrs)
for k, v := range t.config {
testenv[k] = v
}
if _, ok := testenv["control-bucket"]; !ok {
testenv["control-bucket"] = "x"
}
data, err := goyaml.Marshal(envs)
c.Assert(err, IsNil)
es, err := environs.ReadEnvironsBytes(data)
c.Check(err, IsNil)
e, err := es.Open("testenv")
if t.change != nil {
c.Assert(err, IsNil)
// Testing a change in configuration.
var old, changed, valid *config.Config
osenv := e.(*environ)
old = osenv.ecfg().Config
changed, err = old.Apply(t.change)
c.Assert(err, IsNil)
// Keep err for validation below.
valid, err = providerInstance.Validate(changed, old)
if err == nil {
err = osenv.SetConfig(valid)
}
}
if t.err != "" {
c.Check(err, ErrorMatches, t.err)
return
}
c.Assert(err, IsNil)
ecfg := e.(*environ).ecfg()
c.Assert(ecfg.Name(), Equals, "testenv")
c.Assert(ecfg.controlBucket(), Equals, "x")
if t.region != "" {
c.Assert(ecfg.region(), Equals, t.region)
}
if t.username != "" {
c.Assert(ecfg.username(), Equals, t.username)
c.Assert(ecfg.password(), Equals, t.password)
c.Assert(ecfg.tenantName(), Equals, t.tenantName)
c.Assert(ecfg.authURL(), Equals, t.authURL)
expected := map[string]interface{}{
"username": t.username,
"password": t.password,
"tenant-name": t.tenantName,
}
c.Assert(err, IsNil)
actual, err := e.Provider().SecretAttrs(ecfg.Config)
c.Assert(err, IsNil)
c.Assert(expected, DeepEquals, actual)
}
if t.pbucketURL != "" {
c.Assert(ecfg.publicBucketURL(), Equals, t.pbucketURL)
c.Assert(ecfg.publicBucket(), Equals, t.publicBucket)
}
if t.firewallMode != "" {
c.Assert(ecfg.FirewallMode(), Equals, t.firewallMode)
}
}