wehub-resource-sync
395 lines
13 KiB
Lua
395 lines
13 KiB
Lua
local helpers = require "spec.helpers"
|
|
local fixtures = require "spec.fixtures.aws-lambda"
|
|
|
|
|
|
for _, strategy in helpers.each_strategy() do
|
|
describe("[AWS Lambda] request-util [#" .. strategy .. "]", function()
|
|
local proxy_client
|
|
local admin_client
|
|
|
|
lazy_setup(function()
|
|
local bp, db = helpers.get_db_utils(strategy, {
|
|
"routes",
|
|
"services",
|
|
"plugins",
|
|
}, { "aws-lambda" })
|
|
|
|
|
|
local route1 = bp.routes:insert {
|
|
hosts = { "gw.skipfile.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route1.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = true,
|
|
forward_request_body = true,
|
|
skip_large_bodies = true,
|
|
},
|
|
}
|
|
|
|
local route2 = bp.routes:insert {
|
|
hosts = { "gw.readfile.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route2.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = true,
|
|
forward_request_body = true,
|
|
skip_large_bodies = false,
|
|
},
|
|
}
|
|
|
|
local route3 = bp.routes:insert {
|
|
hosts = { "plain.skipfile.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route3.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = false,
|
|
forward_request_body = true,
|
|
skip_large_bodies = true,
|
|
},
|
|
}
|
|
|
|
local route4 = bp.routes:insert {
|
|
hosts = { "plain.readfile.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route4.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = false,
|
|
forward_request_body = true,
|
|
skip_large_bodies = false,
|
|
},
|
|
}
|
|
|
|
local route5 = bp.routes:insert {
|
|
hosts = { "base.sixtyfour.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route5.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = false,
|
|
forward_request_body = true,
|
|
skip_large_bodies = false,
|
|
--base64_encode_body = true,
|
|
},
|
|
}
|
|
|
|
local route6 = bp.routes:insert {
|
|
hosts = { "notbase.sixtyfour.test" },
|
|
}
|
|
bp.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route6.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = false,
|
|
forward_request_body = true,
|
|
skip_large_bodies = false,
|
|
base64_encode_body = false,
|
|
},
|
|
}
|
|
|
|
local route7 = db.routes:insert {
|
|
hosts = { "gw.serviceless.test" },
|
|
}
|
|
db.plugins:insert {
|
|
name = "aws-lambda",
|
|
route = { id = route7.id },
|
|
config = {
|
|
port = 10001,
|
|
aws_key = "mock-key",
|
|
aws_secret = "mock-secret",
|
|
aws_region = "us-east-1",
|
|
function_name = "kongLambdaTest",
|
|
awsgateway_compatible = true,
|
|
forward_request_body = true,
|
|
skip_large_bodies = true,
|
|
},
|
|
}
|
|
|
|
|
|
assert(helpers.start_kong({
|
|
database = strategy,
|
|
plugins = "aws-lambda",
|
|
nginx_conf = "spec/fixtures/custom_nginx.template",
|
|
}, nil, nil, fixtures))
|
|
end)
|
|
|
|
before_each(function()
|
|
proxy_client = helpers.proxy_client()
|
|
admin_client = helpers.admin_client()
|
|
local shell = require "resty.shell"
|
|
shell.run(":> " .. helpers.test_conf.nginx_err_logs, nil, 0) -- clean log files
|
|
end)
|
|
|
|
after_each(function ()
|
|
proxy_client:close()
|
|
admin_client:close()
|
|
end)
|
|
|
|
lazy_teardown(function()
|
|
helpers.stop_kong()
|
|
end)
|
|
|
|
|
|
describe("plain:", function() -- plain serialization, not AWS gateway compatible
|
|
|
|
describe("when skip_large_bodies is true", function()
|
|
|
|
it("it skips file-buffered body > max buffer size", function()
|
|
local request_body = ("a"):rep(32 * 1024) -- 32 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "plain.skipfile.test"
|
|
},
|
|
body = request_body
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal("", body.request_body) -- empty because it was skipped
|
|
assert.logfile().has.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
|
|
it("it reads body < max buffer size", function()
|
|
local request_body = ("a"):rep(1 * 1024) -- 1 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "plain.skipfile.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.request_body) -- matches because it was small enough
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
end)
|
|
|
|
|
|
|
|
describe("when skip_large_bodies is false", function()
|
|
|
|
it("it reads file-buffered body > max buffer size", function()
|
|
local request_body = ("a"):rep(32 * 1024) -- 32 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "plain.readfile.test"
|
|
},
|
|
body = request_body
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.request_body) -- matches because it was read from file
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
|
|
it("it reads body < max buffer size", function()
|
|
local request_body = ("a"):rep(1 * 1024) -- 1 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "plain.readfile.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.request_body) -- matches because it was small enough
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
end)
|
|
end)
|
|
|
|
|
|
|
|
describe("aws-gw:", function() -- AWS gateway compatible serialization
|
|
|
|
describe("when skip_large_bodies is true", function()
|
|
|
|
it("it skips file-buffered body > max buffer size", function()
|
|
local request_body = ("a"):rep(32 * 1024) -- 32 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "gw.skipfile.test"
|
|
},
|
|
body = request_body
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal("", body.body) -- empty because it was skipped
|
|
assert.logfile().has.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
|
|
it("it reads body < max buffer size", function()
|
|
local request_body = ("a"):rep(1 * 1024) -- 1 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "gw.skipfile.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.body) -- matches because it was small enough
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
end)
|
|
|
|
|
|
|
|
describe("when skip_large_bodies is false", function()
|
|
|
|
it("it reads file-buffered body > max buffer size", function()
|
|
local request_body = ("a"):rep(32 * 1024) -- 32 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "gw.readfile.test"
|
|
},
|
|
body = request_body
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.body) -- matches because it was read from file
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
|
|
it("it reads body < max buffer size", function()
|
|
local request_body = ("a"):rep(1 * 1024) -- 1 kb
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "gw.readfile.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
assert.equal(ngx.encode_base64(request_body), body.body) -- matches because it was small enough
|
|
assert.logfile().has.no.line("request body was buffered to disk, too large", true)
|
|
end)
|
|
|
|
end)
|
|
end)
|
|
|
|
|
|
|
|
describe("base64 body encoding", function()
|
|
|
|
it("enabled", function()
|
|
local request_body = ("encodemeplease")
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "base.sixtyfour.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.equal(ngx.encode_base64(request_body), body.request_body)
|
|
end)
|
|
|
|
|
|
it("disabled", function()
|
|
local request_body = ("donotencodemeplease")
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "notbase.sixtyfour.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
local body = assert.response(res).has.jsonbody()
|
|
assert.equal(request_body, body.request_body)
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("serviceless plugin", function()
|
|
|
|
it("serviceless", function()
|
|
local request_body = ("encodemeplease")
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get?key1=some_value1&key2=some_value2&key3=some_value3",
|
|
headers = {
|
|
["Host"] = "gw.serviceless.test"
|
|
},
|
|
body = request_body,
|
|
})
|
|
assert.response(res).has.status(200, res)
|
|
assert.is_string(res.headers["x-amzn-RequestId"])
|
|
end)
|
|
end)
|
|
|
|
end)
|
|
end
|