Lua自动化测试框架

发布时间: 2025-03-24 12:21

↑

# Lua自动化测试框架

本文将介绍如何使用Lua构建自动化测试框架,包括单元测试、集成测试以及性能测试等内容。

## 基础框架

### 1. 测试套件

```lua
-- 测试套件基类
local TestSuite = {}
TestSuite.__index = TestSuite

function TestSuite.new(name)
    local self = setmetatable({}, TestSuite)
    self.name = name
    self.tests = {}
    self.setup = nil
    self.teardown = nil
    return self
end

-- 添加测试用例
function TestSuite:addTest(name, func)
    table.insert(self.tests, {
        name = name,
        func = func
    })
end

-- 设置前置条件
function TestSuite:setSetup(func)
    self.setup = func
end

-- 设置后置条件
function TestSuite:setTeardown(func)
    self.teardown = func
end

-- 运行测试套件
function TestSuite:run()
    print("Running test suite: " .. self.name)
    local results = {
        passed = 0,
        failed = 0,
        errors = {}
    }
    
    for _, test in ipairs(self.tests) do
        if self.setup then
            self.setup()
        end
        
        local success, error = pcall(test.func)
        
        if success then
            results.passed = results.passed + 1
            print(string.format("  ✓ %s", test.name))
        else
            results.failed = results.failed + 1
            table.insert(results.errors, {
                name = test.name,
                error = error
            })
            print(string.format("  ✗ %s: %s", test.name, error))
        end
        
        if self.teardown then
            self.teardown()
        end
    end
    
    return results
end
```

### 2. 断言函数

```lua
-- 断言模块
local assert = {}

-- 相等断言
function assert.equals(expected, actual, message)
    if expected ~= actual then
        error(string.format(
            "%s\nExpected: %s\nActual: %s",
            message or "Values are not equal",
            tostring(expected),
            tostring(actual)
        ))
    end
end

-- 类型断言
function assert.type(value, expected_type)
    if type(value) ~= expected_type then
        error(string.format(
            "Expected type %s but got %s",
            expected_type,
            type(value)
        ))
    end
end

-- 表内容相等断言
function assert.table_equals(t1, t2)
    if type(t1) ~= "table" or type(t2) ~= "table" then
        return false
    end
    
    for k, v in pairs(t1) do
        if type(v) == "table" then
            if not assert.table_equals(v, t2[k]) then
                return false
            end
        else
            if v ~= t2[k] then
                return false
            end
        end
    end
    
    for k, v in pairs(t2) do
        if t1[k] == nil then
            return false
        end
    end
    
    return true
end

-- 异常断言
function assert.throws(func, expected_error)
    local success, error = pcall(func)
    if success then
        error("Expected function to throw an error")
    elseif expected_error and 
           not string.match(error, expected_error) then
        error(string.format(
            "Expected error matching '%s' but got '%s'",
            expected_error,
            error
        ))
    end
end
```

## 单元测试

### 1. 基本示例

```lua
-- 被测试的模块
local Calculator = {}

function Calculator.add(a, b)
    return a + b
end

function Calculator.divide(a, b)
    if b == 0 then
        error("Division by zero")
    end
    return a / b
end

-- 测试套件
local suite = TestSuite.new("Calculator Tests")

-- 添加测试用例
suite:addTest("Addition test", function()
    assert.equals(4, Calculator.add(2, 2))
    assert.equals(-2, Calculator.add(-1, -1))
    assert.equals(0, Calculator.add(1, -1))
end)

suite:addTest("Division test", function()
    assert.equals(2, Calculator.divide(4, 2))
    assert.equals(-2, Calculator.divide(4, -2))
    
    -- 测试除零错误
    assert.throws(
        function() Calculator.divide(4, 0) end,
        "Division by zero"
    )
end)

-- 运行测试
local results = suite:run()
```

### 2. 模拟对象

```lua
-- 模拟对象创建器
local Mock = {}

function Mock.new()
    local mock = {
        calls = {},
        returns = {}
    }
    
    -- 记录函数调用
    function mock:record_call(name, ...)
        if not self.calls[name] then
            self.calls[name] = {}
        end
        table.insert(self.calls[name], {...})
    end
    
    -- 设置返回值
    function mock:returns_for(name, value)
        self.returns[name] = value
    end
    
    -- 创建模拟函数
    function mock:func(name)
        return function(...)
            self:record_call(name, ...)
            return self.returns[name]
        end
    end
    
    -- 验证调用
    function mock:verify_called(name, times)
        local actual = self.calls[name] and #self.calls[name] or 0
        assert.equals(
            times,
            actual,
            string.format(
                "Expected %s to be called %d times but was called %d times",
                name,
                times,
                actual
            )
        )
    end
    
    return mock
end

-- 使用示例
local function test_with_mock()
    local mock = Mock.new()
    
    -- 创建模拟的数据库对象
    local db = {
        query = mock:func("query")
    }
    
    -- 设置返回值
    mock:returns_for("query", {{id = 1, name = "test"}})
    
    -- 使用模拟对象
    local result = db.query("SELECT * FROM users")
    
    -- 验证调用
    mock:verify_called("query", 1)
    assert.equals(1, result[1].id)
end
```

