LostInDarkMath/pedantic-python-decorators | Build 10283439719 | pedantic/tests/tests_small_method_decorators.py | Coveralls

1

import asyncio

2✔

2

import unittest

2✔

3

import warnings

2✔

4

from unittest import IsolatedAsyncioTestCase

2✔

6

from pedantic import overrides, timer, count_calls, trace, trace_if_returns, does_same_as_function, deprecated, \

2✔

8

from pedantic.exceptions import NotImplementedException, PedanticOverrideException, PedanticCallWithArgsException

2✔

11

class TestSmallDecoratorMethods(unittest.TestCase):

2✔

12

    def test_overrides_parent_has_no_such_method(self):

2✔

13

        class MyClassA:

2✔

14

            pass

2✔

16

        with self.assertRaises(expected_exception=PedanticOverrideException):

2✔

17

            class MyClassB(MyClassA):

2✔

18

                @overrides(MyClassA)

2✔

19

                def operation(self):

2✔

22

    def test_overrides_all_good(self):

2✔

23

        class MyClassA:

2✔

24

            def operation(self):

2✔

27

        class MyClassB(MyClassA):

2✔

28

            @overrides(MyClassA)

2✔

29

            def operation(self):

2✔

30

                return 42

2✔

32

        b = MyClassB()

2✔

33

        b.operation()

2✔

35

    def test_overrides_static_method(self):

2✔

36

        class MyClassA:

2✔

37

            @staticmethod

2✔

38

            def operation():

2✔

41

        class MyClassB(MyClassA):

2✔

42

            @staticmethod

2✔

43

            @overrides(MyClassA)

2✔

44

            def operation():

2✔

45

                return 42

2✔

47

        b = MyClassB()

2✔

48

        self.assertEqual(b.operation(), 42)

2✔

49

        self.assertEqual(MyClassB.operation(), 42)

2✔

51

    def test_overrides_below_property(self):

2✔

52

        class MyClassA:

2✔

53

            @property

2✔

54

            def operation(self):

2✔

57

        class MyClassB(MyClassA):

2✔

58

            @property

2✔

59

            @overrides(MyClassA)   # Note: it does not work the other way around

2✔

60

            def operation(self):

2✔

61

                return 43

2✔

63

        b = MyClassB()

2✔

64

        self.assertEqual(b.operation, 43)

2✔

66

    def test_overrides_function(self):

2✔

67

        class MyClassA:

2✔

68

            pass

2✔

70

        with self.assertRaises(expected_exception=PedanticOverrideException):

2✔

71

            @overrides(MyClassA)

2✔

72

            def operation():

2✔

75

    def test_deprecated_1(self):

2✔

76

        @deprecated

2✔

77

        def old_method(i: int) -> str:

2✔

78

            return str(i)

2✔

80

        with warnings.catch_warnings(record=True) as w:

2✔

81

            warnings.simplefilter("always")

2✔

82

            old_method(42)

2✔

83

            assert len(w) == 1

2✔

84

            assert issubclass(w[-1].category, DeprecationWarning)

2✔

85

            assert "deprecated" in str(w[-1].message)

2✔

87

    def test_deprecated_2(self):

2✔

88

        def old_method(i: int) -> str:

2✔

89

            return str(i)

2✔

91

        with warnings.catch_warnings(record=True) as w:

2✔

92

            warnings.simplefilter("always")

2✔

93

            old_method(42)

2✔

94

            assert not len(w) == 1

2✔

96

    def test_unimplemented(self):

2✔

97

        @unimplemented

2✔

98

        def dirt(i: int) -> str:

2✔

101

        with self.assertRaises(expected_exception=NotImplementedException):

2✔

102

            dirt(42)

2✔

104

    def test_timer(self):

2✔

105

        @timer

2✔

106

        def operation(i: int) -> str:

2✔

107

            return str(i)

2✔

109

        operation(42)

2✔

111

    def test_count_calls(self):

2✔

112

        @count_calls

2✔

113

        def operation(i: int) -> str:

2✔

114

            return str(i)

2✔

116

        operation(42)

2✔

118

    def test_trace(self):

2✔

119

        def some_method(x, y):

2✔

120

            return x + y

2✔

122

        traced_method = trace(some_method)

2✔

