Toolset to run functional tests, written in Lua.

• It is quick
• Imperative, not declarative syntax. This means you can use control structures, loops and custom functions
• Test cases are written in Lua - universal language
• Test cases, written using Oscar, are simple and can be easily refactored and generates human-readable diffs for code review

Download Oscar

go get -i https://github.com/mono83/oscar

Make simple test case and save it as simple.lua

-- Import Oscar module
local o = require("oscar")

-- Register test case
o.add(
    "Simple test case", -- Test case name
    function (tc)       -- Test case body. First and the only argument - TestCase object
        tc:log("This is simple test case body")
        tc:assertEquals("foo", "foo")
    end
)

Run it

oscar run simple.lua

• --verbose|-v Verbose mode - display detailed information about invocation, assertions and errors
• --quiet|-q Quiet mode - disables any output
• --env|-e INI file with values for global environment values map
• --filter|-f Filters test cases by name using regular expression
• --lib|-l Loads library lua file

There is possibility to provide additional metadata to test case:

-- Import Oscar module
local o = require("oscar")

-- Register test case
o.add(
    name, -- Test case name
    callback, -- Test case body
    metadata -- Additional metadata, optional
)

Metadata is simple Lua table with next keys:

Placeholders have syntax ${name} and are automatically replaced in most method:

tc:log("Running under ${lua.engine}")

Oscar uses variables map to replace placeholders in own methods. There are two major map classes:

• Global environment map. Values in this map are configured during start up (using -e option and ini configuration file) and are immutable during test process.
• Test case values map. Values belongs to own test case and can be modified using :set method at runtime. Furthermore, all Oscar data providers (like :httpPost method) writes response and other data in this values map.

Test case is allowed to read only own values map, but if value for requested key is not found, it automatically falls back to global environment map. Reading can be achieved using :get method or during variable interpolation process.

Registers initialization (setUp) functions, that will be invoked only once for whole file. This function can contain heavy reusable calculations and environment establishment.

Registers new test case with name, passes as first argument. Second arguments stands for callback function, that will be invoked on test case execution. Upon invocation, TestCase object will be passed to callback as first and only argument

RSA is helper object, used to work with RSA public/private keys and certificates.

Use RSA.new(len) to generate public/private key pairs with desired len length and TTL one hour.

local r = RSA.new(2048)

Syntax: :exportCertificate64

Outputs certificate in PEM base64 format.

Syntax: :signSHA256String64(data)

Signs provided data using private key and SHA256 hashing and returns base64-encoded value.

Syntax: :signSHA256Int64(int...)

Packs multiple int64 values (any amount) into one single BigEndian byte array, signs it and then encodes result using Base64.

Each test case callback will automatically receive TestCase object as argument with following methods.

Syntax: :log(message)

Outputs arbitrary message.

SyntaxL :info(message)

Outputs arbitrary message but with contrast color.

Syntax: :get(name)

Returns variable, identified by name

Syntax: :set(name, value)

Sets new value for variable, identified by name

Syntax: :export(name, value)

Sets new value for variable, identified by name. This value is set on top-level scope and can be exported to ini file.

Syntax: :assertEquals(actual, expected [, description])

Aliases: :assert, :assertEq

Performs equality check. All arguments casted to strings.

Syntax: :assertJSONXPath(xpath, expected [, description])

Parses last http.response.body as JSON, finds value under XPath expression and performs equality check for it.

Syntax: :httpGet(url)

Performs HTTP request using GET method and writes response data into variables.

Syntax: :httpPost(url, body)

Performs HTTP request using POST method and writes response data into variables.

Syntax: :jsonXPath(path, body)

Invokes JSON XPath query from path on body and returns invocation result. Interpolation also works

local v = tc.jsonXPath("$.foo.bar", '{"foo":{"bar": 10}}')
-- v = "10"

Currently, only MySQL driver is supported. To enable SQL support by Oscar, pass MySQL DSN in program arguments like --mysql=username:password@protocol(address)/dbname?param=value

After that, following operators will be available on suite level:

• :sqlGetLong(sql, args...) - Fetches single integer column, but returns it value as string
• :sqlGetString(sql, args...) - Fetches single string column
• :sqlGetRow(sql, args...) - Fetches full row and returns it as lua table (hashmap)

All methods above are supposed to work with one row only. If more than one row fetched from database, only last one will be returned. On the other hand, if there were no rows, this method will produce an error.

Syntax: :unix()

Returns current Unix timestamp, in seconds

Syntax: :sleep(millis)

Pauses invocation for requested amount of milliseconds

Syntax: :stringToBase64(value)

Encodes provided string value as Base64

Syntax: :packInt64ToBase64(int64...)

Packs multiple int64 values (any amount) into one single BigEndian byte array and then encodes it using Base64.