Rename controller to nginx

controllers/nginx/lua/vendor/lua-resty-http/t/01-basic.t

@@ -0,0 +1,231 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4) + 1;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Simple default get.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            ngx.status = res.status
+            ngx.print(res:read_body())
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        echo "OK";
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: HTTP 1.0
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                version = 1.0,
+                path = "/b"
+            }
+
+            ngx.status = res.status
+            ngx.print(res:read_body())
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        echo "OK";
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3: Status code
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            ngx.status = res.status
+            ngx.print(res:read_body())
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.status = 404
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- error_code: 404
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 4: Response headers
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            ngx.status = res.status
+            ngx.say(res.headers["X-Test"])
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.header["X-Test"] = "x-value"
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+x-value
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 5: Query
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                query = {
+                    a = 1,
+                    b = 2,
+                },
+                path = "/b"
+            }
+
+            ngx.status = res.status
+
+            for k,v in pairs(res.headers) do
+                ngx.header[k] = v
+            end
+
+            ngx.print(res:read_body())
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            for k,v in pairs(ngx.req.get_uri_args()) do
+                ngx.header["X-Header-" .. string.upper(k)] = v
+            end
+        ';
+    }
+--- request
+GET /a
+--- response_headers
+X-Header-A: 1
+X-Header-B: 2
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 7: HEAD has no body.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                method = "HEAD",
+                path = "/b"
+            }
+
+            local body = res:read_body()
+
+            if body then
+                ngx.print(body)
+            end
+            httpc:close()
+        ';
+    }
+    location = /b {
+        echo "OK";
+    }
+--- request
+GET /a
+--- response_body
+--- no_error_log
+[error]
+[warn]
+

controllers/nginx/lua/vendor/lua-resty-http/t/02-chunked.t

@@ -0,0 +1,158 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Non chunked.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            local body = res:read_body()
+
+            ngx.say(#body)
+            httpc:close()
+        ';
+    }
+    location = /b {
+        chunked_transfer_encoding off;
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32768
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Chunked. The number of chunks received when no max size is given proves the response was in fact chunked.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            local chunks = {}
+            local c = 1
+            repeat
+                local chunk, err = res.body_reader()
+                if chunk then
+                    chunks[c] = chunk
+                    c = c + 1
+                end
+            until not chunk
+
+            local body = table.concat(chunks)
+
+            ngx.say(#body)
+            ngx.say(#chunks)
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+65536
+2
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3: Chunked using read_body method.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            local body = res:read_body()
+
+            ngx.say(#body)
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+65536
+--- no_error_log
+[error]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/03-requestbody.t

@@ -0,0 +1,185 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: POST form-urlencoded
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                body = "a=1&b=2&c=3",
+                path = "/b",
+                headers = {
+                    ["Content-Type"] = "application/x-www-form-urlencoded",
+                }
+            }
+
+            ngx.say(res:read_body())
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.req.read_body()
+            local args = ngx.req.get_post_args()
+            ngx.say("a: ", args.a)
+            ngx.say("b: ", args.b)
+            ngx.print("c: ", args.c)
+        ';
+    }
+--- request
+GET /a
+--- response_body
+a: 1
+b: 2
+c: 3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: POST form-urlencoded 1.0
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                method = "POST",
+                body = "a=1&b=2&c=3",
+                path = "/b",
+                headers = {
+                    ["Content-Type"] = "application/x-www-form-urlencoded",
+                },
+                version = 1.0,
+            }
+
+            ngx.say(res:read_body())
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.req.read_body()
+            local args = ngx.req.get_post_args()
+            ngx.say(ngx.req.get_method())
+            ngx.say("a: ", args.a)
+            ngx.say("b: ", args.b)
+            ngx.print("c: ", args.c)
+        ';
+    }
+--- request
+GET /a
+--- response_body
+POST
+a: 1
+b: 2
+c: 3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3: 100 Continue does not end requset
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                body = "a=1&b=2&c=3",
+                path = "/b",
+                headers = {
+                    ["Expect"] = "100-continue",
+                    ["Content-Type"] = "application/x-www-form-urlencoded",
+                }
+            }
+            ngx.say(res.status)
+            ngx.say(res:read_body())
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.req.read_body()
+            local args = ngx.req.get_post_args()
+            ngx.say("a: ", args.a)
+            ngx.say("b: ", args.b)
+            ngx.print("c: ", args.c)
+        ';
+    }
+--- request
+GET /a
+--- response_body
+200
+a: 1
+b: 2
+c: 3
+--- no_error_log
+[error]
+[warn]
+
+=== TEST 4: Return non-100 status to user
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                headers = {
+                    ["Expect"] = "100-continue",
+                    ["Content-Type"] = "application/x-www-form-urlencoded",
+                }
+            }
+            if not res then
+                ngx.say(err)
+            end
+            ngx.say(res.status)
+            ngx.say(res:read_body())
+            httpc:close()
+        ';
+    }
+    location = /b {
+        return 417 "Expectation Failed";
+    }
+--- request
+GET /a
+--- response_body
+417
+Expectation Failed
+--- no_error_log
+[error]
+[warn]
+

