← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

Viewing changes to src/github.com/juju/version/version_test.go

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/github.com/juju/version/version_test.go
 
1
// Copyright 2012, 2013 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package version_test
 
5
 
 
6
import (
 
7
        "encoding/json"
 
8
        "strings"
 
9
 
 
10
        jc "github.com/juju/testing/checkers"
 
11
        gc "gopkg.in/check.v1"
 
12
        "gopkg.in/mgo.v2/bson"
 
13
        goyaml "gopkg.in/yaml.v2"
 
14
 
 
15
        "github.com/juju/version"
 
16
)
 
17
 
 
18
type suite struct{}
 
19
 
 
20
var _ = gc.Suite(&suite{})
 
21
 
 
22
func (*suite) TestCompare(c *gc.C) {
 
23
        cmpTests := []struct {
 
24
                v1, v2  string
 
25
                compare int
 
26
        }{
 
27
                {"1.0.0", "1.0.0", 0},
 
28
                {"01.0.0", "1.0.0", 0},
 
29
                {"10.0.0", "9.0.0", 1},
 
30
                {"1.0.0", "1.0.1", -1},
 
31
                {"1.0.1", "1.0.0", 1},
 
32
                {"1.0.0", "1.1.0", -1},
 
33
                {"1.1.0", "1.0.0", 1},
 
34
                {"1.0.0", "2.0.0", -1},
 
35
                {"1.2-alpha1", "1.2.0", -1},
 
36
                {"1.2-alpha2", "1.2-alpha1", 1},
 
37
                {"1.2-alpha2.1", "1.2-alpha2", 1},
 
38
                {"1.2-alpha2.2", "1.2-alpha2.1", 1},
 
39
                {"1.2-beta1", "1.2-alpha1", 1},
 
40
                {"1.2-beta1", "1.2-alpha2.1", 1},
 
41
                {"1.2-beta1", "1.2.0", -1},
 
42
                {"1.2.1", "1.2.0", 1},
 
43
                {"2.0.0", "1.0.0", 1},
 
44
                {"2.0.0.0", "2.0.0", 0},
 
45
                {"2.0.0.0", "2.0.0.0", 0},
 
46
                {"2.0.0.1", "2.0.0.0", 1},
 
47
                {"2.0.1.10", "2.0.0.0", 1},
 
48
                {"2.0-_0", "2.0-00", 1},
 
49
                {"2.0-_0", "2.0.0", -1},
 
50
                {"2.0-_0", "2.0-alpha1.0", -1},
 
51
                {"2.0-_0", "1.999.0", 1},
 
52
        }
 
53
 
 
54
        for i, test := range cmpTests {
 
55
                c.Logf("test %d", i)
 
56
                v1, err := version.Parse(test.v1)
 
57
                c.Assert(err, jc.ErrorIsNil)
 
58
                v2, err := version.Parse(test.v2)
 
59
                c.Assert(err, jc.ErrorIsNil)
 
60
                compare := v1.Compare(v2)
 
61
                c.Check(compare, gc.Equals, test.compare)
 
62
                // Check that reversing the operands has
 
63
                // the expected result.
 
64
                compare = v2.Compare(v1)
 
65
                c.Check(compare, gc.Equals, -test.compare)
 
66
        }
 
67
}
 