123

        self.assertEqual(some_method(42, 99), traced_method(42, 99))

2✔

125

    def test_trace_if_returns(self):

2✔

126

        def some_method(x, y):

2✔

127

            return x + y

2✔

128

        traced_method = trace_if_returns(100)(some_method)

2✔

129

        self.assertEqual(some_method(42, 99), traced_method(42, 99))

2✔

130

        self.assertEqual(some_method(42, 58), traced_method(42, 58))

2✔

132

    def test_does_same_as_function(self):

2✔

133

        def some_method(x, y, z):

2✔

134

            return x * (y + z)

2✔

136

        @does_same_as_function(some_method)

2✔

137

        def other_method(x, y, z):

2✔

138

            return x * y + x * z

2✔

140

        other_method(1, 2, 3)

2✔

141

        other_method(4, 5, 6)

2✔

143

    def test_does_same_as_function_wrong(self):

2✔

144

        def some_method(x, y, z):

2✔

145

            return x * (y + z)

2✔

147

        @does_same_as_function(some_method)

2✔

148

        def other_method(x, y, z):

2✔

149

            return x * y + z

2✔

151

        other_method(0, 2, 0)

2✔

152

        with self.assertRaises(expected_exception=AssertionError):

2✔

153

            other_method(4, 5, 6)

2✔

156

class AsyncSmallDecoratorTests(IsolatedAsyncioTestCase):

2✔

157

    async def test_overrides_async_instance_method(self) -> None:

2✔

158

        class MyClassA:

2✔

159

            async def operation(self):

2✔

162

        class MyClassB(MyClassA):

2✔

163

            @overrides(MyClassA)

2✔

164

            async def operation(self):

2✔

165

                await asyncio.sleep(0)

2✔

166

                return 42

2✔

168

        b = MyClassB()

2✔

169

        await b.operation()

2✔

171

    async def test_overrides_parent_has_no_such_method_async(self):

2✔

172

        class MyClassA:

2✔

173

            pass

2✔

175

        with self.assertRaises(expected_exception=PedanticOverrideException):

2✔

176

            class MyClassB(MyClassA):

2✔

177

                @overrides(MyClassA)

2✔

178

                async def operation(self):

2✔

181

    async def test_count_calls_async(self):

2✔

182

        @count_calls

2✔

183

        async def operation(i: int) -> str:

2✔

184

            await asyncio.sleep(0)

2✔

185

            return str(i)

2✔

187

        res = await operation(42)

2✔

188

        self.assertEqual('42', res)

2✔

190

    async def test_trace_async(self):

2✔

191

        async def some_method(x, y):

2✔

192

            await asyncio.sleep(0)

2✔

193

            return x + y

2✔

195

        traced_method = trace(some_method)

2✔

196

        self.assertEqual(await some_method(42, 99), await traced_method(42, 99))

2✔

198

    async def test_trace_if_returns_async(self):

2✔

199

        async def some_method(x, y):

2✔

200

            await asyncio.sleep(0)

2✔

201

            return x + y

2✔

203

        traced_method = trace_if_returns(100)(some_method)

2✔

204

        self.assertEqual(await some_method(42, 99), await traced_method(42, 99))

2✔

205

        self.assertEqual(await some_method(42, 58), await traced_method(42, 58))

2✔

207

    async def test_timer_async(self):

2✔

208

        @timer

2✔

209

        async def operation(i: int) -> str:

2✔

210

            await asyncio.sleep(0.05)

2✔

211

            return str(i)

2✔

213

        await operation(42)

2✔

215

    async def test_deprecated_async(self):

2✔

216

        @deprecated

2✔

217

        async def old_method(i: int) -> str:

2✔

218

            return str(i)

2✔

220

        with warnings.catch_warnings(record=True) as w:

2✔

221

            warnings.simplefilter("always")

2✔

222

            await old_method(42)

2✔

223

            assert len(w) == 1

2✔

224

            assert issubclass(w[-1].category, DeprecationWarning)

2✔

225

            assert "deprecated" in str(w[-1].message)

2✔

227

    async def test_does_same_as_function_async(self):

2✔

228

        async def some_method(x, y, z):

2✔

229

            await asyncio.sleep(0)

2✔

230

            return x * (y + z)

2✔