controllers/nginx/lua/vendor/lua-resty-http/t/04-trailers.t

@@ -0,0 +1,151 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Trailers. Check Content-MD5 generated after the body is sent matches up.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b",
+                headers = {
+                    ["TE"] = "trailers",
+                }
+            }
+
+            local body = res:read_body()
+            local hash = ngx.md5(body)
+            res:read_trailers()
+
+            if res.headers["Content-MD5"] == hash then
+                ngx.say("OK")
+            else
+                ngx.say(res.headers["Content-MD5"])
+            end
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            -- We use the raw socket to compose a response, since OpenResty
+            -- doesnt support trailers natively.
+
+            ngx.req.read_body()
+            local sock, err = ngx.req.socket(true)
+            if not sock then
+                ngx.say(err)
+            end
+
+            local res = {}
+            table.insert(res, "HTTP/1.1 200 OK")
+            table.insert(res, "Date: " .. ngx.http_time(ngx.time()))
+            table.insert(res, "Transfer-Encoding: chunked")
+            table.insert(res, "Trailer: Content-MD5")
+            table.insert(res, "")
+
+            local body = "Hello, World"
+
+            table.insert(res, string.format("%x", #body))
+            table.insert(res, body)
+            table.insert(res, "0")
+            table.insert(res, "")
+        
+            table.insert(res, "Content-MD5: " .. ngx.md5(body))
+
+            table.insert(res, "")
+            table.insert(res, "")
+            sock:send(table.concat(res, "\\r\\n"))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Advertised trailer does not exist, handled gracefully.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local res, err = httpc:request{
+                path = "/b",
+                headers = {
+                    ["TE"] = "trailers",
+                }
+            }
+
+            local body = res:read_body()
+            local hash = ngx.md5(body)
+            res:read_trailers()
+
+            ngx.say("OK")
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            -- We use the raw socket to compose a response, since OpenResty
+            -- doesnt support trailers natively.
+
+            ngx.req.read_body()
+            local sock, err = ngx.req.socket(true)
+            if not sock then
+                ngx.say(err)
+            end
+
+            local res = {}
+            table.insert(res, "HTTP/1.1 200 OK")
+            table.insert(res, "Date: " .. ngx.http_time(ngx.time()))
+            table.insert(res, "Transfer-Encoding: chunked")
+            table.insert(res, "Trailer: Content-MD5")
+            table.insert(res, "")
+
+            local body = "Hello, World"
+
+            table.insert(res, string.format("%x", #body))
+            table.insert(res, body)
+            table.insert(res, "0")
+            
+            table.insert(res, "")
+            table.insert(res, "")
+            sock:send(table.concat(res, "\\r\\n"))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+

controllers/nginx/lua/vendor/lua-resty-http/t/05-stream.t

@@ -0,0 +1,566 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4) - 1;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Chunked streaming body reader returns the right content length.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+            }
+
+            local chunks = {}
+            repeat
+                local chunk = res.body_reader()
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(res.headers["Transfer-Encoding"])
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32768
+chunked
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Non-Chunked streaming body reader returns the right content length.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+            }
+
+            local chunks = {}
+            repeat
+                local chunk = res.body_reader()
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(res.headers["Transfer-Encoding"])
+            ngx.say(#chunks)
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        chunked_transfer_encoding off;
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32768
+nil
+1
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2b: Non-Chunked streaming body reader, buffer size becomes nil
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+            }
+
+            local chunks = {}
+            local buffer_size = 16384
+            repeat
+                local chunk = res.body_reader(buffer_size)
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+
+                buffer_size = nil
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(res.headers["Transfer-Encoding"])
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        chunked_transfer_encoding off;
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+nil
+--- error_log
+Buffer size not specified, bailing
+
+
+=== TEST 3: HTTP 1.0 body reader with no max size returns the right content length.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                version = 1.0,
+            }
+
+            local chunks = {}
+            repeat
+                local chunk = res.body_reader()
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(res.headers["Transfer-Encoding"])
+            ngx.say(#chunks)
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        chunked_transfer_encoding off;
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32768
+nil
+1
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 4: HTTP 1.0 body reader with max chunk size returns the right content length.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                version = 1.0,
+            }
+
+            local chunks = {}
+            local size = 8192
+            repeat
+                local chunk = res.body_reader(size)
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+                size = size + size
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(res.headers["Transfer-Encoding"])
+            ngx.say(#chunks)
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        chunked_transfer_encoding off;
+        content_by_lua '
+            local len = 32769
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32769
+nil
+3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 4b: HTTP 1.0 body reader with no content length, stream works as expected.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                version = 1.0,
+            }
+
+            local chunks = {}
+            local size = 8192
+            repeat
+                local chunk = res.body_reader(size)
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+                size = size + size
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(#chunks)
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.req.read_body()
+            local sock, err = ngx.req.socket(true)
+            if not sock then
+                ngx.say(err)
+            end
+
+            local res = {}
+            table.insert(res, "HTTP/1.0 200 OK")
+            table.insert(res, "Date: " .. ngx.http_time(ngx.time()))
+            table.insert(res, "")
+
+            local len = 32769
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            table.insert(res, table.concat(t))
+            sock:send(table.concat(res, "\\r\\n"))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32769
+3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 5: Chunked streaming body reader with max chunk size returns the right content length.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+            }
+
+            local chunks = {}
+            local size = 8192
+            repeat
+                local chunk = res.body_reader(size)
+                if chunk then
+                    table.insert(chunks, chunk)
+                end
+                size = size + size
+            until not chunk
+
+            local body = table.concat(chunks)
+            ngx.say(#body)
+            ngx.say(res.headers["Transfer-Encoding"])
+            ngx.say(#chunks)
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            local len = 32768
+            local t = {}
+            for i=1,len do
+                t[i] = 0
+            end
+            ngx.print(table.concat(t))
+        ';
+    }
+--- request
+GET /a
+--- response_body
+32768
+chunked
+3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 6: Request reader correctly reads body
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        lua_need_request_body off;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+
+            local reader, err = httpc:get_client_body_reader(8192)
+
+            repeat
+                local chunk, err = reader()
+                if chunk then
+                    ngx.print(chunk)
+                end
+            until chunk == nil
+
+        ';
+    }
+
+--- request
+POST /a
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- response_body: foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- no_error_log
+[error]
+[warn]
+
+=== TEST 7: Request reader correctly reads body in chunks
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        lua_need_request_body off;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+
+            local reader, err = httpc:get_client_body_reader(64)
+
+            local chunks = 0
+            repeat
+                chunks = chunks +1
+                local chunk, err = reader()
+                if chunk then
+                    ngx.print(chunk)
+                end
+            until chunk == nil
+            ngx.say("\\n"..chunks)
+        ';
+    }
+
+--- request
+POST /a
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- response_body
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+3
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 8: Request reader passes into client
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        lua_need_request_body off;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local reader, err = httpc:get_client_body_reader(64)
+
+            local res, err = httpc:request{
+                method = POST,
+                path = "/b",
+                body = reader,
+                headers = ngx.req.get_headers(100, true),
+            }
+
+            local body = res:read_body()
+            ngx.say(body)
+            httpc:close()
+
+        ';
+    }
+
+    location = /b {
+        content_by_lua '
+            ngx.req.read_body()
+            local body, err = ngx.req.get_body_data()
+            ngx.print(body)
+        ';
+    }
+
+--- request
+POST /a
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- response_body
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 9: Body reader is a function returning nil when no body is present.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                method = "HEAD",
+            }
+
+            repeat
+                local chunk = res.body_reader()
+            until not chunk
+
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.exit(200)
+        ';
+    }
+--- request
+GET /a
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 10: Issue a notice (but do not error) if trying to read the request body in a subrequest
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        echo_location /b;
+    }
+    location = /b {
+        lua_need_request_body off;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+
+            local reader, err = httpc:get_client_body_reader(8192)
+            if not reader then
+                ngx.log(ngx.NOTICE, err)
+                return
+            end
+
+            repeat
+                local chunk, err = reader()
+                if chunk then
+                    ngx.print(chunk)
+                end
+            until chunk == nil
+        ';
+    }
+
+--- request
+POST /a
+foobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbazfoobarbaz
+--- response_body: 
+--- no_error_log
+[error]
+[warn]
+--- error_log
+attempt to read the request body in a subrequest

