1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
# pytest-lazy-fixtures
[](https://codecov.io/gh/dev-petrov/pytest-lazy-fixtures)
[](https://github.com/dev-petrov/pytest-lazy-fixtures/actions/workflows/ci-test.yml)
[](https://badge.fury.io/py/pytest-lazy-fixtures)
Use your fixtures in `@pytest.mark.parametrize`.
This project was inspired by [pytest-lazy-fixture](https://github.com/TvoroG/pytest-lazy-fixture).
Improvements that have been made in this project:
1. You can use fixtures in any data structures
2. You can access the attributes of fixtures
3. You can use functions in fixtures
## Installation
```shell
pip install pytest-lazy-fixtures
```
## Usage
To use your fixtures inside `@pytest.mark.parametrize` you can use `lf` (`lazy_fixture`) or `pytest.lazy_fixtures`.
```python
import pytest
from pytest_lazy_fixtures import lf
@pytest.fixture()
def one():
return 1
@pytest.mark.parametrize('arg1,arg2', [('val1', lf('one'))])
def test_func(arg1, arg2):
assert arg2 == 1
@pytest.mark.parametrize('arg1,arg2', [('val1', pytest.lazy_fixtures('one'))])
def test_func(arg1, arg2):
assert arg2 == 1
```
`lf` can be used with any data structures. For example, in the following example, `lf` is used in the dictionary:
```python
import pytest
from pytest_lazy_fixtures import lf
@pytest.fixture()
def one():
return 1
@pytest.mark.parametrize('arg1,arg2', [('val1', {"value": lf('one')})])
def test_func(arg1, arg2):
assert arg2 == {"value": 1}
```
You can also specify getting an attribute through a dot:
```python
import pytest
from pytest_lazy_fixtures import lf
class Entity:
def __init__(self, value):
self.value = value
@pytest.fixture()
def one():
return Entity(1)
@pytest.mark.parametrize('arg1,arg2', [('val1', lf('one.value'))])
def test_func(arg1, arg2):
assert arg2 == 1
```
And there is some useful wrapper called `lfc` (`lazy_fixture_callable`) or `pytest.lazy_fixtures_callable`.
It can work with any callable and your fixtures, e.g.
```python
import pytest
from pytest_lazy_fixtures import lf, lfc
class Entity:
def __init__(self, value):
self.value = value
def __str__(self) -> str:
return str(self.value)
def sum(self, value: int) -> int:
return self.value + value
@pytest.fixture()
def entity():
return Entity(1)
@pytest.fixture()
def two():
return 2
@pytest.fixture()
def three():
return 3
@pytest.fixture()
def entity_format():
def _entity_format(entity: Entity):
return {"value": entity.value}
return _entity_format
@pytest.mark.parametrize(
"message",
[
lfc(
"There is two lazy fixture args, {} and {}! And one kwarg {field}! And also simple value {simple}".format,
lf("entity"),
lf("two"),
field=lf("three"),
simple="value",
),
],
)
def test_lazy_fixture_callable_with_func(message):
assert message == "There is two lazy fixture args, 1 and 2! And one kwarg 3! And also simple value value"
@pytest.mark.parametrize("formatted", [lfc("entity_format", lf("entity"))])
def test_lazy_fixture_callable_with_lf(formatted, entity):
assert formatted == {"value": entity.value}
@pytest.mark.parametrize("result", [lfc("entity.sum", lf("two"))])
def test_lazy_fixture_callable_with_attr_lf(result):
assert result == 3
```
## Contributing
Contributions are very welcome. Tests can be run with `pytest`.
## License
Distributed under the terms of the `MIT` license, `pytest-lazy-fixtures` is free and open source software
## Issues
If you encounter any problems, please file an issue along with a detailed description.
|
