tests.test_ext.VerboseValueConstantTestCase.test_group() - Code Metrics - Inspection of "Ensure code coverage is sent to Scrutinizer" - oblalex/candv - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 81bb9a...af753b )

by Oleksandr

created 2020-11-12 19:40 UTC

tests.test_ext.VerboseValueConstantTestCase.test_group() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines	32
Code Lines	28

Duplication

Lines	32
Ratio	100 %

Importance

Changes

Metric	Value
eloc	28
dl	32
loc	32
rs	9.208
c	0
b	0
f	0
cc	1
nop	1

import operator
import unittest

from collections.abc import Iterator

from datetime import date

from dataclasses import dataclass

from candv.core import Constants
from candv.core import SimpleConstant

from candv.exceptions import CandvValueNotFoundError

from candv.ext import VerboseConstant
from candv.ext import Values
from candv.ext import ValueConstant
from candv.ext import VerboseValueConstant


class VerboseConstantTestCase(unittest.TestCase):

  def test_no_args(self):

    class FOO(Constants):
      CONSTANT = VerboseConstant()

    self.assertEqual(FOO.CONSTANT.name, "CONSTANT")
    self.assertEqual(FOO.CONSTANT.full_name, "FOO.CONSTANT")
    self.assertIsNone(FOO.CONSTANT.verbose_name)
    self.assertIsNone(FOO.CONSTANT.help_text)

  def test_versose_name(self):
    constant = VerboseConstant(verbose_name="foo")
    self.assertEqual(constant.verbose_name, "foo")

  def test_help_text(self):
    constant = VerboseConstant(help_text="just test constant")
    self.assertEqual(constant.help_text, "just test constant")

  def test_all_args(self):

    class FOO(Constants):
      CONSTANT = VerboseConstant("foo", "just test constant")

    self.assertEqual(FOO.CONSTANT.name, "CONSTANT")
    self.assertEqual(FOO.CONSTANT.full_name, "FOO.CONSTANT")
    self.assertEqual(FOO.CONSTANT.verbose_name, "foo")
    self.assertEqual(FOO.CONSTANT.help_text, "just test constant")

  def test_to_primitive_no_args(self):

    class FOO(Constants):
      CONSTANT = VerboseConstant()

    self.assertEqual(
      FOO.CONSTANT.to_primitive(),
      {
        'name': "CONSTANT",
        'verbose_name': None,
        'help_text': None,
      }
    )

  def test_to_primitive_all_args(self):

    class FOO(Constants):
      CONSTANT = VerboseConstant("Constant", "A test constant")

    self.assertEqual(
      FOO.CONSTANT.to_primitive(),
      {
        'name': "CONSTANT",
        'verbose_name': "Constant",
        'help_text': "A test constant",
      }
    )

  def test_group(self):

    class FOO(Constants):
      A = SimpleConstant()
      B = VerboseConstant(
        verbose_name="Constant B",
        help_text="Just a group with verbose name"
      ).to_group(
        group_class=Constants,
        C=SimpleConstant(),
        D=SimpleConstant(),
      )

    self.assertEqual(FOO.B.verbose_name, "Constant B")
    self.assertEqual(FOO.B.help_text, "Just a group with verbose name")
    self.assertEqual(FOO.B.names(), ["C", "D", ])
    self.assertEqual(
      FOO.to_primitive(),
      {
        'name': "FOO",
        'items': [
          {'name': "A", },
          {
            'name': "B",
            'verbose_name': "Constant B",
            'help_text': "Just a group with verbose name",
            'items': [
              {'name': "C", },
              {'name': "D", },
            ],
          },
        ],
      },
    )


