134 lines
2.8 KiB
Go
134 lines
2.8 KiB
Go
package deps
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestParseRequirement(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
req, err := ParseRequirement("lua5.1 (>= 5.1.5) | luajit")
|
|
if err != nil {
|
|
t.Fatalf("ParseRequirement() error = %v", err)
|
|
}
|
|
|
|
if len(req.Alternatives) != 2 {
|
|
t.Fatalf("expected 2 alternatives, got %d", len(req.Alternatives))
|
|
}
|
|
|
|
first := req.Alternatives[0]
|
|
if first.Name != "lua5.1" || first.Op != OpGreaterOrEqual || first.Version != "5.1.5" {
|
|
t.Fatalf("unexpected first alt: %#v", first)
|
|
}
|
|
second := req.Alternatives[1]
|
|
if second.Name != "luajit" || second.Op != OpAny {
|
|
t.Fatalf("unexpected second alt: %#v", second)
|
|
}
|
|
}
|
|
|
|
func TestParseRequirementsInvalid(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
invalid := []string{
|
|
"",
|
|
" ",
|
|
"bad dep",
|
|
"foo (>> 1)",
|
|
"foo >=",
|
|
"foo |",
|
|
"| foo",
|
|
}
|
|
|
|
for _, raw := range invalid {
|
|
if _, err := ParseRequirement(raw); err == nil {
|
|
t.Fatalf("expected parse error for %q", raw)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompareVersions(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
a, b string
|
|
want int
|
|
}{
|
|
{"1.0", "1.0", 0},
|
|
{"1.0", "1.0.1", -1},
|
|
{"2.0", "1.9", 1},
|
|
{"1.02", "1.2", 0},
|
|
{"1.0~rc1", "1.0", -1},
|
|
{"1:1.0-1", "1.9.9", 1},
|
|
{"2:1.0-1", "1:9.0-9", 1},
|
|
{"1.0-2", "1.0-10", -1},
|
|
{"1.0+dfsg1", "1.0+dfsg2", -1},
|
|
{"1.0a", "1.0", 1},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
got := CompareVersions(tc.a, tc.b)
|
|
if sign(got) != sign(tc.want) {
|
|
t.Fatalf("CompareVersions(%q, %q): want sign %d, got %d", tc.a, tc.b, sign(tc.want), sign(got))
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConstraintMatchesVersion(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
cases := []struct {
|
|
rawDep string
|
|
version string
|
|
want bool
|
|
}{
|
|
{"foo", "1.0", true},
|
|
{"foo=1.0", "1.0", true},
|
|
{"foo=1.0", "1.1", false},
|
|
{"foo>=1.0", "1.2", true},
|
|
{"foo>=1.0", "0.9", false},
|
|
{"foo<2.0", "1.9", true},
|
|
{"foo<2.0", "2.0", false},
|
|
{"foo (<= 2.1)", "2.1", true},
|
|
}
|
|
|
|
for _, tc := range cases {
|
|
req, err := ParseRequirement(tc.rawDep)
|
|
if err != nil {
|
|
t.Fatalf("ParseRequirement(%q) error = %v", tc.rawDep, err)
|
|
}
|
|
got := req.Alternatives[0].MatchesVersion(tc.version)
|
|
if got != tc.want {
|
|
t.Fatalf("MatchesVersion(%q, %q): want %v, got %v", tc.rawDep, tc.version, tc.want, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestParseRequirements(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
input := []string{"foo", "bar>=1.2", "baz | qux"}
|
|
got, err := ParseRequirements(input)
|
|
if err != nil {
|
|
t.Fatalf("ParseRequirements() error = %v", err)
|
|
}
|
|
if len(got) != 3 {
|
|
t.Fatalf("expected 3 requirements, got %d", len(got))
|
|
}
|
|
|
|
names := []string{got[0].Alternatives[0].Name, got[1].Alternatives[0].Name, got[2].Alternatives[0].Name}
|
|
if want := []string{"foo", "bar", "baz"}; !reflect.DeepEqual(names, want) {
|
|
t.Fatalf("unexpected parsed names:\nwant: %#v\ngot: %#v", want, names)
|
|
}
|
|
}
|
|
|
|
func sign(v int) int {
|
|
switch {
|
|
case v < 0:
|
|
return -1
|
|
case v > 0:
|
|
return 1
|
|
default:
|
|
return 0
|
|
}
|
|
}
|