controllers/nginx/lua/vendor/lua-resty-http/t/06-simpleinterface.t

@@ -0,0 +1,145 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4) + 6;
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Simple URI interface
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local res, err = httpc:request_uri("http://127.0.0.1:"..ngx.var.server_port.."/b?a=1&b=2")
+            
+            if not res then
+                ngx.log(ngx.ERR, err)
+            end
+            ngx.status = res.status
+
+            ngx.header["X-Header-A"] = res.headers["X-Header-A"]
+            ngx.header["X-Header-B"] = res.headers["X-Header-B"]
+
+            ngx.print(res.body)
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            for k,v in pairs(ngx.req.get_uri_args()) do
+                ngx.header["X-Header-" .. string.upper(k)] = v
+            end
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_headers
+X-Header-A: 1
+X-Header-B: 2
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Simple URI interface HTTP 1.0
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local res, err = httpc:request_uri(
+                "http://127.0.0.1:"..ngx.var.server_port.."/b?a=1&b=2", {
+                }
+            )
+            
+            ngx.status = res.status
+            
+            ngx.header["X-Header-A"] = res.headers["X-Header-A"]
+            ngx.header["X-Header-B"] = res.headers["X-Header-B"]
+
+            ngx.print(res.body)
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            for k,v in pairs(ngx.req.get_uri_args()) do
+                ngx.header["X-Header-" .. string.upper(k)] = v
+            end
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_headers
+X-Header-A: 1
+X-Header-B: 2
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3 Simple URI interface, params override
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local res, err = httpc:request_uri(
+                "http://127.0.0.1:"..ngx.var.server_port.."/b?a=1&b=2", {
+                    path = "/c",
+                    query = {
+                        a = 2,
+                        b = 3,
+                    },
+                }
+            )
+            
+            ngx.status = res.status
+            
+            ngx.header["X-Header-A"] = res.headers["X-Header-A"]
+            ngx.header["X-Header-B"] = res.headers["X-Header-B"]
+
+            ngx.print(res.body)
+        ';
+    }
+    location = /c {
+        content_by_lua '
+            for k,v in pairs(ngx.req.get_uri_args()) do
+                ngx.header["X-Header-" .. string.upper(k)] = v
+            end
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_headers
+X-Header-A: 2
+X-Header-B: 3
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/07-keepalive.t

@@ -0,0 +1,182 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1 Simple interface, Connection: Keep-alive. Test the connection is reused.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local res, err = httpc:request_uri(
+                "http://127.0.0.1:"..ngx.var.server_port.."/b", {
+                }
+            )
+
+            ngx.say(res.headers["Connection"])
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+keep-alive
+1
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2 Simple interface, Connection: close, test we don't try to keepalive, but also that subsequent connections can keepalive.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local res, err = httpc:request_uri(
+                "http://127.0.0.1:"..ngx.var.server_port.."/b", {
+                    version = 1.0,
+                    headers = {
+                        ["Connection"] = "close",
+                    },
+                }
+            )
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+            
+            httpc:set_keepalive()
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+0
+1
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3 Generic interface, Connection: Keep-alive. Test the connection is reused.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            local body = res:read_body()
+
+            ngx.say(res.headers["Connection"])
+            ngx.say(httpc:set_keepalive())
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+keep-alive
+1
+1
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 4 Generic interface, Connection: Close. Test we don't try to keepalive, but also that subsequent connections can keepalive.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                version = 1.0,
+                headers = {
+                    ["Connection"] = "Close",
+                },
+                path = "/b"
+            }
+
+            local body = res:read_body()
+
+            ngx.say(res.headers["Connection"])
+            local r, e = httpc:set_keepalive()
+            ngx.say(r)
+            ngx.say(e)
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+
+            httpc:set_keepalive()
+
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            ngx.say(httpc:get_reused_times())
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+close
+2
+connection must be closed
+0
+1
+--- no_error_log
+[error]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/08-pipeline.t

