wehub-resource-sync
1533 lines
47 KiB
Lua
1533 lines
47 KiB
Lua
local helpers = require "spec.helpers"
|
|
local cjson = require "cjson"
|
|
local spy = require "luassert.spy"
|
|
local splitlines = require("pl.stringx").splitlines
|
|
|
|
for _, strategy in helpers.each_strategy() do
|
|
describe("helpers [#" .. strategy .. "]: assertions and modifiers", function()
|
|
local proxy_client
|
|
local env = {
|
|
database = strategy,
|
|
nginx_conf = "spec/fixtures/custom_nginx.template",
|
|
}
|
|
|
|
lazy_setup(function()
|
|
local bp = helpers.get_db_utils(strategy, {
|
|
"routes",
|
|
"services",
|
|
})
|
|
|
|
local service = bp.services:insert {
|
|
host = helpers.mock_upstream_host,
|
|
port = helpers.mock_upstream_port,
|
|
protocol = helpers.mock_upstream_protocol,
|
|
}
|
|
|
|
bp.routes:insert {
|
|
hosts = { "mock_upstream" },
|
|
protocols = { "http" },
|
|
service = service
|
|
}
|
|
|
|
assert(helpers.start_kong(env))
|
|
end)
|
|
|
|
lazy_teardown(function()
|
|
helpers.stop_kong()
|
|
end)
|
|
|
|
before_each(function()
|
|
proxy_client = helpers.proxy_client(5000)
|
|
end)
|
|
|
|
after_each(function()
|
|
if proxy_client then
|
|
proxy_client:close()
|
|
end
|
|
end)
|
|
|
|
describe("http_client", function()
|
|
it("encodes nested tables and arrays in Kong-compatible way when using form-urlencoded content-type", function()
|
|
local tests = {
|
|
{ input = { names = { "alice", "bob", "casius" } },
|
|
expected = { ["names[1]"] = "alice",
|
|
["names[2]"] = "bob",
|
|
["names[3]"] = "casius" } },
|
|
|
|
{ input = { headers = { location = { "here", "there", "everywhere" } } },
|
|
expected = { ["headers.location[1]"] = "here",
|
|
["headers.location[2]"] = "there",
|
|
["headers.location[3]"] = "everywhere" } },
|
|
|
|
{ input = { ["hello world"] = "foo, bar" } ,
|
|
expected = { ["hello world"] = "foo, bar" } },
|
|
|
|
{ input = { hash = { answer = 42 } },
|
|
expected = { ["hash.answer"] = "42" } },
|
|
|
|
{ input = { hash_array = { arr = { "one", "two" } } },
|
|
expected = { ["hash_array.arr[1]"] = "one",
|
|
["hash_array.arr[2]"] = "two" } },
|
|
|
|
{ input = { array_hash = { { name = "peter" } } },
|
|
expected = { ["array_hash[1].name"] = "peter" } },
|
|
|
|
{ input = { array_array = { { "x", "y" } } },
|
|
expected = { ["array_array[1][1]"] = "x",
|
|
["array_array[1][2]"] = "y" } },
|
|
|
|
{ input = { hybrid = { 1, 2, n = 3 } },
|
|
expected = { ["hybrid[1]"] = "1",
|
|
["hybrid[2]"] = "2",
|
|
["hybrid.n"] = "3" } },
|
|
}
|
|
|
|
for i = 1, #tests do
|
|
local r = proxy_client:get("/", {
|
|
headers = {
|
|
["Content-type"] = "application/x-www-form-urlencoded",
|
|
host = "mock_upstream",
|
|
},
|
|
body = tests[i].input
|
|
})
|
|
local json = assert.response(r).has.jsonbody()
|
|
assert.same(tests[i].expected, json.post_data.params)
|
|
end
|
|
end)
|
|
|
|
describe("reopen", function()
|
|
local client
|
|
|
|
local function restart_kong()
|
|
assert(helpers.restart_kong(env))
|
|
|
|
-- ensure we can make at least one successful request after restarting
|
|
assert.eventually(function()
|
|
local httpc = helpers.proxy_client(1000, 15555)
|
|
local res = httpc:get("/")
|
|
res:read_body()
|
|
httpc:close()
|
|
assert.res_status(200, res)
|
|
end)
|
|
.has_no_error("Kong responds to proxy requests after restart")
|
|
end
|
|
|
|
before_each(function()
|
|
client = helpers.proxy_client(1000, 15555)
|
|
end)
|
|
|
|
after_each(function()
|
|
if client then
|
|
client:close()
|
|
end
|
|
end)
|
|
|
|
describe("(disabled)", function()
|
|
it("is the default behavior", function()
|
|
assert.falsy(client.reopen)
|
|
end)
|
|
|
|
it("does not retry requests when the connection is closed by the server", function()
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
restart_kong()
|
|
|
|
res, err = client:send({ method = "GET", path = "/" })
|
|
assert.is_nil(res, "expected request to fail")
|
|
assert.equals("closed", err)
|
|
end)
|
|
|
|
it("does not retry requests when the connection is closed by the client", function()
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
client:close()
|
|
|
|
res, err = client:send({ method = "GET", path = "/" })
|
|
assert.is_nil(res, "expected request to fail")
|
|
assert.equals("closed", err)
|
|
end)
|
|
end)
|
|
|
|
describe("(enabled)", function()
|
|
it("retries requests when a connection is closed by the server", function()
|
|
client.reopen = true
|
|
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
restart_kong()
|
|
|
|
res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
restart_kong()
|
|
|
|
res, err = client:head("/")
|
|
assert.res_status(200, res, err)
|
|
end)
|
|
|
|
it("retries requests when a connection is closed by the client", function()
|
|
client.reopen = true
|
|
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
client:close()
|
|
|
|
res, err = client:head("/")
|
|
assert.res_status(200, res, err)
|
|
end)
|
|
|
|
it("does not retry unsafe requests", function()
|
|
client.reopen = true
|
|
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
restart_kong()
|
|
|
|
res, err = client:send({ method = "POST", path = "/" })
|
|
assert.is_nil(res, "expected request to fail")
|
|
assert.equals("closed", err)
|
|
end)
|
|
|
|
it("raises an exception when reconnection fails", function()
|
|
client.reopen = true
|
|
|
|
-- sanity
|
|
local res, err = client:get("/")
|
|
assert.res_status(200, res, err)
|
|
|
|
helpers.stop_kong(nil, true, true)
|
|
finally(function()
|
|
helpers.start_kong(env, nil, true)
|
|
end)
|
|
|
|
assert.error_matches(function()
|
|
-- using send() instead of get() because get() has an extra
|
|
-- assert() call that might muddy the waters a little bit
|
|
client:send({ method = "GET", path = "/" })
|
|
end, "connection refused")
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("response modifier", function()
|
|
it("fails with bad input", function()
|
|
assert.error(function() assert.response().True(true) end)
|
|
assert.error(function() assert.response(true).True(true) end)
|
|
assert.error(function() assert.response("bad...").True(true) end)
|
|
end)
|
|
it("succeeds with a mock_upstream response", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.response(r).True(true)
|
|
end)
|
|
it("succeeds with a mock upstream response", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/anything",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.response(r).True(true)
|
|
end)
|
|
end)
|
|
|
|
describe("request modifier", function()
|
|
it("fails with bad input", function()
|
|
assert.error(function() assert.request().True(true) end)
|
|
assert.error(function() assert.request(true).True(true) end)
|
|
assert.error(function() assert.request("bad... ").True(true) end)
|
|
end)
|
|
it("succeeds with a mock_upstream response", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.request(r).True(true)
|
|
end)
|
|
it("succeeds with a mock_upstream response", function()
|
|
-- GET request
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.request(r).True(true)
|
|
|
|
-- POST request
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/post",
|
|
body = {
|
|
v1 = "v2",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "www-form-urlencoded",
|
|
},
|
|
})
|
|
assert.request(r).True(true)
|
|
end)
|
|
it("fails with a non mock_upstream response", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/headers", -- this path is not supported, but should yield valid json for the test
|
|
headers = {
|
|
host = "127.0.0.1:15555",
|
|
},
|
|
})
|
|
assert.error(function() assert.request(r).True(true) end)
|
|
end)
|
|
end)
|
|
|
|
describe("contains assertion", function()
|
|
it("verifies content properly", function()
|
|
local arr = { "one", "three" }
|
|
assert.equals(1, assert.contains("one", arr))
|
|
assert.not_contains("two", arr)
|
|
assert.equals(2, assert.contains("ee$", arr, true))
|
|
end)
|
|
end)
|
|
|
|
describe("status assertion", function()
|
|
it("succeeds with a response", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.status(200, r)
|
|
local body = assert.response(r).has.status(200)
|
|
assert(cjson.decode(body))
|
|
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/status/404",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
assert.response(r).has.status(404)
|
|
end)
|
|
it("fails with bad input", function()
|
|
assert.error(function() assert.status(200, nil) end)
|
|
assert.error(function() assert.status(200, {}) end)
|
|
end)
|
|
end)
|
|
|
|
describe("jsonbody assertion", function()
|
|
it("fails with explicit or no parameters", function()
|
|
assert.error(function() assert.jsonbody({}) end)
|
|
assert.error(function() assert.jsonbody() end)
|
|
end)
|
|
it("succeeds on a response object on /request", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
local json = assert.response(r).has.jsonbody()
|
|
assert(json.url:find(helpers.mock_upstream_host), "expected a mock_upstream response")
|
|
end)
|
|
it("succeeds on a mock_upstream request object on /request", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
body = { hello = "world" },
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
local json = assert.request(r).has.jsonbody()
|
|
assert.equals("world", json.params.hello)
|
|
end)
|
|
it("succeeds on a mock_upstream request object on /post", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/post",
|
|
body = { hello = "world" },
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
local json = assert.request(r).has.jsonbody()
|
|
assert.equals("world", json.params.hello)
|
|
end)
|
|
end)
|
|
|
|
describe("header assertion", function()
|
|
it("checks appropriate response headers", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
body = { hello = "world" },
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
local v1 = assert.response(r).has.header("x-powered-by")
|
|
local v2 = assert.response(r).has.header("X-POWERED-BY")
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.response(r).has.header("does not exists") end)
|
|
end)
|
|
it("checks appropriate mock_upstream request headers", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["just-a-test-header"] = "just-a-test-value"
|
|
}
|
|
})
|
|
local v1 = assert.request(r).has.header("just-a-test-header")
|
|
local v2 = assert.request(r).has.header("just-a-test-HEADER")
|
|
assert.equals("just-a-test-value", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.response(r).has.header("does not exists") end)
|
|
end)
|
|
it("checks appropriate mock_upstream request headers", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["just-a-test-header"] = "just-a-test-value"
|
|
}
|
|
})
|
|
local v1 = assert.request(r).has.header("just-a-test-header")
|
|
local v2 = assert.request(r).has.header("just-a-test-HEADER")
|
|
assert.equals("just-a-test-value", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.response(r).has.header("does not exists") end)
|
|
end)
|
|
end)
|
|
|
|
describe("queryParam assertion", function()
|
|
it("checks appropriate mock_upstream query parameters", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/request",
|
|
query = {
|
|
hello = "world",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
},
|
|
})
|
|
local v1 = assert.request(r).has.queryparam("hello")
|
|
local v2 = assert.request(r).has.queryparam("HELLO")
|
|
assert.equals("world", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.response(r).has.queryparam("notHere") end)
|
|
end)
|
|
it("checks appropriate mock_upstream query parameters", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/post",
|
|
query = {
|
|
hello = "world",
|
|
},
|
|
body = {
|
|
hello2 = "world2",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
local v1 = assert.request(r).has.queryparam("hello")
|
|
local v2 = assert.request(r).has.queryparam("HELLO")
|
|
assert.equals("world", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.response(r).has.queryparam("notHere") end)
|
|
end)
|
|
end)
|
|
|
|
describe("formparam assertion", function()
|
|
it("checks appropriate mock_upstream url-encoded form parameters", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/request",
|
|
body = {
|
|
hello = "world",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/x-www-form-urlencoded",
|
|
},
|
|
})
|
|
local v1 = assert.request(r).has.formparam("hello")
|
|
local v2 = assert.request(r).has.formparam("HELLO")
|
|
assert.equals("world", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.request(r).has.queryparam("notHere") end)
|
|
end)
|
|
it("fails with mock_upstream non-url-encoded form data", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/request",
|
|
body = {
|
|
hello = "world",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
assert.error(function() assert.request(r).has.formparam("hello") end)
|
|
end)
|
|
it("checks appropriate mock_upstream url-encoded form parameters", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/post",
|
|
body = {
|
|
hello = "world",
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/x-www-form-urlencoded",
|
|
},
|
|
})
|
|
local v1 = assert.request(r).has.formparam("hello")
|
|
local v2 = assert.request(r).has.formparam("HELLO")
|
|
assert.equals("world", v1)
|
|
assert.equals(v1, v2)
|
|
assert.error(function() assert.request(r).has.queryparam("notHere") end)
|
|
end)
|
|
it("fails with mock_upstream non-url-encoded form parameters", function()
|
|
local r = assert(proxy_client:send {
|
|
method = "POST",
|
|
path = "/post",
|
|
body = {
|
|
hello = "world"
|
|
},
|
|
headers = {
|
|
host = "mock_upstream",
|
|
["Content-Type"] = "application/json",
|
|
},
|
|
})
|
|
assert.error(function() assert.request(r).has.formparam("hello") end)
|
|
end)
|
|
end)
|
|
|
|
|
|
describe("certificates,", function()
|
|
|
|
local function get_cert(server_name)
|
|
local _, _, stdout = assert(helpers.execute(
|
|
string.format("echo 'GET /' | openssl s_client -connect 0.0.0.0:%d -servername %s",
|
|
helpers.get_proxy_port(true), server_name)
|
|
))
|
|
return stdout
|
|
end
|
|
|
|
|
|
it("cn assertion with 2 parameters, positive success", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.has.cn("localhost", cert)
|
|
end)
|
|
|
|
it("cn assertion with 2 parameters, positive failure", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.has.error(function()
|
|
assert.has.cn("some.other.host.org", cert)
|
|
end)
|
|
end)
|
|
|
|
it("cn assertion with 2 parameters, negative success", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.Not.cn("some.other.host.org", cert)
|
|
end)
|
|
|
|
it("cn assertion with 2 parameters, negative failure", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.has.error(function()
|
|
assert.Not.cn("localhost", cert)
|
|
end)
|
|
end)
|
|
|
|
it("cn assertion with modifier and 1 parameter", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.certificate(cert).has.cn("localhost")
|
|
end)
|
|
|
|
it("cn assertion with modifier and 2 parameters fails", function()
|
|
local cert = get_cert("ssl1.com")
|
|
assert.has.error(function()
|
|
assert.certificate(cert).has.cn("localhost", cert)
|
|
end)
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("eventually()", function()
|
|
local function returns(v)
|
|
return function()
|
|
return v
|
|
end
|
|
end
|
|
|
|
local function raises(e)
|
|
return function()
|
|
error(e)
|
|
end
|
|
end
|
|
|
|
local function noop() end
|
|
|
|
local function after_n(n, callback, before)
|
|
local i = 0
|
|
before = before or noop
|
|
|
|
return function()
|
|
i = i + 1
|
|
|
|
if i > n then
|
|
return callback()
|
|
end
|
|
|
|
return before()
|
|
end
|
|
end
|
|
|
|
-- returns a value on the nth time the function is called
|
|
-- otherwise, returns pre_n
|
|
local function return_after_n(n, value, pre_n)
|
|
return after_n(n, returns(value), returns(pre_n))
|
|
end
|
|
|
|
--- raise an error until the function is called n times
|
|
local function raise_for_n(n)
|
|
return after_n(n, noop, raises("not yet"))
|
|
end
|
|
|
|
--- raise an error until the function is called n times
|
|
local function raise_after(n)
|
|
return after_n(n, raises("done"), noop)
|
|
end
|
|
|
|
local function new_timer()
|
|
local start
|
|
local timer = {}
|
|
timer.start = function()
|
|
ngx.update_time()
|
|
start = ngx.now()
|
|
return timer
|
|
end
|
|
|
|
timer.elapsed = function()
|
|
ngx.update_time()
|
|
return ngx.now() - start
|
|
end
|
|
|
|
return timer
|
|
end
|
|
|
|
it("calls a function until a condition is met", function()
|
|
assert.has_no_error(function()
|
|
assert.eventually(return_after_n(10, true))
|
|
.is_truthy()
|
|
end)
|
|
end)
|
|
|
|
it("returns on the first success", function()
|
|
local fn = spy.new(returns(true))
|
|
|
|
assert.has_no_error(function()
|
|
assert.eventually(fn)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.spy(fn).was.called(1)
|
|
|
|
|
|
fn = spy.new(return_after_n(5, true, nil))
|
|
|
|
assert.has_no_error(function()
|
|
assert.eventually(fn)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.spy(fn).was.called(6)
|
|
end)
|
|
|
|
it("gives up after a timeout", function()
|
|
local timer = new_timer().start()
|
|
|
|
local timeout = 0.5
|
|
local sleep = timeout / 10
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(function()
|
|
ngx.sleep(sleep)
|
|
end)
|
|
.with_timeout(timeout)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.near(timeout, timer.elapsed(), 0.1)
|
|
end)
|
|
|
|
describe("max_tries", function()
|
|
it("can limit the number of tries until giving up", function()
|
|
local n = 10
|
|
local fn = spy.new(return_after_n(n, true))
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(fn)
|
|
.with_max_tries(n)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.spy(fn).was.called(n)
|
|
end)
|
|
end)
|
|
|
|
describe("ignore_exceptions", function()
|
|
it("causes raised errors to be treated as a normal failure", function()
|
|
local maybe_raise = raise_for_n(2)
|
|
local eventually_succeed = return_after_n(3, true)
|
|
|
|
local fn = spy.new(function()
|
|
maybe_raise()
|
|
return eventually_succeed()
|
|
end)
|
|
|
|
assert.has_no_error(function()
|
|
assert.eventually(fn)
|
|
.ignore_exceptions(true)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.spy(fn).was.called(6)
|
|
end)
|
|
|
|
it("is turned off by default", function()
|
|
local maybe_raise = raise_for_n(5)
|
|
local eventually_succeed = return_after_n(3, true)
|
|
|
|
local fn = spy.new(function()
|
|
maybe_raise()
|
|
return eventually_succeed()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(fn)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.spy(fn).was.called(1)
|
|
end)
|
|
end)
|
|
|
|
describe("conditions", function()
|
|
it("is_truthy() requires a truthy return value", function()
|
|
assert.has_no_error(function()
|
|
assert.eventually(returns("yup"))
|
|
.is_truthy()
|
|
end)
|
|
|
|
-- it's common knowledge that null is truthy, but let's
|
|
-- test it anyways
|
|
assert.has_no_error(function()
|
|
assert.eventually(returns(ngx.null))
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns(false))
|
|
.with_timeout(0.001)
|
|
.is_truthy()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns(nil))
|
|
.with_timeout(0.001)
|
|
.is_truthy()
|
|
end)
|
|
end)
|
|
|
|
it("is_falsy() requires a falsy return value", function()
|
|
assert.has_no_error(function()
|
|
assert.eventually(returns(nil))
|
|
.is_falsy()
|
|
end)
|
|
|
|
assert.has_no_error(function()
|
|
assert.eventually(returns(false))
|
|
.is_falsy()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns(true))
|
|
.with_timeout(0.001)
|
|
.is_falsy()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns("yup"))
|
|
.with_timeout(0.001)
|
|
.is_falsy()
|
|
end)
|
|
|
|
-- it's common knowledge that null is truthy, but let's
|
|
-- test it anyways
|
|
assert.has_error(function()
|
|
assert.eventually(returns(ngx.null))
|
|
.with_timeout(0.001)
|
|
.is_falsy()
|
|
end)
|
|
end)
|
|
|
|
it("has_no_error() requires the function not to raise an error()", function()
|
|
assert.has_no_error(function()
|
|
assert.eventually(returns(true))
|
|
.has_no_error()
|
|
end)
|
|
|
|
assert.has_no_error(function()
|
|
-- note: raise_until() does not return any value in the success case
|
|
assert.eventually(raise_for_n(5))
|
|
.has_no_error()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(error)
|
|
.with_timeout(0.001)
|
|
.has_no_error()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(error)
|
|
.with_timeout(0.001)
|
|
.has_no_error()
|
|
end)
|
|
end)
|
|
|
|
it("has_error() requires the function to raise an error()", function()
|
|
assert.has_no_error(function()
|
|
assert.eventually(error)
|
|
.has_error()
|
|
end)
|
|
|
|
assert.has_no_error(function()
|
|
assert.eventually(raise_after(5))
|
|
.has_error()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns(true))
|
|
.with_timeout(0.001)
|
|
.has_error()
|
|
end)
|
|
|
|
assert.has_error(function()
|
|
assert.eventually(returns(false))
|
|
.with_timeout(0.001)
|
|
.has_error()
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("failure messages", function()
|
|
-- for reference, here's an example of an assertion that will fail:
|
|
|
|
--[[
|
|
local n = 0
|
|
assert
|
|
.eventually(function()
|
|
n = n + 1
|
|
|
|
if n < 3 then
|
|
error("I have raised an error, n = " .. tostring(n))
|
|
end
|
|
|
|
-- yup, you can return non-string error values
|
|
return nil, { n = n, err = "nope, not yet" }
|
|
end)
|
|
.with_timeout(0.1)
|
|
.ignore_exceptions(true)
|
|
.is_truthy("something should have worked by now")
|
|
]]--
|
|
|
|
-- ...and here is the assertion failure/output produced:
|
|
|
|
--[[
|
|
|
|
spec/02-integration/01-helpers/01-helpers_spec.lua:20: Failed to assert eventual condition:
|
|
|
|
"something should have worked by now"
|
|
|
|
Result: timed out after 0.10000014305115s
|
|
|
|
Last raised error:
|
|
|
|
"spec/02-integration/01-helpers/01-helpers_spec.lua:13: I have raised an error, n = 2"
|
|
|
|
|
|
stack traceback:
|
|
[C]: in function 'error'
|
|
spec/02-integration/01-helpers/01-helpers_spec.lua:13: in function <spec/02-integration/01-helpers/01-helpers_spec.lua:9>
|
|
[C]: in function 'xpcall'
|
|
./spec/helpers/wait.lua:187: in function 'wait'
|
|
./spec/helpers/wait.lua:315: in function 'callback'
|
|
...ild/bin/build/kong-dev/share/lua/5.1/luassert/assert.lua:43: in function 'is_truthy'
|
|
spec/02-integration/01-helpers/01-helpers_spec.lua:20: in function <spec/02-integration/01-helpers/01-helpers_spec.lua:7>
|
|
[C]: in function 'xpcall'
|
|
...stbuild/bin/build/kong-dev/share/lua/5.1/busted/core.lua:178: in function 'safe'
|
|
...stbuild/bin/build/kong-dev/share/lua/5.1/busted/init.lua:40: in function 'executor'
|
|
...
|
|
...stbuild/bin/build/kong-dev/share/lua/5.1/busted/core.lua:314: in function <...stbuild/bin/build/kong-dev/share/lua/5.1/busted/core.lua:314>
|
|
[C]: in function 'xpcall'
|
|
...stbuild/bin/build/kong-dev/share/lua/5.1/busted/core.lua:178: in function 'safe'
|
|
...stbuild/bin/build/kong-dev/share/lua/5.1/busted/core.lua:314: in function 'execute'
|
|
...uild/bin/build/kong-dev/share/lua/5.1/busted/execute.lua:58: in function 'execute'
|
|
...build/bin/build/kong-dev/share/lua/5.1/busted/runner.lua:186: in function <...build/bin/build/kong-dev/share/lua/5.1/busted/runner.lua:11>
|
|
/home/michaelm/git/kong/kong/bin/busted:63: in function 'file_gen'
|
|
init_worker_by_lua:52: in function <init_worker_by_lua:50>
|
|
[C]: in function 'xpcall'
|
|
init_worker_by_lua:59: in function <init_worker_by_lua:57>
|
|
|
|
Last returned error:
|
|
|
|
{
|
|
err = "nope, not yet",
|
|
n = 3
|
|
}
|
|
|
|
---
|
|
|
|
Timeout = 0.1
|
|
Step = 0.05
|
|
Elapsed = 0.10000014305115
|
|
Tries = 3
|
|
Raised = true
|
|
|
|
]]--
|
|
|
|
it("truthy", function()
|
|
local e = assert.has_error(function()
|
|
assert.eventually(function()
|
|
return false, "nope!"
|
|
end)
|
|
.with_timeout(0.01)
|
|
.is_truthy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.contains("Last returned error:", lines, true)
|
|
assert.contains("nope!", lines, true)
|
|
|
|
assert.contains("Last returned value:", lines, true)
|
|
assert.contains("false", lines, true)
|
|
|
|
assert.not_contains("Last raised error:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
assert.contains("Raised%s+= false", lines, true)
|
|
end)
|
|
|
|
it("truthy + error() + ignore_exceptions=false", function()
|
|
local e = assert.has_error(function()
|
|
assert.eventually(raises("my error"))
|
|
.with_timeout(0.01)
|
|
.is_truthy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: error() raised", lines, true)
|
|
|
|
assert.not_contains("Last returned error:", lines, true)
|
|
assert.not_contains("Last returned value:", lines, true)
|
|
|
|
assert.contains("Last raised error:", lines, true)
|
|
assert.contains("my error", lines, true)
|
|
|
|
assert.contains("stack traceback:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
-- note: only one try because of the uncaught exception
|
|
assert.contains("Tries%s+= 1", lines, true)
|
|
assert.contains("Raised%s+= true", lines, true)
|
|
end)
|
|
|
|
it("truthy + error() + ignore_execptions=true", function()
|
|
local e = assert.has_error(function()
|
|
local n = 0
|
|
assert.eventually(function()
|
|
n = n + 1
|
|
if n < 2 then
|
|
return nil, "some error"
|
|
end
|
|
|
|
error("some exception")
|
|
end)
|
|
.ignore_exceptions(true)
|
|
.with_timeout(0.01)
|
|
.is_truthy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.contains("Last returned error:", lines, true)
|
|
assert.contains("some error", lines, true)
|
|
|
|
assert.not_contains("Last returned value:", lines, true)
|
|
|
|
assert.contains("Last raised error:", lines, true)
|
|
assert.contains("some exception", lines, true)
|
|
assert.contains("stack traceback:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
-- note: raised = true
|
|
assert.contains("Raised%s+= true", lines, true)
|
|
end)
|
|
|
|
|
|
it("falsy", function()
|
|
local e = assert.has_error(function()
|
|
assert.eventually(returns("yup"))
|
|
.with_timeout(0.01)
|
|
.is_falsy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.contains("Last returned value:", lines, true)
|
|
assert.contains("yup", lines, true)
|
|
|
|
assert.not_contains("Last raised error:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
assert.contains("Raised%s+= false", lines, true)
|
|
end)
|
|
|
|
it("falsy + error() + ignore_exceptions=false", function()
|
|
local e = assert.has_error(function()
|
|
assert.eventually(raises("my error"))
|
|
.with_timeout(0.01)
|
|
.is_falsy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: error() raised", lines, true)
|
|
|
|
assert.not_contains("Last returned error:", lines, true)
|
|
assert.not_contains("Last returned value:", lines, true)
|
|
|
|
assert.contains("Last raised error:", lines, true)
|
|
assert.contains("my error", lines, true)
|
|
assert.contains("stack traceback:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
-- note: only one try because of the uncaught exception
|
|
assert.contains("Tries%s+= 1", lines, true)
|
|
assert.contains("Raised%s+= true", lines, true)
|
|
end)
|
|
|
|
it("falsy + error() + ignore_execptions=true", function()
|
|
local e = assert.has_error(function()
|
|
local n = 0
|
|
assert.eventually(function()
|
|
n = n + 1
|
|
if n < 2 then
|
|
return "maybe"
|
|
end
|
|
|
|
error("some exception")
|
|
end)
|
|
.ignore_exceptions(true)
|
|
.with_timeout(0.01)
|
|
.is_falsy("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.not_contains("Last returned error:", lines, true)
|
|
|
|
assert.contains("Last returned value:", lines, true)
|
|
assert.contains("maybe", lines, true)
|
|
|
|
assert.contains("Last raised error:", lines, true)
|
|
assert.contains("some exception", lines, true)
|
|
assert.contains("stack traceback:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
assert.contains("Raised%s+= true", lines, true)
|
|
end)
|
|
|
|
|
|
it("has_no_error", function()
|
|
local e = assert.has_error(function()
|
|
assert.eventually(raises("don't raise me, bro"))
|
|
.with_timeout(0.01)
|
|
.has_no_error("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.contains("Last raised error:", lines, true)
|
|
assert.contains("don't raise me, bro", lines, true)
|
|
assert.contains("stack traceback:", lines, true)
|
|
|
|
assert.not_contains("Last returned value:", lines, true)
|
|
assert.not_contains("Last returned error:", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
assert.contains("Raised%s+= true", lines, true)
|
|
end)
|
|
|
|
|
|
it("has_error", function()
|
|
local e = assert.has_error(function()
|
|
local n = 0
|
|
assert.eventually(function()
|
|
n = n + 1
|
|
if n < 2 then
|
|
return false, "my returned error"
|
|
else
|
|
return "my return value"
|
|
end
|
|
end)
|
|
.with_timeout(0.01)
|
|
.has_error("foo condition")
|
|
end)
|
|
|
|
assert.is_string(e.message)
|
|
local lines = splitlines(e.message)
|
|
|
|
assert.contains("Failed to assert eventual condition", lines, true)
|
|
assert.contains("foo condition", lines, true)
|
|
|
|
assert.contains("Result: timed out", lines, true)
|
|
|
|
assert.not_contains("Last raised error:", lines, true)
|
|
|
|
assert.contains("Last returned value:", lines, true)
|
|
assert.contains("my return value", lines, true)
|
|
|
|
assert.contains("Last returned error:", lines, true)
|
|
assert.contains("my returned error", lines, true)
|
|
|
|
assert.contains("Timeout%s+= ", lines, true)
|
|
assert.contains("Step%s+=", lines, true)
|
|
assert.contains("Elapsed%s+=", lines, true)
|
|
assert.contains("Tries%s+=", lines, true)
|
|
assert.contains("Raised%s+= false", lines, true)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
end)
|
|
end
|
|
|
|
describe("helpers: utilities", function()
|
|
describe("get_version()", function()
|
|
it("gets the version of Kong running", function()
|
|
local meta = require 'kong.meta'
|
|
local version = require 'version'
|
|
assert.equal(version(meta._VERSION), helpers.get_version())
|
|
end)
|
|
end)
|
|
|
|
describe("wait_until()", function()
|
|
it("does not raise an error when the function returns truth-y", function()
|
|
assert.has_no_error(function()
|
|
local i = 0
|
|
helpers.wait_until(function()
|
|
i = i + 1
|
|
return i > 1
|
|
end, 3)
|
|
end)
|
|
end)
|
|
|
|
it("raises an error if the function does not return truth-y within the timeout", function()
|
|
assert.error_matches(function()
|
|
helpers.wait_until(function()
|
|
return false, "thing still not done"
|
|
end, 1)
|
|
end, "timed out")
|
|
end)
|
|
|
|
it("fails when test function raises an error()", function()
|
|
local e = assert.has_error(function()
|
|
helpers.wait_until(function()
|
|
error("oops")
|
|
end, 1)
|
|
end)
|
|
assert.is_string(e.message)
|
|
assert.matches("oops", e.message)
|
|
end)
|
|
|
|
it("fails when test function raised an assertion error", function()
|
|
assert.has_error(function()
|
|
helpers.wait_until(function()
|
|
assert.is_true(false)
|
|
end, 1)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("pwait_until()", function()
|
|
it("succeeds when a function does not raise an error()", function()
|
|
assert.has_no_error(function()
|
|
local i = 0
|
|
helpers.pwait_until(function()
|
|
i = i + 1
|
|
|
|
if i < 5 then
|
|
error("i is less than 5")
|
|
end
|
|
|
|
assert.is_true(i > 6)
|
|
end, 1)
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("wait_for_file_contents()", function()
|
|
local function time()
|
|
ngx.update_time()
|
|
return ngx.now()
|
|
end
|
|
|
|
it("returns the file contents when the file is readable and non-empty", function()
|
|
local fname = assert(helpers.path.tmpname())
|
|
assert(helpers.file.write(fname, "test"))
|
|
|
|
assert.equals("test", helpers.wait_for_file_contents(fname))
|
|
end)
|
|
|
|
it("waits for the file if need be", function()
|
|
local fname = assert(helpers.path.tmpname())
|
|
assert(os.remove(fname))
|
|
|
|
local timeout = 2
|
|
local delay = 1
|
|
local start, duration
|
|
|
|
local sema = require("ngx.semaphore").new()
|
|
|
|
local ok, res
|
|
ngx.timer.at(0, function()
|
|
ngx.update_time()
|
|
start = time()
|
|
|
|
ok, res = pcall(helpers.wait_for_file_contents, fname, timeout)
|
|
|
|
ngx.update_time()
|
|
duration = time() - start
|
|
sema:post(1)
|
|
end)
|
|
|
|
ngx.sleep(delay)
|
|
assert(helpers.file.write(fname, "test"))
|
|
|
|
assert.truthy(sema:wait(timeout),
|
|
"timed out waiting for timer to finish")
|
|
|
|
assert.truthy(ok, "timer raised an error: " .. tostring(res))
|
|
assert.equals("test", res)
|
|
|
|
assert.near(delay, duration, delay * 0.25,
|
|
"expected wait_for_file_contents to return in " ..
|
|
"~" .. delay .. " seconds")
|
|
end)
|
|
|
|
it("doesn't wait longer than the timeout in the failure case", function()
|
|
local fname = assert(helpers.path.tmpname())
|
|
|
|
local timeout = 1
|
|
local start, duration
|
|
|
|
local sema = require("ngx.semaphore").new()
|
|
|
|
local ok, err
|
|
ngx.timer.at(0, function()
|
|
ngx.update_time()
|
|
start = time()
|
|
|
|
ok, err = pcall(helpers.wait_for_file_contents, fname, timeout)
|
|
|
|
ngx.update_time()
|
|
duration = time() - start
|
|
sema:post(1)
|
|
end)
|
|
|
|
assert.truthy(sema:wait(timeout * 1.5),
|
|
"timed out waiting for timer to finish")
|
|
|
|
assert.falsy(ok, "expected wait_for_file_contents to fail")
|
|
assert.not_nil(err)
|
|
|
|
assert.near(timeout, duration, timeout * 0.25,
|
|
"expected wait_for_file_contents to timeout after " ..
|
|
"~" .. timeout .. " seconds")
|
|
end)
|
|
|
|
|
|
it("raises an assertion error if the file does not exist", function()
|
|
assert.error_matches(function()
|
|
helpers.wait_for_file_contents("/i/do/not/exist", 0)
|
|
end, "does not exist or is not readable")
|
|
end)
|
|
|
|
it("raises an assertion error if the file is empty", function()
|
|
local fname = assert(helpers.path.tmpname())
|
|
|
|
assert.error_matches(function()
|
|
helpers.wait_for_file_contents(fname, 0)
|
|
end, "exists but is empty")
|
|
end)
|
|
end)
|
|
|
|
describe("clean_logfile()", function()
|
|
it("truncates a file", function()
|
|
local fname = assert(os.tmpname())
|
|
assert(helpers.file.write(fname, "some data\nand some more data\n"))
|
|
assert(helpers.path.getsize(fname) > 0)
|
|
|
|
finally(function()
|
|
os.remove(fname)
|
|
end)
|
|
|
|
helpers.clean_logfile(fname)
|
|
assert(helpers.path.getsize(fname) == 0)
|
|
end)
|
|
|
|
it("truncates the test conf error.log file if no input is given", function()
|
|
local log_dir = helpers.path.join(helpers.test_conf.prefix, "logs")
|
|
if not helpers.path.exists(log_dir) then
|
|
assert(helpers.dir.makepath(log_dir))
|
|
finally(function()
|
|
finally(function()
|
|
helpers.dir.rmtree(log_dir)
|
|
end)
|
|
end)
|
|
end
|
|
|
|
local fname = helpers.path.join(log_dir, "error.log")
|
|
assert(helpers.file.write(fname, "some data\nand some more data\n"))
|
|
assert(helpers.path.getsize(fname) > 0)
|
|
|
|
helpers.clean_logfile(fname)
|
|
assert(helpers.path.getsize(fname) == 0)
|
|
end)
|
|
|
|
it("creates an empty file if one does not exist", function()
|
|
local fname = assert(os.tmpname())
|
|
assert(os.remove(fname))
|
|
assert(not helpers.path.exists(fname))
|
|
|
|
helpers.clean_logfile(fname)
|
|
|
|
finally(function()
|
|
os.remove(fname)
|
|
end)
|
|
|
|
assert(helpers.path.isfile(fname))
|
|
assert(helpers.path.getsize(fname) == 0)
|
|
end)
|
|
|
|
|
|
it("doesn't raise an error if the parent directory does not exist", function()
|
|
local fname = "/tmp/i-definitely/do-not-exist." .. ngx.worker.pid()
|
|
assert(not helpers.path.exists(fname))
|
|
|
|
assert.has_no_error(function()
|
|
helpers.clean_logfile(fname)
|
|
end)
|
|
end)
|
|
|
|
it("raises an error if the path is not a file", function()
|
|
local path = os.tmpname()
|
|
os.remove(path)
|
|
assert(helpers.dir.makepath(path))
|
|
assert(helpers.path.isdir(path))
|
|
|
|
finally(function()
|
|
helpers.dir.rmtree(path)
|
|
end)
|
|
|
|
assert.error_matches(function()
|
|
helpers.clean_logfile(path)
|
|
end, "Is a directory")
|
|
end)
|
|
end)
|
|
|
|
describe("partial_match()", function()
|
|
describe("positive mod", function()
|
|
it("allows to match to tables paritally", function()
|
|
local partial_table = {
|
|
x = 100,
|
|
y = {
|
|
z = 200
|
|
}
|
|
}
|
|
local full_table = {
|
|
x = 100,
|
|
a = "test1",
|
|
y = {
|
|
b = "test2",
|
|
z = 200
|
|
}
|
|
}
|
|
|
|
assert.partial_match(partial_table, full_table)
|
|
end)
|
|
|
|
it("fails if tables do not match paritally", function()
|
|
local partial_table = {
|
|
x = 100,
|
|
y = {
|
|
z = 77
|
|
}
|
|
}
|
|
local full_table = {
|
|
x = 100,
|
|
a = "test1",
|
|
y = {
|
|
b = "test2",
|
|
z = 200
|
|
}
|
|
}
|
|
|
|
local ok, err_actual = pcall(function() assert.partial_match(partial_table, full_table) end)
|
|
assert.falsy(ok)
|
|
assert.matches(".*Values at key %(string%) 'y%.z' should be equal but are not.\nExpected: %(number%) 77, given: %(number%) 200\n", err_actual.message)
|
|
end)
|
|
end)
|
|
|
|
describe("negative mod", function()
|
|
it("allows to verify if tables do not match", function()
|
|
local partial_table = {
|
|
x = 77,
|
|
y = {
|
|
z = 88
|
|
}
|
|
}
|
|
|
|
local full_table = {
|
|
x = 100,
|
|
a = "test1",
|
|
y = {
|
|
b = "test2",
|
|
z = 200
|
|
}
|
|
}
|
|
|
|
assert.does_not.partial_match(partial_table, full_table)
|
|
end)
|
|
|
|
it("fails if tables do match paritally", function()
|
|
local partial_table = {
|
|
x = 100,
|
|
y = {
|
|
z = 77
|
|
}
|
|
}
|
|
local full_table = {
|
|
x = 100,
|
|
a = "test1",
|
|
y = {
|
|
b = "test2",
|
|
z = 200
|
|
}
|
|
}
|
|
|
|
local ok, err_actual = pcall(function() assert.does_not.partial_match(partial_table, full_table) end)
|
|
assert.falsy(ok)
|
|
assert.matches(".*Values at key %(string%) 'x' should not be equal", err_actual.message)
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|