232

        @does_same_as_function(some_method)

2✔

233

        async def other_method(x, y, z):

2✔

234

            await asyncio.sleep(0)

2✔

235

            return x * y + x * z

2✔

237

        await other_method(1, 2, 3)

2✔

238

        await other_method(4, 5, 6)

2✔

240

    async def test_does_same_as_function_async_and_sync(self):

2✔

241

        def some_method(x, y, z):

2✔

242

            return x * (y + z)

2✔

244

        @does_same_as_function(some_method)

2✔

245

        async def other_method(x, y, z):

2✔

246

            await asyncio.sleep(0)

2✔

247

            return x * y + x * z

2✔

249

        await other_method(1, 2, 3)

2✔

250

        await other_method(4, 5, 6)

2✔

252

    async def test_does_same_as_function_wrong(self):

2✔

253

        async def some_method(x, y, z):

2✔

254

            await asyncio.sleep(0)

2✔

255

            return x * (y + z)

2✔

257

        @does_same_as_function(some_method)

2✔

258

        async def other_method(x, y, z):

2✔

259

            await asyncio.sleep(0)

2✔

260

            return x * y + z

2✔

262

        await other_method(0, 2, 0)

2✔

264

        with self.assertRaises(expected_exception=AssertionError):

2✔

265

            await other_method(4, 5, 6)

2✔

267

    async def test_mock_async(self) -> None:

2✔

268

        @mock(return_value=42)

2✔

269

        async def my_function(a, b, c):

2✔

273

        assert await my_function(1, 2, 3) == 42

2✔

274

        assert await my_function(100, 200, 300) == 42

2✔

276

    async def test_require_kwargs(self):

2✔

277

        @require_kwargs

2✔

278

        async def calc(n: int, m: int, i: int) -> int:

2✔

279

            return n + m + i

2✔

281

        await calc(n=1, m=2, i=3)

2✔

283

        with self.assertRaises(expected_exception=PedanticCallWithArgsException):

2✔

284

            await calc(1, m=2, i=3)

2✔

