KCL 测试框架设计

｜背景｜

KCL 虽然是一个面向云原生配置和策略的 DSL，但是依然有测试的需求。本文是 KCL 测试工具具体设计和使用方式的简单介绍。

｜主流语言的测试方案｜

Python 的单元测试

Python 标准库自带了 unitest 测试库和测试工具。

import unittest

class TestStringMethods(unittest.TestCase):
    def setUp(self):
        pass
    def tearDown(self):
        pass
    
    def test_upper(self):
        self.assertEqual('foo'.upper(), 'FOO')

• 测试代码以 class 组织

• 每个测试 class 都必须从 unittest.TestCase 继承

• class 中每个以 “test_” 开头的方法是独立的测试函数

• self.assertEqual 是测试框架提供的辅助测试函数

• setUp 和 tearDown 用于测试前后准备和清理工作

TestCase 可以再组织为 TestSuite：

def suite():
    suite = unittest.TestSuite()
    suite.addTest(WidgetTestCase('test_default_widget_size'))
    suite.addTest(WidgetTestCase('test_widget_resize'))
    return suite

if __name__ == '__main__':
    runner = unittest.TextTestRunner()
    runner.run(suite())

Python 社区也有其他的测试框架如 pytest 测试框架，其提供了更简单的测试代码书写方式：

# content of test_sample.py
def inc(x):
    return x + 1

def test_answer():
    assert inc(3) == 5

• test_xxx.py 是默认的测试文件

• test_xxx 全局函数是测试函数

• assert 指令辅助测试

总结：

• test_xxx.py 文件名区分测试代码

• 通过 TestXXX 类来组织针对某个目标测试代码

• 类中的 test_xxx 方法用于不同参数条件下的测试

• 每个测试可以有准备和清理的的函数

• pytest 测试代码书写更简单，但是需要安装额外的 pytest 工具

Java的单元测试 - JUnit

Java 的 JUint 是 xUint 测试框架中的一员，测试代码和 Python 的 unittest 结构很像：

public class HelloWorld extends TestCase {
    public void testMultiplication() {
        assertEquals("Multiplication", 6, 3*2);
    }
}

• 从 TestCase 继承

• testMultiplication 表示测试函数

• assertEquals 是从 TestCase 继承的方法

在新的版本中，测试类不再需要从 TestCase 继承（有点类似 pytest），增加了 @Test 修饰器标注测试方法：

public class HelloWorld {
    @Test
    public void testMultiplication() {
        assertEquals("Multiplication", 6, 3*2);
    }
}

总结：

• 通过基础测试框架 TestCase 提供 assertEquals 等测试函数

• testXXX 等方法表示测试函数

Go 的单元测试

Go 的单元测试和 pytest 风格很像，同步全局的测试函数组织测试代码：

// xxx_test.Go
func TestFoo(t testing.T) {
    if 1+1 != 2 { t.Fatal(‘msg’) }
}

通过传入的t参数可以简单控制测试的流程（比如根据调整选择不同的测试流程）。

测试函数通过命名规则和 type、method 和 name形成关联，用于更友好展示测试信息：

func Test_suffix() { ... }
func TestF_suffix() { ... }
func TestT_suffix() { ... }
func TestT_M_suffix() { ... }

内置的 go test 工具还可以根据条件运行某些测试，也支持递归运行子目录的测试。此外，还支持运行性能和模糊测试。

总结：

• Go 的单元测试固定命名规则，维护简单同时也可以关联到相关的目标

• 支持并发测试和失败测试

• 内置的测试工具简单灵活

C/C++ 单元测试 - GTest

GTest 是 C/C++ 测试框架，测试代码如下：

#include <gtest/gtest.h>

// Tests factorial of 0.
TEST(FactorialTest, HandlesZeroInput) {
  EXPECT_EQ(Factorial(0), 1);
}

// Tests factorial of positive numbers.
TEST(FactorialTest, HandlesPositiveInput) {
  EXPECT_EQ(Factorial(1), 1);
  EXPECT_EQ(Factorial(2), 2);
  EXPECT_EQ(Factorial(3), 6);
  EXPECT_EQ(Factorial(8), 40320);
}

因为语言的原因，GTest 需要自定义入口函数：

int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv); // 初始化，所有测试都是这里启动的
  return RUN_ALL_TESTS(); // 运行所有测试用例
}

