government / src / cmd / government / run_test.go

@ 57ff1329428c2a48f4d12c02516f552806a79d7e | history


package main

import (
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func compileTo(t *testing.T, dir, name, src string, extra ...string) string {
	t.Helper()
	lisp := filepath.Join(dir, name+".gov.lisp")
	gov := filepath.Join(dir, name+".gov")
	os.WriteFile(lisp, []byte(src), 0o644)
	args := append([]string{"compile", lisp, "-o", gov}, extra...)
	if code, _, stderr := runCmd(args...); code != exitOK {
		t.Fatalf("compile: exit %d: %s", code, stderr)
	}
	return gov
}

func TestRun(t *testing.T) {
	gov := compileTo(t, t.TempDir(), "sq", sqSource)
	code, stdout, stderr := runCmd("run", gov)
	if code != exitOK || stdout != "144\n" {
		t.Errorf("exit %d, stdout %q, stderr %q", code, stdout, stderr)
	}
}

func TestRunRuntimeError(t *testing.T) {
	gov := compileTo(t, t.TempDir(), "bad", "1\n(car '())\n2\n")
	code, stdout, stderr := runCmd("run", gov)
	if code != exitRuntime || stdout != "1\n" || !strings.Contains(stderr, "E-TYPE: car needs a pair, got () at GOV.0.2.1 (depth 1)") {
		t.Errorf("exit %d, stdout %q, stderr %q", code, stdout, stderr)
	}
}

func TestRunRefusals(t *testing.T) {
	dir := t.TempDir()
	gov := compileTo(t, dir, "p", "(+ 1 2)")
	data, _ := os.ReadFile(gov)
	tampered := filepath.Join(dir, "tampered.gov")
	i := strings.LastIndex(string(data), "-----END")
	broken := []byte(string(data))
	broken[i-5] ^= 1 // a base64 character near the end: inside the signature
	os.WriteFile(tampered, broken, 0o644)

	tests := []struct {
		args []string
		want string
	}{
		{[]string{"run", gov, "--at", "1999-01-01T00:00:00Z"}, "E-NOT-IN-FORCE"},
		{[]string{"run", gov, "--max-nodes", "2"}, "E-TOO-LARGE"},
		{[]string{"run", gov, "--at", "yesterday"}, "RFC 3339"},
		{[]string{"run", tampered}, "E-"},
		{[]string{"run", filepath.Join(dir, "missing.gov")}, "no such file"},
		{[]string{"run"}, "usage"},
	}
	for _, tt := range tests {
		code, _, stderr := runCmd(tt.args...)
		if code != exitInvalid || !strings.Contains(stderr, tt.want) {
			t.Errorf("%v: exit %d, stderr %q; want exit %d mentioning %q", tt.args, code, stderr, exitInvalid, tt.want)
		}
	}
}

func TestRunWithAnchor(t *testing.T) {
	dir := t.TempDir()
	mine := compileTo(t, dir, "mine", "(+ 1 2)")
	other := compileTo(t, dir, "other", "(* 2 3)")
	if code, stdout, stderr := runCmd("run", "--anchor", mine, other); code != exitOK || stdout != "6\n" {
		// Same default seed, so the same author: the pin matches.
		t.Errorf("same author: exit %d, %q, %q", code, stdout, stderr)
	}
}

// TestRunIsTheDefault checks "government prog.gov", the run command
// without its name, and that command names and typos still mean commands.
func TestRunIsTheDefault(t *testing.T) {
	dir := t.TempDir()
	gov := compileTo(t, dir, "p", "(+ 1 2)")
	if code, stdout, stderr := runCmd(gov); code != exitOK || stdout != "3\n" {
		t.Errorf("government p.gov: exit %d, %q, %s", code, stdout, stderr)
	}
	if code, stdout, stderr := runCmd("--at", "2027-06-01T00:00:00Z", gov, "--max-nodes", "100"); code != exitOK || stdout != "3\n" {
		t.Errorf("with flags on both sides: exit %d, %q, %s", code, stdout, stderr)
	}
	if code, _, stderr := runCmd(gov, "--at", "1999-01-01T00:00:00Z"); code != exitInvalid || !strings.Contains(stderr, "E-NOT-IN-FORCE") {
		t.Errorf("refused program: exit %d, %s", code, stderr)
	}

	// A file with no .gov extension still runs if it exists.
	bare := filepath.Join(dir, "law")
	data, _ := os.ReadFile(gov)
	os.WriteFile(bare, data, 0o644)
	if code, stdout, stderr := runCmd(bare); code != exitOK || stdout != "3\n" {
		t.Errorf("file without .gov: exit %d, %q, %s", code, stdout, stderr)
	}

	tests := []struct {
		args []string
		want string
	}{
		{[]string{"compiel", "x.gov.lisp"}, "did you mean compile?"},
		{[]string{"frobnicate"}, "unknown command \"frobnicate\""},
		{[]string{filepath.Join(dir, "missing.gov")}, "no such file"},
		{[]string{gov, gov}, "want one file, got 2"},
	}
	for _, tt := range tests {
		code, _, stderr := runCmd(tt.args...)
		if code != exitInvalid || !strings.Contains(stderr, tt.want) {
			t.Errorf("%v: exit %d, %q; want %q", tt.args, code, stderr, tt.want)
		}
	}
}