Add nested archive cataloging (#5260)

Signed-off-by: Kudryavcev Nikolay <kydry.nikolau@gmail.com>
Signed-off-by: Thomas Bechtold <thomasbechtold@jpberlin.de>
Signed-off-by: Alex Goodman <wagoodman@users.noreply.github.com>
Signed-off-by: Keith Zantow <kzantow@gmail.com>
Co-authored-by: Kudryavcev Nikolay <kydry.nikolau@gmail.com>
Co-authored-by: Thomas Bechtold <thomasbechtold@jpberlin.de>
Co-authored-by: Alex Goodman <wagoodman@users.noreply.github.com>

syft/file/location_test.go

@@ -1,9 +1,11 @@
 package file
 
 import (
+	"encoding/json"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 
 	"github.com/anchore/stereoscope/pkg/file"
 )
@@ -48,3 +50,73 @@ func TestLocation_ID(t *testing.T) {
 	}
 
 }
+
+func TestLocation_fullPathIsIdentity(t *testing.T) {
+	a := NewLocationFromCoordinates(Coordinates{RealPath: "/a.jar", FullPath: "/a.jar!/META-INF/MANIFEST.MF"})
+	b := NewLocationFromCoordinates(Coordinates{RealPath: "/b.jar", FullPath: "/b.jar!/META-INF/MANIFEST.MF"})
+
+	assert.False(t, a.Equals(b))
+	assert.NotEqual(t, a.String(), b.String())
+	assert.Contains(t, a.String(), `RealPath="/a.jar"`)
+}
+
+func TestLocation_JSON(t *testing.T) {
+	tests := []struct {
+		name     string
+		location Location
+		expected string
+	}{
+		{
+			name:     "a file outside an archive writes no fullPath",
+			location: NewVirtualLocationFromDirectory("/etc/os-release", "/etc/link", file.Reference{}).WithAnnotation("k", "v"),
+			expected: `{"path":"/etc/os-release","accessPath":"/etc/link","annotations":{"k":"v"}}`,
+		},
+		{
+			name:     "a file within an archive writes its full path",
+			location: NewLocationFromCoordinates(Coordinates{RealPath: "/app.war", FileSystemID: "layer", FullPath: "/app.war!/META-INF/MANIFEST.MF"}),
+			expected: `{"path":"/app.war","layerID":"layer","fullPath":"/app.war!/META-INF/MANIFEST.MF","accessPath":"/app.war!/META-INF/MANIFEST.MF"}`,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			data, err := json.Marshal(tt.location)
+			require.NoError(t, err)
+			assert.JSONEq(t, tt.expected, string(data))
+
+			var decoded Location
+			require.NoError(t, json.Unmarshal(data, &decoded))
+			assert.Equal(t, tt.location.Coordinates, decoded.Coordinates, "decoding fills FullPath back in")
+			assert.Equal(t, tt.location.AccessPath, decoded.AccessPath)
+
+			data, err = json.Marshal(tt.location.Coordinates)
+			require.NoError(t, err)
+			var coordinates Coordinates
+			require.NoError(t, json.Unmarshal(data, &coordinates))
+			assert.Equal(t, tt.location.Coordinates, coordinates)
+		})
+	}
+}
+
+func TestCoordinates_ID_unchangedByTopLevelFullRealPath(t *testing.T) {
+	assert.Equal(t, Coordinates{RealPath: "/a"}.ID(), NewCoordinates("/a", "").ID())
+	assert.NotEqual(t, NewCoordinates("/a", "").ID(), Coordinates{RealPath: "/a", FullPath: "/a!/b"}.ID())
+}
+
+func TestCoordinates_LocalPath(t *testing.T) {
+	assert.Equal(t, "/a.jar", NewCoordinates("/a.jar", "").LocalPath())
+	assert.Equal(t, "/a.jar", Coordinates{RealPath: "/a.jar"}.LocalPath())
+	assert.Equal(t, "/META-INF/MANIFEST.MF", Coordinates{RealPath: "/a.war", FullPath: "/a.war!/lib/b.jar!/META-INF/MANIFEST.MF"}.LocalPath())
+	assert.Equal(t, "/data/Hello!/world.txt", NewCoordinates("/data/Hello!/world.txt", "").LocalPath(), "a separator in a real path is not an archive boundary")
+	assert.Equal(t, "/data/Hello!/world.txt", Coordinates{RealPath: "/data/Hello!/world.txt", FullPath: "/data/Hello!/world.txt"}.LocalPath())
+	assert.Equal(t, "/x.txt", Coordinates{RealPath: "/data/Hello!/a.zip", FullPath: "/data/Hello!/a.zip!/x.txt"}.LocalPath())
+	assert.Equal(t, "/x.txt", Coordinates{RealPath: "/data/Hello!/a.zip", FullPath: "/data/Hello!/a.zip!/b.jar!/x.txt"}.LocalPath())
+}
+
+func TestLocation_Path(t *testing.T) {
+	nested := Coordinates{RealPath: "/a.war", FullPath: "/a.war!/lib/b.jar!/META-INF/MANIFEST.MF"}
+	assert.Equal(t, "/a.jar", NewLocation("/a.jar").Path())
+	assert.Equal(t, "/link", NewVirtualLocation("/a.jar", "/link").Path())
+	assert.Equal(t, nested.FullPath, NewLocationFromCoordinates(nested).Path())
+	assert.Equal(t, nested.FullPath, Location{LocationData: LocationData{Coordinates: nested}}.Path(), "a nested location without an access path is still full")
+	assert.Equal(t, nested.FullPath, NewVirtualLocationFromCoordinates(nested, nested.FullPath).Path())
+}