Blame - tools/compliance/cmd/sbom/sbom_test.go - android_build

2022-10-22 01:28:05 +0000

[diff] [blame]

2363

}

2364

Ibrahim Kanouche

8c745a4

2023-04-07 18:29:48 +0000

[diff] [blame]

2365

// validate returns an error if the Document is found to be invalid

2366

func validate(doc *spdx.Document) error {

2367

if doc.SPDXVersion == "" {

2368

return fmt.Errorf("SPDXVersion: got nothing, want spdx version")

2369

}

2370

if doc.DataLicense == "" {

2371

return fmt.Errorf("DataLicense: got nothing, want Data License")

2372

}

2373

if doc.SPDXIdentifier == "" {

2374

return fmt.Errorf("SPDXIdentifier: got nothing, want SPDX Identifier")

2375

}

2376

if doc.DocumentName == "" {

2377

return fmt.Errorf("DocumentName: got nothing, want Document Name")

2378

}

Jingwen Chen

376b6b6

2023-06-07 05:58:11 +0000

[diff] [blame]

2379

if c := fmt.Sprintf("%v", doc.CreationInfo.Creators[1].Creator); c != "Google LLC" {

2380

return fmt.Errorf("Creator: got %v, want 'Google LLC'", c)

Ibrahim Kanouche

8c745a4

2023-04-07 18:29:48 +0000

[diff] [blame]

2381

}

2382

_, err := time.Parse(time.RFC3339, doc.CreationInfo.Created)

2383

if err != nil {

2384

return fmt.Errorf("Invalid time spec: %q: got error %q, want no error", doc.CreationInfo.Created, err)

2385

}

2386

2387

for _, license := range doc.OtherLicenses {

2388

if license.ExtractedText == "" {

2389

return fmt.Errorf("License file: %q: got nothing, want license text", license.LicenseName)

}

}

return nil

}

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2395

// compareSpdxDocs deep-compares two spdx docs by going through the info section, packages, relationships and licenses

2396

func compareSpdxDocs(t *testing.T, actual, expected *spdx.Document) {

2397

2398

if actual == nil || expected == nil {

2399

t.Errorf("SBOM: SPDX Doc is nil! Got %v: Expected %v", actual, expected)

2400

}

Ibrahim Kanouche

f89fc4a

2023-04-03 20:15:14 +0000

[diff] [blame]

2401

2402

if actual.DocumentName != expected.DocumentName {

2403

t.Errorf("sbom: unexpected SPDX Document Name got %q, want %q", actual.DocumentName, expected.DocumentName)

2404

}

2405

2406

if actual.SPDXVersion != expected.SPDXVersion {

2407

t.Errorf("sbom: unexpected SPDX Version got %s, want %s", actual.SPDXVersion, expected.SPDXVersion)

2408

}

2409

2410

if actual.DataLicense != expected.DataLicense {

2411

t.Errorf("sbom: unexpected SPDX DataLicense got %s, want %s", actual.DataLicense, expected.DataLicense)

2412

}

2413

2414

if actual.SPDXIdentifier != expected.SPDXIdentifier {

2415

t.Errorf("sbom: unexpected SPDX Identified got %s, want %s", actual.SPDXIdentifier, expected.SPDXIdentifier)

2416

}

2417

2418

if actual.DocumentNamespace != expected.DocumentNamespace {

2419

t.Errorf("sbom: unexpected SPDX Document Namespace got %s, want %s", actual.DocumentNamespace, expected.DocumentNamespace)

2420

}

2421

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2422

// compare creation info

2423

compareSpdxCreationInfo(t, actual.CreationInfo, expected.CreationInfo)

2424

2425

// compare packages

2426

if len(actual.Packages) != len(expected.Packages) {

2427

t.Errorf("SBOM: Number of Packages is different! Got %d: Expected %d", len(actual.Packages), len(expected.Packages))

2428

}

2429

2430

for i, pkg := range actual.Packages {

2431

if !compareSpdxPackages(t, i, pkg, expected.Packages[i]) {

break

}

}

// compare licenses

if len(actual.OtherLicenses) != len(expected.OtherLicenses) {

2438

t.Errorf("SBOM: Number of Licenses in actual is different! Got %d: Expected %d", len(actual.OtherLicenses), len(expected.OtherLicenses))

2439

}

2440

for i, license := range actual.OtherLicenses {

2441

if !compareLicenses(t, i, license, expected.OtherLicenses[i]) {

break

}

}

//compare Relationships

2447

if len(actual.Relationships) != len(expected.Relationships) {

2448

t.Errorf("SBOM: Number of Licenses in actual is different! Got %d: Expected %d", len(actual.Relationships), len(expected.Relationships))

2449

}

2450

for i, rl := range actual.Relationships {

2451

if !compareRelationShips(t, i, rl, expected.Relationships[i]) {

2452

break

2453

}

2454

}

Ibrahim Kanouche

2022-10-22 01:28:05 +0000

[diff] [blame]

2455

}

2456

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2457

