func (s *NewAPIClientSuite) TestWithInfoError(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
expectErr := fmt.Errorf("an error")
store := newConfigStoreWithError(expectErr)
client, err := juju.NewAPIFromStore("noconfig", store, panicAPIOpen)
c.Assert(err, gc.Equals, expectErr)
c.Assert(client, gc.IsNil)
}
func (s *NewAPIClientSuite) TestWithInfoNoAddresses(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("noconfig", &environInfo{
endpoint: configstore.APIEndpoint{
Addresses: []string{},
CACert: "certificated",
},
})
st, err := juju.NewAPIFromStore("noconfig", store, panicAPIOpen)
c.Assert(err, gc.ErrorMatches, `environment "noconfig" not found`)
c.Assert(st, gc.IsNil)
}
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 *NewAPIClientSuite) TestWithInfoOnly(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("noconfig", dummyStoreInfo)
called := 0
expectState := &mockAPIState{
apiHostPorts: [][]instance.HostPort{
instance.AddressesWithPort([]instance.Address{instance.NewAddress("0.1.2.3", instance.NetworkUnknown)}, 1234),
},
}
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, "user-foo")
c.Check(string(apiInfo.CACert), gc.Equals, "certificated")
c.Check(apiInfo.Password, gc.Equals, "foopass")
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
// Give NewAPIFromStore a store interface that can report when the
// config was written to, to check if the cache is updated.
mockStore := &storageWithWriteNotify{store: store}
st, err := juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 1)
c.Assert(mockStore.written, jc.IsTrue)
info, err := store.ReadInfo("noconfig")
c.Assert(err, gc.IsNil)
c.Assert(info.APIEndpoint().Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
mockStore.written = false
// If APIHostPorts haven't changed, then the store won't be updated.
st, err = juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, gc.IsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 2)
c.Assert(mockStore.written, jc.IsFalse)
}
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) TestWithInfoAPIOpenError(c *gc.C) {
defer coretesting.MakeEmptyFakeHome(c).Restore()
store := newConfigStore("noconfig", &environInfo{
endpoint: configstore.APIEndpoint{
Addresses: []string{"foo.invalid"},
},
})
expectErr := fmt.Errorf("an error")
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
return nil, expectErr
}
st, err := juju.NewAPIFromStore("noconfig", store, apiOpen)
c.Assert(err, gc.Equals, expectErr)
c.Assert(st, gc.IsNil)
}
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 (*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 (*NewAPIClientSuite) TestWithBootstrapConfigTakesPrecedence(c *gc.C) {
// We want to make sure that the code is using the bootstrap
// config rather than information from environments.yaml,
// even when there is an entry in environments.yaml
// We can do that by changing the info bootstrap config
// so it has a different environment name.
defer coretesting.MakeMultipleEnvHome(c).Restore()
store := configstore.NewMem()
bootstrapEnv(c, coretesting.SampleEnvName, store)
info, err := store.ReadInfo(coretesting.SampleEnvName)
c.Assert(err, gc.IsNil)
envName2 := coretesting.SampleCertName + "-2"
info2, err := store.CreateInfo(envName2)
c.Assert(err, gc.IsNil)
info2.SetBootstrapConfig(info.BootstrapConfig())
err = info2.Write()
c.Assert(err, gc.IsNil)
// Now we have info for envName2 which will actually
// cause a connection to the originally bootstrapped
// state.
apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
return &mockAPIState{}, nil
}
st, err := juju.NewAPIFromStore(envName2, store, apiOpen)
c.Check(err, gc.IsNil)
st.Close()
// Sanity check that connecting to the envName2
// but with no info fails.
// Currently this panics with an "environment not prepared" error.
// Disable for now until an upcoming branch fixes it.
// err = info2.Destroy()
// c.Assert(err, gc.IsNil)
// st, err = juju.NewAPIFromStore(envName2, store)
// if err == nil {
// st.Close()
// }
// c.Assert(err, gc.ErrorMatches, "fooobie")
}
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")
}
}