class ValuesTestCase(unittest.TestCase):

  def test_get_by_value(self):

    class FOO(Values):
      ONE = ValueConstant(1)
      TWO = ValueConstant(2)

    self.assertEqual(FOO.get_by_value(2), FOO.TWO)

  def test_get_by_value_missing(self):

    class FOO(Values):
      ONE = ValueConstant(1)

    with self.assertRaises(CandvValueNotFoundError) as cm:
      FOO.get_by_value(2)

    self.assertEqual(
      cm.exception.args[0],
      "constant with value \"2\" is not present in "
      "\"<constants container 'FOO'>\""
    )

  def test_get_by_value_with_duplicates(self):

    class FOO(Values):
      ONE = ValueConstant(1)
      TWO = ValueConstant(2)
      TWO_DUB = ValueConstant(1)

    self.assertEqual(FOO.get_by_value(2), FOO.TWO)

  def test_filter_by_value(self):

    class FOO(Values):
      ONE = ValueConstant(1)
      TWO = ValueConstant(2)
      ONE_DUB2 = ValueConstant(1)
      THREE = ValueConstant(3)
      ONE_DUB1 = ValueConstant(1)

    constants = FOO.filter_by_value(1)
    self.assertIsInstance(constants, list)
    self.assertEqual(
      list(map(operator.attrgetter("name"), constants)),
      [
        "ONE",
        "ONE_DUB2",
        "ONE_DUB1",
      ],
    )

  def test_values(self):

    class FOO(Values):
      ONE = ValueConstant(1)
      THREE = ValueConstant(3)
      TWO = ValueConstant(2)

    values = FOO.values()

    self.assertIsInstance(values, list)
    self.assertEqual(values, [1, 3, 2, ])

  def test_itervalues(self):

    class FOO(Values):
      ONE = ValueConstant(1)
      THREE = ValueConstant(3)
      TWO = ValueConstant(2)

    values = FOO.itervalues()

    self.assertIsInstance(values, Iterator)
    self.assertEqual(list(values), [1, 3, 2, ])

  def test_to_primitive_scalar(self):

    class FOO(Values):
      ONE = ValueConstant(1)

    self.assertEqual(
      FOO.ONE.to_primitive(),
      {
        'name': "ONE",
        'value': 1,
      },
    )

  def test_to_primitive_callable(self):

    class FOO(Values):
      ONE = ValueConstant(lambda: 1)

    self.assertEqual(
      FOO.ONE.to_primitive(),
      {
        'name': "ONE",
        'value': 1,
      },
    )

  def test_to_primitive_custom(self):

    @dataclass
    class Point2D:
      x: int
      y: int

      def to_primitive(self, context=None):
        return f"{self.x}:{self.y}"

    class FOO(Values):
      POS = ValueConstant(Point2D(10, 20))

    self.assertEqual(
      FOO.POS.to_primitive(),
      {
        'name': "POS",
        'value': "10:20",
      },
    )

  def test_to_primitive_date(self):

    class FOO(Values):
      DATE = ValueConstant(date(1999, 12, 31))

    self.assertEqual(
      FOO.DATE.to_primitive(),
      {
        'name': "DATE",
        'value': "1999-12-31",
      },
    )

  def test_group(self):

    class FOO(Constants):
      A = SimpleConstant()
      B = ValueConstant(10).to_group(
        group_class=Constants,
        C=SimpleConstant(),
        D=SimpleConstant(),
      )

    self.assertEqual(FOO.B.value, 10)
    self.assertEqual(FOO.B.names(), ["C", "D", ])
    self.assertEqual(
      FOO.to_primitive(),
      {
        'name': "FOO",
        'items': [
          {'name': "A", },
          {
            'name': "B",
            'value': 10,
            'items': [
              {'name': "C", },
              {'name': "D", },
            ],
          },
        ],
      },
    )


class VerboseValueConstantTestCase(unittest.TestCase):

  def test_group(self):

    class FOO(Constants):
      A = SimpleConstant()
      B = VerboseValueConstant(
        value=10,
        verbose_name="Constant B",
        help_text="A group with verbose name and value"
      ).to_group(
        group_class=Constants,
        C=SimpleConstant(),
        D=SimpleConstant(),
      )

    self.assertEqual(FOO.B.value, 10)
    self.assertEqual(FOO.B.verbose_name, "Constant B")
    self.assertEqual(FOO.B.help_text, "A group with verbose name and value")
    self.assertEqual(FOO.B.names(), ["C", "D", ])
    self.assertEqual(
      FOO.to_primitive(),
      {
        'name': "FOO",
        'items': [
          {'name': "A", },
          {
            'name': "B",
            'verbose_name': "Constant B",
            'help_text': "A group with verbose name and value",
            'value': 10,
            'items': [
                {'name': "C", },
                {'name': "D", },
            ],
          },
        ],
      },
    )


