func (*suite) TestConfigPerm(c *gc.C) {
defer testing.MakeSampleHome(c).Restore()
path := testing.HomePath(".juju")
info, err := os.Lstat(path)
c.Assert(err, gc.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, gc.IsNil)
info, err = os.Lstat(outfile)
c.Assert(err, gc.IsNil)
c.Assert(info.Mode().Perm(), gc.Equals, os.FileMode(0600))
info, err = os.Lstat(filepath.Dir(outfile))
c.Assert(err, gc.IsNil)
c.Assert(info.Mode().Perm(), gc.Equals, oldPerm)
}
// TODO(jam): 2013-08-27 This should move somewhere in api.*
func (*NewAPIClientSuite) TestMultipleCloseOk(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
bootstrapEnv(c, "", defaultConfigStore(c))
client, _ := juju.NewAPIClientFromName("")
c.Assert(client.Close(), gc.IsNil)
c.Assert(client.Close(), gc.IsNil)
c.Assert(client.Close(), gc.IsNil)
}
func (*NewConnSuite) TestNewConnFromNameNotSetGetsDefault(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
bootstrapEnv(c, "", defaultConfigStore(c))
conn, err := juju.NewConnFromName("")
c.Assert(err, gc.IsNil)
defer assertClose(c, conn)
c.Assert(conn.Environ.Name(), gc.Equals, coretesting.SampleEnvName)
}
func (*NewConnSuite) TestConnMultipleCloseOk(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
bootstrapEnv(c, "", defaultConfigStore(c))
// Error return from here is tested in TestNewConnFromNameNotSetGetsDefault.
conn, err := juju.NewConnFromName("")
c.Assert(err, gc.IsNil)
assertClose(c, conn)
assertClose(c, conn)
assertClose(c, conn)
}
func (s *NewAPIClientSuite) TestWithConfigAndNoInfo(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
store := newConfigStore(coretesting.SampleEnvName, &environInfo{
bootstrapConfig: map[string]interface{}{
"type": "dummy",
"name": "myenv",
"state-server": true,
"authorized-keys": "i-am-a-key",
"default-series": config.LatestLtsSeries(),
"firewall-mode": config.FwInstance,
"development": false,
"ssl-hostname-verification": true,
"admin-secret": "adminpass",
},
})
bootstrapEnv(c, coretesting.SampleEnvName, store)
// Verify the cache is empty.
info, err := store.ReadInfo("myenv")
c.Assert(err, gc.IsNil)
c.Assert(info, gc.NotNil)
c.Assert(info.APIEndpoint(), jc.DeepEquals, configstore.APIEndpoint{})
c.Assert(info.APICredentials(), jc.DeepEquals, configstore.APICredentials{})
called := 0
expectState := &mockAPIState{}
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, "user-admin")
c.Check(string(apiInfo.CACert), gc.Not(gc.Equals), "")
c.Check(apiInfo.Password, gc.Equals, "adminpass")
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
st, err := juju.NewAPIFromStore("myenv", store, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 1)
// Make sure the cache is updated.
info, err = store.ReadInfo("myenv")
c.Assert(err, gc.IsNil)
c.Assert(info, gc.NotNil)
ep := info.APIEndpoint()
c.Assert(ep.Addresses, gc.HasLen, 1)
c.Check(ep.Addresses[0], gc.Matches, `127\.0\.0\.1:\d+`)
c.Check(ep.CACert, gc.Not(gc.Equals), "")
creds := info.APICredentials()
c.Check(creds.User, gc.Equals, "admin")
c.Check(creds.Password, gc.Equals, "adminpass")
}
func (s *ImageMetadataSuite) TestImageMetadataBadArgs(c *gc.C) {
home := testing.MakeSampleHome(c)
s.AddCleanup(func(*gc.C) {
home.Restore()
dummy.Reset()
})
for i, t := range errTests {
c.Logf("test: %d", i)
ctx := testing.Context(c)
code := cmd.Main(&ImageMetadataCommand{}, ctx, t.args)
c.Check(code, gc.Equals, 1)
}
}
func (s *PublishSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.HTTPSuite.SetUpTest(c)
s.home = testing.MakeSampleHome(c, testing.TestFile{
Name: ".bazaar/bazaar.conf",
Data: "[DEFAULT]\nemail = Test <*****@*****.**>\n",
})
s.dir = c.MkDir()
s.branch = bzr.New(s.dir)
err := s.branch.Init()
c.Assert(err, gc.IsNil)
}
func (s *NewAPIClientSuite) TestWithSlowInfoConnect(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
infoOpenedState := &mockAPIState{}
infoEndpointOpened := make(chan struct{})
cfgOpenedState := &mockAPIState{}
// On a sample run with no delay, the logic took 45ms to run, so
// we make the delay slightly more than that, so that if the
// logic doesn't delay at all, the test will fail reasonably consistently.
s.PatchValue(juju.ProviderConnectDelay, 50*time.Millisecond)
apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
if info.Addrs[0] == "infoapi.invalid" {
infoEndpointOpened <- struct{}{}
return infoOpenedState, nil
}
return cfgOpenedState, nil
}
stateClosed := make(chan juju.APIState)
infoOpenedState.close = func(st juju.APIState) error {
stateClosed <- st
return nil
}
cfgOpenedState.close = infoOpenedState.close
startTime := time.Now()
st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
c.Assert(err, gc.IsNil)
// The connection logic should wait for some time before opening
// the API from the configuration.
c.Assert(time.Since(startTime), jc.GreaterThan, *juju.ProviderConnectDelay)
c.Assert(st, gc.Equals, cfgOpenedState)
select {
case <-infoEndpointOpened:
case <-time.After(coretesting.LongWait):
c.Errorf("api never opened via info")
}
// Check that the ignored state was closed.
select {
case st := <-stateClosed:
c.Assert(st, gc.Equals, infoOpenedState)
case <-time.After(coretesting.LongWait):
c.Errorf("timed out waiting for state to be closed")
}
}
func (s *NewAPIClientSuite) TestBothError(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
if info.Addrs[0] == "infoapi.invalid" {
return nil, fmt.Errorf("info connect failed")
}
return nil, fmt.Errorf("config connect failed")
}
st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
c.Check(err, gc.ErrorMatches, "config connect failed")
c.Check(st, gc.IsNil)
}
func (s *ToolsMetadataSuite) SetUpTest(c *gc.C) {
s.LoggingSuite.SetUpTest(c)
s.home = coretesting.MakeSampleHome(c)
s.AddCleanup(func(*gc.C) {
s.home.Restore()
dummy.Reset()
loggo.ResetLoggers()
})
env, err := environs.PrepareFromName("erewhemos", coretesting.Context(c), configstore.NewMem())
c.Assert(err, gc.IsNil)
s.env = env
envtesting.RemoveAllTools(c, s.env)
loggo.GetLogger("").SetLogLevel(loggo.INFO)
// Switch the default tools location.
s.publicStorageDir = c.MkDir()
s.PatchValue(&tools.DefaultBaseURL, s.publicStorageDir)
}
func (*NewAPIClientSuite) TestWithBootstrapConfigAndNoEnvironmentsFile(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
info, err := store.ReadInfo(coretesting.SampleEnvName)
c.Assert(err, gc.IsNil)
c.Assert(info.BootstrapConfig(), gc.NotNil)
c.Assert(info.APIEndpoint().Addresses, gc.HasLen, 0)
err = os.Remove(osenv.JujuHomePath("environments.yaml"))
c.Assert(err, gc.IsNil)
apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
return &mockAPIState{}, nil
}
st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
c.Check(err, gc.IsNil)
st.Close()
}
func (suite *HelpToolSuite) SetUpTest(c *gc.C) {
suite.home = testing.MakeSampleHome(c)
}
func (s *NewAPIClientSuite) TestWithSlowConfigConnect(c *gc.C) {
defer coretesting.MakeSampleHome(c).Restore()
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
setEndpointAddress(c, store, coretesting.SampleEnvName, "infoapi.invalid")
infoOpenedState := &mockAPIState{}
infoEndpointOpened := make(chan struct{})
cfgOpenedState := &mockAPIState{}
cfgEndpointOpened := make(chan struct{})
s.PatchValue(juju.ProviderConnectDelay, 0*time.Second)
apiOpen := func(info *api.Info, opts api.DialOpts) (juju.APIState, error) {
if info.Addrs[0] == "infoapi.invalid" {
infoEndpointOpened <- struct{}{}
<-infoEndpointOpened
return infoOpenedState, nil
}
cfgEndpointOpened <- struct{}{}
<-cfgEndpointOpened
return cfgOpenedState, nil
}
stateClosed := make(chan juju.APIState)
infoOpenedState.close = func(st juju.APIState) error {
stateClosed <- st
return nil
}
cfgOpenedState.close = infoOpenedState.close
done := make(chan struct{})
go func() {
st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
c.Check(err, gc.IsNil)
c.Check(st, gc.Equals, infoOpenedState)
close(done)
}()
// Check that we're trying to connect to both endpoints:
select {
case <-infoEndpointOpened:
case <-time.After(coretesting.LongWait):
c.Fatalf("api never opened via info")
}
select {
case <-cfgEndpointOpened:
case <-time.After(coretesting.LongWait):
c.Fatalf("api never opened via config")
}
// Let the info endpoint open go ahead and
// check that the NewAPIFromStore call returns.
infoEndpointOpened <- struct{}{}
select {
case <-done:
case <-time.After(coretesting.LongWait):
c.Errorf("timed out opening API")
}
// Let the config endpoint open go ahead and
// check that its state is closed.
cfgEndpointOpened <- struct{}{}
select {
case st := <-stateClosed:
c.Assert(st, gc.Equals, cfgOpenedState)
case <-time.After(coretesting.LongWait):
c.Errorf("timed out waiting for state to be closed")
}
}
func (suite *PluginSuite) SetUpTest(c *gc.C) {
suite.LoggingSuite.SetUpTest(c)
suite.oldPath = os.Getenv("PATH")
suite.home = testing.MakeSampleHome(c)
os.Setenv("PATH", "/bin:"+testing.HomePath())
}
func (s *MainSuite) TestRunMain(c *gc.C) {
defer testing.MakeSampleHome(c).Restore()
// The test array structure needs to be inline here as some of the
// expected values below use deployHelpText(). This constructs the deploy
// command and runs gets the help for it. When the deploy command is
// setting the flags (which is needed for the help text) it is accessing
// osenv.JujuHome(), which panics if SetJujuHome has not been called.
// The FakeHome from testing does this.
for i, t := range []struct {
summary string
args []string
code int
out string
}{{
summary: "no params shows help",
args: []string{},
code: 0,
out: strings.TrimLeft(helpBasics, "\n"),
}, {
summary: "juju help is the same as juju",
args: []string{"help"},
code: 0,
out: strings.TrimLeft(helpBasics, "\n"),
}, {
summary: "juju --help works too",
args: []string{"--help"},
code: 0,
out: strings.TrimLeft(helpBasics, "\n"),
}, {
summary: "juju help basics is the same as juju",
args: []string{"help", "basics"},
code: 0,
out: strings.TrimLeft(helpBasics, "\n"),
}, {
summary: "juju help foo doesn't exist",
args: []string{"help", "foo"},
code: 1,
out: "ERROR unknown command or topic for foo\n",
}, {
summary: "juju help deploy shows the default help without global options",
args: []string{"help", "deploy"},
code: 0,
out: deployHelpText(),
}, {
summary: "juju --help deploy shows the same help as 'help deploy'",
args: []string{"--help", "deploy"},
code: 0,
out: deployHelpText(),
}, {
summary: "juju deploy --help shows the same help as 'help deploy'",
args: []string{"deploy", "--help"},
code: 0,
out: deployHelpText(),
}, {
summary: "unknown command",
args: []string{"discombobulate"},
code: 1,
out: "ERROR unrecognized command: juju discombobulate\n",
}, {
summary: "unknown option before command",
args: []string{"--cheese", "bootstrap"},
code: 2,
out: "error: flag provided but not defined: --cheese\n",
}, {
summary: "unknown option after command",
args: []string{"bootstrap", "--cheese"},
code: 2,
out: "error: flag provided but not defined: --cheese\n",
}, {
summary: "known option, but specified before command",
args: []string{"--environment", "blah", "bootstrap"},
code: 2,
out: "error: flag provided but not defined: --environment\n",
}, {
summary: "juju sync-tools registered properly",
args: []string{"sync-tools", "--help"},
code: 0,
out: syncToolsHelpText(),
}, {
summary: "check version command registered properly",
args: []string{"version"},
code: 0,
out: version.Current.String() + "\n",
},
} {
c.Logf("test %d: %s", i, t.summary)
out := badrun(c, t.code, t.args...)
c.Assert(out, gc.Equals, t.out)
}
}