wehub-resource-sync
128 lines
3.5 KiB
Lua
128 lines
3.5 KiB
Lua
local helpers = require "spec.helpers"
|
|
local merge = kong.table.merge
|
|
local cjson = require "cjson"
|
|
|
|
for _, strategy in helpers.all_strategies() do
|
|
describe("db.key_sets #" .. strategy, function()
|
|
local bp, db, keyset, jwk, pem_pub, pem_priv
|
|
|
|
lazy_setup(function()
|
|
bp, db = helpers.get_db_utils(strategy ~= "off" and strategy or nil, {
|
|
"keys",
|
|
"key_sets"})
|
|
|
|
local jwk_pub, jwk_priv = helpers.generate_keys("JWK")
|
|
pem_pub, pem_priv = helpers.generate_keys("PEM")
|
|
|
|
jwk = merge(cjson.decode(jwk_pub), cjson.decode(jwk_priv))
|
|
|
|
keyset = assert(bp.key_sets:insert {
|
|
name = "testset",
|
|
})
|
|
end)
|
|
|
|
lazy_teardown(function()
|
|
db:truncate("keys")
|
|
db:truncate("key_sets")
|
|
end)
|
|
|
|
it(":select returns an item", function()
|
|
local key_set, err = kong.db.key_sets:select(keyset)
|
|
assert.is_nil(err)
|
|
assert(key_set.name == keyset.name)
|
|
end)
|
|
|
|
it(":insert creates a keyset with name 'this'", function()
|
|
local key_set, err = kong.db.key_sets:insert {
|
|
name = "this"
|
|
}
|
|
assert.is_nil(err)
|
|
assert(key_set.name == "this")
|
|
end)
|
|
|
|
it(":delete works", function()
|
|
local key_set, err = kong.db.key_sets:insert {
|
|
name = "that"
|
|
}
|
|
assert.is_nil(err)
|
|
assert(key_set.name == "that")
|
|
local ok, d_err = kong.db.key_sets:delete(key_set)
|
|
assert.is_nil(d_err)
|
|
assert.is_truthy(ok)
|
|
end)
|
|
|
|
it(":update updates a keyset's fields", function()
|
|
local key_set, err = kong.db.key_sets:update(keyset, {
|
|
name = "changed"
|
|
})
|
|
assert.is_nil(err)
|
|
assert(key_set.name == "changed")
|
|
end)
|
|
|
|
it(":delete cascades correctly", function ()
|
|
local key_set, err = kong.db.key_sets:insert {
|
|
name = "deletecascade"
|
|
}
|
|
assert(key_set.name == "deletecascade")
|
|
assert.is_nil(err)
|
|
local key, ins_err = kong.db.keys:insert {
|
|
name = "testkey",
|
|
kid = jwk.kid,
|
|
set = key_set,
|
|
jwk = cjson.encode(jwk)
|
|
}
|
|
assert.is_nil(ins_err)
|
|
-- verify creation
|
|
local key_select, select_err = kong.db.keys:select(key)
|
|
assert.is_nil(select_err)
|
|
assert.is_not_nil(key_select)
|
|
-- delete the set
|
|
local ok, d_err = kong.db.key_sets:delete(key_set)
|
|
assert.is_true(ok)
|
|
assert.is_nil(d_err)
|
|
-- verify if key is gone
|
|
local key_select_deleted, select_deleted_err = kong.db.keys:select(key)
|
|
assert.is_nil(select_deleted_err)
|
|
assert.is_nil(key_select_deleted)
|
|
end)
|
|
|
|
it("allows to have multiple keys with different formats in a set", function ()
|
|
local key_set, err = kong.db.key_sets:insert {
|
|
name = "multikeys"
|
|
}
|
|
assert(key_set.name == "multikeys")
|
|
assert.is_nil(err)
|
|
local pem_key, ins_err = kong.db.keys:insert {
|
|
name = "pem_k",
|
|
kid = "2",
|
|
set = key_set,
|
|
pem = {
|
|
private_key = pem_priv,
|
|
public_key = pem_pub,
|
|
}
|
|
}
|
|
assert.is_nil(ins_err)
|
|
assert.is_not_nil(pem_key)
|
|
|
|
local jwk, jwk_ins_err = kong.db.keys:insert {
|
|
name = "jwk_k",
|
|
kid = jwk.kid,
|
|
jwk = cjson.encode(jwk),
|
|
set = key_set,
|
|
}
|
|
assert.is_nil(jwk_ins_err)
|
|
assert.is_not_nil(jwk)
|
|
|
|
local rows = {}
|
|
local i = 1
|
|
for row, err_t in kong.db.keys:each_for_set(key_set) do
|
|
assert.is_nil(err_t)
|
|
rows[i] = row
|
|
i = i + 1
|
|
end
|
|
assert.is_nil(err)
|
|
assert.is_same(2, #rows)
|
|
end)
|
|
end)
|
|
end
|