Add an os-disk constraint

constraints/constraints_test.go

 // Copyright 2013 Canonical Ltd.
 // Licensed under the AGPLv3, see LICENCE file for details.
 
 package constraints_test
 
 import (
         "encoding/json"
         "testing"
 
-        . "launchpad.net/gocheck"
+        gc "launchpad.net/gocheck"
         "launchpad.net/goyaml"
 
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/instance"
 )
 
 func TestPackage(t *testing.T) {
-        TestingT(t)
+        gc.TestingT(t)
 }
 
 type ConstraintsSuite struct{}
 
-var _ = Suite(&ConstraintsSuite{})
+var _ = gc.Suite(&ConstraintsSuite{})
 
 var parseConstraintsTests = []struct {
         summary string
         args    []string
         err     string
 }{
         // Simple errors.
         {
                 summary: "nothing at all",
         }, {
@@ skipping 165 matching lines @@
         }, {
                 summary: "double set mem together",
                 args:    []string{"mem=1G  mem=2G"},
                 err:     `bad "mem" constraint: already set`,
         }, {
                 summary: "double set mem separately",
                 args:    []string{"mem=1G", "mem=2G"},
                 err:     `bad "mem" constraint: already set`,
         },
 
-        // "os-disk" in detail.
-        {
-                summary: "set os-disk empty",
-                args:    []string{"os-disk="},
-        }, {
-                summary: "set os-disk zero",
-                args:    []string{"os-disk=0"},
-        }, {
-                summary: "set os-disk without suffix",
-                args:    []string{"os-disk=512"},
-        }, {
-                summary: "set os-disk with M suffix",
-                args:    []string{"os-disk=512M"},
-        }, {
-                summary: "set os-disk with G suffix",
-                args:    []string{"os-disk=1.5G"},
-        }, {
-                summary: "set os-disk with T suffix",
-                args:    []string{"os-disk=36.2T"},
-        }, {
-                summary: "set os-disk with P suffix",
-                args:    []string{"os-disk=18.9P"},
-        }, {
-                summary: "set nonsense os-disk 1",
-                args:    []string{"os-disk=cheese"},
-                err:     `bad "os-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
-        }, {
-                summary: "set nonsense os-disk 2",
-                args:    []string{"os-disk=-1"},
-                err:     `bad "os-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
-        }, {
-                summary: "set nonsense os-disk 3",
-                args:    []string{"os-disk=32Y"},
-                err:     `bad "os-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
-        }, {
-                summary: "double set os-disk together",
-                args:    []string{"os-disk=1G  os-disk=2G"},
-                err:     `bad "os-disk" constraint: already set`,
-        }, {
-                summary: "double set os-disk separately",
-                args:    []string{"os-disk=1G", "os-disk=2G"},
-                err:     `bad "os-disk" constraint: already set`,
+        // "root-disk" in detail.
+        {
+                summary: "set root-disk empty",
+                args:    []string{"root-disk="},
+        }, {
+                summary: "set root-disk zero",
+                args:    []string{"root-disk=0"},
+        }, {
+                summary: "set root-disk without suffix",
+                args:    []string{"root-disk=512"},
+        }, {
+                summary: "set root-disk with M suffix",
+                args:    []string{"root-disk=512M"},
+        }, {
+                summary: "set root-disk with G suffix",
+                args:    []string{"root-disk=1.5G"},
+        }, {
+                summary: "set root-disk with T suffix",
+                args:    []string{"root-disk=36.2T"},
+        }, {
+                summary: "set root-disk with P suffix",
+                args:    []string{"root-disk=18.9P"},
+        }, {
+                summary: "set nonsense root-disk 1",
+                args:    []string{"root-disk=cheese"},
+                err:     `bad "root-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
+        }, {
+                summary: "set nonsense root-disk 2",
+                args:    []string{"root-disk=-1"},
+                err:     `bad "root-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
+        }, {
+                summary: "set nonsense root-disk 3",
+                args:    []string{"root-disk=32Y"},
+                err:     `bad "root-disk" constraint: must be a non-negative float with optional M/G/T/P suffix`,
+        }, {
+                summary: "double set root-disk together",
+                args:    []string{"root-disk=1G  root-disk=2G"},
+                err:     `bad "root-disk" constraint: already set`,
+        }, {
+                summary: "double set root-disk separately",
+                args:    []string{"root-disk=1G", "root-disk=2G"},
+                err:     `bad "root-disk" constraint: already set`,
         },
 
         // Everything at once.
         {
                 summary: "kitchen sink together",
-                args:    []string{" os-disk=8G mem=2T  arch=i386  cpu-cores=4096 cpu-power=9001 container=lxc"},
+                args:    []string{" root-disk=8G mem=2T  arch=i386  cpu-cores=4096 cpu-power=9001 container=lxc"},
         }, {
                 summary: "kitchen sink separately",
-                args:    []string{"os-disk=8G", "mem=2T", "cpu-cores=4096", "cpu-power=9001", "arch=arm", "container=lxc"},
-        },
-}
-
-func (s *ConstraintsSuite) TestParseConstraints(c *C) {
+                args:    []string{"root-disk=8G", "mem=2T", "cpu-cores=4096", "cpu-power=9001", "arch=arm", "container=lxc"},
+        },
+}
+
+func (s *ConstraintsSuite) TestParseConstraints(c *gc.C) {
         for i, t := range parseConstraintsTests {
                 c.Logf("test %d: %s", i, t.summary)
                 cons0, err := constraints.Parse(t.args...)
                 if t.err == "" {
-                        c.Assert(err, IsNil)
+                        c.Assert(err, gc.IsNil)
                 } else {
-                        c.Assert(err, ErrorMatches, t.err)
+                        c.Assert(err, gc.ErrorMatches, t.err)
                         continue
                 }
                 cons1, err := constraints.Parse(cons0.String())
-                c.Assert(err, IsNil)
-                c.Assert(cons1, DeepEquals, cons0)
+                c.Assert(err, gc.IsNil)
+                c.Assert(cons1, gc.DeepEquals, cons0)
         }
 }
 
 func uint64p(i uint64) *uint64 {
         return &i
 }
 
 func strp(s string) *string {
         return &s
 }
 
 func ctypep(ctype string) *instance.ContainerType {
         res := instance.ContainerType(ctype)
         return &res
 }
 
 var constraintsRoundtripTests = []constraints.Value{
         {},
         {Arch: strp("")},
         {Arch: strp("amd64")},
         {Container: ctypep("")},
         {Container: ctypep("lxc")},
         {CpuCores: uint64p(0)},
         {CpuCores: uint64p(128)},
         {CpuPower: uint64p(0)},
         {CpuPower: uint64p(250)},
         {Mem: uint64p(0)},
         {Mem: uint64p(98765)},
-        {OsDisk: uint64p(98765)},
+        {RootDisk: uint64p(0)},
+        {RootDisk: uint64p(109876)},
         {
                 Arch:      strp("i386"),
                 Container: ctypep("lxc"),
                 CpuCores:  uint64p(4096),
                 CpuPower:  uint64p(9001),
                 Mem:       uint64p(18000000000),
-                OsDisk:    uint64p(18000000000),
-        },
-}
-
-func (s *ConstraintsSuite) TestRoundtripGnuflagValue(c *C) {
+                RootDisk:  uint64p(24000000000),
+        },
+}
+
+func (s *ConstraintsSuite) TestRoundtripGnuflagValue(c *gc.C) {
         for i, t := range constraintsRoundtripTests {
                 c.Logf("test %d", i)
                 var cons constraints.Value
                 val := constraints.ConstraintsValue{&cons}
                 err := val.Set(t.String())
-                c.Assert(err, IsNil)
-                c.Assert(cons, DeepEquals, t)
-        }
-}
-
-func (s *ConstraintsSuite) TestRoundtripString(c *C) {
+                c.Assert(err, gc.IsNil)
+                c.Assert(cons, gc.DeepEquals, t)
+        }
+}
+
+func (s *ConstraintsSuite) TestRoundtripString(c *gc.C) {
         for i, t := range constraintsRoundtripTests {
                 c.Logf("test %d", i)
                 cons, err := constraints.Parse(t.String())
-                c.Assert(err, IsNil)
-                c.Assert(cons, DeepEquals, t)
-        }
-}
-
-func (s *ConstraintsSuite) TestRoundtripJson(c *C) {
+                c.Assert(err, gc.IsNil)
+                c.Assert(cons, gc.DeepEquals, t)
+        }
+}
+
+func (s *ConstraintsSuite) TestRoundtripJson(c *gc.C) {
         for i, t := range constraintsRoundtripTests {
                 c.Logf("test %d", i)
                 data, err := json.Marshal(t)
-                c.Assert(err, IsNil)
+                c.Assert(err, gc.IsNil)
                 var cons constraints.Value
                 err = json.Unmarshal(data, &cons)
-                c.Assert(err, IsNil)
-                c.Assert(cons, DeepEquals, t)
-        }
-}
-
-func (s *ConstraintsSuite) TestRoundtripYaml(c *C) {
+                c.Assert(err, gc.IsNil)
+                c.Assert(cons, gc.DeepEquals, t)
+        }
+}
+
+func (s *ConstraintsSuite) TestRoundtripYaml(c *gc.C) {
         for i, t := range constraintsRoundtripTests {
                 c.Logf("test %d", i)
                 data, err := goyaml.Marshal(t)
-                c.Assert(err, IsNil)
+                c.Assert(err, gc.IsNil)
                 c.Logf("%s", data)
                 var cons constraints.Value
                 err = goyaml.Unmarshal(data, &cons)
-                c.Assert(err, IsNil)
-                c.Assert(cons, DeepEquals, t)
+                c.Assert(err, gc.IsNil)
+                c.Assert(cons, gc.DeepEquals, t)
         }
 }
 
 var withFallbacksTests = []struct {
         desc      string
         initial   string
         fallbacks string
         final     string
 }{
         {
@@ skipping 52 matching lines @@
         }, {
                 desc:      "mem with ignored fallback",
                 initial:   "mem=4G",
                 fallbacks: "mem=8G",
                 final:     "mem=4G",
         }, {
                 desc:      "mem from fallback",
                 fallbacks: "mem=8G",
                 final:     "mem=8G",
         }, {
-                desc:    "os-disk with empty fallback",
-                initial: "os-disk=4G",
-                final:   "os-disk=4G",
-        }, {
-                desc:      "os-disk with ignored fallback",
-                initial:   "os-disk=4G",
-                fallbacks: "os-disk=8G",
-                final:     "os-disk=4G",
-        }, {
-                desc:      "os-disk from fallback",
-                fallbacks: "os-disk=8G",
-                final:     "os-disk=8G",
+                desc:    "root-disk with empty fallback",
+                initial: "root-disk=4G",
+                final:   "root-disk=4G",
+        }, {
+                desc:      "root-disk with ignored fallback",
+                initial:   "root-disk=4G",
+                fallbacks: "root-disk=8G",
+                final:     "root-disk=4G",
+        }, {
+                desc:      "root-disk from fallback",
+                fallbacks: "root-disk=8G",
+                final:     "root-disk=8G",
         }, {
                 desc:      "non-overlapping mix",
-                initial:   "os-disk=8G mem=4G arch=amd64",
+                initial:   "root-disk=8G mem=4G arch=amd64",
                 fallbacks: "cpu-power=1000 cpu-cores=4",
-                final:     "os-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
+                final:     "root-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
         }, {
                 desc:      "overlapping mix",
-                initial:   "os-disk=8G mem=4G arch=amd64",
+                initial:   "root-disk=8G mem=4G arch=amd64",
                 fallbacks: "cpu-power=1000 cpu-cores=4 mem=8G",
-                final:     "os-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
-        },
-}
-
-func (s *ConstraintsSuite) TestWithFallbacks(c *C) {
+                final:     "root-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
+        },
+}
+
+func (s *ConstraintsSuite) TestWithFallbacks(c *gc.C) {
         for i, t := range withFallbacksTests {
                 c.Logf("test %d", i)
                 initial := constraints.MustParse(t.initial)
                 fallbacks := constraints.MustParse(t.fallbacks)
                 final := constraints.MustParse(t.final)
-                c.Assert(initial.WithFallbacks(fallbacks), DeepEquals, final)
+                c.Assert(initial.WithFallbacks(fallbacks), gc.DeepEquals, final)
         }
 }
 
 var hasContainerTests = []struct {
         constraints  string
         hasContainer bool
 }{
         {
                 hasContainer: false,
         }, {
                 constraints:  "container=lxc",
                 hasContainer: true,
         }, {
                 constraints:  "container=none",
                 hasContainer: false,
         },
 }
 
-func (s *ConstraintsSuite) TestHasContainer(c *C) {
+func (s *ConstraintsSuite) TestHasContainer(c *gc.C) {
         for i, t := range hasContainerTests {
                 c.Logf("test %d", i)
                 cons := constraints.MustParse(t.constraints)
-                c.Assert(cons.HasContainer(), Equals, t.hasContainer)
-        }
-}
+                c.Assert(cons.HasContainer(), gc.Equals, t.hasContainer)
+        }
+}