func (s *DestroySuite) TestIgnoreNoVolumeSupport(c *gc.C) {
staticProvider := &dummy.StorageProvider{
IsDynamic: true,
StorageScope: storage.ScopeEnviron,
SupportsFunc: func(storage.StorageKind) bool {
return false
},
}
registry.RegisterProvider("filesystem", staticProvider)
defer registry.RegisterProvider("filesystem", nil)
registry.RegisterEnvironStorageProviders("anything, really", "filesystem")
defer registry.ResetEnvironStorageProviders("anything, really")
env := &mockEnviron{
config: configGetter(c),
allInstances: func() ([]instance.Instance, error) {
return nil, environs.ErrNoInstances
},
}
err := common.Destroy(env)
c.Assert(err, jc.ErrorIsNil)
// common.Destroy will ignore storage providers that don't support
// volumes (until we have persistent filesystems, that is).
staticProvider.CheckCallNames(c, "Dynamic", "Scope", "Supports")
}
func (s *DestroySuite) TestDestroyVolumeErrors(c *gc.C) {
volumeSource := &dummy.VolumeSource{
ListVolumesFunc: func() ([]string, error) {
return []string{"vol-0", "vol-1", "vol-2"}, nil
},
DestroyVolumesFunc: func(ids []string) []error {
return []error{
nil,
errors.New("cannot destroy vol-1"),
errors.New("cannot destroy vol-2"),
}
},
}
staticProvider := &dummy.StorageProvider{
IsDynamic: true,
StorageScope: storage.ScopeEnviron,
VolumeSourceFunc: func(*config.Config, *storage.Config) (storage.VolumeSource, error) {
return volumeSource, nil
},
}
registry.RegisterProvider("environ", staticProvider)
defer registry.RegisterProvider("environ", nil)
registry.RegisterEnvironStorageProviders("anything, really", "environ")
defer registry.ResetEnvironStorageProviders("anything, really")
env := &mockEnviron{
config: configGetter(c),
allInstances: func() ([]instance.Instance, error) {
return nil, environs.ErrNoInstances
},
}
err := common.Destroy(env)
c.Assert(err, gc.ErrorMatches, "destroying storage: destroying volumes: cannot destroy vol-1, cannot destroy vol-2")
}
func (s *DestroySuite) TestIgnoreMachineScopedVolumes(c *gc.C) {
staticProvider := &dummy.StorageProvider{
IsDynamic: true,
StorageScope: storage.ScopeMachine,
}
registry.RegisterProvider("machine", staticProvider)
defer registry.RegisterProvider("machine", nil)
registry.RegisterEnvironStorageProviders("anything, really", "machine")
defer registry.ResetEnvironStorageProviders("anything, really")
env := &mockEnviron{
config: configGetter(c),
allInstances: func() ([]instance.Instance, error) {
return nil, environs.ErrNoInstances
},
}
err := common.Destroy(env)
c.Assert(err, jc.ErrorIsNil)
// common.Destroy will ignore machine-scoped storage providers.
staticProvider.CheckCallNames(c, "Dynamic", "Scope")
}
func (s *DestroySuite) TestDestroyEnvScopedVolumes(c *gc.C) {
volumeSource := &dummy.VolumeSource{
ListVolumesFunc: func() ([]string, error) {
return []string{"vol-0", "vol-1", "vol-2"}, nil
},
DestroyVolumesFunc: func(ids []string) []error {
return make([]error, len(ids))
},
}
staticProvider := &dummy.StorageProvider{
IsDynamic: true,
StorageScope: storage.ScopeEnviron,
VolumeSourceFunc: func(*config.Config, *storage.Config) (storage.VolumeSource, error) {
return volumeSource, nil
},
}
registry.RegisterProvider("environ", staticProvider)
defer registry.RegisterProvider("environ", nil)
registry.RegisterEnvironStorageProviders("anything, really", "environ")
defer registry.ResetEnvironStorageProviders("anything, really")
env := &mockEnviron{
config: configGetter(c),
allInstances: func() ([]instance.Instance, error) {
return nil, environs.ErrNoInstances
},
}
err := common.Destroy(env)
c.Assert(err, jc.ErrorIsNil)
// common.Destroy will ignore machine-scoped storage providers.
staticProvider.CheckCallNames(c, "Dynamic", "Scope", "Supports", "VolumeSource")
volumeSource.CheckCalls(c, []gitjujutesting.StubCall{
{"ListVolumes", nil},
{"DestroyVolumes", []interface{}{[]string{"vol-0", "vol-1", "vol-2"}}},
})
}