func (s *SpacesSuite) checkCreateSpaces(c *gc.C, p checkCreateSpacesParams) {
args := params.CreateSpaceParams{}
if p.Name != "" {
args.SpaceTag = "space-" + p.Name
}
if len(p.Subnets) > 0 {
for _, cidr := range p.Subnets {
args.SubnetTags = append(args.SubnetTags, "subnet-"+cidr)
}
}
args.Public = p.Public
args.ProviderId = p.ProviderId
spaces := params.CreateSpacesParams{}
spaces.Spaces = append(spaces.Spaces, args)
results, err := networkingcommon.CreateSpaces(apiservertesting.BackingInstance, spaces)
c.Assert(len(results.Results), gc.Equals, 1)
c.Assert(err, gc.IsNil)
if p.Error == "" {
c.Assert(results.Results[0].Error, gc.IsNil)
} else {
c.Assert(results.Results[0].Error, gc.NotNil)
c.Assert(results.Results[0].Error, gc.ErrorMatches, p.Error)
}
baseCalls := []apiservertesting.StubMethodCall{
apiservertesting.BackingCall("ModelConfig"),
apiservertesting.BackingCall("CloudSpec"),
apiservertesting.ProviderCall("Open", apiservertesting.BackingInstance.EnvConfig),
apiservertesting.ZonedNetworkingEnvironCall("SupportsSpaces"),
}
addSpaceCalls := append(baseCalls, apiservertesting.BackingCall("AddSpace", p.Name, network.Id(p.ProviderId), p.Subnets, p.Public))
if p.Error == "" {
apiservertesting.CheckMethodCalls(c, apiservertesting.SharedStub, addSpaceCalls...)
} else {
apiservertesting.CheckMethodCalls(c, apiservertesting.SharedStub, baseCalls...)
}
}
func (s *SubnetsSuite) CheckAddSubnetsFails(
c *gc.C, envName string,
withZones, withSpaces, withSubnets apiservertesting.SetUpFlag,
expectedError string,
) {
apiservertesting.BackingInstance.SetUp(c, envName, withZones, withSpaces, withSubnets)
// These calls always happen.
expectedCalls := []apiservertesting.StubMethodCall{
apiservertesting.BackingCall("EnvironConfig"),
apiservertesting.ProviderCall("Open", apiservertesting.BackingInstance.EnvConfig),
}
// Subnets is also always called. but the receiver is different.
switch envName {
case apiservertesting.StubNetworkingEnvironName:
expectedCalls = append(
expectedCalls,
apiservertesting.NetworkingEnvironCall("Subnets", instance.UnknownId, []network.Id(nil)),
)
case apiservertesting.StubZonedNetworkingEnvironName:
expectedCalls = append(
expectedCalls,
apiservertesting.ZonedNetworkingEnvironCall("Subnets", instance.UnknownId, []network.Id(nil)),
)
}
if !withSubnets {
// Set provider subnets to empty for this test.
originalSubnets := make([]network.SubnetInfo, len(apiservertesting.ProviderInstance.Subnets))
copy(originalSubnets, apiservertesting.ProviderInstance.Subnets)
apiservertesting.ProviderInstance.Subnets = []network.SubnetInfo{}
defer func() {
apiservertesting.ProviderInstance.Subnets = make([]network.SubnetInfo, len(originalSubnets))
copy(apiservertesting.ProviderInstance.Subnets, originalSubnets)
}()
if envName == apiservertesting.StubEnvironName || envName == apiservertesting.StubNetworkingEnvironName {
// networking is either not supported or no subnets are
// defined, so expected the same calls for each of the two
// arguments to AddSubnets() below.
expectedCalls = append(expectedCalls, expectedCalls...)
}
} else {
// Having subnets implies spaces will be cached as well.
expectedCalls = append(expectedCalls, apiservertesting.BackingCall("AllSpaces"))
}
if withSpaces && withSubnets {
// Having both subnets and spaces means we'll also cache zones.
expectedCalls = append(expectedCalls, apiservertesting.BackingCall("AvailabilityZones"))
}
if !withZones && withSpaces {
// Set provider zones to empty for this test.
originalZones := make([]providercommon.AvailabilityZone, len(apiservertesting.ProviderInstance.Zones))
copy(originalZones, apiservertesting.ProviderInstance.Zones)
apiservertesting.ProviderInstance.Zones = []providercommon.AvailabilityZone{}
defer func() {
apiservertesting.ProviderInstance.Zones = make([]providercommon.AvailabilityZone, len(originalZones))
copy(apiservertesting.ProviderInstance.Zones, originalZones)
}()
// updateZones tries to constructs a ZonedEnviron with these calls.
zoneCalls := append([]apiservertesting.StubMethodCall{},
apiservertesting.BackingCall("EnvironConfig"),
apiservertesting.ProviderCall("Open", apiservertesting.BackingInstance.EnvConfig),
)
// Receiver can differ according to envName, but
// AvailabilityZones() will be called on either receiver.
switch envName {
case apiservertesting.StubZonedEnvironName:
zoneCalls = append(
zoneCalls,
apiservertesting.ZonedEnvironCall("AvailabilityZones"),
)
case apiservertesting.StubZonedNetworkingEnvironName:
zoneCalls = append(
zoneCalls,
apiservertesting.ZonedNetworkingEnvironCall("AvailabilityZones"),
)
}
// Finally after caching provider zones backing zones are
// updated.
zoneCalls = append(
zoneCalls,
apiservertesting.BackingCall("SetAvailabilityZones", apiservertesting.ProviderInstance.Zones),
)
// Now, because we have 2 arguments to AddSubnets() below, we
// need to expect the same zoneCalls twice, with a
// AvailabilityZones backing lookup between them.
expectedCalls = append(expectedCalls, zoneCalls...)
expectedCalls = append(expectedCalls, apiservertesting.BackingCall("AvailabilityZones"))
expectedCalls = append(expectedCalls, zoneCalls...)
}
// Pass 2 arguments covering all cases we need.
args := params.AddSubnetsParams{
Subnets: []params.AddSubnetParams{{
SubnetTag: "subnet-10.42.0.0/16",
SpaceTag: "space-dmz",
Zones: []string{"zone1"},
}, {
SubnetProviderId: "vlan-42",
SpaceTag: "space-private",
Zones: []string{"zone3"},
}},
}
results, err := s.facade.AddSubnets(args)
c.Assert(err, jc.ErrorIsNil)
c.Assert(results.Results, gc.HasLen, len(args.Subnets))
for _, result := range results.Results {
if !c.Check(result.Error, gc.NotNil) {
continue
}
c.Check(result.Error, gc.ErrorMatches, expectedError)
c.Check(result.Error.Code, gc.Equals, "")
}
apiservertesting.CheckMethodCalls(c, apiservertesting.SharedStub, expectedCalls...)
}