Revision 0f383dcc kamaki/cli/utils/test.py

b/kamaki/cli/utils/test.py
33 33

  
34 34
from unittest import TestCase
35 35
#from tempfile import NamedTemporaryFile
36
#from mock import patch, call
36
from mock import patch, call
37 37
from itertools import product
38 38

  
39 39

  
......
63 63
            else:
64 64
                self.assertRaises(AssertionError, guess_mime_type, *args)
65 65

  
66
    def test_pretty_keys(self):
67
        from kamaki.cli.utils import pretty_keys
68
        for args, exp in (
69
                (
70
                    ({'k1': 'v1', 'k1_k2': 'v2'}, ),
71
                    {'k1': 'v1', 'k1 k2': 'v2'}),
72
                (
73
                    ({'k1': 'v1', 'k1_k2': 'v2'}, '1'),
74
                    {'k': 'v1', 'k _k2': 'v2'}),
75
                (
76
                    ({'k1_k2': 'v1', 'k1': {'k2': 'v2', 'k2_k3': 'v3'}}, ),
77
                    {'k1 k2': 'v1', 'k1': {'k2': 'v2', 'k2_k3': 'v3'}}),
78
                (
79
                    (
80
                        {'k1_k2': 'v1', 'k1': {'k2': 'v2', 'k2_k3': 'v3'}},
81
                        '_',
82
                        True),
83
                    {'k1 k2': 'v1', 'k1': {'k2': 'v2', 'k2 k3': 'v3'}}),
66
    @patch('kamaki.cli.utils.dumps', return_value='(dumps output)')
67
    @patch('kamaki.cli.utils._print')
68
    def test_print_json(self, PR, JD):
69
        from kamaki.cli.utils import print_json, INDENT_TAB
70
        print_json('some data')
71
        JD.assert_called_once_with('some data', indent=INDENT_TAB)
72
        PR.assert_called_once_with('(dumps output)')
73

  
74
    @patch('kamaki.cli.utils._print')
75
    def test_print_dict(self, PR):
76
        from kamaki.cli.utils import print_dict, INDENT_TAB
77
        call_counter = 0
78
        self.assertRaises(AssertionError, print_dict, 'non-dict think')
79
        self.assertRaises(AssertionError, print_dict, {}, indent=-10)
80
        for args in product(
84 81
                (
85
                    (
86
                        {
87
                            'k1_k2': {'k_1': 'v_1', 'k_2': {'k_3': 'v_3'}},
88
                            'k1': {'k2': 'v2', 'k2_k3': 'v3'}},
89
                        '_',
90
                        True),
82
                    {'k1': 'v1'},
83
                    {'k1': 'v1', 'k2': 'v2'},
84
                    {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'},
85
                    {'k1': 'v1', 'k2': {'k1': 'v1', 'k2': 'v2'}, 'k3': 'v3'},
91 86
                    {
92
                        'k1 k2': {'k 1': 'v_1', 'k 2': {'k 3': 'v_3'}},
93
                        'k1': {'k2': 'v2', 'k2 k3': 'v3'}}),
94
                (
95
                    (
96
                        {
97
                            'k1_k2': {'k_1': 'v_1', 'k_2': {'k_3': 'v_3'}},
98
                            'k1': {'k2': 'v2', 'k2_k3': 'v3'}},
99
                        '1',
100
                        True),
87
                        'k1': {'k1': 'v1', 'k2': 'v2'},
88
                        'k2': [1, 2, 3],
89
                        'k3': 'v3'},
90
                    {
91
                        'k1': {'k1': 'v1', 'k2': 'v2'},
92
                        'k2': 42,
93
                        'k3': {'k1': 1, 'k2': [1, 2, 3]}},
101 94
                    {
102
                        'k _k2': {'k_': 'v_1', 'k_2': {'k_3': 'v_3'}},
103
                        'k': {'k2': 'v2', 'k2_k3': 'v3'}})
104
            ):
105
            initial = dict(args[0])
106
            self.assert_dicts_are_equal(pretty_keys(*args), exp)
107
            self.assert_dicts_are_equal(initial, args[0])
95
                        'k1': {
96
                            'k1': 'v1',
97
                            'k2': [1, 2, 3],
98
                            'k3': {'k1': [(1, 2)]}},
99
                        'k2': (3, 4, 5),
100
                        'k3': {'k1': 1, 'k2': [1, 2, 3]}}),
101
                (tuple(), ('k1', ), ('k1', 'k2')),
102
                (0, 1, 2, 9), (False, True), (False, True)):
