Tests and suites

Defining a suite

A suite can be either represented by:

  • a module (in this case the module must define a SUITE variable that contains at least the "description" key), each test is a function decorated with @lcc.test:

    # suites/mysuite.py:
    
    import lemoncheesecake.api as lcc
    from lemoncheesecake.matching import *
    
    SUITE = {
      "description": "My suite"
    }
    
    @lcc.test("My test")
    def my_test():
        check_that("value", "foo", equal_to("foo"))
    
  • a class (in this case the class name must match the module name), each test is a method decorated with @lcc.test:

    # suites/mysuite.py:
    
    import lemoncheesecake.api as lcc
    from lemoncheesecake.matching import *
    
    @lcc.suite("My suite")
    class mysuite:
        @lcc.test("My test")
        def my_test(self):
            check_that("value", "foo", equal_to("foo"))
    

A suite can be nested in another suite, it can be performed in different ways:

  • as a class in a suite module:

    # suites/mysuite.py:
    
    SUITE = {
      "description": "Parent suite"
    }
    
    @lcc.test("Test A")
    def test_a():
        pass
    
    @lcc.suite("Child suite 1")
    class child_suite_1:
        @lcc.test("Test B")
        def test_b(self):
            pass
    
    @lcc.suite("Child suite 2")
    class child_suite_2:
        @lcc.test("Test C")
        def test_c(self):
            pass
    
  • as a nested class:

    # suites/mysuite.py:
    
    @lcc.suite("Parent suite")
    class parent_suite:
        @lcc.suite("Child suite")
        class child_suite:
            pass
    
  • as a module in a sub directory whose name matches the parent suite module:

    $ tree
    .
    ├── parent_suite
    │   └── child_suite.py
    └── parent_suite.py
    
    1 directory, 2 files
    

Adding metadata to tests and suites

Several type of metadata can be associated to both tests and suites using decorators:

  • tags (take one or more tag name as argument):

    @lcc.test("Test something")
    @lcc.tags("important")
    def test_something():
        pass
    
    @lcc.test("Test something else")
    @lcc.tags("slow")
    def test_something_else():
        pass
    
    @lcc.test("Test something else again")
    @lcc.tags("slow", "deprecated")
    def test_something_else_again():
        pass
    
  • properties (take a key/value pair arguments):

    @lcc.test("Test something")
    @lcc.prop("type", "acceptance")
    def test_something(self):
        pass
    
    @lcc.test("Test something else")
    @lcc.prop("type", "destructive")
    def test_something_else(self):
        pass
    
  • links (take an URL and an optional description as arguments):

    @lcc.test("Test something")
    @lcc.link("http://bugtracker.example.com/issues/1234", "TICKET-1234")
    def test_something():
        pass
    
    @lcc.test("Test something else")
    @lcc.link("http://bugtracker.example.com/issues/5678")
    def test_something_else():
        pass
    

Metadata can also be associated to a suite module using the SUITE variable:

SUITE = {
    "description": "My Suite",
    "tags": ["slow"]
}

Once, the metadata are set, they:

  • can be used as filters in the various lemoncheesecake CLI tools
  • will be available in the test report

Disabling a test or a suite

A test or an entire suite can be disabled using the @lcc.disabled() decorator:

@lcc.test("Test something")
@lcc.disabled()
def test_something(self):
    pass

Disabled tests are visible in the report but they are not taken into account while computing the percentage of successful tests.

If you want to completely hide a test or a suite from the test tree and the report, use @lcc.hidden().

Conditional tests and suites

A test or an entire suite can included or excluded from the test tree using the @lcc.conditional(condition) decorator.

This decorator can be associated to both tests and suites, it takes a callback as argument. This callback will be called with the object to which it is associated (a module, a class or a function). If the callback return a non-true value, then the test/suite won’t be included in the test tree, meaning it won’t be executed, it won’t be present in the test report nor in the lcc show command output.

Usage:

@lcc.suite("My Suite")
class mysuite:
    some_feature_enabled = True

    @lcc.test("Test something")
    @lcc.conditional(lambda test: mysuite.some_feature_enabled)
    def test_something(self):
        pass