440 lines
14 KiB
Go
440 lines
14 KiB
Go
package comparison
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestPlanDestination(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
absent := filepath.Join(workingDirectory, "absent")
|
|
plan, err := PlanDestination(workingDirectory, absent, false)
|
|
if err != nil {
|
|
t.Fatalf("PlanDestination() error = %v", err)
|
|
}
|
|
if plan.Target != absent || plan.Exists {
|
|
t.Fatalf("PlanDestination() = %#v, want absent target", plan)
|
|
}
|
|
nested := filepath.Join(workingDirectory, "missing-parent", "comparison")
|
|
if _, err := PlanDestination(workingDirectory, nested, false); err != nil {
|
|
t.Fatalf("PlanDestination(nested) error = %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Dir(nested)); !errors.Is(err, os.ErrNotExist) {
|
|
t.Fatalf("read-only plan created parent: stat error = %v", err)
|
|
}
|
|
|
|
empty := filepath.Join(workingDirectory, "empty")
|
|
if err := os.Mkdir(empty, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
plan, err = PlanDestination(workingDirectory, empty, false)
|
|
if err != nil || !plan.Exists {
|
|
t.Fatalf("PlanDestination(empty) = %#v, %v", plan, err)
|
|
}
|
|
|
|
file := filepath.Join(workingDirectory, "file")
|
|
if err := os.WriteFile(file, []byte("not a directory"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertDestinationErrorKind(t, workingDirectory, file, false, DestinationNotDirectory)
|
|
assertDestinationErrorKind(t, workingDirectory, workingDirectory, false, DestinationWorkingDirectory)
|
|
assertDestinationErrorKind(t, workingDirectory, string(os.PathSeparator), false, DestinationFilesystemRoot)
|
|
assertDestinationErrorKind(t, workingDirectory, "relative", false, DestinationInvalidPath)
|
|
|
|
link := filepath.Join(workingDirectory, "link")
|
|
if err := os.Symlink(empty, link); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertDestinationErrorKind(t, workingDirectory, link, false, DestinationSymlink)
|
|
|
|
dangling := filepath.Join(workingDirectory, "dangling")
|
|
if err := os.Symlink(filepath.Join(workingDirectory, "missing"), dangling); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertDestinationErrorKind(t, workingDirectory, dangling, false, DestinationSymlink)
|
|
assertDestinationErrorKind(t, workingDirectory, filepath.Join(dangling, "child"), false, DestinationInspection)
|
|
|
|
nonempty := filepath.Join(workingDirectory, "nonempty")
|
|
if err := os.Mkdir(nonempty, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(nonempty, "extra"), []byte("x"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertDestinationErrorKind(t, workingDirectory, nonempty, false, DestinationNotEmpty)
|
|
assertDestinationErrorKind(t, workingDirectory, nonempty, true, DestinationUnrecognized)
|
|
}
|
|
|
|
func TestPlanDestinationRejectsUnreadableDirectory(t *testing.T) {
|
|
if os.Geteuid() == 0 {
|
|
t.Skip("root can inspect directories regardless of mode")
|
|
}
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "unreadable")
|
|
if err := os.Mkdir(target, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Chmod(target, 0); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = os.Chmod(target, 0o700) })
|
|
assertDestinationErrorKind(t, workingDirectory, target, false, DestinationInspection)
|
|
}
|
|
|
|
func TestRecognizeBundleRejectsUnsafeAndMalformedContents(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
mutate func(t *testing.T, directory string)
|
|
}{
|
|
{name: "extra file", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
if err := os.WriteFile(filepath.Join(directory, "extra.txt"), []byte("extra"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "subdirectory", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
if err := os.Mkdir(filepath.Join(directory, "nested"), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "missing report", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
if err := os.Remove(filepath.Join(directory, "01-weather-light.md")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "symlink report", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
path := filepath.Join(directory, "01-weather-light.md")
|
|
if err := os.Remove(path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(filepath.Join(directory, DataPackageFilename), path); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "digest mismatch", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
if err := os.WriteFile(filepath.Join(directory, DataPackageFilename), []byte("altered"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "unknown manifest field", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
path := filepath.Join(directory, ManifestFilename)
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
data = append(data[:len(data)-2], []byte(",\n \"unknown\": true\n}\n")...)
|
|
if err := os.WriteFile(path, data, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
{name: "traversal report path", mutate: func(t *testing.T, directory string) {
|
|
t.Helper()
|
|
path := filepath.Join(directory, ManifestFilename)
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var manifest Manifest
|
|
if err := json.Unmarshal(data, &manifest); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
manifest.Results[0].ReportPath = "../outside.md"
|
|
data, err = json.Marshal(manifest)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(path, data, 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
directory := publishTestBundle(t, testBundle())
|
|
test.mutate(t, directory)
|
|
if _, err := RecognizeBundle(directory); !errors.Is(err, ErrUnrecognizedBundle) {
|
|
t.Fatalf("RecognizeBundle() error = %v, want ErrUnrecognizedBundle", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPlanDestinationAcceptsRecognizedReplacement(t *testing.T) {
|
|
directory := publishTestBundle(t, testBundle())
|
|
plan, err := PlanDestination(filepath.Dir(directory), directory, true)
|
|
if err != nil {
|
|
t.Fatalf("PlanDestination() error = %v", err)
|
|
}
|
|
if !plan.Exists {
|
|
t.Fatal("PlanDestination() did not record recognized existing destination")
|
|
}
|
|
}
|
|
|
|
func TestPublishWritesAndReplacesBundle(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
plan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), plan, testBundle()); err != nil {
|
|
t.Fatalf("Publish() error = %v", err)
|
|
}
|
|
if _, err := RecognizeBundle(target); err != nil {
|
|
t.Fatalf("RecognizeBundle() error = %v", err)
|
|
}
|
|
assertMode(t, target, 0o700)
|
|
for _, name := range []string{ManifestFilename, DataPackageFilename, "01-weather-light.md"} {
|
|
assertMode(t, filepath.Join(target, name), 0o600)
|
|
}
|
|
|
|
next := testBundle()
|
|
next.Manifest.Results[0].ProfileID = "weather-balanced"
|
|
next.Manifest.Results[0].ReportPath = "01-weather-balanced.md"
|
|
next.Reports[0].Path = "01-weather-balanced.md"
|
|
next.Reports[0].Markdown = []byte("# Replacement\n")
|
|
plan, err = PlanDestination(workingDirectory, target, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), plan, next); err != nil {
|
|
t.Fatalf("Publish(replace) error = %v", err)
|
|
}
|
|
if _, err := os.Stat(filepath.Join(target, "01-weather-light.md")); !errors.Is(err, os.ErrNotExist) {
|
|
t.Fatalf("stale report stat error = %v, want not exist", err)
|
|
}
|
|
if data, err := os.ReadFile(filepath.Join(target, "01-weather-balanced.md")); err != nil || string(data) != "# Replacement\n" {
|
|
t.Fatalf("replacement report = %q, %v", data, err)
|
|
}
|
|
}
|
|
|
|
func TestPublishReplacesEmptyDirectory(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
if err := os.Mkdir(target, 0o755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
plan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), plan, testBundle()); err != nil {
|
|
t.Fatalf("Publish() error = %v", err)
|
|
}
|
|
if _, err := RecognizeBundle(target); err != nil {
|
|
t.Fatalf("RecognizeBundle() error = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestPublishRestoresExistingBundleAfterReplacementFailure(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
initial := testBundle()
|
|
initialPlan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), initialPlan, initial); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := directorySnapshot(t, target)
|
|
|
|
next := testBundle()
|
|
next.Reports[0].Markdown = []byte("# New\n")
|
|
plan, err := PlanDestination(workingDirectory, target, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
calls := 0
|
|
err = publish(context.Background(), plan, next, publishOperations{rename: func(oldPath, newPath string) error {
|
|
calls++
|
|
if calls == 2 {
|
|
return errors.New("replace failed")
|
|
}
|
|
return os.Rename(oldPath, newPath)
|
|
}})
|
|
if err == nil {
|
|
t.Fatal("publish() succeeded despite replacement failure")
|
|
}
|
|
after := directorySnapshot(t, target)
|
|
if !equalSnapshots(before, after) {
|
|
t.Fatal("failed publication changed the prior bundle")
|
|
}
|
|
entries, err := os.ReadDir(workingDirectory)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(entries) != 1 || entries[0].Name() != filepath.Base(target) {
|
|
t.Fatalf("failed publication left sibling artifacts: %#v", entries)
|
|
}
|
|
}
|
|
|
|
func TestPublishRetainsBackupWhenRestorationFails(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
initialPlan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), initialPlan, testBundle()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
plan, err := PlanDestination(workingDirectory, target, true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var backupPath string
|
|
calls := 0
|
|
err = publish(context.Background(), plan, testBundle(), publishOperations{rename: func(oldPath, newPath string) error {
|
|
calls++
|
|
if calls == 1 {
|
|
backupPath = newPath
|
|
}
|
|
if calls == 2 || calls == 3 {
|
|
return errors.New("rename failed")
|
|
}
|
|
return os.Rename(oldPath, newPath)
|
|
}})
|
|
if err == nil || !strings.Contains(err.Error(), backupPath) {
|
|
t.Fatalf("publish() error = %v, want retained backup path %q", err, backupPath)
|
|
}
|
|
if info, statErr := os.Stat(backupPath); statErr != nil || !info.IsDir() {
|
|
t.Fatalf("backup stat = %v, %v, want retained directory", info, statErr)
|
|
}
|
|
}
|
|
|
|
func TestPublishCancellationBeforeCommitLeavesNoDestination(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
plan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
if err := publish(ctx, plan, testBundle(), publishOperations{rename: os.Rename, beforeCommit: cancel}); !errors.Is(err, context.Canceled) {
|
|
t.Fatalf("Publish() error = %v, want context cancellation", err)
|
|
}
|
|
if _, err := os.Lstat(target); !errors.Is(err, os.ErrNotExist) {
|
|
t.Fatalf("destination stat error = %v, want not exist", err)
|
|
}
|
|
}
|
|
|
|
func assertDestinationErrorKind(t *testing.T, workingDirectory, target string, replace bool, want DestinationErrorKind) {
|
|
t.Helper()
|
|
_, err := PlanDestination(workingDirectory, target, replace)
|
|
var destinationError *DestinationError
|
|
if !errors.As(err, &destinationError) || destinationError.Kind != want {
|
|
t.Fatalf("PlanDestination(%q) error = %v, want destination error %q", target, err, want)
|
|
}
|
|
}
|
|
|
|
func publishTestBundle(t *testing.T, bundle LogicalBundle) string {
|
|
t.Helper()
|
|
workingDirectory := t.TempDir()
|
|
target := filepath.Join(workingDirectory, "comparison-daily")
|
|
plan, err := PlanDestination(workingDirectory, target, false)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := Publish(context.Background(), plan, bundle); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return target
|
|
}
|
|
|
|
func testBundle() LogicalBundle {
|
|
dataPackage := []byte("report: daily\n")
|
|
manifest := validManifest()
|
|
manifest.DataPackage.SHA256 = SHA256(dataPackage)
|
|
return LogicalBundle{
|
|
Manifest: manifest,
|
|
DataPackage: dataPackage,
|
|
Reports: []BundleReport{{
|
|
Position: 1,
|
|
Path: "01-weather-light.md",
|
|
Markdown: []byte("# Daily\n"),
|
|
}},
|
|
}
|
|
}
|
|
|
|
func assertMode(t *testing.T, path string, want os.FileMode) {
|
|
t.Helper()
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got := info.Mode().Perm(); got != want {
|
|
t.Fatalf("mode for %q = %#o, want %#o", path, got, want)
|
|
}
|
|
}
|
|
|
|
func directorySnapshot(t *testing.T, directory string) map[string]string {
|
|
t.Helper()
|
|
entries, err := os.ReadDir(directory)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot := make(map[string]string, len(entries))
|
|
for _, entry := range entries {
|
|
data, err := os.ReadFile(filepath.Join(directory, entry.Name()))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
snapshot[entry.Name()] = string(data)
|
|
}
|
|
return snapshot
|
|
}
|
|
|
|
func equalSnapshots(left, right map[string]string) bool {
|
|
if len(left) != len(right) {
|
|
return false
|
|
}
|
|
for name, value := range left {
|
|
if right[name] != value {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func TestRecognizeBundleRejectsTrailingJSONValue(t *testing.T) {
|
|
directory := publishTestBundle(t, testBundle())
|
|
path := filepath.Join(directory, ManifestFilename)
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(path, append(data, []byte("{}")...), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := RecognizeBundle(directory); !errors.Is(err, ErrUnrecognizedBundle) {
|
|
t.Fatalf("RecognizeBundle() error = %v, want ErrUnrecognizedBundle", err)
|
|
}
|
|
}
|
|
|
|
func TestPlanDestinationRejectsWhitespaceTarget(t *testing.T) {
|
|
workingDirectory := t.TempDir()
|
|
assertDestinationErrorKind(t, workingDirectory, " \t", false, DestinationInvalidPath)
|
|
}
|
|
|
|
func TestRecognizeBundleDoesNotAcceptNonRegularManifest(t *testing.T) {
|
|
directory := t.TempDir()
|
|
if err := os.Mkdir(filepath.Join(directory, ManifestFilename), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := RecognizeBundle(directory); !strings.Contains(err.Error(), "regular file") {
|
|
t.Fatalf("RecognizeBundle() error = %v, want regular file rejection", err)
|
|
}
|
|
}
|