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"

[dimitern, 2013/08/14 17:08:59]

While you're at it can you import gocheck as gc and change the references to it
below please?

[sidnei.da.silva, 2013/08/14 17:17:18]

Done.

         "launchpad.net/goyaml"
 
         "launchpad.net/juju-core/constraints"
         "launchpad.net/juju-core/instance"
 )
 
 func TestPackage(t *testing.T) {
         TestingT(t)
 }
 
@@ skipping 178 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`,
+        },
+
         // Everything at once.
         {
                 summary: "kitchen sink together",
-                args:    []string{" mem=2T  arch=i386  cpu-cores=4096 cpu-power=9001 container=lxc"},
+                args:    []string{" os-disk=8G mem=2T  arch=i386  cpu-cores=4096 cpu-power=9001 container=lxc"},
         }, {
                 summary: "kitchen sink separately",
-                args:    []string{"mem=2T", "cpu-cores=4096", "cpu-power=9001", "arch=arm", "container=lxc"},
+                args:    []string{"os-disk=8G", "mem=2T", "cpu-cores=4096", "cpu-power=9001", "arch=arm", "container=lxc"},
         },
 }
 
 func (s *ConstraintsSuite) TestParseConstraints(c *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)
                 } else {
@@ skipping 24 matching lines @@
         {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)},

[dimitern, 2013/08/14 17:08:59]

Perhaps both:
{OsDisk: uint64p(0)},
{OsDisk: uint64p(98765)},

Like Mem or CpuCores?

[sidnei.da.silva, 2013/08/14 17:17:18]

Done.

         {
                 Arch:      strp("i386"),
                 Container: ctypep("lxc"),
                 CpuCores:  uint64p(4096),
                 CpuPower:  uint64p(9001),
                 Mem:       uint64p(18000000000),
+                OsDisk:    uint64p(18000000000),
         },
 }
 
 func (s *ConstraintsSuite) TestRoundtripGnuflagValue(c *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)
@@ skipping 97 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:      "non-overlapping mix",
-                initial:   "mem=4G arch=amd64",
+                initial:   "os-disk=8G mem=4G arch=amd64",
                 fallbacks: "cpu-power=1000 cpu-cores=4",
-                final:     "mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
+                final:     "os-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
         }, {
                 desc:      "overlapping mix",
-                initial:   "mem=4G arch=amd64",
+                initial:   "os-disk=8G mem=4G arch=amd64",
                 fallbacks: "cpu-power=1000 cpu-cores=4 mem=8G",
-                final:     "mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
+                final:     "os-disk=8G mem=4G arch=amd64 cpu-power=1000 cpu-cores=4",
         },
 }
 
 func (s *ConstraintsSuite) TestWithFallbacks(c *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)
@@ skipping 15 matching lines @@
         },
 }
 
 func (s *ConstraintsSuite) TestHasContainer(c *C) {
         for i, t := range hasContainerTests {
                 c.Logf("test %d", i)
                 cons := constraints.MustParse(t.constraints)
                 c.Assert(cons.HasContainer(), Equals, t.hasContainer)
         }
 }