103
            d, exclude, indent, with_enumeration, recursive_enumeration = args
104
            with patch('kamaki.cli.utils.print_dict') as PD:
105
                with patch('kamaki.cli.utils.print_list') as PL:
106
                    pd_calls, pl_calls = 0, 0
107
                    print_dict(*args)
108
                    exp_calls = []
109
                    for i, (k, v) in enumerate(d.items()):
110
                        if k in exclude:
111
                            continue
112
                        str_k = ' ' * indent
113
                        str_k += '%s.' % (i + 1) if with_enumeration else ''
114
                        str_k += '%s:' % k
115
                        if isinstance(v, dict):
116
                            self.assertEqual(
117
                                PD.mock_calls[pd_calls],
118
                                call(
119
                                    v,
120
                                    exclude,
121
                                    indent + INDENT_TAB,
122
                                    recursive_enumeration,
123
                                    recursive_enumeration))
124
                            pd_calls += 1
125
                            exp_calls.append(call(str_k))
126
                        elif isinstance(v, list) or isinstance(v, tuple):
127
                            self.assertEqual(
128
                                PL.mock_calls[pl_calls],
129
                                call(
130
                                    v,
131
                                    exclude,
132
                                    indent + INDENT_TAB,
133
                                    recursive_enumeration,
134
                                    recursive_enumeration))
135
                            pl_calls += 1
136
                            exp_calls.append(call(str_k))
137
                        else:
138
                            exp_calls.append(call('%s %s' % (str_k, v)))
139
                    real_calls = PR.mock_calls[call_counter:]
140
                    call_counter = len(PR.mock_calls)
141
                    self.assertEqual(sorted(real_calls), sorted(exp_calls))
142

  
143
    @patch('kamaki.cli.utils._print')
144
    def test_print_list(self, PR):
145
        from kamaki.cli.utils import print_list, INDENT_TAB
146
        call_counter = 0
147
        self.assertRaises(AssertionError, print_list, 'non-list non-tuple')
148
        self.assertRaises(AssertionError, print_list, {}, indent=-10)
149
        for args in product(
150
                (
151
                    ['v1', ],
152
                    ('v2', 'v3'),
153
                    [1, '2', 'v3'],
154
                    ({'k1': 'v1'}, 2, 'v3'),
155
                    [(1, 2), 'v2', [(3, 4), {'k3': [5, 6], 'k4': 7}]]),
156
                (tuple(), ('v1', ), ('v1', 1), ('v1', 'k3')),
157
                (0, 1, 2, 9), (False, True), (False, True)):
158
            l, exclude, indent, with_enumeration, recursive_enumeration = args
159
            with patch('kamaki.cli.utils.print_dict') as PD:
160
                with patch('kamaki.cli.utils.print_list') as PL:
161
                    pd_calls, pl_calls = 0, 0
162
                    print_list(*args)
163
                    exp_calls = []
164
                    for i, v in enumerate(l):
165
                        str_v = ' ' * indent
166
                        str_v += '%s.' % (i + 1) if with_enumeration else ''
167
                        if isinstance(v, dict):
168
                            if with_enumeration:
169
                                exp_calls.append(call(str_v))
170
                            elif i and i < len(l):
171
                                exp_calls.append(call())
172
                            self.assertEqual(
173
                                PD.mock_calls[pd_calls],
174
                                call(
175
                                    v,
176
                                    exclude,
177
                                    indent + (
178
                                        INDENT_TAB if with_enumeration else 0),
179
                                    recursive_enumeration,
180
                                    recursive_enumeration))
181
                            pd_calls += 1
182
                        elif isinstance(v, list) or isinstance(v, tuple):
183
                            if with_enumeration:
184
                                exp_calls.append(call(str_v))
185
                            elif i and i < len(l):
186
                                exp_calls.append(call())
187
                            self.assertEqual(
188
                                PL.mock_calls[pl_calls],
189
                                call(
190
                                    v,
191
                                    exclude,
192
                                    indent + INDENT_TAB,
193
                                    recursive_enumeration,
194
                                    recursive_enumeration))
195
                            pl_calls += 1
196
                        elif ('%s' % v) in exclude:
197
                            continue
198
                        else:
199
                            exp_calls.append(call('%s%s' % (str_v, v)))
200
                    real_calls = PR.mock_calls[call_counter:]
201
                    call_counter = len(PR.mock_calls)
202
                    self.assertEqual(sorted(real_calls), sorted(exp_calls))
108 203

  
109 204

  
110 205
if __name__ == '__main__':

Also available in: Unified diff