@@ -0,0 +1,143 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1 Test that pipelined reqests can be read correctly.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            
+            local responses = httpc:request_pipeline{
+                {
+                    path = "/b",
+                },
+                {
+                    path = "/c",
+                },
+                {
+                    path = "/d",
+                }
+            }
+
+            for i,r in ipairs(responses) do
+                if r.status then
+                    ngx.say(r.status)
+                    ngx.say(r.headers["X-Res"])
+                    ngx.say(r:read_body())
+                end
+            end
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["X-Res"] = "B"
+            ngx.print("B")
+        ';
+    }
+    location = /c {
+        content_by_lua '
+            ngx.status = 404
+            ngx.header["X-Res"] = "C"
+            ngx.print("C")
+        ';
+    }
+    location = /d {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["X-Res"] = "D"
+            ngx.print("D")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+200
+B
+B
+404
+C
+C
+200
+D
+D
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Test we can handle timeouts on reading the pipelined requests.
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            httpc:set_timeout(1)
+            
+            local responses = httpc:request_pipeline{
+                {
+                    path = "/b",
+                },
+                {
+                    path = "/c",
+                },
+            }
+
+            for i,r in ipairs(responses) do
+                if r.status then
+                    ngx.say(r.status)
+                    ngx.say(r.headers["X-Res"])
+                    ngx.say(r:read_body())
+                end
+            end
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["X-Res"] = "B"
+            ngx.print("B")
+        ';
+    }
+    location = /c {
+        content_by_lua '
+            ngx.status = 404
+            ngx.header["X-Res"] = "C"
+            ngx.sleep(1)
+            ngx.print("C")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+200
+B
+B
+--- no_error_log
+[warn]
+--- error_log eval
+[qr/timeout/]

controllers/nginx/lua/vendor/lua-resty-http/t/09-ssl.t

@@ -0,0 +1,59 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: parse_uri returns port 443 for https URIs
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local parsed = httpc:parse_uri("https://www.google.com/foobar")
+            ngx.say(parsed[3])
+        ';
+    }
+--- request
+GET /a
+--- response_body
+443
+--- no_error_log
+[error]
+[warn]
+
+=== TEST 2: parse_uri returns port 80 for http URIs
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            local parsed = httpc:parse_uri("http://www.google.com/foobar")
+            ngx.say(parsed[3])
+        ';
+    }
+--- request
+GET /a
+--- response_body
+80
+--- no_error_log
+[error]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/10-clientbodyreader.t

