tests: reorganize and speed up unit tests

11 files changed, 502 insertions, 72 deletions

diff --git a/spec/unit/build_spec.lua b/spec/unit/build_spec.lua
index 6ab143c6..fb680858 100644
--- a/spec/unit/build_spec.lua
+++ b/spec/unit/build_spec.lua
@@ -6,9 +6,6 @@ local testing_paths = test_env.testing_paths
 local write_file = test_env.write_file
 local P = test_env.P
 
-test_env.unload_luarocks()
-
-test_env.unload_luarocks()
 test_env.setup_specs()
 local cfg = require("luarocks.core.cfg")
 local deps = require("luarocks.deps")
diff --git a/spec/unit/deps_spec.lua b/spec/unit/deps_spec.lua
new file mode 100644
index 00000000..b8c89a2d
--- /dev/null
+++ b/spec/unit/deps_spec.lua
@@ -0,0 +1,144 @@
+local test_env = require("spec.util.test_env")
+local testing_paths = test_env.testing_paths
+
+local cfg = require("luarocks.core.cfg")
+local deps = require("luarocks.deps")
+local fs = require("luarocks.fs")
+
+describe("LuaRocks deps #unit", function()
+   local runner
+
+   lazy_setup(function()
+      cfg.init()
+      fs.init()
+      deps.check_lua_incdir(cfg.variables)
+      deps.check_lua_libdir(cfg.variables)
+
+      runner = require("luacov.runner")
+      runner.init(testing_paths.testrun_dir .. "/luacov.config")
+      runner.tick = true
+   end)
+
+   lazy_teardown(function()
+      runner.shutdown()
+   end)
+
+   describe("deps", function()
+      describe("deps.autodetect_external_dependencies", function()
+         it("returns false if the given build table has no external dependencies", function()
+            local build_table = {
+               type = "builtin"
+            }
+
+            assert.falsy(deps.autodetect_external_dependencies(build_table))
+         end)
+
+         it("returns a table of the external dependencies found in the given build table", function()
+            local build_table = {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = { "foo1", "foo2" },
+                  },
+                  module2 = {
+                     libraries = "foo3"
+                  },
+               }
+            }
+
+            local extdeps = deps.autodetect_external_dependencies(build_table)
+            assert.same(extdeps["FOO1"], { library = "foo1" })
+            assert.same(extdeps["FOO2"], { library = "foo2" })
+            assert.same(extdeps["FOO3"], { library = "foo3" })
+         end)
+
+         it("adds proper include and library dirs to the given build table", function()
+            local build_table
+
+            build_table = {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo"
+                  }
+               }
+            }
+            deps.autodetect_external_dependencies(build_table)
+            assert.same(build_table, {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "$(FOO_INCDIR)" },
+                     libdirs = { "$(FOO_LIBDIR)" }
+                  }
+               }
+            })
+
+            build_table = {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "INCDIRS" }
+                  }
+               }
+            }
+            deps.autodetect_external_dependencies(build_table)
+            assert.same(build_table, {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "INCDIRS" },
+                     libdirs = { "$(FOO_LIBDIR)" }
+                  }
+               }
+            })
+
+            build_table = {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     libdirs = { "LIBDIRS" }
+                  }
+               }
+            }
+            deps.autodetect_external_dependencies(build_table)
+            assert.same(build_table, {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "$(FOO_INCDIR)" },
+                     libdirs = { "LIBDIRS" }
+                  }
+               }
+            })
+
+            build_table = {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "INCDIRS" },
+                     libdirs = { "LIBDIRS" }
+                  }
+               }
+            }
+            deps.autodetect_external_dependencies(build_table)
+            assert.same(build_table, {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "INCDIRS" },
+                     libdirs = { "LIBDIRS" }
+                  }
+               }
+            })
+         end)
+      end)
+   end)
+end)
diff --git a/spec/unit/dir_spec.lua b/spec/unit/dir_spec.lua
index b5dadda8..f340beea 100644
--- a/spec/unit/dir_spec.lua
+++ b/spec/unit/dir_spec.lua
@@ -2,7 +2,6 @@ local test_env = require("spec.util.test_env")
 local testing_paths = test_env.testing_paths
 local P = test_env.P
 
-test_env.unload_luarocks()
 test_env.setup_specs()
 local dir = require("luarocks.dir")
 
diff --git a/spec/unit/fetch_spec.lua b/spec/unit/fetch_spec.lua
index 38da379e..c58e2cea 100644
--- a/spec/unit/fetch_spec.lua
+++ b/spec/unit/fetch_spec.lua
@@ -1,6 +1,5 @@
 local test_env = require("spec.util.test_env")
 