68
 
 
69
var parseTests = []struct {
 
70
        v      string
 
71
        err    string
 
72
        expect version.Number
 
73
}{{
 
74
        v: "0.0.0",
 
75
}, {
 
76
        v:      "0.0.1",
 
77
        expect: version.Number{Major: 0, Minor: 0, Patch: 1},
 
78
}, {
 
79
        v:      "0.0.2",
 
80
        expect: version.Number{Major: 0, Minor: 0, Patch: 2},
 
81
}, {
 
82
        v:      "0.1.0",
 
83
        expect: version.Number{Major: 0, Minor: 1, Patch: 0},
 
84
}, {
 
85
        v:      "0.2.3",
 
86
        expect: version.Number{Major: 0, Minor: 2, Patch: 3},
 
87
}, {
 
88
        v:      "1.0.0",
 
89
        expect: version.Number{Major: 1, Minor: 0, Patch: 0},
 
90
}, {
 
91
        v:      "10.234.3456",
 
92
        expect: version.Number{Major: 10, Minor: 234, Patch: 3456},
 
93
}, {
 
94
        v:      "10.234.3456.1",
 
95
        expect: version.Number{Major: 10, Minor: 234, Patch: 3456, Build: 1},
 
96
}, {
 
97
        v:      "10.234.3456.64",
 
98
        expect: version.Number{Major: 10, Minor: 234, Patch: 3456, Build: 64},
 
99
}, {
 
100
        v:      "10.235.3456",
 
101
        expect: version.Number{Major: 10, Minor: 235, Patch: 3456},
 
102
}, {
 
103
        v:      "1.21-alpha1",
 
104
        expect: version.Number{Major: 1, Minor: 21, Patch: 1, Tag: "alpha"},
 
105
}, {
 
106
        v:      "1.21-alpha1.1",
 
107
        expect: version.Number{Major: 1, Minor: 21, Patch: 1, Tag: "alpha", Build: 1},
 
108
}, {
 
109
        v:      "1.21.0",
 
110
        expect: version.Number{Major: 1, Minor: 21},
 
111
}, {
 
112
        v:   "1234567890.2.1",
 
113
        err: "invalid version.*",
 
114
}, {
 
115
        v:   "0.2..1",
 
116
        err: "invalid version.*",
 
117
}, {
 
118
        v:   "1.21.alpha1",
 
119
        err: "invalid version.*",
 
120
}, {
 
121
        v:   "1.21-alpha",
 
122
        err: "invalid version.*",
 
123
}, {
 
124
        v:   "1.21-alpha1beta",
 
125
        err: "invalid version.*",
 
126
}, {
 
127
        v:   "1.21-alpha-dev",
 
128
        err: "invalid version.*",
 
129
}}
 
130
 
 
131
func (*suite) TestParse(c *gc.C) {
 
132
        for i, test := range parseTests {
 
133
                c.Logf("test %d", i)
 
134
                got, err := version.Parse(test.v)
 
135
                if test.err != "" {
 
136
                        c.Assert(err, gc.ErrorMatches, test.err)
 
137
                } else {
 
138
                        c.Assert(err, jc.ErrorIsNil)
 
139
                        c.Assert(got, gc.Equals, test.expect)
 
140
                        c.Check(got.String(), gc.Equals, test.v)
 
141
                }
 
142
        }
 
143
}
 
144
 
 
145
func binaryVersion(major, minor, patch, build int, tag, series, arch string) version.Binary {
 
146
        return version.Binary{
 
147
                Number: version.Number{
 
148
                        Major: major,
 
149
                        Minor: minor,
 
150
                        Patch: patch,
 
151
                        Build: build,
 
152
                        Tag:   tag,
 
153
                },
 
154
                Series: series,
 
155
                Arch:   arch,
 
156
        }
 
157
}
 
158
 
 
159
func (*suite) TestParseBinary(c *gc.C) {
 
160
        parseBinaryTests := []struct {
 
161
                v      string
 
162
                err    string
 
163
                expect version.Binary
 
164
        }{{
 
165
                v:      "1.2.3-trusty-amd64",
 
166
                expect: binaryVersion(1, 2, 3, 0, "", "trusty", "amd64"),
 
167
        }, {
 
168
                v:      "1.2.3.4-trusty-amd64",
 
169
                expect: binaryVersion(1, 2, 3, 4, "", "trusty", "amd64"),
 
170
        }, {
 
171
                v:      "1.2-alpha3-trusty-amd64",
 
172
                expect: binaryVersion(1, 2, 3, 0, "alpha", "trusty", "amd64"),
 
173
        }, {
 
174
                v:      "1.2-alpha3.4-trusty-amd64",
 
175
                expect: binaryVersion(1, 2, 3, 4, "alpha", "trusty", "amd64"),
 
176
        }, {
 
177
                v:   "1.2.3",
 
178
                err: "invalid binary version.*",
 
179
        }, {
 
180
                v:   "1.2-beta1",
 
181
                err: "invalid binary version.*",
 
182
        }, {
 
183
                v:   "1.2.3--amd64",
 
184
                err: "invalid binary version.*",
 
185
        }, {
 
186
                v:   "1.2.3-trusty-",
 
187
                err: "invalid binary version.*",
 
188
        }}
 
189
 
 
190
        for i, test := range parseBinaryTests {
 
191
                c.Logf("test 1: %d", i)
 
192
                got, err := version.ParseBinary(test.v)
 
193
                if test.err != "" {
 
194
                        c.Assert(err, gc.ErrorMatches, test.err)
 
195
                } else {
 
196
                        c.Assert(err, jc.ErrorIsNil)
 
197
                        c.Assert(got, gc.Equals, test.expect)
 
198
                }
 
199
        }
 
200
 
 
201
        for i, test := range parseTests {
 
202
                c.Logf("test 2: %d", i)
 
203
                v := test.v + "-trusty-amd64"
 
204
                got, err := version.ParseBinary(v)
 
205
                expect := version.Binary{
 
206
                        Number: test.expect,
 
207
                        Series: "trusty",
 
208
                        Arch:   "amd64",
 
209
                }
 
210
                if test.err != "" {
 
211
                        c.Assert(err, gc.ErrorMatches, strings.Replace(test.err, "version", "binary version", 1))
 
212
                } else {
 
213
                        c.Assert(err, jc.ErrorIsNil)
 
214
                        c.Assert(got, gc.Equals, expect)
 
215
                }
 
216
        }
 
217
}
 
