goscript 0.0.84 → 0.1.1

package/compiler/gotest/runner_test.go

@@ -0,0 +1,627 @@
+package gotest
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestRunnerRunsOrdinaryPackageTest(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/gotest\n\ngo 1.25.3\n",
+		"value.go": strings.Join([]string{
+			"package gotest",
+			"",
+			"func Add(a int, b int) int {",
+			"\treturn a + b",
+			"}",
+			"",
+		}, "\n"),
+		"value_test.go": strings.Join([]string{
+			"package gotest",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestAdd(t *testing.T) {",
+			"\tif Add(1, 2) != 3 {",
+			"\t\tt.Fatalf(\"unexpected sum\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+		Verbose:  true,
+	})
+	if err != nil {
+		t.Fatalf("run package test: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected package test to pass: %#v", result.Packages)
+	}
+	if len(result.Packages) != 1 || len(result.Packages[0].Tests) != 1 {
+		t.Fatalf("unexpected package results: %#v", result.Packages)
+	}
+	if result.Packages[0].Tests[0].Name != "TestAdd" {
+		t.Fatalf("unexpected test discovery: %#v", result.Packages[0].Tests)
+	}
+	if result.Packages[0].Phases.Workspace != PhaseStatusPass ||
+		result.Packages[0].Phases.Compile != PhaseStatusPass ||
+		result.Packages[0].Phases.Emit != PhaseStatusPass ||
+		result.Packages[0].Phases.TypeCheck != PhaseStatusPass ||
+		result.Packages[0].Phases.Runtime != PhaseStatusPass {
+		t.Fatalf("unexpected phase status: %#v", result.Packages[0].Phases)
+	}
+}
+
+func TestRunnerReportsShortMode(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/short\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package short",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestShort(t *testing.T) {",
+			"\tif !testing.Short() {",
+			"\t\tt.Fatalf(\"expected short mode\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Short:    true,
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run short package: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected short package to pass: %#v", result.Packages)
+	}
+}
+
+func TestRunnerRunsAsyncSubtest(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/asyncsubtest\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package asyncsubtest",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestAsyncSubtest(t *testing.T) {",
+			"\tt.Run(\"child\", func(t *testing.T) {",
+			"\t\tch := make(chan string, 1)",
+			"\t\tch <- \"ok\"",
+			"\t\tif <-ch != \"ok\" {",
+			"\t\t\tt.Fatalf(\"unexpected channel value\")",
+			"\t\t}",
+			"\t})",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run async subtest package: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected async subtest to pass: %#v", result.Packages)
+	}
+}
+
+func TestRunnerAwaitsAsyncDependencyCallsInTests(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/asyncdep\n\ngo 1.25.3\n",
+		"value_test.go": strings.Join([]string{
+			"package asyncdep",
+			"",
+			"import (",
+			"\t\"math/rand\"",
+			"\t\"testing\"",
+			")",
+			"",
+			"func TestAsyncDependencyCall(t *testing.T) {",
+			"\tr := rand.New(rand.NewSource(1))",
+			"\t_ = uint8(r.Intn(256))",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run async dependency package: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected async dependency package to pass: %#v", result.Packages)
+	}
+}
+
+func TestRunnerRunsExternalPackageTest(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/external\n\ngo 1.25.3\n",
+		"value.go": strings.Join([]string{
+			"package external",
+			"",
+			"func Add(a int, b int) int {",
+			"\treturn a + b",
+			"}",
+			"",
+		}, "\n"),
+		"value_test.go": strings.Join([]string{
+			"package external_test",
+			"",
+			"import (",
+			"\t\"testing\"",
+			"",
+			"\texternal \"example.test/external\"",
+			")",
+			"",
+			"func TestExternalAdd(t *testing.T) {",
+			"\tif external.Add(4, 5) != 9 {",
+			"\t\tt.Fatalf(\"unexpected sum\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run external package test: %v", err)
+	}
+	if !result.Passed() {
+		t.Fatalf("expected external package test to pass: %#v", result.Packages)
+	}
+	if len(result.Packages) != 1 || len(result.Packages[0].Tests) != 1 {
+		t.Fatalf("unexpected package results: %#v", result.Packages)
+	}
+	if result.Packages[0].TestPackagePath == "" {
+		t.Fatalf("expected test package path: %#v", result.Packages[0])
+	}
+}
+
+func TestRunnerRejectsInvalidRunPattern(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod":   "module example.test/badrun\n\ngo 1.25.3\n",
+		"value.go": "package badrun\n",
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"."},
+		Run:      "[",
+	})
+	if err != nil {
+		t.Fatalf("run package test: %v", err)
+	}
+	if result.Passed() {
+		t.Fatalf("expected invalid run pattern to fail")
+	}
+	if result.Packages[0].Owner != OwnerPackageGraph {
+		t.Fatalf("unexpected owner classification: %#v", result.Packages[0])
+	}
+	if len(result.Diagnostics) != 1 || result.Diagnostics[0].Code != "goscript/gotest:run-pattern" {
+		t.Fatalf("expected structured run-pattern diagnostic: %#v", result.Diagnostics)
+	}
+}
+
+func TestRunnerFailsPackagePatternsWhenGraphHasOnlyDiagnostics(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod":   "module example.test/missing\n\ngo 1.25.3\n",
+		"value.go": "package missing\n",
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./does-not-exist"},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run missing package test: %v", err)
+	}
+	if result.Passed() {
+		t.Fatalf("expected missing package pattern to fail")
+	}
+	if len(result.Packages) != 1 || result.Packages[0].Owner != OwnerPackageGraph {
+		t.Fatalf("unexpected package graph failure: %#v", result.Packages)
+	}
+}
+
+func TestMarkAllFailuresPreservesExistingPackageOwners(t *testing.T) {
+	result := &Result{Packages: []PackageResult{
+		{
+			PackagePath: "example.test/broken",
+			Action:      ActionFail,
+			Owner:       OwnerPackageGraph,
+			Error:       "load failed",
+		},
+		{
+			PackagePath: "example.test/run",
+			Action:      ActionFail,
+		},
+		{
+			PackagePath: "example.test/notests",
+			Action:      ActionSkip,
+		},
+	}}
+
+	markAllFailures(result, OwnerTestRunner, "typecheck failed")
+
+	if result.Packages[0].Owner != OwnerPackageGraph || result.Packages[0].Error != "load failed" {
+		t.Fatalf("package graph failure was overwritten: %#v", result.Packages[0])
+	}
+	if result.Packages[1].Owner != OwnerTestRunner || result.Packages[1].Error != "typecheck failed" {
+		t.Fatalf("unowned failure was not marked: %#v", result.Packages[1])
+	}
+	if result.Packages[2].Action != ActionSkip || result.Packages[2].Owner != "" {
+		t.Fatalf("skipped package should stay skipped: %#v", result.Packages[2])
+	}
+}
+
+func TestRunnerScopesPackageLoadErrors(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/mixed\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int { return 11 }",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\tif Value() != 11 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"broken/value.go": "package broken\nfunc Value() int { return 12 }\n",
+		"broken/value_test.go": strings.Join([]string{
+			"package broken",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBroken(t *testing.T) {",
+			"\tMissing()",
+			"}",
+			"",
+		}, "\n"),
+		"notests/value.go": "package notests\nfunc Value() int { return 13 }\n",
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./..."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run mixed package tests: %v", err)
+	}
+
+	clean := requirePackageResult(t, result, "example.test/mixed/clean")
+	if clean.Action != ActionPass {
+		t.Fatalf("clean package should pass independently: %#v", clean)
+	}
+	broken := requirePackageResult(t, result, "example.test/mixed/broken")
+	if broken.Action != ActionFail || broken.Owner != OwnerPackageGraph {
+		t.Fatalf("broken package should carry package graph failure: %#v", broken)
+	}
+	if broken.Phases.Compile != PhaseStatusFail {
+		t.Fatalf("broken package should carry compile phase failure: %#v", broken)
+	}
+	if !strings.Contains(broken.Error, "Missing") {
+		t.Fatalf("broken package error should preserve load diagnostic: %#v", broken)
+	}
+	noTests := requirePackageResult(t, result, "example.test/mixed/notests")
+	if noTests.Action != ActionSkip {
+		t.Fatalf("no-test package should stay skipped: %#v", noTests)
+	}
+}
+
+func TestRunnerScopesPackageCompileErrors(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/mixedcompile\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int { return 11 }",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\tif Value() != 11 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"broken/value.go": strings.Join([]string{
+			"package broken",
+			"",
+			"func Value() int {",
+			"\tx := 1",
+			"\t_ = &(x)",
+			"\treturn x",
+			"}",
+			"",
+		}, "\n"),
+		"broken/value_test.go": strings.Join([]string{
+			"package broken",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBroken(t *testing.T) {",
+			"\tif Value() == 0 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./..."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run mixed compile test: %v", err)
+	}
+
+	clean := requirePackageResult(t, result, "example.test/mixedcompile/clean")
+	if clean.Action != ActionPass {
+		t.Fatalf("clean package should pass independently: %#v", clean)
+	}
+	broken := requirePackageResult(t, result, "example.test/mixedcompile/broken")
+	if broken.Action != ActionFail || broken.Owner != OwnerLowering {
+		t.Fatalf("broken package should carry lowering failure: %#v", broken)
+	}
+	if !strings.Contains(broken.Error, "unsupported address expression") {
+		t.Fatalf("broken package error should preserve compile diagnostic: %#v", broken)
+	}
+}
+
+func TestRunnerDoesNotCompileDependencyTests(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/deptest\n\ngo 1.25.3\n",
+		"dep/value.go": strings.Join([]string{
+			"package dep",
+			"",
+			"func Value() int { return 11 }",
+			"",
+		}, "\n"),
+		"dep/value_test.go": strings.Join([]string{
+			"package dep",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestDependencyOnly(t *testing.T) {",
+			"Loop:",
+			"\tfor {",
+			"\t\tbreak Loop",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"app/value.go": strings.Join([]string{
+			"package app",
+			"",
+			"import \"example.test/deptest/dep\"",
+			"",
+			"func Value() int { return dep.Value() }",
+			"",
+		}, "\n"),
+		"app/value_test.go": strings.Join([]string{
+			"package app",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\tif Value() != 11 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./app"},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run dependency test isolation fixture: %v", err)
+	}
+
+	app := requirePackageResult(t, result, "example.test/deptest/app")
+	if app.Action != ActionPass {
+		t.Fatalf("package under test should ignore dependency-only tests: %#v", app)
+	}
+}
+
+func TestRunnerScopesPackageTypecheckErrors(t *testing.T) {
+	moduleDir := writeFixture(t, map[string]string{
+		"go.mod": "module example.test/mixedtypecheck\n\ngo 1.25.3\n",
+		"clean/value.go": strings.Join([]string{
+			"package clean",
+			"",
+			"func Value() int { return 11 }",
+			"",
+		}, "\n"),
+		"clean/value_test.go": strings.Join([]string{
+			"package clean",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestValue(t *testing.T) {",
+			"\tif Value() != 11 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+		"bad/value.go": strings.Join([]string{
+			"package bad",
+			"",
+			"func Value() int { return 12 }",
+			"",
+		}, "\n"),
+		"bad/value_test.go": strings.Join([]string{
+			"package bad",
+			"",
+			"import \"testing\"",
+			"",
+			"func TestBad(t *testing.T) {",
+			"\tif Value() != 12 {",
+			"\t\tt.Fatal(\"bad value\")",
+			"\t}",
+			"}",
+			"",
+		}, "\n"),
+	})
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "tsgo"), strings.Join([]string{
+		"#!/bin/sh",
+		"project=",
+		"while [ \"$#\" -gt 0 ]; do",
+		"\tif [ \"$1\" = \"--project\" ]; then",
+		"\t\tshift",
+		"\t\tproject=\"$1\"",
+		"\tfi",
+		"\tshift || break",
+		"done",
+		"runner=$(sed -n 's/.*\"\\(runner-[0-9][0-9]*\\.ts\\)\".*/\\1/p' \"$project\" | head -n 1)",
+		"if grep -q 'example.test/mixedtypecheck/bad' \"$runner\"; then",
+		"\techo 'TypeScript TS9000: bad package'",
+		"\texit 1",
+		"fi",
+		"exit 0",
+		"",
+	}, "\n"))
+	writeExecutable(t, filepath.Join(moduleDir, "node_modules", ".bin", "bun"), strings.Join([]string{
+		"#!/bin/sh",
+		"exit 0",
+		"",
+	}, "\n"))
+
+	result, err := NewRunner().Run(context.Background(), &Request{
+		Dir:      moduleDir,
+		Patterns: []string{"./..."},
+		Timeout:  30 * time.Second,
+	})
+	if err != nil {
+		t.Fatalf("run mixed typecheck test: %v", err)
+	}
+
+	clean := requirePackageResult(t, result, "example.test/mixedtypecheck/clean")
+	if clean.Action != ActionPass {
+		t.Fatalf("clean package should pass independently: %#v", clean)
+	}
+	bad := requirePackageResult(t, result, "example.test/mixedtypecheck/bad")
+	if bad.Action != ActionFail || bad.Owner != OwnerTypeScriptEmitter {
+		t.Fatalf("bad package should carry typecheck failure: %#v", bad)
+	}
+	if !strings.Contains(bad.Error, "TS9000") {
+		t.Fatalf("bad package error should preserve typecheck output: %#v", bad)
+	}
+}
+
+func TestRenderTypeScriptProjectDisablesAmbientTypePackages(t *testing.T) {
+	req := &normalizedRequest{
+		WorkDir: "/work",
+	}
+
+	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", false)
+	if !strings.Contains(tsconfig, "\"types\": []") {
+		t.Fatalf("expected generated tsconfig to disable ambient @types packages: %s", tsconfig)
+	}
+	if !strings.Contains(tsconfig, "\"goscript-node.d.ts\"") {
+		t.Fatalf("expected generated tsconfig to include GoScript node ambient declarations: %s", tsconfig)
+	}
+}
+
+func TestRenderTypeScriptProjectUsesNodeTypesWhenAvailable(t *testing.T) {
+	req := &normalizedRequest{
+		WorkDir: "/work",
+	}
+
+	tsconfig := renderTypeScriptProject(req, "/work/output/package-0", "runner-0.ts", true)
+	if !strings.Contains(tsconfig, "\"types\": [\"node\"]") {
+		t.Fatalf("expected generated tsconfig to opt into node types: %s", tsconfig)
+	}
+}
+
+func requirePackageResult(t *testing.T, result *Result, packagePath string) PackageResult {
+	t.Helper()
+
+	if result != nil {
+		for _, pkg := range result.Packages {
+			if pkg.PackagePath == packagePath {
+				return pkg
+			}
+		}
+	}
+	t.Fatalf("missing package result %q in %#v", packagePath, result)
+	return PackageResult{}
+}
+
+func writeFixture(t *testing.T, files map[string]string) string {
+	t.Helper()
+
+	dir := t.TempDir()
+	for name, contents := range files {
+		path := filepath.Join(dir, name)
+		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+			t.Fatal(err.Error())
+		}
+		if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+			t.Fatal(err.Error())
+		}
+	}
+	return dir
+}
+
+func writeExecutable(t *testing.T, path string, contents string) {
+	t.Helper()
+
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+	if err := os.WriteFile(path, []byte(contents), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+}

package/compiler/gotest/test.go

@@ -0,0 +1,9 @@
+package gotest
+
+// Test describes one discovered Go test function.
+type Test struct {
+	// Name is the Go TestXxx function name.
+	Name string
+	// PackagePath is the package variant that exports the function.
+	PackagePath string
+}

package/compiler/index.test.ts

@@ -1,31 +1,31 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { compile } from "./index";
-import * as path from "path";
-import * as fs from "fs/promises";
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { describe, it, expect } from 'vitest'
+import { compile } from './index'
 
-const exampleDir = path.resolve(__dirname, "../example/simple");
-const outputDir = path.join(exampleDir, "output"); // Use a separate output dir for tests
-const expectedOutputFile = path.join(outputDir, "@goscript", "example", "main.gs.ts");
+describe('GoScript Compiler API', () => {
+  it('compiles a simple package through the CLI adapter', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'goscript-api-'))
+    const output = join(dir, 'output')
+    await mkdir(dir, { recursive: true })
+    await writeFile(join(dir, 'go.mod'), 'module example.test/api\n\ngo 1.25.3\n')
+    await writeFile(join(dir, 'main.go'), [
+      'package main',
+      'func main() {',
+      '  println("api")',
+      '}',
+      '',
+    ].join('\n'))
 
-describe("GoScript Compiler API", () => {
-  // Clean up before and after tests
-  beforeAll(async () => {
-    await fs.rm(outputDir, { recursive: true, force: true });
-  });
-  afterAll(async () => {
-    await fs.rm(outputDir, { recursive: true, force: true });
-  });
+    await compile({
+      pkg: '.',
+      output,
+      dir,
+    })
 
-  it("should compile the simple example package", async () => {
-    const config = {
-      pkg: ".", // Compile the package in the exampleDir
-      dir: exampleDir,
-      output: outputDir,
-    };
-
-    await expect(compile(config)).resolves.toBeUndefined();
-    // fs.access resolves to undefined/null on success - verify file exists
-    const fileExists = await fs.access(expectedOutputFile).then(() => true).catch(() => false);
-    expect(fileExists).toBe(true);
-  }, 30000); // 30 second timeout for compilation
-});
+    const generated = await readFile(join(output, '@goscript', 'example.test', 'api', 'main.gs.ts'), 'utf8')
+    expect(generated).toContain('export async function main(): globalThis.Promise<void>')
+    expect(generated).toContain('$.println("api")')
+  }, 30000)
+})