func compareSpdxCreationInfo(t *testing.T, actual, expected *spdx.CreationInfo) {

2458

if actual == nil || expected == nil {

2459

t.Errorf("SBOM: Creation info is nil! Got %q: Expected %q", actual, expected)

2460

}

2461

2462

if actual.LicenseListVersion != expected.LicenseListVersion {

2463

t.Errorf("SBOM: Creation info license version Error! Got %s: Expected %s", actual.LicenseListVersion, expected.LicenseListVersion)

2464

}

2465

2466

if len(actual.Creators) != len(expected.Creators) {

2467

t.Errorf("SBOM: Creation info creators Error! Got %d: Expected %d", len(actual.Creators), len(expected.Creators))

2468

}

2469

2470

for i, info := range actual.Creators {

2471

if info != expected.Creators[i] {

2472

t.Errorf("SBOM: Creation info creators Error! Got %q: Expected %q", info, expected.Creators[i])

}

}

}

func compareSpdxPackages(t *testing.T, i int, actual, expected *spdx.Package) bool {

2478

if actual == nil || expected == nil {

2479

t.Errorf("SBOM: Packages are nil at index %d! Got %v: Expected %v", i, actual, expected)

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2480

return false

Ibrahim Kanouche

e97adc5

2023-03-20 16:42:09 +0000

[diff] [blame]

2481

}

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2482

if actual.PackageName != expected.PackageName {

2483

t.Errorf("SBOM: Package name Error at index %d! Got %s: Expected %s", i, actual.PackageName, expected.PackageName)

Ibrahim Kanouche

e97adc5

2023-03-20 16:42:09 +0000

[diff] [blame]

2484

return false

2485

}

Ibrahim Kanouche

2022-10-22 01:28:05 +0000

[diff] [blame]

2486

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2487

if actual.PackageVersion != expected.PackageVersion {

2488

t.Errorf("SBOM: Package version Error at index %d! Got %s: Expected %s", i, actual.PackageVersion, expected.PackageVersion)

Ibrahim Kanouche

e97adc5

2023-03-20 16:42:09 +0000

[diff] [blame]

2489

return false

2490

}

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2491

2492

if actual.PackageSPDXIdentifier != expected.PackageSPDXIdentifier {

2493

t.Errorf("SBOM: Package identifier Error at index %d! Got %s: Expected %s", i, actual.PackageSPDXIdentifier, expected.PackageSPDXIdentifier)

return false

}

if actual.PackageDownloadLocation != expected.PackageDownloadLocation {

2498

t.Errorf("SBOM: Package download location Error at index %d! Got %s: Expected %s", i, actual.PackageDownloadLocation, expected.PackageDownloadLocation)

return false

}

if actual.PackageLicenseConcluded != expected.PackageLicenseConcluded {

2503

t.Errorf("SBOM: Package license concluded Error at index %d! Got %s: Expected %s", i, actual.PackageLicenseConcluded, expected.PackageLicenseConcluded)

2504

return false

2505

}

2506

return true

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2507

}

2508

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2509

func compareRelationShips(t *testing.T, i int, actual, expected *spdx.Relationship) bool {

2510

if actual == nil || expected == nil {

2511

t.Errorf("SBOM: Relationships is nil at index %d! Got %v: Expected %v", i, actual, expected)

return false

}

if actual.RefA != expected.RefA {

2516

t.Errorf("SBOM: Relationship RefA Error at index %d! Got %s: Expected %s", i, actual.RefA, expected.RefA)

return false

}

if actual.RefB != expected.RefB {

2521

t.Errorf("SBOM: Relationship RefB Error at index %d! Got %s: Expected %s", i, actual.RefB, expected.RefB)

return false

}

if actual.Relationship != expected.Relationship {

2526

t.Errorf("SBOM: Relationship type Error at index %d! Got %s: Expected %s", i, actual.Relationship, expected.Relationship)

2527

return false

2528

}

2529

return true

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2530

}

2531

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2532

func compareLicenses(t *testing.T, i int, actual, expected *spdx.OtherLicense) bool {

2533

if actual == nil || expected == nil {

2534

t.Errorf("SBOM: Licenses is nil at index %d! Got %v: Expected %v", i, actual, expected)

2535

return false

2536

}

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2537

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2538

if actual.LicenseName != expected.LicenseName {

2539

t.Errorf("SBOM: License Name Error at index %d! Got %s: Expected %s", i, actual.LicenseName, expected.LicenseName)

2540

return false

2541

}

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2542

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2543

if actual.LicenseIdentifier != expected.LicenseIdentifier {

2544

t.Errorf("SBOM: License Identifier Error at index %d! Got %s: Expected %s", i, actual.LicenseIdentifier, expected.LicenseIdentifier)

2545

return false

2546

}

Bob Badour

2023-03-31 14:51:36 +0000

[diff] [blame]

2547

Ibrahim Kanouche

2023-04-01 05:05:32 +0000

[diff] [blame]

2548

if actual.ExtractedText != expected.ExtractedText {

2549

t.Errorf("SBOM: License Extracted Text Error at index %d! Got: %q want: %q", i, actual.ExtractedText, expected.ExtractedText)

2550

return false

2551

}

2552

return true

Ibrahim Kanouche

2022-10-22 01:28:05 +0000

[diff] [blame]

2553

}

2554

Ibrahim Kanouche

f89fc4a

2023-04-03 20:15:14 +0000

[diff] [blame]

2555

func fakeTime() string {

2556

t := time.UnixMicro(0)

2557

return t.UTC().Format("2006-01-02T15:04:05Z")

Ibrahim Kanouche