@@ -0,0 +1,57 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Issue a notice (but do not error) if trying to read the request body in a subrequest
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        echo_location /b;
+    }
+    location = /b {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/c",
+                headers = {
+                    ["Content-Type"] = "application/x-www-form-urlencoded",
+                }
+            }
+            if not res then
+                ngx.say(err)
+            end
+            ngx.print(res:read_body())
+            httpc:close()
+        ';
+    }
+    location /c {
+        echo "OK";
+    }
+--- request
+GET /a
+--- response_body
+OK
+--- no_error_log
+[error]
+[warn]
+

controllers/nginx/lua/vendor/lua-resty-http/t/11-proxy.t

@@ -0,0 +1,152 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 5);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Proxy GET request and response
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a_prx {
+        rewrite ^(.*)_prx$ $1 break;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            httpc:proxy_response(httpc:proxy_request())
+            httpc:set_keepalive()
+        ';
+    }
+    location = /a {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["X-Test"] = "foo"
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a_prx
+--- response_body
+OK
+--- response_headers
+X-Test: foo
+--- error_code: 200
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Proxy POST request and response
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a_prx {
+        rewrite ^(.*)_prx$ $1 break;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            httpc:proxy_response(httpc:proxy_request())
+            httpc:set_keepalive()
+        ';
+    }
+    location = /a {
+        lua_need_request_body on;
+        content_by_lua '
+            ngx.status = 404
+            ngx.header["X-Test"] = "foo"
+            local args, err = ngx.req.get_post_args()
+            ngx.say(args["foo"])
+            ngx.say(args["hello"])
+        ';
+    }
+--- request
+POST /a_prx
+foo=bar&hello=world
+--- response_body
+bar
+world
+--- response_headers
+X-Test: foo
+--- error_code: 404
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3: Proxy multiple headers
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a_prx {
+        rewrite ^(.*)_prx$ $1 break;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            httpc:proxy_response(httpc:proxy_request())
+            httpc:set_keepalive()
+        ';
+    }
+    location = /a {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["Set-Cookie"] = { "cookie1", "cookie2" }
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a_prx
+--- response_body
+OK
+--- raw_response_headers_like: .*Set-Cookie: cookie1\r\nSet-Cookie: cookie2\r\n
+--- error_code: 200
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 4: Proxy still works with spaces in URI
+--- http_config eval: $::HttpConfig
+--- config
+    location = "/a_ b_prx" {
+        rewrite ^(.*)_prx$ $1 break;
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+            httpc:proxy_response(httpc:proxy_request())
+            httpc:set_keepalive()
+        ';
+    }
+    location = "/a_ b" {
+        content_by_lua '
+            ngx.status = 200
+            ngx.header["X-Test"] = "foo"
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a_%20b_prx
+--- response_body
+OK
+--- response_headers
+X-Test: foo
+--- error_code: 200
+--- no_error_log
+[error]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/12-case_insensitive_headers.t

@@ -0,0 +1,160 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 4);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: Test header normalisation
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http_headers = require "resty.http_headers"
+
+            local headers = http_headers.new()
+
+            headers.x_a_header = "a"
+            headers["x-b-header"] = "b"
+            headers["X-C-Header"] = "c"
+            headers["X_d-HEAder"] = "d"
+
+            ngx.say(headers["X-A-Header"])
+            ngx.say(headers.x_b_header)
+            
+            for k,v in pairs(headers) do
+                ngx.say(k, ": ", v)
+            end
+        ';
+    }
+--- request
+GET /a
+--- response_body
+a
+b
+x-b-header: b
+x-a-header: a
+X-d-HEAder: d
+X-C-Header: c
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 2: Test headers can be accessed in all cases
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b"
+            }
+
+            ngx.status = res.status
+            ngx.say(res.headers["X-Foo-Header"])
+            ngx.say(res.headers["x-fOo-heaDeR"])
+            ngx.say(res.headers.x_foo_header)
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.header["X-Foo-Header"] = "bar"
+            ngx.say("OK")
+        ';
+    }
+--- request
+GET /a
+--- response_body
+bar
+bar
+bar
+--- no_error_log
+[error]
+[warn]
+
+
+=== TEST 3: Test request headers are normalised
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            httpc:connect("127.0.0.1", ngx.var.server_port)
+
+            local res, err = httpc:request{
+                path = "/b",
+                headers = {
+                    ["uSeR-AgENT"] = "test_user_agent",
+                    x_foo = "bar",
+                },
+            }
+
+            ngx.status = res.status
+            ngx.print(res:read_body())
+            
+            httpc:close()
+        ';
+    }
+    location = /b {
+        content_by_lua '
+            ngx.say(ngx.req.get_headers()["User-Agent"])
+            ngx.say(ngx.req.get_headers()["X-Foo"])
+        ';
+    }
+--- request
+GET /a
+--- response_body
+test_user_agent
+bar
+--- no_error_log
+[error]
+
+
+=== TEST 4: Test that headers remain unique
+--- http_config eval: $::HttpConfig
+--- config
+    location = /a {
+        content_by_lua '
+            local http_headers = require "resty.http_headers"
+
+            local headers = http_headers.new()
+
+            headers["x-a-header"] = "a"
+            headers["X-A-HEAder"] = "b"
+
+            for k,v in pairs(headers) do
+            ngx.log(ngx.DEBUG, k, ": ", v)
+                ngx.header[k] = v
+            end
+        ';
+    }
+--- request
+GET /a
+--- response_headers
+x-a-header: b
+--- no_error_log
+[error]
+[warn]
+[warn]

