| // Copyright 2018 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| package mvs |
| |
| import ( |
| "fmt" |
| "reflect" |
| "strings" |
| "testing" |
| |
| "golang.org/x/mod/module" |
| ) |
| |
| var tests = ` |
| # Scenario from blog. |
| name: blog |
| A: B1 C2 |
| B1: D3 |
| C1: D2 |
| C2: D4 |
| C3: D5 |
| C4: G1 |
| D2: E1 |
| D3: E2 |
| D4: E2 F1 |
| D5: E2 |
| G1: C4 |
| A2: B1 C4 D4 |
| build A: A B1 C2 D4 E2 F1 |
| upgrade* A: A B1 C4 D5 E2 F1 G1 |
| upgrade A C4: A B1 C4 D4 E2 F1 G1 |
| downgrade A2 D2: A2 C4 D2 |
| |
| name: trim |
| A: B1 C2 |
| B1: D3 |
| C2: B2 |
| B2: |
| build A: A B2 C2 D3 |
| |
| # Cross-dependency between D and E. |
| # No matter how it arises, should get result of merging all build lists via max, |
| # which leads to including both D2 and E2. |
| |
| name: cross1 |
| A: B C |
| B: D1 |
| C: D2 |
| D1: E2 |
| D2: E1 |
| build A: A B C D2 E2 |
| |
| name: cross1V |
| A: B2 C D2 E1 |
| B1: |
| B2: D1 |
| C: D2 |
| D1: E2 |
| D2: E1 |
| build A: A B2 C D2 E2 |
| |
| name: cross1U |
| A: B1 C |
| B1: |
| B2: D1 |
| C: D2 |
| D1: E2 |
| D2: E1 |
| build A: A B1 C D2 E1 |
| upgrade A B2: A B2 C D2 E2 |
| |
| name: cross1R |
| A: B C |
| B: D2 |
| C: D1 |
| D1: E2 |
| D2: E1 |
| build A: A B C D2 E2 |
| |
| name: cross1X |
| A: B C |
| B: D1 E2 |
| C: D2 |
| D1: E2 |
| D2: E1 |
| build A: A B C D2 E2 |
| |
| name: cross2 |
| A: B D2 |
| B: D1 |
| D1: E2 |
| D2: E1 |
| build A: A B D2 E2 |
| |
| name: cross2X |
| A: B D2 |
| B: D1 E2 |
| C: D2 |
| D1: E2 |
| D2: E1 |
| build A: A B D2 E2 |
| |
| name: cross3 |
| A: B D2 E1 |
| B: D1 |
| D1: E2 |
| D2: E1 |
| build A: A B D2 E2 |
| |
| name: cross3X |
| A: B D2 E1 |
| B: D1 E2 |
| D1: E2 |
| D2: E1 |
| build A: A B D2 E2 |
| |
| # Should not get E2 here, because B has been updated |
| # not to depend on D1 anymore. |
| name: cross4 |
| A1: B1 D2 |
| A2: B2 D2 |
| B1: D1 |
| B2: D2 |
| D1: E2 |
| D2: E1 |
| build A1: A1 B1 D2 E2 |
| build A2: A2 B2 D2 E1 |
| |
| # But the upgrade from A1 preserves the E2 dep explicitly. |
| upgrade A1 B2: A1 B2 D2 E2 |
| upgradereq A1 B2: B2 E2 |
| |
| name: cross5 |
| A: D1 |
| D1: E2 |
| D2: E1 |
| build A: A D1 E2 |
| upgrade* A: A D2 E2 |
| upgrade A D2: A D2 E2 |
| upgradereq A D2: D2 E2 |
| |
| name: cross6 |
| A: D2 |
| D1: E2 |
| D2: E1 |
| build A: A D2 E1 |
| upgrade* A: A D2 E2 |
| upgrade A E2: A D2 E2 |
| |
| name: cross7 |
| A: B C |
| B: D1 |
| C: E1 |
| D1: E2 |
| E1: D2 |
| build A: A B C D2 E2 |
| |
| # golang.org/issue/31248: |
| # Even though we select X2, the requirement on I1 |
| # via X1 should be preserved. |
| name: cross8 |
| M: A1 B1 |
| A1: X1 |
| B1: X2 |
| X1: I1 |
| X2: |
| build M: M A1 B1 I1 X2 |
| |
| # Upgrade from B1 to B2 should not drop the transitive dep on D. |
| name: drop |
| A: B1 C1 |
| B1: D1 |
| B2: |
| C2: |
| D2: |
| build A: A B1 C1 D1 |
| upgrade* A: A B2 C2 D2 |
| |
| name: simplify |
| A: B1 C1 |
| B1: C2 |
| C1: D1 |
| C2: |
| build A: A B1 C2 D1 |
| |
| name: up1 |
| A: B1 C1 |
| B1: |
| B2: |
| B3: |
| B4: |
| B5.hidden: |
| C2: |
| C3: |
| build A: A B1 C1 |
| upgrade* A: A B4 C3 |
| |
| name: up2 |
| A: B5.hidden C1 |
| B1: |
| B2: |
| B3: |
| B4: |
| B5.hidden: |
| C2: |
| C3: |
| build A: A B5.hidden C1 |
| upgrade* A: A B5.hidden C3 |
| |
| name: down1 |
| A: B2 |
| B1: C1 |
| B2: C2 |
| build A: A B2 C2 |
| downgrade A C1: A B1 |
| |
| name: down2 |
| A: B2 E2 |
| B1: |
| B2: C2 F2 |
| C1: |
| D1: |
| C2: D2 E2 |
| D2: B2 |
| E2: D2 |
| E1: |
| F1: |
| downgrade A F1: A B1 E1 |
| |
| name: down3 |
| A: |
| |
| # golang.org/issue/25542. |
| name: noprev1 |
| A: B4 C2 |
| B2.hidden: |
| C2: |
| downgrade A B2.hidden: A B2.hidden C2 |
| |
| name: noprev2 |
| A: B4 C2 |
| B2.hidden: |
| B1: |
| C2: |
| downgrade A B2.hidden: A B2.hidden C2 |
| |
| name: noprev3 |
| A: B4 C2 |
| B3: |
| B2.hidden: |
| C2: |
| downgrade A B2.hidden: A B2.hidden C2 |
| |
| # Cycles involving the target. |
| |
| # The target must be the newest version of itself. |
| name: cycle1 |
| A: B1 |
| B1: A1 |
| B2: A2 |
| B3: A3 |
| build A: A B1 |
| upgrade A B2: A B2 |
| upgrade* A: A B3 |
| |
| # golang.org/issue/29773: |
| # Requirements of older versions of the target |
| # must be carried over. |
| name: cycle2 |
| A: B1 |
| A1: C1 |
| A2: D1 |
| B1: A1 |
| B2: A2 |
| C1: A2 |
| C2: |
| D2: |
| build A: A B1 C1 D1 |
| upgrade* A: A B2 C2 D2 |
| |
| # Cycles with multiple possible solutions. |
| # (golang.org/issue/34086) |
| name: cycle3 |
| M: A1 C2 |
| A1: B1 |
| B1: C1 |
| B2: C2 |
| C1: |
| C2: B2 |
| build M: M A1 B2 C2 |
| req M: A1 B2 |
| req M A: A1 B2 |
| req M C: A1 C2 |
| |
| # Requirement minimization. |
| |
| name: req1 |
| A: B1 C1 D1 E1 F1 |
| B1: C1 E1 F1 |
| req A: B1 D1 |
| req A C: B1 C1 D1 |
| |
| name: req2 |
| A: G1 H1 |
| G1: H1 |
| H1: G1 |
| req A: G1 |
| req A G: G1 |
| req A H: H1 |
| |
| name: req3 |
| M: A1 B1 |
| A1: X1 |
| B1: X2 |
| X1: I1 |
| X2: |
| req M: A1 B1 |
| ` |
| |
| func Test(t *testing.T) { |
| var ( |
| name string |
| reqs reqsMap |
| fns []func(*testing.T) |
| ) |
| flush := func() { |
| if name != "" { |
| t.Run(name, func(t *testing.T) { |
| for _, fn := range fns { |
| fn(t) |
| } |
| }) |
| } |
| } |
| m := func(s string) module.Version { |
| return module.Version{Path: s[:1], Version: s[1:]} |
| } |
| ms := func(list []string) []module.Version { |
| var mlist []module.Version |
| for _, s := range list { |
| mlist = append(mlist, m(s)) |
| } |
| return mlist |
| } |
| checkList := func(t *testing.T, desc string, list []module.Version, err error, val string) { |
| if err != nil { |
| t.Fatalf("%s: %v", desc, err) |
| } |
| vs := ms(strings.Fields(val)) |
| if !reflect.DeepEqual(list, vs) { |
| t.Errorf("%s = %v, want %v", desc, list, vs) |
| } |
| } |
| |
| for _, line := range strings.Split(tests, "\n") { |
| line = strings.TrimSpace(line) |
| if strings.HasPrefix(line, "#") || line == "" { |
| continue |
| } |
| i := strings.Index(line, ":") |
| if i < 0 { |
| t.Fatalf("missing colon: %q", line) |
| } |
| key := strings.TrimSpace(line[:i]) |
| val := strings.TrimSpace(line[i+1:]) |
| if key == "" { |
| t.Fatalf("missing key: %q", line) |
| } |
| kf := strings.Fields(key) |
| switch kf[0] { |
| case "name": |
| if len(kf) != 1 { |
| t.Fatalf("name takes no arguments: %q", line) |
| } |
| flush() |
| reqs = make(reqsMap) |
| fns = nil |
| name = val |
| continue |
| case "build": |
| if len(kf) != 2 { |
| t.Fatalf("build takes one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := BuildList(m(kf[1]), reqs) |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| case "upgrade*": |
| if len(kf) != 2 { |
| t.Fatalf("upgrade* takes one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := UpgradeAll(m(kf[1]), reqs) |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| case "upgradereq": |
| if len(kf) < 2 { |
| t.Fatalf("upgrade takes at least one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := Upgrade(m(kf[1]), reqs, ms(kf[2:])...) |
| if err == nil { |
| // Copy the reqs map, but substitute the upgraded requirements in |
| // place of the target's original requirements. |
| upReqs := make(reqsMap, len(reqs)) |
| for m, r := range reqs { |
| upReqs[m] = r |
| } |
| upReqs[m(kf[1])] = list |
| |
| list, err = Req(m(kf[1]), nil, upReqs) |
| } |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| case "upgrade": |
| if len(kf) < 2 { |
| t.Fatalf("upgrade takes at least one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := Upgrade(m(kf[1]), reqs, ms(kf[2:])...) |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| case "downgrade": |
| if len(kf) < 2 { |
| t.Fatalf("downgrade takes at least one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := Downgrade(m(kf[1]), reqs, ms(kf[1:])...) |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| case "req": |
| if len(kf) < 2 { |
| t.Fatalf("req takes at least one argument: %q", line) |
| } |
| fns = append(fns, func(t *testing.T) { |
| list, err := Req(m(kf[1]), kf[2:], reqs) |
| checkList(t, key, list, err, val) |
| }) |
| continue |
| } |
| if len(kf) == 1 && 'A' <= key[0] && key[0] <= 'Z' { |
| var rs []module.Version |
| for _, f := range strings.Fields(val) { |
| r := m(f) |
| if reqs[r] == nil { |
| reqs[r] = []module.Version{} |
| } |
| rs = append(rs, r) |
| } |
| reqs[m(key)] = rs |
| continue |
| } |
| t.Fatalf("bad line: %q", line) |
| } |
| flush() |
| } |
| |
| type reqsMap map[module.Version][]module.Version |
| |
| func (r reqsMap) Max(v1, v2 string) string { |
| if v1 == "none" || v2 == "" { |
| return v2 |
| } |
| if v2 == "none" || v1 == "" { |
| return v1 |
| } |
| if v1 < v2 { |
| return v2 |
| } |
| return v1 |
| } |
| |
| func (r reqsMap) Upgrade(m module.Version) (module.Version, error) { |
| var u module.Version |
| for k := range r { |
| if k.Path == m.Path && u.Version < k.Version && !strings.HasSuffix(k.Version, ".hidden") { |
| u = k |
| } |
| } |
| if u.Path == "" { |
| return module.Version{}, fmt.Errorf("missing module: %v", module.Version{Path: m.Path}) |
| } |
| return u, nil |
| } |
| |
| func (r reqsMap) Previous(m module.Version) (module.Version, error) { |
| var p module.Version |
| for k := range r { |
| if k.Path == m.Path && p.Version < k.Version && k.Version < m.Version && !strings.HasSuffix(k.Version, ".hidden") { |
| p = k |
| } |
| } |
| if p.Path == "" { |
| return module.Version{Path: m.Path, Version: "none"}, nil |
| } |
| return p, nil |
| } |
| |
| func (r reqsMap) Required(m module.Version) ([]module.Version, error) { |
| rr, ok := r[m] |
| if !ok { |
| return nil, fmt.Errorf("missing module: %v", m) |
| } |
| return rr, nil |
| } |