-test_env.unload_luarocks()
 test_env.setup_specs()
 local cfg = require("luarocks.core.cfg")
 local fetch = require("luarocks.fetch")
diff --git a/spec/unit/fs_spec.lua b/spec/unit/fs_spec.lua
index aea86af3..7643e9b5 100644
--- a/spec/unit/fs_spec.lua
+++ b/spec/unit/fs_spec.lua
@@ -1,6 +1,5 @@
 local test_env = require("spec.util.test_env")
 
-test_env.unload_luarocks()
 test_env.setup_specs()
 local fs = require("luarocks.fs")
 local path = require("luarocks.path")
@@ -542,7 +541,7 @@ describe("luarocks.fs #unit", function()
          if is_win then
             assert.same(tmpdir, fs.current_dir())
          else
-            assert.same(lfs.attributes(tmpdir).ino, lfs.attributes(fs.current_dir()).ino)
+            assert.same(lfs.attributes(tmpdir).ino, lfs.attributes((fs.current_dir())).ino)
          end
       end)
    end)
@@ -578,7 +577,7 @@ describe("luarocks.fs #unit", function()
          if is_win then
             assert.same(tmpdir, fs.current_dir())
          else
-            assert.same(lfs.attributes(tmpdir).ino, lfs.attributes(lfs.currentdir()).ino)
+            assert.same(lfs.attributes(tmpdir).ino, lfs.attributes(fs.current_dir()).ino)
          end
       end)
 
@@ -1283,67 +1282,6 @@ describe("luarocks.fs #unit", function()
       end)
    end)
 
