class TestMyTestCase:
    def test_one(self):
        pass

% pytest ch1   
=============================================== test session starts ===============================================
platform darwin -- Python 3.9.1, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /Users/panyoriokome/Workspaces/git/crafting_test_driven_software_with_python
collected 1 item                                                                                                  

ch1/test_automatictests.py .                                                                                [100%]

================================================ 1 passed in 0.00s ================================================

class TestMyTestCase:
    def test_one(self):
        pass

    # Helper Function
    def helper_one(self):
        pass

class TestAddition():
    def test_main(self):
        result = addition(3, 2)
        assert result == 5

==================================== FAILURES =====================================
_____________________________ TestAddition.test_main ______________________________

self = <test_tdd.TestAddition object at 0x7f9936e41c10>

    def test_main(self):
>       result = addition(3, 2)
E       NameError: name 'addition' is not defined

ch1/test_tdd.py:3: NameError
============================= short test summary info =============================
FAILED ch1/test_tdd.py::TestAddition::test_main - NameError: name 'addition' is ...
================================ 1 failed in 0.02s ================================

def addition(arg1, arg2):
    return arg1 + arg2

$ pytest ch1/test_tdd.py 
================================ test session starts ================================
platform linux -- Python 3.9.6, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /home/deepstation/Documents/workspace/git/crafting_test_driven_software_with_python
collected 1 item                                                                    

ch1/test_tdd.py .                                                             [100%]

================================= 1 passed in 0.00s =================================

def addition(*args):
    a1, a2 = args
    return a1 + a2

class TestAddition():
    ...
    def test_threeargs(self):
        result = addition(3, 2, 1)
        assert result == 6

    def test_noargs(self):
        result = addition()
        assert result == 0

def multiply(num1, num2):
    total = 0
    for _ in range(num2):
        total = addition(total, num1)
    return total

def addition(*args):
    total = 0 
    for a in args: 
        total += a
    return total

class TestChatAcceptance:
    def test_message_exchange(self):
        user1 = ChatClient("山田")
        user2 = chatClient("佐藤")

        user1.send_message("こんにちは")
        messages = user2.fetch_messages()

        assert messages == ["山田: こんにちは"]

class TestChatClient:
    def test_nickname(self):
        client = ChatClient("User 1")

        assert client.nickname == 'User 1'

class ChatClient:
    def __init__(self, nickname):
        self.nickname = nickname

$ pytest ch2/test_acceptance.py::TestChatClient 
================================= test session starts ==================================
platform linux -- Python 3.9.6, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
rootdir: /home/deepstation/Documents/workspace/git/crafting_test_driven_software_with_python
collected 1 item                                                                       

ch2/test_acceptance.py .                                                         [100%]

================================== 1 passed in 0.00s ===================================

$ python 01_chat_acceptance.py TestChatAcceptance
E
======================================================================
ERROR: test_message_exchange (__main__.TestChatAcceptance)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "01_chat_acceptance.py", line 8, in test_message_exchange
    user1.send_message("Hello World")
AttributeError: ChatClient instance has no attribute 'send_message'

----------------------------------------------------------------------
Ran 1 test in 0.000s

class TestChatClient(unittest.TestCase):
    ...
    def test_send_message(self):
        client = ChatClient("User 1")
        sent_message = client.send_message("Hello World")
        
        assert sent_message == "User 1: Hello World"

class TestChatClient:
    ...
    def test_send_message(self):
        client = ChatClient("User 1")
        client.connection = _DummyConnection()
        sent_message = client.send_message("Hello World")

        assert sent_message == "User 1: Hello World"

class ChatClient:
    def __init__(self, nickname):
        self.nickname = nickname

    def send_message(self, message):
        sent_message = "{}: {}".format(self.nickname, message)
        self.connection.broadcast(message)
        return sent_message

class _DummyConnection:
    def broadcast(*args, **kwargs):
        pass

+import unittest.mock
...
class TestChatClient:
    ...
    def test_send_message(self):
        client = ChatClient("User 1")
+       client.connection = unittest.mock.Mock()
        sent_message = client.send_message("Hello World")

        assert sent_message == "User 1: Hello World"

class Connection(SyncManager):
    def __init__(self, address):
        self.register("get_messages")
        super().__init__(address=address, authkey=b'mychatsecret')
        self.connect()

    def broadcast(self, message):
        messages = self.get_messages()
        messages.append(message)


