diff options
Diffstat (limited to 'tests/core')
32 files changed, 0 insertions, 3635 deletions
diff --git a/tests/core/async_spec.lua b/tests/core/async_spec.lua deleted file mode 100644 index 8bb74bfa..00000000 --- a/tests/core/async_spec.lua +++ /dev/null @@ -1,198 +0,0 @@ -local assert = require "luassert" -local spy = require "luassert.spy" -local match = require "luassert.match" -local a = require "mason.core.async" -local process = require "mason.core.process" - -local function timestamp() - local seconds, microseconds = vim.loop.gettimeofday() - return (seconds * 1000) + math.floor(microseconds / 1000) -end - -describe("async", function() - it("should run in blocking mode", function() - local start = timestamp() - a.run_blocking(function() - a.sleep(100) - end) - local stop = timestamp() - local grace_ms = 50 - assert.is_true((stop - start) >= (100 - grace_ms)) - end) - - it("should return values in blocking mode", function() - local function slow_maths(arg1, arg2) - a.sleep(10) - return arg1 + arg2 - 42 - end - local value = a.run_blocking(slow_maths, 13, 37) - assert.equals(8, value) - end) - - it( - "should pass arguments to .run", - async_test(function() - local callback = spy.new() - local start = timestamp() - a.run(a.sleep, callback, 100) - assert.wait_for(function() - assert.spy(callback).was_called(1) - local stop = timestamp() - local grace_ms = 25 - assert.is_true((stop - start) >= (100 - grace_ms)) - end, 150) - end) - ) - - it( - "should wrap callback-style async functions", - async_test(function() - local stdio = process.in_memory_sink() - local success, exit_code = a.promisify(process.spawn)("env", { - args = {}, - env = { "FOO=BAR", "BAR=BAZ" }, - stdio_sink = stdio.sink, - }) - assert.is_true(success) - assert.equals(0, exit_code) - assert.equals("FOO=BAR\nBAR=BAZ\n", table.concat(stdio.buffers.stdout, "")) - end) - ) - - it( - "should reject callback-style functions", - async_test(function() - local err = assert.has_error(function() - a.promisify(function(arg1, cb) - cb(arg1, nil) - end, true) "påskmust" - end) - assert.equals(err, "påskmust") - end) - ) - - it( - "should return all values", - async_test(function() - local val1, val2, val3 = a.wait(function(resolve) - resolve(1, 2, 3) - end) - assert.equals(1, val1) - assert.equals(2, val2) - assert.equals(3, val3) - end) - ) - - it( - "should cancel coroutine", - async_test(function() - local james_bond = spy.new() - local poutine = a.scope(function() - a.sleep(100) - james_bond() - end)() - poutine() - a.sleep(200) - assert.spy(james_bond).was_not.called() - end) - ) - - it( - "should raise error if async function raises error", - async_test(function() - local err = assert.has.errors(a.promisify(function() - error "something went wrong" - end)) - assert.is_true(match.has_match "something went wrong$"(err)) - end) - ) - - it( - "should raise error if async function rejects", - async_test(function() - local err = assert.has.errors(function() - a.wait(function(_, reject) - reject "This is an error" - end) - end) - assert.equals("This is an error", err) - end) - ) - - it( - "should pass nil arguments to promisified functions", - async_test(function() - local fn = spy.new(function(_, _, _, _, _, _, _, cb) - cb() - end) - a.promisify(fn)(nil, 2, nil, 4, nil, nil, 7) - assert.spy(fn).was_called_with(nil, 2, nil, 4, nil, nil, 7, match.is_function()) - end) - ) - - it("should accept yielding non-promise values to parent coroutine context", function() - local thread = coroutine.create(function(val) - a.run_blocking(function() - coroutine.yield(val) - end) - end) - local ok, value = coroutine.resume(thread, 1337) - assert.is_true(ok) - assert.equals(1337, value) - end) - - it( - "should run all suspending functions concurrently", - async_test(function() - local start = timestamp() - local function sleep(ms, ret_val) - return function() - a.sleep(ms) - return ret_val - end - end - local one, two, three, four, five = a.wait_all { - sleep(100, 1), - sleep(100, "two"), - sleep(100, "three"), - sleep(100, 4), - sleep(100, 5), - } - local grace = 50 - local delta = timestamp() - start - assert.is_true(delta <= (100 + grace)) - assert.is_true(delta >= (100 - grace)) - assert.equals(1, one) - assert.equals("two", two) - assert.equals("three", three) - assert.equals(4, four) - assert.equals(5, five) - end) - ) - - it( - "should run all suspending functions concurrently", - async_test(function() - local start = timestamp() - local called = spy.new() - local function sleep(ms, ret_val) - return function() - a.sleep(ms) - called() - return ret_val - end - end - local first = a.wait_first { - sleep(150, 1), - sleep(50, "first"), - sleep(150, "three"), - sleep(150, 4), - sleep(150, 5), - } - local grace = 20 - local delta = timestamp() - start - assert.is_true(delta <= (50 + grace)) - assert.equals("first", first) - end) - ) -end) diff --git a/tests/core/clients/eclipse_spec.lua b/tests/core/clients/eclipse_spec.lua deleted file mode 100644 index 4a013c48..00000000 --- a/tests/core/clients/eclipse_spec.lua +++ /dev/null @@ -1,10 +0,0 @@ -local eclipse = require "mason.core.clients.eclipse" - -describe("eclipse client", function() - it("parses jdtls version strings", function() - assert.equal( - "1.8.0-202112170540", - eclipse._parse_jdtls_version_string "jdt-language-server-1.8.0-202112170540.tar.gz" - ) - end) -end) diff --git a/tests/core/fetch_spec.lua b/tests/core/fetch_spec.lua deleted file mode 100644 index e2506f89..00000000 --- a/tests/core/fetch_spec.lua +++ /dev/null @@ -1,106 +0,0 @@ -local stub = require "luassert.stub" -local match = require "luassert.match" -local fetch = require "mason.core.fetch" -local spawn = require "mason.core.spawn" -local Result = require "mason.core.result" - -describe("fetch", function() - it( - "should exhaust all candidates", - async_test(function() - stub(spawn, "wget") - stub(spawn, "curl") - spawn.wget.returns(Result.failure "wget failure") - spawn.curl.returns(Result.failure "curl failure") - - local result = fetch("https://api.github.com", { - headers = { ["X-Custom-Header"] = "here" }, - }) - assert.is_true(result:is_failure()) - assert.spy(spawn.wget).was_called(1) - assert.spy(spawn.curl).was_called(1) - assert.spy(spawn.wget).was_called_with { - { - "--header='User-Agent: mason.nvim (+https://github.com/williamboman/mason.nvim)'", - "--header='X-Custom-Header: here'", - }, - "-nv", - "-O", - "-", - "--method=GET", - vim.NIL, -- body-data - "https://api.github.com", - } - - assert.spy(spawn.curl).was_called_with(match.tbl_containing { - match.same { - { - "-H", - "User-Agent: mason.nvim (+https://github.com/williamboman/mason.nvim)", - }, - { - "-H", - "X-Custom-Header: here", - }, - }, - "-fsSL", - match.same { "-X", "GET" }, - vim.NIL, -- data - vim.NIL, -- out file - "https://api.github.com", - on_spawn = match.is_function(), - }) - end) - ) - - it( - "should return stdout", - async_test(function() - stub(spawn, "wget") - spawn.wget.returns(Result.success { - stdout = [[{"data": "here"}]], - }) - local result = fetch "https://api.github.com/data" - assert.is_true(result:is_success()) - assert.equals([[{"data": "here"}]], result:get_or_throw()) - end) - ) - - it( - "should respect out_file opt", - async_test(function() - stub(spawn, "wget") - stub(spawn, "curl") - spawn.wget.returns(Result.failure "wget failure") - spawn.curl.returns(Result.failure "curl failure") - fetch("https://api.github.com/data", { out_file = "/test.json" }) - - assert.spy(spawn.wget).was_called_with { - { - "--header='User-Agent: mason.nvim (+https://github.com/williamboman/mason.nvim)'", - }, - "-nv", - "-O", - "/test.json", - "--method=GET", - vim.NIL, -- body-data - "https://api.github.com/data", - } - - assert.spy(spawn.curl).was_called_with(match.tbl_containing { - match.same { - { - "-H", - "User-Agent: mason.nvim (+https://github.com/williamboman/mason.nvim)", - }, - }, - "-fsSL", - match.same { "-X", "GET" }, - vim.NIL, -- data - match.same { "-o", "/test.json" }, - "https://api.github.com/data", - on_spawn = match.is_function(), - }) - end) - ) -end) diff --git a/tests/core/fs_spec.lua b/tests/core/fs_spec.lua deleted file mode 100644 index 9fa59189..00000000 --- a/tests/core/fs_spec.lua +++ /dev/null @@ -1,24 +0,0 @@ -local fs = require "mason.core.fs" -local mason = require "mason" - -describe("fs", function() - before_each(function() - mason.setup { - install_root_dir = "/foo", - } - end) - - it( - "refuses to rmrf paths outside of boundary", - async_test(function() - local e = assert.has.errors(function() - fs.async.rmrf "/thisisa/path" - end) - - assert.equal( - [[Refusing to rmrf "/thisisa/path" which is outside of the allowed boundary "/foo". Please report this error at https://github.com/williamboman/mason.nvim/issues/new]], - e - ) - end) - ) -end) diff --git a/tests/core/functional/data_spec.lua b/tests/core/functional/data_spec.lua deleted file mode 100644 index cdc26809..00000000 --- a/tests/core/functional/data_spec.lua +++ /dev/null @@ -1,28 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: data", function() - it("creates enums", function() - local colors = _.enum { - "BLUE", - "YELLOW", - } - assert.same({ - ["BLUE"] = "BLUE", - ["YELLOW"] = "YELLOW", - }, colors) - end) - - it("creates sets", function() - local colors = _.set_of { - "BLUE", - "YELLOW", - "BLUE", - "RED", - } - assert.same({ - ["BLUE"] = true, - ["YELLOW"] = true, - ["RED"] = true, - }, colors) - end) -end) diff --git a/tests/core/functional/function_spec.lua b/tests/core/functional/function_spec.lua deleted file mode 100644 index 21951dc3..00000000 --- a/tests/core/functional/function_spec.lua +++ /dev/null @@ -1,142 +0,0 @@ -local spy = require "luassert.spy" -local match = require "luassert.match" -local _ = require "mason.core.functional" - -describe("functional: function", function() - it("curries functions", function() - local function sum(...) - local res = 0 - for i = 1, select("#", ...) do - res = res + select(i, ...) - end - return res - end - local arity0 = _.curryN(sum, 0) - local arity1 = _.curryN(sum, 1) - local arity2 = _.curryN(sum, 2) - local arity3 = _.curryN(sum, 3) - - assert.equals(0, arity0(42)) - assert.equals(42, arity1(42)) - assert.equals(3, arity2(1)(2)) - assert.equals(3, arity2(1, 2)) - assert.equals(6, arity3(1)(2)(3)) - assert.equals(6, arity3(1, 2, 3)) - - -- should discard superfluous args - assert.equals(0, arity1(0, 10, 20, 30)) - end) - - it("coalesces first non-nil value", function() - assert.equal("Hello World!", _.coalesce(nil, nil, "Hello World!", "")) - end) - - it("should compose functions", function() - local function add(x) - return function(y) - return y + x - end - end - local function subtract(x) - return function(y) - return y - x - end - end - local function multiply(x) - return function(y) - return y * x - end - end - - local big_maths = _.compose(add(1), subtract(3), multiply(5)) - - assert.equals(23, big_maths(5)) - end) - - it("should not allow composing no functions", function() - local e = assert.error(function() - _.compose() - end) - assert.equals("compose requires at least one function", e) - end) - - it("should partially apply functions", function() - local funcy = spy.new() - local partially_funcy = _.partial(funcy, "a", "b", "c") - partially_funcy("d", "e", "f") - assert.spy(funcy).was_called_with("a", "b", "c", "d", "e", "f") - end) - - it("should partially apply functions with nil arguments", function() - local funcy = spy.new() - local partially_funcy = _.partial(funcy, "a", nil, "c") - partially_funcy("d", nil, "f") - assert.spy(funcy).was_called_with("a", nil, "c", "d", nil, "f") - end) - - it("memoizes functions with default cache mechanism", function() - local expensive_function = spy.new(function(s) - return s - end) - local memoized_fn = _.memoize(expensive_function) - assert.equal("key", memoized_fn "key") - assert.equal("key", memoized_fn "key") - assert.equal("new_key", memoized_fn "new_key") - assert.spy(expensive_function).was_called(2) - end) - - it("memoizes function with custom cache mechanism", function() - local expensive_function = spy.new(function(arg1, arg2) - return arg1 .. arg2 - end) - local memoized_fn = _.memoize(expensive_function, function(arg1, arg2) - return arg1 .. arg2 - end) - assert.equal("key1key2", memoized_fn("key1", "key2")) - assert.equal("key1key2", memoized_fn("key1", "key2")) - assert.equal("key1key3", memoized_fn("key1", "key3")) - assert.spy(expensive_function).was_called(2) - end) - - it("should evaluate functions lazily", function() - local impl = spy.new(function() - return {}, {} - end) - local lazy_fn = _.lazy(impl) - assert.spy(impl).was_called(0) - local a, b = lazy_fn() - assert.spy(impl).was_called(1) - assert.is_true(match.is_table()(a)) - assert.is_true(match.is_table()(b)) - local new_a, new_b = lazy_fn() - assert.spy(impl).was_called(1) - assert.is_true(match.is_ref(a)(new_a)) - assert.is_true(match.is_ref(b)(new_b)) - end) - - it("should support nil return values in lazy functions", function() - local lazy_fn = _.lazy(function() - return nil, 2 - end) - local a, b = lazy_fn() - assert.is_nil(a) - assert.equal(2, b) - end) - - it("should provide identity value", function() - local obj = {} - assert.equals(2, _.identity(2)) - assert.equals(obj, _.identity(obj)) - end) - - it("should always return bound value", function() - local obj = {} - assert.equals(2, _.always(2)()) - assert.equals(obj, _.always(obj)()) - end) - - it("true is true and false is false", function() - assert.is_true(_.T()) - assert.is_false(_.F()) - end) -end) diff --git a/tests/core/functional/list_spec.lua b/tests/core/functional/list_spec.lua deleted file mode 100644 index a03fee68..00000000 --- a/tests/core/functional/list_spec.lua +++ /dev/null @@ -1,193 +0,0 @@ -local spy = require "luassert.spy" -local _ = require "mason.core.functional" -local Optional = require "mason.core.optional" - -describe("functional: list", function() - it("should produce list without nils", function() - assert.same({ 1, 2, 3, 4 }, _.list_not_nil(nil, 1, 2, nil, 3, nil, 4, nil)) - end) - - it("makes a shallow copy of a list", function() - local list = { "BLUE", { nested = "TABLE" }, "RED" } - local list_copy = _.list_copy(list) - assert.same({ "BLUE", { nested = "TABLE" }, "RED" }, list_copy) - assert.is_not.is_true(list == list_copy) - assert.is_true(list[2] == list_copy[2]) - end) - - it("reverses lists", function() - local colors = { "BLUE", "YELLOW", "RED" } - assert.same({ - "RED", - "YELLOW", - "BLUE", - }, _.reverse(colors)) - -- should not modify in-place - assert.same({ "BLUE", "YELLOW", "RED" }, colors) - end) - - it("maps over list", function() - local colors = { "BLUE", "YELLOW", "RED" } - assert.same( - { - "LIGHT_BLUE", - "LIGHT_YELLOW", - "LIGHT_RED", - }, - _.map(function(color) - return "LIGHT_" .. color - end, colors) - ) - -- should not modify in-place - assert.same({ "BLUE", "YELLOW", "RED" }, colors) - end) - - it("filter_map over list", function() - local colors = { "BROWN", "BLUE", "YELLOW", "GREEN", "CYAN" } - assert.same( - { - "BROWN EYES", - "BLUE EYES", - "GREEN EYES", - }, - _.filter_map(function(color) - if _.any_pass({ _.equals "BROWN", _.equals "BLUE", _.equals "GREEN" }, color) then - return Optional.of(("%s EYES"):format(color)) - else - return Optional.empty() - end - end, colors) - ) - end) - - it("finds first item that fulfills predicate", function() - local predicate = spy.new(function(item) - return item == "Waldo" - end) - - assert.equal( - "Waldo", - _.find_first(predicate, { - "Where", - "On Earth", - "Is", - "Waldo", - "?", - }) - ) - assert.spy(predicate).was.called(4) - end) - - it("determines whether any item in the list fulfills predicate", function() - local predicate = spy.new(function(item) - return item == "On Earth" - end) - - assert.is_true(_.any(predicate, { - "Where", - "On Earth", - "Is", - "Waldo", - "?", - })) - - assert.spy(predicate).was.called(2) - end) - - it("should iterate list in .each", function() - local list = { "BLUE", "YELLOW", "RED" } - local iterate_fn = spy.new() - _.each(iterate_fn, list) - assert.spy(iterate_fn).was_called(3) - assert.spy(iterate_fn).was_called_with("BLUE", 1) - assert.spy(iterate_fn).was_called_with("YELLOW", 2) - assert.spy(iterate_fn).was_called_with("RED", 3) - end) - - it("should concat list tables", function() - local list = { "monstera", "tulipa", "carnation" } - assert.same({ "monstera", "tulipa", "carnation", "rose", "daisy" }, _.concat(list, { "rose", "daisy" })) - assert.same({ "monstera", "tulipa", "carnation" }, list) -- does not mutate list - end) - - it("should concat strings", function() - assert.equals("FooBar", _.concat("Foo", "Bar")) - end) - - it("should zip list into table", function() - local fnkey = function() end - assert.same({ - a = "a", - [fnkey] = 1, - }, _.zip_table({ "a", fnkey }, { "a", 1 })) - end) - - it("should get nth item", function() - assert.equals("first", _.nth(1, { "first", "middle", "last" })) - assert.equals("last", _.nth(-1, { "first", "middle", "last" })) - assert.equals("middle", _.nth(-2, { "first", "middle", "last" })) - assert.equals("a", _.nth(1, "abc")) - assert.equals("c", _.nth(-1, "abc")) - assert.equals("b", _.nth(-2, "abc")) - assert.is_nil(_.nth(0, { "value" })) - assert.equals("", _.nth(0, "abc")) - end) - - it("should get length", function() - assert.equals(0, _.length {}) - assert.equals(0, _.length { nil }) - assert.equals(0, _.length { obj = "doesnt count" }) - assert.equals(0, _.length "") - assert.equals(1, _.length { "" }) - assert.equals(4, _.length "fire") - end) - - it("should sort by comparator", function() - local list = { - { - name = "William", - }, - { - name = "Boman", - }, - } - assert.same({ - { - name = "Boman", - }, - { - name = "William", - }, - }, _.sort_by(_.prop "name", list)) - - -- Should not mutate original list - assert.same({ - { - name = "William", - }, - { - name = "Boman", - }, - }, list) - end) - - it("should append to list", function() - local list = { "Earth", "Wind" } - assert.same({ "Earth", "Wind", { "Fire" } }, _.append({ "Fire" }, list)) - - -- Does not mutate original list - assert.same({ "Earth", "Wind" }, list) - end) - - it("should prepend to list", function() - local list = { "Fire" } - assert.same({ { "Earth", "Wind" }, "Fire" }, _.prepend({ "Earth", "Wind" }, list)) - - -- Does not mutate original list - assert.same({ "Fire" }, list) - end) - - it("joins lists", function() - assert.equals("Hello, John", _.join(", ", { "Hello", "John" })) - end) -end) diff --git a/tests/core/functional/logic_spec.lua b/tests/core/functional/logic_spec.lua deleted file mode 100644 index 073ca52c..00000000 --- a/tests/core/functional/logic_spec.lua +++ /dev/null @@ -1,57 +0,0 @@ -local spy = require "luassert.spy" -local _ = require "mason.core.functional" - -describe("functional: logic", function() - it("should check that all_pass checks that all predicates pass", function() - local is_waldo = _.equals "waldo" - assert.is_true(_.all_pass { _.T, _.T, is_waldo, _.T } "waldo") - assert.is_false(_.all_pass { _.T, _.T, is_waldo, _.F } "waldo") - assert.is_false(_.all_pass { _.T, _.T, is_waldo, _.T } "waldina") - end) - - it("should check that any_pass checks that any predicates pass", function() - local is_waldo = _.equals "waldo" - local is_waldina = _.equals "waldina" - local is_luigi = _.equals "luigi" - - assert.is_true(_.any_pass { is_waldo, is_waldina } "waldo") - assert.is_false(_.any_pass { is_waldina, is_luigi } "waldo") - assert.is_true(_.any_pass { is_waldina, is_luigi } "waldina") - end) - - it("should branch if_else", function() - local a = spy.new() - local b = spy.new() - _.if_else(_.T, a, b) "a" - _.if_else(_.F, a, b) "b" - assert.spy(a).was_called(1) - assert.spy(a).was_called_with "a" - assert.spy(b).was_called(1) - assert.spy(b).was_called_with "b" - end) - - it("should flip booleans", function() - assert.is_true(_.is_not(false)) - assert.is_false(_.is_not(true)) - end) - - it("should resolve correct cond", function() - local planetary_object = _.cond { - { - _.equals "Moon!", - _.format "to the %s", - }, - { - _.equals "World!", - _.format "Hello %s", - }, - } - assert.equals("Hello World!", planetary_object "World!") - assert.equals("to the Moon!", planetary_object "Moon!") - end) - - it("should give complements", function() - assert.is_true(_.complement(_.is_nil, "not nil")) - assert.is_false(_.complement(_.is_nil, nil)) - end) -end) diff --git a/tests/core/functional/number_spec.lua b/tests/core/functional/number_spec.lua deleted file mode 100644 index f23156fe..00000000 --- a/tests/core/functional/number_spec.lua +++ /dev/null @@ -1,50 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: number", function() - it("should negate numbers", function() - assert.equals(-42, _.negate(42)) - assert.equals(42, _.negate(-42)) - end) - - it("should check numbers greater than value", function() - local greater_than_life = _.gt(42) - assert.is_false(greater_than_life(0)) - assert.is_false(greater_than_life(42)) - assert.is_true(greater_than_life(43)) - end) - - it("should check numbers greater or equal than value", function() - local greater_or_equal_to_life = _.gte(42) - assert.is_false(greater_or_equal_to_life(0)) - assert.is_true(greater_or_equal_to_life(42)) - assert.is_true(greater_or_equal_to_life(43)) - end) - - it("should check numbers lower than value", function() - local lesser_than_life = _.lt(42) - assert.is_true(lesser_than_life(0)) - assert.is_false(lesser_than_life(42)) - assert.is_false(lesser_than_life(43)) - end) - - it("should check numbers lower or equal than value", function() - local lesser_or_equal_to_life = _.lte(42) - assert.is_true(lesser_or_equal_to_life(0)) - assert.is_true(lesser_or_equal_to_life(42)) - assert.is_false(lesser_or_equal_to_life(43)) - end) - - it("should increment numbers", function() - local add_5 = _.inc(5) - assert.equals(0, add_5(-5)) - assert.equals(5, add_5(0)) - assert.equals(7, add_5(2)) - end) - - it("should decrement numbers", function() - local subtract_5 = _.dec(5) - assert.equals(5, subtract_5(10)) - assert.equals(-5, subtract_5(0)) - assert.equals(-3, subtract_5(2)) - end) -end) diff --git a/tests/core/functional/relation_spec.lua b/tests/core/functional/relation_spec.lua deleted file mode 100644 index 4c92ffb5..00000000 --- a/tests/core/functional/relation_spec.lua +++ /dev/null @@ -1,36 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: relation", function() - it("should check equality", function() - local tbl = {} - local is_tbl = _.equals(tbl) - local is_a = _.equals "a" - local is_42 = _.equals(42) - - assert.is_true(is_tbl(tbl)) - assert.is_true(is_a "a") - assert.is_true(is_42(42)) - assert.is_false(is_a "b") - assert.is_false(is_42(32)) - end) - - it("should check property equality", function() - local fn_key = function() end - local tbl = { a = "a", b = "b", number = 42, [fn_key] = "fun" } - assert.is_true(_.prop_eq("a", "a", tbl)) - assert.is_true(_.prop_eq(fn_key, "fun", tbl)) - assert.is_true(_.prop_eq(fn_key) "fun"(tbl)) - end) - - it("should check whether property satisfies predicate", function() - local obj = { - low = 0, - med = 10, - high = 15, - } - - assert.is_false(_.prop_satisfies(_.gt(10), "low", obj)) - assert.is_false(_.prop_satisfies(_.gt(10), "med")(obj)) - assert.is_true(_.prop_satisfies(_.gt(10)) "high"(obj)) - end) -end) diff --git a/tests/core/functional/string_spec.lua b/tests/core/functional/string_spec.lua deleted file mode 100644 index 4f9f4722..00000000 --- a/tests/core/functional/string_spec.lua +++ /dev/null @@ -1,43 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: string", function() - it("matches string patterns", function() - assert.is_true(_.matches("foo", "foo")) - assert.is_true(_.matches("bar", "foobarbaz")) - assert.is_true(_.matches("ba+r", "foobaaaaaaarbaz")) - - assert.is_false(_.matches("ba+r", "foobharbaz")) - assert.is_false(_.matches("bar", "foobaz")) - end) - - it("should format strings", function() - assert.equals("Hello World!", _.format("%s", "Hello World!")) - assert.equals("special manouvers", _.format("%s manouvers", "special")) - end) - - it("should split strings", function() - assert.same({ "This", "is", "a", "sentence" }, _.split("%s", "This is a sentence")) - assert.same({ "This", "is", "a", "sentence" }, _.split("|", "This|is|a|sentence")) - end) - - it("should gsub strings", function() - assert.same("predator", _.gsub("^apex%s*", "", "apex predator")) - end) - - it("should dedent strings", function() - assert.equals( - [[Lorem -Ipsum - Dolor - Sit - Amet]], - _.dedent [[ - Lorem - Ipsum - Dolor - Sit - Amet -]] - ) - end) -end) diff --git a/tests/core/functional/table_spec.lua b/tests/core/functional/table_spec.lua deleted file mode 100644 index b10527f1..00000000 --- a/tests/core/functional/table_spec.lua +++ /dev/null @@ -1,51 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: table", function() - it("retrieves property of table", function() - assert.equals("hello", _.prop("a", { a = "hello" })) - end) - - it("picks properties of table", function() - local function fn() end - assert.same( - { - ["key1"] = 1, - [fn] = 2, - }, - _.pick({ "key1", fn }, { - ["key1"] = 1, - [fn] = 2, - [3] = 3, - }) - ) - end) - - it("converts table to pairs", function() - assert.same( - _.sort_by(_.nth(1), { - { - "skies", - "cloudy", - }, - { - "temperature", - "20°", - }, - }), - _.sort_by(_.nth(1), _.to_pairs { skies = "cloudy", temperature = "20°" }) - ) - end) - - it("should invert tables", function() - assert.same( - { - val1 = "key1", - val2 = "key2", - }, - _.invert { - key1 = "val1", - key2 = "val2", - } - ) - end) -end) diff --git a/tests/core/functional/type_spec.lua b/tests/core/functional/type_spec.lua deleted file mode 100644 index 8e8068df..00000000 --- a/tests/core/functional/type_spec.lua +++ /dev/null @@ -1,26 +0,0 @@ -local _ = require "mason.core.functional" - -describe("functional: type", function() - it("should check nil value", function() - assert.is_true(_.is_nil(nil)) - assert.is_false(_.is_nil(1)) - assert.is_false(_.is_nil {}) - assert.is_false(_.is_nil(function() end)) - end) - - it("should check types", function() - local is_fun = _.is "function" - local is_string = _.is "string" - local is_number = _.is "number" - local is_boolean = _.is "boolean" - - assert.is_true(is_fun(function() end)) - assert.is_false(is_fun(1)) - assert.is_true(is_string "") - assert.is_false(is_string(1)) - assert.is_true(is_number(1)) - assert.is_false(is_number "") - assert.is_true(is_boolean(true)) - assert.is_false(is_boolean(1)) - end) -end) diff --git a/tests/core/installer_spec.lua b/tests/core/installer_spec.lua deleted file mode 100644 index 857721bb..00000000 --- a/tests/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) diff --git a/tests/core/managers/cargo_spec.lua b/tests/core/managers/cargo_spec.lua deleted file mode 100644 index 59bb75da..00000000 --- a/tests/core/managers/cargo_spec.lua +++ /dev/null @@ -1,226 +0,0 @@ -local spy = require "luassert.spy" -local match = require "luassert.match" -local mock = require "luassert.mock" -local Optional = require "mason.core.optional" -local installer = require "mason.core.installer" -local cargo = require "mason.core.managers.cargo" -local Result = require "mason.core.result" -local spawn = require "mason.core.spawn" -local path = require "mason.core.path" - -describe("cargo manager", function() - it( - "should call cargo install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, cargo.crate "my-crate") - assert.spy(ctx.spawn.cargo).was_called(1) - assert.spy(ctx.spawn.cargo).was_called_with { - "install", - "--root", - ".", - "--locked", - { "--version", "42.13.37" }, - vim.NIL, -- --features - "my-crate", - } - end) - ) - - it( - "should call cargo install with git source", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, cargo.crate("https://my-crate.git", { git = true })) - assert.spy(ctx.spawn.cargo).was_called(1) - assert.spy(ctx.spawn.cargo).was_called_with { - "install", - "--root", - ".", - "--locked", - vim.NIL, - vim.NIL, -- --features - { "--git", "https://my-crate.git" }, - } - end) - ) - - it( - "should call cargo install with git source and a specific crate", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, cargo.crate("crate-name", { git = "https://my-crate.git" })) - assert.spy(ctx.spawn.cargo).was_called(1) - assert.spy(ctx.spawn.cargo).was_called_with { - "install", - "--root", - ".", - "--locked", - vim.NIL, - vim.NIL, -- --features - { "--git", "https://my-crate.git", "crate-name" }, - } - end) - ) - - it( - "should respect options", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, cargo.crate("my-crate", { features = "lsp" })) - assert.spy(ctx.spawn.cargo).was_called(1) - assert.spy(ctx.spawn.cargo).was_called_with { - "install", - "--root", - ".", - "--locked", - { "--version", "42.13.37" }, - { "--features", "lsp" }, - "my-crate", - } - end) - ) - - it( - "should not allow combining version with git crate", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - local err = assert.has_error(function() - installer.run_installer( - ctx, - cargo.crate("my-crate", { - git = true, - }) - ) - end) - assert.equals("Providing a version when installing a git crate is not allowed.", err) - assert.spy(ctx.spawn.cargo).was_called(0) - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, cargo.crate "main-package") - assert.same({ - type = "cargo", - package = "main-package", - }, ctx.receipt.primary_source) - end) - ) -end) - -describe("cargo version check", function() - it("parses cargo installed packages output", function() - assert.same( - { - ["bat"] = "0.18.3", - ["exa"] = "0.10.1", - ["git-select-branch"] = "0.1.1", - ["hello_world"] = "0.0.1", - ["rust-analyzer"] = "0.0.0", - ["stylua"] = "0.11.2", - ["zoxide"] = "0.5.0", - }, - cargo.parse_installed_crates [[bat v0.18.3: - bat -exa v0.10.1: - exa -git-select-branch v0.1.1: - git-select-branch -hello_world v0.0.1 (/private/var/folders/ky/s6yyhm_d24d0jsrql4t8k4p40000gn/T/tmp.LGbguATJHj): - hello_world -rust-analyzer v0.0.0 (/private/var/folders/ky/s6yyhm_d24d0jsrql4t8k4p40000gn/T/tmp.YlsHeA9JVL/crates/rust-analyzer): - rust-analyzer -stylua v0.11.2: - stylua -zoxide v0.5.0: - zoxide -]] - ) - end) - - it( - "should return current version", - async_test(function() - spawn.cargo = spy.new(function() - return Result.success { - stdout = [[flux-lsp v0.8.8 (https://github.com/influxdata/flux-lsp#4e452f07): - flux-lsp -]], - } - end) - - local result = cargo.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "cargo", - package = "https://github.com/influxdata/flux-lsp", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.cargo).was_called(1) - assert.spy(spawn.cargo).was_called_with(match.tbl_containing { - "install", - "--list", - "--root", - ".", - cwd = path.package_prefix "dummy", - }) - assert.is_true(result:is_success()) - assert.equals("0.8.8", result:get_or_nil()) - - spawn.cargo = nil - end) - ) - - -- XXX: This test will actually send http request to crates.io's API. It's not mocked. - it( - "should return outdated primary package", - async_test(function() - spawn.cargo = spy.new(function() - return Result.success { - stdout = [[lelwel v0.4.0: - lelwel-ls -]], - } - end) - - local result = cargo.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "cargo", - package = "lelwel", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.cargo).was_called(1) - assert.spy(spawn.cargo).was_called_with(match.tbl_containing { - "install", - "--list", - "--root", - ".", - cwd = path.package_prefix "dummy", - }) - assert.is_true(result:is_success()) - assert.is_true(match.tbl_containing { - current_version = "0.4.0", - latest_version = match.matches "%d.%d.%d", - name = "lelwel", - }(result:get_or_nil())) - - spawn.cargo = nil - end) - ) -end) diff --git a/tests/core/managers/composer_spec.lua b/tests/core/managers/composer_spec.lua deleted file mode 100644 index 48cb4784..00000000 --- a/tests/core/managers/composer_spec.lua +++ /dev/null @@ -1,179 +0,0 @@ -local spy = require "luassert.spy" -local mock = require "luassert.mock" -local installer = require "mason.core.installer" -local Optional = require "mason.core.optional" -local composer = require "mason.core.managers.composer" -local Result = require "mason.core.result" -local spawn = require "mason.core.spawn" -local path = require "mason.core.path" - -describe("composer manager", function() - it( - "should call composer require", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - ctx.fs.file_exists = spy.new(mockx.returns(false)) - installer.run_installer( - ctx, - composer.packages { "main-package", "supporting-package", "supporting-package2" } - ) - assert.spy(ctx.spawn.composer).was_called(2) - assert.spy(ctx.spawn.composer).was_called_with { - "init", - "--no-interaction", - "--stability=stable", - } - assert.spy(ctx.spawn.composer).was_called_with { - "require", - { - "main-package:42.13.37", - "supporting-package", - "supporting-package2", - }, - } - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer( - ctx, - composer.packages { "main-package", "supporting-package", "supporting-package2" } - ) - assert.same({ - type = "composer", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "composer", - package = "supporting-package", - }, - { - type = "composer", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) - -describe("composer version check", function() - it( - "should return current version", - async_test(function() - spawn.composer = spy.new(function() - return Result.success { - stdout = [[ -{ - "name": "vimeo/psalm", - "versions": [ - "4.0.0" - ] -} -]], - } - end) - - local result = composer.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "composer", - package = "vimeo/psalm", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.composer).was_called(1) - assert.spy(spawn.composer).was_called_with { - "info", - "--format=json", - "vimeo/psalm", - cwd = path.package_prefix "dummy", - } - assert.is_true(result:is_success()) - assert.equals("4.0.0", result:get_or_nil()) - - spawn.composer = nil - end) - ) - - it( - "should return outdated primary package", - async_test(function() - spawn.composer = spy.new(function() - return Result.success { - stdout = [[ -{ - "installed": [ - { - "name": "vimeo/psalm", - "version": "4.0.0", - "latest": "4.22.0", - "latest-status": "semver-safe-update", - "description": "A static analysis tool for finding errors in PHP applications" - } - ] -} -]], - } - end) - - local result = composer.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "composer", - package = "vimeo/psalm", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.composer).was_called(1) - assert.spy(spawn.composer).was_called_with { - "outdated", - "--no-interaction", - "--format=json", - cwd = path.package_prefix "dummy", - } - assert.is_true(result:is_success()) - assert.same({ - name = "vimeo/psalm", - current_version = "4.0.0", - latest_version = "4.22.0", - }, result:get_or_nil()) - - spawn.composer = nil - end) - ) - - it( - "should return failure if primary package is not outdated", - async_test(function() - spawn.composer = spy.new(function() - return Result.success { - stdout = [[{"installed": []}]], - } - end) - - local result = composer.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "composer", - package = "vimeo/psalm", - }, - }, - path.package_prefix "dummy" - ) - - assert.is_true(result:is_failure()) - assert.equals("Primary package is not outdated.", result:err_or_nil()) - spawn.composer = nil - end) - ) -end) diff --git a/tests/core/managers/dotnet_spec.lua b/tests/core/managers/dotnet_spec.lua deleted file mode 100644 index ff922720..00000000 --- a/tests/core/managers/dotnet_spec.lua +++ /dev/null @@ -1,35 +0,0 @@ -local installer = require "mason.core.installer" -local dotnet = require "mason.core.managers.dotnet" - -describe("dotnet manager", function() - it( - "should call dotnet tool update", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, dotnet.package "main-package") - assert.spy(ctx.spawn.dotnet).was_called(1) - assert.spy(ctx.spawn.dotnet).was_called_with { - "tool", - "update", - "--tool-path", - ".", - { "--version", "42.13.37" }, - "main-package", - } - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, dotnet.package "main-package") - assert.same({ - type = "dotnet", - package = "main-package", - }, ctx.receipt.primary_source) - end) - ) -end) diff --git a/tests/core/managers/gem_spec.lua b/tests/core/managers/gem_spec.lua deleted file mode 100644 index 5beb6c95..00000000 --- a/tests/core/managers/gem_spec.lua +++ /dev/null @@ -1,206 +0,0 @@ -local spy = require "luassert.spy" -local match = require "luassert.match" -local mock = require "luassert.mock" -local installer = require "mason.core.installer" -local Optional = require "mason.core.optional" -local gem = require "mason.core.managers.gem" -local Result = require "mason.core.result" -local spawn = require "mason.core.spawn" - -describe("gem manager", function() - it( - "should call gem install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, gem.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.spy(ctx.spawn.gem).was_called(1) - assert.spy(ctx.spawn.gem).was_called_with(match.tbl_containing { - "install", - "--no-user-install", - "--install-dir=.", - "--bindir=bin", - "--no-document", - match.tbl_containing { - "main-package:42.13.37", - "supporting-package", - "supporting-package2", - }, - }) - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, gem.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.same({ - type = "gem", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "gem", - package = "supporting-package", - }, - { - type = "gem", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) - -describe("gem version check", function() - it( - "should return current version", - async_test(function() - spawn.gem = spy.new(function() - return Result.success { - stdout = [[shellwords (default: 0.1.0) -singleton (default: 0.1.1) -solargraph (0.44.0) -stringio (default: 3.0.1) -strscan (default: 3.0.1) -]], - } - end) - - local result = gem.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "gem", - package = "solargraph", - }, - }, - "/tmp/install/dir" - ) - - assert.spy(spawn.gem).was_called(1) - assert.spy(spawn.gem).was_called_with(match.tbl_containing { - "list", - cwd = "/tmp/install/dir", - env = match.tbl_containing { - GEM_HOME = "/tmp/install/dir", - GEM_PATH = "/tmp/install/dir", - PATH = match.matches "^/tmp/install/dir/bin:.*$", - }, - }) - assert.is_true(result:is_success()) - assert.equals("0.44.0", result:get_or_nil()) - - spawn.gem = nil - end) - ) - - it( - "should return outdated primary package", - async_test(function() - spawn.gem = spy.new(function() - return Result.success { - stdout = [[bigdecimal (3.1.1 < 3.1.2) -cgi (0.3.1 < 0.3.2) -logger (1.5.0 < 1.5.1) -ostruct (0.5.2 < 0.5.3) -reline (0.3.0 < 0.3.1) -securerandom (0.1.1 < 0.2.0) -solargraph (0.44.0 < 0.44.3) -]], - } - end) - - local result = gem.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "gem", - package = "solargraph", - }, - }, - "/tmp/install/dir" - ) - - assert.spy(spawn.gem).was_called(1) - assert.spy(spawn.gem).was_called_with(match.tbl_containing { - "outdated", - cwd = "/tmp/install/dir", - env = match.tbl_containing { - GEM_HOME = "/tmp/install/dir", - GEM_PATH = "/tmp/install/dir", - PATH = match.matches "^/tmp/install/dir/bin:.*$", - }, - }) - assert.is_true(result:is_success()) - assert.same({ - name = "solargraph", - current_version = "0.44.0", - latest_version = "0.44.3", - }, result:get_or_nil()) - - spawn.gem = nil - end) - ) - - it( - "should return failure if primary package is not outdated", - async_test(function() - spawn.gem = spy.new(function() - return Result.success { - stdout = "", - } - end) - - local result = gem.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "gem", - package = "solargraph", - }, - }, - "/tmp/install/dir" - ) - - assert.is_true(result:is_failure()) - assert.equals("Primary package is not outdated.", result:err_or_nil()) - spawn.gem = nil - end) - ) - - it("parses outdated gem output", function() - local normalize = gem.parse_outdated_gem - assert.same({ - name = "solargraph", - current_version = "0.42.2", - latest_version = "0.44.2", - }, normalize [[solargraph (0.42.2 < 0.44.2)]]) - assert.same({ - name = "sorbet-runtime", - current_version = "0.5.9307", - latest_version = "0.5.9468", - }, normalize [[sorbet-runtime (0.5.9307 < 0.5.9468)]]) - end) - - it("returns nil when unable to parse outdated gem", function() - assert.is_nil(gem.parse_outdated_gem "a whole bunch of gibberish!") - assert.is_nil(gem.parse_outdated_gem "") - end) - - it("should parse gem list output", function() - assert.same( - { - ["solargraph"] = "0.44.3", - ["unicode-display_width"] = "2.1.0", - }, - gem.parse_gem_list_output [[ - -*** LOCAL GEMS *** - -nokogiri (1.13.3 arm64-darwin) -solargraph (0.44.3) -unicode-display_width (2.1.0) -]] - ) - end) -end) diff --git a/tests/core/managers/git_spec.lua b/tests/core/managers/git_spec.lua deleted file mode 100644 index f6a3f9d1..00000000 --- a/tests/core/managers/git_spec.lua +++ /dev/null @@ -1,181 +0,0 @@ -local spy = require "luassert.spy" -local mock = require "luassert.mock" -local spawn = require "mason.core.spawn" -local Result = require "mason.core.result" -local installer = require "mason.core.installer" - -local git = require "mason.core.managers.git" -local Optional = require "mason.core.optional" - -describe("git manager", function() - it( - "should fail if no git repo provided", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - local err = assert.has_errors(function() - installer.run_installer(ctx, function() - git.clone {} - end) - end) - assert.equals("No git URL provided.", err) - assert.spy(ctx.spawn.git).was_not_called() - end) - ) - - it( - "should clone provided repo", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, function() - git.clone { "https://github.com/williamboman/mason.nvim.git" } - end) - assert.spy(ctx.spawn.git).was_called(1) - assert.spy(ctx.spawn.git).was_called_with { - "clone", - "--depth", - "1", - vim.NIL, - "https://github.com/williamboman/mason.nvim.git", - ".", - } - end) - ) - - it( - "should fetch and checkout revision if requested", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "1337" }) - installer.run_installer(ctx, function() - git.clone { "https://github.com/williamboman/mason.nvim.git" } - end) - assert.spy(ctx.spawn.git).was_called(3) - assert.spy(ctx.spawn.git).was_called_with { - "clone", - "--depth", - "1", - vim.NIL, - "https://github.com/williamboman/mason.nvim.git", - ".", - } - assert.spy(ctx.spawn.git).was_called_with { - "fetch", - "--depth", - "1", - "origin", - "1337", - } - assert.spy(ctx.spawn.git).was_called_with { "checkout", "FETCH_HEAD" } - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, function() - git.clone({ "https://github.com/williamboman/mason.nvim.git" }).with_receipt() - end) - assert.same({ - type = "git", - remote = "https://github.com/williamboman/mason.nvim.git", - }, ctx.receipt.primary_source) - assert.is_true(#ctx.receipt.secondary_sources == 0) - end) - ) -end) - -describe("git version check", function() - it( - "should return current version", - async_test(function() - spawn.git = spy.new(function() - return Result.success { - stdout = [[19c668c]], - } - end) - - local result = git.get_installed_revision({ type = "git" }, "/tmp/install/dir") - - assert.spy(spawn.git).was_called(1) - assert.spy(spawn.git).was_called_with { "rev-parse", "--short", "HEAD", cwd = "/tmp/install/dir" } - assert.is_true(result:is_success()) - assert.equals("19c668c", result:get_or_nil()) - - spawn.git = nil - end) - ) - - it( - "should check for outdated git clone", - async_test(function() - spawn.git = spy.new(function() - return Result.success { - stdout = [[728307a74cd5f2dec7ca2ca164785c25673d6328 -19c668cd10695b243b09452f0dfd53570c1a2e7d]], - } - end) - - local result = git.check_outdated_git_clone( - mock.new { - primary_source = mock.new { - type = "git", - remote = "https://github.com/williamboman/mason.nvim.git", - }, - }, - "/tmp/install/dir" - ) - - assert.spy(spawn.git).was_called(2) - assert.spy(spawn.git).was_called_with { - "fetch", - "origin", - "HEAD", - cwd = "/tmp/install/dir", - } - assert.spy(spawn.git).was_called_with { - "rev-parse", - "FETCH_HEAD", - "HEAD", - cwd = "/tmp/install/dir", - } - assert.is_true(result:is_success()) - assert.same({ - name = "https://github.com/williamboman/mason.nvim.git", - current_version = "19c668cd10695b243b09452f0dfd53570c1a2e7d", - latest_version = "728307a74cd5f2dec7ca2ca164785c25673d6328", - }, result:get_or_nil()) - - spawn.git = nil - end) - ) - - it( - "should return failure if clone is not outdated", - async_test(function() - spawn.git = spy.new(function() - return Result.success { - stdout = [[19c668cd10695b243b09452f0dfd53570c1a2e7d -19c668cd10695b243b09452f0dfd53570c1a2e7d]], - } - end) - - local result = git.check_outdated_git_clone( - mock.new { - primary_source = mock.new { - type = "git", - remote = "https://github.com/williamboman/mason.nvim.git", - }, - }, - "/tmp/install/dir" - ) - - assert.is_true(result:is_failure()) - assert.equals("Git clone is up to date.", result:err_or_nil()) - spawn.git = nil - end) - ) -end) diff --git a/tests/core/managers/github_client_spec.lua b/tests/core/managers/github_client_spec.lua deleted file mode 100644 index 11e8c392..00000000 --- a/tests/core/managers/github_client_spec.lua +++ /dev/null @@ -1,41 +0,0 @@ -local client = require "mason.core.managers.github.client" - -describe("github client", function() - ---@type GitHubRelease - local release = { - tag_name = "v0.1.0", - prerelease = false, - draft = false, - assets = {}, - } - - local function stub_release(mock) - return setmetatable(mock, { __index = release }) - end - - it("should identify stable prerelease", function() - local predicate = client.release_predicate { - include_prerelease = false, - } - - assert.is_false(predicate(stub_release { prerelease = true })) - assert.is_true(predicate(stub_release { prerelease = false })) - end) - - it("should identify stable release with tag name pattern", function() - local predicate = client.release_predicate { - tag_name_pattern = "^lsp%-server.*$", - } - - assert.is_false(predicate(stub_release { tag_name = "v0.1.0" })) - assert.is_true(predicate(stub_release { tag_name = "lsp-server-v0.1.0" })) - end) - - it("should identify stable release", function() - local predicate = client.release_predicate {} - - assert.is_true(predicate(stub_release { tag_name = "v0.1.0" })) - assert.is_false(predicate(stub_release { prerelease = true })) - assert.is_false(predicate(stub_release { draft = true })) - end) -end) diff --git a/tests/core/managers/go_spec.lua b/tests/core/managers/go_spec.lua deleted file mode 100644 index 7526120e..00000000 --- a/tests/core/managers/go_spec.lua +++ /dev/null @@ -1,174 +0,0 @@ -local mock = require "luassert.mock" -local stub = require "luassert.stub" -local spy = require "luassert.spy" -local Result = require "mason.core.result" -local go = require "mason.core.managers.go" -local spawn = require "mason.core.spawn" -local installer = require "mason.core.installer" -local path = require "mason.core.path" - -describe("go manager", function() - it( - "should call go install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, go.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.spy(ctx.spawn.go).was_called(3) - assert.spy(ctx.spawn.go).was_called_with { - "install", - "-v", - "main-package@42.13.37", - env = { GOBIN = path.package_build_prefix "dummy" }, - } - assert.spy(ctx.spawn.go).was_called_with { - "install", - "-v", - "supporting-package@latest", - env = { GOBIN = path.package_build_prefix "dummy" }, - } - assert.spy(ctx.spawn.go).was_called_with { - "install", - "-v", - "supporting-package2@latest", - env = { GOBIN = path.package_build_prefix "dummy" }, - } - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, go.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.same({ - type = "go", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "go", - package = "supporting-package", - }, - { - type = "go", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) - -describe("go version check", function() - local go_version_output = [[ -gopls: go1.18 - path golang.org/x/tools/cmd - mod golang.org/x/tools/cmd v0.8.1 h1:q5nDpRopYrnF4DN/1o8ZQ7Oar4Yd4I5OtGMx5RyV2/8= - dep github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o= - dep mvdan.cc/xurls/v2 v2.4.0 h1:tzxjVAj+wSBmDcF6zBB7/myTy3gX9xvi8Tyr28AuQgc= - build -compiler=gc - build GOOS=darwin -]] - - it("should parse go version output", function() - local parsed = go.parse_mod_version_output(go_version_output) - assert.same({ - path = { ["golang.org/x/tools/cmd"] = "" }, - mod = { ["golang.org/x/tools/cmd"] = "v0.8.1" }, - dep = { ["github.com/google/go-cmp"] = "v0.5.7", ["mvdan.cc/xurls/v2"] = "v2.4.0" }, - build = { ["-compiler=gc"] = "", ["GOOS=darwin"] = "" }, - }, parsed) - end) - - it( - "should return current version", - async_test(function() - spawn.go = spy.new(function() - return Result.success { stdout = go_version_output } - end) - - local result = go.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "go", - package = "golang.org/x/tools/cmd/gopls/...", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.go).was_called(1) - assert.spy(spawn.go).was_called_with { - "version", - "-m", - "gopls", - cwd = path.package_prefix "dummy", - } - print(result:err_or_nil()) - assert.is_true(result:is_success()) - assert.equals("v0.8.1", result:get_or_nil()) - - spawn.go = nil - end) - ) - - it( - "should return outdated primary package", - async_test(function() - stub(spawn, "go") - spawn.go - .on_call_with({ - "list", - "-json", - "-m", - "golang.org/x/tools/cmd@latest", - cwd = path.package_prefix "dummy", - }) - .returns(Result.success { - stdout = ([[ - { - "Path": %q, - "Version": "v2.0.0" - } - ]]):format(path.package_prefix "dummy"), - }) - spawn.go - .on_call_with({ - "version", - "-m", - "gopls", - cwd = path.package_prefix "dummy", - }) - .returns(Result.success { - stdout = go_version_output, - }) - - local result = go.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "go", - package = "golang.org/x/tools/cmd/gopls/...", - }, - }, - path.package_prefix "dummy" - ) - - assert.is_true(result:is_success()) - assert.same({ - name = "golang.org/x/tools/cmd", - current_version = "v0.8.1", - latest_version = "v2.0.0", - }, result:get_or_nil()) - - spawn.go = nil - end) - ) - - it("should parse package mod names", function() - assert.equals("github.com/cweill/gotests", go.parse_package_mod "github.com/cweill/gotests/...") - assert.equals("golang.org/x/tools/gopls", go.parse_package_mod "golang.org/x/tools/gopls/...") - assert.equals("golang.org/x/crypto", go.parse_package_mod "golang.org/x/crypto/...") - assert.equals("github.com/go-delve/delve", go.parse_package_mod "github.com/go-delve/delve/cmd/dlv") - end) -end) diff --git a/tests/core/managers/luarocks_spec.lua b/tests/core/managers/luarocks_spec.lua deleted file mode 100644 index a7091e51..00000000 --- a/tests/core/managers/luarocks_spec.lua +++ /dev/null @@ -1,109 +0,0 @@ -local installer = require "mason.core.installer" -local luarocks = require "mason.core.managers.luarocks" -local path = require "mason.core.path" - -describe("luarocks manager", function() - it( - "should install provided package", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, luarocks.package "lua-cjson") - assert.spy(ctx.spawn.luarocks).was_called(1) - print(vim.inspect(ctx.spawn.luarocks)) - assert.spy(ctx.spawn.luarocks).was_called_with { - "install", - "--tree", - path.package_prefix "dummy", - vim.NIL, -- --dev flag - "lua-cjson", - vim.NIL, -- version - } - end) - ) - - it( - "should install provided version", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "1.2.3" }) - installer.run_installer(ctx, luarocks.package "lua-cjson") - assert.spy(ctx.spawn.luarocks).was_called(1) - assert.spy(ctx.spawn.luarocks).was_called_with { - "install", - "--tree", - path.package_prefix "dummy", - vim.NIL, -- --dev flag - "lua-cjson", - "1.2.3", - } - end) - ) - - it( - "should provide --dev flag", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, luarocks.package("lua-cjson", { dev = true })) - assert.spy(ctx.spawn.luarocks).was_called(1) - assert.spy(ctx.spawn.luarocks).was_called_with { - "install", - "--tree", - path.package_prefix "dummy", - "--dev", - "lua-cjson", - vim.NIL, -- version - } - end) - ) - - it("should parse outdated luarocks", function() - assert.same( - { - { - name = "lua-cjson", - installed = "2.1.0-1", - available = "2.1.0.6-1", - repo = "https://luarocks.org", - }, - { - name = "lua-resty-influx-mufanh", - installed = "0.2.1-0", - available = "0.2.1-1", - repo = "https://luarocks.org", - }, - }, - luarocks.parse_outdated_rocks [[lua-cjson 2.1.0-1 2.1.0.6-1 https://luarocks.org -lua-resty-influx-mufanh 0.2.1-0 0.2.1-1 https://luarocks.org]] - ) - end) - - it("should parse listed luarocks", function() - assert.same( - { - { - package = "lua-cjson", - version = "2.1.0-1", - arch = "installed", - nrepo = "/my/luarock/loc", - }, - { - package = "lua-resty-http", - version = "0.17.0.beta.1-0", - arch = "installed", - nrepo = "/my/luarock/loc", - }, - { - package = "lua-resty-influx-mufanh", - version = "0.2.1-0", - arch = "installed", - nrepo = "/my/luarock/loc", - }, - }, - luarocks.parse_installed_rocks [[lua-cjson 2.1.0-1 installed /my/luarock/loc -lua-resty-http 0.17.0.beta.1-0 installed /my/luarock/loc -lua-resty-influx-mufanh 0.2.1-0 installed /my/luarock/loc]] - ) - end) -end) diff --git a/tests/core/managers/npm_spec.lua b/tests/core/managers/npm_spec.lua deleted file mode 100644 index a2170a63..00000000 --- a/tests/core/managers/npm_spec.lua +++ /dev/null @@ -1,194 +0,0 @@ -local spy = require "luassert.spy" -local match = require "luassert.match" -local mock = require "luassert.mock" -local installer = require "mason.core.installer" -local npm = require "mason.core.managers.npm" -local Result = require "mason.core.result" -local spawn = require "mason.core.spawn" -local path = require "mason.core.path" - -describe("npm manager", function() - it( - "should call npm install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, npm.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.spy(ctx.spawn.npm).was_called_with(match.tbl_containing { - "install", - match.tbl_containing { - "main-package@42.13.37", - "supporting-package", - "supporting-package2", - }, - }) - end) - ) - - it( - "should call npm init if node_modules and package.json doesnt exist", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - ctx.fs.file_exists = mockx.returns(false) - ctx.fs.dir_exists = mockx.returns(false) - installer.run_installer(ctx, function() - npm.install { "main-package", "supporting-package", "supporting-package2" } - end) - assert.spy(ctx.spawn.npm).was_called_with { - "init", - "--yes", - "--scope=mason", - } - end) - ) - - it( - "should append .npmrc file", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - ctx.fs.append_file = spy.new(mockx.just_runs()) - installer.run_installer(ctx, npm.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.spy(ctx.fs.append_file).was_called(1) - assert.spy(ctx.fs.append_file).was_called_with(ctx.fs, ".npmrc", "global-style=true") - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, npm.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.same({ - type = "npm", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "npm", - package = "supporting-package", - }, - { - type = "npm", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) - -describe("npm version check", function() - it( - "should return current version", - async_test(function() - spawn.npm = spy.new(function() - return Result.success { - stdout = [[ - { - "name": "bash", - "dependencies": { - "bash-language-server": { - "version": "2.0.0", - "resolved": "https://registry.npmjs.org/bash-language-server/-/bash-language-server-2.0.0.tgz" - } - } - } - ]], - } - end) - - local result = npm.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "npm", - package = "bash-language-server", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.npm).was_called(1) - assert.spy(spawn.npm).was_called_with { "ls", "--json", cwd = path.package_prefix "dummy" } - assert.is_true(result:is_success()) - assert.equals("2.0.0", result:get_or_nil()) - - spawn.npm = nil - end) - ) - - it( - "should return outdated primary package", - async_test(function() - spawn.npm = spy.new(function() - -- npm outdated returns with exit code 1 if outdated packages are found! - return Result.failure { - exit_code = 1, - stdout = [[ - { - "bash-language-server": { - "current": "1.17.0", - "wanted": "1.17.0", - "latest": "2.0.0", - "dependent": "bash", - "location": "/tmp/install/dir" - } - } - ]], - } - end) - - local result = npm.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "npm", - package = "bash-language-server", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.npm).was_called(1) - assert.spy(spawn.npm).was_called_with { - "outdated", - "--json", - "bash-language-server", - cwd = path.package_prefix "dummy", - } - assert.is_true(result:is_success()) - assert.same({ - name = "bash-language-server", - current_version = "1.17.0", - latest_version = "2.0.0", - }, result:get_or_nil()) - - spawn.npm = nil - end) - ) - - it( - "should return failure if primary package is not outdated", - async_test(function() - spawn.npm = spy.new(function() - return Result.success { - stdout = "{}", - } - end) - - local result = npm.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "npm", - package = "bash-language-server", - }, - }, - path.package_prefix "dummy" - ) - - assert.is_true(result:is_failure()) - assert.equals("Primary package is not outdated.", result:err_or_nil()) - spawn.npm = nil - end) - ) -end) diff --git a/tests/core/managers/opam_spec.lua b/tests/core/managers/opam_spec.lua deleted file mode 100644 index 1a279fde..00000000 --- a/tests/core/managers/opam_spec.lua +++ /dev/null @@ -1,51 +0,0 @@ -local match = require "luassert.match" -local mock = require "luassert.mock" -local Optional = require "mason.core.optional" -local installer = require "mason.core.installer" -local opam = require "mason.core.managers.opam" - -describe("opam manager", function() - it( - "should call opam install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, opam.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.spy(ctx.spawn.opam).was_called(1) - assert.spy(ctx.spawn.opam).was_called_with(match.tbl_containing { - "install", - "--destdir=.", - "--yes", - "--verbose", - match.tbl_containing { - "main-package.42.13.37", - "supporting-package", - "supporting-package2", - }, - }) - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, opam.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.same({ - type = "opam", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "opam", - package = "supporting-package", - }, - { - type = "opam", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) diff --git a/tests/core/managers/pip3_spec.lua b/tests/core/managers/pip3_spec.lua deleted file mode 100644 index 17489fe9..00000000 --- a/tests/core/managers/pip3_spec.lua +++ /dev/null @@ -1,242 +0,0 @@ -local mock = require "luassert.mock" -local spy = require "luassert.spy" -local path = require "mason.core.path" - -local pip3 = require "mason.core.managers.pip3" -local Optional = require "mason.core.optional" -local installer = require "mason.core.installer" -local Result = require "mason.core.result" -local settings = require "mason.settings" -local spawn = require "mason.core.spawn" - -describe("pip3 manager", function() - it("normalizes pip3 packages", function() - local normalize = pip3.normalize_package - assert.equal("python-lsp-server", normalize "python-lsp-server[all]") - assert.equal("python-lsp-server", normalize "python-lsp-server[]") - assert.equal("python-lsp-server", normalize "python-lsp-server[[]]") - end) - - it( - "should create venv and call pip3 install", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, pip3.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.equals(path.package_prefix "dummy", ctx.cwd:get()) -- should've promoted cwd - assert.spy(ctx.spawn.python3).was_called(1) - assert.spy(ctx.spawn.python3).was_called_with { - "-m", - "venv", - "venv", - } - assert.spy(ctx.spawn.python).was_called(1) - assert.spy(ctx.spawn.python).was_called_with { - "-m", - "pip", - "--disable-pip-version-check", - "install", - "-U", - {}, - { - "main-package==42.13.37", - "supporting-package", - "supporting-package2", - }, - with_paths = { path.concat { path.package_prefix "dummy", "venv", "bin" } }, - } - end) - ) - - it( - "should exhaust python3 executable candidates if all fail", - async_test(function() - vim.g.python3_host_prog = "/my/python3" - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - ctx.spawn.python3 = spy.new(mockx.throws()) - ctx.spawn.python = spy.new(mockx.throws()) - ctx.spawn[vim.g.python3_host_prog] = spy.new(mockx.throws()) - local err = assert.has_error(function() - installer.run_installer(ctx, pip3.packages { "package" }) - end) - vim.g.python3_host_prog = nil - - assert.equals("Unable to create python3 venv environment.", err) - assert.spy(ctx.spawn["/my/python3"]).was_called(1) - assert.spy(ctx.spawn.python3).was_called(1) - assert.spy(ctx.spawn.python).was_called(1) - end) - ) - - it( - "should not exhaust python3 executable if one succeeds", - async_test(function() - vim.g.python3_host_prog = "/my/python3" - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - ctx.spawn.python3 = spy.new(mockx.throws()) - ctx.spawn.python = spy.new(mockx.returns {}) - ctx.spawn[vim.g.python3_host_prog] = spy.new(mockx.returns {}) - - installer.run_installer(ctx, pip3.packages { "package" }) - vim.g.python3_host_prog = nil - assert.spy(ctx.spawn.python3).was_called(0) - assert.spy(ctx.spawn.python).was_called(1) - assert.spy(ctx.spawn["/my/python3"]).was_called(1) - end) - ) - - it( - "should use install_args from settings", - async_test(function() - settings.set { - pip = { - install_args = { "--proxy", "http://localhost:8080" }, - }, - } - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle) - installer.run_installer(ctx, pip3.packages { "package" }) - assert.spy(ctx.spawn.python).was_called_with { - "-m", - "pip", - "--disable-pip-version-check", - "install", - "-U", - { "--proxy", "http://localhost:8080" }, - { "package" }, - with_paths = { path.concat { path.package_prefix "dummy", "venv", "bin" } }, - } - end) - ) - - it( - "should provide receipt information", - async_test(function() - local handle = InstallHandleGenerator "dummy" - local ctx = InstallContextGenerator(handle, { requested_version = "42.13.37" }) - installer.run_installer(ctx, pip3.packages { "main-package", "supporting-package", "supporting-package2" }) - assert.same({ - type = "pip3", - package = "main-package", - }, ctx.receipt.primary_source) - assert.same({ - { - type = "pip3", - package = "supporting-package", - }, - { - type = "pip3", - package = "supporting-package2", - }, - }, ctx.receipt.secondary_sources) - end) - ) -end) - -describe("pip3 version check", function() - it( - "should return current version", - async_test(function() - spawn.python = spy.new(function() - return Result.success { - stdout = [[ - [{"name": "astroid", "version": "2.9.3"}, {"name": "mccabe", "version": "0.6.1"}, {"name": "python-lsp-server", "version": "1.3.0", "latest_version": "1.4.0", "latest_filetype": "wheel"}, {"name": "wrapt", "version": "1.13.3", "latest_version": "1.14.0", "latest_filetype": "wheel"}] - ]], - } - end) - - local result = pip3.get_installed_primary_package_version( - mock.new { - primary_source = mock.new { - type = "pip3", - package = "python-lsp-server", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.python).was_called(1) - assert.spy(spawn.python).was_called_with { - "-m", - "pip", - "list", - "--format=json", - cwd = path.package_prefix "dummy", - with_paths = { path.concat { path.package_prefix "dummy", "venv", "bin" } }, - } - assert.is_true(result:is_success()) - assert.equals("1.3.0", result:get_or_nil()) - - spawn.python = nil - end) - ) - - it( - "should return outdated primary package", - async_test(function() - spawn.python = spy.new(function() - return Result.success { - stdout = [[ -[{"name": "astroid", "version": "2.9.3", "latest_version": "2.11.0", "latest_filetype": "wheel"}, {"name": "mccabe", "version": "0.6.1", "latest_version": "0.7.0", "latest_filetype": "wheel"}, {"name": "python-lsp-server", "version": "1.3.0", "latest_version": "1.4.0", "latest_filetype": "wheel"}, {"name": "wrapt", "version": "1.13.3", "latest_version": "1.14.0", "latest_filetype": "wheel"}] - ]], - } - end) - - local result = pip3.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "pip3", - package = "python-lsp-server", - }, - }, - path.package_prefix "dummy" - ) - - assert.spy(spawn.python).was_called(1) - assert.spy(spawn.python).was_called_with { - "-m", - "pip", - "list", - "--outdated", - "--format=json", - cwd = path.package_prefix "dummy", - with_paths = { path.concat { path.package_prefix "dummy", "venv", "bin" } }, - } - assert.is_true(result:is_success()) - assert.same({ - name = "python-lsp-server", - current_version = "1.3.0", - latest_version = "1.4.0", - }, result:get_or_nil()) - - spawn.python = nil - end) - ) - - it( - "should return failure if primary package is not outdated", - async_test(function() - spawn.python = spy.new(function() - return Result.success { - stdout = "[]", - } - end) - - local result = pip3.check_outdated_primary_package( - mock.new { - primary_source = mock.new { - type = "pip3", - package = "python-lsp-server", - }, - }, - "/tmp/install/dir" - ) - - assert.is_true(result:is_failure()) - assert.equals("Primary package is not outdated.", result:err_or_nil()) - spawn.python = nil - end) - ) -end) diff --git a/tests/core/optional_spec.lua b/tests/core/optional_spec.lua deleted file mode 100644 index 8a33def4..00000000 --- a/tests/core/optional_spec.lua +++ /dev/null @@ -1,63 +0,0 @@ -local Optional = require "mason.core.optional" -local spy = require "luassert.spy" - -describe("Optional.of_nilable", function() - it("should create empty optionals", function() - local empty = Optional.empty() - assert.is_false(empty:is_present()) - end) - - it("should create non-empty optionals", function() - local empty = Optional.of_nilable "value" - assert.is_true(empty:is_present()) - end) - - it("should use memoized empty value", function() - assert.is_true(Optional.empty() == Optional.empty()) - end) -end) - -describe("Optional.get()", function() - it("should map non-empty values", function() - local str = Optional.of_nilable("world!") - :map(function(val) - return "Hello " .. val - end) - :get() - assert.equals("Hello world!", str) - end) - - it("should raise error when getting empty value", function() - local err = assert.has_error(function() - Optional.empty():get() - end) - assert.equals("No value present.", err) - end) -end) - -describe("Optional.or_else()", function() - it("should use .or_else() value if empty", function() - local value = Optional.empty():or_else "Hello!" - assert.equals("Hello!", value) - end) - - it("should not use .or_else() value if not empty", function() - local value = Optional.of_nilable("Good bye!"):or_else "Hello!" - assert.equals("Good bye!", value) - end) -end) - -describe("Optional.if_present()", function() - it("should not call .if_present() if value is empty", function() - local present = spy.new() - Optional.empty():if_present(present) - assert.spy(present).was_not_called() - end) - - it("should call .if_present() if value is not empty", function() - local present = spy.new() - Optional.of_nilable("value"):if_present(present) - assert.spy(present).was_called(1) - assert.spy(present).was_called_with "value" - end) -end) diff --git a/tests/core/path_spec.lua b/tests/core/path_spec.lua deleted file mode 100644 index 3d05fd14..00000000 --- a/tests/core/path_spec.lua +++ /dev/null @@ -1,23 +0,0 @@ -local path = require "mason.core.path" - -describe("path", function() - it("concatenates paths", function() - assert.equal("foo/bar/baz/~", path.concat { "foo", "bar", "baz", "~" }) - end) - - it("concatenates paths on Windows", function() - local old_os = jit.os - jit.os = "windows" - package.loaded["mason.core.path"] = nil - local path = require "mason.core.path" - assert.equal([[foo\bar\baz\~]], path.concat { "foo", "bar", "baz", "~" }) - jit.os = old_os - end) - - it("identifies subdirectories", function() - assert.is_true(path.is_subdirectory("/foo/bar", "/foo/bar/baz")) - assert.is_true(path.is_subdirectory("/foo/bar", "/foo/bar")) - assert.is_false(path.is_subdirectory("/foo/bar", "/foo/bas/baz")) - assert.is_false(path.is_subdirectory("/foo/bar", "/foo/bars/baz")) - end) -end) diff --git a/tests/core/platform_spec.lua b/tests/core/platform_spec.lua deleted file mode 100644 index 54a06f7a..00000000 --- a/tests/core/platform_spec.lua +++ /dev/null @@ -1,159 +0,0 @@ -local stub = require "luassert.stub" -local spy = require "luassert.spy" -local match = require "luassert.match" - -describe("platform", function() - local function platform() - package.loaded["mason.core.platform"] = nil - return require "mason.core.platform" - end - - local function stub_mac(arch) - arch = arch or "x86_64" - stub(vim.fn, "has") - stub(vim.loop, "os_uname") - vim.loop.os_uname.returns { machine = arch } - vim.fn.has.on_call_with("mac").returns(1) - vim.fn.has.on_call_with("unix").returns(1) - vim.fn.has.on_call_with(match._).returns(0) - end - - local function stub_linux() - stub(vim.fn, "has") - vim.fn.has.on_call_with("mac").returns(0) - vim.fn.has.on_call_with("unix").returns(1) - vim.fn.has.on_call_with(match._).returns(0) - end - - local function stub_windows() - stub(vim.fn, "has") - vim.fn.has.on_call_with("win32").returns(1) - vim.fn.has.on_call_with(match._).returns(0) - end - - it("should be able to detect platform and arch", function() - stub_mac "arm64" - assert.is_true(platform().is.mac_arm64) - assert.is_false(platform().is.mac_x64) - assert.is_false(platform().is.nothing) - end) - - it("should be able to detect macos", function() - stub_mac() - assert.is_true(platform().is_mac) - assert.is_true(platform().is.mac) - assert.is_true(platform().is_unix) - assert.is_true(platform().is.unix) - assert.is_false(platform().is_linux) - assert.is_false(platform().is.linux) - assert.is_false(platform().is_win) - assert.is_false(platform().is.win) - end) - - it("should be able to detect linux", function() - stub_linux() - assert.is_false(platform().is_mac) - assert.is_false(platform().is.mac) - assert.is_true(platform().is_unix) - assert.is_true(platform().is.unix) - assert.is_true(platform().is_linux) - assert.is_true(platform().is.linux) - assert.is_false(platform().is_win) - assert.is_false(platform().is.win) - end) - - it("should be able to detect windows", function() - stub_windows() - assert.is_false(platform().is_mac) - assert.is_false(platform().is.mac) - assert.is_false(platform().is_unix) - assert.is_false(platform().is.unix) - assert.is_false(platform().is_linux) - assert.is_false(platform().is.linux) - assert.is_true(platform().is_win) - assert.is_true(platform().is.win) - end) - - it("should run correct case on linux", function() - local unix = spy.new() - local win = spy.new() - local mac = spy.new() - local linux = spy.new() - - stub_linux() - platform().when { - unix = unix, - win = win, - linux = linux, - mac = mac, - } - assert.spy(unix).was_not_called() - assert.spy(mac).was_not_called() - assert.spy(win).was_not_called() - assert.spy(linux).was_called(1) - end) - - it("should run correct case on mac", function() - local unix = spy.new() - local win = spy.new() - local mac = spy.new() - local linux = spy.new() - - stub_mac() - platform().when { - unix = unix, - win = win, - linux = linux, - mac = mac, - } - assert.spy(unix).was_not_called() - assert.spy(mac).was_called(1) - assert.spy(win).was_not_called() - assert.spy(linux).was_not_called() - end) - - it("should run correct case on windows", function() - local unix = spy.new() - local win = spy.new() - local mac = spy.new() - local linux = spy.new() - - stub_windows() - platform().when { - unix = unix, - win = win, - linux = linux, - mac = mac, - } - assert.spy(unix).was_not_called() - assert.spy(mac).was_not_called() - assert.spy(win).was_called(1) - assert.spy(linux).was_not_called() - end) - - it("should run correct case on mac (unix)", function() - local unix = spy.new() - local win = spy.new() - - stub_mac() - platform().when { - unix = unix, - win = win, - } - assert.spy(unix).was_called(1) - assert.spy(win).was_not_called() - end) - - it("should run correct case on linux (unix)", function() - local unix = spy.new() - local win = spy.new() - - stub_linux() - platform().when { - unix = unix, - win = win, - } - assert.spy(unix).was_called(1) - assert.spy(win).was_not_called() - end) -end) diff --git a/tests/core/process_spec.lua b/tests/core/process_spec.lua deleted file mode 100644 index 8eb79e05..00000000 --- a/tests/core/process_spec.lua +++ /dev/null @@ -1,28 +0,0 @@ -local spy = require "luassert.spy" -local match = require "luassert.match" -local process = require "mason.core.process" - -describe("process.spawn", function() - -- Unix only - it( - "should spawn command and feed output to sink", - async_test(function() - local stdio = process.in_memory_sink() - local callback = spy.new() - process.spawn("env", { - args = {}, - env = { - "HELLO=world", - "MY_ENV=var", - }, - stdio_sink = stdio.sink, - }, callback) - - assert.wait_for(function() - assert.spy(callback).was_called(1) - assert.spy(callback).was_called_with(true, 0, match.is_number()) - assert.equal(table.concat(stdio.buffers.stdout, ""), "HELLO=world\nMY_ENV=var\n") - end) - end) - ) -end) diff --git a/tests/core/result_spec.lua b/tests/core/result_spec.lua deleted file mode 100644 index bb884314..00000000 --- a/tests/core/result_spec.lua +++ /dev/null @@ -1,143 +0,0 @@ -local Result = require "mason.core.result" -local match = require "luassert.match" -local spy = require "luassert.spy" - -describe("result", function() - it("should create success", function() - local result = Result.success "Hello!" - assert.is_true(result:is_success()) - assert.is_false(result:is_failure()) - assert.equals("Hello!", result:get_or_nil()) - end) - - it("should create failure", function() - local result = Result.failure "Hello!" - assert.is_true(result:is_failure()) - assert.is_false(result:is_success()) - assert.equals("Hello!", result:err_or_nil()) - end) - - it("should return value on get_or_throw()", function() - local result = Result.success "Hello!" - local val = result:get_or_throw() - assert.equals("Hello!", val) - end) - - it("should throw failure on get_or_throw()", function() - local result = Result.failure "Hello!" - local err = assert.has_error(function() - result:get_or_throw() - end) - assert.equals("Hello!", err) - end) - - it("should map() success", function() - local result = Result.success "Hello" - local mapped = result:map(function(x) - return x .. " World!" - end) - assert.equals("Hello World!", mapped:get_or_nil()) - assert.is_nil(mapped:err_or_nil()) - end) - - it("should not map() failure", function() - local result = Result.failure "Hello" - local mapped = result:map(function(x) - return x .. " World!" - end) - assert.equals("Hello", mapped:err_or_nil()) - assert.is_nil(mapped:get_or_nil()) - end) - - it("should raise exceptions in map()", function() - local result = Result.success "failure" - local err = assert.has_error(function() - result:map(function() - error "error" - end) - end) - assert.equals("error", err) - end) - - it("should map_catching() success", function() - local result = Result.success "Hello" - local mapped = result:map_catching(function(x) - return x .. " World!" - end) - assert.equals("Hello World!", mapped:get_or_nil()) - assert.is_nil(mapped:err_or_nil()) - end) - - it("should not map_catching() failure", function() - local result = Result.failure "Hello" - local mapped = result:map_catching(function(x) - return x .. " World!" - end) - assert.equals("Hello", mapped:err_or_nil()) - assert.is_nil(mapped:get_or_nil()) - end) - - it("should catch errors in map_catching()", function() - local result = Result.success "value" - local mapped = result:map_catching(function() - error "This is an error" - end) - assert.is_false(mapped:is_success()) - assert.is_true(mapped:is_failure()) - assert.is_true(match.has_match "This is an error$"(mapped:err_or_nil())) - end) - - it("should recover errors", function() - local result = Result.failure("call an ambulance"):recover(function(err) - return err .. ". but not for me!" - end) - assert.is_true(result:is_success()) - assert.equals("call an ambulance. but not for me!", result:get_or_nil()) - end) - - it("should catch errors in recover", function() - local result = Result.failure("call an ambulance"):recover_catching(function(err) - error("Oh no... " .. err, 2) - end) - assert.is_true(result:is_failure()) - assert.equals("Oh no... call an ambulance", result:err_or_nil()) - end) - - it("should return results in run_catching", function() - local result = Result.run_catching(function() - return "Hello world!" - end) - assert.is_true(result:is_success()) - assert.equals("Hello world!", result:get_or_nil()) - end) - - it("should return failures in run_catching", function() - local result = Result.run_catching(function() - error("Oh noes", 2) - end) - assert.is_true(result:is_failure()) - assert.equals("Oh noes", result:err_or_nil()) - end) - - it("should run on_failure if failure", function() - local on_success = spy.new() - local on_failure = spy.new() - local result = Result.failure("Oh noes"):on_failure(on_failure):on_success(on_success) - assert.is_true(result:is_failure()) - assert.equals("Oh noes", result:err_or_nil()) - assert.spy(on_failure).was_called(1) - assert.spy(on_success).was_called(0) - assert.spy(on_failure).was_called_with "Oh noes" - end) - - it("should run on_success if success", function() - local on_success = spy.new() - local on_failure = spy.new() - local result = Result.success("Oh noes"):on_failure(on_failure):on_success(on_success) - assert.is_true(result:is_success()) - assert.equals("Oh noes", result:get_or_nil()) - assert.spy(on_failure).was_called(0) - assert.spy(on_success).was_called(1) - assert.spy(on_success).was_called_with "Oh noes" - end) -end) diff --git a/tests/core/spawn_spec.lua b/tests/core/spawn_spec.lua deleted file mode 100644 index 744dfa6d..00000000 --- a/tests/core/spawn_spec.lua +++ /dev/null @@ -1,216 +0,0 @@ -local spy = require "luassert.spy" -local stub = require "luassert.stub" -local match = require "luassert.match" -local spawn = require "mason.core.spawn" -local process = require "mason.core.process" - -describe("async spawn", function() - it( - "should spawn commands and return stdout & stderr", - async_test(function() - local result = spawn.env { - env_raw = { "FOO=bar" }, - } - assert.is_true(result:is_success()) - assert.equals("FOO=bar\n", result:get_or_nil().stdout) - assert.equals("", result:get_or_nil().stderr) - end) - ) - - it( - "should use provided stdio_sink", - async_test(function() - local stdio = process.in_memory_sink() - local result = spawn.env { - env_raw = { "FOO=bar" }, - stdio_sink = stdio.sink, - } - assert.is_true(result:is_success()) - assert.equals(nil, result:get_or_nil().stdout) - assert.equals(nil, result:get_or_nil().stderr) - assert.equals("FOO=bar\n", table.concat(stdio.buffers.stdout, "")) - assert.equals("", table.concat(stdio.buffers.stderr, "")) - end) - ) - - it( - "should pass command arguments", - async_test(function() - local result = spawn.bash { - "-c", - 'echo "Hello $VAR"', - env = { VAR = "world" }, - } - - assert.is_true(result:is_success()) - assert.equals("Hello world\n", result:get_or_nil().stdout) - assert.equals("", result:get_or_nil().stderr) - end) - ) - - it( - "should ignore vim.NIL args", - async_test(function() - spy.on(process, "spawn") - local result = spawn.bash { - vim.NIL, - vim.NIL, - "-c", - { vim.NIL, vim.NIL }, - 'echo "Hello $VAR"', - env = { VAR = "world" }, - } - - assert.is_true(result:is_success()) - assert.equals("Hello world\n", result:get_or_nil().stdout) - assert.equals("", result:get_or_nil().stderr) - assert.spy(process.spawn).was_called(1) - assert.spy(process.spawn).was_called_with( - "bash", - match.tbl_containing { - stdio_sink = match.tbl_containing { - stdout = match.is_function(), - stderr = match.is_function(), - }, - env = match.list_containing "VAR=world", - args = match.tbl_containing { - "-c", - 'echo "Hello $VAR"', - }, - }, - match.is_function() - ) - end) - ) - - it( - "should flatten table args", - async_test(function() - local result = spawn.bash { - { "-c", 'echo "Hello $VAR"' }, - env = { VAR = "world" }, - } - - assert.is_true(result:is_success()) - assert.equals("Hello world\n", result:get_or_nil().stdout) - assert.equals("", result:get_or_nil().stderr) - end) - ) - - it( - "should call on_spawn", - async_test(function() - local on_spawn = spy.new(function(_, stdio) - local stdin = stdio[1] - stdin:write "im so piped rn" - stdin:close() - end) - - local result = spawn.cat { - { "-" }, - on_spawn = on_spawn, - } - - assert.spy(on_spawn).was_called(1) - assert.spy(on_spawn).was_called_with(match.is_not.is_nil(), match.is_table(), match.is_number()) - assert.is_true(result:is_success()) - assert.equals("im so piped rn", result:get_or_nil().stdout) - end) - ) - - it( - "should not call on_spawn if spawning fails", - async_test(function() - local on_spawn = spy.new() - - local result = spawn.this_cmd_doesnt_exist { - on_spawn = on_spawn, - } - - assert.spy(on_spawn).was_called(0) - assert.is_true(result:is_failure()) - end) - ) - - it( - "should handle failure to spawn process", - async_test(function() - stub(process, "spawn", function(_, _, callback) - callback(false) - end) - - local result = spawn.my_cmd {} - assert.is_true(result:is_failure()) - assert.is_nil(result:err_or_nil().exit_code) - end) - ) - - it( - "should format failure message", - async_test(function() - stub(process, "spawn", function(cmd, opts, callback) - opts.stdio_sink.stderr(("This is an error message for %s!"):format(cmd)) - callback(false, 127) - end) - - local result = spawn.bash {} - assert.is_true(result:is_failure()) - assert.equals( - "spawn: bash failed with exit code 127 and signal -. This is an error message for bash!", - tostring(result:err_or_nil()) - ) - end) - ) - - it( - "should check whether command is executable", - async_test(function() - local result = spawn.my_cmd {} - assert.is_true(result:is_failure()) - assert.equals( - "spawn: my_cmd failed with exit code - and signal -. my_cmd is not executable", - tostring(result:err_or_nil()) - ) - end) - ) - - it( - "should skip checking whether command is executable", - async_test(function() - stub(process, "spawn", function(_, _, callback) - callback(false, 127) - end) - - local result = spawn.my_cmd { "arg1", check_executable = false } - assert.is_true(result:is_failure()) - assert.spy(process.spawn).was_called(1) - assert.spy(process.spawn).was_called_with( - "my_cmd", - match.tbl_containing { - args = match.same { "arg1" }, - }, - match.is_function() - ) - end) - ) - - it( - "should skip checking whether command is executable if with_paths is provided", - async_test(function() - stub(process, "spawn", function(_, _, callback) - callback(false, 127) - end) - - local result = spawn.my_cmd { "arg1", with_paths = {} } - assert.is_true(result:is_failure()) - assert.spy(process.spawn).was_called(1) - assert.spy(process.spawn).was_called_with( - "my_cmd", - match.tbl_containing { - args = match.same { "arg1" }, - }, - match.is_function() - ) - end) - ) -end) diff --git a/tests/core/ui_spec.lua b/tests/core/ui_spec.lua deleted file mode 100644 index 215a7283..00000000 --- a/tests/core/ui_spec.lua +++ /dev/null @@ -1,301 +0,0 @@ -local match = require "luassert.match" -local spy = require "luassert.spy" -local display = require "mason.core.ui.display" -local Ui = require "mason.core.ui" -local a = require "mason.core.async" - -describe("ui", function() - it("produces a correct tree", function() - local function renderer(state) - return Ui.CascadingStyleNode({ "INDENT" }, { - Ui.When(not state.is_active, function() - return Ui.Text { - "I'm not active", - "Another line", - } - end), - Ui.When(state.is_active, function() - return Ui.Text { - "I'm active", - "Yet another line", - } - end), - }) - end - - assert.same({ - children = { - { - type = "HL_TEXT", - lines = { - { { "I'm not active", "" } }, - { { "Another line", "" } }, - }, - }, - { - type = "NODE", - children = {}, - }, - }, - styles = { "INDENT" }, - type = "CASCADING_STYLE", - }, renderer { is_active = false }) - - assert.same({ - children = { - { - type = "NODE", - children = {}, - }, - { - type = "HL_TEXT", - lines = { - { { "I'm active", "" } }, - { { "Yet another line", "" } }, - }, - }, - }, - styles = { "INDENT" }, - type = "CASCADING_STYLE", - }, renderer { is_active = true }) - end) - - it("renders a tree correctly", function() - local render_output = display._render_node( - { - win_width = 120, - }, - Ui.CascadingStyleNode({ "INDENT" }, { - Ui.Keybind("i", "INSTALL_PACKAGE", { "sumneko_lua" }, true), - Ui.HlTextNode { - { - { "Hello World!", "MyHighlightGroup" }, - }, - { - { "Another Line", "Comment" }, - }, - }, - Ui.HlTextNode { - { - { "Install something idk", "Stuff" }, - }, - }, - Ui.StickyCursor { id = "sticky" }, - Ui.Keybind("<CR>", "INSTALL_PACKAGE", { "tsserver" }, false), - Ui.DiagnosticsNode { - message = "yeah this one's outdated", - severity = vim.diagnostic.severity.WARN, - source = "trust me bro", - }, - Ui.Text { "I'm a text node" }, - }) - ) - - assert.same({ - highlights = { - { - col_start = 2, - col_end = 14, - line = 0, - hl_group = "MyHighlightGroup", - }, - { - col_start = 2, - col_end = 14, - line = 1, - hl_group = "Comment", - }, - { - col_start = 2, - col_end = 23, - line = 2, - hl_group = "Stuff", - }, - }, - lines = { " Hello World!", " Another Line", " Install something idk", " I'm a text node" }, - virt_texts = {}, - sticky_cursors = { line_map = { [3] = "sticky" }, id_map = { ["sticky"] = 3 } }, - keybinds = { - { - effect = "INSTALL_PACKAGE", - key = "i", - line = -1, - payload = { "sumneko_lua" }, - }, - { - effect = "INSTALL_PACKAGE", - key = "<CR>", - line = 3, - payload = { "tsserver" }, - }, - }, - diagnostics = { - { - line = 3, - message = "yeah this one's outdated", - source = "trust me bro", - severity = vim.diagnostic.severity.WARN, - }, - }, - }, render_output) - end) -end) - -describe("integration test", function() - it( - "calls vim APIs as expected during rendering", - async_test(function() - local window = display.new_view_only_win("test", "my-filetype") - - window.view(function(state) - return Ui.Node { - Ui.Keybind("U", "EFFECT", nil, true), - Ui.Text { - "Line number 1!", - state.text, - }, - Ui.Keybind("R", "R_EFFECT", { state.text }), - Ui.HlTextNode { - { - { "My highlighted text", "MyHighlightGroup" }, - }, - }, - } - end) - - local mutate_state = window.state { text = "Initial state" } - - local clear_namespace = spy.on(vim.api, "nvim_buf_clear_namespace") - local buf_set_option = spy.on(vim.api, "nvim_buf_set_option") - local win_set_option = spy.on(vim.api, "nvim_win_set_option") - local set_lines = spy.on(vim.api, "nvim_buf_set_lines") - local set_extmark = spy.on(vim.api, "nvim_buf_set_extmark") - local set_hl = spy.on(vim.api, "nvim_set_hl") - local add_highlight = spy.on(vim.api, "nvim_buf_add_highlight") - local set_keymap = spy.on(vim.keymap, "set") - - window.init { - effects = { - ["EFFECT"] = function() end, - ["R_EFFECT"] = function() end, - }, - highlight_groups = { - MyHighlight = { bold = true }, - }, - } - window.open { border = "none" } - - -- Initial window and buffer creation + initial render - a.scheduler() - - assert.spy(set_hl).was_called(1) - assert.spy(set_hl).was_called_with(match.is_number(), "MyHighlight", match.same { bold = true }) - - assert.spy(win_set_option).was_called(8) - assert.spy(win_set_option).was_called_with(match.is_number(), "number", false) - assert.spy(win_set_option).was_called_with(match.is_number(), "relativenumber", false) - assert.spy(win_set_option).was_called_with(match.is_number(), "wrap", false) - assert.spy(win_set_option).was_called_with(match.is_number(), "spell", false) - assert.spy(win_set_option).was_called_with(match.is_number(), "foldenable", false) - assert.spy(win_set_option).was_called_with(match.is_number(), "signcolumn", "no") - assert.spy(win_set_option).was_called_with(match.is_number(), "colorcolumn", "") - assert.spy(win_set_option).was_called_with(match.is_number(), "cursorline", true) - - assert.spy(buf_set_option).was_called(10) - assert.spy(buf_set_option).was_called_with(match.is_number(), "modifiable", false) - assert.spy(buf_set_option).was_called_with(match.is_number(), "swapfile", false) - assert.spy(buf_set_option).was_called_with(match.is_number(), "textwidth", 0) - assert.spy(buf_set_option).was_called_with(match.is_number(), "buftype", "nofile") - assert.spy(buf_set_option).was_called_with(match.is_number(), "bufhidden", "wipe") - assert.spy(buf_set_option).was_called_with(match.is_number(), "buflisted", false) - assert.spy(buf_set_option).was_called_with(match.is_number(), "filetype", "my-filetype") - assert.spy(buf_set_option).was_called_with(match.is_number(), "undolevels", -1) - - assert.spy(set_lines).was_called(1) - assert - .spy(set_lines) - .was_called_with(match.is_number(), 0, -1, false, { "Line number 1!", "Initial state", "My highlighted text" }) - - assert.spy(set_extmark).was_called(0) - - assert.spy(add_highlight).was_called(1) - assert - .spy(add_highlight) - .was_called_with(match.is_number(), match.is_number(), "MyHighlightGroup", 2, 0, 19) - - assert.spy(set_keymap).was_called(2) - assert.spy(set_keymap).was_called_with( - "n", - "U", - match.is_function(), - match.tbl_containing { nowait = true, silent = true, buffer = match.is_number() } - ) - assert.spy(set_keymap).was_called_with( - "n", - "R", - match.is_function(), - match.tbl_containing { nowait = true, silent = true, buffer = match.is_number() } - ) - - assert.spy(clear_namespace).was_called(1) - assert.spy(clear_namespace).was_called_with(match.is_number(), match.is_number(), 0, -1) - - mutate_state(function(state) - state.text = "New state" - end) - - assert.spy(set_lines).was_called(1) - a.scheduler() - assert.spy(set_lines).was_called(2) - - assert - .spy(set_lines) - .was_called_with(match.is_number(), 0, -1, false, { "Line number 1!", "New state", "My highlighted text" }) - end) - ) - - it( - "anchors to sticky cursor", - async_test(function() - local window = display.new_view_only_win("test", "my-filetype") - window.view(function(state) - local extra_lines = state.show_extra_lines - and Ui.Text { - "More", - "Lines", - "Here", - } - or Ui.Node {} - return Ui.Node { - extra_lines, - Ui.Text { - "Line 1", - "Line 2", - "Line 3", - "Line 4", - "Special line", - }, - Ui.StickyCursor { id = "special" }, - Ui.Text { - "Line 6", - "Line 7", - "Line 8", - "Line 9", - "Line 10", - }, - } - end) - local mutate_state = window.state { show_extra_lines = false } - window.init {} - window.open { border = "none" } - a.scheduler() - window.set_cursor { 5, 3 } -- move cursor to sticky line - mutate_state(function(state) - state.show_extra_lines = true - end) - a.scheduler() - local cursor = window.get_cursor() - assert.same({ 8, 3 }, cursor) - end) - ) -end) |