diff options
author | Steve Winslow <steve@swinslow.net> | 2020-06-14 14:54:46 -0400 |
---|---|---|
committer | Steve Winslow <steve@swinslow.net> | 2020-06-14 14:54:46 -0400 |
commit | 2d11b095ab5ab903b3c5712e69a139abe1cdc69e (patch) | |
tree | 6563302986dd904fa5433dfd4a05fd3a7c7cfb21 /tvloader/parser2v2 | |
parent | 5f6fa11c4a328ae3689d71ae13d245df36525bd1 (diff) | |
download | spdx-tools-2d11b095ab5ab903b3c5712e69a139abe1cdc69e.tar.gz |
Add tvloader and tests for 2.2
Signed-off-by: Steve Winslow <steve@swinslow.net>
Diffstat (limited to 'tvloader/parser2v2')
21 files changed, 5338 insertions, 0 deletions
diff --git a/tvloader/parser2v2/parse_annotation.go b/tvloader/parser2v2/parse_annotation.go new file mode 100644 index 0000000..8cd5b76 --- /dev/null +++ b/tvloader/parser2v2/parse_annotation.go @@ -0,0 +1,43 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" +) + +func (parser *tvParser2_2) parsePairForAnnotation2_2(tag string, value string) error { + if parser.ann == nil { + return fmt.Errorf("no annotation struct created in parser ann pointer") + } + + switch tag { + case "Annotator": + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + if subkey == "Person" || subkey == "Organization" || subkey == "Tool" { + parser.ann.AnnotatorType = subkey + parser.ann.Annotator = subvalue + return nil + } + return fmt.Errorf("unrecognized Annotator type %v", subkey) + case "AnnotationDate": + parser.ann.AnnotationDate = value + case "AnnotationType": + parser.ann.AnnotationType = value + case "SPDXREF": + deID, err := extractDocElementID(value) + if err != nil { + return err + } + parser.ann.AnnotationSPDXIdentifier = deID + case "AnnotationComment": + parser.ann.AnnotationComment = value + default: + return fmt.Errorf("received unknown tag %v in Annotation section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_annotation_test.go b/tvloader/parser2v2/parse_annotation_test.go new file mode 100644 index 0000000..7a12adf --- /dev/null +++ b/tvloader/parser2v2/parse_annotation_test.go @@ -0,0 +1,158 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Annotation section tests ===== +func TestParser2_2FailsIfAnnotationNotSet(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePairForAnnotation2_2("Annotator", "Person: John Doe (jdoe@example.com)") + if err == nil { + t.Errorf("expected error when calling parsePairFromAnnotation2_2 without setting ann pointer") + } +} + +func TestParser2_2FailsIfAnnotationTagUnknown(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + // start with valid annotator + err := parser.parsePair2_2("Annotator", "Person: John Doe (jdoe@example.com)") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // parse invalid tag, using parsePairForAnnotation2_2( + err = parser.parsePairForAnnotation2_2("blah", "oops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfAnnotationFieldsWithoutAnnotation(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("AnnotationDate", "2018-09-15T17:25:00Z") + if err == nil { + t.Errorf("expected error when calling parsePair2_2 for AnnotationDate without Annotator first") + } + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err == nil { + t.Errorf("expected error when calling parsePair2_2 for AnnotationType without Annotator first") + } + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err == nil { + t.Errorf("expected error when calling parsePair2_2 for SPDXREF without Annotator first") + } + err = parser.parsePair2_2("AnnotationComment", "comment whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2 for AnnotationComment without Annotator first") + } +} + +func TestParser2_2CanParseAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // Annotator without email address + err := parser.parsePair2_2("Annotator", "Person: John Doe") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.ann.Annotator != "John Doe" { + t.Errorf("got %v for Annotator, expected John Doe", parser.ann.Annotator) + } + if parser.ann.AnnotatorType != "Person" { + t.Errorf("got %v for AnnotatorType, expected Person", parser.ann.AnnotatorType) + } + + // Annotation Date + dt := "2018-09-15T17:32:00Z" + err = parser.parsePair2_2("AnnotationDate", dt) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.ann.AnnotationDate != dt { + t.Errorf("got %v for AnnotationDate, expected %v", parser.ann.AnnotationDate, dt) + } + + // Annotation type + aType := "REVIEW" + err = parser.parsePair2_2("AnnotationType", aType) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.ann.AnnotationType != aType { + t.Errorf("got %v for AnnotationType, expected %v", parser.ann.AnnotationType, aType) + } + + // SPDX Identifier Reference + ref := "SPDXRef-30" + err = parser.parsePair2_2("SPDXREF", ref) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + deID := parser.ann.AnnotationSPDXIdentifier + if deID.DocumentRefID != "" || deID.ElementRefID != "30" { + t.Errorf("got %v for SPDXREF, expected %v", parser.ann.AnnotationSPDXIdentifier, "30") + } + + // Annotation Comment + cmt := "this is a comment" + err = parser.parsePair2_2("AnnotationComment", cmt) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.ann.AnnotationComment != cmt { + t.Errorf("got %v for AnnotationComment, expected %v", parser.ann.AnnotationComment, cmt) + } +} + +func TestParser2_2FailsIfAnnotatorInvalid(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("Annotator", "John Doe (jdoe@example.com)") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfAnnotatorTypeInvalid(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("Annotator", "Human: John Doe (jdoe@example.com)") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfAnnotationRefInvalid(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + // start with valid annotator + err := parser.parsePair2_2("Annotator", "Person: John Doe (jdoe@example.com)") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePair2_2("SPDXREF", "blah:other") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/parse_creation_info.go b/tvloader/parser2v2/parse_creation_info.go new file mode 100644 index 0000000..9c84404 --- /dev/null +++ b/tvloader/parser2v2/parse_creation_info.go @@ -0,0 +1,107 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromCreationInfo2_2(tag string, value string) error { + // fail if not in Creation Info parser state + if parser.st != psCreationInfo2_2 { + return fmt.Errorf("Got invalid state %v in parsePairFromCreationInfo2_2", parser.st) + } + + // create an SPDX Creation Info data struct if we don't have one already + if parser.doc.CreationInfo == nil { + parser.doc.CreationInfo = &spdx.CreationInfo2_2{} + } + + ci := parser.doc.CreationInfo + switch tag { + case "SPDXVersion": + ci.SPDXVersion = value + case "DataLicense": + ci.DataLicense = value + case "SPDXID": + ci.SPDXIdentifier = spdx.ElementID(value) + case "DocumentName": + ci.DocumentName = value + case "DocumentNamespace": + ci.DocumentNamespace = value + case "ExternalDocumentRef": + ci.ExternalDocumentReferences = append(ci.ExternalDocumentReferences, value) + case "LicenseListVersion": + ci.LicenseListVersion = value + case "Creator": + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "Person": + ci.CreatorPersons = append(ci.CreatorPersons, subvalue) + case "Organization": + ci.CreatorOrganizations = append(ci.CreatorOrganizations, subvalue) + case "Tool": + ci.CreatorTools = append(ci.CreatorTools, subvalue) + default: + return fmt.Errorf("unrecognized Creator type %v", subkey) + } + case "Created": + ci.Created = value + case "CreatorComment": + ci.CreatorComment = value + case "DocumentComment": + ci.DocumentComment = value + + // tag for going on to package section + case "PackageName": + parser.st = psPackage2_2 + parser.pkg = &spdx.Package2_2{ + FilesAnalyzed: true, + IsFilesAnalyzedTagPresent: false, + } + return parser.parsePairFromPackage2_2(tag, value) + // tag for going on to _unpackaged_ file section + case "FileName": + // leave pkg as nil, so that packages will be placed in UnpackagedFiles + parser.st = psFile2_2 + parser.pkg = nil + return parser.parsePairFromFile2_2(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_2 + return parser.parsePairFromOtherLicense2_2(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_2 + return parser.parsePairFromReview2_2(tag, value) + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in CreationInfo section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_creation_info_test.go b/tvloader/parser2v2/parse_creation_info_test.go new file mode 100644 index 0000000..0be6110 --- /dev/null +++ b/tvloader/parser2v2/parse_creation_info_test.go @@ -0,0 +1,431 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser creation info state change tests ===== +func TestParser2_2CIMovesToPackageAfterParsingPackageNameTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + pkgName := "testPkg" + err := parser.parsePair2_2("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } + // and a package should be created + if parser.pkg == nil { + t.Fatalf("parser didn't create new package") + } + // and the package name should be as expected + if parser.pkg.PackageName != pkgName { + t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName) + } + // and the package should default to true for FilesAnalyzed + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected FilesAnalyzed to default to true, got false") + } + if parser.pkg.IsFilesAnalyzedTagPresent != false { + t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") + } + // and the package should NOT be in the SPDX Document's map of packages, + // because it doesn't have an SPDX identifier yet + if len(parser.doc.Packages) != 0 { + t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages)) + } +} + +func TestParser2_2CIMovesToFileAfterParsingFileNameTagWithNoPackages(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("FileName", "testFile") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } + // and current package should be nil, meaning Files are placed in the + // UnpackagedFiles map instead of in a Package + if parser.pkg != nil { + t.Fatalf("expected pkg to be nil, got non-nil pkg") + } +} + +func TestParser2_2CIMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } +} + +func TestParser2_2CIMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } +} + +func TestParser2_2CIStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } +} + +func TestParser2_2CIStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this spdx file") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } +} + +func TestParser2_2FailsParsingCreationInfoWithInvalidState(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psPackage2_2, + } + err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +// ===== Creation Info section tests ===== +func TestParser2_2HasCreationInfoAfterCallToParseFirstTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2") + if err != nil { + t.Errorf("got error when calling parsePairFromCreationInfo2_2: %v", err) + } + if parser.doc.CreationInfo == nil { + t.Errorf("doc.CreationInfo is still nil after parsing first pair") + } +} + +func TestParser2_2CanParseCreationInfoTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // SPDX Version + err := parser.parsePairFromCreationInfo2_2("SPDXVersion", "SPDX-2.2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.SPDXVersion != "SPDX-2.2" { + t.Errorf("got %v for SPDXVersion", parser.doc.CreationInfo.SPDXVersion) + } + + // Data License + err = parser.parsePairFromCreationInfo2_2("DataLicense", "CC0-1.0") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.DataLicense != "CC0-1.0" { + t.Errorf("got %v for DataLicense", parser.doc.CreationInfo.DataLicense) + } + + // SPDX Identifier + err = parser.parsePairFromCreationInfo2_2("SPDXID", "SPDXRef-DOCUMENT") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.SPDXIdentifier != "SPDXRef-DOCUMENT" { + t.Errorf("got %v for SPDXIdentifier", parser.doc.CreationInfo.SPDXIdentifier) + } + + // Document Name + err = parser.parsePairFromCreationInfo2_2("DocumentName", "xyz-2.1.5") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.DocumentName != "xyz-2.1.5" { + t.Errorf("got %v for DocumentName", parser.doc.CreationInfo.DocumentName) + } + + // Document Namespace + err = parser.parsePairFromCreationInfo2_2("DocumentNamespace", "http://example.com/xyz-2.1.5.spdx") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.DocumentNamespace != "http://example.com/xyz-2.1.5.spdx" { + t.Errorf("got %v for DocumentNamespace", parser.doc.CreationInfo.DocumentNamespace) + } + + // External Document Reference + refs := []string{ + "DocumentRef-spdx-tool-1.2 http://spdx.org/spdxdocs/spdx-tools-v1.2-3F2504E0-4F89-41D3-9A0C-0305E82C3301 SHA1: d6a770ba38583ed4bb4525bd96e50461655d2759", + "DocumentRef-xyz-2.1.2 http://example.com/xyz-2.1.2 SHA1: d6a770ba38583ed4bb4525bd96e50461655d2760", + } + err = parser.parsePairFromCreationInfo2_2("ExternalDocumentRef", refs[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_2("ExternalDocumentRef", refs[1]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.doc.CreationInfo.ExternalDocumentReferences) != 2 || + parser.doc.CreationInfo.ExternalDocumentReferences[0] != refs[0] || + parser.doc.CreationInfo.ExternalDocumentReferences[1] != refs[1] { + t.Errorf("got %v for ExternalDocumentReferences", parser.doc.CreationInfo.ExternalDocumentReferences) + } + + // License List Version + err = parser.parsePairFromCreationInfo2_2("LicenseListVersion", "2.2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.LicenseListVersion != "2.2" { + t.Errorf("got %v for LicenseListVersion", parser.doc.CreationInfo.LicenseListVersion) + } + + // Creators: Persons + refPersons := []string{ + "Person: Person A", + "Person: Person B", + } + err = parser.parsePairFromCreationInfo2_2("Creator", refPersons[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_2("Creator", refPersons[1]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.doc.CreationInfo.CreatorPersons) != 2 || + parser.doc.CreationInfo.CreatorPersons[0] != "Person A" || + parser.doc.CreationInfo.CreatorPersons[1] != "Person B" { + t.Errorf("got %v for CreatorPersons", parser.doc.CreationInfo.CreatorPersons) + } + + // Creators: Organizations + refOrgs := []string{ + "Organization: Organization A", + "Organization: Organization B", + } + err = parser.parsePairFromCreationInfo2_2("Creator", refOrgs[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_2("Creator", refOrgs[1]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.doc.CreationInfo.CreatorOrganizations) != 2 || + parser.doc.CreationInfo.CreatorOrganizations[0] != "Organization A" || + parser.doc.CreationInfo.CreatorOrganizations[1] != "Organization B" { + t.Errorf("got %v for CreatorOrganizations", parser.doc.CreationInfo.CreatorOrganizations) + } + + // Creators: Tools + refTools := []string{ + "Tool: Tool A", + "Tool: Tool B", + } + err = parser.parsePairFromCreationInfo2_2("Creator", refTools[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_2("Creator", refTools[1]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.doc.CreationInfo.CreatorTools) != 2 || + parser.doc.CreationInfo.CreatorTools[0] != "Tool A" || + parser.doc.CreationInfo.CreatorTools[1] != "Tool B" { + t.Errorf("got %v for CreatorTools", parser.doc.CreationInfo.CreatorTools) + } + + // Created date + err = parser.parsePairFromCreationInfo2_2("Created", "2018-09-10T11:46:00Z") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.Created != "2018-09-10T11:46:00Z" { + t.Errorf("got %v for Created", parser.doc.CreationInfo.Created) + } + + // Creator Comment + err = parser.parsePairFromCreationInfo2_2("CreatorComment", "Blah whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.CreatorComment != "Blah whatever" { + t.Errorf("got %v for CreatorComment", parser.doc.CreationInfo.CreatorComment) + } + + // Document Comment + err = parser.parsePairFromCreationInfo2_2("DocumentComment", "Blah whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.DocumentComment != "Blah whatever" { + t.Errorf("got %v for DocumentComment", parser.doc.CreationInfo.DocumentComment) + } + +} + +func TestParser2_2InvalidCreatorTagsFail(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePairFromCreationInfo2_2("Creator", "blah: somebody") + if err == nil { + t.Errorf("expected error from parsing invalid Creator format, got nil") + } + + err = parser.parsePairFromCreationInfo2_2("Creator", "Tool with no colons") + if err == nil { + t.Errorf("expected error from parsing invalid Creator format, got nil") + } +} + +func TestParser2_2CreatorTagWithMultipleColonsPasses(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePairFromCreationInfo2_2("Creator", "Tool: tool1:2:3") + if err != nil { + t.Errorf("unexpected error from parsing valid Creator format") + } +} + +func TestParser2_2CIUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePairFromCreationInfo2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestParser2_2CICreatesRelationship(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.rln == nil { + t.Fatalf("parser didn't create and point to Relationship struct") + } + if parser.rln != parser.doc.Relationships[0] { + t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]") + } +} + +func TestParser2_2CICreatesAnnotation(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.ann == nil { + t.Fatalf("parser didn't create and point to Annotation struct") + } + if parser.ann != parser.doc.Annotations[0] { + t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]") + } +} diff --git a/tvloader/parser2v2/parse_file.go b/tvloader/parser2v2/parse_file.go new file mode 100644 index 0000000..c0e3c92 --- /dev/null +++ b/tvloader/parser2v2/parse_file.go @@ -0,0 +1,132 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromFile2_2(tag string, value string) error { + // expire fileAOP for anything other than an AOPHomePage or AOPURI + // (we'll actually handle the HomePage and URI further below) + if tag != "ArtifactOfProjectHomePage" && tag != "ArtifactOfProjectURI" { + parser.fileAOP = nil + } + + switch tag { + // tag for creating new file section + case "FileName": + parser.file = &spdx.File2_2{} + parser.file.FileName = value + // tag for creating new package section and going back to parsing Package + case "PackageName": + parser.st = psPackage2_2 + parser.file = nil + return parser.parsePairFromPackage2_2(tag, value) + // tag for going on to snippet section + case "SnippetSPDXID": + parser.st = psSnippet2_2 + return parser.parsePairFromSnippet2_2(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_2 + return parser.parsePairFromOtherLicense2_2(tag, value) + // tags for file data + case "SPDXID": + eID, err := extractElementID(value) + if err != nil { + return err + } + parser.file.FileSPDXIdentifier = eID + if parser.pkg == nil { + if parser.doc.UnpackagedFiles == nil { + parser.doc.UnpackagedFiles = map[spdx.ElementID]*spdx.File2_2{} + } + parser.doc.UnpackagedFiles[eID] = parser.file + } else { + if parser.pkg.Files == nil { + parser.pkg.Files = map[spdx.ElementID]*spdx.File2_2{} + } + parser.pkg.Files[eID] = parser.file + } + case "FileType": + parser.file.FileType = append(parser.file.FileType, value) + case "FileChecksum": + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "SHA1": + parser.file.FileChecksumSHA1 = subvalue + case "SHA256": + parser.file.FileChecksumSHA256 = subvalue + case "MD5": + parser.file.FileChecksumMD5 = subvalue + default: + return fmt.Errorf("got unknown checksum type %s", subkey) + } + case "LicenseConcluded": + parser.file.LicenseConcluded = value + case "LicenseInfoInFile": + parser.file.LicenseInfoInFile = append(parser.file.LicenseInfoInFile, value) + case "LicenseComments": + parser.file.LicenseComments = value + case "FileCopyrightText": + parser.file.FileCopyrightText = value + case "ArtifactOfProjectName": + parser.fileAOP = &spdx.ArtifactOfProject2_2{} + parser.file.ArtifactOfProjects = append(parser.file.ArtifactOfProjects, parser.fileAOP) + parser.fileAOP.Name = value + case "ArtifactOfProjectHomePage": + if parser.fileAOP == nil { + return fmt.Errorf("no current ArtifactOfProject found") + } + parser.fileAOP.HomePage = value + case "ArtifactOfProjectURI": + if parser.fileAOP == nil { + return fmt.Errorf("no current ArtifactOfProject found") + } + parser.fileAOP.URI = value + case "FileComment": + parser.file.FileComment = value + case "FileNotice": + parser.file.FileNotice = value + case "FileContributor": + parser.file.FileContributor = append(parser.file.FileContributor, value) + case "FileDependency": + parser.file.FileDependencies = append(parser.file.FileDependencies, value) + case "FileAttributionText": + parser.file.FileAttributionTexts = append(parser.file.FileAttributionTexts, value) + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_2 + return parser.parsePairFromReview2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in File section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_file_test.go b/tvloader/parser2v2/parse_file_test.go new file mode 100644 index 0000000..ffa7662 --- /dev/null +++ b/tvloader/parser2v2/parse_file_test.go @@ -0,0 +1,913 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser file section state change tests ===== +func TestParser2_2FileStartsNewFileAfterParsingFileNameTag(t *testing.T) { + // create the first file + fileOldName := "f1.txt" + + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: fileOldName, FileSPDXIdentifier: "f1"}, + } + fileOld := parser.file + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = fileOld + // the Package's Files should have this one only + if len(parser.pkg.Files) != 1 { + t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f1"] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + } + if parser.pkg.Files["f1"].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + } + + // now add a new file + fileName := "f2.txt" + err := parser.parsePair2_2("FileName", fileName) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psFile2_2 { + t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st) + } + // and a file should be created + if parser.file == nil { + t.Fatalf("parser didn't create new file") + } + // and the file name should be as expected + if parser.file.FileName != fileName { + t.Errorf("expected file name %s, got %s", fileName, parser.file.FileName) + } + // and the Package's Files should still be of size 1 and not have this new + // one yet, since it hasn't seen an SPDX identifier + if len(parser.pkg.Files) != 1 { + t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f1"] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + } + if parser.pkg.Files["f1"].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + } + + // now parse an SPDX identifier tag + err = parser.parsePair2_2("SPDXID", "SPDXRef-f2ID") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // and the Package's Files should now be of size 2 and have this new one + if len(parser.pkg.Files) != 2 { + t.Fatalf("expected 2 files, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f1"] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + } + if parser.pkg.Files["f1"].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + } + if parser.pkg.Files["f2ID"] != parser.file { + t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files["f2ID"]) + } + if parser.pkg.Files["f2ID"].FileName != fileName { + t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files["f2ID"].FileName) + } +} + +func TestParser2_2FileAddsToPackageOrUnpackagedFiles(t *testing.T) { + // start with no packages + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // add a file and SPDX identifier + fileName := "f2.txt" + err := parser.parsePair2_2("FileName", fileName) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + err = parser.parsePair2_2("SPDXID", "SPDXRef-f2ID") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + fileOld := parser.file + // should have been added to UnpackagedFiles + if len(parser.doc.UnpackagedFiles) != 1 { + t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles)) + } + if parser.doc.UnpackagedFiles["f2ID"] != fileOld { + t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"]) + } + // now create a package and a new file + err = parser.parsePair2_2("PackageName", "package1") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + err = parser.parsePair2_2("SPDXID", "SPDXRef-pkg1") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + err = parser.parsePair2_2("FileName", "f3.txt") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + err = parser.parsePair2_2("SPDXID", "SPDXRef-f3ID") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // UnpackagedFiles should still be size 1 and have old file only + if len(parser.doc.UnpackagedFiles) != 1 { + t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles)) + } + if parser.doc.UnpackagedFiles["f2ID"] != fileOld { + t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"]) + } + // and new package should have gotten the new file + if len(parser.pkg.Files) != 1 { + t.Fatalf("expected 1 file in Files, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f3ID"] != parser.file { + t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files["f3ID"]) + } +} + +func TestParser2_2FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + // create the first file and package + p1Name := "package1" + f1Name := "f1.txt" + + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: f1Name, FileSPDXIdentifier: "f1"}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages["package1"] = p1 + parser.pkg.Files["f1"] = f1 + + // now add a new package + p2Name := "package2" + err := parser.parsePair2_2("PackageName", p2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should go back to Package + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } + // and a package should be created + if parser.pkg == nil { + t.Fatalf("parser didn't create new pkg") + } + // and the package name should be as expected + if parser.pkg.PackageName != p2Name { + t.Errorf("expected package name %s, got %s", p2Name, parser.pkg.PackageName) + } + // and the package should default to true for FilesAnalyzed + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected FilesAnalyzed to default to true, got false") + } + if parser.pkg.IsFilesAnalyzedTagPresent != false { + t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") + } + // and the new Package should have no files + if len(parser.pkg.Files) != 0 { + t.Errorf("Expected no files in pkg.Files, got %d", len(parser.pkg.Files)) + } + // and the Document's Packages should still be of size 1 and not have this + // new one, because no SPDX identifier has been seen yet + if len(parser.doc.Packages) != 1 { + t.Fatalf("expected 1 package, got %d", len(parser.doc.Packages)) + } + if parser.doc.Packages["package1"] != p1 { + t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"]) + } + if parser.doc.Packages["package1"].PackageName != p1Name { + t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages["package1"].PackageName) + } + // and the first Package's Files should be of size 1 and have f1 only + if len(parser.doc.Packages["package1"].Files) != 1 { + t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files)) + } + if parser.doc.Packages["package1"].Files["f1"] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"]) + } + if parser.doc.Packages["package1"].Files["f1"].FileName != f1Name { + t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages["package1"].Files["f1"].FileName) + } + // and the current file should be nil + if parser.file != nil { + t.Errorf("Expected nil for parser.file, got %v", parser.file) + } +} + +func TestParser2_2FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + fileCurrent := parser.file + + err := parser.parsePair2_2("SnippetSPDXID", "SPDXRef-Test1") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psSnippet2_2 { + t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) + } + // and current file should remain what it was + if parser.file != fileCurrent { + t.Fatalf("expected file to remain %v, got %v", fileCurrent, parser.file) + } +} + +func TestParser2_2FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f2"] = parser.file + + err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } +} + +func TestParser2_2FileMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePair2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } +} + +func TestParser2_2FileStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should remain unchanged + if parser.st != psFile2_2 { + t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still remain unchanged + if parser.st != psFile2_2 { + t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st) + } +} + +func TestParser2_2FileStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psFile2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_2) + } +} + +// ===== File data section tests ===== +func TestParser2_2CanParseFileTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileName != "f1.txt" { + t.Errorf("got %v for FileName", parser.file.FileName) + } + // should not yet be added to the Packages file list, because we haven't + // seen an SPDX identifier yet + if len(parser.pkg.Files) != 0 { + t.Errorf("expected 0 files, got %d", len(parser.pkg.Files)) + } + + // File SPDX Identifier + err = parser.parsePairFromFile2_2("SPDXID", "SPDXRef-f1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileSPDXIdentifier != "f1" { + t.Errorf("got %v for FileSPDXIdentifier", parser.file.FileSPDXIdentifier) + } + // should now be added to the Packages file list + if len(parser.pkg.Files) != 1 { + t.Errorf("expected 1 file, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f1"] != parser.file { + t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files["f1"]) + } + + // File Type + fileTypes := []string{ + "TEXT", + "DOCUMENTATION", + } + for _, ty := range fileTypes { + err = parser.parsePairFromFile2_2("FileType", ty) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, typeWant := range fileTypes { + flagFound := false + for _, typeCheck := range parser.file.FileType { + if typeWant == typeCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in FileType", typeWant) + } + } + if len(fileTypes) != len(parser.file.FileType) { + t.Errorf("expected %d types in FileType, got %d", len(fileTypes), + len(parser.file.FileType)) + } + + // File Checksums + codeSha1 := "85ed0817af83a24ad8da68c2b5094de69833983c" + sumSha1 := "SHA1: 85ed0817af83a24ad8da68c2b5094de69833983c" + codeSha256 := "11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd" + sumSha256 := "SHA256: 11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd" + codeMd5 := "624c1abb3664f4b35547e7c73864ad24" + sumMd5 := "MD5: 624c1abb3664f4b35547e7c73864ad24" + err = parser.parsePairFromFile2_2("FileChecksum", sumSha1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("FileChecksum", sumSha256) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("FileChecksum", sumMd5) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileChecksumSHA1 != codeSha1 { + t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha1, parser.file.FileChecksumSHA1) + } + if parser.file.FileChecksumSHA256 != codeSha256 { + t.Errorf("expected %s for FileChecksumSHA256, got %s", codeSha256, parser.file.FileChecksumSHA256) + } + if parser.file.FileChecksumMD5 != codeMd5 { + t.Errorf("expected %s for FileChecksumMD5, got %s", codeMd5, parser.file.FileChecksumMD5) + } + + // Concluded License + err = parser.parsePairFromFile2_2("LicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.LicenseConcluded != "Apache-2.0 OR GPL-2.0-or-later" { + t.Errorf("got %v for LicenseConcluded", parser.file.LicenseConcluded) + } + + // License Information in File + lics := []string{ + "Apache-2.0", + "GPL-2.0-or-later", + "CC0-1.0", + } + for _, lic := range lics { + err = parser.parsePairFromFile2_2("LicenseInfoInFile", lic) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, licWant := range lics { + flagFound := false + for _, licCheck := range parser.file.LicenseInfoInFile { + if licWant == licCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in LicenseInfoInFile", licWant) + } + } + if len(lics) != len(parser.file.LicenseInfoInFile) { + t.Errorf("expected %d licenses in LicenseInfoInFile, got %d", len(lics), + len(parser.file.LicenseInfoInFile)) + } + + // Comments on License + err = parser.parsePairFromFile2_2("LicenseComments", "this is a comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.LicenseComments != "this is a comment" { + t.Errorf("got %v for LicenseComments", parser.file.LicenseComments) + } + + // Copyright Text + err = parser.parsePairFromFile2_2("FileCopyrightText", "copyright (c) me") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileCopyrightText != "copyright (c) me" { + t.Errorf("got %v for FileCopyrightText", parser.file.FileCopyrightText) + } + + // Artifact of Projects: Name, HomePage and URI + // Artifact set 1 + err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/1/") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/1/uri.whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // Artifact set 2 -- just name + err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // Artifact set 3 -- just name and home page + err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project3") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/3/") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // Artifact set 4 -- just name and URI + err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project4") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/4/uri.whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + + if len(parser.file.ArtifactOfProjects) != 4 { + t.Fatalf("expected len %d, got %d", 4, len(parser.file.ArtifactOfProjects)) + } + + aop := parser.file.ArtifactOfProjects[0] + if aop.Name != "project1" { + t.Errorf("expected %v, got %v", "project1", aop.Name) + } + if aop.HomePage != "http://example.com/1/" { + t.Errorf("expected %v, got %v", "http://example.com/1/", aop.HomePage) + } + if aop.URI != "http://example.com/1/uri.whatever" { + t.Errorf("expected %v, got %v", "http://example.com/1/uri.whatever", aop.URI) + } + + aop = parser.file.ArtifactOfProjects[1] + if aop.Name != "project2" { + t.Errorf("expected %v, got %v", "project2", aop.Name) + } + if aop.HomePage != "" { + t.Errorf("expected %v, got %v", "", aop.HomePage) + } + if aop.URI != "" { + t.Errorf("expected %v, got %v", "", aop.URI) + } + + aop = parser.file.ArtifactOfProjects[2] + if aop.Name != "project3" { + t.Errorf("expected %v, got %v", "project3", aop.Name) + } + if aop.HomePage != "http://example.com/3/" { + t.Errorf("expected %v, got %v", "http://example.com/3/", aop.HomePage) + } + if aop.URI != "" { + t.Errorf("expected %v, got %v", "", aop.URI) + } + + aop = parser.file.ArtifactOfProjects[3] + if aop.Name != "project4" { + t.Errorf("expected %v, got %v", "project4", aop.Name) + } + if aop.HomePage != "" { + t.Errorf("expected %v, got %v", "", aop.HomePage) + } + if aop.URI != "http://example.com/4/uri.whatever" { + t.Errorf("expected %v, got %v", "http://example.com/4/uri.whatever", aop.URI) + } + + // File Comment + err = parser.parsePairFromFile2_2("FileComment", "this is a comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileComment != "this is a comment" { + t.Errorf("got %v for FileComment", parser.file.FileComment) + } + + // File Notice + err = parser.parsePairFromFile2_2("FileNotice", "this is a Notice") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileNotice != "this is a Notice" { + t.Errorf("got %v for FileNotice", parser.file.FileNotice) + } + + // File Contributor + contribs := []string{ + "John Doe jdoe@example.com", + "EvilCorp", + } + for _, contrib := range contribs { + err = parser.parsePairFromFile2_2("FileContributor", contrib) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, contribWant := range contribs { + flagFound := false + for _, contribCheck := range parser.file.FileContributor { + if contribWant == contribCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in FileContributor", contribWant) + } + } + if len(contribs) != len(parser.file.FileContributor) { + t.Errorf("expected %d contribenses in FileContributor, got %d", len(contribs), + len(parser.file.FileContributor)) + } + + // File Dependencies + deps := []string{ + "f-1.txt", + "g.txt", + } + for _, dep := range deps { + err = parser.parsePairFromFile2_2("FileDependency", dep) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, depWant := range deps { + flagFound := false + for _, depCheck := range parser.file.FileDependencies { + if depWant == depCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in FileDependency", depWant) + } + } + if len(deps) != len(parser.file.FileDependencies) { + t.Errorf("expected %d depenses in FileDependency, got %d", len(deps), + len(parser.file.FileDependencies)) + } + + // File Attribution Texts + attrs := []string{ + "Include this notice in all advertising materials", + "This is a \nmulti-line string", + } + for _, attr := range attrs { + err = parser.parsePairFromFile2_2("FileAttributionText", attr) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, attrWant := range attrs { + flagFound := false + for _, attrCheck := range parser.file.FileAttributionTexts { + if attrWant == attrCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in FileAttributionText", attrWant) + } + } + if len(attrs) != len(parser.file.FileAttributionTexts) { + t.Errorf("expected %d attribution texts in FileAttributionTexts, got %d", len(attrs), + len(parser.file.FileAttributionTexts)) + } + +} + +func TestParser2_2FileCreatesRelationshipInDocument(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.rln == nil { + t.Fatalf("parser didn't create and point to Relationship struct") + } + if parser.rln != parser.doc.Relationships[0] { + t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]") + } +} + +func TestParser2_2FileCreatesAnnotationInDocument(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.ann == nil { + t.Fatalf("parser didn't create and point to Annotation struct") + } + if parser.ann != parser.doc.Annotations[0] { + t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]") + } +} + +func TestParser2_2FileUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePairFromFile2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestFileAOPPointerChangesAfterTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePairFromFile2_2("ArtifactOfProjectName", "project1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.fileAOP == nil { + t.Errorf("expected non-nil AOP pointer, got nil") + } + curPtr := parser.fileAOP + + // now, a home page; pointer should stay + err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "http://example.com/1/") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.fileAOP != curPtr { + t.Errorf("expected no change in AOP pointer, was %v, got %v", curPtr, parser.fileAOP) + } + + // a URI; pointer should stay + err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "http://example.com/1/uri.whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.fileAOP != curPtr { + t.Errorf("expected no change in AOP pointer, was %v, got %v", curPtr, parser.fileAOP) + } + + // now, another artifact name; pointer should change but be non-nil + // now, a home page; pointer should stay + err = parser.parsePairFromFile2_2("ArtifactOfProjectName", "project2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.fileAOP == curPtr { + t.Errorf("expected change in AOP pointer, got no change") + } + + // finally, an unrelated tag; pointer should go away + err = parser.parsePairFromFile2_2("FileComment", "whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.fileAOP != nil { + t.Errorf("expected nil AOP pointer, got %v", parser.fileAOP) + } +} + +func TestParser2_2FailsIfInvalidSPDXIDInFileSection(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // start with File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid SPDX Identifier + err = parser.parsePairFromFile2_2("SPDXID", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfInvalidChecksumFormatInFileSection(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // start with File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid format for checksum line, missing colon + err = parser.parsePairFromFile2_2("FileChecksum", "SHA1 85ed0817af83a24ad8da68c2b5094de69833983c") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // start with File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // unknown checksum type + err = parser.parsePairFromFile2_2("FileChecksum", "Special: 85ed0817af83a24ad8da68c2b5094de69833983c") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // start with File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // artifact home page appears before artifact name + err = parser.parsePairFromFile2_2("ArtifactOfProjectHomePage", "https://example.com") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfArtifactURIBeforeArtifactName(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + } + parser.doc.Packages["test"] = parser.pkg + + // start with File Name + err := parser.parsePairFromFile2_2("FileName", "f1.txt") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // artifact home page appears before artifact name + err = parser.parsePairFromFile2_2("ArtifactOfProjectURI", "https://example.com") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/parse_other_license.go b/tvloader/parser2v2/parse_other_license.go new file mode 100644 index 0000000..371f834 --- /dev/null +++ b/tvloader/parser2v2/parse_other_license.go @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromOtherLicense2_2(tag string, value string) error { + switch tag { + // tag for creating new other license section + case "LicenseID": + parser.otherLic = &spdx.OtherLicense2_2{} + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.otherLic.LicenseIdentifier = value + case "ExtractedText": + parser.otherLic.ExtractedText = value + case "LicenseName": + parser.otherLic.LicenseName = value + case "LicenseCrossReference": + parser.otherLic.LicenseCrossReferences = append(parser.otherLic.LicenseCrossReferences, value) + case "LicenseComment": + parser.otherLic.LicenseComment = value + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_2 + return parser.parsePairFromReview2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in OtherLicense section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_other_license_test.go b/tvloader/parser2v2/parse_other_license_test.go new file mode 100644 index 0000000..ebf4170 --- /dev/null +++ b/tvloader/parser2v2/parse_other_license_test.go @@ -0,0 +1,339 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser other license section state change tests ===== +func TestParser2_2OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + // create the first other license + olid1 := "LicenseRef-Lic11" + olname1 := "License 11" + + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: olid1, + LicenseName: olname1, + }, + } + olic1 := parser.otherLic + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + // the Document's OtherLicenses should have this one only + if parser.doc.OtherLicenses[0] != olic1 { + t.Errorf("Expected other license %v in OtherLicenses[0], got %v", olic1, parser.doc.OtherLicenses[0]) + } + if parser.doc.OtherLicenses[0].LicenseName != olname1 { + t.Errorf("expected other license name %s in OtherLicenses[0], got %s", olname1, parser.doc.OtherLicenses[0].LicenseName) + } + + // now add a new other license + olid2 := "LicenseRef-22" + olname2 := "License 22" + err := parser.parsePair2_2("LicenseID", olid2) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } + // and an other license should be created + if parser.otherLic == nil { + t.Fatalf("parser didn't create new other license") + } + // also parse the new license's name + err = parser.parsePair2_2("LicenseName", olname2) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still be correct + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } + // and the other license name should be as expected + if parser.otherLic.LicenseName != olname2 { + t.Errorf("expected other license name %s, got %s", olname2, parser.otherLic.LicenseName) + } + // and the Document's Other Licenses should be of size 2 and have these two + if len(parser.doc.OtherLicenses) != 2 { + t.Fatalf("Expected OtherLicenses to have len 2, got %d", len(parser.doc.OtherLicenses)) + } + if parser.doc.OtherLicenses[0] != olic1 { + t.Errorf("Expected other license %v in OtherLicenses[0], got %v", olic1, parser.doc.OtherLicenses[0]) + } + if parser.doc.OtherLicenses[0].LicenseIdentifier != olid1 { + t.Errorf("expected other license ID %s in OtherLicenses[0], got %s", olid1, parser.doc.OtherLicenses[0].LicenseIdentifier) + } + if parser.doc.OtherLicenses[0].LicenseName != olname1 { + t.Errorf("expected other license name %s in OtherLicenses[0], got %s", olname1, parser.doc.OtherLicenses[0].LicenseName) + } + if parser.doc.OtherLicenses[1] != parser.otherLic { + t.Errorf("Expected other license %v in OtherLicenses[1], got %v", parser.otherLic, parser.doc.OtherLicenses[1]) + } + if parser.doc.OtherLicenses[1].LicenseIdentifier != olid2 { + t.Errorf("expected other license ID %s in OtherLicenses[1], got %s", olid2, parser.doc.OtherLicenses[1].LicenseIdentifier) + } + if parser.doc.OtherLicenses[1].LicenseName != olname2 { + t.Errorf("expected other license name %s in OtherLicenses[1], got %s", olname2, parser.doc.OtherLicenses[1].LicenseName) + } +} + +func TestParser2_2OLMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } +} + +func TestParser2_2OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-whatever", + LicenseName: "the whatever license", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should remain unchanged + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } + // and the relationship should be in the Document's Relationships + if len(parser.doc.Relationships) != 1 { + t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships)) + } + deID := parser.doc.Relationships[0].RefA + if deID.DocumentRefID != "" || deID.ElementRefID != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still remain unchanged + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } +} + +func TestParser2_2OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-whatever", + LicenseName: "the whatever license", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_2) + } + + // and the annotation should be in the Document's Annotations + if len(parser.doc.Annotations) != 1 { + t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations)) + } + if parser.doc.Annotations[0].Annotator != "John Doe ()" { + t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator) + } +} + +func TestParser2_2OLFailsAfterParsingOtherSectionTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + // can't go back to old sections + err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } + err = parser.parsePair2_2("PackageName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } + err = parser.parsePair2_2("FileName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } +} + +// ===== Other License data section tests ===== +func TestParser2_2CanParseOtherLicenseTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + // License Identifier + err := parser.parsePairFromOtherLicense2_2("LicenseID", "LicenseRef-Lic11") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.otherLic.LicenseIdentifier != "LicenseRef-Lic11" { + t.Errorf("got %v for LicenseID", parser.otherLic.LicenseIdentifier) + } + + // Extracted Text + err = parser.parsePairFromOtherLicense2_2("ExtractedText", "You are permitted to do anything with the software, hooray!") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.otherLic.ExtractedText != "You are permitted to do anything with the software, hooray!" { + t.Errorf("got %v for ExtractedText", parser.otherLic.ExtractedText) + } + + // License Name + err = parser.parsePairFromOtherLicense2_2("LicenseName", "License 11") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.otherLic.LicenseName != "License 11" { + t.Errorf("got %v for LicenseName", parser.otherLic.LicenseName) + } + + // License Cross Reference + crossRefs := []string{ + "https://example.com/1", + "https://example.com/2", + "https://example.com/3", + } + for _, cr := range crossRefs { + err = parser.parsePairFromOtherLicense2_2("LicenseCrossReference", cr) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, refWant := range crossRefs { + flagFound := false + for _, refCheck := range parser.otherLic.LicenseCrossReferences { + if refWant == refCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in LicenseCrossReferences", refWant) + } + } + if len(crossRefs) != len(parser.otherLic.LicenseCrossReferences) { + t.Errorf("expected %d types in LicenseCrossReferences, got %d", len(crossRefs), + len(parser.otherLic.LicenseCrossReferences)) + } + + // License Comment + err = parser.parsePairFromOtherLicense2_2("LicenseComment", "this is a comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.otherLic.LicenseComment != "this is a comment" { + t.Errorf("got %v for LicenseComment", parser.otherLic.LicenseComment) + } +} + +func TestParser2_2OLUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psOtherLicense2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePairFromOtherLicense2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} diff --git a/tvloader/parser2v2/parse_package.go b/tvloader/parser2v2/parse_package.go new file mode 100644 index 0000000..ddc9cb0 --- /dev/null +++ b/tvloader/parser2v2/parse_package.go @@ -0,0 +1,217 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + "strings" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromPackage2_2(tag string, value string) error { + // expire pkgExtRef for anything other than a comment + // (we'll actually handle the comment further below) + if tag != "ExternalRefComment" { + parser.pkgExtRef = nil + } + + switch tag { + case "PackageName": + // if package already has a name, create and go on to a new package + if parser.pkg == nil || parser.pkg.PackageName != "" { + parser.pkg = &spdx.Package2_2{ + FilesAnalyzed: true, + IsFilesAnalyzedTagPresent: false, + } + } + parser.pkg.PackageName = value + // tag for going on to file section + case "FileName": + parser.st = psFile2_2 + return parser.parsePairFromFile2_2(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_2 + return parser.parsePairFromOtherLicense2_2(tag, value) + case "SPDXID": + eID, err := extractElementID(value) + if err != nil { + return err + } + parser.pkg.PackageSPDXIdentifier = eID + if parser.doc.Packages == nil { + parser.doc.Packages = map[spdx.ElementID]*spdx.Package2_2{} + } + parser.doc.Packages[eID] = parser.pkg + case "PackageVersion": + parser.pkg.PackageVersion = value + case "PackageFileName": + parser.pkg.PackageFileName = value + case "PackageSupplier": + if value == "NOASSERTION" { + parser.pkg.PackageSupplierNOASSERTION = true + break + } + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "Person": + parser.pkg.PackageSupplierPerson = subvalue + case "Organization": + parser.pkg.PackageSupplierOrganization = subvalue + default: + return fmt.Errorf("unrecognized PackageSupplier type %v", subkey) + } + case "PackageOriginator": + if value == "NOASSERTION" { + parser.pkg.PackageOriginatorNOASSERTION = true + break + } + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "Person": + parser.pkg.PackageOriginatorPerson = subvalue + case "Organization": + parser.pkg.PackageOriginatorOrganization = subvalue + default: + return fmt.Errorf("unrecognized PackageOriginator type %v", subkey) + } + case "PackageDownloadLocation": + parser.pkg.PackageDownloadLocation = value + case "FilesAnalyzed": + parser.pkg.IsFilesAnalyzedTagPresent = true + if value == "false" { + parser.pkg.FilesAnalyzed = false + } else if value == "true" { + parser.pkg.FilesAnalyzed = true + } + case "PackageVerificationCode": + code, excludesFileName := extractCodeAndExcludes(value) + parser.pkg.PackageVerificationCode = code + parser.pkg.PackageVerificationCodeExcludedFile = excludesFileName + case "PackageChecksum": + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "SHA1": + parser.pkg.PackageChecksumSHA1 = subvalue + case "SHA256": + parser.pkg.PackageChecksumSHA256 = subvalue + case "MD5": + parser.pkg.PackageChecksumMD5 = subvalue + default: + return fmt.Errorf("got unknown checksum type %s", subkey) + } + case "PackageHomePage": + parser.pkg.PackageHomePage = value + case "PackageSourceInfo": + parser.pkg.PackageSourceInfo = value + case "PackageLicenseConcluded": + parser.pkg.PackageLicenseConcluded = value + case "PackageLicenseInfoFromFiles": + parser.pkg.PackageLicenseInfoFromFiles = append(parser.pkg.PackageLicenseInfoFromFiles, value) + case "PackageLicenseDeclared": + parser.pkg.PackageLicenseDeclared = value + case "PackageLicenseComments": + parser.pkg.PackageLicenseComments = value + case "PackageCopyrightText": + parser.pkg.PackageCopyrightText = value + case "PackageSummary": + parser.pkg.PackageSummary = value + case "PackageDescription": + parser.pkg.PackageDescription = value + case "PackageComment": + parser.pkg.PackageComment = value + case "PackageAttributionText": + parser.pkg.PackageAttributionTexts = append(parser.pkg.PackageAttributionTexts, value) + case "ExternalRef": + parser.pkgExtRef = &spdx.PackageExternalReference2_2{} + parser.pkg.PackageExternalReferences = append(parser.pkg.PackageExternalReferences, parser.pkgExtRef) + category, refType, locator, err := extractPackageExternalReference(value) + if err != nil { + return err + } + parser.pkgExtRef.Category = category + parser.pkgExtRef.RefType = refType + parser.pkgExtRef.Locator = locator + case "ExternalRefComment": + if parser.pkgExtRef == nil { + return fmt.Errorf("no current ExternalRef found") + } + parser.pkgExtRef.ExternalRefComment = value + // now, expire pkgExtRef anyway because it can have at most one comment + parser.pkgExtRef = nil + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_2 + return parser.parsePairFromReview2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in Package section", tag) + } + + return nil +} + +// ===== Helper functions ===== + +func extractCodeAndExcludes(value string) (string, string) { + // FIXME this should probably be done using regular expressions instead + // split by paren + word "excludes:" + sp := strings.SplitN(value, "(excludes:", 2) + if len(sp) < 2 { + // not found; return the whole string as just the code + return value, "" + } + + // if we're here, code is in first part and excludes filename is in + // second part, with trailing paren + code := strings.TrimSpace(sp[0]) + parsedSp := strings.SplitN(sp[1], ")", 2) + fileName := strings.TrimSpace(parsedSp[0]) + return code, fileName +} + +func extractPackageExternalReference(value string) (string, string, string, error) { + sp := strings.Split(value, " ") + // remove any that are just whitespace + keepSp := []string{} + for _, s := range sp { + ss := strings.TrimSpace(s) + if ss != "" { + keepSp = append(keepSp, ss) + } + } + // now, should have 3 items and should be able to map them + if len(keepSp) != 3 { + return "", "", "", fmt.Errorf("expected 3 elements, got %d", len(keepSp)) + } + return keepSp[0], keepSp[1], keepSp[2], nil +} diff --git a/tvloader/parser2v2/parse_package_test.go b/tvloader/parser2v2/parse_package_test.go new file mode 100644 index 0000000..6f40170 --- /dev/null +++ b/tvloader/parser2v2/parse_package_test.go @@ -0,0 +1,1097 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser package section state change tests ===== +func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + // create the first package + pkgOldName := "p1" + + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: pkgOldName, PackageSPDXIdentifier: "p1"}, + } + pkgOld := parser.pkg + parser.doc.Packages["p1"] = pkgOld + // the Document's Packages should have this one only + if parser.doc.Packages["p1"] != pkgOld { + t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"]) + } + if len(parser.doc.Packages) != 1 { + t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) + } + + // now add a new package + pkgName := "p2" + err := parser.parsePair2_2("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } + // and a package should be created + if parser.pkg == nil { + t.Fatalf("parser didn't create new package") + } + // and it should not be pkgOld + if parser.pkg == pkgOld { + t.Errorf("expected new package, got pkgOld") + } + // and the package name should be as expected + if parser.pkg.PackageName != pkgName { + t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName) + } + // and the package should default to true for FilesAnalyzed + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected FilesAnalyzed to default to true, got false") + } + if parser.pkg.IsFilesAnalyzedTagPresent != false { + t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") + } + // and the Document's Packages should still be of size 1 and have pkgOld only + if parser.doc.Packages["p1"] != pkgOld { + t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages["p1"]) + } + if len(parser.doc.Packages) != 1 { + t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) + } +} + +func TestParser2_2PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(t *testing.T) { + // pkg is nil, so that Files appearing before the first PackageName tag + // are added to UnpackagedFiles instead of Packages + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psFile2_2, + pkg: nil, + } + // the Document's Packages should be empty + if len(parser.doc.Packages) != 0 { + t.Errorf("Expected zero packages, got %d", len(parser.doc.Packages)) + } + + // now add a new package + pkgName := "p2" + err := parser.parsePair2_2("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } + // and a package should be created + if parser.pkg == nil { + t.Fatalf("parser didn't create new package") + } + // and the package name should be as expected + if parser.pkg.PackageName != pkgName { + t.Errorf("expected package name %s, got %s", pkgName, parser.pkg.PackageName) + } + // and the package should default to true for FilesAnalyzed + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected FilesAnalyzed to default to true, got false") + } + if parser.pkg.IsFilesAnalyzedTagPresent != false { + t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") + } + // and the Document's Packages should be of size 0, because the prior was + // unpackaged files and this one won't be added until an SPDXID is seen + if len(parser.doc.Packages) != 0 { + t.Errorf("Expected %v packages in doc, got %v", 0, len(parser.doc.Packages)) + } +} + +func TestParser2_2PackageMovesToFileAfterParsingFileNameTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + pkgCurrent := parser.pkg + + err := parser.parsePair2_2("FileName", "testFile") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psFile2_2 { + t.Errorf("expected state to be %v, got %v", psFile2_2, parser.st) + } + // and current package should remain what it was + if parser.pkg != pkgCurrent { + t.Fatalf("expected package to remain %v, got %v", pkgCurrent, parser.pkg) + } +} + +func TestParser2_2PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } +} + +func TestParser2_2PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } +} + +func TestParser2_2PackageStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should remain unchanged + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still remain unchanged + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } +} + +func TestParser2_2PackageStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this package") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psPackage2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_2) + } +} + +// ===== Package data section tests ===== +func TestParser2_2CanParsePackageTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // should not yet be in Packages map, b/c no SPDX identifier + if len(parser.doc.Packages) != 0 { + t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages)) + } + + // Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageName != "p1" { + t.Errorf("got %v for PackageName", parser.pkg.PackageName) + } + // still should not yet be in Packages map, b/c no SPDX identifier + if len(parser.doc.Packages) != 0 { + t.Errorf("expected 0 packages, got %d", len(parser.doc.Packages)) + } + + // Package SPDX Identifier + err = parser.parsePairFromPackage2_2("SPDXID", "SPDXRef-p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // "SPDXRef-" prefix should be removed from the item + if parser.pkg.PackageSPDXIdentifier != "p1" { + t.Errorf("got %v for PackageSPDXIdentifier", parser.pkg.PackageSPDXIdentifier) + } + // and it should now be added to the Packages map + if len(parser.doc.Packages) != 1 { + t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) + } + if parser.doc.Packages["p1"] != parser.pkg { + t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages["p1"]) + } + + // Package Version + err = parser.parsePairFromPackage2_2("PackageVersion", "2.1.1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageVersion != "2.1.1" { + t.Errorf("got %v for PackageVersion", parser.pkg.PackageVersion) + } + + // Package File Name + err = parser.parsePairFromPackage2_2("PackageFileName", "p1-2.1.1.tar.gz") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageFileName != "p1-2.1.1.tar.gz" { + t.Errorf("got %v for PackageFileName", parser.pkg.PackageFileName) + } + + // Package Supplier + // SKIP -- separate tests for subvalues below + + // Package Originator + // SKIP -- separate tests for subvalues below + + // Package Download Location + err = parser.parsePairFromPackage2_2("PackageDownloadLocation", "https://example.com/whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageDownloadLocation != "https://example.com/whatever" { + t.Errorf("got %v for PackageDownloadLocation", parser.pkg.PackageDownloadLocation) + } + + // Files Analyzed + err = parser.parsePairFromPackage2_2("FilesAnalyzed", "false") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.FilesAnalyzed != false { + t.Errorf("got %v for FilesAnalyzed", parser.pkg.FilesAnalyzed) + } + if parser.pkg.IsFilesAnalyzedTagPresent != true { + t.Errorf("got %v for IsFilesAnalyzedTagPresent", parser.pkg.IsFilesAnalyzedTagPresent) + } + + // Package Verification Code + // SKIP -- separate tests for "excludes", or not, below + + // Package Checksums + codeSha1 := "85ed0817af83a24ad8da68c2b5094de69833983c" + sumSha1 := "SHA1: 85ed0817af83a24ad8da68c2b5094de69833983c" + codeSha256 := "11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd" + sumSha256 := "SHA256: 11b6d3ee554eedf79299905a98f9b9a04e498210b59f15094c916c91d150efcd" + codeMd5 := "624c1abb3664f4b35547e7c73864ad24" + sumMd5 := "MD5: 624c1abb3664f4b35547e7c73864ad24" + err = parser.parsePairFromPackage2_2("PackageChecksum", sumSha1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_2("PackageChecksum", sumSha256) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_2("PackageChecksum", sumMd5) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageChecksumSHA1 != codeSha1 { + t.Errorf("expected %s for PackageChecksumSHA1, got %s", codeSha1, parser.pkg.PackageChecksumSHA1) + } + if parser.pkg.PackageChecksumSHA256 != codeSha256 { + t.Errorf("expected %s for PackageChecksumSHA256, got %s", codeSha256, parser.pkg.PackageChecksumSHA256) + } + if parser.pkg.PackageChecksumMD5 != codeMd5 { + t.Errorf("expected %s for PackageChecksumMD5, got %s", codeMd5, parser.pkg.PackageChecksumMD5) + } + + // Package Home Page + err = parser.parsePairFromPackage2_2("PackageHomePage", "https://example.com/whatever2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageHomePage != "https://example.com/whatever2" { + t.Errorf("got %v for PackageHomePage", parser.pkg.PackageHomePage) + } + + // Package Source Info + err = parser.parsePairFromPackage2_2("PackageSourceInfo", "random comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSourceInfo != "random comment" { + t.Errorf("got %v for PackageSourceInfo", parser.pkg.PackageSourceInfo) + } + + // Package License Concluded + err = parser.parsePairFromPackage2_2("PackageLicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageLicenseConcluded != "Apache-2.0 OR GPL-2.0-or-later" { + t.Errorf("got %v for PackageLicenseConcluded", parser.pkg.PackageLicenseConcluded) + } + + // All Licenses Info From Files + lics := []string{ + "Apache-2.0", + "GPL-2.0-or-later", + "CC0-1.0", + } + for _, lic := range lics { + err = parser.parsePairFromPackage2_2("PackageLicenseInfoFromFiles", lic) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, licWant := range lics { + flagFound := false + for _, licCheck := range parser.pkg.PackageLicenseInfoFromFiles { + if licWant == licCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in PackageLicenseInfoFromFiles", licWant) + } + } + if len(lics) != len(parser.pkg.PackageLicenseInfoFromFiles) { + t.Errorf("expected %d licenses in PackageLicenseInfoFromFiles, got %d", len(lics), + len(parser.pkg.PackageLicenseInfoFromFiles)) + } + + // Package License Declared + err = parser.parsePairFromPackage2_2("PackageLicenseDeclared", "Apache-2.0 OR GPL-2.0-or-later") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageLicenseDeclared != "Apache-2.0 OR GPL-2.0-or-later" { + t.Errorf("got %v for PackageLicenseDeclared", parser.pkg.PackageLicenseDeclared) + } + + // Package License Comments + err = parser.parsePairFromPackage2_2("PackageLicenseComments", "this is a license comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageLicenseComments != "this is a license comment" { + t.Errorf("got %v for PackageLicenseComments", parser.pkg.PackageLicenseComments) + } + + // Package Copyright Text + err = parser.parsePairFromPackage2_2("PackageCopyrightText", "Copyright (c) me myself and i") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageCopyrightText != "Copyright (c) me myself and i" { + t.Errorf("got %v for PackageCopyrightText", parser.pkg.PackageCopyrightText) + } + + // Package Summary + err = parser.parsePairFromPackage2_2("PackageSummary", "i wrote this package") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSummary != "i wrote this package" { + t.Errorf("got %v for PackageSummary", parser.pkg.PackageSummary) + } + + // Package Description + err = parser.parsePairFromPackage2_2("PackageDescription", "i wrote this package a lot") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageDescription != "i wrote this package a lot" { + t.Errorf("got %v for PackageDescription", parser.pkg.PackageDescription) + } + + // Package Comment + err = parser.parsePairFromPackage2_2("PackageComment", "i scanned this package") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageComment != "i scanned this package" { + t.Errorf("got %v for PackageComment", parser.pkg.PackageComment) + } + + // Package Attribution Text + attrs := []string{ + "Include this notice in all advertising materials", + "This is a \nmulti-line string", + } + for _, attr := range attrs { + err = parser.parsePairFromPackage2_2("PackageAttributionText", attr) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, attrWant := range attrs { + flagFound := false + for _, attrCheck := range parser.pkg.PackageAttributionTexts { + if attrWant == attrCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in PackageAttributionText", attrWant) + } + } + if len(attrs) != len(parser.pkg.PackageAttributionTexts) { + t.Errorf("expected %d attribution texts in PackageAttributionTexts, got %d", len(attrs), + len(parser.pkg.PackageAttributionTexts)) + } + + // Package External References and Comments + ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + ref1Category := "SECURITY" + ref1Type := "cpe23Type" + ref1Locator := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + ref1Comment := "this is comment #1" + ref2 := "OTHER LocationRef-acmeforge acmecorp/acmenator/4.1.3alpha" + ref2Category := "OTHER" + ref2Type := "LocationRef-acmeforge" + ref2Locator := "acmecorp/acmenator/4.1.3alpha" + ref2Comment := "this is comment #2" + err = parser.parsePairFromPackage2_2("ExternalRef", ref1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.pkg.PackageExternalReferences) != 1 { + t.Errorf("expected 1 external reference, got %d", len(parser.pkg.PackageExternalReferences)) + } + if parser.pkgExtRef == nil { + t.Errorf("expected non-nil pkgExtRef, got nil") + } + if parser.pkg.PackageExternalReferences[0] == nil { + t.Errorf("expected non-nil PackageExternalReferences[0], got nil") + } + if parser.pkgExtRef != parser.pkg.PackageExternalReferences[0] { + t.Errorf("expected pkgExtRef to match PackageExternalReferences[0], got no match") + } + err = parser.parsePairFromPackage2_2("ExternalRefComment", ref1Comment) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_2("ExternalRef", ref2) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if len(parser.pkg.PackageExternalReferences) != 2 { + t.Errorf("expected 2 external references, got %d", len(parser.pkg.PackageExternalReferences)) + } + if parser.pkgExtRef == nil { + t.Errorf("expected non-nil pkgExtRef, got nil") + } + if parser.pkg.PackageExternalReferences[1] == nil { + t.Errorf("expected non-nil PackageExternalReferences[1], got nil") + } + if parser.pkgExtRef != parser.pkg.PackageExternalReferences[1] { + t.Errorf("expected pkgExtRef to match PackageExternalReferences[1], got no match") + } + err = parser.parsePairFromPackage2_2("ExternalRefComment", ref2Comment) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // finally, check these values + gotRef1 := parser.pkg.PackageExternalReferences[0] + if gotRef1.Category != ref1Category { + t.Errorf("expected ref1 category to be %s, got %s", gotRef1.Category, ref1Category) + } + if gotRef1.RefType != ref1Type { + t.Errorf("expected ref1 type to be %s, got %s", gotRef1.RefType, ref1Type) + } + if gotRef1.Locator != ref1Locator { + t.Errorf("expected ref1 locator to be %s, got %s", gotRef1.Locator, ref1Locator) + } + if gotRef1.ExternalRefComment != ref1Comment { + t.Errorf("expected ref1 comment to be %s, got %s", gotRef1.ExternalRefComment, ref1Comment) + } + gotRef2 := parser.pkg.PackageExternalReferences[1] + if gotRef2.Category != ref2Category { + t.Errorf("expected ref2 category to be %s, got %s", gotRef2.Category, ref2Category) + } + if gotRef2.RefType != ref2Type { + t.Errorf("expected ref2 type to be %s, got %s", gotRef2.RefType, ref2Type) + } + if gotRef2.Locator != ref2Locator { + t.Errorf("expected ref2 locator to be %s, got %s", gotRef2.Locator, ref2Locator) + } + if gotRef2.ExternalRefComment != ref2Comment { + t.Errorf("expected ref2 comment to be %s, got %s", gotRef2.ExternalRefComment, ref2Comment) + } + +} + +func TestParser2_2CanParsePackageSupplierPersonTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Supplier: Person + err := parser.parsePairFromPackage2_2("PackageSupplier", "Person: John Doe") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSupplierPerson != "John Doe" { + t.Errorf("got %v for PackageSupplierPerson", parser.pkg.PackageSupplierPerson) + } +} + +func TestParser2_2CanParsePackageSupplierOrganizationTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Supplier: Organization + err := parser.parsePairFromPackage2_2("PackageSupplier", "Organization: John Doe, Inc.") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSupplierOrganization != "John Doe, Inc." { + t.Errorf("got %v for PackageSupplierOrganization", parser.pkg.PackageSupplierOrganization) + } +} + +func TestParser2_2CanParsePackageSupplierNOASSERTIONTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Supplier: NOASSERTION + err := parser.parsePairFromPackage2_2("PackageSupplier", "NOASSERTION") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSupplierNOASSERTION != true { + t.Errorf("got false for PackageSupplierNOASSERTION") + } +} + +func TestParser2_2CanParsePackageOriginatorPersonTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Originator: Person + err := parser.parsePairFromPackage2_2("PackageOriginator", "Person: John Doe") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageOriginatorPerson != "John Doe" { + t.Errorf("got %v for PackageOriginatorPerson", parser.pkg.PackageOriginatorPerson) + } +} + +func TestParser2_2CanParsePackageOriginatorOrganizationTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Originator: Organization + err := parser.parsePairFromPackage2_2("PackageOriginator", "Organization: John Doe, Inc.") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageOriginatorOrganization != "John Doe, Inc." { + t.Errorf("got %v for PackageOriginatorOrganization", parser.pkg.PackageOriginatorOrganization) + } +} + +func TestParser2_2CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Originator: NOASSERTION + err := parser.parsePairFromPackage2_2("PackageOriginator", "NOASSERTION") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageOriginatorNOASSERTION != true { + t.Errorf("got false for PackageOriginatorNOASSERTION") + } +} + +func TestParser2_2CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Verification Code with excludes parenthetical + code := "d6a770ba38583ed4bb4525bd96e50461655d2758" + fileName := "./package.spdx" + fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)" + err := parser.parsePairFromPackage2_2("PackageVerificationCode", fullCodeValue) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageVerificationCode != code { + t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode) + } + if parser.pkg.PackageVerificationCodeExcludedFile != fileName { + t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile) + } + +} + +func TestParser2_2CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + // Package Verification Code without excludes parenthetical + code := "d6a770ba38583ed4bb4525bd96e50461655d2758" + err := parser.parsePairFromPackage2_2("PackageVerificationCode", code) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageVerificationCode != code { + t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode) + } + if parser.pkg.PackageVerificationCodeExcludedFile != "" { + t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile) + } + +} + +func TestParser2_2PackageExternalRefPointerChangesAfterTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + err := parser.parsePairFromPackage2_2("ExternalRef", ref1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkgExtRef == nil { + t.Errorf("expected non-nil external reference pointer, got nil") + } + + // now, a comment; pointer should go away + err = parser.parsePairFromPackage2_2("ExternalRefComment", "whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkgExtRef != nil { + t.Errorf("expected nil external reference pointer, got non-nil") + } + + ref2 := "Other LocationRef-something https://example.com/whatever" + err = parser.parsePairFromPackage2_2("ExternalRef", ref2) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkgExtRef == nil { + t.Errorf("expected non-nil external reference pointer, got nil") + } + + // and some other random tag makes the pointer go away too + err = parser.parsePairFromPackage2_2("PackageSummary", "whatever") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkgExtRef != nil { + t.Errorf("expected nil external reference pointer, got non-nil") + } +} + +func TestParser2_2PackageCreatesRelationshipInDocument(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.rln == nil { + t.Fatalf("parser didn't create and point to Relationship struct") + } + if parser.rln != parser.doc.Relationships[0] { + t.Errorf("pointer to new Relationship doesn't match idx 0 for doc.Relationships[]") + } +} + +func TestParser2_2PackageCreatesAnnotationInDocument(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.ann == nil { + t.Fatalf("parser didn't create and point to Annotation struct") + } + if parser.ann != parser.doc.Annotations[0] { + t.Errorf("pointer to new Annotation doesn't match idx 0 for doc.Annotations[]") + } +} + +func TestParser2_2PackageUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{PackageName: "p1", PackageSPDXIdentifier: "p1"}, + } + parser.doc.Packages["p1"] = parser.pkg + + err := parser.parsePairFromPackage2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestParser2_2FailsIfInvalidSPDXIDInPackageSection(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid ID format + err = parser.parsePairFromPackage2_2("SPDXID", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfInvalidPackageSupplierFormat(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid supplier format + err = parser.parsePairFromPackage2_2("PackageSupplier", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfUnknownPackageSupplierType(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid supplier type + err = parser.parsePairFromPackage2_2("PackageSupplier", "whoops: John Doe") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfInvalidPackageOriginatorFormat(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid originator format + err = parser.parsePairFromPackage2_2("PackageOriginator", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfUnknownPackageOriginatorType(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid originator type + err = parser.parsePairFromPackage2_2("PackageOriginator", "whoops: John Doe") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2SetsFilesAnalyzedTagsCorrectly(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // set tag + err = parser.parsePairFromPackage2_2("FilesAnalyzed", "true") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected %v, got %v", true, parser.pkg.FilesAnalyzed) + } + if parser.pkg.IsFilesAnalyzedTagPresent != true { + t.Errorf("expected %v, got %v", true, parser.pkg.IsFilesAnalyzedTagPresent) + } +} + +func TestParser2_2FailsIfInvalidPackageChecksumFormat(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid checksum format + err = parser.parsePairFromPackage2_2("PackageChecksum", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfInvalidPackageChecksumType(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid checksum type + err = parser.parsePairFromPackage2_2("PackageChecksum", "whoops: blah") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfInvalidExternalRefFormat(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid external ref format + err = parser.parsePairFromPackage2_2("ExternalRef", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfExternalRefCommentBeforeExternalRef(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psPackage2_2, + pkg: &spdx.Package2_2{}, + } + + // start with Package Name + err := parser.parsePairFromPackage2_2("PackageName", "p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // external ref comment before external ref + err = parser.parsePairFromPackage2_2("ExternalRefComment", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +// ===== Helper function tests ===== + +func TestCanCheckAndExtractExcludesFilenameAndCode(t *testing.T) { + code := "d6a770ba38583ed4bb4525bd96e50461655d2758" + fileName := "./package.spdx" + fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)" + + gotCode, gotFileName := extractCodeAndExcludes(fullCodeValue) + if gotCode != code { + t.Errorf("got %v for gotCode", gotCode) + } + if gotFileName != fileName { + t.Errorf("got %v for gotFileName", gotFileName) + } +} + +func TestCanExtractPackageExternalReference(t *testing.T) { + ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + category := "SECURITY" + refType := "cpe23Type" + location := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + + gotCategory, gotRefType, gotLocation, err := extractPackageExternalReference(ref1) + if err != nil { + t.Errorf("got non-nil error: %v", err) + } + if gotCategory != category { + t.Errorf("expected category %s, got %s", category, gotCategory) + } + if gotRefType != refType { + t.Errorf("expected refType %s, got %s", refType, gotRefType) + } + if gotLocation != location { + t.Errorf("expected location %s, got %s", location, gotLocation) + } +} + +func TestCanExtractPackageExternalReferenceWithExtraWhitespace(t *testing.T) { + ref1 := " SECURITY \t cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:* \t " + category := "SECURITY" + refType := "cpe23Type" + location := "cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + + gotCategory, gotRefType, gotLocation, err := extractPackageExternalReference(ref1) + if err != nil { + t.Errorf("got non-nil error: %v", err) + } + if gotCategory != category { + t.Errorf("expected category %s, got %s", category, gotCategory) + } + if gotRefType != refType { + t.Errorf("expected refType %s, got %s", refType, gotRefType) + } + if gotLocation != location { + t.Errorf("expected location %s, got %s", location, gotLocation) + } +} + +func TestFailsPackageExternalRefWithInvalidFormat(t *testing.T) { + _, _, _, err := extractPackageExternalReference("whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/parse_relationship.go b/tvloader/parser2v2/parse_relationship.go new file mode 100644 index 0000000..28e5b72 --- /dev/null +++ b/tvloader/parser2v2/parse_relationship.go @@ -0,0 +1,52 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + "strings" +) + +func (parser *tvParser2_2) parsePairForRelationship2_2(tag string, value string) error { + if parser.rln == nil { + return fmt.Errorf("no relationship struct created in parser rln pointer") + } + + if tag == "Relationship" { + // parse the value to see if it's a valid relationship format + sp := strings.SplitN(value, " ", -1) + + // filter out any purely-whitespace items + var rp []string + for _, v := range sp { + v = strings.TrimSpace(v) + if v != "" { + rp = append(rp, v) + } + } + + if len(rp) != 3 { + return fmt.Errorf("invalid relationship format for %s", value) + } + + aID, err := extractDocElementID(strings.TrimSpace(rp[0])) + if err != nil { + return err + } + parser.rln.RefA = aID + parser.rln.Relationship = strings.TrimSpace(rp[1]) + bID, err := extractDocElementID(strings.TrimSpace(rp[2])) + if err != nil { + return err + } + parser.rln.RefB = bID + return nil + } + + if tag == "RelationshipComment" { + parser.rln.RelationshipComment = value + return nil + } + + return fmt.Errorf("received unknown tag %v in Relationship section", tag) +} diff --git a/tvloader/parser2v2/parse_relationship_test.go b/tvloader/parser2v2/parse_relationship_test.go new file mode 100644 index 0000000..1312cc5 --- /dev/null +++ b/tvloader/parser2v2/parse_relationship_test.go @@ -0,0 +1,171 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Relationship section tests ===== +func TestParser2_2FailsIfRelationshipNotSet(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePairForRelationship2_2("Relationship", "SPDXRef-A CONTAINS SPDXRef-B") + if err == nil { + t.Errorf("expected error when calling parsePairFromRelationship2_2 without setting rln pointer") + } +} + +func TestParser2_2FailsIfRelationshipCommentWithoutRelationship(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + err := parser.parsePair2_2("RelationshipComment", "comment whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2 for RelationshipComment without Relationship first") + } +} + +func TestParser2_2CanParseRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // Relationship + err := parser.parsePair2_2("Relationship", "SPDXRef-something CONTAINS DocumentRef-otherdoc:SPDXRef-something-else") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rln.RefA.DocumentRefID != "" || parser.rln.RefA.ElementRefID != "something" { + t.Errorf("got %v for first part of Relationship, expected something", parser.rln.RefA) + } + if parser.rln.RefB.DocumentRefID != "otherdoc" || parser.rln.RefB.ElementRefID != "something-else" { + t.Errorf("got %v for second part of Relationship, expected otherdoc:something-else", parser.rln.RefB) + } + if parser.rln.Relationship != "CONTAINS" { + t.Errorf("got %v for Relationship type, expected CONTAINS", parser.rln.Relationship) + } + + // Relationship Comment + cmt := "this is a comment" + err = parser.parsePair2_2("RelationshipComment", cmt) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rln.RelationshipComment != cmt { + t.Errorf("got %v for RelationshipComment, expected %v", parser.rln.RelationshipComment, cmt) + } +} + +func TestParser2_2InvalidRelationshipTagsNoValueFail(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // no items + parser.rln = nil + err := parser.parsePair2_2("Relationship", "") + if err == nil { + t.Errorf("expected error for empty items in relationship, got nil") + } +} + +func TestParser2_2InvalidRelationshipTagsOneValueFail(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // one item + parser.rln = nil + err := parser.parsePair2_2("Relationship", "DESCRIBES") + if err == nil { + t.Errorf("expected error for only one item in relationship, got nil") + } +} + +func TestParser2_2InvalidRelationshipTagsTwoValuesFail(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // two items + parser.rln = nil + err := parser.parsePair2_2("Relationship", "SPDXRef-DOCUMENT DESCRIBES") + if err == nil { + t.Errorf("expected error for only two items in relationship, got nil") + } +} + +func TestParser2_2InvalidRelationshipTagsThreeValuesSucceed(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // three items but with interspersed additional whitespace + parser.rln = nil + err := parser.parsePair2_2("Relationship", " SPDXRef-DOCUMENT \t DESCRIBES SPDXRef-something-else ") + if err != nil { + t.Errorf("expected pass for three items in relationship w/ extra whitespace, got: %v", err) + } +} + +func TestParser2_2InvalidRelationshipTagsFourValuesFail(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // four items + parser.rln = nil + err := parser.parsePair2_2("Relationship", "SPDXRef-a DESCRIBES SPDXRef-b SPDXRef-c") + if err == nil { + t.Errorf("expected error for more than three items in relationship, got nil") + } +} + +func TestParser2_2InvalidRelationshipTagsInvalidRefIDs(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // four items + parser.rln = nil + err := parser.parsePair2_2("Relationship", "SPDXRef-a DESCRIBES b") + if err == nil { + t.Errorf("expected error for missing SPDXRef- prefix, got nil") + } + + parser.rln = nil + err = parser.parsePair2_2("Relationship", "a DESCRIBES SPDXRef-b") + if err == nil { + t.Errorf("expected error for missing SPDXRef- prefix, got nil") + } +} + +func TestParser2_2FailsToParseUnknownTagInRelationshipSection(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{}, + st: psCreationInfo2_2, + } + + // Relationship + err := parser.parsePair2_2("Relationship", "SPDXRef-something CONTAINS DocumentRef-otherdoc:SPDXRef-something-else") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid tag + err = parser.parsePairForRelationship2_2("blah", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/parse_review.go b/tvloader/parser2v2/parse_review.go new file mode 100644 index 0000000..065d889 --- /dev/null +++ b/tvloader/parser2v2/parse_review.go @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromReview2_2(tag string, value string) error { + switch tag { + // tag for creating new review section + case "Reviewer": + parser.rev = &spdx.Review2_2{} + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + subkey, subvalue, err := extractSubs(value) + if err != nil { + return err + } + switch subkey { + case "Person": + parser.rev.Reviewer = subvalue + parser.rev.ReviewerType = "Person" + case "Organization": + parser.rev.Reviewer = subvalue + parser.rev.ReviewerType = "Organization" + case "Tool": + parser.rev.Reviewer = subvalue + parser.rev.ReviewerType = "Tool" + default: + return fmt.Errorf("unrecognized Reviewer type %v", subkey) + } + case "ReviewDate": + parser.rev.ReviewDate = value + case "ReviewComment": + parser.rev.ReviewComment = value + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in Review section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_review_test.go b/tvloader/parser2v2/parse_review_test.go new file mode 100644 index 0000000..f482184 --- /dev/null +++ b/tvloader/parser2v2/parse_review_test.go @@ -0,0 +1,414 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser review section state change tests ===== +func TestParser2_2ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) { + // create the first review + rev1 := "John Doe" + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{ + Reviewer: rev1, + ReviewerType: "Person", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + r1 := parser.rev + + // the Document's Reviews should have this one only + if len(parser.doc.Reviews) != 1 { + t.Errorf("Expected only one review, got %d", len(parser.doc.Reviews)) + } + if parser.doc.Reviews[0] != r1 { + t.Errorf("Expected review %v in Reviews[0], got %v", r1, parser.doc.Reviews[0]) + } + if parser.doc.Reviews[0].Reviewer != rev1 { + t.Errorf("expected review name %s in Reviews[0], got %s", rev1, parser.doc.Reviews[0].Reviewer) + } + + // now add a new review + rev2 := "Steve" + rp2 := "Person: Steve" + err := parser.parsePair2_2("Reviewer", rp2) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } + // and a review should be created + if parser.rev == nil { + t.Fatalf("parser didn't create new review") + } + // and the reviewer's name should be as expected + if parser.rev.Reviewer != rev2 { + t.Errorf("expected reviewer name %s, got %s", rev2, parser.rev.Reviewer) + } + // and the Document's reviews should be of size 2 and have these two + if len(parser.doc.Reviews) != 2 { + t.Fatalf("Expected Reviews to have len 2, got %d", len(parser.doc.Reviews)) + } + if parser.doc.Reviews[0] != r1 { + t.Errorf("Expected review %v in Reviews[0], got %v", r1, parser.doc.Reviews[0]) + } + if parser.doc.Reviews[0].Reviewer != rev1 { + t.Errorf("expected reviewer name %s in Reviews[0], got %s", rev1, parser.doc.Reviews[0].Reviewer) + } + if parser.doc.Reviews[1] != parser.rev { + t.Errorf("Expected review %v in Reviews[1], got %v", parser.rev, parser.doc.Reviews[1]) + } + if parser.doc.Reviews[1].Reviewer != rev2 { + t.Errorf("expected reviewer name %s in Reviews[1], got %s", rev2, parser.doc.Reviews[1].Reviewer) + } + +} + +func TestParser2_2ReviewStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{ + Reviewer: "Jane Doe", + ReviewerType: "Person", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should remain unchanged + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } + // and the relationship should be in the Document's Relationships + if len(parser.doc.Relationships) != 1 { + t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships)) + } + deID := parser.doc.Relationships[0].RefA + if deID.DocumentRefID != "" || deID.ElementRefID != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still remain unchanged + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } +} + +func TestParser2_2ReviewStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{ + Reviewer: "Jane Doe", + ReviewerType: "Person", + }, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_2) + } + + // and the annotation should be in the Document's Annotations + if len(parser.doc.Annotations) != 1 { + t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations)) + } + if parser.doc.Annotations[0].Annotator != "John Doe ()" { + t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator) + } +} + +func TestParser2_2ReviewFailsAfterParsingOtherSectionTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + // can't go back to old sections + err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } + err = parser.parsePair2_2("PackageName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } + err = parser.parsePair2_2("FileName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } + err = parser.parsePair2_2("LicenseID", "LicenseRef-Lic22") + if err == nil { + t.Errorf("expected error when calling parsePair2_2, got nil") + } +} + +// ===== Review data section tests ===== +func TestParser2_2CanParseReviewTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + // Reviewer (DEPRECATED) + // handled in subsequent subtests + + // Review Date (DEPRECATED) + err := parser.parsePairFromReview2_2("ReviewDate", "2018-09-23T08:30:00Z") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rev.ReviewDate != "2018-09-23T08:30:00Z" { + t.Errorf("got %v for ReviewDate", parser.rev.ReviewDate) + } + + // Review Comment (DEPRECATED) + err = parser.parsePairFromReview2_2("ReviewComment", "this is a comment") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rev.ReviewComment != "this is a comment" { + t.Errorf("got %v for ReviewComment", parser.rev.ReviewComment) + } +} + +func TestParser2_2CanParseReviewerPersonTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + // Reviewer: Person + err := parser.parsePairFromReview2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rev.Reviewer != "John Doe" { + t.Errorf("got %v for Reviewer", parser.rev.Reviewer) + } + if parser.rev.ReviewerType != "Person" { + t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType) + } +} + +func TestParser2_2CanParseReviewerOrganizationTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + // Reviewer: Organization + err := parser.parsePairFromReview2_2("Reviewer", "Organization: John Doe, Inc.") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rev.Reviewer != "John Doe, Inc." { + t.Errorf("got %v for Reviewer", parser.rev.Reviewer) + } + if parser.rev.ReviewerType != "Organization" { + t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType) + } +} + +func TestParser2_2CanParseReviewerToolTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + // Reviewer: Tool + err := parser.parsePairFromReview2_2("Reviewer", "Tool: scannertool - 1.2.12") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rev.Reviewer != "scannertool - 1.2.12" { + t.Errorf("got %v for Reviewer", parser.rev.Reviewer) + } + if parser.rev.ReviewerType != "Tool" { + t.Errorf("got %v for ReviewerType", parser.rev.ReviewerType) + } +} + +func TestParser2_2FailsIfReviewerInvalidFormat(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + rev: &spdx.Review2_2{}, + } + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePairFromReview2_2("Reviewer", "oops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsIfReviewerUnknownType(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + rev: &spdx.Review2_2{}, + } + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePairFromReview2_2("Reviewer", "whoops: John Doe") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2ReviewUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psReview2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, + otherLic: &spdx.OtherLicense2_2{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_2{}, + } + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePairFromReview2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} diff --git a/tvloader/parser2v2/parse_snippet.go b/tvloader/parser2v2/parse_snippet.go new file mode 100644 index 0000000..0d9dc3f --- /dev/null +++ b/tvloader/parser2v2/parse_snippet.go @@ -0,0 +1,124 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + "strconv" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_2) parsePairFromSnippet2_2(tag string, value string) error { + switch tag { + // tag for creating new snippet section + case "SnippetSPDXID": + parser.snippet = &spdx.Snippet2_2{} + eID, err := extractElementID(value) + if err != nil { + return err + } + // FIXME: how should we handle where not associated with current file? + if parser.file != nil { + if parser.file.Snippets == nil { + parser.file.Snippets = map[spdx.ElementID]*spdx.Snippet2_2{} + } + parser.file.Snippets[eID] = parser.snippet + } + parser.snippet.SnippetSPDXIdentifier = eID + // tag for creating new file section and going back to parsing File + case "FileName": + parser.st = psFile2_2 + parser.snippet = nil + return parser.parsePairFromFile2_2(tag, value) + // tag for creating new package section and going back to parsing Package + case "PackageName": + parser.st = psPackage2_2 + parser.file = nil + parser.snippet = nil + return parser.parsePairFromPackage2_2(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_2 + return parser.parsePairFromOtherLicense2_2(tag, value) + // tags for snippet data + case "SnippetFromFileSPDXID": + deID, err := extractDocElementID(value) + if err != nil { + return err + } + parser.snippet.SnippetFromFileSPDXIdentifier = deID + case "SnippetByteRange": + byteStart, byteEnd, err := extractSubs(value) + if err != nil { + return err + } + bIntStart, err := strconv.Atoi(byteStart) + if err != nil { + return err + } + bIntEnd, err := strconv.Atoi(byteEnd) + if err != nil { + return err + } + parser.snippet.SnippetByteRangeStart = bIntStart + parser.snippet.SnippetByteRangeEnd = bIntEnd + case "SnippetLineRange": + lineStart, lineEnd, err := extractSubs(value) + if err != nil { + return err + } + lInttStart, err := strconv.Atoi(lineStart) + if err != nil { + return err + } + lInttEnd, err := strconv.Atoi(lineEnd) + if err != nil { + return err + } + parser.snippet.SnippetLineRangeStart = lInttStart + parser.snippet.SnippetLineRangeEnd = lInttEnd + case "SnippetLicenseConcluded": + parser.snippet.SnippetLicenseConcluded = value + case "LicenseInfoInSnippet": + parser.snippet.LicenseInfoInSnippet = append(parser.snippet.LicenseInfoInSnippet, value) + case "SnippetLicenseComments": + parser.snippet.SnippetLicenseComments = value + case "SnippetCopyrightText": + parser.snippet.SnippetCopyrightText = value + case "SnippetComment": + parser.snippet.SnippetComment = value + case "SnippetName": + parser.snippet.SnippetName = value + case "SnippetAttributionText": + parser.snippet.SnippetAttributionTexts = append(parser.snippet.SnippetAttributionTexts, value) + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_2{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_2(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_2(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_2{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_2(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_2(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_2(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_2 + return parser.parsePairFromReview2_2(tag, value) + default: + return fmt.Errorf("received unknown tag %v in Snippet section", tag) + } + + return nil +} diff --git a/tvloader/parser2v2/parse_snippet_test.go b/tvloader/parser2v2/parse_snippet_test.go new file mode 100644 index 0000000..987fe2a --- /dev/null +++ b/tvloader/parser2v2/parse_snippet_test.go @@ -0,0 +1,616 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser snippet section state change tests ===== +func TestParser2_2SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { + // create the first snippet + sid1 := spdx.ElementID("s1") + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: sid1}, + } + s1 := parser.snippet + parser.doc.Packages["test"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets[sid1] = parser.snippet + + // the File's Snippets should have this one only + if len(parser.file.Snippets) != 1 { + t.Errorf("Expected len(Snippets) to be 1, got %d", len(parser.file.Snippets)) + } + if parser.file.Snippets["s1"] != s1 { + t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"]) + } + if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 { + t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier) + } + + // now add a new snippet + err := parser.parsePair2_2("SnippetSPDXID", "SPDXRef-s2") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psSnippet2_2 { + t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) + } + // and a snippet should be created + if parser.snippet == nil { + t.Fatalf("parser didn't create new snippet") + } + // and the snippet ID should be as expected + if parser.snippet.SnippetSPDXIdentifier != "s2" { + t.Errorf("expected snippet ID %s, got %s", "s2", parser.snippet.SnippetSPDXIdentifier) + } + // and the File's Snippets should be of size 2 and have these two + if len(parser.file.Snippets) != 2 { + t.Errorf("Expected len(Snippets) to be 2, got %d", len(parser.file.Snippets)) + } + if parser.file.Snippets["s1"] != s1 { + t.Errorf("Expected snippet %v in Snippets[s1], got %v", s1, parser.file.Snippets["s1"]) + } + if parser.file.Snippets["s1"].SnippetSPDXIdentifier != sid1 { + t.Errorf("expected snippet ID %s in Snippets[s1], got %s", sid1, parser.file.Snippets["s1"].SnippetSPDXIdentifier) + } + if parser.file.Snippets["s2"] != parser.snippet { + t.Errorf("Expected snippet %v in Snippets[s2], got %v", parser.snippet, parser.file.Snippets["s2"]) + } + if parser.file.Snippets["s2"].SnippetSPDXIdentifier != "s2" { + t.Errorf("expected snippet ID %s in Snippets[s2], got %s", "s2", parser.file.Snippets["s2"].SnippetSPDXIdentifier) + } +} + +func TestParser2_2SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + // now add a new package + p2Name := "package2" + err := parser.parsePair2_2("PackageName", p2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should go back to Package + if parser.st != psPackage2_2 { + t.Errorf("expected state to be %v, got %v", psPackage2_2, parser.st) + } + // and a package should be created + if parser.pkg == nil { + t.Fatalf("parser didn't create new pkg") + } + // and the package name should be as expected + if parser.pkg.PackageName != p2Name { + t.Errorf("expected package name %s, got %s", p2Name, parser.pkg.PackageName) + } + // and the package should default to true for FilesAnalyzed + if parser.pkg.FilesAnalyzed != true { + t.Errorf("expected FilesAnalyzed to default to true, got false") + } + if parser.pkg.IsFilesAnalyzedTagPresent != false { + t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") + } + // and the Document's Packages should still be of size 1 b/c no SPDX + // identifier has been seen yet + if len(parser.doc.Packages) != 1 { + t.Errorf("Expected len(Packages) to be 1, got %d", len(parser.doc.Packages)) + } + if parser.doc.Packages["package1"] != p1 { + t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"]) + } + if parser.doc.Packages["package1"].PackageName != "package1" { + t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages["package1"].PackageName) + } + // and the first Package's Files should be of size 1 and have f1 only + if len(parser.doc.Packages["package1"].Files) != 1 { + t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files)) + } + if parser.doc.Packages["package1"].Files["f1"] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"]) + } + if parser.doc.Packages["package1"].Files["f1"].FileName != "f1.txt" { + t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages["package1"].Files["f1"].FileName) + } + // and the new Package should have no files + if len(parser.pkg.Files) != 0 { + t.Errorf("Expected no files in Packages[1].Files, got %d", len(parser.pkg.Files)) + } + // and the current file should be nil + if parser.file != nil { + t.Errorf("Expected nil for parser.file, got %v", parser.file) + } + // and the current snippet should be nil + if parser.snippet != nil { + t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet) + } +} + +func TestParser2_2SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { + f1Name := "f1.txt" + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + f2Name := "f2.txt" + err := parser.parsePair2_2("FileName", f2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should be correct + if parser.st != psFile2_2 { + t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) + } + // and current package should remain what it was + if parser.pkg != p1 { + t.Fatalf("expected package to remain %v, got %v", p1, parser.pkg) + } + // and a file should be created + if parser.file == nil { + t.Fatalf("parser didn't create new file") + } + // and the file name should be as expected + if parser.file.FileName != f2Name { + t.Errorf("expected file name %s, got %s", f2Name, parser.file.FileName) + } + // and the Package's Files should still be of size 1 since we haven't seen + // an SPDX identifier yet for this new file + if len(parser.pkg.Files) != 1 { + t.Errorf("Expected len(Files) to be 1, got %d", len(parser.pkg.Files)) + } + if parser.pkg.Files["f1"] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files["f1"]) + } + if parser.pkg.Files["f1"].FileName != f1Name { + t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files["f1"].FileName) + } + // and the current snippet should be nil + if parser.snippet != nil { + t.Errorf("Expected nil for parser.snippet, got %v", parser.snippet) + } +} + +func TestParser2_2SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + err := parser.parsePair2_2("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psOtherLicense2_2 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_2, parser.st) + } +} + +func TestParser2_2SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + err := parser.parsePair2_2("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psReview2_2 { + t.Errorf("expected state to be %v, got %v", psReview2_2, parser.st) + } +} + +func TestParser2_2SnippetStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + err := parser.parsePair2_2("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should remain unchanged + if parser.st != psSnippet2_2 { + t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) + } + // and the relationship should be in the Document's Relationships + if len(parser.doc.Relationships) != 1 { + t.Fatalf("expected doc.Relationships to have len 1, got %d", len(parser.doc.Relationships)) + } + deID := parser.doc.Relationships[0].RefA + if deID.DocumentRefID != "" || deID.ElementRefID != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_2("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + // state should still remain unchanged + if parser.st != psSnippet2_2 { + t.Errorf("expected state to be %v, got %v", psSnippet2_2, parser.st) + } +} + +func TestParser2_2SnippetStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + parser.file.Snippets["s1"] = parser.snippet + + err := parser.parsePair2_2("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psSnippet2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) + } + + err = parser.parsePair2_2("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psSnippet2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) + } + + err = parser.parsePair2_2("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psSnippet2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) + } + + err = parser.parsePair2_2("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psSnippet2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) + } + + err = parser.parsePair2_2("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psSnippet2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_2) + } + + // and the annotation should be in the Document's Annotations + if len(parser.doc.Annotations) != 1 { + t.Fatalf("expected doc.Annotations to have len 1, got %d", len(parser.doc.Annotations)) + } + if parser.doc.Annotations[0].Annotator != "John Doe ()" { + t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator) + } +} + +// ===== Snippet data section tests ===== +func TestParser2_2CanParseSnippetTags(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + // Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetSPDXIdentifier != "s1" { + t.Errorf("got %v for SnippetSPDXIdentifier", parser.snippet.SnippetSPDXIdentifier) + } + + // Snippet from File SPDX Identifier + err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "SPDXRef-f1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + wantDeID := spdx.DocElementID{DocumentRefID: "", ElementRefID: spdx.ElementID("f1")} + if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID { + t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier) + } + + // Snippet Byte Range + err = parser.parsePairFromSnippet2_2("SnippetByteRange", "20:320") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetByteRangeStart != 20 { + t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.SnippetByteRangeStart) + } + if parser.snippet.SnippetByteRangeEnd != 320 { + t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.SnippetByteRangeEnd) + } + + // Snippet Line Range + err = parser.parsePairFromSnippet2_2("SnippetLineRange", "5:12") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetLineRangeStart != 5 { + t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.SnippetLineRangeStart) + } + if parser.snippet.SnippetLineRangeEnd != 12 { + t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.SnippetLineRangeEnd) + } + + // Snippet Concluded License + err = parser.parsePairFromSnippet2_2("SnippetLicenseConcluded", "BSD-3-Clause") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetLicenseConcluded != "BSD-3-Clause" { + t.Errorf("got %v for SnippetLicenseConcluded", parser.snippet.SnippetLicenseConcluded) + } + + // License Information in Snippet + lics := []string{ + "Apache-2.0", + "GPL-2.0-or-later", + "CC0-1.0", + } + for _, lic := range lics { + err = parser.parsePairFromSnippet2_2("LicenseInfoInSnippet", lic) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, licWant := range lics { + flagFound := false + for _, licCheck := range parser.snippet.LicenseInfoInSnippet { + if licWant == licCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in LicenseInfoInSnippet", licWant) + } + } + if len(lics) != len(parser.snippet.LicenseInfoInSnippet) { + t.Errorf("expected %d licenses in LicenseInfoInSnippet, got %d", len(lics), + len(parser.snippet.LicenseInfoInSnippet)) + } + + // Snippet Comments on License + err = parser.parsePairFromSnippet2_2("SnippetLicenseComments", "this is a comment about the licenses") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetLicenseComments != "this is a comment about the licenses" { + t.Errorf("got %v for SnippetLicenseComments", parser.snippet.SnippetLicenseComments) + } + + // Snippet Copyright Text + err = parser.parsePairFromSnippet2_2("SnippetCopyrightText", "copyright (c) John Doe and friends") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetCopyrightText != "copyright (c) John Doe and friends" { + t.Errorf("got %v for SnippetCopyrightText", parser.snippet.SnippetCopyrightText) + } + + // Snippet Comment + err = parser.parsePairFromSnippet2_2("SnippetComment", "this is a comment about the snippet") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetComment != "this is a comment about the snippet" { + t.Errorf("got %v for SnippetComment", parser.snippet.SnippetComment) + } + + // Snippet Name + err = parser.parsePairFromSnippet2_2("SnippetName", "from some other package called abc") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetName != "from some other package called abc" { + t.Errorf("got %v for SnippetName", parser.snippet.SnippetName) + } + + // Snippet Attribution Texts + attrs := []string{ + "Include this notice in all advertising materials", + "This is a \nmulti-line string", + } + for _, attr := range attrs { + err = parser.parsePairFromSnippet2_2("SnippetAttributionText", attr) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + } + for _, attrWant := range attrs { + flagFound := false + for _, attrCheck := range parser.snippet.SnippetAttributionTexts { + if attrWant == attrCheck { + flagFound = true + } + } + if flagFound == false { + t.Errorf("didn't find %s in SnippetAttributionText", attrWant) + } + } + if len(attrs) != len(parser.snippet.SnippetAttributionTexts) { + t.Errorf("expected %d attribution texts in SnippetAttributionTexts, got %d", len(attrs), + len(parser.snippet.SnippetAttributionTexts)) + } + +} + +func TestParser2_2SnippetUnknownTagFails(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{SnippetSPDXIdentifier: "s1"}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + err := parser.parsePairFromSnippet2_2("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestParser2_2FailsForInvalidSnippetSPDXID(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + // invalid Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsForInvalidSnippetFromFileSPDXID(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + // start with Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid From File identifier + err = parser.parsePairFromSnippet2_2("SnippetFromFileSPDXID", "whoops") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsForInvalidSnippetByteValues(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + // start with Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid byte formats and values + err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200 210") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } + err = parser.parsePairFromSnippet2_2("SnippetByteRange", "a:210") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } + err = parser.parsePairFromSnippet2_2("SnippetByteRange", "200:a") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} + +func TestParser2_2FailsForInvalidSnippetLineValues(t *testing.T) { + parser := tvParser2_2{ + doc: &spdx.Document2_2{Packages: map[spdx.ElementID]*spdx.Package2_2{}}, + st: psSnippet2_2, + pkg: &spdx.Package2_2{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_2{}}, + file: &spdx.File2_2{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_2{}}, + snippet: &spdx.Snippet2_2{}, + } + parser.doc.Packages["package1"] = parser.pkg + parser.pkg.Files["f1"] = parser.file + + // start with Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_2("SnippetSPDXID", "SPDXRef-s1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // invalid byte formats and values + err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200 210") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } + err = parser.parsePairFromSnippet2_2("SnippetLineRange", "a:210") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } + err = parser.parsePairFromSnippet2_2("SnippetLineRange", "200:a") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/parser.go b/tvloader/parser2v2/parser.go new file mode 100644 index 0000000..e89bab1 --- /dev/null +++ b/tvloader/parser2v2/parser.go @@ -0,0 +1,64 @@ +// Package parser2v2 contains functions to read, load and parse +// SPDX tag-value files, version 2.2. +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" + "github.com/spdx/tools-golang/tvloader/reader" +) + +// ParseTagValues takes a list of (tag, value) pairs, parses it and returns +// a pointer to a parsed SPDX Document. +func ParseTagValues(tvs []reader.TagValuePair) (*spdx.Document2_2, error) { + parser := tvParser2_2{} + for _, tv := range tvs { + err := parser.parsePair2_2(tv.Tag, tv.Value) + if err != nil { + return nil, err + } + } + + return parser.doc, nil +} + +func (parser *tvParser2_2) parsePair2_2(tag string, value string) error { + switch parser.st { + case psStart2_2: + return parser.parsePairFromStart2_2(tag, value) + case psCreationInfo2_2: + return parser.parsePairFromCreationInfo2_2(tag, value) + case psPackage2_2: + return parser.parsePairFromPackage2_2(tag, value) + case psFile2_2: + return parser.parsePairFromFile2_2(tag, value) + case psSnippet2_2: + return parser.parsePairFromSnippet2_2(tag, value) + case psOtherLicense2_2: + return parser.parsePairFromOtherLicense2_2(tag, value) + case psReview2_2: + return parser.parsePairFromReview2_2(tag, value) + default: + return fmt.Errorf("Parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value) + } +} + +func (parser *tvParser2_2) parsePairFromStart2_2(tag string, value string) error { + // fail if not in Start parser state + if parser.st != psStart2_2 { + return fmt.Errorf("Got invalid state %v in parsePairFromStart2_2", parser.st) + } + + // create an SPDX Document data struct if we don't have one already + if parser.doc == nil { + parser.doc = &spdx.Document2_2{} + } + + // move to Creation Info parser state + parser.st = psCreationInfo2_2 + + // and ask Creation Info subfunc to parse + return parser.parsePairFromCreationInfo2_2(tag, value) +} diff --git a/tvloader/parser2v2/parser_test.go b/tvloader/parser2v2/parser_test.go new file mode 100644 index 0000000..a2de032 --- /dev/null +++ b/tvloader/parser2v2/parser_test.go @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/tvloader/reader" +) + +// ===== Parser exported entry point tests ===== +func TestParser2_2CanParseTagValues(t *testing.T) { + var tvPairs []reader.TagValuePair + + // create some pairs + tvPair1 := reader.TagValuePair{Tag: "SPDXVersion", Value: "SPDX-2.2"} + tvPairs = append(tvPairs, tvPair1) + tvPair2 := reader.TagValuePair{Tag: "DataLicense", Value: "CC0-1.0"} + tvPairs = append(tvPairs, tvPair2) + tvPair3 := reader.TagValuePair{Tag: "SPDXID", Value: "SPDXRef-DOCUMENT"} + tvPairs = append(tvPairs, tvPair3) + + // now parse them + doc, err := ParseTagValues(tvPairs) + if err != nil { + t.Errorf("got error when calling ParseTagValues: %v", err) + } + if doc.CreationInfo.SPDXVersion != "SPDX-2.2" { + t.Errorf("expected SPDXVersion to be SPDX-2.2, got %v", doc.CreationInfo.SPDXVersion) + } + if doc.CreationInfo.DataLicense != "CC0-1.0" { + t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.CreationInfo.DataLicense) + } + if doc.CreationInfo.SPDXIdentifier != "SPDXRef-DOCUMENT" { + t.Errorf("expected SPDXIdentifier to be SPDXRef-DOCUMENT, got %v", doc.CreationInfo.SPDXIdentifier) + } + +} + +// ===== Parser initialization tests ===== +func TestParser2_2InitCreatesResetStatus(t *testing.T) { + parser := tvParser2_2{} + if parser.st != psStart2_2 { + t.Errorf("parser did not begin in start state") + } + if parser.doc != nil { + t.Errorf("parser did not begin with nil document") + } +} + +func TestParser2_2HasDocumentAfterCallToParseFirstTag(t *testing.T) { + parser := tvParser2_2{} + err := parser.parsePair2_2("SPDXVersion", "SPDX-2.2") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.doc == nil { + t.Errorf("doc is still nil after parsing first pair") + } +} + +// ===== Parser start state change tests ===== +func TestParser2_2StartMovesToCreationInfoStateAfterParsingFirstTag(t *testing.T) { + parser := tvParser2_2{} + err := parser.parsePair2_2("SPDXVersion", "b") + if err != nil { + t.Errorf("got error when calling parsePair2_2: %v", err) + } + if parser.st != psCreationInfo2_2 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_2) + } +} + +func TestParser2_2StartFailsToParseIfInInvalidState(t *testing.T) { + parser := tvParser2_2{st: psReview2_2} + err := parser.parsePairFromStart2_2("SPDXVersion", "SPDX-2.2") + if err == nil { + t.Errorf("expected non-nil error, got nil") + } +} diff --git a/tvloader/parser2v2/types.go b/tvloader/parser2v2/types.go new file mode 100644 index 0000000..6039a1c --- /dev/null +++ b/tvloader/parser2v2/types.go @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "github.com/spdx/tools-golang/spdx" +) + +type tvParser2_2 struct { + // document into which data is being parsed + doc *spdx.Document2_2 + + // current parser state + st tvParserState2_2 + + // current SPDX item being filled in, if any + pkg *spdx.Package2_2 + pkgExtRef *spdx.PackageExternalReference2_2 + file *spdx.File2_2 + fileAOP *spdx.ArtifactOfProject2_2 + snippet *spdx.Snippet2_2 + otherLic *spdx.OtherLicense2_2 + rln *spdx.Relationship2_2 + ann *spdx.Annotation2_2 + rev *spdx.Review2_2 + // don't need creation info pointer b/c only one, + // and we can get to it via doc.CreationInfo +} + +// parser state (SPDX document version 2.2) +type tvParserState2_2 int + +const ( + // at beginning of document + psStart2_2 tvParserState2_2 = iota + + // in document creation info section + psCreationInfo2_2 + + // in package data section + psPackage2_2 + + // in file data section (including "unpackaged" files) + psFile2_2 + + // in snippet data section (including "unpackaged" files) + psSnippet2_2 + + // in other license section + psOtherLicense2_2 + + // in review section + psReview2_2 +) diff --git a/tvloader/parser2v2/util.go b/tvloader/parser2v2/util.go new file mode 100644 index 0000000..691fe4e --- /dev/null +++ b/tvloader/parser2v2/util.go @@ -0,0 +1,98 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v2 + +import ( + "fmt" + "strings" + + "github.com/spdx/tools-golang/spdx" +) + +// used to extract key / value from embedded substrings +// returns subkey, subvalue, nil if no error, or "", "", error otherwise +func extractSubs(value string) (string, string, error) { + // parse the value to see if it's a valid subvalue format + sp := strings.SplitN(value, ":", 2) + if len(sp) == 1 { + return "", "", fmt.Errorf("invalid subvalue format for %s (no colon found)", value) + } + + subkey := strings.TrimSpace(sp[0]) + subvalue := strings.TrimSpace(sp[1]) + + return subkey, subvalue, nil +} + +// used to extract DocumentRef and SPDXRef values from an SPDX Identifier +// which can point either to this document or to a different one +func extractDocElementID(value string) (spdx.DocElementID, error) { + docRefID := "" + idStr := value + + // check prefix to see if it's a DocumentRef ID + if strings.HasPrefix(idStr, "DocumentRef-") { + // extract the part that comes between "DocumentRef-" and ":" + strs := strings.Split(idStr, ":") + // should be exactly two, part before and part after + if len(strs) < 2 { + return spdx.DocElementID{}, fmt.Errorf("no colon found although DocumentRef- prefix present") + } + if len(strs) > 2 { + return spdx.DocElementID{}, fmt.Errorf("more than one colon found") + } + + // trim the prefix and confirm non-empty + docRefID = strings.TrimPrefix(strs[0], "DocumentRef-") + if docRefID == "" { + return spdx.DocElementID{}, fmt.Errorf("document identifier has nothing after prefix") + } + // and use remainder for element ID parsing + idStr = strs[1] + } + + // check prefix to confirm it's got the right prefix for element IDs + if !strings.HasPrefix(idStr, "SPDXRef-") { + return spdx.DocElementID{}, fmt.Errorf("missing SPDXRef- prefix for element identifier") + } + + // make sure no colons are present + if strings.Contains(idStr, ":") { + // we know this means there was no DocumentRef- prefix, because + // we would have handled multiple colons above if it was + return spdx.DocElementID{}, fmt.Errorf("invalid colon in element identifier") + } + + // trim the prefix and confirm non-empty + eltRefID := strings.TrimPrefix(idStr, "SPDXRef-") + if eltRefID == "" { + return spdx.DocElementID{}, fmt.Errorf("element identifier has nothing after prefix") + } + + // we're good + return spdx.DocElementID{DocumentRefID: docRefID, ElementRefID: spdx.ElementID(eltRefID)}, nil +} + +// used to extract SPDXRef values only from an SPDX Identifier which can point +// to this document only. Use extractDocElementID for parsing IDs that can +// refer either to this document or a different one. +func extractElementID(value string) (spdx.ElementID, error) { + // check prefix to confirm it's got the right prefix for element IDs + if !strings.HasPrefix(value, "SPDXRef-") { + return spdx.ElementID(""), fmt.Errorf("missing SPDXRef- prefix for element identifier") + } + + // make sure no colons are present + if strings.Contains(value, ":") { + return spdx.ElementID(""), fmt.Errorf("invalid colon in element identifier") + } + + // trim the prefix and confirm non-empty + eltRefID := strings.TrimPrefix(value, "SPDXRef-") + if eltRefID == "" { + return spdx.ElementID(""), fmt.Errorf("element identifier has nothing after prefix") + } + + // we're good + return spdx.ElementID(eltRefID), nil +} diff --git a/tvloader/parser2v2/util_test.go b/tvloader/parser2v2/util_test.go new file mode 100644 index 0000000..9f63364 --- /dev/null +++ b/tvloader/parser2v2/util_test.go @@ -0,0 +1,111 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v2 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Helper function tests ===== + +func TestCanExtractSubvalues(t *testing.T) { + subkey, subvalue, err := extractSubs("SHA1: abc123") + if err != nil { + t.Errorf("got error when calling extractSubs: %v", err) + } + if subkey != "SHA1" { + t.Errorf("got %v for subkey", subkey) + } + if subvalue != "abc123" { + t.Errorf("got %v for subvalue", subvalue) + } +} + +func TestReturnsErrorForInvalidSubvalueFormat(t *testing.T) { + _, _, err := extractSubs("blah") + if err == nil { + t.Errorf("expected error when calling extractSubs for invalid format (0 colons), got nil") + } +} + +func TestCanExtractDocumentAndElementRefsFromID(t *testing.T) { + // test with valid ID in this document + helperForExtractDocElementID(t, "SPDXRef-file1", false, "", "file1") + // test with valid ID in another document + helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-file2", false, "doc2", "file2") + // test with invalid ID in this document + helperForExtractDocElementID(t, "a:SPDXRef-file1", true, "", "") + helperForExtractDocElementID(t, "file1", true, "", "") + helperForExtractDocElementID(t, "SPDXRef-", true, "", "") + helperForExtractDocElementID(t, "SPDXRef-file1:", true, "", "") + // test with invalid ID in another document + helperForExtractDocElementID(t, "DocumentRef-doc2", true, "", "") + helperForExtractDocElementID(t, "DocumentRef-doc2:", true, "", "") + helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-", true, "", "") + helperForExtractDocElementID(t, "DocumentRef-doc2:a", true, "", "") + helperForExtractDocElementID(t, "DocumentRef-:", true, "", "") + helperForExtractDocElementID(t, "DocumentRef-:SPDXRef-file1", true, "", "") + // test with invalid formats + helperForExtractDocElementID(t, "DocumentRef-doc2:SPDXRef-file1:file2", true, "", "") +} + +func helperForExtractDocElementID(t *testing.T, tst string, wantErr bool, wantDoc string, wantElt string) { + deID, err := extractDocElementID(tst) + if err != nil && wantErr == false { + t.Errorf("testing %v: expected nil error, got %v", tst, err) + } + if err == nil && wantErr == true { + t.Errorf("testing %v: expected non-nil error, got nil", tst) + } + if deID.DocumentRefID != wantDoc { + if wantDoc == "" { + t.Errorf("testing %v: want empty string for DocumentRefID, got %v", tst, deID.DocumentRefID) + } else { + t.Errorf("testing %v: want %v for DocumentRefID, got %v", tst, wantDoc, deID.DocumentRefID) + } + } + if deID.ElementRefID != spdx.ElementID(wantElt) { + if wantElt == "" { + t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, deID.ElementRefID) + } else { + t.Errorf("testing %v: want %v for ElementRefID, got %v", tst, wantElt, deID.ElementRefID) + } + } +} + +func TestCanExtractElementRefsOnlyFromID(t *testing.T) { + // test with valid ID in this document + helperForExtractElementID(t, "SPDXRef-file1", false, "file1") + // test with valid ID in another document + helperForExtractElementID(t, "DocumentRef-doc2:SPDXRef-file2", true, "") + // test with invalid ID in this document + helperForExtractElementID(t, "a:SPDXRef-file1", true, "") + helperForExtractElementID(t, "file1", true, "") + helperForExtractElementID(t, "SPDXRef-", true, "") + helperForExtractElementID(t, "SPDXRef-file1:", true, "") + // test with invalid ID in another document + helperForExtractElementID(t, "DocumentRef-doc2", true, "") + helperForExtractElementID(t, "DocumentRef-doc2:", true, "") + helperForExtractElementID(t, "DocumentRef-doc2:SPDXRef-", true, "") + helperForExtractElementID(t, "DocumentRef-doc2:a", true, "") + helperForExtractElementID(t, "DocumentRef-:", true, "") + helperForExtractElementID(t, "DocumentRef-:SPDXRef-file1", true, "") +} + +func helperForExtractElementID(t *testing.T, tst string, wantErr bool, wantElt string) { + eID, err := extractElementID(tst) + if err != nil && wantErr == false { + t.Errorf("testing %v: expected nil error, got %v", tst, err) + } + if err == nil && wantErr == true { + t.Errorf("testing %v: expected non-nil error, got nil", tst) + } + if eID != spdx.ElementID(wantElt) { + if wantElt == "" { + t.Errorf("testing %v: want emptyString for ElementRefID, got %v", tst, eID) + } else { + t.Errorf("testing %v: want %v for ElementRefID, got %v", tst, wantElt, eID) + } + } +} |