class TestConnection:
    def test_broadcast(self):
        """コネクションを確立させてメッセージの送信ができることを確認する
        """
        c = Connection(('localhost', 9090))
        c.broadcast("some message")
        assert c.get_message()[-1] == "some message"

class TestConnection:
    def test_broadcast(self):
        """コネクションを確立させてメッセージの送信ができることを確認する
        """
        # unittest.mock.patch.objectを使ってConnectionにパッチを当てる
        with unittest.mock.patch.object(Connection, "connect"):
            c = Connection(('localhost', 9090))
        c.broadcast("some message")
        assert c.get_message()[-1] == "some message"

class TestConnection:
    def test_broadcast(self):
        """コネクションを確立させてメッセージの送信ができることを確認する
        """
        # unittest.mock.patch.objectを使ってConnectionにパッチを当てる
        with unittest.mock.patch.object(Connection, "connect"):
            c = Connection(('localhost', 9090))

        with unittest.mock.patch.object(c, "get_messages", return_value=[]):
            c.broadcast("some message")
            assert c.get_messages()[-1] == "some message"

class TestChatClient:
    ...

    def test_client_connection(self):
        client = ChatClient("User 1")

        connection_spy = unittest.mock.MagicMock()
        with unittest.mock.patch.object(client, "_get_connection",
                                        return_value=connection_spy):
            client.send_message("Hello World")
        # spyが期待通りの値を設定されて呼ばれているかテストする
        connection_spy.broadcast.assert_called_with(("User 1: Hello World"))

unittest.mock.Mock()
unittest.mock.patch.object()
unittest.mock.MagicMock()

from unittest.mock import Mock

# ファイルの代わりにMockを使う
def read_file(f):
    print("READING ALL FILE")
    return f.read()

m = Mock()
read_file(m)
>>> READING ALL FILE

# Stubみたいにして使う
m.read.return_value = "Hello World"
print(read_file(m))
>>> READING ALL FILE
        Hello World

# spyのように使う
m.read.call_count
>>> 2

# 正常系
m.read.assert_called_with()

# エラーが発生
m.read.assert_called_with("some argument")
>>> AssertionError: Expected call: read('some argument')
Actual call: read()

class TestConnection:
    ...
    def test_exchange_with_server(self):
        with unittest.mock.patch(
            "multiprocessing.managers.listener_client",
            new={"pickle": (None, FakeServer())}
        ):
            c1 = Connection(("localhost", 9090))
            c2 = Connection(("localhost", 9090))

            c1.broadcast("connected message")

            assert c2.get_messages()[-1] == "connected message"

class FakeServer:
    def __init__(self):
        self.last_command = None
        self.last_args = None
        self.messages = []

    def __call__(self, *args, **kwargs):
        return self
    
    def send(self, data):
        # Track any command that was sent to the server.
        callid, command, args, kwargs = data
        self.last_command = command
        self.last_args = args

    def recv(self, *args, **kwargs):
        if self.last_command == "dummy":
            return "#RETURN", None
        elif self.last_command == "create":
            return "#RETURN", ("fakeid", tuple())
        elif self.last_command == "append":
            self.messages.append(self.last_args[0])
            return "#RETURN", None
        elif self.last_command == "__getitem__":
            return "#RETURN", self.messages[self.last_args[0]]
        elif self.last_command in ("incref", "decref", 
                                   "accept_connection"):
            return "#RETURN", None
        else:
            return "#ERROR", ValueError("%s - %r" % (
                self.last_command,self.last_args)
            )

    def close(self):
        pass

class ChatClient:
    def __init__(self, nickname, connection_provider):
        self.nickname = nickname
        self._connection = None
        self._connection_provider = connection_provider
        self._last_msg_idx = 0

    def send_message(self, message):
        sent_message = "{}: {}".format(self.nickname, message)
        self.connection.broadcast(sent_message)
        return sent_message

    def fetch_messages(self):
        messages = list(self.connection.get_messages())
        new_messages = messages[self._last_msg_idx:]
        self._last_msg_idx = len(messages)
        return new_messages

    @property
    def connection(self):
        if self._connection is None:
            self._connection = self._connection_provider(("localhost", 
                                                          9090))
        return self._connection
    
    # @connection.setter
    # def connection(self, value):
    #     if self._connection is not None:
    #         self._connection.close()
    #     self._connection = value

    # def _get_connection(self):
    #     return Connection(("localhost", 9090))