LostInDarkMath / pedantic-python-decorators / 10283439719

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1	import asyncio	2✔
2	import unittest	2✔
3	import warnings	2✔
4	from unittest import IsolatedAsyncioTestCase	2✔
5
6	from pedantic import overrides, timer, count_calls, trace, trace_if_returns, does_same_as_function, deprecated, \	2✔
7	unimplemented, mock, require_kwargs
8	from pedantic.exceptions import NotImplementedException, PedanticOverrideException, PedanticCallWithArgsException	2✔
9
10
11	class TestSmallDecoratorMethods(unittest.TestCase):	2✔
12	def test_overrides_parent_has_no_such_method(self):	2✔
13	class MyClassA:	2✔
14	pass	2✔
15
16	with self.assertRaises(expected_exception=PedanticOverrideException):	2✔
17	class MyClassB(MyClassA):	2✔
18	@overrides(MyClassA)	2✔
19	def operation(self):	2✔
20	return 42	×
21
22	def test_overrides_all_good(self):	2✔
23	class MyClassA:	2✔
24	def operation(self):	2✔
25	pass	×
26
27	class MyClassB(MyClassA):	2✔
28	@overrides(MyClassA)	2✔
29	def operation(self):	2✔
30	return 42	2✔
31
32	b = MyClassB()	2✔
33	b.operation()	2✔
34
35	def test_overrides_static_method(self):	2✔
36	class MyClassA:	2✔
37	@staticmethod	2✔
38	def operation():	2✔
UNCOV 39	pass	×
40
41	class MyClassB(MyClassA):	2✔
42	@staticmethod	2✔
43	@overrides(MyClassA)	2✔
44	def operation():	2✔
45	return 42	2✔
46
47	b = MyClassB()	2✔
48	self.assertEqual(b.operation(), 42)	2✔
49	self.assertEqual(MyClassB.operation(), 42)	2✔
50
51	def test_overrides_below_property(self):	2✔
52	class MyClassA:	2✔
53	@property	2✔
54	def operation(self):	2✔
NEW 55	return 42	×
56
57	class MyClassB(MyClassA):	2✔
58	@property	2✔
59	@overrides(MyClassA) # Note: it does not work the other way around	2✔
60	def operation(self):	2✔
61	return 43	2✔
62
63	b = MyClassB()	2✔
64	self.assertEqual(b.operation, 43)	2✔
65
66	def test_overrides_function(self):	2✔
67	class MyClassA:	2✔
68	pass	2✔
69
70	with self.assertRaises(expected_exception=PedanticOverrideException):	2✔
71	@overrides(MyClassA)	2✔
72	def operation():	2✔
UNCOV 73	return 42	×
74
75	def test_deprecated_1(self):	2✔
76	@deprecated	2✔
77	def old_method(i: int) -> str:	2✔
78	return str(i)	2✔
79
80	with warnings.catch_warnings(record=True) as w:	2✔
81	warnings.simplefilter("always")	2✔
82	old_method(42)	2✔
83	assert len(w) == 1	2✔
84	assert issubclass(w[-1].category, DeprecationWarning)	2✔
85	assert "deprecated" in str(w[-1].message)	2✔
86
87	def test_deprecated_2(self):	2✔
88	def old_method(i: int) -> str:	2✔
89	return str(i)	2✔
90
91	with warnings.catch_warnings(record=True) as w:	2✔
92	warnings.simplefilter("always")	2✔
93	old_method(42)	2✔
94	assert not len(w) == 1	2✔
95
96	def test_unimplemented(self):	2✔
97	@unimplemented	2✔
98	def dirt(i: int) -> str:	2✔
UNCOV 99	return str(i)	×
100
101	with self.assertRaises(expected_exception=NotImplementedException):	2✔
102	dirt(42)	2✔
103
104	def test_timer(self):	2✔
105	@timer	2✔
106	def operation(i: int) -> str:	2✔
107	return str(i)	2✔
108
109	operation(42)	2✔
110
111	def test_count_calls(self):	2✔
112	@count_calls	2✔
113	def operation(i: int) -> str:	2✔
114	return str(i)	2✔
115
116	operation(42)	2✔
117
118	def test_trace(self):	2✔
119	def some_method(x, y):	2✔
120	return x + y	2✔
121
122	traced_method = trace(some_method)	2✔
123	self.assertEqual(some_method(42, 99), traced_method(42, 99))	2✔
124
125	def test_trace_if_returns(self):	2✔
126	def some_method(x, y):	2✔
127	return x + y	2✔
128	traced_method = trace_if_returns(100)(some_method)	2✔
129	self.assertEqual(some_method(42, 99), traced_method(42, 99))	2✔
130	self.assertEqual(some_method(42, 58), traced_method(42, 58))	2✔
131
132	def test_does_same_as_function(self):	2✔
133	def some_method(x, y, z):	2✔
134	return x * (y + z)	2✔
135
136	@does_same_as_function(some_method)	2✔
137	def other_method(x, y, z):	2✔
138	return x * y + x * z	2✔
139
140	other_method(1, 2, 3)	2✔
141	other_method(4, 5, 6)	2✔
142
143	def test_does_same_as_function_wrong(self):	2✔
144	def some_method(x, y, z):	2✔
145	return x * (y + z)	2✔
146
147	@does_same_as_function(some_method)	2✔
148	def other_method(x, y, z):	2✔
149	return x * y + z	2✔
150
151	other_method(0, 2, 0)	2✔
152	with self.assertRaises(expected_exception=AssertionError):	2✔
153	other_method(4, 5, 6)	2✔
154
155
156	class AsyncSmallDecoratorTests(IsolatedAsyncioTestCase):	2✔
157	async def test_overrides_async_instance_method(self) -> None:	2✔
158	class MyClassA:	2✔
159	async def operation(self):	2✔
UNCOV 160	pass	×
161
162	class MyClassB(MyClassA):	2✔
163	@overrides(MyClassA)	2✔
164	async def operation(self):	2✔
165	await asyncio.sleep(0)	2✔
166	return 42	2✔
167
168	b = MyClassB()	2✔
169	await b.operation()	2✔
170
171	async def test_overrides_parent_has_no_such_method_async(self):	2✔
172	class MyClassA:	2✔
173	pass	2✔
174
175	with self.assertRaises(expected_exception=PedanticOverrideException):	2✔
176	class MyClassB(MyClassA):	2✔
177	@overrides(MyClassA)	2✔
178	async def operation(self):	2✔
UNCOV 179	return 42	×
180
181	async def test_count_calls_async(self):	2✔
182	@count_calls	2✔
183	async def operation(i: int) -> str:	2✔
184	await asyncio.sleep(0)	2✔
185	return str(i)	2✔
186
187	res = await operation(42)	2✔
188	self.assertEqual('42', res)	2✔
189
190	async def test_trace_async(self):	2✔
191	async def some_method(x, y):	2✔
192	await asyncio.sleep(0)	2✔
193	return x + y	2✔
194
195	traced_method = trace(some_method)	2✔
196	self.assertEqual(await some_method(42, 99), await traced_method(42, 99))	2✔
197
198	async def test_trace_if_returns_async(self):	2✔
199	async def some_method(x, y):	2✔
200	await asyncio.sleep(0)	2✔
201	return x + y	2✔
202
203	traced_method = trace_if_returns(100)(some_method)	2✔
204	self.assertEqual(await some_method(42, 99), await traced_method(42, 99))	2✔
205	self.assertEqual(await some_method(42, 58), await traced_method(42, 58))	2✔
206
207	async def test_timer_async(self):	2✔
208	@timer	2✔
209	async def operation(i: int) -> str:	2✔
210	await asyncio.sleep(0.05)	2✔
211	return str(i)	2✔
212
213	await operation(42)	2✔
214
215	async def test_deprecated_async(self):	2✔
216	@deprecated	2✔
217	async def old_method(i: int) -> str:	2✔
218	return str(i)	2✔
219
220	with warnings.catch_warnings(record=True) as w:	2✔
221	warnings.simplefilter("always")	2✔
222	await old_method(42)	2✔
223	assert len(w) == 1	2✔
224	assert issubclass(w[-1].category, DeprecationWarning)	2✔
225	assert "deprecated" in str(w[-1].message)	2✔
226
227	async def test_does_same_as_function_async(self):	2✔
228	async def some_method(x, y, z):	2✔
229	await asyncio.sleep(0)	2✔
230	return x * (y + z)	2✔
231
232	@does_same_as_function(some_method)	2✔
233	async def other_method(x, y, z):	2✔
234	await asyncio.sleep(0)	2✔
235	return x * y + x * z	2✔
236
237	await other_method(1, 2, 3)	2✔
238	await other_method(4, 5, 6)	2✔
239
240	async def test_does_same_as_function_async_and_sync(self):	2✔
241	def some_method(x, y, z):	2✔
242	return x * (y + z)	2✔
243
244	@does_same_as_function(some_method)	2✔
245	async def other_method(x, y, z):	2✔
246	await asyncio.sleep(0)	2✔
247	return x * y + x * z	2✔
248
249	await other_method(1, 2, 3)	2✔
250	await other_method(4, 5, 6)	2✔
251
252	async def test_does_same_as_function_wrong(self):	2✔
253	async def some_method(x, y, z):	2✔
254	await asyncio.sleep(0)	2✔
255	return x * (y + z)	2✔
256
257	@does_same_as_function(some_method)	2✔
258	async def other_method(x, y, z):	2✔
259	await asyncio.sleep(0)	2✔
260	return x * y + z	2✔
261
262	await other_method(0, 2, 0)	2✔
263
264	with self.assertRaises(expected_exception=AssertionError):	2✔
265	await other_method(4, 5, 6)	2✔
266
267	async def test_mock_async(self) -> None:	2✔
268	@mock(return_value=42)	2✔
269	async def my_function(a, b, c):	2✔
UNCOV 270	await asyncio.sleep(0)	×
UNCOV 271	return a + b + c	×
272
273	assert await my_function(1, 2, 3) == 42	2✔
274	assert await my_function(100, 200, 300) == 42	2✔
275
276	async def test_require_kwargs(self):	2✔
277	@require_kwargs	2✔
278	async def calc(n: int, m: int, i: int) -> int:	2✔
279	return n + m + i	2✔
280
281	await calc(n=1, m=2, i=3)	2✔
282
283	with self.assertRaises(expected_exception=PedanticCallWithArgsException):	2✔
284	await calc(1, m=2, i=3)	2✔

LostInDarkMath / pedantic-python-decorators / 10283439719

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous