func (s *ConstraintsSuite) TestMerge(c *gc.C) {
con1 := constraints.MustParse("arch=amd64 mem=4G")
con2 := constraints.MustParse("cpu-cores=42")
con3 := constraints.MustParse(
"root-disk=8G container=lxc spaces=space1,^space2 networks=net1,^net2",
)
merged, err := constraints.Merge(con1, con2)
c.Assert(err, jc.ErrorIsNil)
c.Assert(merged, jc.DeepEquals, constraints.MustParse("arch=amd64 mem=4G cpu-cores=42"))
merged, err = constraints.Merge(con1)
c.Assert(err, jc.ErrorIsNil)
c.Assert(merged, jc.DeepEquals, con1)
merged, err = constraints.Merge(con1, con2, con3)
c.Assert(err, jc.ErrorIsNil)
c.Assert(merged, jc.DeepEquals, constraints.
MustParse("arch=amd64 mem=4G cpu-cores=42 root-disk=8G container=lxc spaces=space1,^space2 networks=net1,^net2"),
)
merged, err = constraints.Merge()
c.Assert(err, jc.ErrorIsNil)
c.Assert(merged, jc.DeepEquals, constraints.Value{})
foo := "foo"
merged, err = constraints.Merge(constraints.Value{Arch: &foo}, con2)
c.Assert(err, gc.NotNil)
c.Assert(err, gc.ErrorMatches, `bad "arch" constraint: "foo" not recognized`)
c.Assert(merged, jc.DeepEquals, constraints.Value{})
merged, err = constraints.Merge(con1, con1)
c.Assert(err, gc.NotNil)
c.Assert(err, gc.ErrorMatches, `bad "arch" constraint: already set`)
c.Assert(merged, jc.DeepEquals, constraints.Value{})
}
func (s *BundleDeployCharmStoreSuite) TestDeployBundleApplicationConstrants(c *gc.C) {
testcharms.UploadCharm(c, s.client, "xenial/wordpress-42", "wordpress")
testcharms.UploadCharm(c, s.client, "precise/dummy-0", "dummy")
_, err := s.DeployBundleYAML(c, `
applications:
wordpress:
charm: wordpress
constraints: mem=4G cores=2
customized:
charm: precise/dummy-0
num_units: 1
constraints: arch=i386
`)
c.Assert(err, jc.ErrorIsNil)
s.assertCharmsUploaded(c, "cs:precise/dummy-0", "cs:xenial/wordpress-42")
s.assertApplicationsDeployed(c, map[string]serviceInfo{
"customized": {
charm: "cs:precise/dummy-0",
constraints: constraints.MustParse("arch=i386"),
},
"wordpress": {
charm: "cs:xenial/wordpress-42",
constraints: constraints.MustParse("mem=4G cores=2"),
},
})
s.assertUnitsCreated(c, map[string]string{
"customized/0": "0",
})
}
func (s *clientSuite) TestEnableHAPlacement(c *gc.C) {
placement := []string{"valid"}
enableHAResult, err := s.enableHA(c, 3, constraints.MustParse("mem=4G"), defaultSeries, placement)
c.Assert(err, jc.ErrorIsNil)
c.Assert(enableHAResult.Maintained, gc.DeepEquals, []string{"machine-0"})
c.Assert(enableHAResult.Added, gc.DeepEquals, []string{"machine-1", "machine-2"})
c.Assert(enableHAResult.Removed, gc.HasLen, 0)
c.Assert(enableHAResult.Converted, gc.HasLen, 0)
machines, err := s.State.AllMachines()
c.Assert(err, jc.ErrorIsNil)
c.Assert(machines, gc.HasLen, 3)
expectedCons := []constraints.Value{
{},
constraints.MustParse("mem=4G"),
constraints.MustParse("mem=4G"),
}
expectedPlacement := []string{"", "valid", ""}
for i, m := range machines {
cons, err := m.Constraints()
c.Assert(err, jc.ErrorIsNil)
c.Check(cons, gc.DeepEquals, expectedCons[i])
c.Check(m.Placement(), gc.Equals, expectedPlacement[i])
}
}
func (s *DeployLocalSuite) TestDeployWithFewerPlacement(c *gc.C) {
err := s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, jc.ErrorIsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 3,
Placement: []*instance.Placement{
{Scope: s.State.EnvironUUID(), Directive: "valid"},
},
})
c.Assert(err, jc.ErrorIsNil)
s.assertConstraints(c, service, serviceCons)
units, err := service.AllUnits()
c.Assert(err, jc.ErrorIsNil)
c.Assert(units, gc.HasLen, 3)
// Check each of the newly added units.
s.assertAssignedUnit(c, units[0], "0", constraints.MustParse("mem=2G cpu-cores=2"))
s.assertAssignedUnit(c, units[1], "1", constraints.MustParse("mem=2G cpu-cores=2"))
s.assertAssignedUnit(c, units[2], "2", constraints.MustParse("mem=2G cpu-cores=2"))
}
func (s *AssignSuite) TestAssignUnitToNewMachineSetsConstraints(c *gc.C) {
// Set up constraints.
scons := constraints.MustParse("mem=2G cpu-power=400")
err := s.wordpress.SetConstraints(scons)
c.Assert(err, jc.ErrorIsNil)
econs := constraints.MustParse("mem=4G cpu-cores=2")
err = s.State.SetModelConstraints(econs)
c.Assert(err, jc.ErrorIsNil)
// Unit will take combined service/environ constraints on creation.
unit, err := s.wordpress.AddUnit()
c.Assert(err, jc.ErrorIsNil)
// Change service/env constraints before assigning, to verify this.
scons = constraints.MustParse("mem=6G cpu-power=800")
err = s.wordpress.SetConstraints(scons)
c.Assert(err, jc.ErrorIsNil)
econs = constraints.MustParse("cpu-cores=4")
err = s.State.SetModelConstraints(econs)
c.Assert(err, jc.ErrorIsNil)
// The new machine takes the original combined unit constraints.
err = unit.AssignToNewMachine()
c.Assert(err, jc.ErrorIsNil)
err = unit.Refresh()
c.Assert(err, jc.ErrorIsNil)
mid, err := unit.AssignedMachineId()
c.Assert(err, jc.ErrorIsNil)
machine, err := s.State.Machine(mid)
c.Assert(err, jc.ErrorIsNil)
mcons, err := machine.Constraints()
c.Assert(err, jc.ErrorIsNil)
expect := constraints.MustParse("mem=2G cpu-cores=2 cpu-power=400")
c.Assert(mcons, gc.DeepEquals, expect)
}
func (s *constraintsValidationSuite) TestServiceConstraints(c *gc.C) {
charm := s.AddTestingCharm(c, "wordpress")
service := s.AddTestingService(c, "wordpress", charm)
for i, t := range setConstraintsTests {
c.Logf(
"test %d: %s\nconsToSet: %q\nconsFallback: %q\n",
i, t.about, t.consToSet, t.consFallback,
)
// Set fallbacks as model constraints and verify them.
err := s.State.SetModelConstraints(constraints.MustParse(t.consFallback))
c.Check(err, jc.ErrorIsNil)
econs, err := s.State.ModelConstraints()
c.Check(econs, jc.DeepEquals, constraints.MustParse(t.effectiveModelCons))
// Set the service deployment constraints.
err = service.SetConstraints(constraints.MustParse(t.consToSet))
c.Check(err, jc.ErrorIsNil)
u, err := service.AddUnit()
c.Check(err, jc.ErrorIsNil)
// New unit deployment constraints get merged with the fallbacks.
ucons, err := u.Constraints()
c.Check(err, jc.ErrorIsNil)
c.Check(*ucons, jc.DeepEquals, constraints.MustParse(t.effectiveUnitCons))
// Service constraints remain as set.
scons, err := service.Constraints()
c.Check(err, jc.ErrorIsNil)
c.Check(scons, jc.DeepEquals, constraints.MustParse(t.effectiveServiceCons))
}
}
func (s *serviceSuite) TestSetServiceDeploy(c *gc.C) {
var called bool
service.PatchFacadeCall(s, s.client, func(request string, a, response interface{}) error {
called = true
c.Assert(request, gc.Equals, "ServicesDeploy")
args, ok := a.(params.ServicesDeploy)
c.Assert(ok, jc.IsTrue)
c.Assert(args.Services, gc.HasLen, 1)
c.Assert(args.Services[0].CharmUrl, gc.Equals, "charmURL")
c.Assert(args.Services[0].ServiceName, gc.Equals, "serviceA")
c.Assert(args.Services[0].Series, gc.Equals, "series")
c.Assert(args.Services[0].NumUnits, gc.Equals, 2)
c.Assert(args.Services[0].ConfigYAML, gc.Equals, "configYAML")
c.Assert(args.Services[0].Constraints, gc.DeepEquals, constraints.MustParse("mem=4G"))
c.Assert(args.Services[0].ToMachineSpec, gc.Equals, "machineSpec")
c.Assert(args.Services[0].Networks, gc.DeepEquals, []string{"neta"})
c.Assert(args.Services[0].Storage, gc.DeepEquals, map[string]storage.Constraints{"data": storage.Constraints{Pool: "pool"}})
result := response.(*params.ErrorResults)
result.Results = make([]params.ErrorResult, 1)
return nil
})
err := s.client.ServiceDeploy("charmURL", "serviceA", "series", 2, "configYAML", constraints.MustParse("mem=4G"),
"machineSpec", nil, []string{"neta"}, map[string]storage.Constraints{"data": storage.Constraints{Pool: "pool"}})
c.Assert(err, jc.ErrorIsNil)
c.Assert(called, jc.IsTrue)
}
func (s *DeployLocalSuite) TestDeployForceMachineIdWithContainer(c *gc.C) {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, gc.IsNil)
c.Assert(machine.Id(), gc.Equals, "0")
envCons := constraints.MustParse("mem=2G")
err = s.State.SetEnvironConstraints(envCons)
c.Assert(err, gc.IsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 1,
ToMachineSpec: fmt.Sprintf("%s:0", instance.LXC),
})
c.Assert(err, gc.IsNil)
s.assertConstraints(c, service, serviceCons)
units, err := service.AllUnits()
c.Assert(err, gc.IsNil)
c.Assert(units, gc.HasLen, 1)
// The newly created container will use the constraints.
id, err := units[0].AssignedMachineId()
c.Assert(err, gc.IsNil)
machine, err = s.State.Machine(id)
c.Assert(err, gc.IsNil)
machineCons, err := machine.Constraints()
c.Assert(err, gc.IsNil)
unitCons, err := units[0].Constraints()
c.Assert(err, gc.IsNil)
c.Assert(machineCons, gc.DeepEquals, *unitCons)
}
func (s *DeployLocalSuite) TestDeployWithPlacement(c *gc.C) {
machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
c.Assert(err, jc.ErrorIsNil)
c.Assert(machine.Id(), gc.Equals, "0")
err = s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, jc.ErrorIsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 3,
Placement: []*instance.Placement{
{Scope: s.State.EnvironUUID(), Directive: "valid"},
{Scope: "#", Directive: "0"},
{Scope: "lxc", Directive: "1"},
},
ToMachineSpec: "will be ignored",
})
c.Assert(err, jc.ErrorIsNil)
s.assertConstraints(c, service, serviceCons)
units, err := service.AllUnits()
c.Assert(err, jc.ErrorIsNil)
c.Assert(units, gc.HasLen, 3)
// Check each of the newly added units.
s.assertAssignedUnit(c, units[0], "1", constraints.MustParse("mem=2G cpu-cores=2"))
s.assertAssignedUnit(c, units[1], "0", constraints.Value{})
s.assertAssignedUnit(c, units[2], "1/lxc/0", constraints.MustParse("mem=2G cpu-cores=2"))
}
func (s *ConstraintsSuite) TestWithout(c *gc.C) {
for i, t := range withoutTests {
c.Logf("test %d", i)
initial := constraints.MustParse(t.initial)
final := constraints.Without(initial, t.without...)
c.Check(final, jc.DeepEquals, constraints.MustParse(t.final))
}
}
func (s *environSuite) TestConstraintsValidatorMerge(c *gc.C) {
validator := s.constraintsValidator(c)
cons, err := validator.Merge(
constraints.MustParse("mem=3G arch=amd64"),
constraints.MustParse("instance-type=D1"),
)
c.Assert(err, jc.ErrorIsNil)
c.Assert(cons.String(), gc.Equals, "instance-type=D1")
}
func (s *localServerSuite) TestConstraintsMerge(c *gc.C) {
env := s.Open(c)
validator, err := env.ConstraintsValidator()
c.Assert(err, gc.IsNil)
consA := constraints.MustParse("arch=amd64 mem=1G root-disk=10G")
consB := constraints.MustParse("instance-type=m1.small")
cons, err := validator.Merge(consA, consB)
c.Assert(err, gc.IsNil)
c.Assert(cons, gc.DeepEquals, constraints.MustParse("instance-type=m1.small"))
}
func (t *localServerSuite) TestConstraintsMerge(c *gc.C) {
env := t.Prepare(c)
validator, err := env.ConstraintsValidator()
c.Assert(err, jc.ErrorIsNil)
consA := constraints.MustParse("arch=amd64 mem=1G cpu-power=10 cpu-cores=2 tags=bar")
consB := constraints.MustParse("arch=i386 instance-type=m1.small")
cons, err := validator.Merge(consA, consB)
c.Assert(err, jc.ErrorIsNil)
c.Assert(cons, gc.DeepEquals, constraints.MustParse("arch=i386 instance-type=m1.small tags=bar"))
}
func (s *validationSuite) TestMergeError(c *gc.C) {
validator := constraints.NewValidator()
validator.RegisterConflicts([]string{"instance-type"}, []string{"mem"})
consFallback := constraints.MustParse("instance-type=foo mem=4G")
cons := constraints.MustParse("cores=2")
_, err := validator.Merge(consFallback, cons)
c.Assert(err, gc.ErrorMatches, `ambiguous constraints: "instance-type" overlaps with "mem"`)
_, err = validator.Merge(cons, consFallback)
c.Assert(err, gc.ErrorMatches, `ambiguous constraints: "instance-type" overlaps with "mem"`)
}
func (s *environSuite) TestConstraintsValidatorVocabulary(c *gc.C) {
validator := s.constraintsValidator(c)
_, err := validator.Validate(constraints.MustParse("arch=armhf"))
c.Assert(err, gc.ErrorMatches,
"invalid constraint value: arch=armhf\nvalid values are: \\[amd64\\]",
)
_, err = validator.Validate(constraints.MustParse("instance-type=t1.micro"))
c.Assert(err, gc.ErrorMatches,
"invalid constraint value: instance-type=t1.micro\nvalid values are: \\[D1 Standard_D1\\]",
)
}
func (s *localServerSuite) TestConstraintsValidatorVocab(c *gc.C) {
env := s.Open(c)
validator, err := env.ConstraintsValidator()
c.Assert(err, gc.IsNil)
cons := constraints.MustParse("arch=arm64")
_, err = validator.Validate(cons)
c.Assert(err, gc.ErrorMatches, "invalid constraint value: arch=arm64\nvalid values are:.*")
cons = constraints.MustParse("instance-type=foo")
_, err = validator.Validate(cons)
c.Assert(err, gc.ErrorMatches, "invalid constraint value: instance-type=foo\nvalid values are:.*")
}
func (t *localServerSuite) TestConstraintsValidatorVocab(c *gc.C) {
env := t.Prepare(c)
validator, err := env.ConstraintsValidator()
c.Assert(err, jc.ErrorIsNil)
cons := constraints.MustParse("arch=ppc64el")
_, err = validator.Validate(cons)
c.Assert(err, gc.ErrorMatches, "invalid constraint value: arch=ppc64el\nvalid values are:.*")
cons = constraints.MustParse("instance-type=foo")
_, err = validator.Validate(cons)
c.Assert(err, gc.ErrorMatches, "invalid constraint value: instance-type=foo\nvalid values are:.*")
}
func (s *MigrationImportSuite) TestLinkLayerDeviceMigratesReferences(c *gc.C) {
machine := s.Factory.MakeMachine(c, &factory.MachineParams{
Constraints: constraints.MustParse("arch=amd64 mem=8G"),
})
machine2 := s.Factory.MakeMachineNested(c, machine.Id(), &factory.MachineParams{
Constraints: constraints.MustParse("arch=amd64 mem=8G"),
})
deviceArgs := []state.LinkLayerDeviceArgs{{
Name: "foo",
Type: state.BridgeDevice,
}, {
Name: "bar",
ParentName: "foo",
Type: state.EthernetDevice,
}}
for _, args := range deviceArgs {
err := machine.SetLinkLayerDevices(args)
c.Assert(err, jc.ErrorIsNil)
}
machine2DeviceArgs := state.LinkLayerDeviceArgs{
Name: "baz",
ParentName: fmt.Sprintf("m#%v#d#foo", machine.Id()),
Type: state.EthernetDevice,
}
err := machine2.SetLinkLayerDevices(machine2DeviceArgs)
c.Assert(err, jc.ErrorIsNil)
_, newSt := s.importModel(c)
devices, err := newSt.AllLinkLayerDevices()
c.Assert(err, jc.ErrorIsNil)
c.Assert(devices, gc.HasLen, 3)
var parent *state.LinkLayerDevice
others := []*state.LinkLayerDevice{}
for _, device := range devices {
if device.Name() == "foo" {
parent = device
} else {
others = append(others, device)
}
}
// Assert we found the parent.
c.Assert(others, gc.HasLen, 2)
err = parent.Remove()
c.Assert(err, gc.ErrorMatches, `.*parent device "foo" has 2 children.*`)
err = others[0].Remove()
c.Assert(err, jc.ErrorIsNil)
err = parent.Remove()
c.Assert(err, gc.ErrorMatches, `.*parent device "foo" has 1 children.*`)
err = others[1].Remove()
c.Assert(err, jc.ErrorIsNil)
err = parent.Remove()
c.Assert(err, jc.ErrorIsNil)
}
func (s *ConstraintsSuite) TestIncludeExcludeAndHaveNetworks(c *gc.C) {
con := constraints.MustParse("networks=net1,^net2,net3,^net4")
c.Assert(con.Networks, gc.Not(gc.IsNil))
c.Check(*con.Networks, gc.HasLen, 4)
c.Check(con.IncludeNetworks(), jc.SameContents, []string{"net1", "net3"})
c.Check(con.ExcludeNetworks(), jc.SameContents, []string{"net2", "net4"})
c.Check(con.HaveNetworks(), jc.IsTrue)
con = constraints.MustParse("mem=4G")
c.Check(con.HaveNetworks(), jc.IsFalse)
con = constraints.MustParse("mem=4G networks=^net1,^net2")
c.Check(con.HaveNetworks(), jc.IsTrue)
}
func (s *constraintsValidationSuite) TestMachineConstraints(c *gc.C) {
for i, t := range setConstraintsTests {
c.Logf("test %d: fallback: %q, cons: %q", i, t.consFallback, t.cons)
err := s.State.SetEnvironConstraints(constraints.MustParse(t.consFallback))
c.Check(err, gc.IsNil)
m, err := s.addOneMachine(c, constraints.MustParse(t.cons))
c.Check(err, gc.IsNil)
cons, err := m.Constraints()
c.Check(err, gc.IsNil)
c.Check(cons, jc.DeepEquals, constraints.MustParse(t.expected))
}
}
func (s *instanceTypeSuite) TestGetMatchingInstanceTypesErrors(c *gc.C) {
_, err := MatchingInstanceTypes(nil, "test", constraints.MustParse("cpu-power=9001"))
c.Check(err, gc.ErrorMatches, `no instance types in test matching constraints "cpu-power=9001"`)
_, err = MatchingInstanceTypes(instanceTypes, "test", constraints.MustParse("arch=i386 mem=8G"))
c.Check(err, gc.ErrorMatches, `no instance types in test matching constraints "arch=i386 mem=8192M"`)
_, err = MatchingInstanceTypes(instanceTypes, "test", constraints.MustParse("cpu-cores=9000"))
c.Check(err, gc.ErrorMatches, `no instance types in test matching constraints "cpu-cores=9000"`)
_, err = MatchingInstanceTypes(instanceTypes, "test", constraints.MustParse("mem=90000M"))
c.Check(err, gc.ErrorMatches, `no instance types in test matching constraints "mem=90000M"`)
}
func (s *validationSuite) TestMerge(c *gc.C) {
for i, t := range mergeTests {
c.Logf("test %d: %s", i, t.desc)
validator := constraints.NewValidator()
validator.RegisterConflicts(t.reds, t.blues)
consFallback := constraints.MustParse(t.consFallback)
cons := constraints.MustParse(t.cons)
merged, err := validator.Merge(consFallback, cons)
c.Assert(err, jc.ErrorIsNil)
expected := constraints.MustParse(t.expected)
c.Check(merged, gc.DeepEquals, expected)
}
}
func (s *DeployLocalSuite) TestDeployConstraints(c *gc.C) {
err := s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, gc.IsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
})
c.Assert(err, gc.IsNil)
s.assertConstraints(c, service, serviceCons)
}
func (s *DeployLocalSuite) TestDeployConstraints(c *gc.C) {
err := s.State.SetModelConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, jc.ErrorIsNil)
serviceCons := constraints.MustParse("cores=2")
service, err := juju.DeployApplication(s.State,
juju.DeployApplicationParams{
ApplicationName: "bob",
Charm: s.charm,
Constraints: serviceCons,
})
c.Assert(err, jc.ErrorIsNil)
s.assertConstraints(c, service, serviceCons)
}
func (s *bootstrapSuite) TestBootstrapSpecifiedConstraints(c *gc.C) {
env := newEnviron("foo", useDefaultKeys, nil)
s.setDummyStorage(c, env)
bootstrapCons := constraints.MustParse("cpu-cores=3 mem=7G")
environCons := constraints.MustParse("cpu-cores=2 mem=4G")
err := bootstrap.Bootstrap(envtesting.BootstrapContext(c), env, bootstrap.BootstrapParams{
BootstrapConstraints: bootstrapCons,
EnvironConstraints: environCons,
})
c.Assert(err, jc.ErrorIsNil)
c.Assert(env.bootstrapCount, gc.Equals, 1)
c.Assert(env.args.BootstrapConstraints, gc.DeepEquals, bootstrapCons)
c.Assert(env.args.EnvironConstraints, gc.DeepEquals, environCons)
}
func (s *ConstraintsSuite) TestIncludeExcludeAndHaveSpaces(c *gc.C) {
con := constraints.MustParse("spaces=space1,^space2,space3,^space4")
c.Assert(con.Spaces, gc.Not(gc.IsNil))
c.Check(*con.Spaces, gc.HasLen, 4)
c.Check(con.IncludeSpaces(), jc.SameContents, []string{"space1", "space3"})
c.Check(con.ExcludeSpaces(), jc.SameContents, []string{"space2", "space4"})
c.Check(con.HaveSpaces(), jc.IsTrue)
con = constraints.MustParse("mem=4G")
c.Check(con.HaveSpaces(), jc.IsFalse)
con = constraints.MustParse("mem=4G spaces=space-foo,^space-bar")
c.Check(con.IncludeSpaces(), jc.SameContents, []string{"space-foo"})
c.Check(con.ExcludeSpaces(), jc.SameContents, []string{"space-bar"})
c.Check(con.HaveSpaces(), jc.IsTrue)
}
func (s *DeployLocalSuite) TestDeployNumUnits(c *gc.C) {
err := s.State.SetEnvironConstraints(constraints.MustParse("mem=2G"))
c.Assert(err, jc.ErrorIsNil)
serviceCons := constraints.MustParse("cpu-cores=2")
service, err := juju.DeployService(s.State,
juju.DeployServiceParams{
ServiceName: "bob",
Charm: s.charm,
Constraints: serviceCons,
NumUnits: 2,
})
c.Assert(err, jc.ErrorIsNil)
s.assertConstraints(c, service, serviceCons)
s.assertMachines(c, service, constraints.MustParse("mem=2G cpu-cores=2"), "0", "1")
}
func (s *environPolSuite) TestConstraintsValidatorConflicts(c *gc.C) {
s.Policy.Arches = []string{arch.AMD64}
validator, err := s.Env.ConstraintsValidator()
c.Assert(err, jc.ErrorIsNil)
cons := constraints.MustParse("instance-type=n1-standard-1")
consFallback := constraints.MustParse("cpu-cores=2 cpu-power=1000 mem=10000 tags=bar")
merged, err := validator.Merge(consFallback, cons)
c.Assert(err, jc.ErrorIsNil)
// tags is not supported, but we're not validating here...
expected := constraints.MustParse("instance-type=n1-standard-1 tags=bar cpu-cores=2 cpu-power=1000 mem=10000")
c.Check(merged, jc.DeepEquals, expected)
}
func (s *environPolSuite) TestConstraintsValidatorConflicts(c *gc.C) {
validator, err := s.Env.ConstraintsValidator()
c.Assert(err, jc.ErrorIsNil)
cons := constraints.MustParse("instance-type=n1-standard-1")
// We do not check arch or container since there is only one valid
// value for each and will always match.
consFallback := constraints.MustParse("cores=2 cpu-power=1000 mem=10000 tags=bar")
merged, err := validator.Merge(consFallback, cons)
c.Assert(err, jc.ErrorIsNil)
// tags is not supported, but we're not validating here...
expected := constraints.MustParse("instance-type=n1-standard-1 tags=bar")
c.Check(merged, jc.DeepEquals, expected)
}
func (s *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
env := s.Open(c)
cons := constraints.MustParse("instance-type=m1.large")
placement := ""
err := env.PrecheckInstance("precise", cons, placement)
c.Assert(err, gc.ErrorMatches, `invalid Openstack flavour "m1.large" specified`)
}