init:

dsl/parser_test.go

@@ -0,0 +1,217 @@
+package dsl
+
+import (
+	"testing"
+	"time"
+)
+
+func TestParseBasic(t *testing.T) {
+	src := `
+build "go build -o solution ."
+timeout 10s
+
+group("basic") {
+    weight = 0.4
+
+    test("stdin stdout") {
+        stdin = "5\n1 3 2 5 4\n"
+        stdout = "1 2 3 4 5\n"
+    }
+
+    test("args") {
+        args = "--count" "3"
+        exitCode = 0
+        stdout contains "foo"
+    }
+}
+
+group("files") {
+    weight = 0.6
+    timeout = 5s
+
+    pattern {
+        input  = "testdata/*/input.txt"
+        output = "testdata/*/output.txt"
+    }
+}
+`
+	f, warns, err := Parse(src)
+	if err != nil {
+		t.Fatalf("parse error: %v", err)
+	}
+	if len(warns) > 0 {
+		t.Logf("warnings: %v", warns)
+	}
+
+	if f.Build != "go build -o solution ." {
+		t.Errorf("wrong build: %q", f.Build)
+	}
+	if f.Timeout != 10*time.Second {
+		t.Errorf("wrong timeout: %v", f.Timeout)
+	}
+	if len(f.Groups) != 2 {
+		t.Fatalf("expected 2 groups, got %d", len(f.Groups))
+	}
+
+	g0 := f.Groups[0]
+	if g0.Name != "basic" {
+		t.Errorf("wrong group name: %q", g0.Name)
+	}
+	if g0.Weight != 0.4 {
+		t.Errorf("wrong weight: %v", g0.Weight)
+	}
+	if len(g0.Tests) != 2 {
+		t.Fatalf("expected 2 tests, got %d", len(g0.Tests))
+	}
+
+	t0 := g0.Tests[0]
+	if t0.Name != "stdin stdout" {
+		t.Errorf("wrong test name: %q", t0.Name)
+	}
+	if t0.Stdin == nil || *t0.Stdin != "5\n1 3 2 5 4\n" {
+		t.Errorf("wrong stdin: %v", t0.Stdin)
+	}
+	exact, ok := t0.Stdout.(ExactMatcher)
+	if !ok {
+		t.Errorf("expected ExactMatcher, got %T", t0.Stdout)
+	} else if exact.Value != "1 2 3 4 5\n" {
+		t.Errorf("wrong stdout: %q", exact.Value)
+	}
+
+	t1 := g0.Tests[1]
+	if len(t1.Args) != 2 || t1.Args[0] != "--count" || t1.Args[1] != "3" {
+		t.Errorf("wrong args: %v", t1.Args)
+	}
+	if _, ok := t1.Stdout.(ContainsMatcher); !ok {
+		t.Errorf("expected ContainsMatcher, got %T", t1.Stdout)
+	}
+
+	g1 := f.Groups[1]
+	if g1.Pattern == nil {
+		t.Fatal("expected pattern in group files")
+	}
+	if g1.Pattern.InputGlob != "testdata/*/input.txt" {
+		t.Errorf("wrong input glob: %q", g1.Pattern.InputGlob)
+	}
+	if g1.Timeout != 5*time.Second {
+		t.Errorf("wrong group timeout: %v", g1.Timeout)
+	}
+}
+
+func TestWeightWarning(t *testing.T) {
+	src := `
+build "go build ."
+
+group("a") {
+    weight = 0.3
+    test("x") { stdin = "" stdout = "" }
+}
+
+group("b") {
+    weight = 0.3
+    test("y") { stdin = "" stdout = "" }
+}
+`
+	_, warns, err := Parse(src)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if len(warns) == 0 {
+		t.Error("expected weight warning, got none")
+	}
+	t.Logf("warn: %v", warns)
+}
+
+func TestHeredoc(t *testing.T) {
+	src := `
+build "go build ."
+
+group("g") {
+    weight = 1.0
+    test("heredoc") {
+        stdin = """
+            hello
+            world
+        """
+        stdout = """
+            HELLO
+            WORLD
+        """
+    }
+}
+`
+	f, _, err := Parse(src)
+	if err != nil {
+		t.Fatalf("parse error: %v", err)
+	}
+	test := f.Groups[0].Tests[0]
+	if *test.Stdin != "hello\nworld" {
+		t.Errorf("wrong stdin: %q", *test.Stdin)
+	}
+	exact := test.Stdout.(ExactMatcher)
+	if exact.Value != "HELLO\nWORLD" {
+		t.Errorf("wrong stdout: %q", exact.Value)
+	}
+}
+
+func TestMatchers(t *testing.T) {
+	src := `
+build "go build ."
+
+group("matchers") {
+    weight = 1.0
+
+    test("regex") {
+        stdin = "ping\n"
+        stdout matches "pong.*"
+    }
+
+    test("numeric") {
+        stdin = "1 3\n"
+        stdout ~ 0.001 of "0.333"
+    }
+
+    test("any order") {
+        stdin = "data\n"
+        stdout anyOrder {
+            "line1"
+            "line2"
+            "line3"
+        }
+    }
+
+    test("stderr contains") {
+        args = "--invalid"
+        exitCode = 1
+        stderr contains "invalid flag"
+    }
+}
+`
+	f, _, err := Parse(src)
+	if err != nil {
+		t.Fatalf("parse error: %v", err)
+	}
+	tests := f.Groups[0].Tests
+
+	if _, ok := tests[0].Stdout.(RegexMatcher); !ok {
+		t.Errorf("test 0: expected RegexMatcher, got %T", tests[0].Stdout)
+	}
+
+	num, ok := tests[1].Stdout.(NumericEpsMatcher)
+	if !ok {
+		t.Errorf("test 1: expected NumericEpsMatcher, got %T", tests[1].Stdout)
+	} else if num.Epsilon != 0.001 {
+		t.Errorf("test 1: wrong epsilon %v", num.Epsilon)
+	}
+
+	if _, ok := tests[2].Stdout.(AnyOrderMatcher); !ok {
+		t.Errorf("test 2: expected AnyOrderMatcher, got %T", tests[2].Stdout)
+	}
+
+	if _, ok := tests[3].Stderr.(ContainsMatcher); !ok {
+		t.Errorf("test 3: expected ContainsMatcher on stderr, got %T", tests[3].Stderr)
+	}
+	if *tests[3].ExitCode != 1 {
+		t.Errorf("test 3: expected exitCode 1, got %v", *tests[3].ExitCode)
+	}
+}