controllers/nginx/lua/vendor/lua-resty-http/t/13-default-path.t

@@ -0,0 +1,52 @@
+# vim:set ft= ts=4 sw=4 et:
+
+use Test::Nginx::Socket;
+use Cwd qw(cwd);
+
+plan tests => repeat_each() * (blocks() * 3);
+
+my $pwd = cwd();
+
+our $HttpConfig = qq{
+    lua_package_path "$pwd/lib/?.lua;;";
+    error_log logs/error.log debug;
+};
+
+$ENV{TEST_NGINX_RESOLVER} = '8.8.8.8';
+
+no_long_string();
+#no_diff();
+
+run_tests();
+
+__DATA__
+=== TEST 1: request_uri (check the default path)
+--- http_config eval: $::HttpConfig
+--- config
+    location /lua {
+        content_by_lua '
+            local http = require "resty.http"
+            local httpc = http.new()
+            
+            local res, err = httpc:request_uri("http://127.0.0.1:"..ngx.var.server_port)
+
+            if res and 200 == res.status then
+                ngx.say("OK")
+            else
+                ngx.say("FAIL")
+            end
+        ';
+    }
+
+    location =/ {
+        content_by_lua '
+            ngx.print("OK")
+        ';
+    }
+--- request
+GET /lua
+--- response_body
+OK
+--- no_error_log
+[error]
+