是否有类似 Spock 的 Python 测试库

Question

I've worked with Spock and loved the 'where' clause, which allows you to easily exercise the test case with multiple inputs and outputs. For example:

class HelloSpock extends spock.lang.Specification {
    def "length of Spock's and his friends' names"() {
        expect:
            name.size() == length

        where:
            name     | length
            "Spock"  | 5
            "Kirk"   | 4
            "Scotty" | 6
    }
} 

Is there something similar for Python?

Answer 1

pytest allows you to parametrise a test function :

import pytest
@pytest.mark.parametrize(("input", "expected"), [
    ("3+5", 8),
    ("2+4", 6),
    ("6*9", 42),
])
def test_eval(input, expected):
    assert eval(input) == expected

Answer 2

If you have more than a few tests, I would recommend a BDD framework like behave . You specify a Gherkin syntax , eg (code from the linked tutorial):

Scenario: some scenario
  Given a set of specific users
     | name      | department  |
     | Barry     | Beer Cans   |
     | Pudey     | Silly Walks |
     | Two-Lumps | Silly Walks |

 When we count the number of people in each department
 Then we will find two people in "Silly Walks"
  But we will find one person in "Beer Cans"

And a Python code for parsing it, eg:

@given('a set of specific users')
def step_impl(context):
    for row in context.table:
        model.add_user(name=row['name'], department=row['department'])

Writing the Python code is fairly easy, and there are numerous boilerplate code examples online. The beauty in this technique is that your testing suite is highly re-usable, and can be extended by non-programmers quite easily.

Answer 3

I'm also big fan of Spock framework in Java/Groowy world. In search similar in Python. In my searching I found nimoy which looks very promising.

Example from official page:

from nimoy.specification import Specification

class MySpec(Specification):

    def my_feature_method(self):
        with given:
            a = value_of_a
            b = value_of_b

        with expect:
            (a * b) == expected_value

        with where:
            value_of_a | value_of_b | expected_value
            1          | 10         | 10
            2          | 20         | 40

And there also author blog post why it is born.

Answer 4

No, there is not. Which is sad because Spock is truly excellent. I have been looking for a year now and have pondered what it would take to create such a DSL in python since I miss it so much.

Behave and Lettuce will get you BDD style syntax and idioms but you must maintain separate step files that match to your scenario files. Obviously this sucks for when you want to do TDD but have the readability of BDD which is what Spock enables.

If you also want Spock style mocks then Mox is the closest I have found. But again it's a poor substitute once you are spoiled by Spock.

Answer 5

Yes, there is!

I'm the author of Nimoy - a framework that was built with the purpose of being Spock for Python.

You can create data driven tests:

from nimoy.specification import Specification

class MySpec(Specification):

    def my_feature_method(self):
        with given:
            a = value_of_a
            b = value_of_b

        with expect:
            (a * b) == expected_value

        with where:
            value_of_a | value_of_b | expected_value
            1          | 10         | 10
            2          | 20         | 40

You can stage mocks:

from unittest import mock
from nimoy.specification import Specification

class MySpec(Specification):

    def my_feature_method(self):
        with setup:
            the_mock = mock.Mock()

        with when:
            the_mock.some_method() << [5, 6, 7]

        with then:
            the_mock.some_method() == 5
            the_mock.some_method() == 6
            the_mock.some_method() == 7

And we have pretty mock assertions as well:

from unittest import mock
from nimoy.specification import Specification

class MySpec(Specification):

    def my_feature_method(self):
        with setup:
            the_mock = mock.Mock()

        with when:
            the_mock.some_method('abcd', True)

        with then:
            1 * the_mock.some_method('abcd', True)

Answer 6

There is a new pytest plugin to do just that: https://github.com/zen-xu/spock

Here is an example of a test function, taken from its documentation:

@pytest.mark.spock("{a} > {b}")
def test_bigger():
    def expect(a, b):
        assert a > b

    def where(_, a, b):
        _ | a | b
        _ | 7 | 3
        _ | 5 | 2

I like the way that you can use inner python methods, the documentation is clear and simple to use.