通过 TEST 宏模拟一个测试函数，宏的 2 个参数表示 testCase 对具体测试的名字。比如 TEST(FactorialTest, HandlesZeroInput) 对应 Go 语言的 TestFactorial_handlesZeroInput 测试函数。

总结：

• GTest 通过 TEST 宏组织测试代码

• 需要手工定义测试入口函数

主流单元测试框架总结

• 文件通过 test_xxx 或 xxx_test 文件名来组织测试代码

• 测试函数通过测试 class，并且以 test_xxx 函数名的方式组织测试函数

• 提供便捷的测试命令，支持可选择、可批量运行测试代码 丰富的测试辅助函数

｜KCL 测试框架设计｜

参考主流的测试框架，并结合已有的 KCL 语言特性，通过 lambda 函数组织测试代码、通过内置 runtime 库提供测试失败断言相关辅助函数、通过内置测试工具简化测试运行过程。

测试代码对应的文件名

每个目录下的 xxx_test.k 是单元测试，每个 xxx_test.k 类似一个独立执行的 main.k 文件，可以最大语法灵活度编写测试代码。xxx_test.k 文件不能被其他 k 文件导入。

KCL 单元测试工具内置了简单的测试框架。每个目录下的测试是一组测试集，每个 test.k 文件中每个 lambda 测试函数以 test 开头命名。

单元测试用例

假设这里有个 hello.k 配置文件：

schema Person:
    name: str = "kcl"
    age: int = 1

    check:
        0 <= age <= 120, "age must be in [0, 120]"

hello = Person {
    name = "hello kcl"
    age = 102
}

构造对应的 hello_test.k 单元测试文件 (位于 hello.k 的同文件夹下)：

test_person = lambda {
    a = Person {}
    assert a.name == 'kcl'
}
test_person_age = lambda {
    a = Person {}
    assert a.age == 1
}
test_person_ok = lambda {
    a = Person {}
    assert a.name == "kcl"
    assert a.age == 1
}

在当前目录下通过 kcl test 命令执行测试。输出结果如下：

test_person: PASS (2ms)
test_person_age: PASS (1ms)
test_person_ok: PASS (1ms)
--------------------------------------------------------
PASS: 3/3

失败测试用例

修改 hello_test.k，构造一个失败的测试（真实的场景错误一般在 hello.k，这里只是为了便于演示）：

test_person = lambda {
    a = Person{}
    assert a.name == 'kcl2'
}
test_person_age = lambda {
    a = Person{}
    assert a.age == 123
}
test_person_ok = lambda {
    a = Person{}
    assert a.name == "kcl2"
    assert a.age == 1
}

重新运行测试的输出结果如下：

test_person: FAIL (6ms)
EvaluationError
 --> hello_test.k:3:1
  |
3 |     assert a.name == 'kcl2'

test_person_age: FAIL (3ms)
EvaluationError
 --> hello_test.k:7:1
  |
7 |     assert a.age == 123
  |

test_person_ok: FAIL (2ms)
EvaluationError
  --> hello_test.k:11:1
   |
11 |     assert a.name == "kcl2"
   |

------------------------------------------------------
FAIL: 3/3

如果我们想要正确测试错误情况并检查错误消息，我们可以使用 runtime.catch 函数。

import runtime

test_person_age_check_error_message = lambda {
    msg = runtime.catch(lambda {
        a = Person {age = 123}
    }) 
    assert msg == "age must be in [0, 120]"
}

运行命令

kcl test

输出:

test_person_age_check_error_message: PASS (2ms)
--------------------------------------------------------------------------------
PASS: 1/1

可以看到我们成功检测到了 schema Person 的 check 错误信息。

其他参考测试用例

目前 KCL 在 modules 模型仓库提供了一些基础库并使用了 kcl test 工具保证库的正确性，以下是一些参考用例

• https://github.com/kcl-lang/modules/tree/main/jsonpatch/main_test.k

• https://github.com/kcl-lang/modules/blob/main/json_merge_patch/main_test.

｜总结｜

KCL 参考了主流语言的测试，最终通过 assert 和内置的测试工具配合实现单元测试。具体细节可以参考最新的文档：

https://www.kcl-lang.io/zh-CN/docs/tools/cli/kcl/test

欢迎来玩~ 欢迎 star ⭐️

https://github.com/kcl-lang

https://github.com/KusionStack