tests: add some mason-core.package tests (#69)

1 files changed, 159 insertions, 0 deletions

diff --git a/tests/mason-core/package/package_spec.lua b/tests/mason-core/package/package_spec.lua
new file mode 100644
index 00000000..113d8d1b
--- /dev/null
+++ b/tests/mason-core/package/package_spec.lua
@@ -0,0 +1,159 @@
+local spy = require "luassert.spy"
+local mock = require "luassert.mock"
+local stub = require "luassert.stub"
+local match = require "luassert.match"
+local Pkg = require "mason-core.package"
+local registry = require "mason-registry"
+local Result = require "mason-core.result"
+
+describe("package", function()
+    before_each(function()
+        package.loaded["dummy_package"] = nil
+    end)
+
+    it("should parse package specifiers", function()
+        local function parse(str)
+            local name, version = Pkg.Parse(str)
+            return { name, version }
+        end
+
+        assert.same({ "rust-analyzer", nil }, parse "rust-analyzer")
+        assert.same({ "rust-analyzer", "" }, parse "rust-analyzer@")
+        assert.same({ "rust-analyzer", "nightly" }, parse "rust-analyzer@nightly")
+    end)
+
+    it("should validate spec", function()
+        local valid_spec = {
+            name = "Package name",
+            desc = "Package description",
+            homepage = "https://example.com",
+            categories = { Pkg.Cat.LSP },
+            languages = { Pkg.Lang.Rust },
+            install = function() end,
+        }
+        local function spec(fields)
+            return setmetatable(fields, { __index = valid_spec })
+        end
+        assert.equals(
+            "name: expected string, got number",
+            assert.error(function()
+                Pkg.new(spec { name = 23 })
+            end)
+        )
+
+        assert.equals(
+            "desc: expected string, got number",
+            assert.error(function()
+                Pkg.new(spec { desc = 23 })
+            end)
+        )
+
+        assert.equals(
+            "homepage: expected string, got number",
+            assert.error(function()
+                Pkg.new(spec { homepage = 23 })
+            end)
+        )
+
+        assert.equals(
+            "categories: expected table, got number",
+            assert.error(function()
+                Pkg.new(spec { categories = 23 })
+            end)
+        )
+
+        assert.equals(
+            "languages: expected table, got number",
+            assert.error(function()
+                Pkg.new(spec { languages = 23 })
+            end)
+        )
+
+        assert.equals(
+            "install: expected function, got number",
+            assert.error(function()
+                Pkg.new(spec { install = 23 })
+            end)
+        )
+    end)
+
+    it("should create new handle", function()
+        ---@type Package
+        local dummy = registry.get_package "dummy"
+        -- yo dawg
+        local handle_handler = spy.new()
+        dummy:once("handle", handle_handler)
+        local handle = dummy:new_handle()
+        assert.spy(handle_handler).was_called(1)
+        assert.spy(handle_handler).was_called_with(match.ref(handle))
+    end)
+
+    it("should not create new handle if one already exists", function()
+        ---@type Package
+        local dummy = registry.get_package "dummy"
+        dummy.handle = mock.new {
+            is_closed = mockx.returns(false),
+        }
+        local handle_handler = spy.new()
+        dummy:once("handle", handle_handler)
+        local err = assert.error(function()
+            dummy:new_handle()
+        end)
+        assert.equals("Cannot create new handle because existing handle is not closed.", err)
+        assert.spy(handle_handler).was_called(0)
+    end)
+
+    it("should successfully install package", function()
+        local installer = require "mason-core.installer"
+        stub(installer, "execute")
+        installer.execute.returns(Result.success "Yay!")
+        ---@type Package
+        local dummy = registry.get_package "dummy"
+        local package_install_success_handler = spy.new()
+        local package_install_failed_handler = spy.new()
+        local install_success_handler = spy.new()
+        local install_failed_handler = spy.new()
+        registry:once("package:install:success", package_install_success_handler)
+        registry:once("package:install:failed", package_install_failed_handler)
+        dummy:once("install:success", install_success_handler)
+        dummy:once("install:failed", install_failed_handler)
+
+        local handle = dummy:install { version = "1337" }
+
+        assert.spy(installer.execute).was_called(1)
+        assert.spy(installer.execute).was_called_with(match.is_ref(handle), { requested_version = "1337" })
+        assert.spy(install_success_handler).was_called(1)
+        assert.spy(install_success_handler).was_called_with(match.is_ref(handle))
+        assert.spy(package_install_success_handler).was_called(1)
+        assert.spy(package_install_success_handler).was_called_with(match.is_ref(dummy), match.is_ref(handle))
+        assert.spy(package_install_failed_handler).was_called(0)
+        assert.spy(install_failed_handler).was_called(0)
+    end)
+
+    it("should fail to install package", function()
+        local installer = require "mason-core.installer"
+        stub(installer, "execute")
+        installer.execute.returns(Result.failure "Oh no.")
+        ---@type Package
+        local dummy = registry.get_package "dummy"
+        local package_install_success_handler = spy.new()
+        local package_install_failed_handler = spy.new()
+        local install_success_handler = spy.new()
+        local install_failed_handler = spy.new()
+        registry:once("package:install:success", package_install_success_handler)
+        registry:once("package:install:failed", package_install_failed_handler)
+        dummy:once("install:success", install_success_handler)
+        dummy:once("install:failed", install_failed_handler)
+
+        local handle = dummy:install { version = "1337" }
+
+        assert.spy(installer.execute).was_called(1)
+        assert.spy(installer.execute).was_called_with(match.is_ref(handle), { requested_version = "1337" })
+        assert.spy(install_failed_handler).was_called(1)
+        assert.spy(install_failed_handler).was_called_with(match.is_ref(handle))
+        assert.spy(package_install_failed_handler).was_called(1)
+        assert.spy(package_install_failed_handler).was_called_with(match.is_ref(dummy), match.is_ref(handle))
+        assert.spy(package_install_success_handler).was_called(0)
+        assert.spy(install_success_handler).was_called(0)
+    end)
+end)