Tests: unit tests for build.builtin

1 files changed, 454 insertions, 19 deletions

diff --git a/spec/build_spec.lua b/spec/build_spec.lua
index c7fd2a22..03f60d18 100644
--- a/spec/build_spec.lua
+++ b/spec/build_spec.lua
@@ -30,6 +30,18 @@ local extra_rocks = {
    "/validate-args-1.5.4-1.rockspec"
 }
 
+local c_module_source = [[
+   #include <lua.h>
+   #include <lauxlib.h>
+
+   int luaopen_c_module(lua_State* L) {
+     lua_newtable(L);
+     lua_pushinteger(L, 1);
+     lua_setfield(L, -2, "c_module");
+     return 1;
+   }
+]]
+
 describe("LuaRocks build tests #integration", function()
 
    before_each(function()
@@ -60,24 +72,10 @@ describe("LuaRocks build tests #integration", function()
                }
             }
          ]], finally)
-         write_file("c_module.c", [[
-            #include <lua.h>
-            #include <lauxlib.h>
-
-            int luaopen_c_module(lua_State* L) {
-              lua_newtable(L);
-              lua_pushinteger(L, 1);
-              lua_setfield(L, -2, "c_module");
-              return 1;
-            }
-         ]], finally)
+         write_file("c_module.c", c_module_source, finally)
          
          assert.is_true(run.luarocks_bool("build"))
-         if test_env.TEST_TARGET_OS == "windows" then
-            assert.truthy(lfs.attributes(tmpdir .. "/c_module.dll"))
-         else
-            assert.truthy(lfs.attributes(tmpdir .. "/c_module.so"))
-         end
+         assert.truthy(lfs.attributes(tmpdir .. "/c_module." .. test_env.lib_extension))
          
          lfs.chdir(olddir)
          lfs.rmdir(tmpdir)
@@ -284,9 +282,7 @@ describe("LuaRocks build tests #integration", function()
          
          lfs.mkdir("autodetect")
          write_file("autodetect/bla.lua", "return {}", finally)
-         write_file("c_module.c", [[
-            
-         ]], finally)
+         write_file("c_module.c", c_module_source, finally)
       end)
       
       after_each(function()
@@ -454,3 +450,442 @@ describe("LuaRocks build tests #integration", function()
    end)
 
 end)
