tests.utils.SentinelTestCase

Complexity

Total Complexity

13

Size/Duplication

Total Lines	46
Duplicated Lines	0 %

11 Methods

Rating	Name	Duplication	Size	Complexity
A	tearDown()	0	2	1
A	test_name()	0	2	1
A	test_doc()	0	2	1
A	test_doc_differentiates()	0	8	2
A	test_weakreferencable()	0	2	1
A	test_pickle_roundtrip()	0	3	1
A	test_repr()	0	4	1
A	test_new()	0	3	2
A	test_memo()	0	2	1
A	test_copy()	0	3	1
A	test_deepcopy()	0	3	1

from copy import copy, deepcopy
from pickle import loads, dumps
from unittest import TestCase
from weakref import ref

from zipline.utils.sentinel import sentinel


class SentinelTestCase(TestCase):
    def tearDown(self):
        sentinel._cache.clear()  # don't pollute cache.

    def test_name(self):
        self.assertEqual(sentinel('a').__name__, 'a')

    def test_doc(self):
        self.assertEqual(sentinel('a', 'b').__doc__, 'b')

    def test_doc_differentiates(self):
        a = sentinel('sentinel-name', 'original-doc')
        with self.assertRaises(ValueError) as e:
            sentinel(a.__name__, 'new-doc')

        msg = str(e.exception)
        self.assertIn(a.__name__, msg)
        self.assertIn(a.__doc__, msg)

    def test_memo(self):
        self.assertIs(sentinel('a'), sentinel('a'))

    def test_copy(self):
        a = sentinel('a')
        self.assertIs(copy(a), a)

    def test_deepcopy(self):
        a = sentinel('a')
        self.assertIs(deepcopy(a), a)

    def test_repr(self):
        self.assertEqual(
            repr(sentinel('a')),
            "sentinel('a')",
        )

    def test_new(self):
        with self.assertRaises(TypeError):
            type(sentinel('a'))()

    def test_pickle_roundtrip(self):
        a = sentinel('a')
        self.assertIs(loads(dumps(a)), a)

    def test_weakreferencable(self):
        ref(sentinel('a'))