diff options
Diffstat (limited to 'tvloader')
24 files changed, 5229 insertions, 0 deletions
diff --git a/tvloader/parser2v1/parse_annotation.go b/tvloader/parser2v1/parse_annotation.go new file mode 100644 index 0000000..f83d5bb --- /dev/null +++ b/tvloader/parser2v1/parse_annotation.go @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" +) + +func (parser *tvParser2_1) parsePairForAnnotation2_1(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": + parser.ann.AnnotationSPDXIdentifier = value + case "AnnotationComment": + parser.ann.AnnotationComment = value + default: + return fmt.Errorf("received unknown tag %v in Annotation section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_annotation_test.go b/tvloader/parser2v1/parse_annotation_test.go new file mode 100644 index 0000000..9e53b2d --- /dev/null +++ b/tvloader/parser2v1/parse_annotation_test.go @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Annotation section tests ===== +func TestParser2_1FailsIfAnnotationNotSet(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePairForAnnotation2_1("Annotator", "Person: John Doe (jdoe@example.com)") + if err == nil { + t.Errorf("expected error when calling parsePairFromAnnotation2_1 without setting ann pointer") + } +} + +func TestParser2_1FailsIfAnnotationFieldsWithoutAnnotation(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePair2_1("AnnotationDate", "2018-09-15T17:25:00Z") + if err == nil { + t.Errorf("expected error when calling parsePair2_1 for AnnotationDate without Annotator first") + } + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err == nil { + t.Errorf("expected error when calling parsePair2_1 for AnnotationType without Annotator first") + } + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err == nil { + t.Errorf("expected error when calling parsePair2_1 for SPDXREF without Annotator first") + } + err = parser.parsePair2_1("AnnotationComment", "comment whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1 for AnnotationComment without Annotator first") + } +} + +func TestParser2_1CanParseAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // Annotator without email address + err := parser.parsePair2_1("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_1("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_1("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_1("SPDXREF", ref) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.ann.AnnotationSPDXIdentifier != ref { + t.Errorf("got %v for SPDXREF, expected %v", parser.ann.AnnotationSPDXIdentifier, ref) + } + + // Annotation Comment + cmt := "this is a comment" + err = parser.parsePair2_1("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) + } +} diff --git a/tvloader/parser2v1/parse_creation_info.go b/tvloader/parser2v1/parse_creation_info.go new file mode 100644 index 0000000..f29fe12 --- /dev/null +++ b/tvloader/parser2v1/parse_creation_info.go @@ -0,0 +1,114 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string) error { + // fail if not in Creation Info parser state + if parser.st != psCreationInfo2_1 { + return fmt.Errorf("Got invalid state %v in parsePairFromCreationInfo2_1", 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_1{} + } + + ci := parser.doc.CreationInfo + switch tag { + case "SPDXVersion": + ci.SPDXVersion = value + case "DataLicense": + ci.DataLicense = value + case "SPDXID": + ci.SPDXIdentifier = 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_1 + parser.pkg = &spdx.Package2_1{ + IsUnpackaged: false, + FilesAnalyzed: true, + IsFilesAnalyzedTagPresent: false, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + return parser.parsePairFromPackage2_1(tag, value) + // tag for going on to _unpackaged_ file section + case "FileName": + // create an "unpackaged" Package structure + parser.st = psFile2_1 + parser.pkg = &spdx.Package2_1{ + IsUnpackaged: true, + FilesAnalyzed: true, + IsFilesAnalyzedTagPresent: false, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + return parser.parsePairFromFile2_1(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_1 + return parser.parsePairFromOtherLicense2_1(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_1 + return parser.parsePairFromReview2_1(tag, value) + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + default: + return fmt.Errorf("received unknown tag %v in CreationInfo section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_creation_info_test.go b/tvloader/parser2v1/parse_creation_info_test.go new file mode 100644 index 0000000..ea63dbc --- /dev/null +++ b/tvloader/parser2v1/parse_creation_info_test.go @@ -0,0 +1,448 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser creation info state change tests ===== +func TestParser2_1CIMovesToPackageAfterParsingPackageNameTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + pkgName := "testPkg" + err := parser.parsePair2_1("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } + // 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 _not_ be an "unpackaged" placeholder + if parser.pkg.IsUnpackaged == true { + t.Errorf("package incorrectly has IsUnpackaged flag set") + } + // 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 be in the SPDX Document's slice of packages + flagFound := false + for _, p := range parser.doc.Packages { + if p == parser.pkg { + flagFound = true + } + } + if flagFound == false { + t.Errorf("package isn't in the SPDX Document's slice of packages") + } +} + +func TestParser2_1CIMovesToFileAfterParsingFileNameTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePair2_1("FileName", "testFile") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } + // and current package should be an "unpackaged" placeholder + if parser.pkg == nil { + t.Fatalf("parser didn't create placeholder package") + } + if !parser.pkg.IsUnpackaged { + t.Errorf("placeholder package is not set as unpackaged") + } + // 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 be in the SPDX Document's slice of packages + flagFound := false + for _, p := range parser.doc.Packages { + if p == parser.pkg { + flagFound = true + } + } + if flagFound == false { + t.Errorf("package isn't in the SPDX Document's slice of packages") + } +} + +func TestParser2_1CIMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } +} + +func TestParser2_1CIMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePair2_1("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } +} + +func TestParser2_1CIStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } +} + +func TestParser2_1CIStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this spdx file") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } +} + +// ===== Creation Info section tests ===== +func TestParser2_1HasCreationInfoAfterCallToParseFirstTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePairFromCreationInfo2_1("SPDXVersion", "SPDX-2.1") + if err != nil { + t.Errorf("got error when calling parsePairFromCreationInfo2_1: %v", err) + } + if parser.doc.CreationInfo == nil { + t.Errorf("doc.CreationInfo is still nil after parsing first pair") + } +} + +func TestParser2_1CanParseCreationInfoTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // SPDX Version + err := parser.parsePairFromCreationInfo2_1("SPDXVersion", "SPDX-2.1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.doc.CreationInfo.SPDXVersion != "SPDX-2.1" { + t.Errorf("got %v for SPDXVersion", parser.doc.CreationInfo.SPDXVersion) + } + + // Data License + err = parser.parsePairFromCreationInfo2_1("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_1("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_1("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_1("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_1("ExternalDocumentRef", refs[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_1("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_1("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_1("Creator", refPersons[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_1("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_1("Creator", refOrgs[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_1("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_1("Creator", refTools[0]) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromCreationInfo2_1("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_1("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_1("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_1("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_1InvalidCreatorTagsFail(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePairFromCreationInfo2_1("Creator", "blah: somebody") + if err == nil { + t.Errorf("expected error from parsing invalid Creator format, got nil") + } + + err = parser.parsePairFromCreationInfo2_1("Creator", "Tool with no colons") + if err == nil { + t.Errorf("expected error from parsing invalid Creator format, got nil") + } +} + +func TestParser2_1CreatorTagWithMultipleColonsPasses(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePairFromCreationInfo2_1("Creator", "Tool: tool1:2:3") + if err != nil { + t.Errorf("unexpected error from parsing valid Creator format") + } +} + +func TestParser2_1CIUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePairFromCreationInfo2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestParser2_1CICreatesRelationship(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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_1CICreatesAnnotation(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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/parser2v1/parse_file.go b/tvloader/parser2v1/parse_file.go new file mode 100644 index 0000000..449b4ae --- /dev/null +++ b/tvloader/parser2v1/parse_file.go @@ -0,0 +1,116 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromFile2_1(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_1{} + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.FileName = value + // tag for creating new package section and going back to parsing Package + case "PackageName": + parser.st = psPackage2_1 + parser.file = nil + return parser.parsePairFromPackage2_1(tag, value) + // tag for going on to snippet section + case "SnippetSPDXID": + parser.st = psSnippet2_1 + return parser.parsePairFromSnippet2_1(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_1 + return parser.parsePairFromOtherLicense2_1(tag, value) + // tags for file data + case "SPDXID": + parser.file.FileSPDXIdentifier = value + 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_1{} + 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) + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_1 + return parser.parsePairFromReview2_1(tag, value) + default: + return fmt.Errorf("received unknown tag %v in File section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_file_test.go b/tvloader/parser2v1/parse_file_test.go new file mode 100644 index 0000000..9aef1ea --- /dev/null +++ b/tvloader/parser2v1/parse_file_test.go @@ -0,0 +1,700 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser file section state change tests ===== +func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) { + // create the first file + fileOldName := "f1.txt" + + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: fileOldName}, + } + fileOld := parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, fileOld) + // the Package's Files should have this one only + if parser.pkg.Files[0] != fileOld { + t.Errorf("Expected file %v in Files[0], got %v", fileOld, parser.pkg.Files[0]) + } + if parser.pkg.Files[0].FileName != fileOldName { + t.Errorf("expected file name %s in Files[0], got %s", fileOldName, parser.pkg.Files[0].FileName) + } + + // now add a new file + fileName := "f2.txt" + err := parser.parsePair2_1("FileName", fileName) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psFile2_1 { + t.Errorf("expected state to be %v, got %v", psFile2_1, 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 be of size 2 and have these two + if parser.pkg.Files[0] != fileOld { + t.Errorf("Expected file %v in Files[0], got %v", fileOld, parser.pkg.Files[0]) + } + if parser.pkg.Files[0].FileName != fileOldName { + t.Errorf("expected file name %s in Files[0], got %s", fileOldName, parser.pkg.Files[0].FileName) + } + if parser.pkg.Files[1] != parser.file { + t.Errorf("Expected file %v in Files[1], got %v", parser.file, parser.pkg.Files[1]) + } + if parser.pkg.Files[1].FileName != fileName { + t.Errorf("expected file name %s in Files[1], got %s", fileName, parser.pkg.Files[1].FileName) + } +} + +func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + // create the first file and package + p1Name := "package1" + f1Name := "f1.txt" + + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: p1Name}, + file: &spdx.File2_1{FileName: f1Name}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages = append(parser.doc.Packages, p1) + parser.pkg.Files = append(parser.pkg.Files, f1) + + // now add a new package + p2Name := "package2" + err := parser.parsePair2_1("PackageName", p2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should go back to Package + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, 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 package should _not_ be an "unpackaged" placeholder + if parser.pkg.IsUnpackaged == true { + t.Errorf("package incorrectly has IsUnpackaged flag set") + } + // and the Document's Packages should be of size 2 and have these two + if parser.doc.Packages[0] != p1 { + t.Errorf("Expected package %v in Packages[0], got %v", p1, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].PackageName != p1Name { + t.Errorf("expected package name %s in Packages[0], got %s", p1Name, parser.doc.Packages[0].PackageName) + } + if parser.doc.Packages[1] != parser.pkg { + t.Errorf("Expected package %v in Packages[1], got %v", parser.pkg, parser.doc.Packages[1]) + } + if parser.doc.Packages[1].PackageName != p2Name { + t.Errorf("expected package name %s in Packages[1], got %s", p2Name, parser.doc.Packages[1].PackageName) + } + // and the first Package's Files should be of size 1 and have f1 only + if len(parser.doc.Packages[0].Files) != 1 { + t.Errorf("Expected 1 file in Packages[0].Files, got %d", len(parser.doc.Packages[0].Files)) + } + if parser.doc.Packages[0].Files[0] != f1 { + t.Errorf("Expected file %v in Files[0], got %v", f1, parser.doc.Packages[0].Files[0]) + } + if parser.doc.Packages[0].Files[0].FileName != f1Name { + t.Errorf("expected file name %s in Files[0], got %s", f1Name, parser.doc.Packages[0].Files[0].FileName) + } + // and the second Package should have no files + if len(parser.doc.Packages[1].Files) != 0 { + t.Errorf("Expected no files in Packages[1].Files, got %d", len(parser.doc.Packages[1].Files)) + } + // and the current file should be nil + if parser.file != nil { + t.Errorf("Expected nil for parser.file, got %v", parser.file) + } +} + +func TestParser2_1FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + fileCurrent := parser.file + + err := parser.parsePair2_1("SnippetSPDXID", "SPDXRef-Test1") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psSnippet2_1 { + t.Errorf("expected state to be %v, got %v", psSnippet2_1, 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_1FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, parser.st) + } +} + +func TestParser2_1FileMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, parser.st) + } +} + +func TestParser2_1FileStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should remain unchanged + if parser.st != psFile2_1 { + t.Errorf("expected state to be %v, got %v", psFile2_1, parser.st) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still remain unchanged + if parser.st != psFile2_1 { + t.Errorf("expected state to be %v, got %v", psFile2_1, parser.st) + } +} + +func TestParser2_1FileStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psFile2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) + } +} + +// ===== File data section tests ===== +func TestParser2_1CanParseFileTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + // File Name + err := parser.parsePairFromFile2_1("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) + } + + // File SPDX Identifier + err = parser.parsePairFromFile2_1("SPDXID", "SPDXRef-f1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.file.FileSPDXIdentifier != "SPDXRef-f1" { + t.Errorf("got %v for FileSPDXIdentifier", parser.file.FileSPDXIdentifier) + } + + // File Type + fileTypes := []string{ + "TEXT", + "DOCUMENTATION", + } + for _, ty := range fileTypes { + err = parser.parsePairFromFile2_1("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_1("FileChecksum", sumSha1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("FileChecksum", sumSha256) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("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_1("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_1("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_1("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_1("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_1("ArtifactOfProjectName", "project1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("ArtifactOfProjectHomePage", "http://example.com/1/") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("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_1("ArtifactOfProjectName", "project2") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + // Artifact set 3 -- just name and home page + err = parser.parsePairFromFile2_1("ArtifactOfProjectName", "project3") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("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_1("ArtifactOfProjectName", "project4") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromFile2_1("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_1("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_1("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_1("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_1("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)) + } + +} + +func TestParser2_1FileCreatesRelationshipInDocument(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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_1FileCreatesAnnotationInDocument(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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_1FileUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePairFromFile2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +func TestFileAOPPointerChangesAfterTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + + err := parser.parsePairFromFile2_1("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_1("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_1("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_1("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_1("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) + } +} diff --git a/tvloader/parser2v1/parse_other_license.go b/tvloader/parser2v1/parse_other_license.go new file mode 100644 index 0000000..3090a89 --- /dev/null +++ b/tvloader/parser2v1/parse_other_license.go @@ -0,0 +1,55 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromOtherLicense2_1(tag string, value string) error { + switch tag { + // tag for creating new other license section + case "LicenseID": + parser.otherLic = &spdx.OtherLicense2_1{} + 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_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_1 + return parser.parsePairFromReview2_1(tag, value) + default: + return fmt.Errorf("received unknown tag %v in OtherLicense section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_other_license_test.go b/tvloader/parser2v1/parse_other_license_test.go new file mode 100644 index 0000000..7d004de --- /dev/null +++ b/tvloader/parser2v1/parse_other_license_test.go @@ -0,0 +1,338 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser other license section state change tests ===== +func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + // create the first other license + olid1 := "LicenseRef-Lic11" + olname1 := "License 11" + + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: olid1, + LicenseName: olname1, + }, + } + olic1 := parser.otherLic + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("LicenseID", olid2) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, 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_1("LicenseName", olname2) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still be correct + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, 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_1OLMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_1("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, parser.st) + } +} + +func TestParser2_1OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-whatever", + LicenseName: "the whatever license", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should remain unchanged + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, 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)) + } + if parser.doc.Relationships[0].RefA != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still remain unchanged + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, parser.st) + } +} + +func TestParser2_1OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-whatever", + LicenseName: "the whatever license", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psOtherLicense2_1) + } + + // 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_1OLFailsAfterParsingOtherSectionTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + // can't go back to old sections + err := parser.parsePair2_1("SPDXVersion", "SPDX-2.1") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } + err = parser.parsePair2_1("PackageName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } + err = parser.parsePair2_1("FileName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } +} + +// ===== Other License data section tests ===== +func TestParser2_1CanParseOtherLicenseTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + // License Identifier + err := parser.parsePairFromOtherLicense2_1("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_1("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_1("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_1("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_1("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_1OLUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psOtherLicense2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + + err := parser.parsePairFromOtherLicense2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} diff --git a/tvloader/parser2v1/parse_package.go b/tvloader/parser2v1/parse_package.go new file mode 100644 index 0000000..1d04861 --- /dev/null +++ b/tvloader/parser2v1/parse_package.go @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + "strings" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromPackage2_1(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.PackageName != "" || parser.pkg.IsUnpackaged == true { + parser.pkg = &spdx.Package2_1{ + IsUnpackaged: false, + FilesAnalyzed: true, + IsFilesAnalyzedTagPresent: false, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + } + parser.pkg.PackageName = value + // tag for going on to file section + case "FileName": + parser.st = psFile2_1 + return parser.parsePairFromFile2_1(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_1 + return parser.parsePairFromOtherLicense2_1(tag, value) + case "SPDXID": + parser.pkg.PackageSPDXIdentifier = value + 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 PackageSupplier 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 "ExternalRef": + parser.pkgExtRef = &spdx.PackageExternalReference2_1{} + 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_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_1 + return parser.parsePairFromReview2_1(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/parser2v1/parse_package_test.go b/tvloader/parser2v1/parse_package_test.go new file mode 100644 index 0000000..bba6070 --- /dev/null +++ b/tvloader/parser2v1/parse_package_test.go @@ -0,0 +1,880 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser package section state change tests ===== +func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + // create the first package + pkgOldName := "p1" + + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: pkgOldName}, + } + pkgOld := parser.pkg + parser.doc.Packages = append(parser.doc.Packages, pkgOld) + // the Document's Packages should have this one only + if parser.doc.Packages[0] != pkgOld { + t.Errorf("Expected package %v in Packages[0], got %v", pkgOld, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].PackageName != pkgOldName { + t.Errorf("expected package name %s in Packages[0], got %s", pkgOldName, parser.doc.Packages[0].PackageName) + } + + // now add a new package + pkgName := "p2" + err := parser.parsePair2_1("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, 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 package should _not_ be an "unpackaged" placeholder + if parser.pkg.IsUnpackaged == true { + t.Errorf("package incorrectly has IsUnpackaged flag set") + } + // and the Document's Packages should be of size 2 and have these two + if parser.doc.Packages[0] != pkgOld { + t.Errorf("Expected package %v in Packages[0], got %v", pkgOld, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].PackageName != pkgOldName { + t.Errorf("expected package name %s in Packages[0], got %s", pkgOldName, parser.doc.Packages[0].PackageName) + } + if parser.doc.Packages[1] != parser.pkg { + t.Errorf("Expected package %v in Packages[1], got %v", parser.pkg, parser.doc.Packages[1]) + } + if parser.doc.Packages[1].PackageName != pkgName { + t.Errorf("expected package name %s in Packages[1], got %s", pkgName, parser.doc.Packages[1].PackageName) + } +} + +func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(t *testing.T) { + // create the first package, which is an "unpackaged" Package structure + // (for Files appearing before the first PackageName tag) + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psFile2_1, + pkg: &spdx.Package2_1{IsUnpackaged: true}, + } + pkgOld := parser.pkg + parser.doc.Packages = append(parser.doc.Packages, pkgOld) + // the Document's Packages should have this one only + if parser.doc.Packages[0] != pkgOld { + t.Errorf("Expected package %v in Packages[0], got %v", pkgOld, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].IsUnpackaged != true { + t.Errorf("expected unpackaged 'Package' in Packages[0], got IsUnpackaged == false") + } + + // now add a new package + pkgName := "p2" + err := parser.parsePair2_1("PackageName", pkgName) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, 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 package should _not_ be an "unpackaged" placeholder + if parser.pkg.IsUnpackaged == true { + t.Errorf("package incorrectly has IsUnpackaged flag set") + } + // and the Document's Packages should be of size 2 and have these two + if len(parser.doc.Packages) != 2 { + t.Errorf("Expected %v packages in doc, got %v", 2, len(parser.doc.Packages)) + } + if parser.doc.Packages[0] != pkgOld { + t.Errorf("Expected package %v in Packages[0], got %v", pkgOld, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].IsUnpackaged != true { + t.Errorf("expected unpackaged 'Package' in Packages[0], got IsUnpackaged == false") + } + if parser.doc.Packages[1] != parser.pkg { + t.Errorf("Expected package %v in Packages[1], got %v", parser.pkg, parser.doc.Packages[1]) + } + if parser.doc.Packages[1].PackageName != pkgName { + t.Errorf("expected package name %s in Packages[1], got %s", pkgName, parser.doc.Packages[1].PackageName) + } +} + +func TestParser2_1PackageMovesToFileAfterParsingFileNameTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + pkgCurrent := parser.pkg + + err := parser.parsePair2_1("FileName", "testFile") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psFile2_1 { + t.Errorf("expected state to be %v, got %v", psFile2_1, 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) + } + if parser.pkg.IsUnpackaged { + t.Errorf("expected IsUnpackaged to be false, got true") + } +} + +func TestParser2_1PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, parser.st) + } +} + +func TestParser2_1PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, parser.st) + } +} + +func TestParser2_1PackageStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should remain unchanged + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, parser.st) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still remain unchanged + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, parser.st) + } +} + +func TestParser2_1PackageStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this package") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psPackage2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psPackage2_1) + } +} + +// ===== Package data section tests ===== +func TestParser2_1CanParsePackageTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Name + err := parser.parsePairFromPackage2_1("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) + } + + // Package SPDX Identifier + err = parser.parsePairFromPackage2_1("SPDXID", "SPDXRef-p1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.pkg.PackageSPDXIdentifier != "SPDXRef-p1" { + t.Errorf("got %v for PackageSPDXIdentifier", parser.pkg.PackageSPDXIdentifier) + } + + // Package Version + err = parser.parsePairFromPackage2_1("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_1("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_1("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_1("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_1("PackageChecksum", sumSha1) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_1("PackageChecksum", sumSha256) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_1("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_1("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_1("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_1("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_1("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_1("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_1("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_1("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_1("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_1("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_1("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 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_1("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_1("ExternalRefComment", ref1Comment) + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + err = parser.parsePairFromPackage2_1("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_1("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_1CanParsePackageSupplierPersonTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Supplier: Person + err := parser.parsePairFromPackage2_1("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_1CanParsePackageSupplierOrganizationTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Supplier: Organization + err := parser.parsePairFromPackage2_1("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_1CanParsePackageSupplierNOASSERTIONTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Supplier: NOASSERTION + err := parser.parsePairFromPackage2_1("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_1CanParsePackageOriginatorPersonTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Originator: Person + err := parser.parsePairFromPackage2_1("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_1CanParsePackageOriginatorOrganizationTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Originator: Organization + err := parser.parsePairFromPackage2_1("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_1CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Originator: NOASSERTION + err := parser.parsePairFromPackage2_1("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_1CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Verification Code with excludes parenthetical + code := "d6a770ba38583ed4bb4525bd96e50461655d2758" + fileName := "./package.spdx" + fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)" + err := parser.parsePairFromPackage2_1("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_1CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + // Package Verification Code without excludes parenthetical + code := "d6a770ba38583ed4bb4525bd96e50461655d2758" + err := parser.parsePairFromPackage2_1("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 TestPackageExternalRefPointerChangesAfterTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + ref1 := "SECURITY cpe23Type cpe:2.3:a:pivotal_software:spring_framework:4.1.0:*:*:*:*:*:*:*" + err := parser.parsePairFromPackage2_1("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_1("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_1("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_1("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_1PackageCreatesRelationshipInDocument(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-whatever") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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_1PackageCreatesAnnotationInDocument(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %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_1PackageUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psPackage2_1, + pkg: &spdx.Package2_1{PackageName: "p1", IsUnpackaged: false}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + + err := parser.parsePairFromPackage2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} + +// ===== 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) + } +} diff --git a/tvloader/parser2v1/parse_relationship.go b/tvloader/parser2v1/parse_relationship.go new file mode 100644 index 0000000..8b72285 --- /dev/null +++ b/tvloader/parser2v1/parse_relationship.go @@ -0,0 +1,44 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + "strings" +) + +func (parser *tvParser2_1) parsePairForRelationship2_1(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) + } + + parser.rln.RefA = strings.TrimSpace(rp[0]) + parser.rln.Relationship = strings.TrimSpace(rp[1]) + parser.rln.RefB = strings.TrimSpace(rp[2]) + 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/parser2v1/parse_relationship_test.go b/tvloader/parser2v1/parse_relationship_test.go new file mode 100644 index 0000000..17964fc --- /dev/null +++ b/tvloader/parser2v1/parse_relationship_test.go @@ -0,0 +1,133 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Relationship section tests ===== +func TestParser2_1FailsIfRelationshipNotSet(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePairForRelationship2_1("Relationship", "something DESCRIBES something-else") + if err == nil { + t.Errorf("expected error when calling parsePairFromRelationship2_1 without setting rln pointer") + } +} + +func TestParser2_1FailsIfRelationshipCommentWithoutRelationship(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + err := parser.parsePair2_1("RelationshipComment", "comment whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1 for RelationshipComment without Relationship first") + } +} + +func TestParser2_1CanParseRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // Relationship + err := parser.parsePair2_1("Relationship", "something DESCRIBES something-else") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.rln.RefA != "something" { + t.Errorf("got %v for first part of Relationship, expected something", parser.rln.RefA) + } + if parser.rln.RefB != "something-else" { + t.Errorf("got %v for second part of Relationship, expected something-else", parser.rln.RefB) + } + if parser.rln.Relationship != "DESCRIBES" { + t.Errorf("got %v for Relationship type, expected DESCRIBES", parser.rln.Relationship) + } + + // Relationship Comment + cmt := "this is a comment" + err = parser.parsePair2_1("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_1InvalidRelationshipTagsNoValueFail(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // no items + parser.rln = nil + err := parser.parsePair2_1("Relationship", "") + if err == nil { + t.Errorf("expected error for empty items in relationship, got nil") + } +} + +func TestParser2_1InvalidRelationshipTagsOneValueFail(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // one item + parser.rln = nil + err := parser.parsePair2_1("Relationship", "DESCRIBES") + if err == nil { + t.Errorf("expected error for only one item in relationship, got nil") + } +} + +func TestParser2_1InvalidRelationshipTagsTwoValuesFail(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // two items + parser.rln = nil + err := parser.parsePair2_1("Relationship", "SPDXRef-DOCUMENT DESCRIBES") + if err == nil { + t.Errorf("expected error for only two items in relationship, got nil") + } +} + +func TestParser2_1InvalidRelationshipTagsThreeValuesSucceed(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // three items but with interspersed additional whitespace + parser.rln = nil + err := parser.parsePair2_1("Relationship", " SPDXRef-DOCUMENT \t DESCRIBES something-else ") + if err != nil { + t.Errorf("expected pass for three items in relationship w/ extra whitespace, got: %v", err) + } +} + +func TestParser2_1InvalidRelationshipTagsFourValuesFail(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psCreationInfo2_1, + } + + // four items + parser.rln = nil + err := parser.parsePair2_1("Relationship", "a DESCRIBES b c") + if err == nil { + t.Errorf("expected error for more than three items in relationship, got nil") + } +} diff --git a/tvloader/parser2v1/parse_review.go b/tvloader/parser2v1/parse_review.go new file mode 100644 index 0000000..0d102d3 --- /dev/null +++ b/tvloader/parser2v1/parse_review.go @@ -0,0 +1,63 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromReview2_1(tag string, value string) error { + switch tag { + // tag for creating new review section + case "Reviewer": + parser.rev = &spdx.Review2_1{} + 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_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + default: + return fmt.Errorf("received unknown tag %v in Review section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_review_test.go b/tvloader/parser2v1/parse_review_test.go new file mode 100644 index 0000000..56a0fa8 --- /dev/null +++ b/tvloader/parser2v1/parse_review_test.go @@ -0,0 +1,385 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser review section state change tests ===== +func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) { + // create the first review + rev1 := "John Doe" + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{ + Reviewer: rev1, + ReviewerType: "Person", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("Reviewer", rp2) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, 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_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{ + Reviewer: "Jane Doe", + ReviewerType: "Person", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should remain unchanged + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, 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)) + } + if parser.doc.Relationships[0].RefA != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still remain unchanged + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, parser.st) + } +} + +func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{ + Reviewer: "Jane Doe", + ReviewerType: "Person", + }, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psReview2_1) + } + + // 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_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("SPDXVersion", "SPDX-2.1") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } + err = parser.parsePair2_1("PackageName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } + err = parser.parsePair2_1("FileName", "whatever") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } + err = parser.parsePair2_1("LicenseID", "LicenseRef-Lic22") + if err == nil { + t.Errorf("expected error when calling parsePair2_1, got nil") + } +} + +// ===== Review data section tests ===== +func TestParser2_1CanParseReviewTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("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_1("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_1CanParseReviewerPersonTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("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_1CanParseReviewerOrganizationTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("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_1CanParseReviewerToolTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, 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_1("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_1ReviewUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psReview2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + otherLic: &spdx.OtherLicense2_1{ + LicenseIdentifier: "LicenseRef-Lic11", + LicenseName: "License 11", + }, + rev: &spdx.Review2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.doc.OtherLicenses = append(parser.doc.OtherLicenses, parser.otherLic) + parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) + + err := parser.parsePairFromReview2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} diff --git a/tvloader/parser2v1/parse_snippet.go b/tvloader/parser2v1/parse_snippet.go new file mode 100644 index 0000000..b9abbaf --- /dev/null +++ b/tvloader/parser2v1/parse_snippet.go @@ -0,0 +1,108 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + "strconv" + + "github.com/spdx/tools-golang/spdx" +) + +func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) error { + switch tag { + // tag for creating new snippet section + case "SnippetSPDXID": + parser.snippet = &spdx.Snippet2_1{} + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + parser.snippet.SnippetSPDXIdentifier = value + // tag for creating new file section and going back to parsing File + case "FileName": + parser.st = psFile2_1 + parser.snippet = nil + return parser.parsePairFromFile2_1(tag, value) + // tag for creating new package section and going back to parsing Package + case "PackageName": + parser.st = psPackage2_1 + parser.file = nil + parser.snippet = nil + return parser.parsePairFromPackage2_1(tag, value) + // tag for going on to other license section + case "LicenseID": + parser.st = psOtherLicense2_1 + return parser.parsePairFromOtherLicense2_1(tag, value) + // tags for snippet data + case "SnippetFromFileSPDXID": + parser.snippet.SnippetFromFileSPDXIdentifier = value + 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 + // for relationship tags, pass along but don't change state + case "Relationship": + parser.rln = &spdx.Relationship2_1{} + parser.doc.Relationships = append(parser.doc.Relationships, parser.rln) + return parser.parsePairForRelationship2_1(tag, value) + case "RelationshipComment": + return parser.parsePairForRelationship2_1(tag, value) + // for annotation tags, pass along but don't change state + case "Annotator": + parser.ann = &spdx.Annotation2_1{} + parser.doc.Annotations = append(parser.doc.Annotations, parser.ann) + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationDate": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationType": + return parser.parsePairForAnnotation2_1(tag, value) + case "SPDXREF": + return parser.parsePairForAnnotation2_1(tag, value) + case "AnnotationComment": + return parser.parsePairForAnnotation2_1(tag, value) + // tag for going on to review section (DEPRECATED) + case "Reviewer": + parser.st = psReview2_1 + return parser.parsePairFromReview2_1(tag, value) + default: + return fmt.Errorf("received unknown tag %v in Snippet section", tag) + } + + return nil +} diff --git a/tvloader/parser2v1/parse_snippet_test.go b/tvloader/parser2v1/parse_snippet_test.go new file mode 100644 index 0000000..41b2f9e --- /dev/null +++ b/tvloader/parser2v1/parse_snippet_test.go @@ -0,0 +1,503 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/spdx" +) + +// ===== Parser snippet section state change tests ===== +func TestParser2_1SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { + // create the first snippet + sid1 := "SPDXRef-s1" + + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "test"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: sid1}, + } + s1 := parser.snippet + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, 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[0] != s1 { + t.Errorf("Expected snippet %v in Snippets[0], got %v", s1, parser.file.Snippets[0]) + } + if parser.file.Snippets[0].SnippetSPDXIdentifier != sid1 { + t.Errorf("expected snippet ID %s in Snippets[0], got %s", sid1, parser.file.Snippets[0].SnippetSPDXIdentifier) + } + + // now add a new snippet + sid2 := "SPDXRef-s2" + err := parser.parsePair2_1("SnippetSPDXID", sid2) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psSnippet2_1 { + t.Errorf("expected state to be %v, got %v", psSnippet2_1, 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 != sid2 { + t.Errorf("expected snippet ID %s, got %s", sid2, 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[0] != s1 { + t.Errorf("Expected snippet %v in Snippets[0], got %v", s1, parser.file.Snippets[0]) + } + if parser.file.Snippets[0].SnippetSPDXIdentifier != sid1 { + t.Errorf("expected snippet ID %s in Snippets[0], got %s", sid1, parser.file.Snippets[0].SnippetSPDXIdentifier) + } + if parser.file.Snippets[1] != parser.snippet { + t.Errorf("Expected snippet %v in Snippets[1], got %v", parser.snippet, parser.file.Snippets[1]) + } + if parser.file.Snippets[1].SnippetSPDXIdentifier != sid2 { + t.Errorf("expected snippet ID %s in Snippets[1], got %s", sid2, parser.file.Snippets[1].SnippetSPDXIdentifier) + } +} + +func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { + p1Name := "package1" + f1Name := "f1.txt" + s1Name := "SPDXRef-s1" + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: p1Name}, + file: &spdx.File2_1{FileName: f1Name}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: s1Name}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + // now add a new package + p2Name := "package2" + err := parser.parsePair2_1("PackageName", p2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should go back to Package + if parser.st != psPackage2_1 { + t.Errorf("expected state to be %v, got %v", psPackage2_1, 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 package should _not_ be an "unpackaged" placeholder + if parser.pkg.IsUnpackaged == true { + t.Errorf("package incorrectly has IsUnpackaged flag set") + } + // and the Document's Packages should be of size 2 and have these two + if len(parser.doc.Packages) != 2 { + t.Errorf("Expected len(Packages) to be 2, got %d", len(parser.doc.Packages)) + } + if parser.doc.Packages[0] != p1 { + t.Errorf("Expected package %v in Packages[0], got %v", p1, parser.doc.Packages[0]) + } + if parser.doc.Packages[0].PackageName != p1Name { + t.Errorf("expected package name %s in Packages[0], got %s", p1Name, parser.doc.Packages[0].PackageName) + } + if parser.doc.Packages[1] != parser.pkg { + t.Errorf("Expected package %v in Packages[1], got %v", parser.pkg, parser.doc.Packages[1]) + } + if parser.doc.Packages[1].PackageName != p2Name { + t.Errorf("expected package name %s in Packages[1], got %s", p2Name, parser.doc.Packages[1].PackageName) + } + // and the first Package's Files should be of size 1 and have f1 only + if len(parser.doc.Packages[0].Files) != 1 { + t.Errorf("Expected 1 file in Packages[0].Files, got %d", len(parser.doc.Packages[0].Files)) + } + if parser.doc.Packages[0].Files[0] != f1 { + t.Errorf("Expected file %v in Files[0], got %v", f1, parser.doc.Packages[0].Files[0]) + } + if parser.doc.Packages[0].Files[0].FileName != f1Name { + t.Errorf("expected file name %s in Files[0], got %s", f1Name, parser.doc.Packages[0].Files[0].FileName) + } + // and the second Package should have no files + if len(parser.doc.Packages[1].Files) != 0 { + t.Errorf("Expected no files in Packages[1].Files, got %d", len(parser.doc.Packages[1].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_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { + p1Name := "package1" + f1Name := "f1.txt" + s1Name := "SPDXRef-s1" + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: p1Name}, + file: &spdx.File2_1{FileName: f1Name}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: s1Name}, + } + p1 := parser.pkg + f1 := parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + f2Name := "f2.txt" + err := parser.parsePair2_1("FileName", f2Name) + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should be correct + if parser.st != psFile2_1 { + t.Errorf("expected state to be %v, got %v", psSnippet2_1, 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 be of size 2 and have these two + if parser.pkg.Files[0] != f1 { + t.Errorf("Expected file %v in Files[0], got %v", f1, parser.pkg.Files[0]) + } + if parser.pkg.Files[0].FileName != f1Name { + t.Errorf("expected file name %s in Files[0], got %s", f1Name, parser.pkg.Files[0].FileName) + } + if parser.pkg.Files[1] != parser.file { + t.Errorf("Expected file %v in Files[1], got %v", parser.file, parser.pkg.Files[1]) + } + if parser.pkg.Files[1].FileName != f2Name { + t.Errorf("expected file name %s in Files[1], got %s", f2Name, parser.pkg.Files[1].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_1SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "SPDXRef-s1"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psOtherLicense2_1 { + t.Errorf("expected state to be %v, got %v", psOtherLicense2_1, parser.st) + } +} + +func TestParser2_1SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "SPDXRef-s1"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + err := parser.parsePair2_1("Reviewer", "Person: John Doe") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psReview2_1 { + t.Errorf("expected state to be %v, got %v", psReview2_1, parser.st) + } +} + +func TestParser2_1SnippetStaysAfterParsingRelationshipTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "SPDXRef-s1"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + err := parser.parsePair2_1("Relationship", "blah CONTAINS blah-else") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should remain unchanged + if parser.st != psSnippet2_1 { + t.Errorf("expected state to be %v, got %v", psSnippet2_1, 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)) + } + if parser.doc.Relationships[0].RefA != "blah" { + t.Errorf("expected RefA to be %s, got %s", "blah", parser.doc.Relationships[0].RefA) + } + + err = parser.parsePair2_1("RelationshipComment", "blah") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + // state should still remain unchanged + if parser.st != psSnippet2_1 { + t.Errorf("expected state to be %v, got %v", psSnippet2_1, parser.st) + } +} + +func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "SPDXRef-s1"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + err := parser.parsePair2_1("Annotator", "Person: John Doe ()") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psSnippet2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_1) + } + + err = parser.parsePair2_1("AnnotationDate", "2018-09-15T00:36:00Z") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psSnippet2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_1) + } + + err = parser.parsePair2_1("AnnotationType", "REVIEW") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psSnippet2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_1) + } + + err = parser.parsePair2_1("SPDXREF", "SPDXRef-45") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psSnippet2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_1) + } + + err = parser.parsePair2_1("AnnotationComment", "i guess i had something to say about this particular file") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psSnippet2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psSnippet2_1) + } + + // 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_1CanParseSnippetTags(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + // Snippet SPDX Identifier + err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetSPDXIdentifier != "SPDXRef-s1" { + t.Errorf("got %v for SnippetSPDXIdentifier", parser.snippet.SnippetSPDXIdentifier) + } + + // Snippet from File SPDX Identifier + err = parser.parsePairFromSnippet2_1("SnippetFromFileSPDXID", "SPDXRef-f1") + if err != nil { + t.Errorf("expected nil error, got %v", err) + } + if parser.snippet.SnippetFromFileSPDXIdentifier != "SPDXRef-f1" { + t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier) + } + + // Snippet Byte Range + err = parser.parsePairFromSnippet2_1("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_1("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_1("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_1("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_1("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_1("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_1("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_1("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) + } +} + +func TestParser2_1SnippetUnknownTagFails(t *testing.T) { + parser := tvParser2_1{ + doc: &spdx.Document2_1{}, + st: psSnippet2_1, + pkg: &spdx.Package2_1{PackageName: "package1"}, + file: &spdx.File2_1{FileName: "f1.txt"}, + snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "SPDXRef-s1"}, + } + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) + parser.file.Snippets = append(parser.file.Snippets, parser.snippet) + + err := parser.parsePairFromSnippet2_1("blah", "something") + if err == nil { + t.Errorf("expected error from parsing unknown tag") + } +} diff --git a/tvloader/parser2v1/parser.go b/tvloader/parser2v1/parser.go new file mode 100644 index 0000000..78f4685 --- /dev/null +++ b/tvloader/parser2v1/parser.go @@ -0,0 +1,64 @@ +// Package parser2v1 contains functions to read, load and parse +// SPDX tag-value files. +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +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_1, error) { + parser := tvParser2_1{} + for _, tv := range tvs { + err := parser.parsePair2_1(tv.Tag, tv.Value) + if err != nil { + return nil, err + } + } + + return parser.doc, nil +} + +func (parser *tvParser2_1) parsePair2_1(tag string, value string) error { + switch parser.st { + case psStart2_1: + return parser.parsePairFromStart2_1(tag, value) + case psCreationInfo2_1: + return parser.parsePairFromCreationInfo2_1(tag, value) + case psPackage2_1: + return parser.parsePairFromPackage2_1(tag, value) + case psFile2_1: + return parser.parsePairFromFile2_1(tag, value) + case psSnippet2_1: + return parser.parsePairFromSnippet2_1(tag, value) + case psOtherLicense2_1: + return parser.parsePairFromOtherLicense2_1(tag, value) + case psReview2_1: + return parser.parsePairFromReview2_1(tag, value) + default: + return fmt.Errorf("Parser state %v not recognized when parsing (%s, %s)", parser.st, tag, value) + } +} + +func (parser *tvParser2_1) parsePairFromStart2_1(tag string, value string) error { + // fail if not in Start parser state + if parser.st != psStart2_1 { + return fmt.Errorf("Got invalid state %v in parsePairFromStart2_1", parser.st) + } + + // create an SPDX Document data struct if we don't have one already + if parser.doc == nil { + parser.doc = &spdx.Document2_1{} + } + + // move to Creation Info parser state + parser.st = psCreationInfo2_1 + + // and ask Creation Info subfunc to parse + return parser.parsePairFromCreationInfo2_1(tag, value) +} diff --git a/tvloader/parser2v1/parser_test.go b/tvloader/parser2v1/parser_test.go new file mode 100644 index 0000000..55cb129 --- /dev/null +++ b/tvloader/parser2v1/parser_test.go @@ -0,0 +1,71 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" + + "github.com/spdx/tools-golang/tvloader/reader" +) + +// ===== Parser exported entry point tests ===== +func TestParser2_1CanParseTagValues(t *testing.T) { + var tvPairs []reader.TagValuePair + + // create some pairs + tvPair1 := reader.TagValuePair{Tag: "SPDXVersion", Value: "SPDX-2.1"} + 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.1" { + t.Errorf("expected SPDXVersion to be SPDX-2.1, 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_1InitCreatesResetStatus(t *testing.T) { + parser := tvParser2_1{} + if parser.st != psStart2_1 { + t.Errorf("parser did not begin in start state") + } + if parser.doc != nil { + t.Errorf("parser did not begin with nil document") + } +} + +func TestParser2_1HasDocumentAfterCallToParseFirstTag(t *testing.T) { + parser := tvParser2_1{} + err := parser.parsePair2_1("SPDXVersion", "SPDX-2.1") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.doc == nil { + t.Errorf("doc is still nil after parsing first pair") + } +} + +// ===== Parser start state change tests ===== +func TestParser2_1StartMovesToCreationInfoStateAfterParsingFirstTag(t *testing.T) { + parser := tvParser2_1{} + err := parser.parsePair2_1("SPDXVersion", "b") + if err != nil { + t.Errorf("got error when calling parsePair2_1: %v", err) + } + if parser.st != psCreationInfo2_1 { + t.Errorf("parser is in state %v, expected %v", parser.st, psCreationInfo2_1) + } +} diff --git a/tvloader/parser2v1/types.go b/tvloader/parser2v1/types.go new file mode 100644 index 0000000..5a73864 --- /dev/null +++ b/tvloader/parser2v1/types.go @@ -0,0 +1,54 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "github.com/spdx/tools-golang/spdx" +) + +type tvParser2_1 struct { + // document into which data is being parsed + doc *spdx.Document2_1 + + // current parser state + st tvParserState2_1 + + // current SPDX item being filled in, if any + pkg *spdx.Package2_1 + pkgExtRef *spdx.PackageExternalReference2_1 + file *spdx.File2_1 + fileAOP *spdx.ArtifactOfProject2_1 + snippet *spdx.Snippet2_1 + otherLic *spdx.OtherLicense2_1 + rln *spdx.Relationship2_1 + ann *spdx.Annotation2_1 + rev *spdx.Review2_1 + // 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.1) +type tvParserState2_1 int + +const ( + // at beginning of document + psStart2_1 tvParserState2_1 = iota + + // in document creation info section + psCreationInfo2_1 + + // in package data section + psPackage2_1 + + // in file data section (including "unpackaged" files) + psFile2_1 + + // in snippet data section (including "unpackaged" files) + psSnippet2_1 + + // in other license section + psOtherLicense2_1 + + // in review section + psReview2_1 +) diff --git a/tvloader/parser2v1/util.go b/tvloader/parser2v1/util.go new file mode 100644 index 0000000..ed99063 --- /dev/null +++ b/tvloader/parser2v1/util.go @@ -0,0 +1,23 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package parser2v1 + +import ( + "fmt" + "strings" +) + +// 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 +} diff --git a/tvloader/parser2v1/util_test.go b/tvloader/parser2v1/util_test.go new file mode 100644 index 0000000..c544001 --- /dev/null +++ b/tvloader/parser2v1/util_test.go @@ -0,0 +1,28 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package parser2v1 + +import ( + "testing" +) + +// ===== 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") + } +} diff --git a/tvloader/reader/reader.go b/tvloader/reader/reader.go new file mode 100644 index 0000000..786f7ea --- /dev/null +++ b/tvloader/reader/reader.go @@ -0,0 +1,161 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later + +package reader + +import ( + "bufio" + "fmt" + "io" + "strings" + "unicode" +) + +// TagValuePair is a convenience struct for a (tag, value) string pair. +type TagValuePair struct { + Tag string + Value string +} + +// ReadTagValues takes an io.Reader, scans it line by line and returns +// a slice of {string, string} structs in the form {tag, value}. +func ReadTagValues(content io.Reader) ([]TagValuePair, error) { + r := &tvReader{} + + scanner := bufio.NewScanner(content) + for scanner.Scan() { + // read each line, one by one + err := r.readNextLine(scanner.Text()) + if err != nil { + return nil, err + } + } + if err := scanner.Err(); err != nil { + return nil, err + } + + // finalize and make sure all is well + tvList, err := r.finalize() + if err != nil { + return nil, err + } + + // convert internal format to exported TagValueList + var exportedTVList []TagValuePair + for _, tv := range tvList { + tvPair := TagValuePair{Tag: tv.tag, Value: tv.value} + exportedTVList = append(exportedTVList, tvPair) + } + + return exportedTVList, nil +} + +type tagvalue struct { + tag string + value string +} + +type tvReader struct { + midtext bool + tvList []tagvalue + currentLine int + currentTag string + currentValue string +} + +func (reader *tvReader) finalize() ([]tagvalue, error) { + if reader.midtext { + return nil, fmt.Errorf("finalize called while still midtext parsing a text tag") + } + return reader.tvList, nil +} + +func (reader *tvReader) readNextLine(line string) error { + reader.currentLine++ + + if reader.midtext { + return reader.readNextLineFromMidtext(line) + } + + return reader.readNextLineFromReady(line) +} + +func (reader *tvReader) readNextLineFromReady(line string) error { + // strip whitespace from beginning of line + line2 := strings.TrimLeftFunc(line, func(r rune) bool { + return unicode.IsSpace(r) + }) + + // ignore empty lines + if line2 == "" { + return nil + } + + // ignore comment lines + if strings.HasPrefix(line2, "#") { + return nil + } + + // split at colon + substrings := strings.SplitN(line2, ":", 2) + if len(substrings) == 1 { + // error if a colon isn't found + return fmt.Errorf("no colon found in '%s'", line) + } + + // the first substring is the tag + reader.currentTag = strings.TrimSpace(substrings[0]) + + // determine whether the value contains (or starts) a <text> line + substrings = strings.SplitN(substrings[1], "<text>", 2) + if len(substrings) == 1 { + // no <text> tag found means this is a single-line value + // strip whitespace and use as a single line + reader.currentValue = strings.TrimSpace(substrings[0]) + } else { + // there was a <text> tag; now decide whether it's multi-line + substrings = strings.SplitN(substrings[1], "</text>", 2) + if len(substrings) > 1 { + // there is also a </text> tag; take the middle part and + // set as value + reader.currentValue = substrings[0] + } else { + // there is no </text> tag on this line; switch to midtext + reader.currentValue = substrings[0] + "\n" + reader.midtext = true + return nil + } + } + + // if we got here, the value was on a single line + // so go ahead and add it to the tag-value list + tv := tagvalue{reader.currentTag, reader.currentValue} + reader.tvList = append(reader.tvList, tv) + + // and reset + reader.currentTag = "" + reader.currentValue = "" + + return nil +} + +func (reader *tvReader) readNextLineFromMidtext(line string) error { + // look for whether the line closes here + substrings := strings.SplitN(line, "</text>", 2) + if len(substrings) == 1 { + // doesn't contain </text>, so keep building the current value + reader.currentValue += line + "\n" + return nil + } + + // contains </text>, so end and record this pair + reader.currentValue += substrings[0] + tv := tagvalue{reader.currentTag, reader.currentValue} + reader.tvList = append(reader.tvList, tv) + + // and reset + reader.midtext = false + reader.currentTag = "" + reader.currentValue = "" + + return nil +} diff --git a/tvloader/reader/reader_test.go b/tvloader/reader/reader_test.go new file mode 100644 index 0000000..73b4c9f --- /dev/null +++ b/tvloader/reader/reader_test.go @@ -0,0 +1,563 @@ +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package reader + +import ( + "strings" + "testing" +) + +func TestCanReadTagValues(t *testing.T) { + sText := ` +Tag1: Value1 +Tag2: Value2 + +Tag3: <text>line 1 + line 2</text> +# Comment +Tag4: Value4 +Tag5: Value 5 +` + sReader := strings.NewReader(sText) + + tvPairList, err := ReadTagValues(sReader) + if err != nil { + t.Errorf("got error when calling ReadTagValues: %v", err) + } + if len(tvPairList) != 5 { + t.Fatalf("expected len(tvPairList) to be 5, got %d", len(tvPairList)) + } + if tvPairList[0].Tag != "Tag1" { + t.Errorf("expected tvPairList[0].Tag to be Tag1, got %s", tvPairList[0].Tag) + } + if tvPairList[0].Value != "Value1" { + t.Errorf("expected tvPairList[0].Value to be Value1, got %s", tvPairList[0].Value) + } + if tvPairList[1].Tag != "Tag2" { + t.Errorf("expected tvPairList[1].Tag to be Tag2, got %s", tvPairList[1].Tag) + } + if tvPairList[1].Value != "Value2" { + t.Errorf("expected tvPairList[1].Value to be Value2, got %s", tvPairList[1].Value) + } + if tvPairList[2].Tag != "Tag3" { + t.Errorf("expected tvPairList[2].Tag to be Tag3, got %s", tvPairList[2].Tag) + } + if tvPairList[2].Value != "line 1\n line 2" { + t.Errorf("expected tvPairList[2].Value to be line 1\n line 2, got %s", tvPairList[2].Value) + } + if tvPairList[3].Tag != "Tag4" { + t.Errorf("expected tvPairList[3].Tag to be Tag4, got %s", tvPairList[3].Tag) + } + if tvPairList[3].Value != "Value4" { + t.Errorf("expected tvPairList[3].Value to be Value4, got %s", tvPairList[3].Value) + } + if tvPairList[4].Tag != "Tag5" { + t.Errorf("expected tvPairList[4].Tag to be Tag5, got %s", tvPairList[4].Tag) + } + if tvPairList[4].Value != "Value 5" { + t.Errorf("expected tvPairList[4].Value to be Value 5, got %s", tvPairList[4].Value) + } +} + +func TestCanGetTVListWithFinalize(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + tvList, err := reader.finalize() + if err != nil { + t.Errorf("got error when calling finalize: %v", err) + } + if len(tvList) != 1 || tvList[0].tag != "Tag" || tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", tvList) + } +} + +func TestCanGetTVListIncludingMultilineWithFinalize(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:<text>value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + err = reader.readNextLine("rest of value</text>") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + tvList, err := reader.finalize() + if err != nil { + t.Errorf("got error when calling finalize: %v", err) + } + if len(tvList) != 1 || tvList[0].tag != "Tag" || tvList[0].value != "value\nrest of value" { + t.Errorf("got invalid tag/value list: %v", tvList) + } +} + +func TestCannotFinalizeIfInMidtextState(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:<text>value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + _, err = reader.finalize() + if err == nil { + t.Errorf("should have gotten error when calling finalize midtext") + } +} + +func TestCurrentLineIncreasesOnEachReadCall(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + + reader.currentLine = 23 + err = reader.readNextLine("Tag:value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if reader.currentLine != 24 { + t.Errorf("expected %d for currentLine, got %d", 23, reader.currentLine) + } +} + +func TestReadyCanReadSingleTagValue(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyCanStripWhitespaceFromValue(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag: value ") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } +} + +func TestReadyCannotReadLineWithNoColon(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("No colon should be an error") + if err == nil { + t.Errorf("should have gotten error when calling readNextLine") + } +} + +func TestReadyTextTagSwitchesToMidtext(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag: <text>This begins a multiline value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if !reader.midtext { + t.Errorf("expected midtext to be true, got false") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "Tag" { + t.Errorf("expected %s for currentTag, got %s", "Tag", reader.currentTag) + } + if reader.currentValue != "This begins a multiline value\n" { + t.Errorf("expected %s for currentValue, got %s", "This begins a multiline value\n", reader.currentValue) + } +} + +func TestReadyTextTagAndClosingTagInOneLineFinishesRead(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag: <text>Just one line</text>") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "Just one line" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestCanReadMultilineTextAcrossThreeLines(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag: <text>This value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + err = reader.readNextLine("is three") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + err = reader.readNextLine("lines long</text>") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "This value\nis three\nlines long" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 3 { + t.Errorf("expected %d for currentLine, got %d", 3, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestMidtextContinuesIfNoClosingText(t *testing.T) { + reader := &tvReader{} + reader.midtext = true + reader.currentLine = 1 + reader.currentTag = "Multiline" + reader.currentValue = "First line\n" + + err := reader.readNextLine("Second line") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if !reader.midtext { + t.Errorf("expected midtext to be true, got false") + } + if reader.currentLine != 2 { + t.Errorf("expected %d for currentLine, got %d", 2, reader.currentLine) + } + if reader.currentTag != "Multiline" { + t.Errorf("expected %s for currentTag, got %s", "Multiline", reader.currentTag) + } + if reader.currentValue != "First line\nSecond line\n" { + t.Errorf("expected %s for currentValue, got %s", "First line\nSecond line\n", reader.currentValue) + } +} + +func TestMidtextFinishesIfReachingClosingText(t *testing.T) { + reader := &tvReader{} + reader.midtext = true + reader.currentLine = 1 + reader.currentTag = "Multiline" + reader.currentValue = "First line\n" + + err := reader.readNextLine("Second line</text>") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Multiline" || reader.tvList[0].value != "First line\nSecond line" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 2 { + t.Errorf("expected %d for currentLine, got %d", 2, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyIgnoresCommentLines(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("# this is a comment") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestMidtextIncludesCommentLines(t *testing.T) { + reader := &tvReader{} + reader.midtext = true + reader.currentLine = 1 + reader.currentTag = "Multiline" + reader.currentValue = "First line\n" + + err := reader.readNextLine("# This is part of multiline text") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if !reader.midtext { + t.Errorf("expected midtext to be true, got false") + } + if reader.currentLine != 2 { + t.Errorf("expected %d for currentLine, got %d", 2, reader.currentLine) + } + if reader.currentTag != "Multiline" { + t.Errorf("expected %s for currentTag, got %s", "Multiline", reader.currentTag) + } + if reader.currentValue != "First line\n# This is part of multiline text\n" { + t.Errorf("expected %s for currentValue, got %s", "First line\n# This is part of multiline text\n", reader.currentValue) + } +} + +func TestReadyIgnoresEmptyLines(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestMidtextIncludesEmptyLines(t *testing.T) { + reader := &tvReader{} + reader.midtext = true + reader.currentLine = 1 + reader.currentTag = "Multiline" + reader.currentValue = "First line\n" + + err := reader.readNextLine("") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if !reader.midtext { + t.Errorf("expected midtext to be true, got false") + } + if reader.currentLine != 2 { + t.Errorf("expected %d for currentLine, got %d", 2, reader.currentLine) + } + if reader.currentTag != "Multiline" { + t.Errorf("expected %s for currentTag, got %s", "Multiline", reader.currentTag) + } + if reader.currentValue != "First line\n\n" { + t.Errorf("expected %s for currentValue, got %s", "First line\n\n", reader.currentValue) + } +} + +func TestReadyIgnoresWhitespaceOnlyLines(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine(" \t\t\t ") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestMidtextIncludesWhitespaceOnlyLines(t *testing.T) { + reader := &tvReader{} + reader.midtext = true + reader.currentLine = 1 + reader.currentTag = "Multiline" + reader.currentValue = "First line\n" + + err := reader.readNextLine(" \t\t ") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if !reader.midtext { + t.Errorf("expected midtext to be true, got false") + } + if reader.currentLine != 2 { + t.Errorf("expected %d for currentLine, got %d", 2, reader.currentLine) + } + if reader.currentTag != "Multiline" { + t.Errorf("expected %s for currentTag, got %s", "Multiline", reader.currentTag) + } + if reader.currentValue != "First line\n \t\t \n" { + t.Errorf("expected %s for currentValue, got %s", "First line\n \t\t \n", reader.currentValue) + } +} + +func TestReadyIgnoresSpacesBeforeTag(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine(" \t Tag:value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyIgnoresSpacesBeforeCommentLines(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine(" \t\t # this is a comment") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + + if len(reader.tvList) != 0 { + t.Errorf("expected empty tag/value list, got %v", reader.tvList) + } + if reader.midtext { + t.Errorf("expected midtext to be false, got true") + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyIgnoresSpacesBetweenTagAndColon(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag \t :value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyIgnoresSpacesBetweenColonAndValue(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag: \t value") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} + +func TestReadyIgnoresSpacesAfterEndOfValue(t *testing.T) { + reader := &tvReader{} + err := reader.readNextLine("Tag:value \t ") + if err != nil { + t.Errorf("got error when calling readNextLine: %v", err) + } + if len(reader.tvList) != 1 || reader.tvList[0].tag != "Tag" || reader.tvList[0].value != "value" { + t.Errorf("got invalid tag/value list: %v", reader.tvList) + } + if reader.currentLine != 1 { + t.Errorf("expected %d for currentLine, got %d", 1, reader.currentLine) + } + if reader.currentTag != "" { + t.Errorf("expected empty string for currentTag, got %s", reader.currentTag) + } + if reader.currentValue != "" { + t.Errorf("expected empty string for currentValue, got %s", reader.currentValue) + } +} diff --git a/tvloader/tvloader.go b/tvloader/tvloader.go new file mode 100644 index 0000000..d24c174 --- /dev/null +++ b/tvloader/tvloader.go @@ -0,0 +1,28 @@ +// Package tvloader is used to load and parse SPDX tag-value documents +// into tools-golang data structures. +// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later +package tvloader + +import ( + "io" + + "github.com/spdx/tools-golang/spdx" + "github.com/spdx/tools-golang/tvloader/parser2v1" + "github.com/spdx/tools-golang/tvloader/reader" +) + +// Load2_1 takes an io.Reader and returns a fully-parsed SPDX Document +// (version 2.1) if parseable, or error if any error is encountered. +func Load2_1(content io.Reader) (*spdx.Document2_1, error) { + tvPairs, err := reader.ReadTagValues(content) + if err != nil { + return nil, err + } + + doc, err := parser2v1.ParseTagValues(tvPairs) + if err != nil { + return nil, err + } + + return doc, nil +} |