Add error handling at the server instance

When executing the following code on the remote server instance using
`server:exec()`, we could get an unobvious error:

        s = Server:new()
        s:start()

        -- we expected a custom error with the "My error" message, but
        -- got "Transaction is active at return from function"
        s:exec(function() box.begin() error("My error") end)

This is due to the specific evaluation and capture of the return values
of `net_box:eval` (for more details see here: tarantool/tarantool#7288).

The error will be raised on the server instance side. In the process of
development we found that our approach does not work in the specific
case:

        -- an error message has been expected but got an error table:
        -- {
        --    class = LuatestError,
        --    status = fail,
        --    message = "a value evaluating to true, actual: false"
        -- }
        s:exec(function() require('luatest').assert(false) end)

To fix this error we decided to add the encoding an error to JSON format
on the server and decode it on the client side.

Close #242

Co-authored-by: Yaroslav Lobankov <y.lobankov@tarantool.org>

Author: Oleg Chaplashkin

luatest/server.lua

@@ -522,7 +522,8 @@ end
 
 local function exec_tail(ok, ...)
     if not ok then
-        error(..., 0)
+        local _ok, res = pcall(json.decode, tostring(...))
+        error(_ok and res or ..., 0)
     else
         return ...
     end
@@ -604,7 +605,14 @@ function Server:exec(fn, args, options)
             :format(utils.get_fn_location(fn)))
     end
 
-    return exec_tail(self.net_box:eval([[
+    -- The function `fn` can return multiple values and we cannot use the
+    -- classical approach to work with the `pcall`:
+    --
+    --    local status, result = pcall(function() return 1, 2, 3 end)
+    --
+    -- `result` variable will contain only `1` value, not `1, 2, 3`.
+    -- To solve this, we put everything from `pcall` in a table.
+    return exec_tail(pcall(self.net_box.eval, self.net_box, [[
         local dump, args, passthrough_ups = ...
         local fn = loadstring(dump)
         for i = 1, debug.getinfo(fn, 'u').nups do
@@ -613,11 +621,19 @@ function Server:exec(fn, args, options)
                 debug.setupvalue(fn, i, require(passthrough_ups[name]))
             end
         end
+        local result
         if args == nil then
-            return pcall(fn)
+            result = {pcall(fn)}
         else
-            return pcall(fn, unpack(args))
+            result = {pcall(fn, unpack(args))}
         end
+        if not result[1] then
+            if type(result[2]) == 'table' then
+                result[2] = require('json').encode(result[2])
+            end
+            error(result[2], 0)
+        end
+        return unpack(result, 2)
     ]], {string.dump(fn), args, passthrough_ups}, options))
 end
 

test/server_test.lua

@@ -429,3 +429,50 @@ end
 g.after_test('test_netbox_uri_is_not_overridden', function()
     g.s1:drop()
 end)
+
+g.before_test('test_error_level_is_correct', function()
+    g.s = Server:new()
+    g.s:start()
+end)
+
+g.test_error_level_is_correct = function()
+    local c = require('net.box').connect(g.s.net_box_uri)
+
+    t.assert_error_msg_contains( -- error in exec
+        "My error", g.s.exec, g.s,
+        function() error("My error") end)
+
+    t.assert_error_msg_contains( -- error in eval
+        "eval", g.s.eval, g.s,
+        [[error("My error")]])
+
+    t.assert_error_msg_contains( -- error in closures
+        "My error", g.s.exec, g.s,
+        function()
+            local function internal() error("My error") end
+            internal()
+        end)
+
+    t.assert_error_msg_contains( -- error in tx netbox connection
+        "My error", c.eval, c,
+        [[box.begin() error("My error")]])
+
+    t.assert_error_msg_contains( -- error in tx eval
+        "My error", g.s.eval, g.s,
+        [[box.begin() error("My error")]])
+
+    t.assert_error_msg_contains( -- error in tx exec
+        "My error", g.s.exec, g.s,
+        function() box.begin() error("My error") end)
+
+    t.assert_error_msg_contains( -- error in tx closures
+        "My error", g.s.exec, g.s,
+        function()
+            local function internal() box.begin() error("My error") end
+            internal()
+        end)
+end
+
+g.after_test('test_error_level_is_correct', function()
+    g.s:drop()
+end)