Handle architecture variants in package reference lists

deb/reflist.go

@@ -240,7 +240,7 @@ func (l *PackageRefList) Diff(r *PackageRefList, packageCollection *PackageColle
 			if rel < 0 {
 				// compaction: +(,A) -(B,) --> !(A,B)
 				if len(result) > 0 && result[len(result)-1].Left == nil && result[len(result)-1].Right.Name == pl.Name &&
-					result[len(result)-1].Right.Architecture == pl.Architecture {
+					result[len(result)-1].Right.IndexArchitecture() == pl.IndexArchitecture() {
 					result[len(result)-1] = PackageDiff{Left: pl, Right: result[len(result)-1].Right}
 				} else {
 					result = append(result, PackageDiff{Left: pl, Right: nil})
@@ -250,7 +250,7 @@ func (l *PackageRefList) Diff(r *PackageRefList, packageCollection *PackageColle
 			} else {
 				// compaction: -(A,) +(,B) --> !(A,B)
 				if len(result) > 0 && result[len(result)-1].Right == nil && result[len(result)-1].Left.Name == pr.Name &&
-					result[len(result)-1].Left.Architecture == pr.Architecture {
+					result[len(result)-1].Left.IndexArchitecture() == pr.IndexArchitecture() {
 					result[len(result)-1] = PackageDiff{Left: result[len(result)-1].Left, Right: pr}
 				} else {
 					result = append(result, PackageDiff{Left: nil, Right: pr})

deb/reflist_test.go

@@ -412,3 +412,104 @@ func (s *PackageRefListSuite) TestFilterLatestRefsRemovesInvalidVersions(c *C) {
 
 	c.Check(toStrSlice(result), DeepEquals, []string{"Pi386 dpkg 1.0"})
 }
+
+func (s *PackageRefListSuite) TestArchitectureVariantCoexistence(c *C) {
+	normal := &Package{Name: "example", Version: "1.0", Architecture: "amd64", V06Plus: true}
+	variant := &Package{Name: "example", Version: "1.0", Architecture: "amd64", ArchitectureVariant: "amd64v3", V06Plus: true}
+	c.Assert(s.list.Add(normal), IsNil)
+	c.Assert(s.list.Add(variant), IsNil)
+
+	refs := NewPackageRefListFromPackageList(s.list)
+	c.Check(toStrSlice(refs), DeepEquals, []string{
+		"Pamd64 example 1.0 00000000",
+		"Pamd64v3 example 1.0 00000000",
+	})
+	c.Check(refs.Has(normal), Equals, true)
+	c.Check(refs.Has(variant), Equals, true)
+}
+
+func (s *PackageRefListSuite) TestArchitectureVariantMerge(c *C) {
+	normal := &Package{Name: "example", Version: "1.0", Architecture: "amd64", V06Plus: true}
+	variant := &Package{Name: "example", Version: "1.0", Architecture: "amd64", ArchitectureVariant: "amd64v3", V06Plus: true}
+	left, right := NewPackageList(), NewPackageList()
+	c.Assert(left.Add(normal), IsNil)
+	c.Assert(right.Add(variant), IsNil)
+	leftRefs := NewPackageRefListFromPackageList(left)
+	rightRefs := NewPackageRefListFromPackageList(right)
+
+	for _, overrideMatching := range []bool{false, true} {
+		for _, ignoreConflicting := range []bool{false, true} {
+			for _, reverse := range []bool{false, true} {
+				l, r := leftRefs, rightRefs
+				if reverse {
+					l, r = r, l
+				}
+				merged := l.Merge(r, overrideMatching, ignoreConflicting)
+				c.Check(toStrSlice(merged), DeepEquals, []string{
+					"Pamd64 example 1.0 00000000",
+					"Pamd64v3 example 1.0 00000000",
+				}, Commentf("overrideMatching=%v ignoreConflicting=%v reverse=%v", overrideMatching, ignoreConflicting, reverse))
+			}
+		}
+	}
+}
+
+func (s *PackageRefListSuite) TestArchitectureVariantFilterLatestRefs(c *C) {
+	for _, variant := range []string{"", "amd64v3"} {
+		for _, version := range []string{"1.0", "2.0"} {
+			c.Assert(s.list.Add(&Package{
+				Name: "example", Version: version, Architecture: "amd64", ArchitectureVariant: variant, V06Plus: true,
+			}), IsNil)
+		}
+	}
+	refs := NewPackageRefListFromPackageList(s.list)
+	c.Assert(refs.Len(), Equals, 4)
+	refs.FilterLatestRefs()
+	c.Check(toStrSlice(refs), DeepEquals, []string{
+		"Pamd64 example 2.0 00000000",
+		"Pamd64v3 example 2.0 00000000",
+	})
+}
+
+func (s *PackageRefListSuite) TestArchitectureVariantDiffCompaction(c *C) {
+	db, err := goleveldb.NewOpenDB(c.MkDir())
+	c.Assert(err, IsNil)
+	defer func() { c.Check(db.Close(), IsNil) }()
+	coll := NewPackageCollection(db)
+
+	normal := &Package{Name: "example", Version: "1.0", Architecture: "amd64", V06Plus: true}
+	// Equal and differing versions must both remain separate additions/removals.
+	for _, version := range []string{"1.0", "2.0"} {
+		variant := &Package{Name: "example", Version: version, Architecture: "amd64", ArchitectureVariant: "amd64v3", V06Plus: true}
+		c.Assert(coll.Update(normal), IsNil)
+		c.Assert(coll.Update(variant), IsNil)
+		left, right := NewPackageList(), NewPackageList()
+		c.Assert(left.Add(normal), IsNil)
+		c.Assert(right.Add(variant), IsNil)
+		leftRefs := NewPackageRefListFromPackageList(left)
+		rightRefs := NewPackageRefListFromPackageList(right)
+
+		for _, reverse := range []bool{false, true} {
+			l, r := leftRefs, rightRefs
+			if reverse {
+				l, r = r, l
+			}
+			diff, err := l.Diff(r, coll)
+			c.Assert(err, IsNil)
+			context := Commentf("variant version=%s reverse=%v", version, reverse)
+			c.Check(diff, HasLen, 2, context)
+			var removed, added []string
+			for _, entry := range diff {
+				c.Check(entry.Left != nil && entry.Right != nil, Equals, false, context)
+				if entry.Left != nil {
+					removed = append(removed, string(entry.Left.Key("")))
+				}
+				if entry.Right != nil {
+					added = append(added, string(entry.Right.Key("")))
+				}
+			}
+			c.Check(removed, DeepEquals, toStrSlice(l), context)
+			c.Check(added, DeepEquals, toStrSlice(r), context)
+		}
+	}
+}