diff options
Diffstat (limited to 'rdfloader/parser2v2/parse_file_test.go')
| -rw-r--r-- | rdfloader/parser2v2/parse_file_test.go | 701 |
1 files changed, 701 insertions, 0 deletions
diff --git a/rdfloader/parser2v2/parse_file_test.go b/rdfloader/parser2v2/parse_file_test.go new file mode 100644 index 0000000..e9fa16c --- /dev/null +++ b/rdfloader/parser2v2/parse_file_test.go @@ -0,0 +1,701 @@ +package parser2v2 + +import ( + "bufio" + gordfParser "github.com/RishabhBhatnagar/gordf/rdfloader/parser" + rdfloader2 "github.com/RishabhBhatnagar/gordf/rdfloader/xmlreader" + gordfWriter "github.com/RishabhBhatnagar/gordf/rdfwriter" + "github.com/spdx/tools-golang/spdx" + "strings" + "testing" +) + +// content is the tags within the rdf:RDF tag +// pads the content with the enclosing rdf:RDF tag +func wrapIntoTemplate(content string) string { + header := `<rdf:RDF + xmlns:spdx="http://spdx.org/rdf/terms#" + xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" + xmlns="http://spdx.org/spdxdocs/spdx-example-444504E0-4F89-41D3-9A0C-0305E82C3301#" + xmlns:doap="http://usefulinc.com/ns/doap#" + xmlns:j.0="http://www.w3.org/2009/pointers#" + xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#">` + footer := `</rdf:RDF>` + return header + content + footer +} + +func parserFromBodyContent(content string) (*rdfParser2_2, error) { + rdfContent := wrapIntoTemplate(content) + xmlreader := rdfloader2.XMLReaderFromFileObject(bufio.NewReader(strings.NewReader(rdfContent))) + rootBlock, err := xmlreader.Read() + if err != nil { + return nil, err + } + parser := gordfParser.New() + err = parser.Parse(rootBlock) + if err != nil { + return nil, err + } + nodeToTriples := gordfWriter.GetNodeToTriples(parser.Triples) + rdfParser := NewParser2_2(parser, nodeToTriples) + return rdfParser, err +} + +func Test_rdfParser2_2_getArtifactFromNode(t *testing.T) { + // TestCase 1: artifactOf without project URI + rdfParser, err := parserFromBodyContent( + `<spdx:File> + <spdx:artifactOf> + <doap:Project> + <doap:homepage>http://www.openjena.org/</doap:homepage> + <doap:name>Jena</doap:name> + </doap:Project> + </spdx:artifactOf> + </spdx:File>`) + if err != nil { + t.Errorf("unexpected error while parsing a valid example: %v", err) + } + artifactOfNode := gordfWriter.FilterTriples(rdfParser.gordfParserObj.Triples, nil, &SPDX_ARTIFACT_OF, nil)[0].Object + artifact, err := rdfParser.getArtifactFromNode(artifactOfNode) + if err != nil { + t.Errorf("error parsing a valid artifactOf node: %v", err) + } + if artifact.Name != "Jena" { + t.Errorf("expected name of artifact: %s, found: %s", "Jena", artifact.Name) + } + expectedHomePage := "http://www.openjena.org/" + if artifact.HomePage != expectedHomePage { + t.Errorf("wrong artifact homepage. Expected: %s, found: %s", expectedHomePage, artifact.HomePage) + } + if artifact.URI != "" { + t.Errorf("wrong artifact URI. Expected: %s, found: %s", "", artifact.URI) + } + + // TestCase 2: artifactOf with a Project URI + rdfParser, err = parserFromBodyContent( + `<spdx:File> + <spdx:artifactOf> + <doap:Project rdf:about="http://subversion.apache.org/doap.rdf"> + <doap:homepage>http://www.openjena.org/</doap:homepage> + <doap:name>Jena</doap:name> + </doap:Project> + </spdx:artifactOf> + </spdx:File>`) + if err != nil { + t.Errorf("unexpected error while parsing a valid example: %v", err) + } + artifactOfNode = gordfWriter.FilterTriples(rdfParser.gordfParserObj.Triples, nil, &SPDX_ARTIFACT_OF, nil)[0].Object + artifact, err = rdfParser.getArtifactFromNode(artifactOfNode) + if err != nil { + t.Errorf("error parsing a valid artifactOf node: %v", err) + } + expectedURI := "http://subversion.apache.org/doap.rdf" + if artifact.URI != expectedURI { + t.Errorf("wrong artifact URI. Expected: %s, found: %s", expectedURI, artifact.URI) + } + + // TestCase 3: artifactOf with unknown predicate + rdfParser, err = parserFromBodyContent( + `<spdx:File> + <spdx:artifactOf> + <doap:Project rdf:about="http://subversion.apache.org/doap.rdf"> + <doap:homepage>http://www.openjena.org/</doap:homepage> + <doap:name>Jena</doap:name> + <doap:invalidTag rdf:ID="invalid"/> + </doap:Project> + </spdx:artifactOf> + </spdx:File>`) + if err != nil { + t.Errorf("unexpected error while parsing a valid example: %v", err) + } + artifactOfNode = gordfWriter.FilterTriples(rdfParser.gordfParserObj.Triples, nil, &SPDX_ARTIFACT_OF, nil)[0].Object + _, err = rdfParser.getArtifactFromNode(artifactOfNode) + if err == nil { + t.Errorf("must've raised an error for an invalid predicate") + } +} + +func Test_rdfParser2_2_getFileTypeFromUri(t *testing.T) { + rdfParser, _ := parserFromBodyContent(``) + + // TestCase 1: Valid fileType URI: + fileTypeURI := "http://spdx.org/rdf/terms#fileType_source" + fileType, err := rdfParser.getFileTypeFromUri(fileTypeURI) + if err != nil { + t.Errorf("error in a valid example: %v", err) + } + if fileType != "source" { + t.Errorf("wrong fileType. expected: %s, found: %s", "source", fileType) + } + + // TestCase 2: Invalid fileType URI format. + fileTypeURI = "http://spdx.org/rdf/terms#source" + fileType, err = rdfParser.getFileTypeFromUri(fileTypeURI) + if err == nil { + t.Error("should've raised an error for invalid fileType") + } +} + +func Test_rdfParser2_2_setUnpackagedFiles(t *testing.T) { + // unpackaged files are the files which are not associated with any package + // file associated with a package sets parser.assocWithPackage[fileID] to true. + rdfParser, _ := parserFromBodyContent(``) + file1 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file1")} + file2 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file2")} + file3 := &spdx.File2_2{FileSPDXIdentifier: spdx.ElementID("file3")} + + // setting files to the document as if it were to be set when it was parsed using triples. + rdfParser.files[file1.FileSPDXIdentifier] = file1 + rdfParser.files[file2.FileSPDXIdentifier] = file2 + rdfParser.files[file3.FileSPDXIdentifier] = file3 + + // assuming file1 is associated with a package + rdfParser.assocWithPackage[file1.FileSPDXIdentifier] = true + + rdfParser.setUnpackagedFiles() + + // after setting unpackaged files, parser.doc.UnpackagedFiles must've file2 and file3 + if n := len(rdfParser.doc.UnpackagedFiles); n != 2 { + t.Errorf("unpackage files should've had 2 files, found %d files", n) + } + + // checking if the unpackagedFiles contain only file2 & file3. + for fileID, _ := range rdfParser.doc.UnpackagedFiles { + switch string(fileID) { + case "file2", "file3": + continue + default: + t.Errorf("unexpected file with id %s found in unpackaged files", fileID) + } + } +} + +func Test_setFileIdentifier(t *testing.T) { + file := &spdx.File2_2{} + + // TestCase 1: valid example + err := setFileIdentifier("http://spdx.org/documents/spdx-toolsv2.1.7-SNAPSHOT#SPDXRef-129", file) + if err != nil { + t.Errorf("unexpected error: %v", err) + } + if file.FileSPDXIdentifier != "129" { + t.Errorf("expected %s, found: %s", "129", file.FileSPDXIdentifier) + } + + // TestCase 2: invalid example + err = setFileIdentifier("http://spdx.org/documents/spdx-toolsv2.1.7-SNAPSHOT#129", file) + if err == nil { + t.Errorf("should've raised an error for an invalid example") + } +} + +func Test_rdfParser2_2_setFileChecksumFromNode(t *testing.T) { + // TestCase 1: md5 checksum + parser, _ := parserFromBodyContent(` + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_md5" /> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode := gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file := &spdx.File2_2{} + err := parser.setFileChecksumFromNode(file, checksumNode) + if err != nil { + t.Errorf("error parsing a valid checksum node") + } + checksumValue := "d2356e0fe1c0b85285d83c6b2ad51b5f" + if file.FileChecksumMD5 != checksumValue { + t.Errorf("wrong checksum value for md5. Expected: %s, found: %s", checksumValue, file.FileChecksumMD5) + } + if file.FileChecksumSHA1 != "" { + t.Errorf("incorrectly set sha1, should've been empty") + } + if file.FileChecksumSHA256 != "" { + t.Errorf("incorrectly set sha256, should've been empty") + } + + // TestCase 2: valid sha1 checksum + parser, _ = parserFromBodyContent(` + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha1" /> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file = &spdx.File2_2{} + err = parser.setFileChecksumFromNode(file, checksumNode) + if err != nil { + t.Errorf("error parsing a valid checksum node") + } + if file.FileChecksumSHA1 != checksumValue { + t.Errorf("wrong checksum value for sha1. Expected: %s, found: %s", checksumValue, file.FileChecksumSHA1) + } + if file.FileChecksumMD5 != "" { + t.Errorf("incorrectly set md5, should've been empty") + } + if file.FileChecksumSHA256 != "" { + t.Errorf("incorrectly set sha256, should've been empty") + } + + // TestCase 3: valid sha256 checksum + parser, _ = parserFromBodyContent(` + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha256" /> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file = &spdx.File2_2{} + err = parser.setFileChecksumFromNode(file, checksumNode) + if err != nil { + t.Errorf("error parsing a valid checksum node") + } + if file.FileChecksumSHA256 != checksumValue { + t.Errorf("wrong checksum value for sha256. Expected: %s, found: %s", checksumValue, file.FileChecksumSHA256) + } + if file.FileChecksumMD5 != "" { + t.Errorf("incorrectly set md5, should've been empty") + } + if file.FileChecksumSHA1 != "" { + t.Errorf("incorrectly set sha1, should've been empty") + } + + // TestCase 4: checksum node without one of the mandatory attributes + parser, _ = parserFromBodyContent(` + <spdx:Checksum> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file = &spdx.File2_2{} + err = parser.setFileChecksumFromNode(file, checksumNode) + if err == nil { + t.Errorf("should've raised an error parsing an invalid checksum node") + } + + // TestCase 5: invalid checksum algorithm + parser, _ = parserFromBodyContent(` + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_md43" /> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file = &spdx.File2_2{} + err = parser.setFileChecksumFromNode(file, checksumNode) + if err == nil { + t.Errorf("should've raised an error parsing an invalid checksum node") + } + + // TestCase 6: valid checksum algorithm which is invalid for file (like md4, md6, sha384, etc.) + parser, _ = parserFromBodyContent(` + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha384" /> + <spdx:checksumValue>d2356e0fe1c0b85285d83c6b2ad51b5f</spdx:checksumValue> + </spdx:Checksum> + `) + checksumNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_CHECKSUM_CAPITALIZED)[0].Subject + file = &spdx.File2_2{} + err = parser.setFileChecksumFromNode(file, checksumNode) + if err == nil { + t.Errorf("should've raised an error parsing an invalid checksum algorithm for a file") + } +} + +func Test_rdfParser2_2_getFileFromNode(t *testing.T) { + // TestCase 1: file with invalid id + parser, _ := parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gzspdx.rdf#item177"/> + `) + fileNode := gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err := parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid file ID") + } + + // TestCase 2: invalid fileType + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:fileType rdf:resource="http://spdx.org/rdf/terms#source"/> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid fileType") + } + + // TestCase 3: invalid file checksum + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:checksum> + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha384" /> + <spdx:checksumValue>0a3a0e1ab72b7c132f5021c538a7a3ea6d539bcd</spdx:checksumValue> + </spdx:Checksum> + </spdx:checksum> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid checksum") + } + + // TestCase 4: invalid license concluded + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:licenseConcluded rdf:resource="http://spdx.org/rdf/terms#invalid_license" /> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid license Concluded") + } + + // TestCase 5: invalid artifactOf attribute + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:artifactOf> + <doap:Project> + <doap:unknown_tag /> + <doap:name>Jena</doap:name> + </doap:Project> + </spdx:artifactOf> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid artifactOf predicate") + } + + // TestCase 6: invalid file dependency + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:fileDependency rdf:resource="http://spdx.org/spdxdocs/spdx-example#CommonsLangSrc"/> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid fileDependency") + } + + // TestCase 7: invalid annotation with unknown predicate + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:annotation> + <spdx:Annotation> + <spdx:unknownAttribute /> + </spdx:Annotation> + </spdx:annotation> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid annotation predicate") + } + + // TestCase 8: invalid relationship + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:relationship> + <spdx:Relationship> + <spdx:relationshipType rdf:resource="http://spdx.org/rdf/terms#dynamicLink"/> + </spdx:Relationship> + </spdx:relationship> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid relationship Type") + } + + // TestCase 8: unknown predicate + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:unknown /> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + _, err = parser.getFileFromNode(fileNode) + if err == nil { + t.Errorf("should've raised an error stating invalid predicate for a file") + } + + // TestCase 9: all valid attribute and it's values. + parser, _ = parserFromBodyContent(` + <spdx:File rdf:about="http://anupam-VirtualBox/repo/SPDX2_time-1.9.tar.gz_1535120734-spdx.rdf#SPDXRef-item177"> + <spdx:fileName>time-1.9/ChangeLog</spdx:fileName> + <spdx:name/> + <spdx:fileType rdf:resource="http://spdx.org/rdf/terms#fileType_source"/> + <spdx:checksum> + <spdx:Checksum> + <spdx:algorithm rdf:resource="http://spdx.org/rdf/terms#checksumAlgorithm_sha1" /> + <spdx:checksumValue>0a3a0e1ab72b7c132f5021c538a7a3ea6d539bcd</spdx:checksumValue> + </spdx:Checksum> + </spdx:checksum> + <spdx:licenseConcluded rdf:resource="http://spdx.org/rdf/terms#noassertion" /> + <spdx:licenseInfoInFile rdf:resource="http://spdx.org/rdf/terms#NOASSERTION" /> + <spdx:licenseComments>no comments</spdx:licenseComments> + <spdx:copyrightText>from spdx file</spdx:copyrightText> + <spdx:artifactOf> + <doap:Project> + <doap:homepage>http://www.openjena.org/</doap:homepage> + <doap:name>Jena</doap:name> + </doap:Project> + </spdx:artifactOf> + <rdfs:comment>no comments</rdfs:comment> + <spdx:noticeText rdf:resource="http://spdx.org/rdf/terms#noassertion"/> + <spdx:fileContributor>Some Organization</spdx:fileContributor> + <spdx:fileDependency rdf:resource="http://spdx.org/spdxdocs/spdx-example-444504E0-4F89-41D3-9A0C-0305E82C3301#SPDXRef-CommonsLangSrc"/> + <spdx:attributionText>attribution text</spdx:attributionText> + <spdx:annotation> + <spdx:Annotation> + <spdx:annotationDate>2011-01-29T18:30:22Z</spdx:annotationDate> + <rdfs:comment>File level annotation copied from a spdx document</rdfs:comment> + <spdx:annotator>Person: File Commenter</spdx:annotator> + <spdx:annotationType rdf:resource="http://spdx.org/rdf/terms#annotationType_other"/> + </spdx:Annotation> + </spdx:annotation> + <spdx:relationship> + <spdx:Relationship> + <spdx:relationshipType rdf:resource="http://spdx.org/rdf/terms#relationshipType_contains"/> + <spdx:relatedSpdxElement rdf:resource="http://spdx.org/spdxdocs/spdx-example-444504E0-4F89-41D3-9A0C-0305E82C3301#SPDXRef-Package"/> + </spdx:Relationship> + </spdx:relationship> + </spdx:File> + `) + fileNode = gordfWriter.FilterTriples(parser.gordfParserObj.Triples, nil, &RDF_TYPE, &SPDX_FILE)[0].Subject + file, err := parser.getFileFromNode(fileNode) + if err != nil { + t.Errorf("unexpected error parsing a valid file: %v", err) + } + + // checking each and every attribute of the obtained file. + + expectedFileName := "time-1.9/ChangeLog" + if file.FileName != expectedFileName { + t.Errorf("expected %s, found %s", expectedFileName, file.FileName) + } + + if len(file.FileType) != 1 { + t.Errorf("given file should have 1 fileType attribute. found %d", len(file.FileType)) + } + expectedFileType := "source" + if file.FileType[0] != expectedFileType { + t.Errorf("expected %s, found %s", expectedFileType, file.FileType) + } + + expectedChecksum := "0a3a0e1ab72b7c132f5021c538a7a3ea6d539bcd" + if file.FileChecksumSHA1 != expectedChecksum { + t.Errorf("expected %s, found %s", expectedChecksum, file.FileChecksumSHA1) + } + + expectedLicenseConcluded := "NOASSERTION" + if file.LicenseConcluded != expectedLicenseConcluded { + t.Errorf("expected %s, found %s", expectedLicenseConcluded, file.LicenseConcluded) + } + + if len(file.LicenseInfoInFile) != 1 { + t.Errorf("given file should have 1 licenseInfoInFile attribute. found %d", len(file.LicenseInfoInFile)) + } + expectedLicenseInfoInFile := "NOASSERTION" + if file.LicenseInfoInFile[0] != expectedLicenseInfoInFile { + t.Errorf("expected %s, found %s", expectedLicenseInfoInFile, file.LicenseInfoInFile[0]) + } + + expectedLicenseComments := "no comments" + if file.LicenseComments != expectedLicenseComments { + t.Errorf("expected %s, found %s", expectedLicenseComments, file.LicenseComments) + } + + expectedCopyrightText := "from spdx file" + if file.FileCopyrightText != expectedCopyrightText { + t.Errorf("expected %s, found %s", expectedCopyrightText, file.FileCopyrightText) + } + + if n := len(file.ArtifactOfProjects); n != 1 { + t.Errorf("given file should have 1 artifactOfProjects attribute. found %d", n) + } + artifactOf := file.ArtifactOfProjects[0] + expectedHomePage := "http://www.openjena.org/" + if artifactOf.HomePage != expectedHomePage { + t.Errorf("expected %s, found %s", expectedHomePage, artifactOf.HomePage) + } + if artifactOf.Name != "Jena" { + t.Errorf("expected %s, found %s", "Jena", artifactOf.Name) + } + if artifactOf.URI != "" { + t.Errorf("expected artifactOf uri to be empty, found %s", artifactOf.URI) + } + + expectedFileComment := "no comments" + if file.FileComment != expectedFileComment { + t.Errorf("expected %s, found %s", expectedFileName, file.FileComment) + } + + expectedNoticeText := "NOASSERTION" + if file.FileNotice != expectedNoticeText { + t.Errorf("expected %s, found %s", expectedNoticeText, file.FileNotice) + } + + if n := len(file.FileContributor); n != 1 { + t.Errorf("given file should have 1 fileContributor. found %d", n) + } + expectedFileContributor := "Some Organization" + if file.FileContributor[0] != expectedFileContributor { + t.Errorf("expected %s, found %s", expectedFileContributor, file.FileContributor) + } + + if n := len(file.FileDependencies); n != 1 { + t.Errorf("given file should have 1 fileDependencies. found %d", n) + } + expectedFileDependency := "CommonsLangSrc" + if file.FileDependencies[0] != expectedFileDependency { + t.Errorf("expected %s, found %s", expectedFileDependency, file.FileDependencies[0]) + } + + if n := len(file.FileAttributionTexts); n != 1 { + t.Errorf("given file should have 1 attributionText. found %d", n) + } + expectedAttributionText := "attribution text" + if file.FileAttributionTexts[0] != expectedAttributionText { + t.Errorf("expected %s, found %s", expectedAttributionText, file.FileAttributionTexts[0]) + } + + if n := len(parser.doc.Annotations); n != 1 { + t.Errorf("doc should've had 1 annotation. found %d", n) + } + ann := parser.doc.Annotations[0] + expectedAnnDate := "2011-01-29T18:30:22Z" + if ann.AnnotationDate != expectedAnnDate { + t.Errorf("expected %s, found %s", expectedAnnDate, ann.AnnotationDate) + } + expectedAnnComment := "File level annotation copied from a spdx document" + if ann.AnnotationComment != expectedAnnComment { + t.Errorf("expected %s, found %s", expectedAnnComment, ann.AnnotationComment) + } + expectedAnnotationType := "OTHER" + if ann.AnnotationType != expectedAnnotationType { + t.Errorf("expected %s, found %s", expectedAnnotationType, ann.AnnotationType) + } + expectedAnnotator := "File Commenter" + if ann.Annotator != expectedAnnotator { + t.Errorf("expected %s, found %s", expectedAnnotator, ann.Annotator) + } + expectedAnnotatorType := "Person" + if ann.AnnotationType != expectedAnnotationType { + t.Errorf("expected %s, found %s", expectedAnnotatorType, ann.AnnotatorType) + } + + if n := len(parser.doc.Relationships); n != 1 { + t.Errorf("doc should've had 1 relation. found %d", n) + } + reln := parser.doc.Relationships[0] + expectedRefAEID := "item177" + if reln.RefA.DocumentRefID != "" { + t.Errorf("expected refA.DocumentRefID to be empty, found %s", reln.RefA.DocumentRefID) + } + if string(reln.RefA.ElementRefID) != expectedRefAEID { + t.Errorf("expected %s, found %s", expectedRefAEID, reln.RefA.ElementRefID) + } + expectedRefBEID := "Package" + if reln.RefB.DocumentRefID != "" { + t.Errorf("expected refB.DocumentRefID to be empty, found %s", reln.RefB.DocumentRefID) + } + if string(reln.RefB.ElementRefID) != expectedRefBEID { + t.Errorf("expected %s, found %s", expectedRefBEID, reln.RefB.ElementRefID) + } + expectedRelationType := "contains" + if reln.Relationship != expectedRelationType { + t.Errorf("expected %s, found %s", expectedRefBEID, reln.RefB.ElementRefID) + } + if reln.RelationshipComment != "" { + t.Errorf("expected relationship comment to be empty, found %s", reln.RelationshipComment) + } +} + +func Test_getNoticeTextFromNode(t *testing.T) { + // TestCase 1: SPDX_NOASSERTION_SMALL must return NOASSERTION + output := getNoticeTextFromNode(&gordfParser.Node{ + NodeType: gordfParser.IRI, + ID: SPDX_NOASSERTION_SMALL, + }) + if strings.ToUpper(output) != "NOASSERTION" { + t.Errorf("expected NOASSERTION, found %s", strings.ToUpper(output)) + } + + // TestCase 2: SPDX_NOASSERTION_CAPS must return NOASSERTION + output = getNoticeTextFromNode(&gordfParser.Node{ + NodeType: gordfParser.IRI, + ID: SPDX_NOASSERTION_CAPS, + }) + if strings.ToUpper(output) != "NOASSERTION" { + t.Errorf("expected NOASSERTION, found %s", strings.ToUpper(output)) + } + + // TestCase 3: not a NOASSERTION must return the field verbatim + // TestCase 1: SPDX_NOASSERTION_SMALL must return NOASSERTION + output = getNoticeTextFromNode(&gordfParser.Node{ + NodeType: gordfParser.IRI, + ID: "text", + }) + if output != "text" { + t.Errorf("expected text, found %s", output) + } +} + +func Test_rdfParser2_2_getLicenseInfoInFileFromNode(t *testing.T) { + parser, _ := parserFromBodyContent(``) + + // TestCase 1: noassertion License + lic, err := parser.getLicenseInfoInFileFromNode(&gordfParser.Node{ + NodeType: gordfParser.RESOURCELITERAL, + ID: SPDX_NOASSERTION_CAPS, + }) + if err != nil { + t.Errorf("error parsing a valid license") + } + if lic.ToLicenseString() != "NOASSERTION" { + t.Errorf("expected %s, found %s", "NOASSERTION", lic.ToLicenseString()) + } + + // TestCase 2: none License + lic, err = parser.getLicenseInfoInFileFromNode(&gordfParser.Node{ + NodeType: gordfParser.RESOURCELITERAL, + ID: SPDX_NONE_CAPS, + }) + if err != nil { + t.Errorf("error parsing a valid license") + } + if lic.ToLicenseString() != "NONE" { + t.Errorf("expected %s, found %s", "NONE", lic.ToLicenseString()) + } + + // TestCase 3: invalid license + // TestCase 1: noassertion License + node := &gordfParser.Node{ + NodeType: gordfParser.BLANK, + ID: "N0", + } + parser.gordfParserObj.Triples = append(parser.gordfParserObj.Triples, &gordfParser.Triple{ + Subject: node, + Predicate: &gordfParser.Node{ + NodeType: gordfParser.IRI, + ID: NS_SPDX + "invalidAttribute", + }, + Object: &gordfParser.Node{ + NodeType: gordfParser.IRI, + ID: NS_SPDX + "weirdLicense", + }, + }) + lic, err = parser.getLicenseInfoInFileFromNode(node) + if err == nil { + t.Errorf("should've raised an error parsing an invalid license") + } +} |