From fa78d7cf0445083243cdd8feee4923f99d984e30 Mon Sep 17 00:00:00 2001 From: William Boman Date: Wed, 13 Jul 2022 16:21:16 +0200 Subject: tests: add some InstallHandle tests (#67) --- tests/mason-core/installer/handle_spec.lua | 100 ++++++++++++++++++++++++++ tests/mason-core/installer/installer_spec.lua | 100 ++++++++++++++++++++++++++ tests/mason-core/installer_spec.lua | 100 -------------------------- 3 files changed, 200 insertions(+), 100 deletions(-) create mode 100644 tests/mason-core/installer/handle_spec.lua create mode 100644 tests/mason-core/installer/installer_spec.lua delete mode 100644 tests/mason-core/installer_spec.lua (limited to 'tests/mason-core') 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) diff --git a/tests/mason-core/installer_spec.lua b/tests/mason-core/installer_spec.lua deleted file mode 100644 index 8dc9b516..00000000 --- a/tests/mason-core/installer_spec.lua +++ /dev/null @@ -1,100 +0,0 @@ -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) -- cgit v1.2.3-70-g09d2