vendor/github.com/hashicorp/go-version/version_test.go

   1 package version
   2
   3 import (
   4         "reflect"
   5         "testing"
   6 )
   7
   8 func TestNewVersion(t *testing.T) {
   9         cases := []struct {
  10                 version string
  11                 err     bool
  12         }{
  13                 {"1.2.3", false},
  14                 {"1.0", false},
  15                 {"1", false},
  16                 {"1.2.beta", true},
  17                 {"1.21.beta", true},
  18                 {"foo", true},
  19                 {"1.2-5", false},
  20                 {"1.2-beta.5", false},
  21                 {"\n1.2", true},
  22                 {"1.2.0-x.Y.0+metadata", false},
  23                 {"1.2.0-x.Y.0+metadata-width-hypen", false},
  24                 {"1.2.3-rc1-with-hypen", false},
  25                 {"1.2.3.4", false},
  26                 {"1.2.0.4-x.Y.0+metadata", false},
  27                 {"1.2.0.4-x.Y.0+metadata-width-hypen", false},
  28                 {"1.2.0-X-1.2.0+metadata~dist", false},
  29                 {"1.2.3.4-rc1-with-hypen", false},
  30                 {"1.2.3.4", false},
  31                 {"v1.2.3", false},
  32                 {"foo1.2.3", true},
  33                 {"1.7rc2", false},
  34                 {"v1.7rc2", false},
  35         }
  36
  37         for _, tc := range cases {
  38                 _, err := NewVersion(tc.version)
  39                 if tc.err && err == nil {
  40                         t.Fatalf("expected error for version: %s", tc.version)
  41                 } else if !tc.err && err != nil {
  42                         t.Fatalf("error for version %s: %s", tc.version, err)
  43                 }
  44         }
  45 }
  46
  47 func TestVersionCompare(t *testing.T) {
  48         cases := []struct {
  49                 v1       string
  50                 v2       string
  51                 expected int
  52         }{
  53                 {"1.2.3", "1.4.5", -1},
  54                 {"1.2-beta", "1.2-beta", 0},
  55                 {"1.2", "1.1.4", 1},
  56                 {"1.2", "1.2-beta", 1},
  57                 {"1.2+foo", "1.2+beta", 0},
  58                 {"v1.2", "v1.2-beta", 1},
  59                 {"v1.2+foo", "v1.2+beta", 0},
  60                 {"v1.2.3.4", "v1.2.3.4", 0},
  61                 {"v1.2.0.0", "v1.2", 0},
  62                 {"v1.2.0.0.1", "v1.2", 1},
  63                 {"v1.2", "v1.2.0.0", 0},
  64                 {"v1.2", "v1.2.0.0.1", -1},
  65                 {"v1.2.0.0", "v1.2.0.0.1", -1},
  66                 {"v1.2.3.0", "v1.2.3.4", -1},
  67                 {"1.7rc2", "1.7rc1", 1},
  68                 {"1.7rc2", "1.7", -1},
  69                 {"1.2.0", "1.2.0-X-1.2.0+metadata~dist", 1},
  70         }
  71
  72         for _, tc := range cases {
  73                 v1, err := NewVersion(tc.v1)
  74                 if err != nil {
  75                         t.Fatalf("err: %s", err)
  76                 }
  77
  78                 v2, err := NewVersion(tc.v2)
  79                 if err != nil {
  80                         t.Fatalf("err: %s", err)
  81                 }
  82
  83                 actual := v1.Compare(v2)
  84                 expected := tc.expected
  85                 if actual != expected {
  86                         t.Fatalf(
  87                                 "%s <=> %s\nexpected: %d\nactual: %d",
  88                                 tc.v1, tc.v2,
  89                                 expected, actual)
  90                 }
  91         }
  92 }
  93
  94 func TestComparePreReleases(t *testing.T) {
  95         cases := []struct {
  96                 v1       string
  97                 v2       string
  98                 expected int
  99         }{
 100                 {"1.2-beta.2", "1.2-beta.2", 0},
 101                 {"1.2-beta.1", "1.2-beta.2", -1},
 102                 {"1.2-beta.2", "1.2-beta.11", -1},
 103                 {"3.2-alpha.1", "3.2-alpha", 1},
 104                 {"1.2-beta.2", "1.2-beta.1", 1},
 105                 {"1.2-beta.11", "1.2-beta.2", 1},
 106                 {"1.2-beta", "1.2-beta.3", -1},
 107                 {"1.2-alpha", "1.2-beta.3", -1},
 108                 {"1.2-beta", "1.2-alpha.3", 1},
 109                 {"3.0-alpha.3", "3.0-rc.1", -1},
 110                 {"3.0-alpha3", "3.0-rc1", -1},
 111                 {"3.0-alpha.1", "3.0-alpha.beta", -1},
 112                 {"5.4-alpha", "5.4-alpha.beta", 1},
 113                 {"v1.2-beta.2", "v1.2-beta.2", 0},
 114                 {"v1.2-beta.1", "v1.2-beta.2", -1},
 115                 {"v3.2-alpha.1", "v3.2-alpha", 1},
 116                 {"v3.2-rc.1-1-g123", "v3.2-rc.2", 1},
 117         }
 118
 119         for _, tc := range cases {
 120                 v1, err := NewVersion(tc.v1)
 121                 if err != nil {
 122                         t.Fatalf("err: %s", err)
 123                 }
 124
 125                 v2, err := NewVersion(tc.v2)
 126                 if err != nil {
 127                         t.Fatalf("err: %s", err)
 128                 }
 129
 130                 actual := v1.Compare(v2)
 131                 expected := tc.expected
 132                 if actual != expected {
 133                         t.Fatalf(
 134                                 "%s <=> %s\nexpected: %d\nactual: %d",
 135                                 tc.v1, tc.v2,
 136                                 expected, actual)
 137                 }
 138         }
 139 }
 140
 141 func TestVersionMetadata(t *testing.T) {
 142         cases := []struct {
 143                 version  string
 144                 expected string
 145         }{
 146                 {"1.2.3", ""},
 147                 {"1.2-beta", ""},
 148                 {"1.2.0-x.Y.0", ""},
 149                 {"1.2.0-x.Y.0+metadata", "metadata"},
 150                 {"1.2.0-metadata-1.2.0+metadata~dist", "metadata~dist"},
 151         }
 152
 153         for _, tc := range cases {
 154                 v, err := NewVersion(tc.version)
 155                 if err != nil {
 156                         t.Fatalf("err: %s", err)
 157                 }
 158
 159                 actual := v.Metadata()
 160                 expected := tc.expected
 161                 if actual != expected {
 162                         t.Fatalf("expected: %s\nactual: %s", expected, actual)
 163                 }
 164         }
 165 }
 166
 167 func TestVersionPrerelease(t *testing.T) {
 168         cases := []struct {
 169                 version  string
 170                 expected string
 171         }{
 172                 {"1.2.3", ""},
 173                 {"1.2-beta", "beta"},
 174                 {"1.2.0-x.Y.0", "x.Y.0"},
 175                 {"1.2.0-7.Y.0", "7.Y.0"},
 176                 {"1.2.0-x.Y.0+metadata", "x.Y.0"},
 177                 {"1.2.0-metadata-1.2.0+metadata~dist", "metadata-1.2.0"},
 178                 {"17.03.0-ce", "ce"}, // zero-padded fields
 179         }
 180
 181         for _, tc := range cases {
 182                 v, err := NewVersion(tc.version)
 183                 if err != nil {
 184                         t.Fatalf("err: %s", err)
 185                 }
 186
 187                 actual := v.Prerelease()
 188                 expected := tc.expected
 189                 if actual != expected {
 190                         t.Fatalf("expected: %s\nactual: %s", expected, actual)
 191                 }
 192         }
 193 }
 194
 195 func TestVersionSegments(t *testing.T) {
 196         cases := []struct {
 197                 version  string
 198                 expected []int
 199         }{
 200                 {"1.2.3", []int{1, 2, 3}},
 201                 {"1.2-beta", []int{1, 2, 0}},
 202                 {"1-x.Y.0", []int{1, 0, 0}},
 203                 {"1.2.0-x.Y.0+metadata", []int{1, 2, 0}},
 204                 {"1.2.0-metadata-1.2.0+metadata~dist", []int{1, 2, 0}},
 205                 {"17.03.0-ce", []int{17, 3, 0}}, // zero-padded fields
 206         }
 207
 208         for _, tc := range cases {
 209                 v, err := NewVersion(tc.version)
 210                 if err != nil {
 211                         t.Fatalf("err: %s", err)
 212                 }
 213
 214                 actual := v.Segments()
 215                 expected := tc.expected
 216                 if !reflect.DeepEqual(actual, expected) {
 217                         t.Fatalf("expected: %#v\nactual: %#v", expected, actual)
 218                 }
 219         }
 220 }
 221
 222 func TestVersionSegments64(t *testing.T) {
 223         cases := []struct {
 224                 version  string
 225                 expected []int64
 226         }{
 227                 {"1.2.3", []int64{1, 2, 3}},
 228                 {"1.2-beta", []int64{1, 2, 0}},
 229                 {"1-x.Y.0", []int64{1, 0, 0}},
 230                 {"1.2.0-x.Y.0+metadata", []int64{1, 2, 0}},
 231                 {"1.4.9223372036854775807", []int64{1, 4, 9223372036854775807}},
 232         }
 233
 234         for _, tc := range cases {
 235                 v, err := NewVersion(tc.version)
 236                 if err != nil {
 237                         t.Fatalf("err: %s", err)
 238                 }
 239
 240                 actual := v.Segments64()
 241                 expected := tc.expected
 242                 if !reflect.DeepEqual(actual, expected) {
 243                         t.Fatalf("expected: %#v\nactual: %#v", expected, actual)
 244                 }
 245
 246                 {
 247                         expected := actual[0]
 248                         actual[0]++
 249                         actual = v.Segments64()
 250                         if actual[0] != expected {
 251                                 t.Fatalf("Segments64 is mutable")
 252                         }
 253                 }
 254         }
 255 }
 256
 257 func TestVersionString(t *testing.T) {
 258         cases := [][]string{
 259                 {"1.2.3", "1.2.3"},
 260                 {"1.2-beta", "1.2.0-beta"},
 261                 {"1.2.0-x.Y.0", "1.2.0-x.Y.0"},
 262                 {"1.2.0-x.Y.0+metadata", "1.2.0-x.Y.0+metadata"},
 263                 {"1.2.0-metadata-1.2.0+metadata~dist", "1.2.0-metadata-1.2.0+metadata~dist"},
 264                 {"17.03.0-ce", "17.3.0-ce"}, // zero-padded fields
 265         }
 266
 267         for _, tc := range cases {
 268                 v, err := NewVersion(tc[0])
 269                 if err != nil {
 270                         t.Fatalf("err: %s", err)
 271                 }
 272
 273                 actual := v.String()
 274                 expected := tc[1]
 275                 if actual != expected {
 276                         t.Fatalf("expected: %s\nactual: %s", expected, actual)
 277                 }
 278                 if actual := v.Original(); actual != tc[0] {
 279                         t.Fatalf("expected original: %q\nactual: %q", tc[0], actual)
 280                 }
 281         }
 282 }