1// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later 2 3package spdxlib 4 5import ( 6 "testing" 7 8 "github.com/spdx/tools-golang/spdx/common" 9 "github.com/spdx/tools-golang/spdx/v2_1" 10 "github.com/spdx/tools-golang/spdx/v2_2" 11 "github.com/spdx/tools-golang/spdx/v2_3" 12) 13 14// ===== 2.1 tests ===== 15 16func Test2_1CanGetIDsOfDescribedPackages(t *testing.T) { 17 // set up document and some packages and relationships 18 doc := &v2_1.Document{ 19 SPDXVersion: "SPDX-2.1", 20 DataLicense: "CC0-1.0", 21 SPDXIdentifier: common.ElementID("DOCUMENT"), 22 CreationInfo: &v2_1.CreationInfo{}, 23 Packages: []*v2_1.Package{ 24 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 25 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 26 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 27 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 28 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 29 }, 30 Relationships: []*v2_1.Relationship{ 31 &v2_1.Relationship{ 32 RefA: common.MakeDocElementID("", "DOCUMENT"), 33 RefB: common.MakeDocElementID("", "p1"), 34 Relationship: "DESCRIBES", 35 }, 36 &v2_1.Relationship{ 37 RefA: common.MakeDocElementID("", "DOCUMENT"), 38 RefB: common.MakeDocElementID("", "p5"), 39 Relationship: "DESCRIBES", 40 }, 41 // inverse relationship -- should also get detected 42 &v2_1.Relationship{ 43 RefA: common.MakeDocElementID("", "p4"), 44 RefB: common.MakeDocElementID("", "DOCUMENT"), 45 Relationship: "DESCRIBED_BY", 46 }, 47 // different relationship 48 &v2_1.Relationship{ 49 RefA: common.MakeDocElementID("", "p1"), 50 RefB: common.MakeDocElementID("", "p2"), 51 Relationship: "DEPENDS_ON", 52 }, 53 }, 54 } 55 56 // request IDs for DESCRIBES / DESCRIBED_BY relationships 57 describedPkgIDs, err := GetDescribedPackageIDs2_1(doc) 58 if err != nil { 59 t.Fatalf("expected nil error, got %v", err) 60 } 61 // should be three of the five IDs, returned in alphabetical order 62 if len(describedPkgIDs) != 3 { 63 t.Fatalf("expected %d packages, got %d", 3, len(describedPkgIDs)) 64 } 65 if describedPkgIDs[0] != common.ElementID("p1") { 66 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 67 } 68 if describedPkgIDs[1] != common.ElementID("p4") { 69 t.Errorf("expected %v, got %v", common.ElementID("p4"), describedPkgIDs[1]) 70 } 71 if describedPkgIDs[2] != common.ElementID("p5") { 72 t.Errorf("expected %v, got %v", common.ElementID("p5"), describedPkgIDs[2]) 73 } 74} 75 76func Test2_1GetDescribedPackagesReturnsSinglePackageIfOnlyOne(t *testing.T) { 77 // set up document and one package, but no relationships 78 // b/c only one package 79 doc := &v2_1.Document{ 80 SPDXVersion: "SPDX-2.1", 81 DataLicense: "CC0-1.0", 82 SPDXIdentifier: common.ElementID("DOCUMENT"), 83 CreationInfo: &v2_1.CreationInfo{}, 84 Packages: []*v2_1.Package{ 85 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 86 }, 87 } 88 89 // request IDs for DESCRIBES / DESCRIBED_BY relationships 90 describedPkgIDs, err := GetDescribedPackageIDs2_1(doc) 91 if err != nil { 92 t.Fatalf("expected nil error, got %v", err) 93 } 94 // should return the single package 95 if len(describedPkgIDs) != 1 { 96 t.Fatalf("expected %d package, got %d", 1, len(describedPkgIDs)) 97 } 98 if describedPkgIDs[0] != common.ElementID("p1") { 99 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 100 } 101} 102 103func Test2_1FailsToGetDescribedPackagesIfMoreThanOneWithoutDescribesRelationship(t *testing.T) { 104 // set up document and multiple packages, but no DESCRIBES relationships 105 doc := &v2_1.Document{ 106 SPDXVersion: "SPDX-2.1", 107 DataLicense: "CC0-1.0", 108 SPDXIdentifier: common.ElementID("DOCUMENT"), 109 CreationInfo: &v2_1.CreationInfo{}, 110 Packages: []*v2_1.Package{ 111 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 112 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 113 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 114 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 115 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 116 }, 117 Relationships: []*v2_1.Relationship{ 118 // different relationship 119 &v2_1.Relationship{ 120 RefA: common.MakeDocElementID("", "p1"), 121 RefB: common.MakeDocElementID("", "p2"), 122 Relationship: "DEPENDS_ON", 123 }, 124 }, 125 } 126 127 _, err := GetDescribedPackageIDs2_1(doc) 128 if err == nil { 129 t.Fatalf("expected non-nil error, got nil") 130 } 131} 132 133func Test2_1FailsToGetDescribedPackagesIfMoreThanOneWithNilRelationships(t *testing.T) { 134 // set up document and multiple packages, but no relationships slice 135 doc := &v2_1.Document{ 136 SPDXVersion: "SPDX-2.1", 137 DataLicense: "CC0-1.0", 138 SPDXIdentifier: common.ElementID("DOCUMENT"), 139 CreationInfo: &v2_1.CreationInfo{}, 140 Packages: []*v2_1.Package{ 141 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 142 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 143 }, 144 } 145 146 _, err := GetDescribedPackageIDs2_1(doc) 147 if err == nil { 148 t.Fatalf("expected non-nil error, got nil") 149 } 150} 151 152func Test2_1FailsToGetDescribedPackagesIfZeroPackagesInMap(t *testing.T) { 153 // set up document but no packages 154 doc := &v2_1.Document{ 155 SPDXVersion: "SPDX-2.1", 156 DataLicense: "CC0-1.0", 157 SPDXIdentifier: common.ElementID("DOCUMENT"), 158 CreationInfo: &v2_1.CreationInfo{}, 159 Packages: []*v2_1.Package{}, 160 } 161 162 _, err := GetDescribedPackageIDs2_1(doc) 163 if err == nil { 164 t.Fatalf("expected non-nil error, got nil") 165 } 166} 167 168func Test2_1FailsToGetDescribedPackagesIfNilMap(t *testing.T) { 169 // set up document but no packages 170 doc := &v2_1.Document{ 171 SPDXVersion: "SPDX-2.1", 172 DataLicense: "CC0-1.0", 173 SPDXIdentifier: common.ElementID("DOCUMENT"), 174 CreationInfo: &v2_1.CreationInfo{}, 175 } 176 177 _, err := GetDescribedPackageIDs2_1(doc) 178 if err == nil { 179 t.Fatalf("expected non-nil error, got nil") 180 } 181} 182 183// ===== 2.2 tests ===== 184 185func Test2_2CanGetIDsOfDescribedPackages(t *testing.T) { 186 // set up document and some packages and relationships 187 doc := &v2_2.Document{ 188 SPDXVersion: "SPDX-2.2", 189 DataLicense: "CC0-1.0", 190 SPDXIdentifier: common.ElementID("DOCUMENT"), 191 CreationInfo: &v2_2.CreationInfo{}, 192 Packages: []*v2_2.Package{ 193 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 194 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 195 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 196 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 197 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 198 }, 199 Relationships: []*v2_2.Relationship{ 200 &v2_2.Relationship{ 201 RefA: common.MakeDocElementID("", "DOCUMENT"), 202 RefB: common.MakeDocElementID("", "p1"), 203 Relationship: "DESCRIBES", 204 }, 205 &v2_2.Relationship{ 206 RefA: common.MakeDocElementID("", "DOCUMENT"), 207 RefB: common.MakeDocElementID("", "p5"), 208 Relationship: "DESCRIBES", 209 }, 210 // inverse relationship -- should also get detected 211 &v2_2.Relationship{ 212 RefA: common.MakeDocElementID("", "p4"), 213 RefB: common.MakeDocElementID("", "DOCUMENT"), 214 Relationship: "DESCRIBED_BY", 215 }, 216 // different relationship 217 &v2_2.Relationship{ 218 RefA: common.MakeDocElementID("", "p1"), 219 RefB: common.MakeDocElementID("", "p2"), 220 Relationship: "DEPENDS_ON", 221 }, 222 }, 223 } 224 225 // request IDs for DESCRIBES / DESCRIBED_BY relationships 226 describedPkgIDs, err := GetDescribedPackageIDs2_2(doc) 227 if err != nil { 228 t.Fatalf("expected nil error, got %v", err) 229 } 230 // should be three of the five IDs, returned in alphabetical order 231 if len(describedPkgIDs) != 3 { 232 t.Fatalf("expected %d packages, got %d", 3, len(describedPkgIDs)) 233 } 234 if describedPkgIDs[0] != common.ElementID("p1") { 235 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 236 } 237 if describedPkgIDs[1] != common.ElementID("p4") { 238 t.Errorf("expected %v, got %v", common.ElementID("p4"), describedPkgIDs[1]) 239 } 240 if describedPkgIDs[2] != common.ElementID("p5") { 241 t.Errorf("expected %v, got %v", common.ElementID("p5"), describedPkgIDs[2]) 242 } 243} 244 245func Test2_2GetDescribedPackagesReturnsSinglePackageIfOnlyOne(t *testing.T) { 246 // set up document and one package, but no relationships 247 // b/c only one package 248 doc := &v2_2.Document{ 249 SPDXVersion: "SPDX-2.2", 250 DataLicense: "CC0-1.0", 251 SPDXIdentifier: common.ElementID("DOCUMENT"), 252 CreationInfo: &v2_2.CreationInfo{}, 253 Packages: []*v2_2.Package{ 254 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 255 }, 256 } 257 258 // request IDs for DESCRIBES / DESCRIBED_BY relationships 259 describedPkgIDs, err := GetDescribedPackageIDs2_2(doc) 260 if err != nil { 261 t.Fatalf("expected nil error, got %v", err) 262 } 263 // should return the single package 264 if len(describedPkgIDs) != 1 { 265 t.Fatalf("expected %d package, got %d", 1, len(describedPkgIDs)) 266 } 267 if describedPkgIDs[0] != common.ElementID("p1") { 268 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 269 } 270} 271 272func Test2_2FailsToGetDescribedPackagesIfMoreThanOneWithoutDescribesRelationship(t *testing.T) { 273 // set up document and multiple packages, but no DESCRIBES relationships 274 doc := &v2_2.Document{ 275 SPDXVersion: "SPDX-2.2", 276 DataLicense: "CC0-1.0", 277 SPDXIdentifier: common.ElementID("DOCUMENT"), 278 CreationInfo: &v2_2.CreationInfo{}, 279 Packages: []*v2_2.Package{ 280 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 281 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 282 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 283 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 284 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 285 }, 286 Relationships: []*v2_2.Relationship{ 287 // different relationship 288 &v2_2.Relationship{ 289 RefA: common.MakeDocElementID("", "p1"), 290 RefB: common.MakeDocElementID("", "p2"), 291 Relationship: "DEPENDS_ON", 292 }, 293 }, 294 } 295 296 _, err := GetDescribedPackageIDs2_2(doc) 297 if err == nil { 298 t.Fatalf("expected non-nil error, got nil") 299 } 300} 301 302func Test2_2FailsToGetDescribedPackagesIfMoreThanOneWithNilRelationships(t *testing.T) { 303 // set up document and multiple packages, but no relationships slice 304 doc := &v2_2.Document{ 305 SPDXVersion: "SPDX-2.2", 306 DataLicense: "CC0-1.0", 307 SPDXIdentifier: common.ElementID("DOCUMENT"), 308 CreationInfo: &v2_2.CreationInfo{}, 309 Packages: []*v2_2.Package{ 310 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 311 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 312 }, 313 } 314 315 _, err := GetDescribedPackageIDs2_2(doc) 316 if err == nil { 317 t.Fatalf("expected non-nil error, got nil") 318 } 319} 320 321func Test2_2FailsToGetDescribedPackagesIfZeroPackagesInMap(t *testing.T) { 322 // set up document but no packages 323 doc := &v2_2.Document{ 324 SPDXVersion: "SPDX-2.2", 325 DataLicense: "CC0-1.0", 326 SPDXIdentifier: common.ElementID("DOCUMENT"), 327 CreationInfo: &v2_2.CreationInfo{}, 328 Packages: []*v2_2.Package{}, 329 } 330 331 _, err := GetDescribedPackageIDs2_2(doc) 332 if err == nil { 333 t.Fatalf("expected non-nil error, got nil") 334 } 335} 336 337func Test2_2FailsToGetDescribedPackagesIfNilMap(t *testing.T) { 338 // set up document but no packages 339 doc := &v2_2.Document{ 340 SPDXVersion: "SPDX-2.2", 341 DataLicense: "CC0-1.0", 342 SPDXIdentifier: common.ElementID("DOCUMENT"), 343 CreationInfo: &v2_2.CreationInfo{}, 344 } 345 346 _, err := GetDescribedPackageIDs2_2(doc) 347 if err == nil { 348 t.Fatalf("expected non-nil error, got nil") 349 } 350} 351 352// ===== 2.3 tests ===== 353 354func Test2_3CanGetIDsOfDescribedPackages(t *testing.T) { 355 // set up document and some packages and relationships 356 doc := &v2_3.Document{ 357 SPDXVersion: "SPDX-2.3", 358 DataLicense: "CC0-1.0", 359 SPDXIdentifier: common.ElementID("DOCUMENT"), 360 CreationInfo: &v2_3.CreationInfo{}, 361 Packages: []*v2_3.Package{ 362 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 363 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 364 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 365 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 366 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 367 }, 368 Relationships: []*v2_3.Relationship{ 369 &v2_3.Relationship{ 370 RefA: common.MakeDocElementID("", "DOCUMENT"), 371 RefB: common.MakeDocElementID("", "p1"), 372 Relationship: "DESCRIBES", 373 }, 374 &v2_3.Relationship{ 375 RefA: common.MakeDocElementID("", "DOCUMENT"), 376 RefB: common.MakeDocElementID("", "p5"), 377 Relationship: "DESCRIBES", 378 }, 379 // inverse relationship -- should also get detected 380 &v2_3.Relationship{ 381 RefA: common.MakeDocElementID("", "p4"), 382 RefB: common.MakeDocElementID("", "DOCUMENT"), 383 Relationship: "DESCRIBED_BY", 384 }, 385 // different relationship 386 &v2_3.Relationship{ 387 RefA: common.MakeDocElementID("", "p1"), 388 RefB: common.MakeDocElementID("", "p2"), 389 Relationship: "DEPENDS_ON", 390 }, 391 }, 392 } 393 394 // request IDs for DESCRIBES / DESCRIBED_BY relationships 395 describedPkgIDs, err := GetDescribedPackageIDs2_3(doc) 396 if err != nil { 397 t.Fatalf("expected nil error, got %v", err) 398 } 399 // should be three of the five IDs, returned in alphabetical order 400 if len(describedPkgIDs) != 3 { 401 t.Fatalf("expected %d packages, got %d", 3, len(describedPkgIDs)) 402 } 403 if describedPkgIDs[0] != common.ElementID("p1") { 404 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 405 } 406 if describedPkgIDs[1] != common.ElementID("p4") { 407 t.Errorf("expected %v, got %v", common.ElementID("p4"), describedPkgIDs[1]) 408 } 409 if describedPkgIDs[2] != common.ElementID("p5") { 410 t.Errorf("expected %v, got %v", common.ElementID("p5"), describedPkgIDs[2]) 411 } 412} 413 414func Test2_3GetDescribedPackagesReturnsSinglePackageIfOnlyOne(t *testing.T) { 415 // set up document and one package, but no relationships 416 // b/c only one package 417 doc := &v2_3.Document{ 418 SPDXVersion: "SPDX-2.3", 419 DataLicense: "CC0-1.0", 420 SPDXIdentifier: common.ElementID("DOCUMENT"), 421 CreationInfo: &v2_3.CreationInfo{}, 422 Packages: []*v2_3.Package{ 423 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 424 }, 425 } 426 427 // request IDs for DESCRIBES / DESCRIBED_BY relationships 428 describedPkgIDs, err := GetDescribedPackageIDs2_3(doc) 429 if err != nil { 430 t.Fatalf("expected nil error, got %v", err) 431 } 432 // should return the single package 433 if len(describedPkgIDs) != 1 { 434 t.Fatalf("expected %d package, got %d", 1, len(describedPkgIDs)) 435 } 436 if describedPkgIDs[0] != common.ElementID("p1") { 437 t.Errorf("expected %v, got %v", common.ElementID("p1"), describedPkgIDs[0]) 438 } 439} 440 441func Test2_3FailsToGetDescribedPackagesIfMoreThanOneWithoutDescribesRelationship(t *testing.T) { 442 // set up document and multiple packages, but no DESCRIBES relationships 443 doc := &v2_3.Document{ 444 SPDXVersion: "SPDX-2.3", 445 DataLicense: "CC0-1.0", 446 SPDXIdentifier: common.ElementID("DOCUMENT"), 447 CreationInfo: &v2_3.CreationInfo{}, 448 Packages: []*v2_3.Package{ 449 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 450 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 451 {PackageName: "pkg3", PackageSPDXIdentifier: "p3"}, 452 {PackageName: "pkg4", PackageSPDXIdentifier: "p4"}, 453 {PackageName: "pkg5", PackageSPDXIdentifier: "p5"}, 454 }, 455 Relationships: []*v2_3.Relationship{ 456 // different relationship 457 &v2_3.Relationship{ 458 RefA: common.MakeDocElementID("", "p1"), 459 RefB: common.MakeDocElementID("", "p2"), 460 Relationship: "DEPENDS_ON", 461 }, 462 }, 463 } 464 465 _, err := GetDescribedPackageIDs2_3(doc) 466 if err == nil { 467 t.Fatalf("expected non-nil error, got nil") 468 } 469} 470 471func Test2_3FailsToGetDescribedPackagesIfMoreThanOneWithNilRelationships(t *testing.T) { 472 // set up document and multiple packages, but no relationships slice 473 doc := &v2_3.Document{ 474 SPDXVersion: "SPDX-2.3", 475 DataLicense: "CC0-1.0", 476 SPDXIdentifier: common.ElementID("DOCUMENT"), 477 CreationInfo: &v2_3.CreationInfo{}, 478 Packages: []*v2_3.Package{ 479 {PackageName: "pkg1", PackageSPDXIdentifier: "p1"}, 480 {PackageName: "pkg2", PackageSPDXIdentifier: "p2"}, 481 }, 482 } 483 484 _, err := GetDescribedPackageIDs2_3(doc) 485 if err == nil { 486 t.Fatalf("expected non-nil error, got nil") 487 } 488} 489 490func Test2_3FailsToGetDescribedPackagesIfZeroPackagesInMap(t *testing.T) { 491 // set up document but no packages 492 doc := &v2_3.Document{ 493 SPDXVersion: "SPDX-2.3", 494 DataLicense: "CC0-1.0", 495 SPDXIdentifier: common.ElementID("DOCUMENT"), 496 CreationInfo: &v2_3.CreationInfo{}, 497 Packages: []*v2_3.Package{}, 498 } 499 500 _, err := GetDescribedPackageIDs2_3(doc) 501 if err == nil { 502 t.Fatalf("expected non-nil error, got nil") 503 } 504} 505 506func Test2_3FailsToGetDescribedPackagesIfNilMap(t *testing.T) { 507 // set up document but no packages 508 doc := &v2_3.Document{ 509 SPDXVersion: "SPDX-2.3", 510 DataLicense: "CC0-1.0", 511 SPDXIdentifier: common.ElementID("DOCUMENT"), 512 CreationInfo: &v2_3.CreationInfo{}, 513 } 514 515 _, err := GetDescribedPackageIDs2_3(doc) 516 if err == nil { 517 t.Fatalf("expected non-nil error, got nil") 518 } 519} 520