Utils

AsyncCallQueue

Async callqueue wrapper. Stores information about each function call to synchronized queue.

@callinfo.acallqueue
async def func(a, b):
    return a + b

await func(1, 2)

>>> func.has_calls
True
>>> func.times_called
1
>>> func.next_call()
{'a': 1, 'b': 2}

class testsuite.utils.callinfo.AsyncCallQueue(func: Callable, *, name=None, checker: Callable[[str], None] | None = None)

Function wrapper that puts information about function call into async queue.

This class provides methods to wait/check function underlying function calls.

flush() → None

Clear call queue.

property func

Returns underlying function.

property has_calls: bool

Returns True if call queue is not empty.

next_call() → dict

Pops call from queue and return its arguments dict.

Raises CallQueueError if queue is empty

property times_called: int

Returns call queue length.

await wait_call(timeout=10.0) → dict

Wait for fucntion to be called. Pops call from queue. Blocks if it’s empty.

Parameters:

timeout – timeout in seconds

Raises CallQueueTimeoutError if queue is empty for timeout seconds.

testsuite.utils.callinfo.acallqueue(func: Callable, *, checker: Callable[[str], None] | None = None) → AsyncCallQueue

Turn function into async call queue.

Parameters:

• func – async or sync callable, can be decorated with @staticmethod

• checker – optional function to check whether or not operation on callqueue is possible

Matching

Testsuite provides utility to perform inexact pattern matching. This might be useful when comparing objects. For instance when checking HTTP handle response. Special objects with custom __eq__() method are used for pattern matching. You can use them instead of explicit value when comparing objects.

Here is example assertion on order/create handle response when you do not need to know exact order id returned by handle.

from testsuite import matching

def test_order_create(...):
    response = await client.post('/order/create')
    assert response.status_code == 200

    assert response.json() == {
        'order_id': matching.uuid_string,
        ...
    }

String matching

Regular expressions

class testsuite.matching.RegexString(pattern)

Match string with regular expression.

assert response.json() == {
   'order_id': matching.RegexString('^[0-9a-f]*$'),
   ...
}

Predicates

• any_string, matches any string

• datetime_string, matches any datetime string using dateutil.parser

• uuid_string, string is uuid, e.g.: d08535a5904f4790bd8f95c51c1f3cbe

• objectid_string, String is Mongo objectid, e.g 5e64beab56d0bf70bd8eebcb

Integer matching

Gt

class testsuite.matching.Gt(value)

Value is greater than.

Example:

# Value must be > 10
assert value == matching.Gt(10)

Ge

class testsuite.matching.Ge(value)

Value is greater or equal.

Example:

# Value must be >= 10
assert value == matching.Ge(10)

Lt

class testsuite.matching.Lt(value)

Value is less than.

Example:

# Value must be < 10
assert value == matching.Lt(10)

Le

class testsuite.matching.Le(value)

Value is less or equal.

Example:

# Value must be <= 10
assert value == matching.Le(10)

Predicates

• any_float

• any_integer

• any_numeric

• positive_float

• positive_integer

• positive_numeric

• negative_float

• negative_integer

• negative_numeric

• non_negative_float

• non_negative_integer

• non_negative_numeric

Type matching

class testsuite.matching.IsInstance(types)

Match value by its type.

Use this class when you only need to check value type.

assert response.json() == {
   # order_id must be a string
   'order_id': matching.IsInstance(str),
   # int or float is acceptable here
   'weight': matching.IsInstance([int, float]),
   ...
}

Logical matching

And

class testsuite.matching.And(*conditions)

Logical AND on conditions.

# match integer is in range [10, 100)
assert num == matching.And([matching.Ge(10), matching.Lt(100)])

Or

class testsuite.matching.Or(*conditions)

Logical OR on conditions.

# match integers abs(num) >= 10
assert num == matching.Or([matching.Ge(10), matching.Le(-10)])

Not

class testsuite.matching.Not(condition)

Condition inversion.

Example:

# check value is not 1
assert value == matching.Not(1)

Dict matching

Any dict

class testsuite.matching.AnyDict

Value is a dictionary.

Example:

assert {'foo': 'bar'} == matching.any_dict

Dict of

class testsuite.matching.DictOf(key=<Any>, value=<Any>)

Value is a dictionary of (key, value) pairs.

Example:

pred = matching.DictOf(key=matching.any_string, value=matching.any_string)
assert pred == {'foo': 'bar'}
assert pred != {'foo': 1}
assert pred != {1: 'bar'}

Partial dict matching

class testsuite.matching.PartialDict(*args, **kwargs)

Partial dictionary matching.

It might be useful to only check specific keys of a dictionary. PartialDict serves to solve this task.

PartialDict is wrapper around regular dict() when instantiated all arguments are passed as is to internal dict object.

Example:

assert {'foo': 1, 'bar': 2} == matching.PartialDict({
    # Only check for foo >= 1 ignoring other keys
    'foo': matching.Ge(1),
})

Recusive partial dict matching

testsuite.matching.recursive_partial_dict(*args, **kwargs)

Creates recursive partial dict.

Traverse input dict and create PartialDict for nested dicts. Supports visiting testsuite.matching predicates. Skips inner PartialDict nodes in order to allow user to customize behavior.

l Example:

assert {
    'foo': {'bar': 123, 'extra'}, 'extra'
} == matching.recursive_partial_dict({
         'foo: {'bar': 123}
     })

List matching

Any list

class testsuite.matching.AnyList

Value is a list.

Example:

assert ['foo', 'bar']  == matching.any_dict

List of

class testsuite.matching.ListOf(value=<Any>)

Value is a list of values.

Example:

assert ['foo', 'bar']  == matching.ListOf(matching.any_string)
assert [1, 2]  != matching.ListOf(matching.any_string)

Unordered list

testsuite.matching.unordered_list(sequence, *, key=None)

Unordered list comparison.

You may want to compare lists without respect to order. For instance, when your service is serializing std::unordered_map to array.

unordered_list can help you with that. It sorts both array before comparison.

Parameters:

• sequence – Initial sequence

• key – Sorting key function

Example:

assert [3, 2, 1] == matching.unordered_list([1, 2, 3])

Value captuing

class testsuite.matching.Capture(value=<Any>, _link_captured=None)

Capture matched value(s).

Example:

# You can define matching rule out of pattern
capture_foo = matching.Capture(matching.any_string)
pattern = {'foo': capture_foo}
assert pattern == {'foo': 'bar'}
assert capture_foo.value == 'bar'
assert capture_foo.values_list == ['bar']

# Or do it later
capture_foo = matching.Capture()
pattern = {'foo': capture_foo(matching.any_string)}
assert pattern == {'foo': 'bar'}
assert capture_foo.value == 'bar'
assert capture_foo.values_list == ['bar']