Fix interception of luatest errors in assertions

 * Never intercept assertion failures with t.assert_error() and others,
   because this may hide unexpected assertion failures.
 * Unwrap luatest errors (class = LuatestError, status = error).
   This is required for assertions to work on errors wrapped by
   Server:exec() - see the next commit.

Needed for #396

Author: locker

CHANGELOG.md

@@ -21,6 +21,7 @@
   error serialization is enabled in Tarantool (gh-376).
 - Added `assert_items_exclude`.
 - Strip useless `...` lines from error trace.
+- Make `assert_error_*` ignore errors raised by assertion failures.
 
 ## 1.0.1
 

luatest/assertions.lua

@@ -164,12 +164,30 @@ local function pcall_check_trace(level, fn, ...)
     return ok, err
 end
 
+--
+-- Wrapper around pcall that:
+-- * checks the stack trace for box errors;
+-- * unwraps the error if it was wrapped by luatest (e.g. by Server:exec());
+-- * re-raises the error if it was raised by a luatest assertion failure.
+--
+local function pcall_wrapper(level, fn, ...)
+    local ok, err = pcall_check_trace(level + 1, fn, ...)
+    if not ok and utils.is_luatest_error(err) then
+        if err.status == 'error' then
+            err = err.message
+        else
+            error(err)
+        end
+    end
+    return ok, err
+end
+
 --- Check that calling fn raises an error.
 --
 -- @func fn
 -- @param ... arguments for function
 function M.assert_error(fn, ...)
-    local ok, err = pcall_check_trace(2, fn, ...)
+    local ok, err = pcall_wrapper(2, fn, ...)
     if ok then
         failure("Expected an error when calling function but no error generated", nil, 2)
     end
@@ -565,7 +583,7 @@ function M.assert_str_matches(value, pattern, start, final, message)
 end
 
 local function _assert_error_msg_equals(stripFileAndLine, expectedMsg, func, ...)
-    local no_error, error_msg = pcall_check_trace(3, func, ...)
+    local no_error, error_msg = pcall_wrapper(3, func, ...)
     if no_error then
         local failure_message = string.format(
             'Function successfully returned: %s\nExpected error: %s',
@@ -631,7 +649,7 @@ end
 -- @func fn
 -- @param ... arguments for function
 function M.assert_error_msg_contains(expected_partial, fn, ...)
-    local no_error, error_msg = pcall_check_trace(2, fn, ...)
+    local no_error, error_msg = pcall_wrapper(2, fn, ...)
     log.info('Assert error message %s contains %s', error_msg, expected_partial)
     if no_error then
         local failure_message = string.format(
@@ -654,7 +672,7 @@ end
 -- @func fn
 -- @param ... arguments for function
 function M.assert_error_msg_matches(pattern, fn, ...)
-    local no_error, error_msg = pcall_check_trace(2, fn, ...)
+    local no_error, error_msg = pcall_wrapper(2, fn, ...)
     if no_error then
         local failure_message = string.format(
             'Function successfully returned: %s\nExpected error matching: %s',
@@ -694,7 +712,7 @@ end
 -- @func fn
 -- @param ... arguments for function
 function M.assert_error_covers(expected, fn, ...)
-    local ok, actual = pcall_check_trace(2, fn, ...)
+    local ok, actual = pcall_wrapper(2, fn, ...)
     if ok then
         fail_fmt(2, nil,
                  'Function successfully returned: %s\nExpected error: %s',

test/helpers/general.lua

@@ -1,6 +1,5 @@
 local t = require('luatest')
 local Runner = require('luatest.runner')
-local utils = require('luatest.utils')
 
 local helper = {}
 
@@ -11,8 +10,9 @@ function helper.run_suite(load_tests, args)
 end
 
 function helper.assert_failure(...)
-    local err = t.assert_error(...)
-    t.assert(utils.is_luatest_error(err), err)
+    local ok, err = pcall(...)
+    t.assert_not(ok)
+    t.assert_covers(err, {class = 'LuatestError', status = 'fail'})
     return err
 end
 

test/luaunit/assertions_error_test.lua

@@ -276,3 +276,23 @@ function g.test_error_trace_check()
     assert_failure_contains('Unexpected error trace, expected:',
                             t.assert_error, f_check_trace, 1)
 end
+
+function g.test_luatest_error()
+    local function raise(err)
+        error({class = 'LuatestError', status = 'error', message = err})
+    end
+    t.assert_error(raise, 'foo')
+    t.assert_error_msg_equals('foo', raise, 'foo')
+    t.assert_error_msg_contains('foo', raise, 'foobar')
+    t.assert_error_covers({foo = 'bar'}, raise, {foo = 'bar', fuzz = 'buzz'})
+
+    local msg = 'expected: a value evaluating to true, actual: false'
+    assert_failure_equals(msg, t.assert_error,
+                          t.assert, false)
+    assert_failure_equals(msg, t.assert_error_msg_equals, 'foo',
+                          t.assert, false)
+    assert_failure_equals(msg, t.assert_error_msg_contains, 'foo',
+                          t.assert, false)
+    assert_failure_equals(msg, t.assert_error_covers, {foo = 'bar'},
+                          t.assert, false)
+end

test/server_test.lua

@@ -216,7 +216,7 @@ g.test_net_box_exec = function()
 
     do
         local _l_fn, fn = l(), function() require('luatest').assert(false) end
-        local err = t.assert_error(
+        local err = helper.assert_failure(
             exec, fn
         )
         t.assert(utils.is_luatest_error(err), err)