## 集成测试

### 1. HTTP接口测试

```lua
-- HTTP测试工具
local HttpTest = {}

function HttpTest.new(base_url)
    local self = {
        base_url = base_url,
        headers = {}
    }
    
    function self:set_header(name, value)
        self.headers[name] = value
    end
    
    function self:get(path)
        local http = require("socket.http")
        local response = {}
        
        local result, code = http.request{
            url = self.base_url .. path,
            headers = self.headers,
            sink = ltn12.sink.table(response)
        }
        
        return {
            status = code,
            body = table.concat(response)
        }
    end
    
    function self:post(path, data)
        local http = require("socket.http")
        local response = {}
        
        local result, code = http.request{
            url = self.base_url .. path,
            method = "POST",
            headers = self.headers,
            source = ltn12.source.string(data),
            sink = ltn12.sink.table(response)
        }
        
        return {
            status = code,
            body = table.concat(response)
        }
    end
    
    return self
end

-- 使用示例
local function test_api()
    local client = HttpTest.new("http://api.example.com")
    client:set_header("Content-Type", "application/json")
    
    -- 测试GET请求
    local response = client:get("/users")
    assert.equals(200, response.status)
    
    -- 测试POST请求
    local data = [[{"name":"test","email":"test@example.com"}]]
    response = client:post("/users", data)
    assert.equals(201, response.status)
end
```

### 2. 数据库测试

```lua
-- 数据库测试工具
local DBTest = {}

function DBTest.new(config)
    local self = {
        config = config,
        conn = nil
    }
    
    function self:connect()
        local driver = require("luasql.mysql")
        local env = driver.mysql()
        self.conn = env:connect(
            self.config.database,
            self.config.user,
            self.config.password,
            self.config.host
        )
    end
    
    function self:disconnect()
        if self.conn then
            self.conn:close()
        end
    end
    
    function self:execute(sql)
        return self.conn:execute(sql)
    end
    
    function self:setup_test_data()
        -- 创建测试表
        self:execute([[
            CREATE TEMPORARY TABLE test_users (
                id INT AUTO_INCREMENT PRIMARY KEY,
                name VARCHAR(100),
                email VARCHAR(100)
            )
        ]])
        
        -- 插入测试数据
        self:execute([[
            INSERT INTO test_users (name, email) VALUES
            ('Test User 1', 'test1@example.com'),
            ('Test User 2', 'test2@example.com')
        ]])
    end
    
    return self
end

-- 使用示例
local function test_database()
    local db = DBTest.new({
        host = "localhost",
        database = "test_db",
        user = "test_user",
        password = "test_pass"
    })
    
    db:connect()
    db:setup_test_data()
    
    -- 执行测试
    local cursor = db:execute("SELECT * FROM test_users")
    local row = cursor:fetch({}, "a")
    assert.equals("Test User 1", row.name)
    
    db:disconnect()
end
```

## 性能测试

### 1. 基准测试

```lua
-- 基准测试工具
local Benchmark = {}

function Benchmark.new()
    local self = {
        tests = {}
    }
    
    function self:add(name, func, iterations)
        table.insert(self.tests, {
            name = name,
            func = func,
            iterations = iterations or 1000
        })
    end
    
    function self:run()
        for _, test in ipairs(self.tests) do
            print(string.format("Running benchmark: %s", test.name))
            
            local start = os.clock()
            for i = 1, test.iterations do
                test.func()
            end
            local elapsed = os.clock() - start
            
            print(string.format(
                "  Time: %.6f seconds",
                elapsed
            ))
            print(string.format(
                "  Avg: %.6f seconds per iteration",
                elapsed / test.iterations
            ))
        end
    end
    
    return self
end

-- 使用示例
local benchmark = Benchmark.new()

-- 添加测试用例
benchmark:add("Table insertion", function()
    local t = {}
    for i = 1, 1000 do
        t[i] = i
    end
end)

benchmark:add("String concatenation", function()
    local s = ""
    for i = 1, 100 do
        s = s .. "test"
    end
end)

-- 运行基准测试
benchmark:run()
```

元素码农