// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
package parser2v2
import (
gordfParser "github.com/spdx/gordf/rdfloader/parser"
"github.com/spdx/tools-golang/spdx"
"reflect"
"testing"
)
func Test_setPackageSupplier(t *testing.T) {
var err error
// TestCase 1: no assertion must set PackageSupplierNOASSERTION field to true
pkg := &spdx.Package2_2{}
err = setPackageSupplier(pkg, "NOASSERTION")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !pkg.PackageSupplierNOASSERTION {
t.Errorf("PackageSupplierNOASSERTION must've been set to true")
}
// TestCase 2: lower-case noassertion must also set the
// PackageSupplierNOASSERTION to true.
pkg = &spdx.Package2_2{}
err = setPackageSupplier(pkg, "noassertion")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !pkg.PackageSupplierNOASSERTION {
t.Errorf("PackageSupplierNOASSERTION must've been set to true")
}
// TestCase 3: invalid input without colon separator. must raise an error
pkg = &spdx.Package2_2{}
input := "string without colon separator"
err = setPackageSupplier(pkg, input)
if err == nil {
t.Errorf("invalid input \"%s\" didn't raise an error", input)
}
// TestCase 4: Valid Person
pkg = &spdx.Package2_2{}
personName := "Rishabh Bhatnagar"
input = "Person: " + personName
err = setPackageSupplier(pkg, input)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pkg.PackageSupplierPerson != personName {
t.Errorf("PackageSupplierPerson should be %s. found %s", personName, pkg.PackageSupplierPerson)
}
// TestCase 5: Valid Organization
pkg = &spdx.Package2_2{}
orgName := "SPDX"
input = "Organization: " + orgName
err = setPackageSupplier(pkg, input)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pkg.PackageSupplierOrganization != orgName {
t.Errorf("PackageSupplierPerson should be %s. found %s", orgName, pkg.PackageSupplierOrganization)
}
// TestCase 6: Invalid EntityType
pkg = &spdx.Package2_2{}
input = "InvalidEntity: entity"
err = setPackageSupplier(pkg, input)
if err == nil {
t.Errorf("invalid entity should've raised an error")
}
}
func Test_setPackageOriginator(t *testing.T) {
var err error
// TestCase 1: no assertion must set PackageSupplierNOASSERTION field to true
pkg := &spdx.Package2_2{}
err = setPackageOriginator(pkg, "NOASSERTION")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !pkg.PackageOriginatorNOASSERTION {
t.Errorf("PackageOriginatorNOASSERTION must've been set to true")
}
// TestCase 2: lower-case noassertion must also set the
// PackageOriginatorNOASSERTION to true.
pkg = &spdx.Package2_2{}
err = setPackageOriginator(pkg, "noassertion")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !pkg.PackageOriginatorNOASSERTION {
t.Errorf("PackageOriginatorNOASSERTION must've been set to true")
}
// TestCase 3: invalid input without colon separator. must raise an error
pkg = &spdx.Package2_2{}
input := "string without colon separator"
err = setPackageOriginator(pkg, input)
if err == nil {
t.Errorf("invalid input \"%s\" didn't raise an error", input)
}
// TestCase 4: Valid Person
pkg = &spdx.Package2_2{}
personName := "Rishabh Bhatnagar"
input = "Person: " + personName
err = setPackageOriginator(pkg, input)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pkg.PackageOriginatorPerson != personName {
t.Errorf("PackageOriginatorPerson should be %s. found %s", personName, pkg.PackageOriginatorPerson)
}
// TestCase 5: Valid Organization
pkg = &spdx.Package2_2{}
orgName := "SPDX"
input = "Organization: " + orgName
err = setPackageOriginator(pkg, input)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
if pkg.PackageOriginatorOrganization != orgName {
t.Errorf("PackageOriginatorOrganization should be %s. found %s", orgName, pkg.PackageOriginatorOrganization)
}
// TestCase 6: Invalid EntityType
pkg = &spdx.Package2_2{}
input = "InvalidEntity: entity"
err = setPackageOriginator(pkg, input)
if err == nil {
t.Errorf("invalid entity should've raised an error")
}
}
func Test_rdfParser2_2_setPackageVerificationCode(t *testing.T) {
var parser *rdfParser2_2
var node *gordfParser.Node
var pkg *spdx.Package2_2
var err error
// TestCase 1: invalid predicate must raise an error
parser, _ = parserFromBodyContent(`
cbceb8b5689b75a584efe35587b5d41bd48820ce
./package.spdx
`)
node = parser.gordfParserObj.Triples[0].Subject
pkg = &spdx.Package2_2{}
err = parser.setPackageVerificationCode(pkg, node)
if err == nil {
t.Errorf("expected an error due to invalid predicate, got ")
}
// TestCase 2: valid input
parser, _ = parserFromBodyContent(`
cbceb8b5689b75a584efe35587b5d41bd48820ce
./package.spdx
`)
node = parser.gordfParserObj.Triples[0].Subject
pkg = &spdx.Package2_2{}
err = parser.setPackageVerificationCode(pkg, node)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
expectedValue := "cbceb8b5689b75a584efe35587b5d41bd48820ce"
if pkg.PackageVerificationCode != expectedValue {
t.Errorf("expected %v, got %v", expectedValue, pkg.PackageVerificationCode)
}
expectedExcludedFile := "./package.spdx"
if pkg.PackageVerificationCodeExcludedFile != expectedExcludedFile {
t.Errorf("expected %v, got %v", expectedExcludedFile, pkg.PackageVerificationCodeExcludedFile)
}
}
func Test_rdfParser2_2_getPackageExternalRef(t *testing.T) {
var extRef *spdx.PackageExternalReference2_2
var err error
var parser *rdfParser2_2
var node *gordfParser.Node
// TestCase 1: invalid reference category
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
`)
node = parser.gordfParserObj.Triples[0].Subject
extRef, err = parser.getPackageExternalRef(node)
if err == nil {
t.Errorf("expected an error due to invalid referenceCategory, got ")
}
// TestCase 2: invalid predicate
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
`)
node = parser.gordfParserObj.Triples[0].Subject
extRef, err = parser.getPackageExternalRef(node)
if err == nil {
t.Errorf("expected an error due to invalid referenceCategory, got ")
}
// TestCase 3: valid example (referenceCategory_security)
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
comment
`)
node = parser.gordfParserObj.Triples[0].Subject
extRef, err = parser.getPackageExternalRef(node)
if err != nil {
t.Fatalf("unexpected error parsing a valid example: %v", err)
}
expectedExtRef := &spdx.PackageExternalReference2_2{
Locator: "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
RefType: "http://spdx.org/rdf/references/cpe23Type",
Category: "SECURITY",
ExternalRefComment: "comment",
}
if !reflect.DeepEqual(extRef, expectedExtRef) {
t.Errorf("expected: \n%+v\ngot: \n%+v", expectedExtRef, extRef)
}
// TestCase 4: valid example (referenceCategory_packageManager)
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
comment
`)
node = parser.gordfParserObj.Triples[0].Subject
extRef, err = parser.getPackageExternalRef(node)
if err != nil {
t.Fatalf("unexpected error parsing a valid example: %v", err)
}
expectedExtRef = &spdx.PackageExternalReference2_2{
Locator: "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
RefType: "http://spdx.org/rdf/references/cpe23Type",
Category: "PACKAGE-MANAGER",
ExternalRefComment: "comment",
}
if !reflect.DeepEqual(extRef, expectedExtRef) {
t.Errorf("expected: \n%+v\ngot: \n%+v", expectedExtRef, extRef)
}
// TestCase 5: valid example (referenceCategory_other)
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
comment
`)
node = parser.gordfParserObj.Triples[0].Subject
extRef, err = parser.getPackageExternalRef(node)
if err != nil {
t.Fatalf("unexpected error parsing a valid example: %v", err)
}
expectedExtRef = &spdx.PackageExternalReference2_2{
Locator: "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*",
RefType: "http://spdx.org/rdf/references/cpe23Type",
Category: "OTHER",
ExternalRefComment: "comment",
}
if !reflect.DeepEqual(extRef, expectedExtRef) {
t.Errorf("expected: \n%+v\ngot: \n%+v", expectedExtRef, extRef)
}
}
func Test_rdfParser2_2_getPackageFromNode(t *testing.T) {
var parser *rdfParser2_2
var node *gordfParser.Node
var err error
// TestCase 1: invalid elementId
parser, _ = parserFromBodyContent(`
time-1.9.tar.gz
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(missing SPDXRef- prefix), found %v", err)
}
// TestCase 2: Invalid License Concluded must raise an error:
parser, _ = parserFromBodyContent(`
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid license), found %v", err)
}
// TestCase 2: Invalid License Declared must raise an error:
parser, _ = parserFromBodyContent(`
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid license), found %v", err)
}
// TestCase 3: Invalid ExternalRef
parser, _ = parserFromBodyContent(`
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid externalRef), found %v", err)
}
// TestCase 4: invalid file must raise an error
parser, _ = parserFromBodyContent(`
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid file), found %v", err)
}
// TestCase 5: invalid predicate must raise an error
parser, _ = parserFromBodyContent(`
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid predicate), found %v", err)
}
// TestCase 6: invalid annotation must raise an error
parser, _ = parserFromBodyContent(`
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid annotation), found %v", err)
}
// TestCase 6: invalid homepage must raise an error
parser, _ = parserFromBodyContent(`
u r i
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err == nil {
t.Errorf("expected an error(invalid homepage uri), found %v", err)
}
// TestCase 7: everything valid
parser, _ = parserFromBodyContent(`
Test Package
1.1.1
time-1.9.tar.gz
Person: Jane Doe (jane.doe@example.com)
Organization: SPDX
true
cbceb8b5689b75a584efe35587b5d41bd48820ce
./package.spdx
75068c26abbed3ad3980685bae21d7202d288317
http://www.openjena.org/
uses glibc-2_11-branch from git://sourceware.org/git/glibc.git.
Other versions available for a commercial license
Package for Testing
Some tags are taken from other spdx autogenerated files
no comments
cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*
attribution text
2011-01-29T18:30:22Z
Package level annotation
Person: Package Commenter
`)
node = parser.gordfParserObj.Triples[0].Subject
_, err = parser.getPackageFromNode(node)
if err != nil {
t.Errorf("error parsing a valid package: %v", err)
}
}
func Test_rdfParser2_2_setFileToPackage(t *testing.T) {
var pkg *spdx.Package2_2
var file *spdx.File2_2
var parser *rdfParser2_2
// TestCase 1: setting to a nil files attribute shouldn't panic.
parser, _ = parserFromBodyContent(``)
pkg = &spdx.Package2_2{}
file = &spdx.File2_2{}
parser.setFileToPackage(pkg, file)
if len(pkg.Files) != 1 {
t.Errorf("expected given package to have one file after setting, got %d", len(pkg.Files))
}
if parser.assocWithPackage[file.FileSPDXIdentifier] != true {
t.Errorf("given file should've been associated with a package, assocWithPackage is false")
}
}
func Test_rdfParser2_2_setPackageChecksum(t *testing.T) {
var parser *rdfParser2_2
var node *gordfParser.Node
var pkg *spdx.Package2_2
var gotChecksumValue, expectedChecksumValue string
var err error
// TestCase 1: invalid checksum algorithm
parser, _ = parserFromBodyContent(`
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
`)
pkg = &spdx.Package2_2{}
node = parser.gordfParserObj.Triples[0].Subject
err = parser.setPackageChecksum(pkg, node)
if err == nil {
t.Error("expected an error due to invalid checksum node, got ")
}
// TestCase 1: valid checksum algorithm which is invalid for package
parser, _ = parserFromBodyContent(`
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
`)
pkg = &spdx.Package2_2{}
node = parser.gordfParserObj.Triples[0].Subject
err = parser.setPackageChecksum(pkg, node)
if err == nil {
t.Error("expected an error due to invalid checksum for package, got ")
}
// TestCase 2: valid checksum (sha1)
parser, _ = parserFromBodyContent(`
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
`)
pkg = &spdx.Package2_2{}
node = parser.gordfParserObj.Triples[0].Subject
err = parser.setPackageChecksum(pkg, node)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
expectedChecksumValue = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"
gotChecksumValue = pkg.PackageChecksumSHA1
if gotChecksumValue != expectedChecksumValue {
t.Errorf("expected: %v, got: %v", expectedChecksumValue, gotChecksumValue)
}
// TestCase 3: valid checksum (sha256)
parser, _ = parserFromBodyContent(`
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
`)
pkg = &spdx.Package2_2{}
node = parser.gordfParserObj.Triples[0].Subject
err = parser.setPackageChecksum(pkg, node)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
expectedChecksumValue = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"
gotChecksumValue = pkg.PackageChecksumSHA256
if gotChecksumValue != expectedChecksumValue {
t.Errorf("expected: %v, got: %v", expectedChecksumValue, gotChecksumValue)
}
// TestCase 4: valid checksum (md5)
parser, _ = parserFromBodyContent(`
2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
`)
pkg = &spdx.Package2_2{}
node = parser.gordfParserObj.Triples[0].Subject
err = parser.setPackageChecksum(pkg, node)
if err != nil {
t.Errorf("unexpected error: %v", err)
}
expectedChecksumValue = "2fd4e1c67a2d28fced849ee1bb76e7391b93eb12"
gotChecksumValue = pkg.PackageChecksumMD5
if gotChecksumValue != expectedChecksumValue {
t.Errorf("expected: %v, got: %v", expectedChecksumValue, gotChecksumValue)
}
}
func Test_setDocumentLocationFromURI(t *testing.T) {
var pkg *spdx.Package2_2
var expectedDocumentLocation, gotDocumentLocation string
var inputURI string
var err error
// TestCase 1: NOASSERTION
inputURI = SPDX_NOASSERTION_SMALL
pkg = &spdx.Package2_2{}
err = setDocumentLocationFromURI(pkg, inputURI)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
expectedDocumentLocation = "NOASSERTION"
gotDocumentLocation = pkg.PackageDownloadLocation
if expectedDocumentLocation != gotDocumentLocation {
t.Errorf("expected: %v, got: %v", expectedDocumentLocation, gotDocumentLocation)
}
// TestCase 2: NONE
inputURI = SPDX_NONE_CAPS
pkg = &spdx.Package2_2{}
err = setDocumentLocationFromURI(pkg, inputURI)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
expectedDocumentLocation = "NONE"
gotDocumentLocation = pkg.PackageDownloadLocation
if expectedDocumentLocation != gotDocumentLocation {
t.Errorf("expected: %v, got: %v", expectedDocumentLocation, gotDocumentLocation)
}
// TestCase 3: valid uri
inputURI = "https://www.gnu.org/software/texinfo/"
pkg = &spdx.Package2_2{}
err = setDocumentLocationFromURI(pkg, inputURI)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
expectedDocumentLocation = "https://www.gnu.org/software/texinfo/"
gotDocumentLocation = pkg.PackageDownloadLocation
if expectedDocumentLocation != gotDocumentLocation {
t.Errorf("expected: %v, got: %v", expectedDocumentLocation, gotDocumentLocation)
}
// TestCase 3: invalid uri
inputURI = " "
pkg = &spdx.Package2_2{}
err = setDocumentLocationFromURI(pkg, inputURI)
if err == nil {
t.Fatalf("expected an error due to invalid uri, got %v", err)
}
}
func Test_setFilesAnalyzed(t *testing.T) {
var pkg *spdx.Package2_2
var err error
// TestCase 1: not a valid bool value:
pkg = &spdx.Package2_2{}
err = setFilesAnalyzed(pkg, "no")
if err == nil {
t.Errorf("expected an error due to invalid bool input, got %v", err)
}
// TestCase 2: valid input
pkg = &spdx.Package2_2{}
err = setFilesAnalyzed(pkg, "true")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !pkg.IsFilesAnalyzedTagPresent {
t.Errorf("should've set IsFilesAnalyzedTagPresent, got: %t", pkg.IsFilesAnalyzedTagPresent)
}
if !pkg.FilesAnalyzed {
t.Errorf("expected: %t, got: %t", true, pkg.FilesAnalyzed)
}
}