218
 
 
219
var marshallers = []struct {
 
220
        name      string
 
221
        marshal   func(interface{}) ([]byte, error)
 
222
        unmarshal func([]byte, interface{}) error
 
223
}{{
 
224
        "json",
 
225
        json.Marshal,
 
226
        json.Unmarshal,
 
227
}, {
 
228
        "bson",
 
229
        bson.Marshal,
 
230
        bson.Unmarshal,
 
231
}, {
 
232
        "yaml",
 
233
        goyaml.Marshal,
 
234
        goyaml.Unmarshal,
 
235
}}
 
236
 
 
237
func (*suite) TestBinaryMarshalUnmarshal(c *gc.C) {
 
238
        for _, m := range marshallers {
 
239
                c.Logf("encoding %v", m.name)
 
240
                type doc struct {
 
241
                        Version *version.Binary
 
242
                }
 
243
                // Work around goyaml bug #1096149
 
244
                // SetYAML is not called for non-pointer fields.
 
245
                bp := version.MustParseBinary("1.2.3-trusty-amd64")
 
246
                v := doc{&bp}
 
247
                data, err := m.marshal(&v)
 
248
                c.Assert(err, jc.ErrorIsNil)
 
249
                var bv doc
 
250
                err = m.unmarshal(data, &bv)
 
251
                c.Assert(err, jc.ErrorIsNil)
 
252
                c.Assert(bv, gc.DeepEquals, v)
 
253
        }
 
254
}
 
255
 
 
256
func (*suite) TestNumberMarshalUnmarshal(c *gc.C) {
 
257
        for _, m := range marshallers {
 
258
                c.Logf("encoding %v", m.name)
 
259
                type doc struct {
 
260
                        Version *version.Number
 
261
                }
 
262
                // Work around goyaml bug #1096149
 
263
                // SetYAML is not called for non-pointer fields.
 
264
                np := version.MustParse("1.2.3")
 
265
                v := doc{&np}
 
266
                data, err := m.marshal(&v)
 
267
                c.Assert(err, jc.ErrorIsNil)
 
268
                var nv doc
 
269
                err = m.unmarshal(data, &nv)
 
270
                c.Assert(err, jc.ErrorIsNil)
 
271
                c.Assert(nv, gc.DeepEquals, v)
 
272
        }
 
273
}
 
274
 
 
275
func (*suite) TestParseMajorMinor(c *gc.C) {
 
276
        parseMajorMinorTests := []struct {
 
277
                v           string
 
278
                err         string
 
279
                expectMajor int
 
280
                expectMinor int
 
281
        }{{
 
282
                v:           "1.2",
 
283
                expectMajor: 1,
 
284
                expectMinor: 2,
 
285
        }, {
 
286
                v:           "1",
 
287
                expectMajor: 1,
 
288
                expectMinor: -1,
 
289
        }, {
 
290
                v:   "1.2.3",
 
291
                err: "invalid major.minor version number 1.2.3",
 
292
        }, {
 
293
                v:   "blah",
 
294
                err: `invalid major version number blah: strconv.ParseInt: parsing "blah": invalid syntax`,
 
295
        }}
 
296
 
 
297
        for i, test := range parseMajorMinorTests {
 
298
                c.Logf("test %d", i)
 
299
                major, minor, err := version.ParseMajorMinor(test.v)
 
300
                if test.err != "" {
 
301
                        c.Check(err, gc.ErrorMatches, test.err)
 
302
                } else {
 
303
                        c.Check(err, jc.ErrorIsNil)
 
304
                        c.Check(major, gc.Equals, test.expectMajor)
 
305
                        c.Check(minor, gc.Equals, test.expectMinor)
 
306
                }
 
307
        }
 
308
}