src/sys/pkg/testing/host-target-testing/packages/package_builder_test.go

// Copyright 2020 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 packages

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"path"
	"path/filepath"
	"testing"

	"go.fuchsia.dev/fuchsia/src/sys/pkg/bin/pm/build"
	"go.fuchsia.dev/fuchsia/src/sys/pkg/bin/pm/repo"
)

// createTestPackage fills the given directory with a new repository.
func createTestPackage(dir string) (*Repository, string, error) {
	ctx := context.Background()

	// Initialize a repo.
	fmt.Printf("Creating repo at %s.\n", dir)
	pmRepo, err := repo.New(dir)
	if err != nil {
		return nil, "", fmt.Errorf("failed to create repo. %w", err)
	}
	if err = pmRepo.Init(); err != nil {
		return nil, "", fmt.Errorf("failed to init repo. %w", err)
	}

	// Create a config.
	config := build.TestConfig()
	log.Printf("Creating meta.far in %s", config.OutputDir)
	build.BuildTestPackage(config)
	defer os.RemoveAll(filepath.Dir(config.OutputDir))

	// Grab the merkle of the config's package manifest.
	manifestDir := filepath.Join(config.OutputDir, "package_manifest.json")
	manifest, err := ioutil.ReadFile(manifestDir)
	var packageManifest build.PackageManifest
	if err := json.Unmarshal(manifest, &packageManifest); err != nil {
		return nil, "", fmt.Errorf("could not decode package_manifest.json. %w", err)
	}
	metaMerkle := ""
	for _, blob := range packageManifest.Blobs {
		if blob.Path == "meta/" {
			metaMerkle = blob.Merkle.String()
		}
	}
	if metaMerkle == "" {
		return nil, "", fmt.Errorf("did not find meta.far in manifest")
	}

	// Publish the config to the repo.
	_, err = pmRepo.PublishManifest(manifestDir)
	if err != nil {
		return nil, "", fmt.Errorf("failed to publish manifest. %w", err)
	}
	if err = pmRepo.CommitUpdates(true); err != nil {
		return nil, "", fmt.Errorf("failed to commit updates to repo. %w", err)
	}
	pkgRepo, err := NewRepository(ctx, dir)
	if err != nil {
		return nil, "", fmt.Errorf("failed to read repo. %w", err)
	}

	return pkgRepo, metaMerkle, nil
}

// expandPackage expands the given merkle from the given repository into the given directory.
func expandPackage(pkgRepo *Repository, merkle string, dir string) error {
	// Parse the package we want.
	pkg, err := newPackage(pkgRepo, merkle)
	if err != nil {
		return fmt.Errorf("failed to read package. %w", err)
	}

	// Expand to the given directory.
	if err = pkg.Expand(dir); err != nil {
		return fmt.Errorf("failed to expand to dir. %w", err)
	}
	return nil
}

// createAndExpandPackage creates temporary directories and expands a test package, returning the expand directory.
func createAndExpandPackage(parentDir string) (*Repository, string, error) {
	dir, err := ioutil.TempDir(parentDir, "package")
	if err != nil {
		return nil, "", fmt.Errorf("Failed to create directory %s. %w", dir, err)
	}
	pkgRepo, metaMerkle, err := createTestPackage(dir)
	if err != nil {
		return nil, "", fmt.Errorf("Failed to create test package. %w", err)
	}
	dir, err = ioutil.TempDir(parentDir, "expand")
	if err != nil {
		return nil, "", fmt.Errorf("Failed to create directory %s. %w", dir, err)
	}
	err = expandPackage(pkgRepo, metaMerkle, dir)
	if err != nil {
		return nil, "", fmt.Errorf("Failed to expand package to directory %s. %w", dir, err)
	}
	return pkgRepo, dir, nil
}

