github.com/lineaje-labs/syft@v0.98.1-0.20231227153149-9e393f60ff1b/syft/format/spdxjson/decoder_test.go (about)

     1  package spdxjson
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"path/filepath"
     7  	"testing"
     8  
     9  	"github.com/stretchr/testify/assert"
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/anchore/syft/syft/pkg"
    13  	"github.com/anchore/syft/syft/sbom"
    14  )
    15  
    16  func TestDecoder_Decode(t *testing.T) {
    17  	tests := []struct {
    18  		name          string
    19  		fail          bool
    20  		id            sbom.FormatID
    21  		version       string
    22  		packages      []string
    23  		relationships []string
    24  	}{
    25  		{
    26  			name:          "alpine-3.10.syft.spdx.json",
    27  			id:            ID,
    28  			version:       "2.2",
    29  			packages:      []string{"busybox", "libssl1.1", "ssl_client"},
    30  			relationships: []string{"busybox", "busybox", "libssl1.1", "libssl1.1"},
    31  		},
    32  		{
    33  			name:          "alpine-3.10.vendor.spdx.json",
    34  			id:            ID,
    35  			version:       "2.2",
    36  			packages:      []string{"alpine", "busybox", "ssl_client"},
    37  			relationships: []string{},
    38  		},
    39  		{
    40  			name:    "example7-bin.spdx.json",
    41  			id:      ID,
    42  			version: "2.2",
    43  		},
    44  		{
    45  			name:    "example7-go-module.spdx.json",
    46  			id:      ID,
    47  			version: "2.2",
    48  		},
    49  		{
    50  			name:    "example7-golang.spdx.json",
    51  			id:      ID,
    52  			version: "2.2",
    53  		},
    54  		{
    55  			name:    "example7-third-party-modules.spdx.json",
    56  			id:      ID,
    57  			version: "2.2",
    58  		},
    59  		{
    60  			name:    "bad/example7-bin.spdx.json",
    61  			id:      ID,
    62  			version: "2.2",
    63  			fail:    true,
    64  		},
    65  		{
    66  			name:    "bad/example7-go-module.spdx.json",
    67  			id:      ID,
    68  			version: "2.2",
    69  			fail:    true,
    70  		},
    71  		{
    72  			name:    "bad/example7-golang.spdx.json",
    73  			id:      ID,
    74  			version: "2.2",
    75  			fail:    true,
    76  		},
    77  		{
    78  			name:    "bad/example7-third-party-modules.spdx.json",
    79  			id:      ID,
    80  			version: "2.2",
    81  			fail:    true,
    82  		},
    83  		{
    84  			name: "bad/bad-sbom",
    85  			fail: true,
    86  		},
    87  	}
    88  
    89  	for _, test := range tests {
    90  		t.Run(test.name, func(t *testing.T) {
    91  			reader, err := os.Open(filepath.Join("test-fixtures", "spdx", test.name))
    92  			require.NoError(t, err)
    93  
    94  			dec := NewFormatDecoder()
    95  
    96  			formatID, formatVersion := dec.Identify(reader)
    97  			if test.fail {
    98  				assert.Equal(t, test.id, formatID)
    99  				assert.Equal(t, test.version, formatVersion)
   100  
   101  				_, decodeID, decodeVersion, err := dec.Decode(reader)
   102  				require.Error(t, err)
   103  				assert.Equal(t, test.id, decodeID)
   104  				assert.Equal(t, test.version, decodeVersion)
   105  
   106  				return
   107  			}
   108  			assert.Equal(t, test.id, formatID)
   109  			assert.Equal(t, test.version, formatVersion)
   110  
   111  			s, decodeID, decodeVersion, err := dec.Decode(reader)
   112  
   113  			require.NoError(t, err)
   114  			assert.Equal(t, test.id, decodeID)
   115  			assert.Equal(t, test.version, decodeVersion)
   116  
   117  			if test.packages != nil {
   118  				assert.Equal(t, s.Artifacts.Packages.PackageCount(), len(test.packages))
   119  
   120  			packages:
   121  				for _, pkgName := range test.packages {
   122  					for _, p := range s.Artifacts.Packages.Sorted() {
   123  						if p.Name == pkgName {
   124  							continue packages
   125  						}
   126  					}
   127  					assert.NoError(t, fmt.Errorf("Unable to find package: %s", pkgName))
   128  				}
   129  			}
   130  
   131  			if test.relationships != nil {
   132  				assert.Len(t, s.Relationships, len(test.relationships))
   133  
   134  			relationships:
   135  				for _, pkgName := range test.relationships {
   136  					for _, rel := range s.Relationships {
   137  						p, ok := rel.From.(pkg.Package)
   138  						if ok && p.Name == pkgName {
   139  							continue relationships
   140  						}
   141  					}
   142  					assert.NoError(t, fmt.Errorf("Unable to find relationship: %s", pkgName))
   143  				}
   144  			}
   145  		})
   146  	}
   147  }
   148  
   149  func TestDecoder_Identify(t *testing.T) {
   150  	type testCase struct {
   151  		name    string
   152  		file    string
   153  		id      sbom.FormatID
   154  		version string
   155  	}
   156  
   157  	var cases []testCase
   158  
   159  	for _, version := range SupportedVersions() {
   160  		cases = append(cases, testCase{
   161  			name:    fmt.Sprintf("v%s schema", version),
   162  			file:    fmt.Sprintf("test-fixtures/identify/%s.json", version),
   163  			id:      ID,
   164  			version: version,
   165  		})
   166  	}
   167  
   168  	for _, test := range cases {
   169  		t.Run(test.name, func(t *testing.T) {
   170  			reader, err := os.Open(test.file)
   171  			require.NoError(t, err)
   172  
   173  			dec := NewFormatDecoder()
   174  
   175  			formatID, formatVersion := dec.Identify(reader)
   176  			assert.Equal(t, test.id, formatID)
   177  			assert.Equal(t, test.version, formatVersion)
   178  		})
   179  	}
   180  }