smart-getenv/tests.py at master · Va1/smart-getenv · 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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
import os
import unittest
from smart_getenv import getenv


class GetenvTests(unittest.TestCase):
    """
    Tests for getenv.
    """

    test_var_name = '__ENV_UTILS_TEST_VAR'

    def setUp(self):
        self.delete_test_var()

    def tearDown(self):
        self.delete_test_var()

    def delete_test_var(self):
        """
        Delete test environment variable.
        """
        if self.test_var_name in os.environ.keys():
            del os.environ[self.test_var_name]

    def test_getenv_default(self):
        """
        If environment variable does not exist:
            ensure getenv returns None if default value is not specified,
            ensure getenv returns default value if it is specified,
            ensure getenv does not cast default value to desired type.
        """
        self.assertEqual(getenv(self.test_var_name), None)
        self.assertEqual(getenv(self.test_var_name, default='default string value'), 'default string value')
        self.assertEqual(getenv(self.test_var_name, type=int, default='default string value'), 'default string value')

    def test_getenv_type_str(self):
        """
        Ensure getenv returns string if environment variable exists and desired type is string.
        """
        os.environ[self.test_var_name] = 'abc'
        self.assertEqual(getenv(self.test_var_name, type=str), 'abc')

    def test_getenv_type_int(self):
        """
        If environment variable exists and desired type is int:
            ensure getenv returns int,
            ensure getenv excepts if value can not be casted to int.
        """
        os.environ[self.test_var_name] = '123'
        self.assertEqual(getenv(self.test_var_name, type=int), 123)

        os.environ[self.test_var_name] = 'absolutely not an int'
        try:
            getenv(self.test_var_name, type=int)
            self.fail('Calling getenv_int on a environment variable with'
                      ' non-castable to int value should fail with exception!')
        except ValueError:
            pass

    def test_getenv_type_float(self):
        """
        If environment variable exists and desired type is float:
            ensure getenv returns float,
            ensure getenv excepts if value can not be casted to float.
        """
        os.environ[self.test_var_name] = '123.4'
        self.assertEqual(getenv(self.test_var_name, type=float), 123.4)

        os.environ[self.test_var_name] = 'absolutely not a float'
        try:
            getenv(self.test_var_name, type=float)
            self.fail('Calling getenv_int on a environment variable with'
                      ' non-castable to float value should fail with exception!')
        except ValueError:
            pass

    def test_getenv_type_bool(self):
        """
        If environment variable exists and desired type is bool, ensure getenv returns bool.
        """
        os.environ[self.test_var_name] = 'true'
        self.assertEqual(getenv(self.test_var_name, type=bool), True)

        os.environ[self.test_var_name] = 'True'
        self.assertEqual(getenv(self.test_var_name, type=bool), True)

        os.environ[self.test_var_name] = '1'
        self.assertEqual(getenv(self.test_var_name, type=bool), True)

        os.environ[self.test_var_name] = 'absolutely not a boolean'
        self.assertEqual(getenv(self.test_var_name, type=bool), True)

        os.environ[self.test_var_name] = ' '
        self.assertEqual(getenv(self.test_var_name, type=bool), True)

        os.environ[self.test_var_name] = 'false'
        self.assertEqual(getenv(self.test_var_name, type=bool), False)

        os.environ[self.test_var_name] = 'False'
        self.assertEqual(getenv(self.test_var_name, type=bool), False)

        os.environ[self.test_var_name] = '0'
        self.assertEqual(getenv(self.test_var_name, type=bool), False)

        os.environ[self.test_var_name] = ''
        self.assertEqual(getenv(self.test_var_name, type=bool), False)

    def test_getenv_type_list(self):
        """
        If environment variable exists and desired type is list:
            ensure getenv returns list,
            ensure getenv default separator is ',',
            ensure getenv supports custom separator.
        """
        os.environ[self.test_var_name] = 'abc'
        self.assertEqual(getenv(self.test_var_name, type=list), ['abc'])

        os.environ[self.test_var_name] = 'a,b,c'
        self.assertEqual(getenv(self.test_var_name, type=list), ['a', 'b', 'c'])

        os.environ[self.test_var_name] = ',a,b,c,'
        self.assertEqual(getenv(self.test_var_name, type=list, separator=','), ['', 'a', 'b', 'c', ''])

        os.environ[self.test_var_name] = 'a:b:c'
        self.assertEqual(getenv(self.test_var_name, type=list, separator=':'), ['a', 'b', 'c'])

    def test_getenv_type_tuple(self):
        """
        If environment variable exists and desired type is tuple:
            ensure getenv returns tuple,
            ensure getenv default separator is ',',
            ensure getenv supports custom separator.
        """
        os.environ[self.test_var_name] = 'abc'
        self.assertEqual(getenv(self.test_var_name, type=tuple), ('abc',))

        os.environ[self.test_var_name] = 'a,b,c'
        self.assertEqual(getenv(self.test_var_name, type=tuple), ('a', 'b', 'c'))

        os.environ[self.test_var_name] = ',a,b,c,'
        self.assertEqual(getenv(self.test_var_name, type=tuple, separator=','), ('', 'a', 'b', 'c', ''))

        os.environ[self.test_var_name] = 'a:b:c'
        self.assertEqual(getenv(self.test_var_name, type=tuple, separator=':'), ('a', 'b', 'c'))

    def test_getenv_type_dict(self):
        """
        If environment variable exists and desired type is dict:
            ensure getenv returns dict,
            ensure getenv supports custom separator.
        """
        os.environ[self.test_var_name] = '{"key": "value"}'
        self.assertEqual(getenv(self.test_var_name, type=dict), {'key': 'value'})

        os.environ[self.test_var_name] = '{    "key":    "value"      }'
        self.assertEqual(getenv(self.test_var_name, type=dict), {'key': 'value'})

        os.environ[self.test_var_name] = '{    "key":    "value"      }'
        self.assertEqual(getenv(self.test_var_name, type=dict), {'key': 'value'})

        os.environ[self.test_var_name] = 'absolutely not a dict'
        try:
            getenv(self.test_var_name, type=dict)
            self.fail('Calling getenv with desired type of dict on a environment variable with'
                      ' non-castable to dict value should fail with exception!')
        except TypeError:
            pass
        except SyntaxError:
            pass


if __name__ == '__main__':
    unittest.main()