# Before
    def test_client_connection(self):
        client = ChatClient("User 1")

        connection_spy = unittest.mock.MagicMock()
        with unittest.mock.patch.object(client, "_get_connection",
                                        return_value=connection_spy):
            client.send_message("Hello World")
        # spyが期待通りの値を設定されて呼ばれているかテストする
        connection_spy.broadcast.assert_called_with(("User 1: Hello World"))

# After
    def test_client_connection(self):
        connection_spy = unittest.mock.MagicMock()

        client = ChatClient("User 1", connection_provider=lambda *args:connection_spy)
        client.send_message("Hello World")
        connection_spy.broadcast.assert_called_with(("User 1: Hello World"))

# ディレクトリを指定
pytest tests/core tests/contrib

# ファイルを指定
pytest test_player_mechanics.py`

# ディレクトリ指定とファイル指定の組み合わせ
pytest tests/core tests/contrib/test_text_plugin.py

pytest ch2/test_acceptance.py::TestChatClient 

def test_reverse():
    """
    list.reverse inverts the order of items in a list, in place
    """
    # Arange
    greek = ['alpha', 'beta', 'gamma', 'delta']
	
    # Act
    result = greek.reverse()

    # Assert
    assert result is None
    assert greek == ['delta', 'gamma', 'beta', 'alpha']

def search(needle, haystack):
    left = 0
    right = len(haystack) - 1
    while left <= right:
        middle = left + (right - left) // 2
        middle_element = haystack[middle]
        if middle_element == needle:
            return middle
        elif middle_element < needle:
            left = middle + 1
        else:
            right = middle - 1
    raise ValueError("Value not in haystack")


def test_search():
    assert search(2, [1, 2, 3, 4]) == 1, \
        'found needle somewhere in the haystack'

def test_search_first_element():
    assert search(1, [1, 2, 3, 4]) == 0, \
        'search first element'

def test_search_last_element():
    assert search(4, [1, 2, 3, 4]) == 3, \
        'search last element'

def test_exception_not_found():
    from pytest import raises

    with raises(ValueError):
        search(-1, [1, 2, 3, 4])
    
    with raises(ValueError):
        search(5, [1, 2, 3, 4])

    with raises(ValueError):
        search(2, [1, 3, 4])

import requests
def most_common_word_in_web_page(words, url):
    """
    finds the most common word from a list of words
    in a web page, identified by its URL
    """
    response = requests.get(url)
    text = response.text
    word_frequency = {w: text.count(w) for w in words}
    return sorted(words, key=word_frequency.get)[-1]
    
if __name__ == '__main__':
    most_common = most_common_word_in_web_page(
        ['python', 'Python', 'programming'],
        'https://python.org/',
    )
    print(most_common)

import requests

# 依存性を持った箇所
def most_common_word_in_web_page(words, url):
    """
    finds the most common word from a list of words
    in a web page, identified by its URL
    """
    response = requests.get(url)
    return most_common_word(words, response.text)
    
# 依存性を持っていない箇所
def most_common_word(words, text):
    """
    finds the most common word from a list of words
    in a piece of text
    """
    word_frequency = {w: text.count(w) for w in words}
    return sorted(words, key=word_frequency.get)[-1]

if __name__ == '__main__':
    most_common = most_common_word_in_web_page(
        ['python', 'Python', 'programming'],
        'https://python.org/',
    )
    print(most_common)

import pytest
import sys, os
current_path = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, current_path + '/../')

from dependency.common_word import most_common_word

def test_most_common_word():
    assert most_common_word(['a', 'b', 'c'], 'abbbcc') \
            == 'b', 'most_common_word with unique answer'

def test_most_common_word_empty_candidate():
    from pytest import raises
    with raises(Exception):
        most_common_word([], 'abc')

def test_most_common_ambiguous_result():
    assert most_common_word(['a', 'b', 'c'], 'ab') \
        in ('a', 'b'), "there might be a tie"

def most_common_word_in_web_page(words, url, user_agent=requests):
    """
    finds the most common word from a list of words
    in a web page, identified by its URL
    """
    response = user_agent.get(url)
    return most_common_word(words, response.text)

$ python common_word.py 
Python

def test_with_test_double():
    class TestResponse():
        text = 'aa bbb c'
    class TestUserAgent():
        def get(self, url):
            return TestResponse()
    result = most_common_word_in_web_page(
        ['a', 'b', 'c'],
        'https://python.org/',
        user_agent=TestUserAgent()
    )
    assert result == 'b', \
        'most_common_word_in_web_page tested with test double'

def test_with_test_mock():
    from unittest.mock import Mock
    mock_requests = Mock()
    mock_requests.get.return_value.text = 'aa bbb c'
    result = most_common_word_in_web_page(
        ['a', 'b', 'c'],
        'https://python.org/',
        user_agent=mock_requests
    )
    assert result == 'b', \
        'most_common_word_in_web_page tested with test double'
    assert mock_requests.get.call_count == 1
    assert mock_requests.get.call_args[0][0] \
            == 'https://python.org/', 'called with right URL'

def most_common_word_in_web_page_no_args(words, url):
    """
    finds the most common word from a list of words
    in a web page, identified by its URL
    """
    response = requests.get(url)
    return most_common_word(words, response.text)

from unittest.mock import Mock, patch

def test_with_patch():
    mock_requests = Mock()
    mock_requests.get.return_value.text = 'aa bbb c'
    # 実際にpatchする箇所(この場合requests)と置き換え先のオブジェクト(Mock)を指定
    with patch('dependency.common_word.requests', mock_requests):
        result = most_common_word_in_web_page_no_args(
            ['a', 'b', 'c'],
            'https://python.org/',
        )
    assert result == 'b', \
        'most_common_word_in_web_page tested with test double'
    assert mock_requests.get.call_count == 1
    assert mock_requests.get.call_args[0][0] \
            == 'https://python.org/', 'called with right URL'

import unittest
from fibo import fibonacci

class Test(unittest.TestCase):

    def test_fibo(self):
        result = fibonacci(4)
        self.assertEqual(result, 3)

if __name__ == '__main__':
    unittest.main()

# テストを通過したとき
$ python test_fibo.py
.
----------------------------------------------------------------------
Ran 1 test in 0.000s

# 失敗したとき
$ python test_fibo.py
.
======================================================================
FAIL: test_fibo (__main__.Test)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "test_fibo.py", line 8, in test_fibo
    self.assertEqual(result, 3)
AssertionError: 5 != 3

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures=1)

self.assertEqual(a, b)
self.assertNotEqual(a, b)
self.assertTrue(x)
self.assertFalse(x)
self.assertIs(a, b)
self.assertIsNot(a, b)
self.assertIsNone(x)
self.assertIsNotNone(x)
self.assertIn(a, b)
self.assertNotIn(a, b)
self.assertIsInstance(a, b)
self.assertNotIsInstance(a, b)
self.assertRaises(exc, fun, *args, **kwds)
self.assertRaisesRegex(exc, r, fun, *args, **kwds)
self.assertWarns(warn, fun, *args, **kwds)
self.assertWarnsRegex(warn, r, fun, *args, **kwds)
self.assertLogs(logger, level)
self.assertMultiLineEqual(a, b)
self.assertSequenceEqual(a, b)
self.assertListEqual(a, b)
self.assertTupleEqual(a, b)
self.assertSetEqual(a, b)
self.assertDictEqual(a, b)
self.assertAlmostEqual(a, b)
self.assertNotAlmostEqual(a, b)
self.assertGreater(a, b)
self.assertGreaterEqual(a, b)
self.assertLess(a, b)
self.assertLessEqual(a, b)
self.assertRegex(s, r)
self.assertNotRegex(s, r)
self.assertCountEqual(a, b)

# pythonでassertを実行した際
>>> assert "using assert for errors" == "using asert for errors"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

# pytestで実行した際
$ pytest test_long_lines.py -q
F                                                                                    [100%]
========================================= FAILURES =========================================
_____________________________________ test_long_lines ______________________________________

    def test_long_lines():
>       assert "using assert for errors" == "using asert for errors"
E       AssertionError: assert 'using assert for errors' == 'using asert for errors'
E         - using assert for errors
E         ?        -
E         + using asert for errors

test_long_lines.py:2: AssertionError
1 failed in 0.03s

$ pytest test_long_lines.py::test_long_list -q
F                                                                                    [100%]
========================================= FAILURES =========================================
______________________________________ test_long_list ______________________________________

    def test_long_list():
>       assert ['a', 'very', 'long', 'list', 'of', 'items'] == [
                'a', 'very', 'long', 'list', 'items']
E       AssertionError: assert ['a', 'very',...'of', 'items'] == ['a', 'very',...ist', 'items']
E         At index 4 diff: 'of' != 'items'
E         Left contains one more item: 'items'
E         Full diff:
E         - ['a', 'very', 'long', 'list', 'of', 'items']
E         ?                              ------
E         + ['a', 'very', 'long', 'list', 'items']

test_long_lines.py:5: AssertionError
1 failed in 0.04s

def test_highest_rated():
    series = [
        ("The Office", 2005, 8.8),
        ...,
    ]
    assert highest_rated(series) == "Seinfeld"

def test_oldest():
    series = [
        ("The Office", 2005, 8.8),
        ...,
    ]
    assert oldest(series) == "Seinfeld"

@pytest.fixture
def comedy_series():
    return [
        ("The Office", 2005, 8.8),
        ("Scrubs", 2001, 8.4),
        ("IT Crowd", 2006, 8.5),
        ("Parks and Recreation", 2009, 8.6),
        ("Seinfeld", 1989, 8.9),
    ]

def test_highest_rated(comedy_series):
    assert highest_rated(comedy_series) == "Seinfeld"

def test_oldest(comedy_series):
    assert oldest(comedy_series) == "Seinfeld"

# mark
@pytest.mark.slow
def test_long_computation():

@pytest.mark.timeout(10, method="thread")
def test_topology_sort():

# slowがついたものだけ実行
pytest -m slow

# slowがついていて、serialがついていないもののみ実行
pytest -m "slow and not serial"

$ pytest -m "smoke"
...
$ pytest -m "unittest"
...
$ pytest -m "integration"
...
$ pytest -m "not smoke and not unittest and not integration"

$ pytest -m "smoke"
...
$ pytest -m "unittest"
...
$ pytest -m "integration"
...
$ pytest -m "not smoke and not unittest and not integration"

[pytest]
addopts = --strict
markers =
    slow
    serial
    smoke: quick tests that cover a good portion of the code
    unittest: unit tests for basic functionality
    integration: cover to cover functionality testing

# parameterを使わない場合
from my_module import string_to_bool

class TestStringToBool(object):

    def test_it_detects_lowercase_yes(self):
        assert string_to_bool('yes')

    def test_it_detects_odd_case_yes(self):
        assert string_to_bool('YeS')

    def test_it_detects_uppercase_yes(self):
        assert string_to_bool('YES')

    def test_it_detects_positive_str_integers(self):
        assert string_to_bool('1')

    def test_it_detects_true(self):
        assert string_to_bool('true')

    def test_it_detects_true_with_trailing_spaces(self):
        assert string_to_bool('true ')

    def test_it_detects_true_with_leading_spaces(self):
        assert string_to_bool(' true')


# Parametrizeを利用した場合
import pytest
from my_module import string_to_bool

true_values = ['yes', '1', 'Yes', 'TRUE', 'TruE', 'True', 'true']

class TestStrToBool(object):

    @pytest.mark.parametrize('value', true_values)
    def test_it_detects_truish_strings(self, value)
        assert string_to_bool(value)

import pytest
import sys, os

current_path = os.path.dirname(os.path.abspath(__file__))
sys.path.append(current_path + '/.../')

from _lambda import prod_api_screening

datas = [
    (100, {"divide": 10,  "scale": 1}, '10.0')    
]

@pytest.mark.parametrize("decimals, unit_item, expect", datas)
def test_edit_decimal(decimals, unit_item, expect):
    screening = prod_api_screening.ScreeningPageClass()
    
    result = screening._edit_decimal(decimals, unit_item)
    
    assert result == expect

>>> 0.1 + 0.2 == 0.3
False

def test_approx_simple():
    assert 0.1 + 0.2 == approx(0.3)
    

{
  "BASE_URL": "https://xxxxxxxxxx.execute-api.ap-northeast-1.amazonaws.com/api/",
  "API_KEY": "xxxxxxxxxxxxxxxxx"
}

def pytest_addoption(parser):
    """Add pytest command options."""
    parser.addoption(
        "--dev",
        action="store_true",
        default=False,
        help="set local endpoint"
    )

@pytest.fixture(scope='session', autouse=True)
def cmdopt(request):
    """Get options value."""

    # ENV
    os.environ['ENV'] = request.config.getoption("--env")

    # load file
    if(request.config.getoption("--local")):
        set_environment_variable('./variable.dev.json')
    else:
        print(os.getcwd())
        set_environment_variable('./tests/system/variables.json')


def set_environment_variable(json_filepath):
    """Jsonを読み込み環境変数にセットする."""
    with open(json_filepath) as filedata:
        for key, value in json.load(filedata).items():
            os.environ[key] = value

def test_foo():
    BASE_URL = os.getenv('BASE_URL')

# 開発環境のテスト
$ pytest tests --dev

# 本番環境のテスト
$ pytest tests

...
@pytest.fixture(scope='session')
def base_url(cmdopt):
    return os.getenv('BASE_URL')

def test_foo(base_url):
    url =  os.path.join(base_url, 'foo/bar')

 pytest --cov=functions/ tests/unit --html=index.html

 pytest --cov=functions/ tests/unit --junitxml=report.xml

pip install pytest-cov

pytest -v --cov=src tests

-------------------- coverage: ... ---------------------
Name                 Stmts   Miss  Cover
----------------------------------------
myproj/__init__          2      0   100%
myproj/myproj          257     13    94%
myproj/feature4286      94      7    92%
----------------------------------------
TOTAL                  353     20    94%

 pytest --cov=functions/ tests/unit  --cov-report=html

$ pytest --cov-report term --cov-report=html
----------- coverage: platform linux, python 3.7.8-final-0 -----------
Name                                                                            Stmts   Miss  Cover
---------------------------------------------------------------------------------------------------
path/to/your/file/test.py     112      8    93%
---------------------------------------------------------------------------------------------------
TOTAL                                                                             112      8    93%
Coverage HTML written to dir htmlcov

class TestTODOAcceptance:
    def test_main(self):
        app = TODOApp(io=(self.fake_input, self.fake_output))

class TestTODOAcceptance:
    def test_main(self):
        app = TODOApp(io=(self.fake_input, self.fake_output))

+        app_thread = threading.Thread(target=app.run, daemon=True)
+        app_thread.start()

        self.send_input("quit")
        app_thread.join(timeout=1)
        assert self.get_output() == "bye!\n"

.
├── src
│   ├── setup.py
│   ├── todo
└── tests
    ├── __init__.py
    └── test_acceptance.py

from setuptools import setup

setup(name='todo', packages=['todo'])

pip install -e src/

class TestTODOAcceptance:
    @pytest.fixture
    def fake_inputs(self):
        self.inputs = queue.Queue()
        self.outputs = queue.Queue()

        self.fake_output = lambda txt: self.outputs.put(txt)
        self.fake_input = lambda: self.inputs.get()

        self.get_output = lambda: self.outputs.get(timeout=1)
        self.send_input = lambda cmd: self.inputs.put(cmd)


    def test_main(self, fake_inputs):

 robot hellotest.robot 
==============================================================================
Hellotest                                                                     
==============================================================================
Hello World                                                           | PASS |
------------------------------------------------------------------------------
Hellotest                                                             | PASS |
1 test, 1 passed, 0 failed
==============================================================================

$ webdrivermanager firefox chrome

from pytest import raises

with raises(Exception, message="empty word raises"):
    ...

    from pytest import raises
    with raises(Exception):
        most_common_word([], 'abc')
        pytest.fail("empty word raises")

% pytest test_fixture.py

def test_something():
    a = 5
    b = 10
    assert a + b == 11

class TestMultiple:
    def test_first(self):
        assert 5 == 5

    def test_second(self):
        assert 10 == 10

% pytest -k first
====================== test session starts =======================
platform darwin -- Python 3.9.4, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
...
collected 3 items / 2 deselected / 1 selected                    

test_sample.py .                                           [100%]

================ 1 passed, 2 deselected in 0.00s =================

% pytest -k "not something"
================================== test session starts ===================================
platform darwin -- Python 3.9.4, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
...
collected 3 items / 1 deselected / 2 selected                                            

test_sample.py ..                                                                  [100%]

============================ 2 passed, 1 deselected in 0.00s =============================

pytest tests -s

import pytest

@pytest.fixture
def greetings():
    print("HELLO!")
    yield
    print("GOODBYE")

class TestMultiple:
    def test_first(self):
        assert 5 == 5

    @pytest.mark.usefixtures("greetings")
    def test_second(self):
        assert 10 == 10

% pytest test_fixture.py -s   
============================================ test session starts =============================================
platform darwin -- Python 3.9.4, pytest-6.2.4, py-1.10.0, pluggy-0.13.1
...
collected 2 items                                                                                            

test_fixture.py .HELLO!
.GOODBYE

@pytest.fixture(scope="class")
def provide_current_time(request):
    import datetime
    request.cls.now = datetime.datetime.utcnow()

    print("ENTER CLS")
    yield
    print("EXIT CLS")

@pytest.mark.usefixtures("provide_current_time")
class TestMultiple:
    def test_first(self):
        print("RUNNING AT", self.now)
        assert 5 == 5

    @pytest.mark.usefixtures("greetings")
    def test_second(self):
        assert 10 == 10

import pytest

@pytest.fixture(scope="session", autouse=True)
def setupsuite():
    print("STARTING TESTS")
    yield
    print("FINISHED TESTS")

% pytest test_fixture.py -s -v                                                
...
test_fixture.py::TestMultiple::test_first STARTING TESTS
ENTER CLS
RUNNING AT 2021-10-13 02:22:08.606573
PASSED
test_fixture.py::TestMultiple::test_second HELLO!
PASSEDGOODBYE
EXIT CLS
FINISHED TESTS


=========================== 2 passed in 0.00s ===========================

@pytest.fixture
def random_number_generator():
    import random
    def _number_provider():
        return random.choice(range(10))
    yield _number_provider

def test_something(random_number_generator):
    a = random_number_generator()
    print(a)
    b = 10
    assert a + b >= 10

import pytest

def test_something(random_number_generator):
    a = random_number_generator()
    b = 10
    assert a + b == 11


@pytest.fixture
def random_number_generator():
    """常に1が返される"""
    def _number_provider():
        return 1
    yield _number_provider

def validate(text):
    return 0 < len(text) <= 100

class TestValidate:
    def test_validate(self):
        assert validate("a")
        assert validate("a" * 50)
        assert validate("a" * 100)
        assert not validate("")
        assert not validate("a" * 101)

class TestValidate:
    def test_valid(self):
        """検証が正しい場合
        """
        assert validate("a")
        assert validate("a" * 50)
        assert validate("a" * 100)

    def test_invalid_too_short(self):
        """検証が正しくない: 文字が短すぎる場合
        """
        assert not validate("")
    
    def test_invalid_too_long(self):
        """検証が正しくない: 文字が長すぎる場合
        """
        assert not validate("a" * 101)

class TestValidate:
    @pytest.mark.parametrize("text", ["a", "a" * 50, "a" * 100])
     def test_valid(self, text):
        """検証が正しい場合
        """
        assert validate(text)

    @pytest.mark.parametrize("text", ["", "a" * 101])
    def test_invalid_too_short(self, text):
        """検証が正しくない場合
        """
        assert not validate(text)

import pytest

class TestSum:
    def setup(self):
        self.data = [0, 1, 2, 3]

    def test_sum(self):
        self.data.append(4)
        actual = sum(self.data)
        assert actual == 10

    def test_negative(self):
        self.data.append(-5)
        actual = sum(self.data)
        assert actual == 5

    def test_type_error(self):
        self.data.append(None)
        with pytest.raises(TypeError):
            sum(self.data)

import pytest

class TestSum:
    
    def test_sum(self):
        assert sum([0, 1, 2, 3, 4]) == 10

    def test_negative(self):
        assert sum([0, 1, 2, 3, 4, -5]) == 5

    def test_type_error(self):
        with pytest.raises(TypeError):
            sum([1, None])

import pytest

@pytest.fixture(scope="function")
def test_db():
    print('Setup')

    yield 1

    print("TearDown")

@pytest.mark.usefixtures("test_db")
def test_read_users_empty():
    response = client.get("/users/")
    assert response.status_code == 200
    assert response.json() == []

def test_read_users_empty(test_db):
    response = client.get("/users/")
    assert response.status_code == 200
    assert response.json() == []