func (s *NewAPIClientSuite) TestWithInfoError(c *gc.C) {
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) TestNoEnvironTagDoesntOverwriteCached(c *gc.C) {
store := newConfigStore("noconfig", dummyStoreInfo)
called := 0
// State returns a new set of APIHostPorts but not a new EnvironTag. We
// shouldn't override the cached value with environ tag of "".
expectState := mockedAPIState(true, false)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag, gc.Equals, "environment-fake-uuid")
called++
return expectState, nil
}
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)
ep := info.APIEndpoint()
c.Assert(ep.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
c.Check(ep.EnvironUUID, gc.Equals, "fake-uuid")
}
func (s *NewAPIClientSuite) TestWithBootstrapConfigTakesPrecedence(c *gc.C) {
s.PatchValue(&version.Current, coretesting.FakeVersionNumber)
// 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.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleModelName, store)
info, err := store.ReadInfo(coretesting.SampleModelName)
c.Assert(err, jc.ErrorIsNil)
envName2 := coretesting.SampleCertName + "-2"
info2 := store.CreateInfo(envName2)
info2.SetBootstrapConfig(info.BootstrapConfig())
err = info2.Write()
c.Assert(err, jc.ErrorIsNil)
// Now we have info for envName2 which will actually
// cause a connection to the originally bootstrapped
// state.
apiOpen := func(*api.Info, api.DialOpts) (api.Connection, error) {
return mockedAPIState(noFlags), nil
}
st, err := juju.NewAPIFromStore(envName2, store, apiOpen)
c.Check(err, jc.ErrorIsNil)
st.Close()
}
func (s *NewAPIClientSuite) TestWithInfoNoEnvironTag(c *gc.C) {
store := newConfigStore("noconfig", noTagStoreInfo)
called := 0
expectState := mockedAPIState(true, true)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag, gc.Equals, "")
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"})
c.Check(info.APIEndpoint().EnvironUUID, gc.Equals, "fake-uuid")
}
func (s *NewAPIClientSuite) TestWithInfoNoAPIHostports(c *gc.C) {
// The local cache doesn't have an EnvironTag, which the API does
// return. However, the API doesn't have apiHostPorts, we don't want to
// override the local cache with bad endpoints.
store := newConfigStore("noconfig", noTagStoreInfo)
called := 0
expectState := mockedAPIState(mockedEnvironTag | mockedPreferIPv6)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag.Id(), gc.Equals, "")
called++
return expectState, nil
}
mockStore := &storageWithWriteNotify{store: store}
st, err := juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, jc.ErrorIsNil)
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, jc.ErrorIsNil)
ep := info.APIEndpoint()
// We should have cached the environ tag, but not disturbed the
// Addresses
c.Check(ep.Addresses, gc.HasLen, 1)
c.Check(ep.Addresses[0], gc.Matches, `foo\.invalid`)
c.Check(ep.EnvironUUID, gc.Equals, fakeUUID)
}
func newAPIConnectionFromNames(
c *gc.C,
controller, account, model string,
store jujuclient.ClientStore,
apiOpen api.OpenFunc,
getBootstrapConfig func(string) (*config.Config, error),
) (api.Connection, error) {
params := juju.NewAPIConnectionParams{
Store: store,
ControllerName: controller,
BootstrapConfig: getBootstrapConfig,
DialOpts: api.DefaultDialOpts(),
}
if account != "" {
accountDetails, err := store.AccountByName(controller, account)
c.Assert(err, jc.ErrorIsNil)
params.AccountDetails = accountDetails
}
if model != "" {
modelDetails, err := store.ModelByName(controller, account, model)
c.Assert(err, jc.ErrorIsNil)
params.ModelUUID = modelDetails.ModelUUID
}
return juju.NewAPIFromStore(params, apiOpen)
}
func (s *NewAPIClientSuite) TestWithInfoNoEnvironTag(c *gc.C) {
store := newConfigStore("noconfig", noTagStoreInfo)
called := 0
expectState := mockedAPIState(mockedHostPort | mockedEnvironTag)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag.Id(), gc.Equals, "")
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, jc.ErrorIsNil)
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, jc.ErrorIsNil)
c.Check(info.APIEndpoint().Addresses, jc.DeepEquals, []string{
"0.1.2.3:1234", "[2001:db8::1]:1234",
})
c.Check(info.APIEndpoint().EnvironUUID, gc.Equals, fakeUUID)
// Now simulate prefer-ipv6: true
store = newConfigStore("noconfig", noTagStoreInfo)
mockStore = &storageWithWriteNotify{store: store}
s.PatchValue(juju.MaybePreferIPv6, func(_ configstore.EnvironInfo) bool {
return true
})
expectState = mockedAPIState(mockedHostPort | mockedEnvironTag | mockedPreferIPv6)
st, err = juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 2)
c.Assert(mockStore.written, jc.IsTrue)
info, err = store.ReadInfo("noconfig")
c.Assert(err, jc.ErrorIsNil)
c.Check(info.APIEndpoint().Addresses, jc.DeepEquals, []string{
"[2001:db8::1]:1234", "0.1.2.3:1234",
})
c.Check(info.APIEndpoint().EnvironUUID, gc.Equals, fakeUUID)
}
func (s *NewAPIClientSuite) TestNoEnvironTagDoesntOverwriteCached(c *gc.C) {
store := newConfigStore("noconfig", dummyStoreInfo)
called := 0
// State returns a new set of APIHostPorts but not a new EnvironTag. We
// shouldn't override the cached value with environ tag of "".
expectState := mockedAPIState(mockedHostPort)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag, gc.Equals, names.NewEnvironTag(fakeUUID))
called++
return expectState, nil
}
mockStore := &storageWithWriteNotify{store: store}
st, err := juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, jc.ErrorIsNil)
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, jc.ErrorIsNil)
ep := info.APIEndpoint()
c.Check(ep.Addresses, gc.DeepEquals, []string{
"0.1.2.3:1234", "[2001:db8::1]:1234",
})
c.Check(ep.EnvironUUID, gc.Equals, fakeUUID)
// Now simulate prefer-ipv6: true
s.PatchValue(juju.MaybePreferIPv6, func(_ configstore.EnvironInfo) bool {
return true
})
expectState = mockedAPIState(mockedHostPort | mockedPreferIPv6)
st, err = juju.NewAPIFromStore("noconfig", mockStore, apiOpen)
c.Assert(err, jc.ErrorIsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 2)
c.Assert(mockStore.written, jc.IsTrue)
info, err = store.ReadInfo("noconfig")
c.Assert(err, jc.ErrorIsNil)
ep = info.APIEndpoint()
c.Check(ep.Addresses, gc.DeepEquals, []string{
"[2001:db8::1]:1234", "0.1.2.3:1234",
})
c.Check(ep.EnvironUUID, gc.Equals, fakeUUID)
}
func (s *NewAPIClientSuite) TestWithConfigAndNoInfo(c *gc.C) {
coretesting.MakeSampleJujuHome(c)
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 := mockedAPIState(0)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
c.Check(apiInfo.Tag, gc.Equals, names.NewUserTag("admin"))
c.Check(string(apiInfo.CACert), gc.Not(gc.Equals), "")
c.Check(apiInfo.Password, gc.Equals, "adminpass")
// EnvironTag wasn't in regular Config
c.Check(apiInfo.EnvironTag, gc.IsNil)
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, `localhost:\d+`)
c.Check(ep.CACert, gc.Not(gc.Equals), "")
// Old servers won't hand back EnvironTag, so it should stay empty in
// the cache
c.Check(ep.EnvironUUID, 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) {
store := newConfigStore("noconfig", dummyStoreInfo)
called := 0
expectState := &mockAPIState{
apiHostPorts: [][]network.HostPort{
network.AddressesWithPort(
[]network.Address{network.NewAddress("0.1.2.3", network.ScopeUnknown)},
1234,
),
},
environTag: "environment-fake-uuid",
}
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag, gc.Equals, "environment-fake-uuid")
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)
ep := info.APIEndpoint()
c.Assert(ep.Addresses, gc.DeepEquals, []string{"0.1.2.3:1234"})
c.Check(ep.EnvironUUID, gc.Equals, "fake-uuid")
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) TestWithInfoNoAddresses(c *gc.C) {
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) TestWithSlowInfoConnect(c *gc.C) {
s.PatchValue(&version.Current, coretesting.FakeVersionNumber)
coretesting.MakeSampleJujuHome(c)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleModelName, store)
setEndpointAddressAndHostname(c, store, coretesting.SampleModelName, "0.1.2.3", "infoapi.invalid")
infoOpenedState := mockedAPIState(noFlags)
infoEndpointOpened := make(chan struct{})
cfgOpenedState := mockedAPIState(noFlags)
// 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) (api.Connection, error) {
if info.Addrs[0] == "0.1.2.3" {
infoEndpointOpened <- struct{}{}
return infoOpenedState, nil
}
return cfgOpenedState, nil
}
stateClosed := make(chan api.Connection)
infoOpenedState.close = func(st api.Connection) error {
stateClosed <- st
return nil
}
cfgOpenedState.close = infoOpenedState.close
startTime := time.Now()
st, err := juju.NewAPIFromStore(coretesting.SampleModelName, store, apiOpen)
c.Assert(err, jc.ErrorIsNil)
// 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) TestWithConfigAndNoInfo(c *gc.C) {
c.Skip("not really possible now that there is no defined admin user")
s.PatchValue(&version.Current, coretesting.FakeVersionNumber)
coretesting.MakeSampleJujuHome(c)
store := newConfigStore(coretesting.SampleModelName, &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",
},
})
s.bootstrapEnv(c, coretesting.SampleModelName, store)
info, err := store.ReadInfo("myenv")
c.Assert(err, jc.ErrorIsNil)
c.Assert(info, gc.NotNil)
c.Logf("%#v", info.APICredentials())
called := 0
expectState := mockedAPIState(0)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (api.Connection, error) {
c.Check(apiInfo.Tag, gc.Equals, dummy.AdminUserTag())
c.Check(string(apiInfo.CACert), gc.Not(gc.Equals), "")
c.Check(apiInfo.Password, gc.Equals, "adminpass")
// ModelTag wasn't in regular Config
c.Check(apiInfo.ModelTag.Id(), gc.Equals, "")
c.Check(opts, gc.DeepEquals, api.DefaultDialOpts())
called++
return expectState, nil
}
st, err := juju.NewAPIFromStore("myenv", store, apiOpen)
c.Assert(err, jc.ErrorIsNil)
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, jc.ErrorIsNil)
c.Assert(info, gc.NotNil)
ep := info.APIEndpoint()
c.Assert(ep.Addresses, gc.HasLen, 1)
c.Check(ep.Addresses[0], gc.Matches, `localhost:\d+`)
c.Check(ep.CACert, gc.Not(gc.Equals), "")
}
func (s *NewAPIClientSuite) TestWithInfoAPIOpenError(c *gc.C) {
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) TestWithInfoOnly(c *gc.C) {
store := newConfigStore("noconfig", dummyStoreInfo)
called := 0
expectState := mockedAPIState(mockedHostPort | mockedEnvironTag)
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
checkCommonAPIInfoAttrs(c, apiInfo, opts)
c.Check(apiInfo.EnvironTag, gc.Equals, names.NewEnvironTag(fakeUUID))
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, jc.ErrorIsNil)
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, jc.ErrorIsNil)
ep := info.APIEndpoint()
c.Check(ep.Addresses, jc.DeepEquals, []string{
"0.1.2.3:1234", "[2001:db8::1]:1234",
})
c.Check(ep.EnvironUUID, gc.Equals, fakeUUID)
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, jc.ErrorIsNil)
c.Assert(st, gc.Equals, expectState)
c.Assert(called, gc.Equals, 2)
c.Assert(mockStore.written, jc.IsFalse)
}
func (s *NewAPIClientSuite) TestWithInfoAPIOpenError(c *gc.C) {
store := newConfigStore("noconfig", &environInfo{
endpoint: configstore.APIEndpoint{
Addresses: []string{"foo.invalid"},
},
})
apiOpen := func(apiInfo *api.Info, opts api.DialOpts) (juju.APIState, error) {
return nil, errors.Errorf("an error")
}
st, err := juju.NewAPIFromStore("noconfig", store, apiOpen)
// We expect to get the isNotFound error as it is more important than the
// infoConnectError "an error"
c.Assert(err, gc.ErrorMatches, "environment \"noconfig\" not found")
c.Assert(st, gc.IsNil)
}
func (s *NewAPIClientSuite) TestBothError(c *gc.C) {
coretesting.MakeSampleJujuHome(c)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleEnvName, store)
setEndpointAddressAndHostname(c, store, coretesting.SampleEnvName, "0.1.2.3", "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 *NewAPIClientSuite) TestWithBootstrapConfigAndNoEnvironmentsFile(c *gc.C) {
coretesting.MakeSampleJujuHome(c)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleEnvName, store)
info, err := store.ReadInfo(coretesting.SampleEnvName)
c.Assert(err, jc.ErrorIsNil)
c.Assert(info.BootstrapConfig(), gc.NotNil)
c.Assert(info.APIEndpoint().Addresses, gc.HasLen, 0)
err = os.Remove(osenv.JujuHomePath("environments.yaml"))
c.Assert(err, jc.ErrorIsNil)
apiOpen := func(*api.Info, api.DialOpts) (juju.APIState, error) {
return mockedAPIState(noFlags), nil
}
st, err := juju.NewAPIFromStore(coretesting.SampleEnvName, store, apiOpen)
c.Check(err, jc.ErrorIsNil)
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.
coretesting.WriteEnvironments(c, coretesting.MultipleEnvConfig)
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 mockedAPIState(noFlags), 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) {
coretesting.MakeSampleJujuHome(c)
store := configstore.NewMem()
s.bootstrapEnv(c, coretesting.SampleEnvName, store)
setEndpointAddressAndHostname(c, store, coretesting.SampleEnvName, "0.1.2.3", "infoapi.invalid")
infoOpenedState := mockedAPIState(noFlags)
infoEndpointOpened := make(chan struct{})
cfgOpenedState := mockedAPIState(noFlags)
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] == "0.1.2.3" {
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, jc.ErrorIsNil)
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")
}
}