tests: add some InstallHandle tests (#67)

2 files changed, 200 insertions, 0 deletions

diff --git a/tests/mason-core/installer/handle_spec.lua b/tests/mason-core/installer/handle_spec.lua
new file mode 100644
index 00000000..02fcc358
--- /dev/null
+++ b/tests/mason-core/installer/handle_spec.lua
@@ -0,0 +1,100 @@
+local a = require "mason-core.async"
+local mock = require "luassert.mock"
+local stub = require "luassert.stub"
+local spy = require "luassert.spy"
+local InstallHandle = require "mason-core.installer.handle"
+
+describe("installer handle", function()
+    it("should register spawn handle", function()
+        local handle = InstallHandle.new(mock.new {})
+        local spawn_handle_change_handler = spy.new()
+        handle:once("spawn_handles:change", spawn_handle_change_handler)
+        local luv_handle = mock.new {}
+        handle:register_spawn_handle(luv_handle, 1337, "tar", { "-xvf", "file" })
+        assert.same({
+            uv_handle = luv_handle,
+            pid = 1337,
+            cmd = "tar",
+            args = { "-xvf", "file" },
+        }, handle:peek_spawn_handle():get())
+        assert.spy(spawn_handle_change_handler).was_called(1)
+    end)
+
+    it("should deregister spawn handle", function()
+        local handle = InstallHandle.new(mock.new {})
+        local spawn_handle_change_handler = spy.new()
+        handle:once("spawn_handles:change", spawn_handle_change_handler)
+        local luv_handle1 = mock.new {}
+        local luv_handle2 = mock.new {}
+        handle:register_spawn_handle(luv_handle1, 42, "curl", { "someurl" })
+        handle:register_spawn_handle(luv_handle2, 1337, "tar", { "-xvf", "file" })
+        assert.is_true(handle:deregister_spawn_handle(luv_handle1))
+        assert.equals(1, #handle.spawn_handles)
+        assert.same({
+            uv_handle = luv_handle2,
+            pid = 1337,
+            cmd = "tar",
+            args = { "-xvf", "file" },
+        }, handle:peek_spawn_handle():get())
+        assert.spy(spawn_handle_change_handler).was_called(3)
+    end)
+
+    it("should change state", function()
+        local handle = InstallHandle.new(mock.new {})
+        local state_change_handler = spy.new()
+        handle:once("state:change", state_change_handler)
+        handle:set_state "QUEUED"
+        assert.equals("QUEUED", handle.state)
+        assert.spy(state_change_handler).was_called(1)
+        assert.spy(state_change_handler).was_called_with("QUEUED", "IDLE")
+    end)
+
+    it("should send signals to registered handles", function()
+        local process = require "mason-core.process"
+        stub(process, "kill")
+        local uv_handle = {}
+        local handle = InstallHandle.new(mock.new {})
+        local kill_handler = spy.new()
+        handle:once("kill", kill_handler)
+        handle.state = "ACTIVE"
+        handle.spawn_handles = { { uv_handle = uv_handle } }
+
+        handle:kill(9)
+        assert.spy(process.kill).was_called(1)
+        assert.spy(process.kill).was_called_with(uv_handle, 9)
+        assert.spy(kill_handler).was_called(1)
+        assert.spy(kill_handler).was_called_with(9)
+    end)
+
+    it(
+        "should terminate handle",
+        async_test(function()
+            local process = require "mason-core.process"
+            stub(process, "kill")
+            local uv_handle1 = {}
+            local uv_handle2 = {}
+            local handle = InstallHandle.new(mock.new {})
+            local kill_handler = spy.new()
+            local terminate_handler = spy.new()
+            local closed_handler = spy.new()
+            handle:once("kill", kill_handler)
+            handle:once("terminate", terminate_handler)
+            handle:once("closed", closed_handler)
+            handle.state = "ACTIVE"
+            handle.spawn_handles = { { uv_handle = uv_handle2 }, { uv_handle = uv_handle2 } }
+
+            handle:terminate()
+            assert.spy(process.kill).was_called(2)
+            assert.spy(process.kill).was_called_with(uv_handle1, 15)
+            assert.spy(process.kill).was_called_with(uv_handle2, 15)
+            assert.spy(kill_handler).was_called(1)
+            assert.spy(kill_handler).was_called_with(15)
+            assert.spy(terminate_handler).was_called(1)
+            assert.is_true(handle.is_terminated)
+            assert.wait_for(function()
+                assert.is_true(handle:is_closed())
+                assert.spy(closed_handler).was_called(1)
+            end)
+        end)
+    )
+end)
diff --git a/tests/mason-core/installer/installer_spec.lua b/tests/mason-core/installer/installer_spec.lua
new file mode 100644
index 00000000..8dc9b516
--- /dev/null
+++ b/tests/mason-core/installer/installer_spec.lua
@@ -0,0 +1,100 @@
+local spy = require "luassert.spy"
+local match = require "luassert.match"
+local fs = require "mason-core.fs"
+local a = require "mason-core.async"
+local path = require "mason-core.path"
+local installer = require "mason-core.installer"
+local InstallContext = require "mason-core.installer.context"
+
+local function timestamp()
+    local seconds, microseconds = vim.loop.gettimeofday()
+    return (seconds * 1000) + math.floor(microseconds / 1000)
+end
+
+describe("installer", function()
+    before_each(function()
+        package.loaded["dummy_package"] = nil
+    end)
+
+    it(
+        "should call installer",
+        async_test(function()
+            spy.on(fs.async, "mkdirp")
+            spy.on(fs.async, "rename")
+
+            local handle = InstallHandleGenerator "dummy"
+            spy.on(handle.package.spec, "install")
+            local result = installer.execute(handle, {})
+
+            assert.is_nil(result:err_or_nil())
+            assert.spy(handle.package.spec.install).was_called(1)
+            assert.spy(handle.package.spec.install).was_called_with(match.instanceof(InstallContext))
+            assert.spy(fs.async.mkdirp).was_called_with(path.package_build_prefix "dummy")
+            assert.spy(fs.async.rename).was_called_with(path.package_build_prefix "dummy", path.package_prefix "dummy")
+        end)
+    )
+
+    it(
+        "should return failure if installer errors",
+        async_test(function()
+            spy.on(fs.async, "rmrf")
+            spy.on(fs.async, "rename")
+            local installer_fn = spy.new(function()
+                error("something went wrong. don't try again.", 0)
+            end)
+            local handler = InstallHandleGenerator "dummy"
+            handler.package.spec.install = installer_fn
+            local result = installer.execute(handler, {})
+            assert.spy(installer_fn).was_called(1)
+            assert.is_true(result:is_failure())
+            assert.is_true(match.has_match "^.*: something went wrong. don't try again.$"(result:err_or_nil()))
+            assert.spy(fs.async.rmrf).was_called_with(path.package_build_prefix "dummy")
+            assert.spy(fs.async.rename).was_not_called()
+        end)
+    )
+
+    it(
+        "should write receipt",
+        async_test(function()
+            spy.on(fs.async, "write_file")
+            local handle = InstallHandleGenerator "dummy"
+            installer.execute(handle, {})
+            assert.spy(fs.async.write_file).was_called(1)
+            assert
+                .spy(fs.async.write_file)
+                .was_called_with(("%s/mason-receipt.json"):format(handle.package:get_install_path()), match.is_string())
+        end)
+    )
+
+    it(
+        "should run async functions concurrently",
+        async_test(function()
+            spy.on(fs.async, "write_file")
+            local capture = spy.new()
+            local start = timestamp()
+            local handle = InstallHandleGenerator "dummy"
+            handle.package.spec.install = function(ctx)
+                capture(installer.run_concurrently {
+                    function()
+                        a.sleep(100)
+                        return installer.context()
+                    end,
+                    function()
+                        a.sleep(100)
+                        return "two"
+                    end,
+                    function()
+                        a.sleep(100)
+                        return "three"
+                    end,
+                })
+                ctx.receipt:with_primary_source { type = "dummy" }
+            end
+            installer.execute(handle, {})
+            local stop = timestamp()
+            local grace_ms = 25
+            assert.is_true((stop - start) >= (100 - grace_ms))
+            assert.spy(capture).was_called_with(match.instanceof(InstallContext), "two", "three")
+        end)
+    )
+end)