| // Copyright 2017 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| package build | |
| import ( | |
| "bytes" | |
| "crypto/rand" | |
| "encoding/binary" | |
| "encoding/json" | |
| "errors" | |
| "fmt" | |
| "io" | |
| "os" | |
| "path/filepath" | |
| "sort" | |
| "strings" | |
| "testing" | |
| "github.com/google/go-cmp/cmp" | |
| far "go.fuchsia.dev/fuchsia/src/sys/pkg/lib/far/go" | |
| "go.fuchsia.dev/fuchsia/src/sys/pkg/lib/merkle" | |
| "go.fuchsia.dev/fuchsia/src/testing/host-target-testing/pkg" | |
| ) | |
| // Verifies package manifests can be properly loaded. | |
| func TestLoadPackageManifest(t *testing.T) { | |
| testCases := []struct { | |
| name string | |
| buildDirContents map[string]string | |
| manifestPathToLoad string | |
| expectedManifest PackageManifest | |
| wantError bool | |
| }{ | |
| { | |
| name: "success valid path, blobs, and subpackages", | |
| buildDirContents: map[string]string{ | |
| "package_manifest.json": `{ | |
| "version": "1", | |
| "blobs": [ | |
| { "merkle": "0000000000000000000000000000000000000000000000000000000000000000" } | |
| ], | |
| "subpackages": [ | |
| { | |
| "name": "some_subpackage", | |
| "merkle": "1111111111111111111111111111111111111111111111111111111111111111", | |
| "manifest_path": "subpackage_manifest.json" | |
| } | |
| ] | |
| }`, | |
| }, | |
| manifestPathToLoad: "package_manifest.json", | |
| expectedManifest: PackageManifest{ | |
| Version: "1", | |
| Blobs: []PackageBlobInfo{ | |
| {Merkle: MustDecodeMerkleRoot("0000000000000000000000000000000000000000000000000000000000000000")}, | |
| }, | |
| Subpackages: []PackageSubpackageInfo{ | |
| { | |
| Name: "some_subpackage", | |
| Merkle: MustDecodeMerkleRoot("1111111111111111111111111111111111111111111111111111111111111111"), | |
| ManifestPath: "subpackage_manifest.json", | |
| }, | |
| }, | |
| }, | |
| }, | |
| { | |
| name: "failure incompatible version", | |
| buildDirContents: map[string]string{ | |
| "package_manifest.json": `{ | |
| "version": "2", | |
| }`, | |
| }, | |
| manifestPathToLoad: "package_manifest.json", | |
| wantError: true, | |
| }, | |
| { | |
| name: "failure json improperly formatted", | |
| buildDirContents: map[string]string{ | |
| "package_manifest.json": `{ | |
| Oops. This is not valid json. | |
| }`, | |
| }, | |
| manifestPathToLoad: "package_manifest.json", | |
| wantError: true, | |
| }, { | |
| name: "failure package manifest does not exist", | |
| manifestPathToLoad: "non_existent_manifest.json", | |
| wantError: true, | |
| }, | |
| } | |
| for _, tc := range testCases { | |
| t.Run(tc.name, func(t *testing.T) { | |
| // Generate test env based on input. | |
| tempDirPath := createBuildDir(t, tc.buildDirContents) | |
| // Now that we're set up, we can actually load the package manifest. | |
| actualManifest, err := LoadPackageManifest(filepath.Join(tempDirPath, tc.manifestPathToLoad)) | |
| // Ensure the results match the expectations. | |
| if (err == nil) == tc.wantError { | |
| t.Fatalf("got error [%v], want error? %t", err, tc.wantError) | |
| } | |
| if diff := cmp.Diff(actualManifest, &tc.expectedManifest); err == nil && diff != "" { | |
| t.Fatalf("got manifest %#v, expected %#v", actualManifest, tc.expectedManifest) | |
| } | |
| }) | |
| } | |
| } | |
| func createBuildDir(t *testing.T, files map[string]string) string { | |
| dir := t.TempDir() | |
| for filename, data := range files { | |
| if err := os.MkdirAll(filepath.Join(dir, filepath.Dir(filename)), 0o700); err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := os.WriteFile(filepath.Join(dir, filename), []byte(data), 0o600); err != nil { | |
| t.Fatal(err) | |
| } | |
| } | |
| return dir | |
| } | |
| func TestInit(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| if err := Init(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| f, err := os.Open(filepath.Join(cfg.OutputDir, "meta", "package")) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| var p pkg.Package | |
| if err := json.NewDecoder(f).Decode(&p); err != nil { | |
| t.Fatal(err) | |
| } | |
| f.Close() | |
| if want := cfg.PkgName; p.Name != want { | |
| t.Errorf("got %q, want %q", p.Name, want) | |
| } | |
| if want := "0"; p.Version != want { | |
| t.Errorf("got %q, want %q", p.Version, want) | |
| } | |
| os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| // test condition where package name is empty, name should match the | |
| // name of the output directory | |
| cfg.PkgName = "" | |
| if err = Init(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| f, err = os.Open(filepath.Join(cfg.OutputDir, "meta", "package")) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if err = json.NewDecoder(f).Decode(&p); err != nil { | |
| t.Fatal(err) | |
| } | |
| f.Close() | |
| if want := filepath.Base(cfg.OutputDir); p.Name != want { | |
| t.Errorf("got %q, want %q", p.Name, want) | |
| } | |
| } | |
| func TestUpdate(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| cfg.PkgABIRevision = TestABIRevision | |
| TestPackage(cfg) | |
| manifest, err := cfg.Manifest() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for _, f := range manifest.Content() { | |
| fd, err := os.Create(f) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := io.CopyN(fd, rand.Reader, 1024); err != nil { | |
| t.Fatal(err) | |
| } | |
| fd.Close() | |
| } | |
| if _, ok := manifest.Meta()["meta/contents"]; ok { | |
| t.Fatalf("unexpected pre-existing meta/contents in manifest") | |
| } | |
| if err := Update(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, ok := manifest.Meta()[abiRevisionKey]; !ok { | |
| t.Fatalf("%s was not found in manifest after update", abiRevisionKey) | |
| } | |
| contentsPath, ok := manifest.Meta()["meta/contents"] | |
| if !ok { | |
| t.Fatalf("meta/contents was not found in manifest after update") | |
| } | |
| f, err := os.Open(contentsPath) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| buf, err := io.ReadAll(f) | |
| f.Close() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| lines := strings.Split(string(buf), "\n") | |
| sort.Strings(lines) | |
| if lines[0] == "" { | |
| lines = lines[1:] | |
| } | |
| contentFiles := []string{} | |
| for _, s := range TestFiles { | |
| if strings.HasPrefix(s, "meta/") { | |
| continue | |
| } | |
| contentFiles = append(contentFiles, s) | |
| } | |
| if len(lines) != len(contentFiles) { | |
| t.Fatalf("content lines mismatch: %v\n%v", lines, contentFiles) | |
| } | |
| files := []string{} | |
| files = append(files, contentFiles...) | |
| sort.Strings(files) | |
| for i, pf := range files { | |
| var tree merkle.Tree | |
| f, err := os.Open(manifest.Paths[pf]) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := tree.ReadFrom(f); err != nil { | |
| t.Fatal(err) | |
| } | |
| f.Close() | |
| want := fmt.Sprintf("%s=%x", pf, tree.Root()) | |
| if lines[i] != want { | |
| t.Errorf("contents mismatch: got %q, want %q", lines[i], want) | |
| break | |
| } | |
| } | |
| } | |
| func TestUpdateTakesABIRevisionAndWritesABIRevision(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| TestPackage(cfg) | |
| manifest, err := cfg.Manifest() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| if err := Update(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| // FIXME(https://fxbug.dev/42168416): In order to ease migration, initially the | |
| // abi-revision is not required. | |
| abiRevisionPath, ok := manifest.Meta()[abiRevisionKey] | |
| if !ok { | |
| t.Fatalf("%s was not found in manifest after update", abiRevisionKey) | |
| } | |
| f, err := os.Open(abiRevisionPath) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| defer f.Close() | |
| var abiRevision uint64 | |
| if err := binary.Read(f, binary.LittleEndian, &abiRevision); err != nil { | |
| t.Fatal(err) | |
| } | |
| if abiRevision != TestABIRevision { | |
| t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision) | |
| } | |
| } | |
| func TestUpdateDoesNotRequireABIRevision(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| cfg.PkgABIRevision = 0 | |
| TestPackage(cfg) | |
| if err := Update(cfg); err != nil { | |
| t.Fatalf("expected update to not fail because ABI revision was not specified") | |
| } | |
| } | |
| func TestUpdateReadsABIRevisionFromDirectory(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| cfg.PkgABIRevision = 0 | |
| TestPackage(cfg) | |
| addTestABIRevisionToManifest(cfg, TestABIRevision) | |
| if err := Update(cfg); err != nil { | |
| t.Fatalf("expected update to read ABI revision from file: %v", err) | |
| } | |
| abiOutputPath := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg", "abi-revision") | |
| if _, err := os.Stat(abiOutputPath); err == nil { | |
| t.Fatalf("should not have created abi revision file: %s", abiOutputPath) | |
| } | |
| } | |
| func TestUpdateRequiresManifestABIRevisionToMatchCliABIRevision(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| TestPackage(cfg) | |
| addTestABIRevisionToManifest(cfg, TestABIRevision2) | |
| if err := Update(cfg); err == nil { | |
| t.Fatalf("expected update to fail because manifest ABI revision conflicted with CLI ABI revision") | |
| } | |
| cfg.PkgABIRevision = TestABIRevision2 | |
| if err := Update(cfg); err != nil { | |
| t.Fatalf("expected update to read ABI revision from file: %v", err) | |
| } | |
| abiOutputPath := filepath.Join(cfg.OutputDir, "meta", "fuchsia.pkg", "abi-revision") | |
| if _, err := os.Stat(abiOutputPath); err == nil { | |
| t.Fatalf("should not have created abi revision file: %s", abiOutputPath) | |
| } | |
| } | |
| func TestValidate(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| TestPackage(cfg) | |
| if err := Update(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| err := Validate(cfg) | |
| if err != nil { | |
| t.Fatalf("Unexpected validation error") | |
| } | |
| manifest, err := cfg.Manifest() | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| for _, f := range RequiredFiles { | |
| manifest.Paths[f+"a"] = manifest.Paths[f] | |
| delete(manifest.Paths, f) | |
| if err := Validate(cfg); err == nil { | |
| t.Errorf("expected a validation error when %q is missing", f) | |
| } | |
| manifest.Paths[f] = manifest.Paths[f+"a"] | |
| delete(manifest.Paths, f+"a") | |
| } | |
| } | |
| func TestSeal(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| TestPackage(cfg) | |
| if err := Update(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| if _, err := Seal(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| // TODO(raggi): until we have far reader support this test only verifies that | |
| // the package meta data was correctly updated, it doesn't actually verify | |
| // that the contents of the far are correct. | |
| metafar := filepath.Join(cfg.OutputDir, "meta.far") | |
| f, err := os.Open(metafar) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| r, err := far.NewReader(f) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| abiBytes, err := r.ReadFile(abiRevisionKey) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| var abiRevision uint64 | |
| if err := binary.Read(bytes.NewReader(abiBytes), binary.LittleEndian, &abiRevision); err != nil { | |
| t.Fatal(err) | |
| } | |
| if abiRevision != TestABIRevision { | |
| t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision) | |
| } | |
| } | |
| func TestSealDoesNotRequireABIRevision(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| TestPackage(cfg) | |
| if err := Update(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| cfg.PkgABIRevision = 0 | |
| if _, err := Seal(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| // This test only verifies that the package meta data was correctly | |
| // updated, it doesn't actually verify that the contents of the far are | |
| // correct. | |
| metafar := filepath.Join(cfg.OutputDir, "meta.far") | |
| f, err := os.Open(metafar) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| r, err := far.NewReader(f) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| // FIXME(https://fxbug.dev/42168416): In order to ease migration, initially the | |
| // abi-revision is not required. | |
| _, err = r.Open("meta/fuchsia.pkg/abi-revision") | |
| if err == nil { | |
| t.Fatalf("expected meta/fuchsia.pkg/abi-revision to not be present in meta.far") | |
| } | |
| if !errors.Is(err, os.ErrNotExist) { | |
| t.Fatalf("expected error to be does not exist, not %s", err) | |
| } | |
| } | |
| func TestSealReadsABIRevisionFromDirectory(t *testing.T) { | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| cfg.PkgABIRevision = 0 | |
| TestPackage(cfg) | |
| addTestABIRevisionToManifest(cfg, TestABIRevision) | |
| if err := Update(cfg); err != nil { | |
| t.Fatalf("expected update to read ABI revision from file: %v", err) | |
| } | |
| if _, err := Seal(cfg); err != nil { | |
| t.Fatal(err) | |
| } | |
| // This test only verifies that the package meta data was correctly | |
| // updated, it doesn't actually verify that the contents of the far are | |
| // correct. | |
| metafar := filepath.Join(cfg.OutputDir, "meta.far") | |
| f, err := os.Open(metafar) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| r, err := far.NewReader(f) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| abiBytes, err := r.ReadFile(abiRevisionKey) | |
| if err != nil { | |
| t.Fatal(err) | |
| } | |
| var abiRevision uint64 | |
| if err := binary.Read(bytes.NewReader(abiBytes), binary.LittleEndian, &abiRevision); err != nil { | |
| t.Fatal(err) | |
| } | |
| if abiRevision != TestABIRevision { | |
| t.Fatalf("expected ABI revision to be %x, not %x", TestABIRevision, abiRevision) | |
| } | |
| } | |
| func TestSealValidatesInvalidPackageRepository(t *testing.T) { | |
| defer func() { | |
| if r := recover(); r == nil { | |
| t.Fatalf("Expected to fail on invalid repository") | |
| } | |
| }() | |
| cfg := TestConfig() | |
| defer os.RemoveAll(filepath.Dir(cfg.TempDir)) | |
| cfg.PkgRepository = "x,y" | |
| BuildTestPackage(cfg) | |
| if _, err := Seal(cfg); err == nil { | |
| t.Fatalf("Expected invalid package repository to generate error.") | |
| } | |
| } |