-   describe("fs.download #mock", function()
-      local tmpfile
-      local tmpdir
-
-      setup(function()
-         test_env.mock_server_init()
-      end)
-
-      teardown(function()
-         test_env.mock_server_done()
-      end)
-
-      after_each(function()
-         if tmpfile then
-            os.remove(tmpfile)
-            tmpfile = nil
-         end
-         if tmpdir then
-            lfs.rmdir(tmpdir)
-            tmpdir = nil
-         end
-      end)
-
-      it("returns true and fetches the url argument into the specified filename", function()
-         tmpfile = get_tmp_path()
-         assert.truthy(fs.download("http://localhost:8080/file/a_rock.lua", tmpfile))
-         local fd = assert(io.open(tmpfile, "r"))
-         local downloadcontent = assert(fd:read("*a"))
-         fd:close()
-         fd = assert(io.open(testing_paths.fixtures_dir .. "/a_rock.lua", "r"))
-         local originalcontent = assert(fd:read("*a"))
-         fd:close()
-         assert.same(downloadcontent, originalcontent)
-      end)
-
-      it("returns true and fetches the url argument into a file whose name matches the basename of the url if the filename argument is not given", function()
-         tmpdir = get_tmp_path()
-         lfs.mkdir(tmpdir)
-         fs.change_dir(tmpdir)
-         assert.truthy(fs.download("http://localhost:8080/file/a_rock.lua"))
-         tmpfile = tmpdir .. "/a_rock.lua"
-         local fd = assert(io.open(tmpfile, "r"))
-         local downloadcontent = assert(fd:read("*a"))
-         fd:close()
-         fd = assert(io.open(testing_paths.fixtures_dir .. "/a_rock.lua", "r"))
-         local originalcontent = assert(fd:read("*a"))
-         fd:close()
-         assert.same(downloadcontent, originalcontent)
-         fs.pop_dir()
-      end)
-
-      it("returns false and does nothing if the url argument contains a nonexistent file", function()
-         tmpfile = get_tmp_path()
-         assert.falsy(fs.download("http://localhost:8080/file/nonexistent", tmpfile))
-      end)
-
-      it("returns false and does nothing if the url argument is invalid", function()
-         assert.falsy(fs.download("invalidurl"))
-      end)
-   end)
-
    describe("fs.zip", function()
       local tmpdir
       local olddir
diff --git a/spec/unit/fun_spec.lua b/spec/unit/fun_spec.lua
index 9844ec27..c2b3e864 100644
--- a/spec/unit/fun_spec.lua
+++ b/spec/unit/fun_spec.lua
@@ -1,7 +1,6 @@
 local test_env = require("spec.util.test_env")
 local testing_paths = test_env.testing_paths
 
-test_env.unload_luarocks()
 local fun = require("luarocks.fun")
 
 describe("luarocks.fun #unit", function()
diff --git a/spec/unit/loader_spec.lua b/spec/unit/loader_spec.lua
new file mode 100644
index 00000000..7650c80c
--- /dev/null
+++ b/spec/unit/loader_spec.lua
@@ -0,0 +1,21 @@
+local test_env = require("spec.util.test_env")
+local run = test_env.run
+
+describe("luarocks.loader", function()
+
+   before_each(function()
+      test_env.setup_specs()
+   end)
+
+   describe("#unit", function()
+      it("starts", function()
+         assert(run.lua_bool([[-e "require 'luarocks.loader'; print(package.loaded['luarocks.loaded'])"]]))
+      end)
+
+      describe("which", function()
+         it("finds modules using package.path", function()
+            assert(run.lua_bool([[-e "loader = require 'luarocks.loader'; local x,y,z,p = loader.which('luarocks.loader', 'p'); assert(p == 'p')"]]))
+         end)
+      end)
+   end)
+end)
diff --git a/spec/unit/persist_spec.lua b/spec/unit/persist_spec.lua
index f426fd83..ea5985aa 100644
--- a/spec/unit/persist_spec.lua
+++ b/spec/unit/persist_spec.lua
@@ -1,7 +1,6 @@
 local test_env = require("spec.util.test_env")
 local testing_paths = test_env.testing_paths
 
-test_env.unload_luarocks()
 local persist = require("luarocks.persist")
 
 describe("luarocks.persist #unit", function()
diff --git a/spec/unit/test_spec.lua b/spec/unit/test_spec.lua
new file mode 100644
index 00000000..4d338984
--- /dev/null
+++ b/spec/unit/test_spec.lua
@@ -0,0 +1,174 @@
+local test_env = require("spec.util.test_env")
+local lfs = require("lfs")
+local get_tmp_path = test_env.get_tmp_path
+local testing_paths = test_env.testing_paths
+local write_file = test_env.write_file
+
+local fs = require("luarocks.fs")
+local cfg = require("luarocks.core.cfg")
+local path = require("luarocks.path")
+local test = require("luarocks.test")
+local test_busted = require("luarocks.test.busted")
+local test_command = require("luarocks.test.command")
+
+describe("LuaRocks test #unit", function()
+   local runner
+
+   lazy_setup(function()
+      cfg.init()
+      fs.init()
+      runner = require("luacov.runner")
+      runner.init(testing_paths.testrun_dir .. "/luacov.config")
+      runner.tick = true
+   end)
+
+   lazy_teardown(function()
+      runner.shutdown()
+   end)
+
+   local tmpdir
+   local olddir
+
+   local create_tmp_dir = function()
+      tmpdir = get_tmp_path()
+      olddir = lfs.currentdir()
+      lfs.mkdir(tmpdir)
+      lfs.chdir(tmpdir)
+      fs.change_dir(tmpdir)
+   end
+
+   local destroy_tmp_dir = function()
+      if olddir then
+         lfs.chdir(olddir)
+         if tmpdir then
+            lfs.rmdir(tmpdir)
+         end
+      end
+   end
+
+   describe("test.command", function()
+      describe("command.detect_type", function()
+         before_each(function()
+            create_tmp_dir()
+         end)
+
+         after_each(function()
+            destroy_tmp_dir()
+         end)
+
+         it("returns true if test.lua exists", function()
+            write_file("test.lua", "", finally)
+            assert.truthy(test_command.detect_type())
+         end)
+
+         it("returns false if test.lua doesn't exist", function()
+            assert.falsy(test_command.detect_type())
+         end)
+      end)
+
+      describe("command.run_tests", function()
+         before_each(function()
+            create_tmp_dir()
+         end)
+
+         after_each(function()
+            destroy_tmp_dir()
+         end)
+
+         it("returns the result of the executed tests", function()
+            write_file("test.lua", "assert(1==1)", finally)
+            assert.truthy(test_command.run_tests(nil, {}))
+
+            write_file("test.lua", "assert(1==2)", finally)
+            assert.falsy(test_command.run_tests(nil, {}))
+         end)
+
+         it("returns the result of the executed tests with custom arguments and test command", function()
+            write_file("test.lua", "assert(1==1)", finally)
+
+            local test = {
+               script = "test.lua",
+               flags = {
+                  arg1 = "1",
+                  arg2 = "2"
+               },
+               command = fs.Q(testing_paths.lua)
+            }
+            assert.truthy(test_command.run_tests(test, {}))
+         end)
+
+         it("returns false and does nothing if the test script doesn't exist", function()
+            assert.falsy(test_command.run_tests(nil, {}))
+         end)
+      end)
+   end)
+
+   describe("test.busted", function()
+      describe("busted.detect_type", function()
+         before_each(function()
+            create_tmp_dir()
+         end)
+
+         after_each(function()
+            destroy_tmp_dir()
+         end)
+
+         it("returns true if .busted exists", function()
+            write_file(".busted", "", finally)
+            assert.truthy(test_busted.detect_type())
+         end)
+
+         it("returns false if .busted doesn't exist", function()
+            assert.falsy(test_busted.detect_type())
+         end)
+      end)
+
+      describe("busted.run_tests", function()
+         before_each(function()
+            path.use_tree(testing_paths.testing_sys_tree)
+            create_tmp_dir()
+         end)
+
+         after_each(function()
+            destroy_tmp_dir()
+         end)
+
+         pending("returns the result of the executed tests", function()
+            -- FIXME: busted issue
+            write_file("test_spec.lua", "assert(1==1)", finally)
+            assert.truthy(test_busted.run_tests(nil, {}))
+
+            write_file("test_spec.lua", "assert(1==2)", finally)
+            assert.falsy(test_busted.run_tests())
+         end)
+      end)
+   end)
+
+   describe("test", function()
+      describe("test.run_test_suite", function()
+         before_each(function()
+            create_tmp_dir()
+         end)
+
+         after_each(function()
+            destroy_tmp_dir()
+         end)
+
+         it("returns false if the given rockspec cannot be loaded", function()
+            assert.falsy(test.run_test_suite("invalid", nil, {}))
+         end)
+
+         it("returns false if no test type was detected", function()
+            assert.falsy(test.run_test_suite({ package = "test" }, nil, {}))
+         end)
+
+         it("returns the result of executing the tests specified in the given rockspec", function()
+            write_file("test.lua", "assert(1==1)", finally)
+            assert.truthy(test.run_test_suite({ test_dependencies = {} }, nil, {}))
+
+            write_file("test.lua", "assert(1==2)", finally)
+            assert.falsy(test.run_test_suite({ test_dependencies = {} }, nil, {}))
+         end)
+      end)
+   end)
+end)
diff --git a/spec/unit/tools_spec.lua b/spec/unit/tools_spec.lua
index 29e21740..0863c316 100644
--- a/spec/unit/tools_spec.lua
+++ b/spec/unit/tools_spec.lua
@@ -3,7 +3,6 @@ local get_tmp_path = test_env.get_tmp_path
 local testing_paths = test_env.testing_paths
 local write_file = test_env.write_file
 
-test_env.unload_luarocks()
 local fs = require("luarocks.fs")
 local cfg = require("luarocks.core.cfg")
 local patch = require("luarocks.tools.patch")
diff --git a/spec/unit/util_spec.lua b/spec/unit/util_spec.lua
new file mode 100644
index 00000000..0e380f2a
--- /dev/null
+++ b/spec/unit/util_spec.lua
@@ -0,0 +1,161 @@
+local test_env = require("spec.util.test_env")
+local testing_paths = test_env.testing_paths
+local P = test_env.P
+
+local util = require("luarocks.util")
+local core_util = require("luarocks.core.util")
+
+describe("luarocks.util #unit", function()
+   local runner
+
+   setup(function()
+      runner = require("luacov.runner")
+      runner.init(testing_paths.testrun_dir .. "/luacov.config")
+      runner.tick = true
+   end)
+
+   teardown(function()
+      runner.shutdown()
+   end)
+
+   describe("util.variable_substitutions", function()
+      it("replaces variables", function()
+         local t = {
+            ["hello"] = "$(KIND) world",
+         }
+         util.variable_substitutions(t, {
+            ["KIND"] = "happy",
+         })
+         assert.are.same({
+            ["hello"] = "happy world",
+         }, t)
+      end)
+
+      it("missing variables are empty", function()
+         local t = {
+            ["hello"] = "$(KIND) world",
+         }
+         util.variable_substitutions(t, {
+         })
+         assert.are.same({
+            ["hello"] = " world",
+         }, t)
+      end)
+   end)
+
+   describe("util.sortedpairs", function()
+      local function collect(iter, state, var)
+         local collected = {}
+
+         while true do
+            local returns = {iter(state, var)}
+
+            if returns[1] == nil then
+               return collected
+            else
+               table.insert(collected, returns)
+               var = returns[1]
+            end
+         end
+      end
+
+      it("default sort", function()
+         assert.are.same({}, collect(util.sortedpairs({})))
+         assert.are.same({
+            {1, "v1"},
+            {2, "v2"},
+            {3, "v3"},
+            {"bar", "v5"},
+            {"foo", "v4"}
+         }, collect(util.sortedpairs({"v1", "v2", "v3", foo = "v4", bar = "v5"})))
+      end)
+
+      it("sort by function", function()
+         local function compare(a, b) return a > b end
+         assert.are.same({}, collect(util.sortedpairs({}, compare)))
+         assert.are.same({
+            {3, "v3"},
+            {2, "v2"},
+            {1, "v1"}
+         }, collect(util.sortedpairs({"v1", "v2", "v3"}, compare)))
+      end)
+
+      it("sort by priority table", function()
+         assert.are.same({}, collect(util.sortedpairs({}, {"k1", "k2"})))
+         assert.are.same({
+            {"k3", "v3"},
+            {"k2", "v2", {"sub order"}},
+            {"k1", "v1"},
+            {"k4", "v4"},
+            {"k5", "v5"},
+         }, collect(util.sortedpairs({
+            k1 = "v1", k2 = "v2", k3 = "v3", k4 = "v4", k5 = "v5"
+         }, {"k3", {"k2", {"sub order"}}, "k1"})))
+      end)
+   end)
+
+   describe("core.util.show_table", function()
+      it("returns a pretty-printed string containing the representation of the given table", function()
+         local result
+
+         local t1 = {1, 2, 3}
+         result = core_util.show_table(t1)
+         assert.truthy(result:find("[1] = 1", 1, true))
+         assert.truthy(result:find("[2] = 2", 1, true))
+         assert.truthy(result:find("[3] = 3", 1, true))
+
+         local t2 = {a = 1, b = 2, c = 3}
+         result = core_util.show_table(t2)
+         assert.truthy(result:find("[\"a\"] = 1", 1, true))
+         assert.truthy(result:find("[\"b\"] = 2", 1, true))
+         assert.truthy(result:find("[\"c\"] = 3", 1, true))
+
+         local t3 = {a = 1, b = "2", c = {3}}
+         result = core_util.show_table(t3)
+         assert.truthy(result:find("[\"a\"] = 1", 1, true))
+         assert.truthy(result:find("[\"b\"] = \"2\"", 1, true))
+         assert.truthy(result:find("[\"c\"] = {", 1, true))
+         assert.truthy(result:find("[1] = 3", 1, true))
+
+         local t4 = {a = 1, b = {c = 2, d = {e = "4"}}}
+         result = core_util.show_table(t4)
+         assert.truthy(result:find("[\"a\"] = 1", 1, true))
+         assert.truthy(result:find("[\"b\"] = {", 1, true))
+         assert.truthy(result:find("[\"c\"] = 2", 1, true))
+         assert.truthy(result:find("[\"d\"] = {", 1, true))
+         assert.truthy(result:find("[\"e\"] = \"4\"", 1, true))
+      end)
+   end)
+
+   describe("core.util.cleanup_path", function()
+      it("does not change order of existing items of prepended path", function()
+         local sys_path = P'/usr/local/bin;/usr/bin'
+         local lr_path = P'/home/user/.luarocks/bin;/usr/bin'
+         local path = lr_path .. ';' .. sys_path
+
+         local result = core_util.cleanup_path(path, ';', '5.3', false)
+         assert.are.equal(P'/home/user/.luarocks/bin;/usr/local/bin;/usr/bin', result)
+      end)
+
+      it("does not change order of existing items of appended path", function()
+         local sys_path = P'/usr/local/bin;/usr/bin'
+         local lr_path = P'/home/user/.luarocks/bin;/usr/bin'
+         local path = sys_path .. ';' .. lr_path
+
+         local result = core_util.cleanup_path(path, ';', '5.3', true)
+         assert.are.equal(P'/usr/local/bin;/usr/bin;/home/user/.luarocks/bin', result)
+      end)
+
+      it("rewrites versions that do not match the provided version", function()
+         local expected = P'a/b/lua/5.3/?.lua;a/b/c/lua/5.3/?.lua'
+         local result = core_util.cleanup_path(P'a/b/lua/5.2/?.lua;a/b/c/lua/5.3/?.lua', ';', '5.3')
+         assert.are.equal(expected, result)
+      end)
+
+      it("does not rewrite versions for which the provided version is a substring", function()
+         local expected = P'a/b/lua/5.3/?.lua;a/b/c/lua/5.3.4/?.lua'
+         local result = core_util.cleanup_path(P'a/b/lua/5.2/?.lua;a/b/c/lua/5.3.4/?.lua', ';', '5.3')
+         assert.are.equal(expected, result)
+      end)
+   end)
+end)