Use wildcard to check stack trace outputs (denoland#3)

Makefile

@@ -30,7 +30,9 @@ GO_FILES = \
  os.go \
  os_test.go \
  timers.go \
- util.go
+ util.go \
+ util_test.go \
+ integration_test.go
 
 
 deno: msg.pb.go $(GO_FILES)

TODO.txt

@@ -1,9 +1,5 @@
 - Fix v8_source_maps.ts so that we don't get random segfaults.
 
-- Add wildcard support to testdata/*.out tests so that we can check
- the stack trace output in testdata/007_stack_trace.ts and
- testdata/013_async_throw.ts.
-
 - Remove text-encoding.d.ts because TS2.8 includes the declarations.
  https://github.com/DefinitelyTyped/DefinitelyTyped/issues/24695
 

integration_test.go

@@ -47,7 +47,7 @@ func listTestFiles() []string {
  return out
 }
 
-func checkOutput(t *testing.T, outFile string) {
+func checkOutput(t *testing.T, outFile string, shouldSucceed bool) {
  outFile = path.Join("testdata", outFile)
  jsFile := strings.TrimSuffix(outFile, ".out")
 
@@ -57,10 +57,12 @@ func checkOutput(t *testing.T, outFile string) {
  }
 
  actual, _, err := deno(jsFile)
- if err != nil {
- t.Fatal(err.Error())
+ if shouldSucceed && err != nil {
+ t.Fatalf("Expected success %s", err.Error())
+ } else if !shouldSucceed && err == nil {
+ t.Fatalf("Expected failure but got success")
  }
- if bytes.Compare(actual, expected) != 0 {
+ if !patternMatch(string(expected), string(actual)) {
  t.Fatalf(`Actual output does not match expected.
 -----Actual-------------------
 %s-----Expected-----------------
@@ -77,10 +79,9 @@ func deno(inputFn string) (actual []byte, cachedir string, err error) {
  cmd := exec.Command(denoFn, "--cachedir="+cachedir, inputFn)
  var out bytes.Buffer
  cmd.Stdout = &out
+ cmd.Stderr = &out
  err = cmd.Run()
- if err == nil {
- actual = out.Bytes()
- }
+ actual = out.Bytes()
  return
 }
 
@@ -100,7 +101,8 @@ func TestIntegrationFiles(t *testing.T) {
  outFiles := listTestFiles()
  for _, outFile := range outFiles {
  t.Run(outFile, func(t *testing.T) {
- checkOutput(t, outFile)
+ shouldSucceed := strings.Index(outFile, "error") < 0
+ checkOutput(t, outFile, shouldSucceed)
  })
  }
 }
@@ -133,20 +135,6 @@ func TestIntegrationUrlArgs(t *testing.T) {
  }
 }
 
-func TestErrors(t *testing.T) {
- integrationTestSetup()
-
- _, _, err := deno("testdata/013_async_throw.ts")
- if err == nil {
- t.Fatalf("Expected error.")
- }
-
- _, _, err = deno("testdata/007_stack_trace.ts")
- if err == nil {
- t.Fatalf("Expected error.")
- }
-}
-
 func TestTestsTs(t *testing.T) {
  integrationTestSetup()
  // TODO Need unit test for each of the permissions.

testdata/006_url_imports.ts.out

@@ -1,2 +1,3 @@
+Downloading http:https://localhost:4545/testdata/subdir/print_hello.ts
 Hello
 success

testdata/async_error.ts.out

@@ -0,0 +1,10 @@
+hello
+before error
+error Error: error
+ at foo ([WILDCARD]testdata/async_error.ts:4:11)
+ at eval ([WILDCARD]testdata/async_error.ts:6:1)
+ at Object.eval [as globalEval] (<anonymous>)
+ at execute (/main.js:[WILDCARD])
+ at FileModule.compileAndRun (/main.js:[WILDCARD])
+ at /main.js:[WILDCARD]
+ at /main.js:[WILDCARD]

testdata/error.ts.out

@@ -0,0 +1,10 @@
+/main.js:[WILDCARD]
+ throw _iteratorError;
+ ^
+Error: bad
+ at foo ([WILDCARD]testdata/error.ts:2:9)
+ at bar ([WILDCARD]testdata/error.ts:6:3)
+ at eval ([WILDCARD]testdata/error.ts:9:1)
+ at Object.eval [as globalEval] (<anonymous>)
+ at execute (../runtime.ts:[WILDCARD])
+ at FileModule.compileAndRun (../runtime.ts:[WILDCARD]

util.go

@@ -6,6 +6,7 @@ import (
  "fmt"
  "net/url"
  "os"
+ "strings"
 )
 
 func logDebug(format string, v ...interface{}) {
@@ -59,3 +60,47 @@ func async(cb func()) {
  wg.Done()
  }()
 }
+
+const wildcard = "[WILDCARD]"
+
+// Matches the pattern string against the text string. The pattern can
+// contain "[WILDCARD]" substrings which will match one or more characters.
+// Returns true if matched.
+func patternMatch(pattern string, text string) bool {
+ // Empty pattern only match empty text.
+ if len(pattern) == 0 {
+ return len(text) == 0
+ }
+
+ if pattern == wildcard {
+ return true
+ }
+
+ parts := strings.Split(pattern, wildcard)
+
+ if len(parts) == 1 {
+ return pattern == text
+ }
+
+ if strings.HasPrefix(text, parts[0]) {
+ text = text[len(parts[0]):]
+ } else {
+ return false
+ }
+
+ for i := 1; i < len(parts); i++ {
+ // If the last part is empty, we match.
+ if i == len(parts)-1 {
+ if parts[i] == "" || parts[i] == "\n" {
+ return true
+ }
+ }
+ index := strings.Index(text, parts[i])
+ if index < 0 {
+ return false
+ }
+ text = text[index+len(parts[i]):]
+ }
+
+ return len(text) == 0
+}

util_test.go

@@ -0,0 +1,62 @@
+package deno
+
+import (
+ "testing"
+)
+
+const exStackTrace = `hello
+before error
+error Error: error
+ at foo (/Users/rld/go/src/github.com/ry/deno/testdata/013_async_throw.ts:4:11)
+ at eval (/Users/rld/go/src/github.com/ry/deno/testdata/013_async_throw.ts:6:1)
+ at Object.eval [as globalEval] (<anonymous>)
+ at execute (/main.js:144781:15)
+ at FileModule.compileAndRun (/main.js:144678:13)
+ at /main.js:145161:13
+ at /main.js:15733:13`
+const exStackTracePattern = `hello
+before error
+error Error: error
+ at foo ([WILDCARD]testdata/013_async_throw.ts:4:11)
+ at eval ([WILDCARD]testdata/013_async_throw.ts:6:1)
+ at Object.eval [as globalEval] (<anonymous>)
+ at execute (/main.js:[WILDCARD]`
+
+func TestPatternMatch(t *testing.T) {
+ if patternMatch("aa", "a") != false {
+ t.Fatalf("Wrong resullt (1).")
+ }
+ if patternMatch("aaa[WILDCARD]b", "aaaxsdfdb") != true {
+ t.Fatalf("Wrong resullt (2).")
+ }
+ if patternMatch("aab[WILDCARD]", "xsd") != false {
+ t.Fatalf("Wrong resullt (3).")
+ }
+ if patternMatch("a[WILDCARD]b[WILDCARD]c", "abc") != true {
+ t.Fatalf("Wrong resullt (4).")
+ }
+ if patternMatch("a[WILDCARD]b[WILDCARD]c", "axbc") != true {
+ t.Fatalf("Wrong resullt (5).")
+ }
+ if patternMatch("a[WILDCARD]b[WILDCARD]c", "abxc") != true {
+ t.Fatalf("Wrong resullt (6).")
+ }
+ if patternMatch("a[WILDCARD]b[WILDCARD]c", "axbxc") != true {
+ t.Fatalf("Wrong resullt (7).")
+ }
+ if patternMatch("a[WILDCARD]b[WILDCARD]c", "abcx") != false {
+ t.Fatalf("Wrong resullt (8).")
+ }
+ if patternMatch("a[WILDCARD][WILDCARD]c", "abc") != true {
+ t.Fatalf("Wrong resullt (9).")
+ }
+ if patternMatch("a[WILDCARD][WILDCARD]c", "ac") != true {
+ t.Fatalf("Wrong resullt (10).")
+ }
+}
+
+func TestPatternMatchStackTrace(t *testing.T) {
+ if patternMatch(exStackTracePattern, exStackTrace) != true {
+ t.Fatalf("Wrong resullt (11).")
+ }
+}