Kurzy programovacího jazyka Python
kurzy.python@centrum.czhttps://github.com/tisnik/python-programming-coursespytest–
1 unittest
2 doctest
3 pytest
4 nose
5 testify
6 Trial
7 Twisted
8 subunit
9 testresources
10 reahl.tofu
11 unit testing
12 testtools
13 Sancho
14 zope.testing
15 pry
16 pythoscope
17 testlib
18 pytest
19 dutest
Různé podoby testovací pyramidy
(BDD: behavior-driven development)
# Nástroj
1 Ludibrio
2 Python Mock
3 PyMock
4 mock
5 pMock
6 minimock
7 svnmock
8 Mocker
9 Stubble
10 Mox
11 MockTest
12 Fudge
13 Mockito for Python
14 CaptureMock
15 flexmock
16 doublex
17
"""Výpočet průměru."""
def average(x):
"""Výpočet průměru ze seznamu hodnot předaných v parametru x."""
return sum(x) / float(len(x))
"""Implementace jednotkových testů."""
from average import average
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
assert result == 1.5
pytest
"""Výpočet průměru."""
def average(x):
"""Výpočet průměru ze seznamu hodnot předaných v parametru x."""
return sum(x) / float(1 + len(x))
pytest
"""Implementace jednotkových testů."""
from average import average
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
expected = 1.5
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
"""Implementace jednotkových testů."""
from average import average
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
expected = 1.5
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
def test_average_empty_list():
"""Otestování výpočtu průměru."""
result = average([])
expected = 0.0
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
"""Implementace jednotkových testů."""
import pytest
from average import average
def test_average_basic():
"""Otestování výpočtu průměru."""
result = average([1, 2])
expected = 1.5
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
def test_average_empty_list():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
def test_average_exception_not_raised():
"""Otestování výpočtu průměru."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([1, 2])
"""Implementace jednotkových testů."""
import pytest
from average import average
def test_average_basic_more_checks():
"""Otestování výpočtu průměru."""
inputs = ((0, 0), (1, 0), (1, 1), (1, 2))
expected_results = (0, 0.5, 1, 1.5)
for input, expected in zip(inputs, expected_results):
result = average(input)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
"""Implementace jednotkových testů."""
import pytest
from average import average
testdata = [
((1, 1), 1),
((1, 2), 1.5),
((0, 1), 0.5),
((1, 2, 3), 2.0),
((0, 10), 0.5),
]
@pytest.mark.parametrize("values,expected", testdata)
def test_average_basic(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
def test_average_empty_list_2():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(Exception) as excinfo:
result = average([])
# poměrně křehký způsob testování!
assert excinfo.type == ZeroDivisionError
assert str(excinfo.value) == "float division by zero"
"""Implementace jednotkových testů."""
import pytest
from average import average
testdata = [
((1, 1), 1),
((1, 2), 1.5),
((0, 1), 0.5),
((1, 2, 3), 2.0),
((0, 10), 0.5),
]
@pytest.mark.parametrize(
"values,expected", testdata, ids=["1,1", "1,2", "0,1", "1,2,3", "0,10"]
)
def test_average_basic_2(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
def test_average_empty_list_2():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(Exception) as excinfo:
result = average([])
# poměrně křehký způsob testování!
assert excinfo.type == ZeroDivisionError
assert str(excinfo.value) == "float division by zero"
"""Implementace jednotkových testů."""
import pytest
from average import average
@pytest.mark.parametrize(
"values,expected",
[
pytest.param((1, 1), 1),
pytest.param((1, 2), 1.5),
pytest.param((0, 1), 0.5),
pytest.param((1, 2, 3), 2.0),
pytest.param((0, 10), 0.5),
],
)
def test_average_basic_3(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
def test_average_empty_list_2():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(Exception) as excinfo:
result = average([])
# poměrně křehký způsob testování!
assert excinfo.type == ZeroDivisionError
assert str(excinfo.value) == "float division by zero"
"""Implementace jednotkových testů."""
import pytest
from average import average
def pytest_configure(config):
"""Konfigurace jednotkových testů."""
config.addinivalue_line(
"markers", "smoketest: mark test that are performed very smoketest"
)
testdata = [
((1, 1), 1),
((1, 2), 1.5),
((0, 1), 0.5),
((1, 2, 3), 2.0),
((0, 10), 0.5),
]
@pytest.mark.smoketest
@pytest.mark.parametrize("values,expected", testdata)
def test_average_basic_1(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.smoketest
@pytest.mark.parametrize(
"values,expected", testdata, ids=["1,1", "1,2", "0,1", "1,2,3", "0,10"]
)
def test_average_basic_2(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.smoketest
@pytest.mark.parametrize(
"values,expected",
[
pytest.param((1, 1), 1),
pytest.param((1, 2), 1.5),
pytest.param((0, 1), 0.5),
pytest.param((1, 2, 3), 2.0),
pytest.param((0, 10), 0.5),
pytest.param((), 0),
],
)
def test_average_basic_3(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.thorough
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
@pytest.mark.thorough
def test_average_empty_list_2():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(Exception) as excinfo:
result = average([])
# poměrně křehký způsob testování!
assert excinfo.type == ZeroDivisionError
assert str(excinfo.value) == "float division by zero"
pytest -v -m smoketest
pytest -v -m thorough
pytest -v -m other
"""Implementace jednotkových testů."""
import pytest
from average import average
def pytest_configure(config):
"""Konfigurace jednotkových testů."""
config.addinivalue_line(
"markers", "smoketest: mark test that are performed very smoketest"
)
testdata = [
((1, 1), 1),
((1, 2), 1.5),
((0, 1), 0.5),
((1, 2, 3), 2.0),
((0, 10), 0.5),
]
@pytest.mark.smoketest
@pytest.mark.parametrize("values,expected", testdata)
def test_average_basic_1(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.smoketest
@pytest.mark.parametrize(
"values,expected", testdata, ids=["1,1", "1,2", "0,1", "1,2,3", "0,10"]
)
def test_average_basic_2(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.smoketest
@pytest.mark.parametrize(
"values,expected",
[
pytest.param((1, 1), 1),
pytest.param((1, 2), 1.5),
pytest.param((0, 1), 0.5),
pytest.param((1, 2, 3), 2.0),
pytest.param((0, 10), 0.5),
pytest.param((), 0),
],
)
def test_average_basic_3(values, expected):
"""Otestování výpočtu průměru."""
result = average(values)
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
@pytest.mark.thorough
def test_average_empty_list_1():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(ZeroDivisionError) as excinfo:
result = average([])
@pytest.mark.thorough
def test_average_empty_list_2():
"""Otestování výpočtu průměru pro prázdný vstup."""
with pytest.raises(Exception) as excinfo:
result = average([])
# poměrně křehký způsob testování!
assert excinfo.type == ZeroDivisionError
assert str(excinfo.value) == "float division by zero"
@pytest.fixture
def input_values():
"""Vygenerování vstupních hodnot pro jednotkový test."""
return (1, 2, 3, 4, 5)
def test_average_five_values(input_values):
"""Otestování výpočtu průměru."""
result = average(input_values)
expected = 3
assert result == expected, "Očekávaná hodnota {}, vráceno {}".format(
expected, result
)
"""Výpočet seznamu prvočísel až do zadaného limitu."""
# originální kód lze nalézt na adrese:
# http://www.rosettacode.org/wiki/Sieve_of_Eratosthenes#Odds-only_version_of_the_array_sieve_above
def primes2(limit):
"""Výpočet seznamu prvočísel až do zadaného limitu."""
# okrajový případ
if limit < 2:
return []
# druhý případ - 2 je speciálním prvočíslem
if limit < 3:
return [2]
lmtbf = (limit - 3) // 2
# naplnění tabulky, která se bude prosívat
buf = [True] * (lmtbf + 1)
# vlastní prosívání
for i in range((int(limit ** 0.5) - 3) // 2 + 1):
if buf[i]:
p = i + i + 3
s = p * (i + 1) + i
buf[s::p] = [False] * ((lmtbf - s) // p + 1)
# vytvoření seznamu prvočísel
return [2] + [i + i + 3 for i, v in enumerate(buf) if v]
"""Implementace jednotkových testů."""
from primes import primes2
def test_primes_10():
"""Otestování výpočtu seznamu prvočísel až do limitu 10."""
# získat seznam prvočísel až do limitu 10
p = primes2(10)
# testy lze dále rozšiřovat
assert 2 in p
assert 10 not in p
pytest
pytest -v
"""Implementace jednotkových testů."""
from primes import primes2
def test_primes_10():
"""Otestování výpočtu seznamu prvočísel až do limitu 10."""
# získat seznam prvočísel až do limitu 10
p = primes2(10)
# testy lze dále rozšiřovat
assert 2 in p
assert 10 not in p
def test_primes_0():
"""Otestování výpočtu seznamu prvočísel do limitu 0."""
p = primes2(0)
# otestujeme, zda je sekvence prázdná (není zcela přesné)
assert not p
pytest --cov=. > cov_all.txt
# specifikace balíčku
pytest --cov=primes > cov_primes.txt
# řádky nepokryté jednotkovými testy
pytest --cov=primes --cov-report term-missing > cov_missing.txt
# export do HTML
pytest --cov=primes --cov-report html
"""Výpočet seznamu prvočísel až do zadaného limitu."""
# originální kód lze nalézt na adrese:
# http://www.rosettacode.org/wiki/Sieve_of_Eratosthenes#Odds-only_version_of_the_array_sieve_above
def primes2(limit):
"""Výpočet seznamu prvočísel až do zadaného limitu."""
# okrajový případ
if limit < 2: # pragma: no cover
return []
# druhý případ - 2 je speciálním prvočíslem
if limit < 3: # pragma: no cover
return [2]
lmtbf = (limit - 3) // 2
# naplnění tabulky, která se bude prosívat
buf = [True] * (lmtbf + 1)
# vlastní prosívání
for i in range((int(limit ** 0.5) - 3) // 2 + 1):
if buf[i]:
p = i + i + 3
s = p * (i + 1) + i
buf[s::p] = [False] * ((lmtbf - s) // p + 1)
# vytvoření seznamu prvočísel
return [2] + [i + i + 3 for i, v in enumerate(buf) if v]
Given the customer has logged into their current account
And the balance is shown to be 100 euros
When the customer transfers 75 euros to their savings account
Then the new current account balance should be 25 euros
Části testovacího scénáře:
Feature: Count words function test
Scenario: Check the function count_words()
Given a sample text
"""
Velmi kratka veta.
"""
When I count all words in text
Then I should get 3 as a result
Scenario: Check the function count_words()
Given a sample text
"""
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
eiusmod tempor incididunt ut labore et dolore magna aliqua.
"""
When I count all words in text
Then I should get 19 as a result
Feature: Sum function test 1
Scenario: Check the function sum()
Given a list of integers
|value |
| 1 |
| 10 |
| 100 |
| 1000 |
When I summarize all those integers
Then I should get 1111 as a result
Scenario: Check the exchange rate calculation
Given the following exchange rate table
| currency | rate |
| CZK | 1.000 |
| CAD | 16.172 |
| HRK | 3.407 |
| USD | 20.655 |
When I sell 10 CAD
Then I should receive 161.72 CZK
Scenario Outline: Check the user search feature, perform the search for more users
Given GitHub is accessible
When I search for user with nick <nick>
Then I should receive 200 status code
And I should receive proper JSON response
And I should find the user with full name <fullname>
And I should find that the user works for company <company>
Examples: users
|nick|fullname|company|
|torvalds|Linus Torvalds|Linux Foundation|
|brammool|Bram Moolenaar|Zimbu Labs|
|tisnik|Pavel Tišnovský|Red Hat, Inc.|
Scenario Outline: Check the exchange rate calculation
Given the following exchange rate table
| currency | rate |
| CZK | 1.000 |
| CAD | 16.172 |
| HRK | 3.407 |
| USD | 20.655 |
When I sell <sold> <currency>
Then I should receive <amount> CZK
Examples: sold
| sold | currency | amount |
| 1 | CZK | 1.000 |
| 10 | CZK | 10.000 |
| 1 | CAD | 16.172 |
| 100 | CAD | 1617.200 |
| 2 | HRK | 6.814 |
git clone https://github.com/tisnik/python-behave-demos
├── feature_list.txt
├── features
│ ├── adder.feature
│ └── steps
│ └── common.py
├── requirements.in
├── requirements.txt
├── run_tests.sh
└── src
└── adder.py
Význam souborů v projektu:
src/adder.py vlastní modul, který budeme chtít otestovat
requirements.in/requirements.txt soubory pro pip (instalátor balíčků)
feature_list.txt seznam testovacích scénářů, které se mají spustit
features/ adresář obsahující testovací scénáře i implementaci jednotlivých kroků testů
run_tests.sh pomocný skript pro spuštění testovacích scénářů
def add(x, y):
return x + y
Feature: Adder test
Scenario: Check the function add()
Given The function add is callable
When I call function add with arguments 1 and 2
Then I should get 3 as a result
from behave import given, then, when
from src.adder import add
@given('The function {function_name} is callable')
def initial_state(context, function_name):
pass
@when('I call function {function} with arguments {x:d} and {y:d}')
def call_add(context, function, x, y):
context.result = add(x, y)
@then('I should get {expected:d} as a result')
def check_integer_result(context, expected):
assert context.result == expected, \
"Wrong result: {r} != {e}".format(r=context.result, e=expected)
from behave.log_capture import capture
import ctypes
def _load_library(context, library_name):
if context.tested_library is None:
context.tested_library = ctypes.CDLL(library_name)
def before_all(context):
"""Perform setup before the first event."""
context.tested_library = None
context.load_library = _load_library
#!/bin/bash -ex
export NOVENV=1
function prepare_venv() {
virtualenv -p python3 venv && source venv/bin/activate && python3 `which pip3` install -r requirements.txt
}
[ "$NOVENV" == "1" ] || prepare_venv || exit 1
PYTHONDONTWRITEBYTECODE=1 python3 `which behave` --tags=-skip -D dump_errors=true @feature_list.txt $@
Feature: Adder test # features/adder.feature:1
Scenario: Check the function add() # features/adder.feature:3
Given The function add is callable # features/steps/common.py:20 0.000s
When I call function add with arguments 1 and 2 # features/steps/common.py:25 0.000s
Then I should get 3 as a result # features/steps/common.py:30 0.000s
1 feature passed, 0 failed, 0 skipped
1 scenario passed, 0 failed, 0 skipped
3 steps passed, 0 failed, 0 skipped, 0 undefined
Took 0m0.000s
@smoketest
Scenario: Check the function int add(int, int)
Given The library libadder.so is loaded
When I call native function add with arguments 1 and 2
Then I should get 3 as a result
Scenario Outline: Thorough checking function int add(int, int)
Given The library libadder.so is loaded
When I call native function add with arguments <x> and <y>
Then I should get <result> as a result
Examples: results
|x|y|result|
# basic arithmetic
| 0| 0| 0|
| 1| 2| 3|
| 1|-2| -1|
# no overflows at 16 bit limits
| 32767| 1| 32768|
| 65535| 1| 65536|
# integer overflow
| 2147483648| 1|-2147483647|
|-2147483647|-1|-2147483648|
|-2147483648|-1| 2147483647|
from behave.log_capture import capture
import ctypes
def _load_library(context, library_name):
if context.tested_library is None:
context.tested_library = ctypes.CDLL(library_name)
def before_all(context):
"""Perform setup before the first event."""
context.tested_library = None
context.load_library = _load_library
from behave import given, then, when
@given('The library {library_name} is loaded')
def initial_state(context, library_name):
context.load_library(context, library_name)
@when('I call native function add with arguments {x:d} and {y:d}')
def call_add(context, x, y):
context.result = context.tested_library.add(x, y)
@then('I should get {result:d} as a result')
def check_integer_result(context, result):
assert context.result == result, "Expected result: {e}, returned value: {r}".format(e=result, r=context.result)
@smoketest
Scenario: Check the GitHub API entry point
Given GitHub is accessible
When I access the API endpoint /
Then I should receive 200 status code
Scenario: Check the user search feature
Given GitHub is accessible
When I search for user with nick torvalds
Then I should receive 200 status code
And I should receive proper JSON response
And I should find the user with full name Linus Torvalds
And I should find that the user works for company Linux Foundation
import json
import os.path
from behave.log_capture import capture
import requests
def _is_accessible(context, accepted_codes=None):
accepted_codes = accepted_codes or {200, 401}
url = context.api_url
try:
res = requests.get(url)
return res.status_code in accepted_codes
except requests.exceptions.ConnectionError as e:
print("Connection error: {e}".format(e=e))
return False
def before_all(context):
"""Perform setup before the first event."""
context.is_accessible = _is_accessible
context.api_url = "https://api.github.com"
@capture
def before_scenario(context, scenario):
"""Perform setup before each scenario is run."""
pass
@capture
def after_scenario(context, scenario):
"""Perform cleanup after each scenario is run."""
pass
@capture
def after_all(context):
"""Perform cleanup after the last event."""
pass
import json
from behave import given, then, when
from urllib.parse import urljoin
import requests
@given('GitHub is accessible')
def initial_state(context):
assert context.is_accessible(context)
@given('System is running')
def running_system(context):
"""Ensure that the system is accessible."""
assert is_accessible(context)
@when('I access the API endpoint {url}')
def access_endpoint(context, url):
context.response = requests.get(context.api_url + url)
@when('I search for user with nick {nick}')
def search_for_user(context, nick):
url = urljoin(urljoin(context.api_url, "users/"), nick)
context.response = requests.get(url)
@then('I should receive {status:d} status code')
def check_status_code(context, status):
"""Check the HTTP status code returned by the REST API."""
assert context.response.status_code == status
@then('I should receive proper JSON response')
def check_json_response(context):
content_type = context.response.headers.get('content-type')
assert content_type.startswith('application/json')
context.data = context.response.json()
@then('I should find the user with full name {fullname}')
def check_user_full_name(context, fullname):
assert context.data is not None
assert 'name' in context.data
value = context.data.get('name')
assert value == fullname, "{e} != {v}".format(e=fullname, v=value)
@then('I should find that the user works for company {company}')
def check_company(context, company):
assert context.data is not None
assert 'company' in context.data
value = context.data.get('company')
assert value == company, "{e} != {v}".format(e=company, v=value)