1			import operator
2			import unittest
3
4			from collections.abc import Iterator
5
6			from datetime import date
7
8			from dataclasses import dataclass
9
10			from candv.core import Constants
11			from candv.core import SimpleConstant
12
13			from candv.exceptions import CandvValueNotFoundError
14
15			from candv.ext import VerboseConstant
16			from candv.ext import Values
17			from candv.ext import ValueConstant
18			from candv.ext import VerboseValueConstant
19
20
21			class VerboseConstantTestCase(unittest.TestCase):
22
23			def test_no_args(self):
24
25			class FOO(Constants):
26			CONSTANT = VerboseConstant()
27
28			self.assertEqual(FOO.CONSTANT.name, "CONSTANT")
29			self.assertEqual(FOO.CONSTANT.full_name, "FOO.CONSTANT")
30			self.assertIsNone(FOO.CONSTANT.verbose_name)
31			self.assertIsNone(FOO.CONSTANT.help_text)
32
33			def test_versose_name(self):
34			constant = VerboseConstant(verbose_name="foo")
35			self.assertEqual(constant.verbose_name, "foo")
36
37			def test_help_text(self):
38			constant = VerboseConstant(help_text="just test constant")
39			self.assertEqual(constant.help_text, "just test constant")
40
41			def test_all_args(self):
42
43			class FOO(Constants):
44			CONSTANT = VerboseConstant("foo", "just test constant")
45
46			self.assertEqual(FOO.CONSTANT.name, "CONSTANT")
47			self.assertEqual(FOO.CONSTANT.full_name, "FOO.CONSTANT")
48			self.assertEqual(FOO.CONSTANT.verbose_name, "foo")
49			self.assertEqual(FOO.CONSTANT.help_text, "just test constant")
50
51			def test_to_primitive_no_args(self):
52
53			class FOO(Constants):
54			CONSTANT = VerboseConstant()
55
56			self.assertEqual(
57			FOO.CONSTANT.to_primitive(),
58			{
59			'name': "CONSTANT",
60			'verbose_name': None,
61			'help_text': None,
62			}
63			)
64
65			def test_to_primitive_all_args(self):
66
67			class FOO(Constants):
68			CONSTANT = VerboseConstant("Constant", "A test constant")
69
70			self.assertEqual(
71			FOO.CONSTANT.to_primitive(),
72			{
73			'name': "CONSTANT",
74			'verbose_name': "Constant",
75			'help_text': "A test constant",
76			}
77			)
78
79			def test_group(self):
80
81			class FOO(Constants):
82			A = SimpleConstant()
83			B = VerboseConstant(
84			verbose_name="Constant B",
85			help_text="Just a group with verbose name"
86			).to_group(
87			group_class=Constants,
88			C=SimpleConstant(),
89			D=SimpleConstant(),
90			)
91
92			self.assertEqual(FOO.B.verbose_name, "Constant B")
93			self.assertEqual(FOO.B.help_text, "Just a group with verbose name")
94			self.assertEqual(FOO.B.names(), ["C", "D", ])
95			self.assertEqual(
96			FOO.to_primitive(),
97			{
98			'name': "FOO",
99			'items': [
100			{'name': "A", },
101			{
102			'name': "B",
103			'verbose_name': "Constant B",
104			'help_text': "Just a group with verbose name",
105			'items': [
106			{'name': "C", },
107			{'name': "D", },
108			],
109			},
110			],
111			},
112			)
113
114
115			class ValuesTestCase(unittest.TestCase):
116
117			def test_get_by_value(self):
118
119			class FOO(Values):
120			ONE = ValueConstant(1)
121			TWO = ValueConstant(2)
122
123			self.assertEqual(FOO.get_by_value(2), FOO.TWO)
124
125			def test_get_by_value_missing(self):
126
127			class FOO(Values):
128			ONE = ValueConstant(1)
129
130			with self.assertRaises(CandvValueNotFoundError) as cm:
131			FOO.get_by_value(2)
132
133			self.assertEqual(
134			cm.exception.args[0],
135			"constant with value \"2\" is not present in "
136			"\"<constants container 'FOO'>\""
137			)
138
139			def test_get_by_value_with_duplicates(self):
140
141			class FOO(Values):
142			ONE = ValueConstant(1)
143			TWO = ValueConstant(2)
144			TWO_DUB = ValueConstant(1)
145
146			self.assertEqual(FOO.get_by_value(2), FOO.TWO)
147
148			def test_filter_by_value(self):
149
150			class FOO(Values):
151			ONE = ValueConstant(1)
152			TWO = ValueConstant(2)
153			ONE_DUB2 = ValueConstant(1)
154			THREE = ValueConstant(3)
155			ONE_DUB1 = ValueConstant(1)
156
157			constants = FOO.filter_by_value(1)
158			self.assertIsInstance(constants, list)
159			self.assertEqual(
160			list(map(operator.attrgetter("name"), constants)),
161			[
162			"ONE",
163			"ONE_DUB2",
164			"ONE_DUB1",
165			],
166			)
167
168			def test_values(self):
169
170			class FOO(Values):
171			ONE = ValueConstant(1)
172			THREE = ValueConstant(3)
173			TWO = ValueConstant(2)
174
175			values = FOO.values()
176
177			self.assertIsInstance(values, list)
178			self.assertEqual(values, [1, 3, 2, ])
179
180			def test_itervalues(self):
181
182			class FOO(Values):
183			ONE = ValueConstant(1)
184			THREE = ValueConstant(3)
185			TWO = ValueConstant(2)
186
187			values = FOO.itervalues()
188
189			self.assertIsInstance(values, Iterator)
190			self.assertEqual(list(values), [1, 3, 2, ])
191
192			def test_to_primitive_scalar(self):
193
194			class FOO(Values):
195			ONE = ValueConstant(1)
196
197			self.assertEqual(
198			FOO.ONE.to_primitive(),
199			{
200			'name': "ONE",
201			'value': 1,
202			},
203			)
204
205			def test_to_primitive_callable(self):
206
207			class FOO(Values):
208			ONE = ValueConstant(lambda: 1)
209
210			self.assertEqual(
211			FOO.ONE.to_primitive(),
212			{
213			'name': "ONE",
214			'value': 1,
215			},
216			)
217
218			def test_to_primitive_custom(self):
219
220			@dataclass
221			class Point2D:
222			x: int
223			y: int
224
225			def to_primitive(self, context=None):
226			return f"{self.x}:{self.y}"
227
228			class FOO(Values):
229			POS = ValueConstant(Point2D(10, 20))
230
231			self.assertEqual(
232			FOO.POS.to_primitive(),
233			{
234			'name': "POS",
235			'value': "10:20",
236			},
237			)
238
239			def test_to_primitive_date(self):
240
241			class FOO(Values):
242			DATE = ValueConstant(date(1999, 12, 31))
243
244			self.assertEqual(
245			FOO.DATE.to_primitive(),
246			{
247			'name': "DATE",
248			'value': "1999-12-31",
249			},
250			)
251
252			def test_group(self):
253
254			class FOO(Constants):
255			A = SimpleConstant()
256			B = ValueConstant(10).to_group(
257			group_class=Constants,
258			C=SimpleConstant(),
259			D=SimpleConstant(),
260			)
261
262			self.assertEqual(FOO.B.value, 10)
263			self.assertEqual(FOO.B.names(), ["C", "D", ])
264			self.assertEqual(
265			FOO.to_primitive(),
266			{
267			'name': "FOO",
268			'items': [
269			{'name': "A", },
270			{
271			'name': "B",
272			'value': 10,
273			'items': [
274			{'name': "C", },
275			{'name': "D", },
276			],
277			},
278			],
279			},
280			)
281
282
283			class VerboseValueConstantTestCase(unittest.TestCase):
284
285			def test_group(self):
286
287			class FOO(Constants):
288			A = SimpleConstant()
289			B = VerboseValueConstant(
290			value=10,
291			verbose_name="Constant B",
292			help_text="A group with verbose name and value"
293			).to_group(
294			group_class=Constants,
295			C=SimpleConstant(),
296			D=SimpleConstant(),
297			)
298
299			self.assertEqual(FOO.B.value, 10)
300			self.assertEqual(FOO.B.verbose_name, "Constant B")
301			self.assertEqual(FOO.B.help_text, "A group with verbose name and value")
302			self.assertEqual(FOO.B.names(), ["C", "D", ])
303			self.assertEqual(
304			FOO.to_primitive(),
305			{
306			'name': "FOO",
307			'items': [
308			{'name': "A", },
309			{
310			'name': "B",
311			'verbose_name': "Constant B",
312			'help_text': "A group with verbose name and value",
313			'value': 10,
314			'items': [
315			{'name': "C", },
316			{'name': "D", },
317			],
318			},
319			],
320			},
321			)
322

oblalex / candv

Push — master ( 81bb9a...af753b )

tests.test_ext.VerboseValueConstantTestCase.test_group() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like