Implement unit tests for various parsing / comparsions

Signed-off-by: George Dunlap <george.dunlap@citrix.com>

diff --git a/xen_test.go b/xen_test.go
new file mode 100644 (file)
index 0000000..913141b
--- /dev/null
+++ b/xen_test.go
@@ -0,0 +1,220 @@
+package main
+
+import "testing"
+
+func TestXenVersionFullParse(t *testing.T) {
+       tests := []struct{
+               fv XenVersionFull
+               ok bool
+               v XenVersion
+               p int
+       }{
+               {
+                       XenVersionFull("4.6.4"),
+                       true,
+                       XenVersion("4.6"),
+                       4,
+               },
+               {
+                       XenVersionFull("14.6.4"),
+                       true,
+                       XenVersion("14.6"),
+                       4,
+               },
+               {
+                       XenVersionFull("4.6.433"),
+                       true,
+                       XenVersion("4.6"),
+                       433,
+               },
+               {
+                       XenVersionFull("4.6"),
+                       false,
+                       "error",
+                       -1,
+               },
+               {
+                       XenVersionFull("master"),
+                       true,
+                       XenVersion("master"),
+                       0,
+               },
+               {
+                       XenVersionFull("masterx"),
+                       false,
+                       "error",
+                       -1,
+               },
+       }
+
+       for i := range tests {
+               fv := tests[i].fv
+               t.Logf("Checking %s\n", fv)
+               ok := fv.Check()
+               if ok != tests[i].ok {
+                       t.Errorf("Expected %v got %v\n", tests[i].ok, ok)
+               }
+
+               v := fv.XenVersion()
+               if v != tests[i].v {
+                       t.Errorf("Expected %v got %v\n", tests[i].v, v)
+               }
+               
+               p := fv.Point()
+               if p != tests[i].p {
+                       t.Errorf("Expected %v got %v\n", tests[i].p, p)
+               }
+       }
+}
+
+func TestXenVersionParse(t *testing.T) {
+       tests := []struct{
+               v XenVersion
+               ok bool
+       }{
+               {
+                       XenVersion("4.6"),
+                       true,
+               },
+               {
+                       XenVersion("14.6"),
+                       true,
+               },
+               {
+                       XenVersion("4.6.1"),
+                       false,
+               },
+               {
+                       XenVersion("master"),
+                       true,
+               },
+               {
+                       XenVersion("masterx"),
+                       false,
+               },
+       }
+
+       for i := range tests {
+               v := tests[i].v
+               t.Logf("Checking %s\n", v)
+               ok := v.Check()
+               if ok != tests[i].ok {
+                       t.Errorf("Expected %v got %v\n", tests[i].ok, ok)
+               }
+       }
+}
+
+func TestXenVersionCompare(t *testing.T) {
+       tests := []struct{
+               a, b XenVersion
+               ge bool
+       }{
+               { "4.6", "4.6", true },
+               { "4.5", "4.6", false},
+               { "4.6", "4.5", true},
+               { "4.0", "4.5", false},
+       }
+
+       for i := range tests {
+               a := tests[i].a
+               b := tests[i].b
+               t.Logf("Checking %s > %s\n", a, b)
+               ge := a.IsGreaterEqualThan(b)
+               if ge != tests[i].ge {
+                       t.Errorf("Expected %v got %v\n", tests[i].ge, ge)
+               }
+       }
+}
+
+func TestTagsToVersions(t *testing.T) {
+       t.Logf("Testing tag parsing")
+       xr := XenRepo{ XRType: TreeXen }
+
+       tags := []string{
+               "RELEASE-4.6.4",
+               "RELEASE-4.6.5",
+               "RELEASE-4.7.0",
+               "RELEASE-4.7.1",
+               "RELEASE-4.7.2",
+               "RELEASE-4.8.0",
+               "RELEASE-4.8.1",
+               "4.4.0-rc3",
+               "4.4.0-rc4",
+               "4.4.0-rc5",
+               "4.4.0-rc6",
+               "4.4.1-rc1",
+               "4.4.1-rc2",
+               "4.4.2-rc1",
+               "4.4.2-rc2",
+               "4.4.3-rc1",
+               "4.5-unstable",
+               "4.5.0-rc1",
+               "4.5.0-rc2",
+               "4.5.0-rc3",
+               "4.5.0-rc4",
+               "4.5.1-rc1",
+               "4.5.1-rc2",
+               "4.6.0-rc1",
+               "4.6.0-rc2",
+               "4.6.0-rc3",
+               "4.6.0-rc4",
+               "4.6.0-rc5",
+               "4.7.0-rc1",
+               "4.7.0-rc2",
+               "4.7.0-rc3",
+               "4.7.0-rc4",
+               "4.7.0-rc5",
+               "4.7.0-rc6",
+               "4.8.0-rc1",
+               "4.8.0-rc2",
+               "4.8.0-rc3",
+               "4.8.0-rc4",
+               "4.8.0-rc5",
+               "4.8.0-rc6",
+               "4.8.0-rc7",
+               "4.8.0-rc8",
+               "4.9.0-rc1",
+               "4.9.0-rc1.1",
+               "beta1",
+               "ia64-stable",
+               "latest-semistable",
+               "latest-stable",
+               "semistable",
+               "sparse-tree-deprecated",
+               "split-1.0",
+       }
+
+       expected := []XenVersionFull{
+               XenVersionFull("4.6.4"),
+               XenVersionFull("4.6.5"),
+               XenVersionFull("4.7.0"),
+               XenVersionFull("4.7.1"),
+               XenVersionFull("4.7.2"),
+               XenVersionFull("4.8.0"),
+               XenVersionFull("4.8.1"),
+       }
+       
+       versions, err := xr.tagsToVersions(tags)
+       if err != nil {
+               t.Errorf("Unexpected error: %v\n", err)
+               return
+       }
+
+       if len(versions) != len(expected) {
+               t.Errorf("Number of versions differ: expected %d, got %d\n",
+                       len(expected), len(versions))
+       }
+
+       for i := range versions {
+               if i > len(expected) {
+                       break
+               }
+               t.Logf(" versions[%d] %v\n", i, versions[i])
+               if versions[i] != expected[i] {
+                       t.Errorf(" Mismatch: %v %v\n",
+                               versions[i], expected[i])
+               }
+       }
+       // FIXME: if lengths are unequal, print the missing bits
+}
+