From 460cf54ece7eba418c50407ee35544c5d63588a7 Mon Sep 17 00:00:00 2001 From: Ian Ling Date: Fri, 8 Apr 2022 08:52:57 -0700 Subject: Overhaul structs, refactor JSON parser and saver Signed-off-by: Ian Ling --- tvloader/parser2v1/parse_annotation.go | 4 +- tvloader/parser2v1/parse_annotation_test.go | 7 +- tvloader/parser2v1/parse_creation_info.go | 46 +---- tvloader/parser2v1/parse_creation_info_test.go | 128 ++---------- tvloader/parser2v1/parse_file.go | 30 +-- tvloader/parser2v1/parse_file_test.go | 260 +++++++++++++------------ tvloader/parser2v1/parse_other_license_test.go | 58 +++--- tvloader/parser2v1/parse_package.go | 48 +++-- tvloader/parser2v1/parse_package_test.go | 185 +++++++++--------- tvloader/parser2v1/parse_review_test.go | 84 ++++---- tvloader/parser2v1/parse_snippet.go | 18 +- tvloader/parser2v1/parse_snippet_test.go | 152 +++++++-------- tvloader/parser2v1/parser.go | 42 +++- tvloader/parser2v1/parser_test.go | 24 +-- 14 files changed, 494 insertions(+), 592 deletions(-) (limited to 'tvloader/parser2v1') diff --git a/tvloader/parser2v1/parse_annotation.go b/tvloader/parser2v1/parse_annotation.go index 65680d9..ca2e850 100644 --- a/tvloader/parser2v1/parse_annotation.go +++ b/tvloader/parser2v1/parse_annotation.go @@ -18,8 +18,8 @@ func (parser *tvParser2_1) parsePairForAnnotation2_1(tag string, value string) e return err } if subkey == "Person" || subkey == "Organization" || subkey == "Tool" { - parser.ann.AnnotatorType = subkey - parser.ann.Annotator = subvalue + parser.ann.Annotator.AnnotatorType = subkey + parser.ann.Annotator.Annotator = subvalue return nil } return fmt.Errorf("unrecognized Annotator type %v", subkey) diff --git a/tvloader/parser2v1/parse_annotation_test.go b/tvloader/parser2v1/parse_annotation_test.go index 3fdce9f..eb0f4cf 100644 --- a/tvloader/parser2v1/parse_annotation_test.go +++ b/tvloader/parser2v1/parse_annotation_test.go @@ -70,11 +70,11 @@ func TestParser2_1CanParseAnnotationTags(t *testing.T) { if err != nil { t.Errorf("expected nil error, got %v", err) } - if parser.ann.Annotator != "John Doe" { + if parser.ann.Annotator.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) + if parser.ann.Annotator.AnnotatorType != "Person" { + t.Errorf("got %v for AnnotatorType, expected Person", parser.ann.Annotator.AnnotatorType) } // Annotation Date @@ -156,4 +156,3 @@ func TestParser2_1FailsIfAnnotationRefInvalid(t *testing.T) { t.Errorf("expected non-nil error, got nil") } } - diff --git a/tvloader/parser2v1/parse_creation_info.go b/tvloader/parser2v1/parse_creation_info.go index 8742bf2..df16008 100644 --- a/tvloader/parser2v1/parse_creation_info.go +++ b/tvloader/parser2v1/parse_creation_info.go @@ -17,39 +17,11 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string // 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{ - ExternalDocumentReferences: map[string]spdx.ExternalDocumentRef2_1{}, - } + parser.doc.CreationInfo = &spdx.CreationInfo2_1{} } ci := parser.doc.CreationInfo switch tag { - case "SPDXVersion": - ci.SPDXVersion = value - case "DataLicense": - ci.DataLicense = value - case "SPDXID": - eID, err := extractElementID(value) - if err != nil { - return err - } - ci.SPDXIdentifier = eID - case "DocumentName": - ci.DocumentName = value - case "DocumentNamespace": - ci.DocumentNamespace = value - case "ExternalDocumentRef": - documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value) - if err != nil { - return err - } - edr := spdx.ExternalDocumentRef2_1{ - DocumentRefID: documentRefID, - URI: uri, - Alg: alg, - Checksum: checksum, - } - ci.ExternalDocumentReferences[documentRefID] = edr case "LicenseListVersion": ci.LicenseListVersion = value case "Creator": @@ -57,22 +29,20 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string if err != nil { return err } + + creator := spdx.Creator{Creator: subvalue} 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) + case "Person", "Organization", "Tool": + creator.CreatorType = subkey default: return fmt.Errorf("unrecognized Creator type %v", subkey) } + + ci.Creators = append(ci.Creators, creator) case "Created": ci.Created = value case "CreatorComment": ci.CreatorComment = value - case "DocumentComment": - ci.DocumentComment = value // tag for going on to package section case "PackageName": @@ -91,7 +61,7 @@ func (parser *tvParser2_1) parsePairFromCreationInfo2_1(tag string, value string return parser.parsePairFromPackage2_1(tag, value) // tag for going on to _unpackaged_ file section case "FileName": - // leave pkg as nil, so that packages will be placed in UnpackagedFiles + // leave pkg as nil, so that packages will be placed in Files parser.st = psFile2_1 parser.pkg = nil return parser.parsePairFromFile2_1(tag, value) diff --git a/tvloader/parser2v1/parse_creation_info_test.go b/tvloader/parser2v1/parse_creation_info_test.go index 2a8c094..83058dd 100644 --- a/tvloader/parser2v1/parse_creation_info_test.go +++ b/tvloader/parser2v1/parse_creation_info_test.go @@ -58,7 +58,7 @@ func TestParser2_1CIMovesToFileAfterParsingFileNameTagWithNoPackages(t *testing. t.Errorf("parser is in state %v, expected %v", parser.st, psFile2_1) } // and current package should be nil, meaning Files are placed in the - // UnpackagedFiles map instead of in a Package + // Files map instead of in a Package if parser.pkg != nil { t.Fatalf("expected pkg to be nil, got non-nil pkg") } @@ -179,7 +179,7 @@ func TestParser2_1HasCreationInfoAfterCallToParseFirstTag(t *testing.T) { doc: &spdx.Document2_1{}, st: psCreationInfo2_1, } - err := parser.parsePairFromCreationInfo2_1("SPDXVersion", "SPDX-2.1") + err := parser.parsePairFromCreationInfo2_1("LicenseListVersion", "3.9") if err != nil { t.Errorf("got error when calling parsePairFromCreationInfo2_1: %v", err) } @@ -194,96 +194,8 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) { 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 != "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", - } - wantRef0 := spdx.ExternalDocumentRef2_1{ - DocumentRefID: "spdx-tool-1.2", - URI: "http://spdx.org/spdxdocs/spdx-tools-v1.2-3F2504E0-4F89-41D3-9A0C-0305E82C3301", - Alg: "SHA1", - Checksum: "d6a770ba38583ed4bb4525bd96e50461655d2759", - } - wantRef1 := spdx.ExternalDocumentRef2_1{ - DocumentRefID: "xyz-2.1.2", - URI: "http://example.com/xyz-2.1.2", - Alg: "SHA1", - Checksum: "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 { - t.Errorf("got %d ExternalDocumentReferences, expected %d", len(parser.doc.CreationInfo.ExternalDocumentReferences), 2) - } - gotRef0 := parser.doc.CreationInfo.ExternalDocumentReferences["spdx-tool-1.2"] - if gotRef0.DocumentRefID != wantRef0.DocumentRefID || - gotRef0.URI != wantRef0.URI || - gotRef0.Alg != wantRef0.Alg || - gotRef0.Checksum != wantRef0.Checksum { - t.Errorf("got %#v for ExternalDocumentReferences[0], wanted %#v", gotRef0, wantRef0) - } - gotRef1 := parser.doc.CreationInfo.ExternalDocumentReferences["xyz-2.1.2"] - if gotRef1.DocumentRefID != wantRef1.DocumentRefID || - gotRef1.URI != wantRef1.URI || - gotRef1.Alg != wantRef1.Alg || - gotRef1.Checksum != wantRef1.Checksum { - t.Errorf("got %#v for ExternalDocumentReferences[1], wanted %#v", gotRef1, wantRef1) - } - // License List Version - err = parser.parsePairFromCreationInfo2_1("LicenseListVersion", "2.2") + err := parser.parsePairFromCreationInfo2_1("LicenseListVersion", "2.2") if err != nil { t.Errorf("expected nil error, got %v", err) } @@ -304,10 +216,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) { 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) + if len(parser.doc.CreationInfo.Creators) != 2 || + parser.doc.CreationInfo.Creators[0].Creator != "Person A" || + parser.doc.CreationInfo.Creators[1].Creator != "Person B" { + t.Errorf("got %+v for Creators", parser.doc.CreationInfo.Creators) } // Creators: Organizations @@ -323,10 +235,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) { 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) + if len(parser.doc.CreationInfo.Creators) != 4 || + parser.doc.CreationInfo.Creators[2].Creator != "Organization A" || + parser.doc.CreationInfo.Creators[3].Creator != "Organization B" { + t.Errorf("got %+v for CreatorOrganizations", parser.doc.CreationInfo.Creators) } // Creators: Tools @@ -342,10 +254,10 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) { 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) + if len(parser.doc.CreationInfo.Creators) != 6 || + parser.doc.CreationInfo.Creators[4].Creator != "Tool A" || + parser.doc.CreationInfo.Creators[5].Creator != "Tool B" { + t.Errorf("got %v for CreatorTools", parser.doc.CreationInfo.Creators) } // Created date @@ -365,16 +277,6 @@ func TestParser2_1CanParseCreationInfoTags(t *testing.T) { 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) { diff --git a/tvloader/parser2v1/parse_file.go b/tvloader/parser2v1/parse_file.go index 7347384..81768bb 100644 --- a/tvloader/parser2v1/parse_file.go +++ b/tvloader/parser2v1/parse_file.go @@ -49,37 +49,37 @@ func (parser *tvParser2_1) parsePairFromFile2_1(tag string, value string) error } parser.file.FileSPDXIdentifier = eID if parser.pkg == nil { - if parser.doc.UnpackagedFiles == nil { - parser.doc.UnpackagedFiles = map[spdx.ElementID]*spdx.File2_1{} + if parser.doc.Files == nil { + parser.doc.Files = []*spdx.File2_1{} } - parser.doc.UnpackagedFiles[eID] = parser.file + parser.doc.Files = append(parser.doc.Files, parser.file) } else { if parser.pkg.Files == nil { - parser.pkg.Files = map[spdx.ElementID]*spdx.File2_1{} + parser.pkg.Files = []*spdx.File2_1{} } - parser.pkg.Files[eID] = parser.file + parser.pkg.Files = append(parser.pkg.Files, parser.file) } case "FileType": - parser.file.FileType = append(parser.file.FileType, value) + parser.file.FileTypes = append(parser.file.FileTypes, 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 + if parser.file.Checksums == nil { + parser.file.Checksums = []spdx.Checksum{} + } + switch spdx.ChecksumAlgorithm(subkey) { + case spdx.SHA1, spdx.SHA256, spdx.MD5: + algorithm := spdx.ChecksumAlgorithm(subkey) + parser.file.Checksums = append(parser.file.Checksums, spdx.Checksum{Algorithm: algorithm, Value: 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) + parser.file.LicenseInfoInFiles = append(parser.file.LicenseInfoInFiles, value) case "LicenseComments": parser.file.LicenseComments = value case "FileCopyrightText": @@ -103,7 +103,7 @@ func (parser *tvParser2_1) parsePairFromFile2_1(tag string, value string) error case "FileNotice": parser.file.FileNotice = value case "FileContributor": - parser.file.FileContributor = append(parser.file.FileContributor, value) + parser.file.FileContributors = append(parser.file.FileContributors, value) case "FileDependency": parser.file.FileDependencies = append(parser.file.FileDependencies, value) // for relationship tags, pass along but don't change state diff --git a/tvloader/parser2v1/parse_file_test.go b/tvloader/parser2v1/parse_file_test.go index 9f42b55..375f967 100644 --- a/tvloader/parser2v1/parse_file_test.go +++ b/tvloader/parser2v1/parse_file_test.go @@ -13,23 +13,23 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) { fileOldName := "f1.txt" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: fileOldName, FileSPDXIdentifier: "f1"}, } fileOld := parser.file - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = fileOld + 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 len(parser.pkg.Files) != 1 { t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f1"] != fileOld { - t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + if parser.pkg.Files[0] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0]) } - if parser.pkg.Files["f1"].FileName != fileOldName { - t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + if parser.pkg.Files[0].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName) } // now add a new file @@ -55,11 +55,11 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) { if len(parser.pkg.Files) != 1 { t.Fatalf("expected 1 file, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f1"] != fileOld { - t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + if parser.pkg.Files[0] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0]) } - if parser.pkg.Files["f1"].FileName != fileOldName { - t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + if parser.pkg.Files[0].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName) } // now parse an SPDX identifier tag @@ -71,17 +71,17 @@ func TestParser2_1FileStartsNewFileAfterParsingFileNameTag(t *testing.T) { if len(parser.pkg.Files) != 2 { t.Fatalf("expected 2 files, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f1"] != fileOld { - t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files["f1"]) + if parser.pkg.Files[0] != fileOld { + t.Errorf("expected file %v in Files[f1], got %v", fileOld, parser.pkg.Files[0]) } - if parser.pkg.Files["f1"].FileName != fileOldName { - t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files["f1"].FileName) + if parser.pkg.Files[0].FileName != fileOldName { + t.Errorf("expected file name %s in Files[f1], got %s", fileOldName, parser.pkg.Files[0].FileName) } - if parser.pkg.Files["f2ID"] != parser.file { - t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files["f2ID"]) + if parser.pkg.Files[1] != parser.file { + t.Errorf("expected file %v in Files[f2ID], got %v", parser.file, parser.pkg.Files[1]) } - if parser.pkg.Files["f2ID"].FileName != fileName { - t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files["f2ID"].FileName) + if parser.pkg.Files[1].FileName != fileName { + t.Errorf("expected file name %s in Files[f2ID], got %s", fileName, parser.pkg.Files[1].FileName) } } @@ -103,12 +103,12 @@ func TestParser2_1FileAddsToPackageOrUnpackagedFiles(t *testing.T) { t.Errorf("got error when calling parsePair2_1: %v", err) } fileOld := parser.file - // should have been added to UnpackagedFiles - if len(parser.doc.UnpackagedFiles) != 1 { - t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles)) + // should have been added to Files + if len(parser.doc.Files) != 1 { + t.Fatalf("expected 1 file in Files, got %d", len(parser.doc.Files)) } - if parser.doc.UnpackagedFiles["f2ID"] != fileOld { - t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"]) + if parser.doc.Files[0] != fileOld { + t.Errorf("expected file %v in Files[f2ID], got %v", fileOld, parser.doc.Files[0]) } // now create a package and a new file err = parser.parsePair2_1("PackageName", "package1") @@ -127,19 +127,19 @@ func TestParser2_1FileAddsToPackageOrUnpackagedFiles(t *testing.T) { if err != nil { t.Errorf("got error when calling parsePair2_1: %v", err) } - // UnpackagedFiles should still be size 1 and have old file only - if len(parser.doc.UnpackagedFiles) != 1 { - t.Fatalf("expected 1 file in UnpackagedFiles, got %d", len(parser.doc.UnpackagedFiles)) + // Files should still be size 1 and have old file only + if len(parser.doc.Files) != 1 { + t.Fatalf("expected 1 file in Files, got %d", len(parser.doc.Files)) } - if parser.doc.UnpackagedFiles["f2ID"] != fileOld { - t.Errorf("expected file %v in UnpackagedFiles[f2ID], got %v", fileOld, parser.doc.UnpackagedFiles["f2ID"]) + if parser.doc.Files[0] != fileOld { + t.Errorf("expected file %v in Files[f2ID], got %v", fileOld, parser.doc.Files[0]) } // and new package should have gotten the new file if len(parser.pkg.Files) != 1 { t.Fatalf("expected 1 file in Files, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f3ID"] != parser.file { - t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files["f3ID"]) + if parser.pkg.Files[0] != parser.file { + t.Errorf("expected file %v in Files[f3ID], got %v", parser.file, parser.pkg.Files[0]) } } @@ -149,15 +149,15 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { f1Name := "f1.txt" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: p1Name, PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: f1Name, FileSPDXIdentifier: "f1"}, } p1 := parser.pkg f1 := parser.file - parser.doc.Packages["package1"] = p1 - parser.pkg.Files["f1"] = f1 + parser.doc.Packages = append(parser.doc.Packages, p1) + parser.pkg.Files = append(parser.pkg.Files, f1) // now add a new package p2Name := "package2" @@ -193,21 +193,21 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { if len(parser.doc.Packages) != 1 { t.Fatalf("expected 1 package, got %d", len(parser.doc.Packages)) } - if parser.doc.Packages["package1"] != p1 { - t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"]) + if parser.doc.Packages[0] != p1 { + t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages[0]) } - if parser.doc.Packages["package1"].PackageName != p1Name { - t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages["package1"].PackageName) + if parser.doc.Packages[0].PackageName != p1Name { + t.Errorf("expected package name %s in Packages[package1], got %s", p1Name, parser.doc.Packages[0].PackageName) } // and the first Package's Files should be of size 1 and have f1 only - if len(parser.doc.Packages["package1"].Files) != 1 { - t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files)) + if len(parser.doc.Packages[0].Files) != 1 { + t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages[0].Files)) } - if parser.doc.Packages["package1"].Files["f1"] != f1 { - t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"]) + if parser.doc.Packages[0].Files[0] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages[0].Files[0]) } - if parser.doc.Packages["package1"].Files["f1"].FileName != f1Name { - t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages["package1"].Files["f1"].FileName) + if parser.doc.Packages[0].Files[0].FileName != f1Name { + t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.doc.Packages[0].Files[0].FileName) } // and the current file should be nil if parser.file != nil { @@ -217,13 +217,13 @@ func TestParser2_1FileStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { func TestParser2_1FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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") @@ -242,13 +242,13 @@ func TestParser2_1FileMovesToSnippetAfterParsingSnippetSPDXIDTag(t *testing.T) { func TestParser2_1FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -261,13 +261,13 @@ func TestParser2_1FileMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) func TestParser2_1FileMovesToReviewAfterParsingReviewerTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -280,13 +280,13 @@ func TestParser2_1FileMovesToReviewAfterParsingReviewerTag(t *testing.T) { func TestParser2_1FileStaysAfterParsingRelationshipTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") if err != nil { @@ -309,13 +309,13 @@ func TestParser2_1FileStaysAfterParsingRelationshipTags(t *testing.T) { func TestParser2_1FileStaysAfterParsingAnnotationTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -361,11 +361,11 @@ func TestParser2_1FileStaysAfterParsingAnnotationTags(t *testing.T) { // ===== File data section tests ===== func TestParser2_1CanParseFileTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -393,8 +393,8 @@ func TestParser2_1CanParseFileTags(t *testing.T) { if len(parser.pkg.Files) != 1 { t.Errorf("expected 1 file, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f1"] != parser.file { - t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files["f1"]) + if parser.pkg.Files[0] != parser.file { + t.Errorf("expected Files[f1] to be %v, got %v", parser.file, parser.pkg.Files[0]) } // File Type @@ -410,18 +410,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) { } for _, typeWant := range fileTypes { flagFound := false - for _, typeCheck := range parser.file.FileType { + for _, typeCheck := range parser.file.FileTypes { if typeWant == typeCheck { flagFound = true } } if flagFound == false { - t.Errorf("didn't find %s in FileType", typeWant) + t.Errorf("didn't find %s in FileTypes", typeWant) } } - if len(fileTypes) != len(parser.file.FileType) { - t.Errorf("expected %d types in FileType, got %d", len(fileTypes), - len(parser.file.FileType)) + if len(fileTypes) != len(parser.file.FileTypes) { + t.Errorf("expected %d types in FileTypes, got %d", len(fileTypes), + len(parser.file.FileTypes)) } // File Checksums @@ -443,16 +443,22 @@ func TestParser2_1CanParseFileTags(t *testing.T) { 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) + for _, checksum := range parser.file.Checksums { + switch checksum.Algorithm { + case spdx.SHA1: + if checksum.Value != codeSha1 { + t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha1, checksum.Value) + } + case spdx.SHA256: + if checksum.Value != codeSha256 { + t.Errorf("expected %s for FileChecksumSHA1, got %s", codeSha256, checksum.Value) + } + case spdx.MD5: + if checksum.Value != codeMd5 { + t.Errorf("expected %s for FileChecksumSHA1, got %s", codeMd5, checksum.Value) + } + } } - // Concluded License err = parser.parsePairFromFile2_1("LicenseConcluded", "Apache-2.0 OR GPL-2.0-or-later") if err != nil { @@ -476,18 +482,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) { } for _, licWant := range lics { flagFound := false - for _, licCheck := range parser.file.LicenseInfoInFile { + for _, licCheck := range parser.file.LicenseInfoInFiles { if licWant == licCheck { flagFound = true } } if flagFound == false { - t.Errorf("didn't find %s in LicenseInfoInFile", licWant) + t.Errorf("didn't find %s in LicenseInfoInFiles", licWant) } } - if len(lics) != len(parser.file.LicenseInfoInFile) { - t.Errorf("expected %d licenses in LicenseInfoInFile, got %d", len(lics), - len(parser.file.LicenseInfoInFile)) + if len(lics) != len(parser.file.LicenseInfoInFiles) { + t.Errorf("expected %d licenses in LicenseInfoInFiles, got %d", len(lics), + len(parser.file.LicenseInfoInFiles)) } // Comments on License @@ -625,18 +631,18 @@ func TestParser2_1CanParseFileTags(t *testing.T) { } for _, contribWant := range contribs { flagFound := false - for _, contribCheck := range parser.file.FileContributor { + for _, contribCheck := range parser.file.FileContributors { if contribWant == contribCheck { flagFound = true } } if flagFound == false { - t.Errorf("didn't find %s in FileContributor", contribWant) + t.Errorf("didn't find %s in FileContributors", contribWant) } } - if len(contribs) != len(parser.file.FileContributor) { - t.Errorf("expected %d contribenses in FileContributor, got %d", len(contribs), - len(parser.file.FileContributor)) + if len(contribs) != len(parser.file.FileContributors) { + t.Errorf("expected %d contribenses in FileContributors, got %d", len(contribs), + len(parser.file.FileContributors)) } // File Dependencies @@ -670,13 +676,13 @@ func TestParser2_1CanParseFileTags(t *testing.T) { func TestParser2_1FileCreatesRelationshipInDocument(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever") if err != nil { @@ -692,13 +698,13 @@ func TestParser2_1FileCreatesRelationshipInDocument(t *testing.T) { func TestParser2_1FileCreatesAnnotationInDocument(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -714,13 +720,13 @@ func TestParser2_1FileCreatesAnnotationInDocument(t *testing.T) { func TestParser2_1FileUnknownTagFails(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -730,13 +736,13 @@ func TestParser2_1FileUnknownTagFails(t *testing.T) { func TestFileAOPPointerChangesAfterTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 { @@ -787,11 +793,11 @@ func TestFileAOPPointerChangesAfterTags(t *testing.T) { func TestParser2_1FailsIfInvalidSPDXIDInFileSection(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // start with File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -807,11 +813,11 @@ func TestParser2_1FailsIfInvalidSPDXIDInFileSection(t *testing.T) { func TestParser2_1FailsIfInvalidChecksumFormatInFileSection(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // start with File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -827,11 +833,11 @@ func TestParser2_1FailsIfInvalidChecksumFormatInFileSection(t *testing.T) { func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // start with File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -847,11 +853,11 @@ func TestParser2_1FailsIfUnknownChecksumTypeInFileSection(t *testing.T) { func TestParser2_1FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // start with File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -867,11 +873,11 @@ func TestParser2_1FailsIfArtifactHomePageBeforeArtifactName(t *testing.T) { func TestParser2_1FailsIfArtifactURIBeforeArtifactName(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, } - parser.doc.Packages["test"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // start with File Name err := parser.parsePairFromFile2_1("FileName", "f1.txt") @@ -888,7 +894,7 @@ func TestParser2_1FailsIfArtifactURIBeforeArtifactName(t *testing.T) { func TestParser2_1FilesWithoutSpdxIdThrowError(t *testing.T) { // case 1: The previous file (packaged or unpackaged) does not contain spdxID parser1 := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, file: &spdx.File2_1{FileName: "FileName"}, } diff --git a/tvloader/parser2v1/parse_other_license_test.go b/tvloader/parser2v1/parse_other_license_test.go index d97eb1c..5ae520b 100644 --- a/tvloader/parser2v1/parse_other_license_test.go +++ b/tvloader/parser2v1/parse_other_license_test.go @@ -14,9 +14,9 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) olname1 := "License 11" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: olid1, @@ -24,8 +24,8 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) }, } olic1 := parser.otherLic - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 @@ -90,13 +90,13 @@ func TestParser2_1OLStartsNewOtherLicenseAfterParsingLicenseIDTag(t *testing.T) func TestParser2_1OLMovesToReviewAfterParsingReviewerTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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") @@ -110,17 +110,17 @@ func TestParser2_1OLMovesToReviewAfterParsingReviewerTag(t *testing.T) { func TestParser2_1OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-whatever", LicenseName: "the whatever license", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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", "SPDXRef-blah CONTAINS SPDXRef-blah-else") @@ -152,17 +152,17 @@ func TestParser2_1OtherLicenseStaysAfterParsingRelationshipTags(t *testing.T) { func TestParser2_1OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-whatever", LicenseName: "the whatever license", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 ()") @@ -209,24 +209,24 @@ func TestParser2_1OtherLicenseStaysAfterParsingAnnotationTags(t *testing.T) { 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 ()" { + if parser.doc.Annotations[0].Annotator.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{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", LicenseName: "License 11", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 @@ -247,13 +247,13 @@ func TestParser2_1OLFailsAfterParsingOtherSectionTags(t *testing.T) { // ===== Other License data section tests ===== func TestParser2_1CanParseOtherLicenseTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 @@ -323,13 +323,13 @@ func TestParser2_1CanParseOtherLicenseTags(t *testing.T) { func TestParser2_1OLUnknownTagFails(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psOtherLicense2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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") diff --git a/tvloader/parser2v1/parse_package.go b/tvloader/parser2v1/parse_package.go index a867107..22fc1ed 100644 --- a/tvloader/parser2v1/parse_package.go +++ b/tvloader/parser2v1/parse_package.go @@ -45,16 +45,17 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err } parser.pkg.PackageSPDXIdentifier = eID if parser.doc.Packages == nil { - parser.doc.Packages = map[spdx.ElementID]*spdx.Package2_1{} + parser.doc.Packages = []*spdx.Package2_1{} } - parser.doc.Packages[eID] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) case "PackageVersion": parser.pkg.PackageVersion = value case "PackageFileName": parser.pkg.PackageFileName = value case "PackageSupplier": + parser.pkg.PackageSupplier = &spdx.Supplier{} if value == "NOASSERTION" { - parser.pkg.PackageSupplierNOASSERTION = true + parser.pkg.PackageSupplier.Supplier = value break } subkey, subvalue, err := extractSubs(value) @@ -62,16 +63,16 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err return err } switch subkey { - case "Person": - parser.pkg.PackageSupplierPerson = subvalue - case "Organization": - parser.pkg.PackageSupplierOrganization = subvalue + case "Person", "Organization": + parser.pkg.PackageSupplier.Supplier = subvalue + parser.pkg.PackageSupplier.SupplierType = subkey default: return fmt.Errorf("unrecognized PackageSupplier type %v", subkey) } case "PackageOriginator": + parser.pkg.PackageOriginator = &spdx.Originator{} if value == "NOASSERTION" { - parser.pkg.PackageOriginatorNOASSERTION = true + parser.pkg.PackageOriginator.Originator = value break } subkey, subvalue, err := extractSubs(value) @@ -79,10 +80,9 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err return err } switch subkey { - case "Person": - parser.pkg.PackageOriginatorPerson = subvalue - case "Organization": - parser.pkg.PackageOriginatorOrganization = subvalue + case "Person", "Organization": + parser.pkg.PackageOriginator.Originator = subvalue + parser.pkg.PackageOriginator.OriginatorType = subkey default: return fmt.Errorf("unrecognized PackageOriginator type %v", subkey) } @@ -96,21 +96,19 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err parser.pkg.FilesAnalyzed = true } case "PackageVerificationCode": - code, excludesFileName := extractCodeAndExcludes(value) - parser.pkg.PackageVerificationCode = code - parser.pkg.PackageVerificationCodeExcludedFile = excludesFileName + parser.pkg.PackageVerificationCode = extractCodeAndExcludes(value) 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 + if parser.pkg.PackageChecksums == nil { + parser.pkg.PackageChecksums = []spdx.Checksum{} + } + switch spdx.ChecksumAlgorithm(subkey) { + case spdx.SHA1, spdx.SHA256, spdx.MD5: + algorithm := spdx.ChecksumAlgorithm(subkey) + parser.pkg.PackageChecksums = append(parser.pkg.PackageChecksums, spdx.Checksum{Algorithm: algorithm, Value: subvalue}) default: return fmt.Errorf("got unknown checksum type %s", subkey) } @@ -184,13 +182,13 @@ func (parser *tvParser2_1) parsePairFromPackage2_1(tag string, value string) err // ===== Helper functions ===== -func extractCodeAndExcludes(value string) (string, string) { +func extractCodeAndExcludes(value string) spdx.PackageVerificationCode { // 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, "" + return spdx.PackageVerificationCode{Value: value, ExcludedFiles: []string{}} } // if we're here, code is in first part and excludes filename is in @@ -198,7 +196,7 @@ func extractCodeAndExcludes(value string) (string, string) { code := strings.TrimSpace(sp[0]) parsedSp := strings.SplitN(sp[1], ")", 2) fileName := strings.TrimSpace(parsedSp[0]) - return code, fileName + return spdx.PackageVerificationCode{Value: code, ExcludedFiles: []string{fileName}} } func extractPackageExternalReference(value string) (string, string, string, error) { diff --git a/tvloader/parser2v1/parse_package_test.go b/tvloader/parser2v1/parse_package_test.go index 3cda3ce..734fc91 100644 --- a/tvloader/parser2v1/parse_package_test.go +++ b/tvloader/parser2v1/parse_package_test.go @@ -13,19 +13,12 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T pkgOldName := "p1" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: pkgOldName, PackageSPDXIdentifier: "p1"}, } pkgOld := parser.pkg - parser.doc.Packages["p1"] = pkgOld - // the Document's Packages should have this one only - if parser.doc.Packages["p1"] != pkgOld { - t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"]) - } - if len(parser.doc.Packages) != 1 { - t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) - } + parser.doc.Packages = append(parser.doc.Packages, pkgOld) // now add a new package pkgName := "p2" @@ -57,8 +50,8 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T t.Errorf("expected IsFilesAnalyzedTagPresent to default to false, got true") } // and the Document's Packages should still be of size 1 and have pkgOld only - if parser.doc.Packages["p1"] != pkgOld { - t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages["p1"]) + if parser.doc.Packages[0] != pkgOld { + t.Errorf("Expected package %v, got %v", pkgOld, parser.doc.Packages[0]) } if len(parser.doc.Packages) != 1 { t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) @@ -67,9 +60,9 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTag(t *testing.T func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpackaged(t *testing.T) { // pkg is nil, so that Files appearing before the first PackageName tag - // are added to UnpackagedFiles instead of Packages + // are added to Files instead of Packages parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psFile2_1, pkg: nil, } @@ -112,11 +105,11 @@ func TestParser2_1PackageStartsNewPackageAfterParsingPackageNameTagWhileInUnpack func TestParser2_1PackageMovesToFileAfterParsingFileNameTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) pkgCurrent := parser.pkg err := parser.parsePair2_1("FileName", "testFile") @@ -135,11 +128,11 @@ func TestParser2_1PackageMovesToFileAfterParsingFileNameTag(t *testing.T) { func TestParser2_1PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") if err != nil { @@ -152,11 +145,11 @@ func TestParser2_1PackageMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing. func TestParser2_1PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("Reviewer", "Person: John Doe") if err != nil { @@ -169,11 +162,11 @@ func TestParser2_1PackageMovesToReviewAfterParsingReviewerTag(t *testing.T) { func TestParser2_1PackageStaysAfterParsingRelationshipTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") if err != nil { @@ -196,11 +189,11 @@ func TestParser2_1PackageStaysAfterParsingRelationshipTags(t *testing.T) { func TestParser2_1PackageStaysAfterParsingAnnotationTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("Annotator", "Person: John Doe ()") if err != nil { @@ -246,7 +239,7 @@ func TestParser2_1PackageStaysAfterParsingAnnotationTags(t *testing.T) { // ===== Package data section tests ===== func TestParser2_1CanParsePackageTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -282,8 +275,8 @@ func TestParser2_1CanParsePackageTags(t *testing.T) { if len(parser.doc.Packages) != 1 { t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) } - if parser.doc.Packages["p1"] != parser.pkg { - t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages["p1"]) + if parser.doc.Packages[0] != parser.pkg { + t.Errorf("expected to point to parser.pkg, got %v", parser.doc.Packages[0]) } // Package Version @@ -353,14 +346,22 @@ func TestParser2_1CanParsePackageTags(t *testing.T) { 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) + + for _, checksum := range parser.pkg.PackageChecksums { + switch checksum.Algorithm { + case spdx.SHA1: + if checksum.Value != codeSha1 { + t.Errorf("expected %s for PackageChecksum SHA1, got %s", codeSha1, checksum.Value) + } + case spdx.SHA256: + if checksum.Value != codeSha256 { + t.Errorf("expected %s for PackageChecksum SHA256, got %s", codeSha256, checksum.Value) + } + case spdx.MD5: + if checksum.Value != codeMd5 { + t.Errorf("expected %s for PackageChecksum MD5, got %s", codeMd5, checksum.Value) + } + } } // Package Home Page @@ -555,119 +556,119 @@ func TestParser2_1CanParsePackageTags(t *testing.T) { func TestParser2_1CanParsePackageSupplierPersonTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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) + if parser.pkg.PackageSupplier.Supplier != "John Doe" { + t.Errorf("got %v for PackageSupplierPerson", parser.pkg.PackageSupplier.Supplier) } } func TestParser2_1CanParsePackageSupplierOrganizationTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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) + if parser.pkg.PackageSupplier.Supplier != "John Doe, Inc." { + t.Errorf("got %v for PackageSupplierOrganization", parser.pkg.PackageSupplier.Supplier) } } func TestParser2_1CanParsePackageSupplierNOASSERTIONTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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 { + if parser.pkg.PackageSupplier.Supplier != "NOASSERTION" { t.Errorf("got false for PackageSupplierNOASSERTION") } } func TestParser2_1CanParsePackageOriginatorPersonTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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) + if parser.pkg.PackageOriginator.Originator != "John Doe" { + t.Errorf("got %v for PackageOriginatorPerson", parser.pkg.PackageOriginator.Originator) } } func TestParser2_1CanParsePackageOriginatorOrganizationTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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) + if parser.pkg.PackageOriginator.Originator != "John Doe, Inc." { + t.Errorf("got %v for PackageOriginatorOrganization", parser.pkg.PackageOriginator.Originator) } } func TestParser2_1CanParsePackageOriginatorNOASSERTIONTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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 { + if parser.pkg.PackageOriginator.Originator != "NOASSERTION" { t.Errorf("got false for PackageOriginatorNOASSERTION") } } func TestParser2_1CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // Package Verification Code with excludes parenthetical code := "d6a770ba38583ed4bb4525bd96e50461655d2758" @@ -677,22 +678,22 @@ func TestParser2_1CanParsePackageVerificationCodeTagWithExcludes(t *testing.T) { if err != nil { t.Errorf("expected nil error, got %v", err) } - if parser.pkg.PackageVerificationCode != code { + if parser.pkg.PackageVerificationCode.Value != code { t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode) } - if parser.pkg.PackageVerificationCodeExcludedFile != fileName { - t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile) + if len(parser.pkg.PackageVerificationCode.ExcludedFiles) != 1 || parser.pkg.PackageVerificationCode.ExcludedFiles[0] != fileName { + t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCode.ExcludedFiles) } } func TestParser2_1CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) // Package Verification Code without excludes parenthetical code := "d6a770ba38583ed4bb4525bd96e50461655d2758" @@ -700,22 +701,22 @@ func TestParser2_1CanParsePackageVerificationCodeTagWithoutExcludes(t *testing.T if err != nil { t.Errorf("expected nil error, got %v", err) } - if parser.pkg.PackageVerificationCode != code { + if parser.pkg.PackageVerificationCode.Value != code { t.Errorf("got %v for PackageVerificationCode", parser.pkg.PackageVerificationCode) } - if parser.pkg.PackageVerificationCodeExcludedFile != "" { - t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCodeExcludedFile) + if len(parser.pkg.PackageVerificationCode.ExcludedFiles) != 0 { + t.Errorf("got %v for PackageVerificationCodeExcludedFile", parser.pkg.PackageVerificationCode.ExcludedFiles) } } func TestPackageExternalRefPointerChangesAfterTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + 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) @@ -756,11 +757,11 @@ func TestPackageExternalRefPointerChangesAfterTags(t *testing.T) { func TestParser2_1PackageCreatesRelationshipInDocument(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-whatever") if err != nil { @@ -776,11 +777,11 @@ func TestParser2_1PackageCreatesRelationshipInDocument(t *testing.T) { func TestParser2_1PackageCreatesAnnotationInDocument(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePair2_1("Annotator", "Person: John Doe ()") if err != nil { @@ -796,11 +797,11 @@ func TestParser2_1PackageCreatesAnnotationInDocument(t *testing.T) { func TestParser2_1PackageUnknownTagFails(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: "p1", PackageSPDXIdentifier: "p1"}, } - parser.doc.Packages["p1"] = parser.pkg + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) err := parser.parsePairFromPackage2_1("blah", "something") if err == nil { @@ -810,7 +811,7 @@ func TestParser2_1PackageUnknownTagFails(t *testing.T) { func TestParser2_1FailsIfInvalidSPDXIDInPackageSection(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -829,7 +830,7 @@ func TestParser2_1FailsIfInvalidSPDXIDInPackageSection(t *testing.T) { func TestParser2_1FailsIfInvalidPackageSupplierFormat(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -848,7 +849,7 @@ func TestParser2_1FailsIfInvalidPackageSupplierFormat(t *testing.T) { func TestParser2_1FailsIfUnknownPackageSupplierType(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -867,7 +868,7 @@ func TestParser2_1FailsIfUnknownPackageSupplierType(t *testing.T) { func TestParser2_1FailsIfInvalidPackageOriginatorFormat(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -886,7 +887,7 @@ func TestParser2_1FailsIfInvalidPackageOriginatorFormat(t *testing.T) { func TestParser2_1FailsIfUnknownPackageOriginatorType(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -905,7 +906,7 @@ func TestParser2_1FailsIfUnknownPackageOriginatorType(t *testing.T) { func TestParser2_1SetsFilesAnalyzedTagsCorrectly(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -930,7 +931,7 @@ func TestParser2_1SetsFilesAnalyzedTagsCorrectly(t *testing.T) { func TestParser2_1FailsIfInvalidPackageChecksumFormat(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -949,7 +950,7 @@ func TestParser2_1FailsIfInvalidPackageChecksumFormat(t *testing.T) { func TestParser2_1FailsIfInvalidPackageChecksumType(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -968,7 +969,7 @@ func TestParser2_1FailsIfInvalidPackageChecksumType(t *testing.T) { func TestParser2_1FailsIfInvalidExternalRefFormat(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -987,7 +988,7 @@ func TestParser2_1FailsIfInvalidExternalRefFormat(t *testing.T) { func TestParser2_1FailsIfExternalRefCommentBeforeExternalRef(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{}, } @@ -1011,12 +1012,12 @@ func TestCanCheckAndExtractExcludesFilenameAndCode(t *testing.T) { fileName := "./package.spdx" fullCodeValue := "d6a770ba38583ed4bb4525bd96e50461655d2758 (excludes: ./package.spdx)" - gotCode, gotFileName := extractCodeAndExcludes(fullCodeValue) - if gotCode != code { + gotCode := extractCodeAndExcludes(fullCodeValue) + if gotCode.Value != code { t.Errorf("got %v for gotCode", gotCode) } - if gotFileName != fileName { - t.Errorf("got %v for gotFileName", gotFileName) + if len(gotCode.ExcludedFiles) != 1 || gotCode.ExcludedFiles[0] != fileName { + t.Errorf("got %v for gotFileName", gotCode.ExcludedFiles) } } @@ -1073,15 +1074,15 @@ func TestParser2_1PackageWithoutSpdxIdentifierThrowsError(t *testing.T) { // More than one package, the previous package doesn't contain the SPDXID pkgOldName := "p1" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psPackage2_1, pkg: &spdx.Package2_1{PackageName: pkgOldName}, } pkgOld := parser.pkg - parser.doc.Packages["p1"] = pkgOld + parser.doc.Packages = append(parser.doc.Packages, pkgOld) // the Document's Packages should have this one only - if parser.doc.Packages["p1"] != pkgOld { - t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages["p1"]) + if parser.doc.Packages[0] != pkgOld { + t.Errorf("expected package %v, got %v", pkgOld, parser.doc.Packages[0]) } if len(parser.doc.Packages) != 1 { t.Errorf("expected 1 package, got %d", len(parser.doc.Packages)) diff --git a/tvloader/parser2v1/parse_review_test.go b/tvloader/parser2v1/parse_review_test.go index efcde5c..2ef7006 100644 --- a/tvloader/parser2v1/parse_review_test.go +++ b/tvloader/parser2v1/parse_review_test.go @@ -12,9 +12,9 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) { // create the first review rev1 := "John Doe" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -25,8 +25,8 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) { ReviewerType: "Person", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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 @@ -82,9 +82,9 @@ func TestParser2_1ReviewStartsNewReviewAfterParsingReviewerTag(t *testing.T) { func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -95,8 +95,8 @@ func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) { ReviewerType: "Person", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -129,9 +129,9 @@ func TestParser2_1ReviewStaysAfterParsingRelationshipTags(t *testing.T) { func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -142,8 +142,8 @@ func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) { ReviewerType: "Person", }, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -191,16 +191,16 @@ func TestParser2_1ReviewStaysAfterParsingAnnotationTags(t *testing.T) { 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 ()" { + if parser.doc.Annotations[0].Annotator.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{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -208,8 +208,8 @@ func TestParser2_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -235,9 +235,9 @@ func TestParser2_1ReviewFailsAfterParsingOtherSectionTags(t *testing.T) { // ===== Review data section tests ===== func TestParser2_1CanParseReviewTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -245,8 +245,8 @@ func TestParser2_1CanParseReviewTags(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -274,9 +274,9 @@ func TestParser2_1CanParseReviewTags(t *testing.T) { func TestParser2_1CanParseReviewerPersonTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -284,8 +284,8 @@ func TestParser2_1CanParseReviewerPersonTag(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -304,9 +304,9 @@ func TestParser2_1CanParseReviewerPersonTag(t *testing.T) { func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -314,8 +314,8 @@ func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -334,9 +334,9 @@ func TestParser2_1CanParseReviewerOrganizationTag(t *testing.T) { func TestParser2_1CanParseReviewerToolTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -344,8 +344,8 @@ func TestParser2_1CanParseReviewerToolTag(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -364,8 +364,8 @@ func TestParser2_1CanParseReviewerToolTag(t *testing.T) { func TestParser2_1FailsIfReviewerInvalidFormat(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, - st: psReview2_1, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, + st: psReview2_1, rev: &spdx.Review2_1{}, } parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) @@ -378,8 +378,8 @@ func TestParser2_1FailsIfReviewerInvalidFormat(t *testing.T) { func TestParser2_1FailsIfReviewerUnknownType(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, - st: psReview2_1, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, + st: psReview2_1, rev: &spdx.Review2_1{}, } parser.doc.Reviews = append(parser.doc.Reviews, parser.rev) @@ -392,9 +392,9 @@ func TestParser2_1FailsIfReviewerUnknownType(t *testing.T) { func TestParser2_1ReviewUnknownTagFails(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psReview2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1"}, otherLic: &spdx.OtherLicense2_1{ LicenseIdentifier: "LicenseRef-Lic11", @@ -402,8 +402,8 @@ func TestParser2_1ReviewUnknownTagFails(t *testing.T) { }, rev: &spdx.Review2_1{}, } - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + 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) @@ -412,5 +412,3 @@ func TestParser2_1ReviewUnknownTagFails(t *testing.T) { t.Errorf("expected error from parsing unknown tag") } } - - diff --git a/tvloader/parser2v1/parse_snippet.go b/tvloader/parser2v1/parse_snippet.go index d590383..33392d5 100644 --- a/tvloader/parser2v1/parse_snippet.go +++ b/tvloader/parser2v1/parse_snippet.go @@ -51,7 +51,7 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err if err != nil { return err } - parser.snippet.SnippetFromFileSPDXIdentifier = deID + parser.snippet.SnippetFromFileSPDXIdentifier = deID.ElementRefID case "SnippetByteRange": byteStart, byteEnd, err := extractSubs(value) if err != nil { @@ -65,8 +65,12 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err if err != nil { return err } - parser.snippet.SnippetByteRangeStart = bIntStart - parser.snippet.SnippetByteRangeEnd = bIntEnd + + if parser.snippet.Ranges == nil { + parser.snippet.Ranges = []spdx.SnippetRange{} + } + byteRange := spdx.SnippetRange{StartPointer: spdx.SnippetRangePointer{Offset: bIntStart}, EndPointer: spdx.SnippetRangePointer{Offset: bIntEnd}} + parser.snippet.Ranges = append(parser.snippet.Ranges, byteRange) case "SnippetLineRange": lineStart, lineEnd, err := extractSubs(value) if err != nil { @@ -80,8 +84,12 @@ func (parser *tvParser2_1) parsePairFromSnippet2_1(tag string, value string) err if err != nil { return err } - parser.snippet.SnippetLineRangeStart = lInttStart - parser.snippet.SnippetLineRangeEnd = lInttEnd + + if parser.snippet.Ranges == nil { + parser.snippet.Ranges = []spdx.SnippetRange{} + } + lineRange := spdx.SnippetRange{StartPointer: spdx.SnippetRangePointer{LineNumber: lInttStart}, EndPointer: spdx.SnippetRangePointer{LineNumber: lInttEnd}} + parser.snippet.Ranges = append(parser.snippet.Ranges, lineRange) case "SnippetLicenseConcluded": parser.snippet.SnippetLicenseConcluded = value case "LicenseInfoInSnippet": diff --git a/tvloader/parser2v1/parse_snippet_test.go b/tvloader/parser2v1/parse_snippet_test.go index 603abc5..ea747f4 100644 --- a/tvloader/parser2v1/parse_snippet_test.go +++ b/tvloader/parser2v1/parse_snippet_test.go @@ -12,15 +12,15 @@ func TestParser2_1SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing // create the first snippet sid1 := spdx.ElementID("s1") parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "test", PackageSPDXIdentifier: "test", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: sid1}, } s1 := parser.snippet - parser.doc.Packages["test"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets[sid1] = parser.snippet // the File's Snippets should have this one only @@ -71,16 +71,16 @@ func TestParser2_1SnippetStartsNewSnippetAfterParsingSnippetSPDXIDTag(t *testing func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } p1 := parser.pkg f1 := parser.file - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet // now add a new package @@ -113,21 +113,21 @@ func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T if len(parser.doc.Packages) != 1 { t.Errorf("Expected len(Packages) to be 1, got %d", len(parser.doc.Packages)) } - if parser.doc.Packages["package1"] != p1 { - t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages["package1"]) + if parser.doc.Packages[0] != p1 { + t.Errorf("Expected package %v in Packages[package1], got %v", p1, parser.doc.Packages[0]) } - if parser.doc.Packages["package1"].PackageName != "package1" { - t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages["package1"].PackageName) + if parser.doc.Packages[0].PackageName != "package1" { + t.Errorf("expected package name %s in Packages[package1], got %s", "package1", parser.doc.Packages[0].PackageName) } // and the first Package's Files should be of size 1 and have f1 only - if len(parser.doc.Packages["package1"].Files) != 1 { - t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages["package1"].Files)) + if len(parser.doc.Packages[0].Files) != 1 { + t.Errorf("Expected 1 file in Packages[package1].Files, got %d", len(parser.doc.Packages[0].Files)) } - if parser.doc.Packages["package1"].Files["f1"] != f1 { - t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages["package1"].Files["f1"]) + if parser.doc.Packages[0].Files[0] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.doc.Packages[0].Files[0]) } - if parser.doc.Packages["package1"].Files["f1"].FileName != "f1.txt" { - t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages["package1"].Files["f1"].FileName) + if parser.doc.Packages[0].Files[0].FileName != "f1.txt" { + t.Errorf("expected file name %s in Files[f1], got %s", "f1.txt", parser.doc.Packages[0].Files[0].FileName) } // and the new Package should have no files if len(parser.pkg.Files) != 0 { @@ -146,16 +146,16 @@ func TestParser2_1SnippetStartsNewPackageAfterParsingPackageNameTag(t *testing.T func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { f1Name := "f1.txt" parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } p1 := parser.pkg f1 := parser.file - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet f2Name := "f2.txt" @@ -184,11 +184,11 @@ func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { if len(parser.pkg.Files) != 1 { t.Errorf("Expected len(Files) to be 1, got %d", len(parser.pkg.Files)) } - if parser.pkg.Files["f1"] != f1 { - t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files["f1"]) + if parser.pkg.Files[0] != f1 { + t.Errorf("Expected file %v in Files[f1], got %v", f1, parser.pkg.Files[0]) } - if parser.pkg.Files["f1"].FileName != f1Name { - t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files["f1"].FileName) + if parser.pkg.Files[0].FileName != f1Name { + t.Errorf("expected file name %s in Files[f1], got %s", f1Name, parser.pkg.Files[0].FileName) } // and the current snippet should be nil if parser.snippet != nil { @@ -198,14 +198,14 @@ func TestParser2_1SnippetMovesToFileAfterParsingFileNameTag(t *testing.T) { func TestParser2_1SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet err := parser.parsePair2_1("LicenseID", "LicenseRef-TestLic") @@ -219,14 +219,14 @@ func TestParser2_1SnippetMovesToOtherLicenseAfterParsingLicenseIDTag(t *testing. func TestParser2_1SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet err := parser.parsePair2_1("Reviewer", "Person: John Doe") @@ -240,14 +240,14 @@ func TestParser2_1SnippetMovesToReviewAfterParsingReviewerTag(t *testing.T) { func TestParser2_1SnippetStaysAfterParsingRelationshipTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet err := parser.parsePair2_1("Relationship", "SPDXRef-blah CONTAINS SPDXRef-blah-else") @@ -279,14 +279,14 @@ func TestParser2_1SnippetStaysAfterParsingRelationshipTags(t *testing.T) { func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) parser.file.Snippets["s1"] = parser.snippet err := parser.parsePair2_1("Annotator", "Person: John Doe ()") @@ -333,7 +333,7 @@ func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) { 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 ()" { + if parser.doc.Annotations[0].Annotator.Annotator != "John Doe ()" { t.Errorf("expected Annotator to be %s, got %s", "John Doe ()", parser.doc.Annotations[0].Annotator) } } @@ -341,14 +341,14 @@ func TestParser2_1SnippetStaysAfterParsingAnnotationTags(t *testing.T) { // ===== Snippet data section tests ===== func TestParser2_1CanParseSnippetTags(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) // Snippet SPDX Identifier err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1") @@ -365,7 +365,7 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) { t.Errorf("expected nil error, got %v", err) } wantDeID := spdx.DocElementID{DocumentRefID: "", ElementRefID: spdx.ElementID("f1")} - if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID { + if parser.snippet.SnippetFromFileSPDXIdentifier != wantDeID.ElementRefID { t.Errorf("got %v for SnippetFromFileSPDXIdentifier", parser.snippet.SnippetFromFileSPDXIdentifier) } @@ -374,11 +374,11 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) { 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.Ranges[0].StartPointer.Offset != 20 { + t.Errorf("got %v for SnippetByteRangeStart", parser.snippet.Ranges[0].StartPointer.Offset) } - if parser.snippet.SnippetByteRangeEnd != 320 { - t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.SnippetByteRangeEnd) + if parser.snippet.Ranges[0].EndPointer.Offset != 320 { + t.Errorf("got %v for SnippetByteRangeEnd", parser.snippet.Ranges[0].EndPointer.Offset) } // Snippet Line Range @@ -386,11 +386,11 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) { 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.Ranges[1].StartPointer.LineNumber != 5 { + t.Errorf("got %v for SnippetLineRangeStart", parser.snippet.Ranges[1].StartPointer.LineNumber) } - if parser.snippet.SnippetLineRangeEnd != 12 { - t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.SnippetLineRangeEnd) + if parser.snippet.Ranges[1].EndPointer.LineNumber != 12 { + t.Errorf("got %v for SnippetLineRangeEnd", parser.snippet.Ranges[1].EndPointer.LineNumber) } // Snippet Concluded License @@ -469,14 +469,14 @@ func TestParser2_1CanParseSnippetTags(t *testing.T) { func TestParser2_1SnippetUnknownTagFails(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{SnippetSPDXIdentifier: "s1"}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) err := parser.parsePairFromSnippet2_1("blah", "something") if err == nil { @@ -486,14 +486,14 @@ func TestParser2_1SnippetUnknownTagFails(t *testing.T) { func TestParser2_1FailsForInvalidSnippetSPDXID(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) // invalid Snippet SPDX Identifier err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "whoops") @@ -504,14 +504,14 @@ func TestParser2_1FailsForInvalidSnippetSPDXID(t *testing.T) { func TestParser2_1FailsForInvalidSnippetFromFileSPDXID(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) // start with Snippet SPDX Identifier err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1") @@ -527,14 +527,14 @@ func TestParser2_1FailsForInvalidSnippetFromFileSPDXID(t *testing.T) { func TestParser2_1FailsForInvalidSnippetByteValues(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) // start with Snippet SPDX Identifier err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1") @@ -558,14 +558,14 @@ func TestParser2_1FailsForInvalidSnippetByteValues(t *testing.T) { func TestParser2_1FailsForInvalidSnippetLineValues(t *testing.T) { parser := tvParser2_1{ - doc: &spdx.Document2_1{Packages: map[spdx.ElementID]*spdx.Package2_1{}}, + doc: &spdx.Document2_1{Packages: []*spdx.Package2_1{}}, st: psSnippet2_1, - pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: map[spdx.ElementID]*spdx.File2_1{}}, + pkg: &spdx.Package2_1{PackageName: "package1", PackageSPDXIdentifier: "package1", Files: []*spdx.File2_1{}}, file: &spdx.File2_1{FileName: "f1.txt", FileSPDXIdentifier: "f1", Snippets: map[spdx.ElementID]*spdx.Snippet2_1{}}, snippet: &spdx.Snippet2_1{}, } - parser.doc.Packages["package1"] = parser.pkg - parser.pkg.Files["f1"] = parser.file + parser.doc.Packages = append(parser.doc.Packages, parser.pkg) + parser.pkg.Files = append(parser.pkg.Files, parser.file) // start with Snippet SPDX Identifier err := parser.parsePairFromSnippet2_1("SnippetSPDXID", "SPDXRef-s1") diff --git a/tvloader/parser2v1/parser.go b/tvloader/parser2v1/parser.go index f4a5ae1..70f4819 100644 --- a/tvloader/parser2v1/parser.go +++ b/tvloader/parser2v1/parser.go @@ -59,12 +59,44 @@ func (parser *tvParser2_1) parsePairFromStart2_1(tag string, value string) error // create an SPDX Document data struct if we don't have one already if parser.doc == nil { - parser.doc = &spdx.Document2_1{} + parser.doc = &spdx.Document2_1{ + ExternalDocumentReferences: []spdx.ExternalDocumentRef2_1{}, + } } - // move to Creation Info parser state - parser.st = psCreationInfo2_1 + switch tag { + case "SPDXVersion": + parser.doc.SPDXVersion = value + case "DataLicense": + parser.doc.DataLicense = value + case "SPDXID": + eID, err := extractElementID(value) + if err != nil { + return err + } + parser.doc.SPDXIdentifier = eID + case "DocumentName": + parser.doc.DocumentName = value + case "DocumentNamespace": + parser.doc.DocumentNamespace = value + case "ExternalDocumentRef": + documentRefID, uri, alg, checksum, err := extractExternalDocumentReference(value) + if err != nil { + return err + } + edr := spdx.ExternalDocumentRef2_1{ + DocumentRefID: documentRefID, + URI: uri, + Checksum: spdx.Checksum{Algorithm: spdx.ChecksumAlgorithm(alg), Value: checksum}, + } + parser.doc.ExternalDocumentReferences = append(parser.doc.ExternalDocumentReferences, edr) + case "DocumentComment": + parser.doc.DocumentComment = value + default: + // move to Creation Info parser state + parser.st = psCreationInfo2_1 + return parser.parsePairFromCreationInfo2_1(tag, value) + } - // and ask Creation Info subfunc to parse - return parser.parsePairFromCreationInfo2_1(tag, value) + return nil } diff --git a/tvloader/parser2v1/parser_test.go b/tvloader/parser2v1/parser_test.go index 9fe051f..e895445 100644 --- a/tvloader/parser2v1/parser_test.go +++ b/tvloader/parser2v1/parser_test.go @@ -24,14 +24,14 @@ func TestParser2_1CanParseTagValues(t *testing.T) { 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.SPDXVersion != "SPDX-2.1" { + t.Errorf("expected SPDXVersion to be SPDX-2.1, got %v", doc.SPDXVersion) } - if doc.CreationInfo.DataLicense != "CC0-1.0" { - t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.CreationInfo.DataLicense) + if doc.DataLicense != "CC0-1.0" { + t.Errorf("expected DataLicense to be CC0-1.0, got %v", doc.DataLicense) } - if doc.CreationInfo.SPDXIdentifier != "DOCUMENT" { - t.Errorf("expected SPDXIdentifier to be DOCUMENT, got %v", doc.CreationInfo.SPDXIdentifier) + if doc.SPDXIdentifier != "DOCUMENT" { + t.Errorf("expected SPDXIdentifier to be DOCUMENT, got %v", doc.SPDXIdentifier) } } @@ -58,18 +58,6 @@ func TestParser2_1HasDocumentAfterCallToParseFirstTag(t *testing.T) { } } -// ===== 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) - } -} - func TestParser2_1StartFailsToParseIfInInvalidState(t *testing.T) { parser := tvParser2_1{st: psReview2_1} err := parser.parsePairFromStart2_1("SPDXVersion", "SPDX-2.1") -- cgit v1.2.3