+
+test_env.unload_luarocks()
+test_env.setup_specs()
+local cfg = require("luarocks.core.cfg")
+local deps = require("luarocks.deps")
+local fs = require("luarocks.fs")
+local path = require("luarocks.path")
+local rockspecs = require("luarocks.rockspecs")
+local build_builtin = require("luarocks.build.builtin")
+
+describe("LuaRocks build tests #unit", function()
+   local runner
+
+   setup(function()
+      runner = require("luacov.runner")
+      runner.init(testing_paths.testrun_dir .. "/luacov.config")
+      runner.tick = true
+      cfg.init()
+      fs.init()
+      deps.check_lua(cfg.variables)
+   end)
+
+   teardown(function()
+      runner.shutdown()
+   end)
+
+   describe("build.builtin", function()
+      describe("builtin.autodetect_external_dependencies", function()
+         it("returns false if the given build table has no external dependencies", function()
+            local build_table = {
+               type = "builtin"
+            }
+
+            assert.falsy(build_builtin.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 = build_builtin.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"
+                  }
+               }
+            }
+            build_builtin.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" }
+                  }
+               }
+            }
+            build_builtin.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" }
+                  }
+               }
+            }
+            build_builtin.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" }
+                  }
+               }
+            }
+            build_builtin.autodetect_external_dependencies(build_table)
+            assert.same(build_table, {
+               type = "builtin",
+               modules = {
+                  module1 = {
+                     libraries = "foo",
+                     incdirs = { "INCDIRS" },
+                     libdirs = { "LIBDIRS" }
+                  }
+               }
+            })
+         end)
+      end)
+
+      describe("builtin.autodetect_modules", function()
+         local tmpdir
+         local olddir
+
+         before_each(function()
+            tmpdir = get_tmp_path()
+            olddir = lfs.currentdir()
+            lfs.mkdir(tmpdir)
+            lfs.chdir(tmpdir)
+            fs.change_dir(tmpdir)
+         end)
+
+         after_each(function()
+            if olddir then
+               lfs.chdir(olddir)
+               if tmpdir then
+                  lfs.rmdir(tmpdir)
+               end
+            end
+         end)
+
+         local libs = { "foo1", "foo2" }
+         local incdirs = { "$(FOO1_INCDIR)", "$(FOO2_INCDIR)" }
+         local libdirs = { "$(FOO1_LIBDIR)", "$(FOO2_LIBDIR)" }
+
+         it("returns a table of the modules having as location the current directory", function()
+            write_file("module1.lua", "", finally)
+            write_file("module2.c", "", finally)
+            write_file("module3.c", "int luaopen_my_module()", finally)
+            write_file("test.lua", "", finally)
+            write_file("tests.lua", "", finally)
+
+            local modules = build_builtin.autodetect_modules(libs, incdirs, libdirs)
+            assert.same(modules, {
+               module1 = "module1.lua",
+               module2 = {
+                  sources = "module2.c",
+                  libraries = libs,
+                  incdirs = incdirs,
+                  libdirs = libdirs
+               },
+               my_module = {
+                  sources = "module3.c",
+                  libraries = libs,
+                  incdirs = incdirs,
+                  libdirs = libdirs
+               }
+            })
+         end)
+
+         local test_with_location = function(location)
+            lfs.mkdir(location)
+            lfs.mkdir(location .. "/dir1")
+            lfs.mkdir(location .. "/dir1/dir2")
+
+            write_file(location .. "/module1.lua", "", finally)
+            write_file(location .. "/dir1/module2.c", "", finally)
+            write_file(location .. "/dir1/dir2/module3.c", "int luaopen_my_module()", finally)
+            write_file(location .. "/test.lua", "", finally)
+            write_file(location .. "/tests.lua", "", finally)
+
+            local modules = build_builtin.autodetect_modules(libs, incdirs, libdirs)
+            assert.same(modules, {
+               module1 = location .. "/module1.lua",
+               ["dir1.module2"] = {
+                  sources = location .. "/dir1/module2.c",
+                  libraries = libs,
+                  incdirs = incdirs,
+                  libdirs = libdirs
+               },
+               my_module = {
+                  sources = location .. "/dir1/dir2/module3.c",
+                  libraries = libs,
+                  incdirs = incdirs,
+                  libdirs = libdirs
+               }
+            })
+
+            lfs.rmdir(location .. "/dir1/dir2")
+            lfs.rmdir(location .. "/dir1")
+            lfs.rmdir(location)
+         end
+
+         it("returns a table of the modules having as location the src directory", function()
+            test_with_location("src")
+         end)
+
+         it("returns a table of the modules having as location the lua directory", function()
+            test_with_location("lua")
+         end)
+
+         it("returns as second and third argument tables of the bin files and copy directories", function()
+            lfs.mkdir("doc")
+            lfs.mkdir("docs")
+            lfs.mkdir("samples")
+            lfs.mkdir("tests")
+            lfs.mkdir("bin")
+            write_file("bin/binfile", "", finally)
+
+            local _, install, copy_directories = build_builtin.autodetect_modules({}, {}, {})
+            assert.same(install, { bin = { "bin/binfile" } })
+            assert.same(copy_directories, { "doc", "docs", "samples", "tests" })
+
+            lfs.rmdir("doc")
+            lfs.rmdir("docs")
+            lfs.rmdir("samples")
+            lfs.rmdir("tests")
+            lfs.rmdir("bin")
+         end)
+      end)
+
+      describe("builtin.run", function()
+         local tmpdir
+         local olddir
+
+         before_each(function()
+            tmpdir = get_tmp_path()
+            olddir = lfs.currentdir()
+            lfs.mkdir(tmpdir)
+            lfs.chdir(tmpdir)
+            fs.change_dir(tmpdir)
+            path.use_tree(lfs.currentdir())
+         end)
+
+         after_each(function()
+            if olddir then
+               lfs.chdir(olddir)
+               if tmpdir then
+                  lfs.rmdir(tmpdir)
+               end
+            end
+         end)
+
+         it("returns false if the rockspec has no build modules and its format does not support autoextraction", function()
+            local rockspec = {
+               package = "test",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/test"
+               },
+               build = {}
+            }
+
+            rockspecs.from_persisted_table("test-1.0-1.rockspec", rockspec)
+            assert.falsy(build_builtin.run(rockspec))
+            rockspec.rockspec_format = "1.0"
+            assert.falsy(build_builtin.run(rockspec))
+         end)
+
+         it("returns false if lua.h could not be found", function()
+            local rockspec = {
+               package = "c_module",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/c_module"
+               },
+               build = {
+                  type = "builtin",
+                  modules = {
+                     c_module = "c_module.c"
+                  }
+               }
+            }
+            write_file("c_module.c", c_module_source, finally)
+
+            rockspecs.from_persisted_table("c_module-1.0-1.rockspec", rockspec)
+            rockspec.variables = { LUA_INCDIR = "invalid" }
+            assert.falsy(build_builtin.run(rockspec))
+         end)
+
+         it("returns false if the build fails", function()
+            local rockspec = {
+               package = "c_module",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/c_module"
+               },
+               build = {
+                  type = "builtin",
+                  modules = {
+                     c_module = "c_module.c"
+                  }
+               }
+            }
+            write_file("c_module.c", c_module_source .. "invalid", finally)
+
+            rockspecs.from_persisted_table("c_module-1.0-1.rockspec", rockspec)
+            assert.falsy(build_builtin.run(rockspec))
+         end)
+
+         it("returns true if the build succeeds with C module", function()
+            local rockspec = {
+               package = "c_module",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/c_module"
+               },
+               build = {
+                  type = "builtin",
+                  modules = {
+                     c_module = "c_module.c"
+                  }
+               }
+            }
+            write_file("c_module.c", c_module_source, finally)
+
+            rockspecs.from_persisted_table("c_module-1.0-1.rockspec", rockspec)
+            assert.truthy(build_builtin.run(rockspec))
+            assert.truthy(lfs.attributes("lib/luarocks/rocks-" .. test_env.lua_version .. "/c_module/1.0-1/lib/c_module." .. test_env.lib_extension))
+         end)
+
+         it("returns true if the build succeeds with Lua module", function()
+            local rockspec = {
+               rockspec_format = "1.0",
+               package = "test",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/test"
+               },
+               build = {
+                  type = "builtin",
+                  modules = {
+                     test = "test.lua"
+                  }
+               }
+            }
+            write_file("test.lua", "return {}", finally)
+
+            rockspecs.from_persisted_table("test-1.0-1.rockspec", rockspec)
+            assert.truthy(build_builtin.run(rockspec))
+            assert.truthy(lfs.attributes("lib/luarocks/rocks-" .. test_env.lua_version .. "/test/1.0-1/lua/test.lua"))
+         end)
+
+         it("automatically extracts the modules and libraries if they are not given and builds against any external dependencies", function()
+            local ssllib = "ssl"
+            if test_env.TEST_TARGET_OS == "windows" then
+               if test_env.MINGW then
+                  ssllib = "eay32"
+               else
+                  ssllib = "ssleay32"
+               end
+            end
+
+            local rockspec = {
+               rockspec_format = "3.0",
+               package = "c_module",
+               version = "1.0-1",
+               source = {
+                  url = "http://example.com/c_module"
+               },
+               external_dependencies = {
+                  OPENSSL = {
+                     library = ssllib -- Use OpenSSL since it is available on all testing platforms
+                  }
+               },
+               build = {
+                  type = "builtin"
+               }
+            }
+            write_file("c_module.c", c_module_source, finally)
+
+            rockspecs.from_persisted_table("c_module-1.0-1.rockspec", rockspec)
+            rockspec.variables["OPENSSL_INCDIR"] = test_env.OPENSSL_INCDIR
+            rockspec.variables["OPENSSL_LIBDIR"] = test_env.OPENSSL_LIBDIR
+            assert.truthy(build_builtin.run(rockspec))
+         end)
+
+         it("returns false if any external dependency is missing", function()
+            local rockspec = {
+               rockspec_format = "3.0",
+               package = "c_module",
+               version = "1.0-1",
+               source = {
+                  url = "https://example.com/c_module"
+               },
+               external_dependencies = {
+                  EXTDEP = {
+                    library = "missing"
+                  }
+               },
+               build = {
+                  type = "builtin"
+               }
+            }
+            write_file("c_module.c", c_module_source, finally)
+
+            rockspecs.from_persisted_table("c_module-1.0-1.rockspec", rockspec)
+            rockspec.variables["EXTDEP_INCDIR"] = lfs.currentdir()
+            rockspec.variables["EXTDEP_LIBDIR"] = lfs.currentdir()
+            assert.falsy(build_builtin.run(rockspec))
+         end)
+      end)
+   end)
+end)
+