Version: 2.11

Introducing APISIX’s testing framework

APISIX uses a testing framework based on our fork of test-nginx: https://github.com/iresty/test-nginx. For details, you can check the documentation of this project.

If you want to test the CLI behavior of APISIX (./bin/apisix), you need to write a shell script in the t/cli directory to test it. You can refer to the existing test scripts for more details.

If you want to test the others, you need to write test code based on the framework.

Here, we briefly describe how to do simple testing based on this framework.

Test file

you need to write test cases in the t/ directory, in a corresponding .t file. Note that a single test file should not exceed 800 lines, and if it is too long, it needs to be divided by a suffix. For example:

  1. t/
  2. ├── admin
  3. │ ├── consumers.t
  4. │ ├── consumers2.t

Both consumers.t and consumers2.t contain tests for consumers in the Admin API.

Some of the test files start with this paragraph:

  1. add_block_preprocessor(sub {
  2.     my ($block) = @_;
  5.     if (! $block->request) {
  6.         $block->set_value("request", "GET /t");
  7.     }
  10.     if (! $block->no_error_log && ! $block->error_log) {
  11.         $block->set_value("no_error_log", "[error]\n[alert]");
  12.     }
  13. });

It means that all tests in this test file that do not define request are set to GET /t. The same is true for error_log.

Preparing the configuration

When testing a behavior, we need to prepare the configuration.

If the configuration is from etcd: We can set up specific configurations through the Admin API.

  1. === TEST 7: refer to empty nodes upstream
  2. --- config
  3.     location /t {
  4.         content_by_lua_block {
  5.             local core = require("apisix.core")
  6.             local t = require("lib.test_admin").test
  7.             local code, message = t('/apisix/admin/routes/1',
  8.                 ngx.HTTP_PUT,
  9.                 [[{
  10.                     "methods": ["GET"],
  11.                     "upstream_id": "1",
  12.                     "uri": "/index.html"
  13.                 }]]
  14.                 )
  17.             if code >= 300 then
  18.                 ngx.status = code
  19.                 ngx.print(message)
  20.                 return
  21.             end
  24.             ngx.say(message)
  25.         }
  26.     }
  27. --- request
  28. GET /t
  29. --- response_body
  30. passed

Then trigger it in a later test:

  1. === TEST 8: hit empty nodes upstream
  2. --- request
  3. GET /index.html
  4. --- error_code: 503
  5. --- error_log
  6. no valid upstream node

Send request

We can initiate a request with request and set the request headers with more_headers.

For example.

  1. --- request
  2. PUT /hello?xx=y&xx=z&&y=&&z
  3. body part of the request
  4. --- more_headers
  5. X-Req: foo
  6. X-Req: bar
  7. X-Resp: cat

Lua code can be used to send multiple requests.

One request after another:

  1.     location /t {
  2.         content_by_lua_block {
  3.             local http = require "resty.http"
  4.             local uri = "http://127.0.0.1:" .. ngx.var.server_port
  5.                         .. "/server_port"
  8.             local ports_count = {}
  9.             for i = 1, 12 do
  10.                 local httpc = http.new()
  11.                 local res, err = httpc:request_uri(uri, {method = "GET"})
  12.                 if not res then
  13.                     ngx.say(err)
  14.                     return
  15.                 end
  16.                 ports_count[res.body] = (ports_count[res.body] or 0) + 1
  17.             end

Sending multiple requests concurrently:

  1.     location /t {
  2.         content_by_lua_block {
  3.             local http = require "resty.http"
  4.             local uri = "http://127.0.0.1:" .. ngx.var.server_port
  5.                         .. "/server_port?var=2&var2="
  10.             local t = {}
  11.             local ports_count = {}
  12.             for i = 1, 180 do
  13.                 local th = assert(ngx.thread.spawn(function(i)
  14.                     local httpc = http.new()
  15.                     local res, err = httpc:request_uri(uri..i, {method = "GET"})
  16.                     if not res then
  17.                         ngx.log(ngx.ERR, err)
  18.                         return
  19.                     end
  20.                     ports_count[res.body] = (ports_count[res.body] or 0) + 1
  21.                 end, i))
  22.                 table.insert(t, th)
  23.             end
  24.             for i, th in ipairs(t) do
  25.                 ngx.thread.wait(th)
  26.             end

Assertions

The following assertions are commonly used.

Check status (if not set, the framework will check if the request has 200 status code).

  1. --- error_code: 405

Check response headers.

  1. --- response_headers
  2. X-Resp: foo
  3. X-Req: foo, bar

Check response body.

  1. --- response_body
  2. [{"count":12, "port": "1982"}]

Checking the error log (via grep error log with regular expression).

  1. --- grep_error_log eval
  2. qr/hash_on: header|chash_key: "custom-one"/
  3. --- grep_error_log_out
  4. hash_on: header
  5. chash_key: "custom-one"
  6. hash_on: header
  7. chash_key: "custom-one"
  8. hash_on: header
  9. chash_key: "custom-one"
  10. hash_on: header
  11. chash_key: "custom-one"

The default log level is info, but you can get the debug level log with -- log_level: debug.

Upstream

The test framework listens to multiple ports when it is started.

  • 1980/1981/1982/5044: HTTP upstream port
  • 1983: HTTPS upstream port
  • 1984: APISIX HTTP port. Can be used to verify HTTP related gateway logic, such as concurrent access to an API.
  • 1994: APISIX HTTPS port. Can be used to verify HTTPS related gateway logic, such as testing certificate matching logic.

The methods in t/lib/server.lua are executed when accessing the upstream port. _M.go is the entry point for this file. When the request accesses the upstream /xxx, the _M.xxx method is executed. For example, a request for /hello will execute _M.hello. This allows us to write methods inside t/lib/server.lua to emulate specific upstream logic, such as sending special responses.

Note that before adding new methods to t/lib/server.lua, make sure that you can reuse existing methods.

Run the test

Assume your current work directory is the root of the apisix source code.

  1. Install our fork of test-nginx to ../test-nginx.
  2. Run the test: prove -I. -I../test-nginx/inc -I../test-nginx/lib -r t/path/to/file.t.

Tips

Debugging test cases

The Nginx configuration and logs generated by the test cases are located in the t/servroot directory. The Nginx configuration template for testing is located in t/APISIX.pm.

Running only some test cases

Three notes can be used to control which parts of the tests are executed.

FIRST & LAST:

  1. === TEST 1: vars rule with ! (set)
  2. --- FIRST
  3. --- config
  4. ...
  5. --- response_body
  6. passed
  13. === TEST 2: vars rule with ! (hit)
  14. --- request
  15. GET /hello?name=jack&age=17
  16. --- LAST
  17. --- error_code: 403
  18. --- response_body
  19. Fault Injection!

ONLY:

  1. === TEST 1: list empty resources
  2. --- ONLY
  3. --- config
  4. ...
  5. --- response_body
  6. {"action":"get","count":0,"node":{"dir":true,"key":"/apisix/upstreams","nodes":{}}}