mirror of
https://github.com/anchore/syft.git
synced 2025-11-18 00:43:20 +01:00
963ea594c8
* add policy for empty name and version Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> * default stub version Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> * modifying ids requires augmenting relationships Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com> --------- Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
411 lines
8.2 KiB
Go
411 lines
8.2 KiB
Go
package relationship
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/anchore/syft/syft/artifact"
|
|
"github.com/anchore/syft/syft/file"
|
|
"github.com/anchore/syft/syft/pkg"
|
|
)
|
|
|
|
func Test_Index(t *testing.T) {
|
|
p1 := pkg.Package{
|
|
Name: "pkg-1",
|
|
}
|
|
p2 := pkg.Package{
|
|
Name: "pkg-2",
|
|
}
|
|
p3 := pkg.Package{
|
|
Name: "pkg-3",
|
|
}
|
|
c1 := file.Coordinates{
|
|
RealPath: "/coords/1",
|
|
}
|
|
c2 := file.Coordinates{
|
|
RealPath: "/coords/2",
|
|
}
|
|
|
|
for _, p := range []*pkg.Package{&p1, &p2, &p3} {
|
|
p.SetID()
|
|
}
|
|
|
|
r1 := artifact.Relationship{
|
|
From: p1,
|
|
To: p2,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r2 := artifact.Relationship{
|
|
From: p1,
|
|
To: p3,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r3 := artifact.Relationship{
|
|
From: p1,
|
|
To: c1,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r4 := artifact.Relationship{
|
|
From: p2,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r5 := artifact.Relationship{
|
|
From: p3,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
|
|
dup := artifact.Relationship{
|
|
From: p3,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
|
|
idx := NewIndex(r1, r2, r3, r4, r5, dup)
|
|
require.ElementsMatch(t, slice(r1, r2, r3, r4, r5), idx.All())
|
|
|
|
require.ElementsMatch(t, slice(r1, r4), idx.References(p2))
|
|
require.ElementsMatch(t, slice(r4), idx.References(p2, artifact.ContainsRelationship))
|
|
|
|
require.ElementsMatch(t, slice(r1), idx.To(p2))
|
|
require.ElementsMatch(t, []artifact.Relationship(nil), idx.To(p2, artifact.ContainsRelationship))
|
|
|
|
require.ElementsMatch(t, slice(r4), idx.From(p2))
|
|
require.ElementsMatch(t, slice(r4), idx.From(p2, artifact.ContainsRelationship))
|
|
}
|
|
|
|
func Test_sortOrder(t *testing.T) {
|
|
r1 := artifact.Relationship{
|
|
From: id("1"),
|
|
To: id("2"),
|
|
Type: "1",
|
|
}
|
|
r2 := artifact.Relationship{
|
|
From: id("2"),
|
|
To: id("3"),
|
|
Type: "1",
|
|
}
|
|
r3 := artifact.Relationship{
|
|
From: id("3"),
|
|
To: id("4"),
|
|
Type: "1",
|
|
}
|
|
r4 := artifact.Relationship{
|
|
From: id("1"),
|
|
To: id("2"),
|
|
Type: "2",
|
|
}
|
|
r5 := artifact.Relationship{
|
|
From: id("2"),
|
|
To: id("3"),
|
|
Type: "2",
|
|
}
|
|
dup := artifact.Relationship{
|
|
From: id("2"),
|
|
To: id("3"),
|
|
Type: "2",
|
|
}
|
|
r6 := artifact.Relationship{
|
|
From: id("2"),
|
|
To: id("3"),
|
|
Type: "3",
|
|
}
|
|
|
|
idx := NewIndex(r5, r2, r6, r4, r1, r3, dup)
|
|
require.EqualValues(t, slice(r1, r2, r3, r4, r5, r6), idx.All())
|
|
|
|
require.EqualValues(t, slice(r1, r4), idx.From(id("1")))
|
|
|
|
require.EqualValues(t, slice(r2, r5, r6), idx.To(id("3")))
|
|
|
|
rLast := artifact.Relationship{
|
|
From: id("0"),
|
|
To: id("3"),
|
|
Type: "9999",
|
|
}
|
|
|
|
rFirst := artifact.Relationship{
|
|
From: id("0"),
|
|
To: id("3"),
|
|
Type: "1",
|
|
}
|
|
|
|
rMid := artifact.Relationship{
|
|
From: id("0"),
|
|
To: id("1"),
|
|
Type: "2",
|
|
}
|
|
|
|
idx.Add(rLast, rFirst, rMid)
|
|
|
|
require.EqualValues(t, slice(rFirst, r1, r2, r3, rMid, r4, r5, r6, rLast), idx.All())
|
|
|
|
require.EqualValues(t, slice(rFirst, r2, r5, r6, rLast), idx.To(id("3")))
|
|
}
|
|
|
|
func Test_Coordinates(t *testing.T) {
|
|
p1 := pkg.Package{
|
|
Name: "pkg-1",
|
|
}
|
|
p2 := pkg.Package{
|
|
Name: "pkg-2",
|
|
}
|
|
p3 := pkg.Package{
|
|
Name: "pkg-3",
|
|
}
|
|
c1 := file.Coordinates{
|
|
RealPath: "/coords/1",
|
|
}
|
|
c2 := file.Coordinates{
|
|
RealPath: "/coords/2",
|
|
}
|
|
c3 := file.Coordinates{
|
|
RealPath: "/coords/3",
|
|
}
|
|
c4 := file.Coordinates{
|
|
RealPath: "/coords/4",
|
|
}
|
|
|
|
for _, p := range []*pkg.Package{&p1, &p2, &p3} {
|
|
p.SetID()
|
|
}
|
|
|
|
r1 := artifact.Relationship{
|
|
From: p1,
|
|
To: p2,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r2 := artifact.Relationship{
|
|
From: p1,
|
|
To: p3,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r3 := artifact.Relationship{
|
|
From: p1,
|
|
To: c1,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r4 := artifact.Relationship{
|
|
From: p2,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r5 := artifact.Relationship{
|
|
From: p3,
|
|
To: c1,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r6 := artifact.Relationship{
|
|
From: p3,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r7 := artifact.Relationship{
|
|
From: c1,
|
|
To: c3,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r8 := artifact.Relationship{
|
|
From: c3,
|
|
To: c4,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
|
|
idx := NewIndex(r1, r2, r3, r4, r5, r6, r7, r8)
|
|
|
|
got := idx.Coordinates(p1)
|
|
require.ElementsMatch(t, slice(c1), got)
|
|
|
|
got = idx.Coordinates(p3)
|
|
require.ElementsMatch(t, slice(c1, c2), got)
|
|
}
|
|
|
|
type id string
|
|
|
|
func (i id) ID() artifact.ID {
|
|
return artifact.ID(i)
|
|
}
|
|
|
|
func slice[T any](values ...T) []T {
|
|
return values
|
|
}
|
|
|
|
func TestRemove(t *testing.T) {
|
|
p1 := pkg.Package{Name: "pkg-1"}
|
|
p2 := pkg.Package{Name: "pkg-2"}
|
|
p3 := pkg.Package{Name: "pkg-3"}
|
|
c1 := file.Coordinates{RealPath: "/coords/1"}
|
|
c2 := file.Coordinates{RealPath: "/coords/2"}
|
|
c3 := file.Coordinates{RealPath: "/coords/3"}
|
|
c4 := file.Coordinates{RealPath: "/coords/4"}
|
|
|
|
for _, p := range []*pkg.Package{&p1, &p2, &p3} {
|
|
p.SetID()
|
|
}
|
|
|
|
r1 := artifact.Relationship{
|
|
From: p1,
|
|
To: p2,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r2 := artifact.Relationship{
|
|
From: p1,
|
|
To: p3,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r3 := artifact.Relationship{
|
|
From: p1,
|
|
To: c1,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r4 := artifact.Relationship{
|
|
From: p2,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r5 := artifact.Relationship{
|
|
From: p3,
|
|
To: c1,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r6 := artifact.Relationship{
|
|
From: p3,
|
|
To: c2,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r7 := artifact.Relationship{
|
|
From: c1,
|
|
To: c3,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
r8 := artifact.Relationship{
|
|
From: c3,
|
|
To: c4,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
|
|
index := NewIndex(r1, r2, r3, r4, r5, r6, r7, r8)
|
|
|
|
assert.Equal(t, 8, len(index.All()))
|
|
|
|
// removal of p1 should remove r1, r2, and r3
|
|
index.Remove(p1.ID())
|
|
remaining := index.All()
|
|
|
|
assert.Equal(t, 5, len(remaining))
|
|
assert.NotContains(t, remaining, r1)
|
|
assert.NotContains(t, remaining, r2)
|
|
assert.NotContains(t, remaining, r3)
|
|
|
|
assert.Empty(t, index.From(p1))
|
|
assert.Empty(t, index.To(p1))
|
|
|
|
// removal of c1 should remove r5 and r7
|
|
index.Remove(c1.ID())
|
|
remaining = index.All()
|
|
|
|
// r8 remains since c3->c4 should still exist
|
|
assert.Equal(t, 3, len(remaining))
|
|
assert.NotContains(t, remaining, r5)
|
|
assert.NotContains(t, remaining, r7)
|
|
assert.Contains(t, remaining, r8)
|
|
|
|
assert.Empty(t, index.From(c1))
|
|
assert.Empty(t, index.To(c1))
|
|
|
|
// removal of c3 should remove r8
|
|
index.Remove(c3.ID())
|
|
remaining = index.All()
|
|
|
|
assert.Equal(t, 2, len(remaining))
|
|
assert.Contains(t, remaining, r4)
|
|
assert.Contains(t, remaining, r6)
|
|
|
|
assert.Empty(t, index.From(c3))
|
|
assert.Empty(t, index.To(c3))
|
|
}
|
|
|
|
func TestReplace(t *testing.T) {
|
|
p1 := pkg.Package{Name: "pkg-1"}
|
|
p2 := pkg.Package{Name: "pkg-2"}
|
|
p3 := pkg.Package{Name: "pkg-3"}
|
|
p4 := pkg.Package{Name: "pkg-4"}
|
|
|
|
for _, p := range []*pkg.Package{&p1, &p2, &p3, &p4} {
|
|
p.SetID()
|
|
}
|
|
|
|
r1 := artifact.Relationship{
|
|
From: p1,
|
|
To: p2,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r2 := artifact.Relationship{
|
|
From: p3,
|
|
To: p1,
|
|
Type: artifact.DependencyOfRelationship,
|
|
}
|
|
r3 := artifact.Relationship{
|
|
From: p2,
|
|
To: p3,
|
|
Type: artifact.ContainsRelationship,
|
|
}
|
|
|
|
index := NewIndex(r1, r2, r3)
|
|
|
|
// replace p1 with p4 in the relationships
|
|
index.Replace(p1.ID(), &p4)
|
|
|
|
expectedRels := []artifact.Relationship{
|
|
{
|
|
From: p4, // replaced
|
|
To: p2,
|
|
Type: artifact.DependencyOfRelationship,
|
|
},
|
|
{
|
|
From: p3,
|
|
To: p4, // replaced
|
|
Type: artifact.DependencyOfRelationship,
|
|
},
|
|
{
|
|
From: p2,
|
|
To: p3,
|
|
Type: artifact.ContainsRelationship,
|
|
},
|
|
}
|
|
|
|
compareRelationships(t, expectedRels, index.All())
|
|
}
|
|
|
|
func compareRelationships(t testing.TB, expected, actual []artifact.Relationship) {
|
|
assert.Equal(t, len(expected), len(actual), "number of relationships should match")
|
|
for _, e := range expected {
|
|
found := false
|
|
for _, a := range actual {
|
|
if a.From.ID() == e.From.ID() && a.To.ID() == e.To.ID() && a.Type == e.Type {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
assert.True(t, found, "expected relationship not found: %+v", e)
|
|
}
|
|
}
|
|
|
|
func TestReplace_NoExistingRelations(t *testing.T) {
|
|
p1 := pkg.Package{Name: "pkg-1"}
|
|
p2 := pkg.Package{Name: "pkg-2"}
|
|
|
|
p1.SetID()
|
|
p2.SetID()
|
|
|
|
index := NewIndex()
|
|
|
|
index.Replace(p1.ID(), &p2)
|
|
|
|
allRels := index.All()
|
|
assert.Len(t, allRels, 0)
|
|
}
|