needs/test_needs.py at master · astex/needs · GitHub

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
"""A module to test the behavior of the Need class."""

try:
    import unittest2 as unittest
except ImportError:
    import unittest

from needs import Need, no_need, needs


__all__ = ['TestNeed']


class TestNeed(unittest.TestCase):
    """Tests Need."""
    def setUp(self):
        self.need = Need()

    def test_need(self):
        assert self.need
        assert no_need

    def test_invert_need(self):
        assert not ~self.need

    def test_cast_need(self):
        """Tests instantiating a need with a boolean."""
        assert not Need(False)

    def test_or_need(self):
        assert self.need | self.need
        assert ~self.need | self.need
        assert self.need | ~self.need
        assert not ~self.need | ~self.need

    def test_and_need(self):
        assert self.need & self.need
        assert not ~self.need & self.need
        assert not self.need & ~self.need
        assert not ~self.need & ~self.need

    def test_xor_need(self):
        assert not self.need ^ self.need
        assert ~self.need ^ self.need
        assert self.need ^ ~self.need
        assert not ~self.need & ~self.need

    def test_decorator(self):
        """Tests the need as a decorator."""
        unmet_need = ~no_need
        @unmet_need
        def should_not_execute():
            raise ValueError()

        try:
            should_not_execute()
        except Exception as e:
            assert not isinstance(e, ValueError)

    def test_needs(self):
        """Tests the @needs decorator."""
        @needs(~no_need)
        def should_not_execute():
            raise ValueError()

        try:
            should_not_execute()
        except Exception as e:
            assert not isinstance(e, ValueError)


class TestNeedErrors(unittest.TestCase):
    """Tests the error inheritence of Need."""
    def setUp(self):
        class Err(Exception):
            pass
        self.Err = Err

        class UnMetNeed(Need):
            error = Err()
        self.unmet_need = UnMetNeed(False)

    def test_and_errors(self):
        try:
            with no_need & self.unmet_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

        try:
            with self.unmet_need & no_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

        try:
            with self.unmet_need & ~no_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

    def test_or_errors(self):
        try:
            with ~no_need | self.unmet_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

    def test_xor_errors(self):
        try:
            with ~self.unmet_need ^ no_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

        try:
            with ~no_need ^ self.unmet_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

    def test_combination_errors(self):
        try:
            with (self.unmet_need & no_need) & no_need:
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error

        try:
            with (self.unmet_need & no_need) | (self.unmet_need & no_need):
                raise AssertionError
        except self.Err as e:
            assert e == self.unmet_need.error