wehub-resource-sync
1040 lines
31 KiB
Lua
1040 lines
31 KiB
Lua
local meta = require "kong.meta"
|
|
local helpers = require "spec.helpers"
|
|
local constants = require "kong.constants"
|
|
local cjson = require "cjson"
|
|
local uuid = require("kong.tools.uuid").uuid
|
|
|
|
|
|
local default_server_header = meta._SERVER_TOKENS
|
|
local default_via_value = "1.1 " .. default_server_header
|
|
|
|
for _, strategy in helpers.each_strategy() do
|
|
describe("headers [#" .. strategy .. "]", function()
|
|
|
|
local function stop()
|
|
helpers.stop_kong()
|
|
end
|
|
|
|
describe("Server/Via", function()
|
|
local proxy_client
|
|
local bp
|
|
|
|
local function start(config)
|
|
return function()
|
|
bp.routes:insert {
|
|
hosts = { "headers-inspect.test" },
|
|
}
|
|
|
|
local route = bp.routes:insert {
|
|
hosts = { "short-circuit.test" },
|
|
}
|
|
|
|
bp.plugins:insert {
|
|
route = route,
|
|
name = "request-termination",
|
|
config = {
|
|
status_code = 200,
|
|
message = "Terminated"
|
|
},
|
|
}
|
|
|
|
bp.plugins:insert {
|
|
route = route,
|
|
name = "response-transformer",
|
|
config = {
|
|
add = {
|
|
headers = {
|
|
"Via:" .. default_server_header,
|
|
"Server:" .. "Demo",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
config = config or {}
|
|
config.database = strategy
|
|
config.nginx_conf = "spec/fixtures/custom_nginx.template"
|
|
|
|
assert(helpers.start_kong(config))
|
|
end
|
|
end
|
|
|
|
lazy_setup(function()
|
|
bp = helpers.get_db_utils(strategy, {
|
|
"routes",
|
|
"services",
|
|
}, {
|
|
"error-generator",
|
|
})
|
|
end)
|
|
|
|
before_each(function()
|
|
proxy_client = helpers.proxy_client()
|
|
end)
|
|
|
|
after_each(function()
|
|
if proxy_client then
|
|
proxy_client:close()
|
|
end
|
|
end)
|
|
|
|
describe("(with default configuration values)", function()
|
|
|
|
lazy_setup(start())
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' header but not change the 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header but not the Kong 'Via' header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
end)
|
|
|
|
it("should not return Kong 'Server' header when short-circuited with a matching Kong 'Via' #new", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "short-circuit.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.equal(default_server_header, res.headers["Via"])
|
|
assert.equal("Demo", res.headers["Server"])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = Via)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "Via",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' header but not touch 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
assert.not_equal(default_via_value, res.headers["server"])
|
|
end)
|
|
|
|
it("should not return Kong 'Via' header or Kong 'Via' header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers["via"])
|
|
assert.is_nil(res.headers["server"])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = Server)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "Server",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should not return Kong 'Via' header but not change the 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header but not the Kong 'Via' header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = server_tokens)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "server_tokens",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' header but not change the 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header but not the Kong 'Via' header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with no server_tokens in headers)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "off",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should not return Kong 'Via' header but it should forward the 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.response(res).has.header "server"
|
|
assert.response(res).has_not.header "via"
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
end)
|
|
|
|
it("should not return Kong 'Server' or 'Via' headers when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
end)
|
|
|
|
end)
|
|
end)
|
|
|
|
describe("X-Kong-Proxy-Latency/X-Kong-Upstream-Latency", function()
|
|
local proxy_client
|
|
local bp
|
|
local db
|
|
|
|
local function start(config)
|
|
return function()
|
|
bp.routes:insert {
|
|
hosts = { "headers-inspect.test" },
|
|
}
|
|
|
|
local service = bp.services:insert({
|
|
protocol = helpers.mock_upstream_protocol,
|
|
host = helpers.mock_upstream_host,
|
|
port = 1, -- wrong port
|
|
})
|
|
|
|
bp.routes:insert({
|
|
service = service,
|
|
hosts = { "502.test" }
|
|
})
|
|
|
|
bp.routes:insert {
|
|
hosts = { "error-rewrite.test" },
|
|
}
|
|
|
|
local access_error_route = bp.routes:insert {
|
|
hosts = { "error-access.test" },
|
|
}
|
|
|
|
bp.plugins:insert {
|
|
name = "error-generator",
|
|
route = { id = access_error_route.id },
|
|
config = {
|
|
access = true,
|
|
},
|
|
}
|
|
|
|
local header_filter_error_route = bp.routes:insert {
|
|
hosts = { "error-header-filter.test" },
|
|
}
|
|
|
|
bp.plugins:insert {
|
|
name = "error-generator",
|
|
route = { id = header_filter_error_route.id },
|
|
config = {
|
|
header_filter = true,
|
|
},
|
|
}
|
|
|
|
local request_termination_route = bp.routes:insert({
|
|
service = service,
|
|
hosts = { "request-termination.test" }
|
|
})
|
|
|
|
bp.plugins:insert {
|
|
name = "request-termination",
|
|
route = { id = request_termination_route.id },
|
|
}
|
|
|
|
config = config or {}
|
|
config.database = strategy
|
|
config.nginx_conf = "spec/fixtures/custom_nginx.template"
|
|
|
|
assert(helpers.start_kong(config))
|
|
end
|
|
end
|
|
|
|
lazy_setup(function()
|
|
bp, db = helpers.get_db_utils(strategy, {
|
|
"routes",
|
|
"services",
|
|
}, {
|
|
"error-generator",
|
|
})
|
|
end)
|
|
|
|
before_each(function()
|
|
proxy_client = helpers.proxy_client()
|
|
end)
|
|
|
|
after_each(function()
|
|
if proxy_client then
|
|
proxy_client:close()
|
|
end
|
|
end)
|
|
|
|
describe("(with default configuration values)", function()
|
|
|
|
lazy_setup(start())
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not be returned when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not be returned when request is short-circuited", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "request-termination.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(503, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should be returned when response status code is included in error_page directive (error_page not executing)", function()
|
|
for _, code in ipairs({ 400, 404, 408, 411, 412, 413, 414, 417, 494, 500, 502, 503, 504 }) do
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/status/" .. code,
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(code, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end
|
|
end)
|
|
|
|
it("should be returned with 502 errors (error_page executing)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "502.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(502, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
-- Too painfull to get this to work with dbless (need to start new Kong process etc.)
|
|
if strategy ~= "off" then
|
|
it("should not be returned when plugin errors on rewrite phase", function()
|
|
local admin_client = helpers.admin_client()
|
|
local uuid = uuid()
|
|
local res = assert(admin_client:send {
|
|
method = "PUT",
|
|
path = "/plugins/" .. uuid,
|
|
body = {
|
|
name = "error-generator",
|
|
config = {
|
|
rewrite = true,
|
|
}
|
|
},
|
|
headers = {["Content-Type"] = "application/json"}
|
|
})
|
|
assert.res_status(200, res)
|
|
admin_client:close()
|
|
|
|
helpers.wait_until(function()
|
|
res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "error-rewrite.test",
|
|
}
|
|
})
|
|
|
|
return pcall(function()
|
|
assert.res_status(500, res)
|
|
end)
|
|
end, 10)
|
|
|
|
db.plugins:delete({ id = uuid })
|
|
|
|
assert.res_status(500, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
end
|
|
|
|
it("should not be returned when plugin errors on access phase", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "error-access.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(500, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
|
|
-- TODO: currently we don't handle errors from plugins on header_filter or body_filter.
|
|
pending("should be returned even when plugin errors on header filter phase", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "error-header-filter.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(500, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = latency_tokens)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "latency_tokens",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test"
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not be returned when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = X-Kong-Upstream-Latency)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "X-Kong-Upstream-Latency",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return 'X-Kong-Upstream-Latency' header but not 'X-Kong-Proxy-Latency' when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test"
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not return any latency header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = X-Kong-Proxy-Latency)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "X-Kong-Proxy-Latency",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return 'X-Kong-Proxy-Latency' header but not 'X-Kong-Upstream-Latency' when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test"
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not return any latency header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers = X-Kong-Response-Latency)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "X-Kong-Response-Latency",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should not return 'X-Kong-Proxy-Latency', 'X-Kong-Upstream-Latency' or 'X-Kong-Response-Latency' headers when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test"
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should return 'X-Kong-Response-Latency' when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with no latency_tokens in headers)", function()
|
|
|
|
lazy_setup(start {
|
|
headers = "off",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should not be returned when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should not be returned when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.UPSTREAM_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
|
|
describe("(with headers='server_tokens, X-Kong-Proxy-Latency')", function()
|
|
|
|
lazy_setup(start{
|
|
headers = "server_tokens, X-Kong-Proxy-Latency",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' and 'X-Kong-Proxy-Latency' header but not change the 'Server' header when request was proxied", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header but not the Kong 'Via' or 'X-Kong-Proxy-Latency' header when no API matched (no proxy)", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("can be specified via configuration file", function()
|
|
-- A regression test added with https://github.com/Kong/kong/pull/3419
|
|
-- to ensure that the `headers` configuration value can be specified
|
|
-- via the configuration file (vs. environment variables as the rest
|
|
-- of this test suite uses).
|
|
-- This regression occurred because of the dumping of config values into
|
|
-- .kong_env (and the lack of serialization for the `headers` table).
|
|
assert(helpers.kong_exec("restart -c spec/fixtures/headers.conf"))
|
|
|
|
local admin_client = helpers.admin_client()
|
|
local res = assert(admin_client:send {
|
|
method = "GET",
|
|
path = "/",
|
|
})
|
|
local body = assert.res_status(200, res)
|
|
local json = cjson.decode(body)
|
|
assert.equal("server_tokens", json.configuration.headers[1])
|
|
assert.equal("X-Kong-Proxy-Latency", json.configuration.headers[2])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers='server_tokens, off, X-Kong-Proxy-Latency')", function()
|
|
|
|
lazy_setup(start{
|
|
headers = "server_tokens, off, X-Kong-Proxy-Latency",
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' and 'X-Kong-Proxy-Latency' header as 'off' will not take effect", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header as 'off' will not take effect", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
end)
|
|
end)
|
|
|
|
describe("case insensitiveness", function()
|
|
local proxy_client
|
|
local bp
|
|
|
|
local function start(config)
|
|
return function()
|
|
bp.routes:insert {
|
|
hosts = { "headers-inspect.test" },
|
|
}
|
|
|
|
config = config or {}
|
|
config.database = strategy
|
|
config.nginx_conf = "spec/fixtures/custom_nginx.template"
|
|
|
|
assert(helpers.start_kong(config))
|
|
end
|
|
end
|
|
|
|
lazy_setup(function()
|
|
bp = helpers.get_db_utils(strategy, {
|
|
"routes",
|
|
"services",
|
|
})
|
|
end)
|
|
|
|
before_each(function()
|
|
proxy_client = helpers.proxy_client()
|
|
end)
|
|
|
|
after_each(function()
|
|
if proxy_client then
|
|
proxy_client:close()
|
|
end
|
|
end)
|
|
|
|
describe("are case insensitive", function()
|
|
|
|
lazy_setup(start{
|
|
headers = "serVer_TokEns, x-kOng-pRoXy-lAtency"
|
|
})
|
|
|
|
lazy_teardown(stop)
|
|
|
|
it("should return Kong 'Via' and 'X-Kong-Proxy-Latency' header", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "headers-inspect.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(200, res)
|
|
assert.not_equal(default_server_header, res.headers["server"])
|
|
assert.equal(default_via_value, res.headers["via"])
|
|
assert.is_not_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
|
|
it("should return Kong 'Server' header", function()
|
|
local res = assert(proxy_client:send {
|
|
method = "GET",
|
|
path = "/get",
|
|
headers = {
|
|
host = "404.test",
|
|
}
|
|
})
|
|
|
|
assert.res_status(404, res)
|
|
assert.equal(default_server_header, res.headers["server"])
|
|
assert.is_nil(res.headers["via"])
|
|
assert.is_nil(res.headers[constants.HEADERS.PROXY_LATENCY])
|
|
assert.is_nil(res.headers[constants.HEADERS.RESPONSE_LATENCY])
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("Admin API", function()
|
|
local admin_client
|
|
|
|
local function start(config)
|
|
return function()
|
|
config = config or {}
|
|
config.database = strategy
|
|
config.nginx_conf = "spec/fixtures/custom_nginx.template"
|
|
|
|
assert(helpers.start_kong(config))
|
|
end
|
|
end
|
|
|
|
before_each(function()
|
|
admin_client = helpers.admin_client()
|
|
end)
|
|
|
|
after_each(function()
|
|
if admin_client then
|
|
admin_client:close()
|
|
end
|
|
end)
|
|
|
|
describe("Server", function()
|
|
describe("(with default configuration values)", function()
|
|
lazy_setup(start())
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.SERVER])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = server_tokens)", function()
|
|
lazy_setup(start {
|
|
headers = "server_tokens",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.SERVER])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = Server)", function()
|
|
lazy_setup(start {
|
|
headers = "Server",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.SERVER])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = off)", function()
|
|
lazy_setup(start {
|
|
headers = "off",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should not be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.SERVER])
|
|
end)
|
|
end)
|
|
end)
|
|
|
|
describe("X-Kong-Admin-Latency", function()
|
|
describe("(with default configuration values)", function()
|
|
lazy_setup(start())
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.ADMIN_LATENCY])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = latency_tokens)", function()
|
|
lazy_setup(start {
|
|
headers = "latency_tokens",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.ADMIN_LATENCY])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = X-Kong-Admin-Latency)", function()
|
|
lazy_setup(start {
|
|
headers = "latency_tokens",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_not_nil(res.headers[constants.HEADERS.ADMIN_LATENCY])
|
|
end)
|
|
end)
|
|
|
|
describe("(with headers = off)", function()
|
|
lazy_setup(start {
|
|
headers = "off",
|
|
})
|
|
lazy_teardown(stop)
|
|
|
|
it("should not be returned when admin api is requested", function()
|
|
local res = assert(admin_client:get("/"))
|
|
assert.res_status(200, res)
|
|
assert.is_nil(res.headers[constants.HEADERS.ADMIN_LATENCY])
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
end)
|
|
end
|