Properly propagate object assertions during inheritance

sjsonnet/src/sjsonnet/Val.scala

@@ -167,8 +167,8 @@ object Val{
 
     def addSuper(pos: Position, lhs: Val.Obj): Val.Obj = {
       `super` match{
-        case null => new Val.Obj(pos, getValue0, false, null, lhs)
-        case x => new Val.Obj(pos, getValue0, false, null, x.addSuper(pos, lhs))
+        case null => new Val.Obj(pos, getValue0, false, triggerAsserts, lhs)
+        case x => new Val.Obj(pos, getValue0, false, triggerAsserts, x.addSuper(pos, lhs))
       }
     }
 

sjsonnet/test/src/sjsonnet/EvaluatorTests.scala

@@ -1,17 +1,10 @@
 package sjsonnet
 
 import utest._
-import TestUtils.eval
+import TestUtils.{eval, evalErr}
 object EvaluatorTests extends TestSuite{
 
-  def evalErr(s: String, strict: Boolean = false) = {
-    try {
-      val x = eval(s, strict = strict)
-      throw new Exception (s"Expected exception, got result: $x")
-    }catch{case e: Exception =>
-      e.getMessage.split('\n').map(_.trim).mkString("\n") // normalize inconsistent indenation on JVM vs JS
-    }
-  }
+
   def tests = Tests{
     test("arithmetic") {
       eval("1 + 2 + 3") ==> ujson.Num(6)
@@ -315,13 +308,13 @@ object EvaluatorTests extends TestSuite{
       eval("'%#-0- + 5.5f' % -123.456") ==> ujson.Str("-123.45600")
     }
     test("strict") {
-      eval("({ a: 1 } { b: 2 }).a", false) ==> ujson.Num(1)
-      evalErr("({ a: 1 } { b: 2 }).a", true) ==>
+      eval("({ a: 1 } { b: 2 }).a", strict = false) ==> ujson.Num(1)
+      evalErr("({ a: 1 } { b: 2 }).a", strict = true) ==>
         """sjsonnet.StaticError: Adjacent object literals not allowed in strict mode - Use '+' to concatenate objects
           |at [ObjExtend].(:1:11)""".stripMargin
-      eval("local x = { c: 3 }; (x { a: 1 } { b: 2 }).a", false) ==> ujson.Num(1)
-      eval("local x = { c: 3 }; (x { a: 1 }).a", true) ==> ujson.Num(1)
-      evalErr("local x = { c: 3 }; ({ a: 1 } { b: 2 }).a", true) ==>
+      eval("local x = { c: 3 }; (x { a: 1 } { b: 2 }).a", strict = false) ==> ujson.Num(1)
+      eval("local x = { c: 3 }; (x { a: 1 }).a", strict = true) ==> ujson.Num(1)
+      evalErr("local x = { c: 3 }; ({ a: 1 } { b: 2 }).a", strict = true) ==>
         """sjsonnet.StaticError: Adjacent object literals not allowed in strict mode - Use '+' to concatenate objects
           |at [ObjExtend].(:1:31)""".stripMargin
     }
@@ -368,5 +361,13 @@ object EvaluatorTests extends TestSuite{
       assert(evalErr("""error {a: "b"}""").contains("""{"a": "b"}"""))
       assert(evalErr("""assert 1 == 2 : { a: "b"}; 1""").contains("""{"a": "b"}"""))
     }
+
+    test("assertInheritance"){
+      test - assert(evalErr("""{ } + {assert false}""").contains("sjsonnet.Error: Assertion failed"))
+      test - assert(evalErr("""{assert false} + {}""").contains("sjsonnet.Error: Assertion failed"))
+      test - assert(evalErr("""{assert false} + {} + {}""").contains("sjsonnet.Error: Assertion failed"))
+      test - assert(evalErr("""{} + {assert false} + {}""").contains("sjsonnet.Error: Assertion failed"))
+      test - assert(evalErr("""{} + {} + {assert false}""").contains("sjsonnet.Error: Assertion failed"))
+    }
   }
 }

sjsonnet/test/src/sjsonnet/PreserveOrderTests.scala

@@ -1,7 +1,7 @@
 package sjsonnet
 
 import utest._
-import TestUtils.eval
+import TestUtils.{eval, evalErr}
 object PreserveOrderTests extends TestSuite {
 
   def tests = Tests {
@@ -289,19 +289,17 @@ object PreserveOrderTests extends TestSuite {
     }
 
     test("preserveOrderError") {
-      try {
-        eval(
+      assert(
+        evalErr(
           """local x = { b: 1, a: 2, c: self.a + self.b };
-           error x""", true)
-        assert(false)
-      } catch {
-        case e: Exception =>
-          assert(e.getMessage().startsWith("""sjsonnet.Error: {"b": 1, "a": 2, "c": 3}"""))
-      }
+           error x""", preserveOrder = true
+        )
+          .startsWith("""sjsonnet.Error: {"b": 1, "a": 2, "c": 3}""")
+      )
     }
 
     test("preserveOrderPreservesEquality") {
-      eval("""{a: 1, b: 2} == {b: 2, a: 1}""", true).toString ==> "true"
+      eval("""{a: 1, b: 2} == {b: 2, a: 1}""", preserveOrder = true).toString ==> "true"
     }
 
     test("preserveOrderSet") {

sjsonnet/test/src/sjsonnet/StdFlatMapTests.scala

@@ -1,7 +1,7 @@
 package sjsonnet
 
 import utest._
-import TestUtils.eval
+import TestUtils.{eval, evalErr}
 object StdFlatMapTests extends TestSuite {
 
   def tests = Tests {
@@ -14,13 +14,11 @@ object StdFlatMapTests extends TestSuite {
 
       eval("std.flatMap(function (x) if x == \" \" then null else x, \"a b c d e\")") ==> ujson.Str("abcde")
 
-      try {
-        eval("std.flatMap(function(x) 123, 'Hello')")
-        assert(false)
-      } catch {
-        case e: Exception =>
-          assert(e.getMessage().startsWith("""sjsonnet.Error: flatMap func must return string, got number"""))
-      }
+      assert(
+        evalErr("std.flatMap(function(x) 123, 'Hello')")
+          .startsWith("sjsonnet.Error: flatMap func must return string, got number")
+      )
+
     }
   }
 }

sjsonnet/test/src/sjsonnet/TestUtils.scala

@@ -1,18 +1,28 @@
 package sjsonnet
 
 object TestUtils {
-  def eval(s: String, preserveOrder: Boolean = false, strict: Boolean = false) = {
+  def eval0(s: String, preserveOrder: Boolean = false, strict: Boolean = false) = {
     new Interpreter(
       Map(),
       Map(),
       DummyPath(),
       Importer.empty,
       parseCache = new DefaultParseCache,
       new Settings(preserveOrder = preserveOrder, strict = strict)
-    ).interpret(s, DummyPath("(memory)")) match {
+    ).interpret(s, DummyPath("(memory)"))
+  }
+
+  def eval(s: String, preserveOrder: Boolean = false, strict: Boolean = false) = {
+    eval0(s, preserveOrder, strict) match {
       case Right(x) => x
       case Left(e) => throw new Exception(e)
     }
   }
 
+  def evalErr(s: String, preserveOrder: Boolean = false, strict: Boolean = false) = {
+    eval0(s, preserveOrder, strict) match{
+      case Left(err) => err.split('\n').map(_.trim).mkString("\n")  // normalize inconsistent indenation on JVM vs JS
+      case Right(r) => throw new Exception(s"Expected exception, got result: $r")
+    }
+  }
 }