func TestAddResource(t *testing.T) {
	parentDir := filepath.Join("", "omaha-pkg-test-add-resource")
	if err := os.MkdirAll(parentDir, 0755); err != nil {
		t.Fatalf("Failed to create directory %s, %s", parentDir, err)
	}
	defer os.RemoveAll(parentDir)

	_, expandDir, err := createAndExpandPackage(parentDir)
	if err != nil {
		t.Fatalf("Failed to create and expand package. %s", err)
	}

	pkgBuilder, err := NewPackageBuilderFromDir(expandDir, "testpackage", "0")
	if err != nil {
		t.Fatalf("Failed to parse package from %s. %s", expandDir, err)
	}
	defer pkgBuilder.Close()

	newResource := "blah/z"

	// Confirm the new resource doesn't exist yet.
	if _, ok := pkgBuilder.Contents[newResource]; ok {
		t.Fatalf("Test resource %s should not exist yet in the package.", newResource)
	}

	pkgBuilder.AddResource(newResource, bytes.NewReader([]byte(newResource)))

	// Confirm the file and contents were added.
	path, ok := pkgBuilder.Contents[newResource]
	if !ok {
		t.Fatalf("Test resource %s failed to be added.", newResource)
	}
	newData, err := ioutil.ReadFile(path)
	if err != nil {
		t.Fatalf("Failed to read contents of %s. %s", newResource, err)
	}
	if string(newData) != newResource {
		t.Fatalf("%s expects to have %s, but has %s", newResource, newResource, string(newData))
	}

	expectedFiles := map[string]struct{}{
		"meta/contents": {},
		"meta/foo/one":  {},
		"meta/package":  {},
		"blah/z":        {},
	}
	for _, item := range build.TestFiles {
		expectedFiles[item] = struct{}{}
	}

	for key := range pkgBuilder.Contents {
		if _, ok := expectedFiles[key]; !ok {
			t.Fatalf("File %s is not expected.", key)
		}
	}

	if len(expectedFiles) != len(pkgBuilder.Contents) {
		t.Fatalf("Package contents has %d files, should have %d", len(pkgBuilder.Contents), len(expectedFiles))
	}

	if err := pkgBuilder.AddResource(newResource, bytes.NewReader([]byte(newResource))); err == nil {
		t.Fatalf("Resource %s should have failed to be added twice.", newResource)
	}
}

func TestPublish(t *testing.T) {
	ctx := context.Background()

	parentDir := filepath.Join("", "omaha-pkg-test-publish")
	if err := os.MkdirAll(parentDir, 0755); err != nil {
		t.Fatalf("Failed to create directory %s, %s", parentDir, err)
	}
	defer os.RemoveAll(parentDir)

	pkgRepo, expandDir, err := createAndExpandPackage(parentDir)
	if err != nil {
		t.Fatalf("Failed to create and expand package. %s", err)
	}

	pkgBuilder, err := NewPackageBuilderFromDir(expandDir, "testpackage", "0")
	if err != nil {
		t.Fatalf("Failed to parse package from %s. %s", expandDir, err)
	}
	defer pkgBuilder.Close()

	fullPkgName := fmt.Sprintf("%s/%s", pkgBuilder.Name, pkgBuilder.Version)
	newResource := "blah/z"

	// Confirm package in repo is as expected.
	pkg, err := pkgRepo.OpenPackage(fullPkgName)
	if err != nil {
		t.Fatalf("Repo does not contain '%s'. %s", fullPkgName, err)
	}
	if _, err := pkg.ReadFile(newResource); err == nil {
		t.Fatalf("%s should not be found in package", newResource)
	}

	// Add resource to package.
	pkgBuilder.AddResource(newResource, bytes.NewReader([]byte(newResource)))

	// Update repo with updated package. We don't check the merkle since the package includes randomly generated files.
	actualPkgName, _, err := pkgBuilder.Publish(ctx, pkgRepo)
	if err != nil {
		t.Fatalf("Publishing package failed. %s", err)
	}

	if actualPkgName != fullPkgName {
		t.Fatalf("package path should be %q, not %q", fullPkgName, actualPkgName)
	}

	pkgRepo, err = NewRepository(ctx, path.Dir(pkgRepo.Dir))

	// Confirm that the package is published and updated.
	pkg, err = pkgRepo.OpenPackage(fullPkgName)
	if err != nil {
		t.Fatalf("Repo does not contain '%s'. %s", fullPkgName, err)
	}
	if data, err := pkg.ReadFile(newResource); err != nil {
		t.Fatalf("%s should be in package.", newResource)
	} else {
		if string(data) != newResource {
			t.Fatalf("%s should have value %s but is %s", newResource, newResource, data)
		}
	}
}