test: fix router-luatest/reload_test not reloading vshard

Before this commit the test loaded only the latest version, so the test
ran 2 times on the latest commit and did not test the actual hot-reload.
It tried to start the router on the latest version, changed
`package.loaded` and that's it, `vshard.router` even wasn't required
after that.

Since we don't support hot-reload from new version to the old one (see
0.1.34 release notes), let's actually create the router on old version
from the first start and then reload it to the latest. For that let's
use `LUA_PATH` environment variable. The alternative of using
`package.path` was rejected, since it requires modifying
`instances/router.lua` file.

However, changing `LUA_PATH` so that it points to `vshard_copy`
directory is not enough. The test runs from the repository directory and
`cwd` has higher priority, than `package.path` (which is set to
`LUA_PATH`). To bypass that, let's move the vshard copy to the
`override` directory, it has priority over `cwd`.

This commit also replaces all usages of `vtest.router_cfg` with local
function, since `ivtest.clear_test_cfg_options` may not present on old
version.

We also need to wait for service to be stopped before running the test
after reload during master_search service. The alternative solution is
using `router.master_search_f` to determine on which version function
is running. It's nullified right on reload. But let's better test, that
old services are actually stopped as soon as they're not needed.

Closes tarantool/vshard-ee#11

Co-authored-by: Roman Gromov <r.gromov.official@gmail.com>

NO_DOC=testfix

Author: Serpentian

test/luatest_helpers/vtest.lua

@@ -656,13 +656,13 @@ end
 -- Create a new router in the cluster.
 -- If no cfg was passed configuration should be done manually with server:exec
 --
-local function router_new(g, name, cfg)
+local function router_new(g, name, cfg, server_config)
     if not g.cluster then
         g.cluster = cluster:new({})
     end
-    local server = g.cluster:build_server({
-        alias = name,
-    }, 'router.lua')
+    server_config = server_config or {}
+    server_config.alias = name
+    local server = g.cluster:build_server(server_config, 'router.lua')
     g[name] = server
     g.cluster:add_server(server)
     server:start()

test/router-luatest/reload_test.lua

@@ -1,4 +1,5 @@
 local t = require('luatest')
+local vutil = require('vshard.util')
 local vtest = require('test.luatest_helpers.vtest')
 local git_util = require('test.lua_libs.git_util')
 local fio = require('fio')
@@ -27,11 +28,31 @@ local cfg_template = {
 local global_cfg
 
 g.before_all(function()
+    -- Override of the built in modules is available only since 2.11.0.
+    t.run_only_if(vutil.version_is_at_least(2, 11, 0, nil, 0, 0))
     global_cfg = vtest.config_new(cfg_template)
 
     -- The test works in the following directory
     local vardir = vtest.vardir or fio.tempdir()
-    g.vshard_copy_path =  vardir .. '/vshard_copy'
+    g.vshard_copy_path_load =  vardir .. '/vshard_copy'
+    t.assert_equals(fio.mkdir(g.vshard_copy_path_load), true)
+    --
+    -- Tarantool searches for compilation units in the following order:
+    --   1. preload --> override --> builtin
+    --   2. path.cwd.dot
+    --   3. cpath.cwd.dot
+    --   4. path.cwd.rocks
+    --   5. cpath.cwd.rocks
+    --   6. package.path
+    --   7. package.cpath
+    --   8. croot
+    --
+    -- Since the test is launched from the repository directory, newest
+    -- vshard will be always loaded, disregarding package.path or `LUA_PATH`.
+    -- So we can use package.setsearchroot() to change cwd, luatest's `chdir`
+    -- or override. The last one is used here, since it's the easiest.
+    --
+    g.vshard_copy_path =  vardir .. '/vshard_copy/override'
     t.assert_equals(fio.mkdir(g.vshard_copy_path), true)
     -- Copy source to the temporary directory
     t.assert_equals(fio.mkdir(g.vshard_copy_path .. '/.git'), true)
@@ -71,6 +92,16 @@ g.after_all(function()
     g.cluster:drop()
 end)
 
+--
+-- `vtest.router_cfg` cannot be used in this test, since
+-- `ivtest.clear_test_cfg_options` may be nil on old versions.
+--
+local function router_cfg(router, cfg)
+    router:exec(function(cfg)
+        ivshard.router.cfg(cfg)
+    end, {cfg})
+end
+
 --
 -- Reload test template:
 --     1. Invoke create_router_at:
@@ -83,21 +114,17 @@ end)
 --     5. Test smth on the new version
 --     6. Drop a router with vtest.drop_instance
 --
-
 local function create_router_at(hash)
     git_util.exec('checkout', {args = hash .. ' -f', dir = g.vshard_copy_path})
-    local router = vtest.router_new(g, 'router')
-    router:exec(function(vshard_path)
-        -- Force 'require' to use new directory
-        package.path = string.format('%s/?.lua;%s/?/init.lua;',
-                                     vshard_path, vshard_path)
-        for package_name in pairs(package.loaded) do
-            if package_name:startswith('vshard') then
-                package.loaded[package_name] = nil
-            end
-        end
-    end, {g.vshard_copy_path})
-    vtest.router_cfg(router, global_cfg)
+    local path = g.vshard_copy_path_load
+    local lua_path = string.format("%s/?.lua;%s/?/init.lua;", path, path)
+    local router = vtest.router_new(g, 'router', nil, {
+        env = {
+            -- Force 'require' to use new directory
+            ['LUA_PATH'] = lua_path .. os.getenv('LUA_PATH')
+        },
+    })
+    router_cfg(router, global_cfg)
     return router
 end
 
@@ -196,7 +223,7 @@ g.test_discovery = function(g)
 end
 
 local function test_master_search_template(g, router, auto_master_cfg)
-    vtest.router_cfg(router, auto_master_cfg)
+    router_cfg(router, auto_master_cfg)
 
     -- Working with first replicaset (2 instances)
     local rs_uuid = g.replica_1_a:replicaset_uuid()
@@ -288,6 +315,17 @@ g.test_master_search = function(g)
 
     test_master_search_template(g, router, auto_master_cfg)
     reload_router(router)
+    -- Wait for old master_search service to be stopped.
+    router:exec(function()
+        local router = ivshard.router.internal.static_router
+        ilt.helpers.retrying({}, function()
+            local fiber = router.master_search_fiber
+            if fiber then
+                pcall(fiber.wakeup, fiber)
+            end
+            ilt.assert_equals(router.master_search_service, nil)
+        end)
+    end)
     test_master_search_template(g, router, auto_master_cfg)
     vtest.drop_instance(g, router)
 end