[vpython] Add conditional packages based on PEP425

vpython/spec/match_test.go

+// Copyright 2017 The LUCI Authors. All rights reserved.
+// Use of this source code is governed under the Apache License, Version 2.0
+// that can be found in the LICENSE file.
+
+package spec
+
+import (
+        "fmt"
+        "strings"
+        "testing"
+
+        "github.com/luci/luci-go/vpython/api/vpython"
+
+        . "github.com/smartystreets/goconvey/convey"
+)
+
+func mkTag(version, abi, arch string) *vpython.Pep425Tag {
+        return &vpython.Pep425Tag{
+                Version: version,
+                Abi:     abi,
+                Arch:    arch,

[qyearsley, 2017/06/05 20:20:08]

Note, I guess Pep425Tag is defined elsewhere(?) but it might be worth noting
that in the PEP425 docs these are called "Python", "ABI" and "Platform" rather
than "Version", "Abi", and "Arch" (I think)

[dnj, 2017/06/06 13:59:10]

Yeah, unfortunately fixing these field names would break existing text protobuf
naming, so it's not trivial. Also beyond the scope of the CL. Probably worth
spending the time to do though.

[dnj, 2017/06/06 14:29:34]

FYI, filed this to fix naming: https://codereview.chromium.org/2927573002/

+        }
+}
+
+func tagString(tags []*vpython.Pep425Tag) string {
+        parts := make([]string, len(tags))
+        for i, tag := range tags {
+                parts[i] = tag.TagString()
+        }
+        return strings.Join(parts, ", ")
+}
+
+func TestPEP425Matches(t *testing.T) {
+        t.Parallel()
+
+        testCases := []struct {
+                tags       []*vpython.Pep425Tag
+                matches    []*vpython.Pep425Tag
+                notMatches []*vpython.Pep425Tag
+        }{
+                {
+                        tags: nil,
+                        notMatches: []*vpython.Pep425Tag{
+                                mkTag("", "", ""),
+                                mkTag("foo", "bar", "baz"),
+                        },
+                },
+                {
+                        tags: []*vpython.Pep425Tag{
+                                mkTag("fooV", "fooABI", "fooArch"),

[iannucci, 2017/06/05 19:02:47]

it would be nice to use more realistic looking things here

+                                mkTag("bazV", "bazABI", "bazArch"),
+                        },
+                        matches: []*vpython.Pep425Tag{
+                                mkTag("fooV", "", ""),
+                                mkTag("", "fooABI", ""),
+                                mkTag("", "", "fooArch"),
+                                mkTag("bazV", "", ""),
+                                mkTag("", "bazABI", ""),
+                                mkTag("", "", "bazArch"),
+                                mkTag("", "fooABI", "fooArch"),
+                        },
+                        notMatches: []*vpython.Pep425Tag{
+                                mkTag("", "", ""),
+                                mkTag("fooV", "fooABI", "otherArch"),
+                                mkTag("fooV", "fooABI", "bazArch"),
+                        },
+                },
+                {
+                        tags: []*vpython.Pep425Tag{
+                                mkTag("fooV", "fooABI", ""),
+                        },
+                        matches: []*vpython.Pep425Tag{
+                                mkTag("fooV", "fooABI", ""),
+                        },
+                        notMatches: []*vpython.Pep425Tag{
+                                mkTag("", "", ""),
+                                mkTag("fooV", "fooABI", "otherArch"),
+                        },
+                },
+        }
+
+        Convey(`Test cases for PEP425 tag matching`, t, func() {
+                for _, tc := range testCases {
+                        Convey(fmt.Sprintf(`With system tags: %s`, tagString(tc.tags)), func() {

[qyearsley, 2017/06/05 20:20:08]

General question:
If the test passes then normally when the test is run, is anything printed?

[dnj, 2017/06/06 13:59:10]

If you run with "-v" for verbose, then the test case names are printed.

[dnj, 2017/06/06 13:59:10]

If you run with "-v" for verbose, then the test case names are printed.

+                                for _, m := range tc.matches {
+                                        Convey(fmt.Sprintf(`Tag matches: %s`, m.TagString()), func() {
+                                                So(PEP425Matches(m, tc.tags), ShouldBeTrue)
+                                        })
+                                }
+
+                                for _, m := range tc.notMatches {
+                                        Convey(fmt.Sprintf(`Tag doesn't match: %s`, m.TagString()), func() {
+                                                So(PEP425Matches(m, tc.tags), ShouldBeFalse)
+                                        })
+                                }
+                        })
+                }
+        })
+}
+
+func TestPackageMatches(t *testing.T) {
+        t.Parallel()
+
+        mkPkg := func(name string, tags ...*vpython.Pep425Tag) *vpython.Spec_Package {
+                return &vpython.Spec_Package{
+                        Name:     name,
+                        MatchTag: tags,
+                }
+        }
+
+        testCases := []struct {
+                tags         []*vpython.Pep425Tag
+                matchPkgs    []*vpython.Spec_Package
+                notMatchPkgs []*vpython.Spec_Package
+        }{
+                {
+                        tags: nil,
+                        matchPkgs: []*vpython.Spec_Package{
+                                mkPkg("NoTags"),
+                        },
+                        notMatchPkgs: []*vpython.Spec_Package{
+                                mkPkg("EmptyMatch", mkTag("", "", "")),
+                                mkPkg("MissingMatch", mkTag("foo", "bar", "baz")),
+                        },
+                },
+                {
+                        tags: []*vpython.Pep425Tag{
+                                mkTag("fooV", "fooABI", "fooArch"),
+                                mkTag("barV", "barABI", "barArch"),
+                        },
+                        matchPkgs: []*vpython.Spec_Package{
+                                mkPkg("NoTags"),
+                                mkPkg("OneMatchingTag", mkTag("fooV", "", "")),
+                                mkPkg("MultipleMatchingTag", mkTag("fooV", "", ""), mkTag("", "barABI", "")),
+                        },
+                        notMatchPkgs: []*vpython.Spec_Package{
+                                mkPkg("EmptyMatch", mkTag("", "", "")),
+                                mkPkg("MissingMatch", mkTag("none", "none", "none")),
+                        },
+                },
+        }
+
+        Convey(`Test cases for package tag matching`, t, func() {
+                for _, tc := range testCases {
+                        Convey(fmt.Sprintf(`With system tags: %s`, tagString(tc.tags)), func() {
+                                for _, m := range tc.matchPkgs {
+                                        Convey(fmt.Sprintf(`Package %q matches: %s`, m.Name, tagString(m.MatchTag)), func() {
+                                                So(PackageMatches(m, tc.tags), ShouldBeTrue)
+                                        })
+                                }
+
+                                for _, m := range tc.notMatchPkgs {
+                                        Convey(fmt.Sprintf(`Package %q doesn't match: %s`, m.Name, tagString(m.MatchTag)), func() {
+                                                So(PackageMatches(m, tc.tags), ShouldBeFalse)
+                                        })
+                                }
+                        })
+                }
+        })
+}