← Back to branch summary

~ubuntu-branches/ubuntu/quantal/cloud-init/quantal

« back to all changes in this revision

Viewing changes to tests/unittests/test_distros/test_user_data_normalize.py

  • Committer: Package Import Robot
  • Author(s): Scott Moser
  • Date: 2012-09-30 14:29:04 UTC
  • Revision ID: package-import@ubuntu.com-20120930142904-nq8fkve62i0xytqz
https://launchpad.net/bugs/1002155
https://launchpad.net/bugs/1055688
https://launchpad.net/bugs/978127
* add CloudStack to DataSources listed by dpkg-reconfigure (LP: #1002155)
* New upstream snapshot.
  * 0440 permissions on /etc/sudoers.d files rather than 0644
  * get host ssh keys to the console (LP: #1055688)
  * MAAS DataSource adjust timestamp in oauth header to one based on the
    timestamp in the response of a 403.  This accounts for a bad local
    clock. (LP: #978127)
  * re-start the salt daemon rather than start to ensure config changes
    are taken.
  * allow for python unicode types in yaml that is loaded.
  * cleanup in how config modules get at users and groups.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/unittests/test_distros/test_user_data_normalize.py
 
1
from mocker import MockerTestCase
 
2
 
 
3
from cloudinit import distros
 
4
from cloudinit import helpers
 
5
from cloudinit import settings
 
6
 
 
7
 
 
8
class TestUGNormalize(MockerTestCase):
 
9
 
 
10
    def _make_distro(self, dtype, def_user=None, def_groups=None):
 
11
        cfg = dict(settings.CFG_BUILTIN)
 
12
        cfg['system_info']['distro'] = dtype
 
13
        paths = helpers.Paths(cfg['system_info']['paths'])
 
14
        distro_cls = distros.fetch(dtype)
 
15
        distro = distro_cls(dtype, cfg['system_info'], paths)
 
16
        if def_user:
 
17
            distro.default_user = def_user
 
18
        if def_groups:
 
19
            distro.default_user_groups = def_groups
 
20
        return distro
 
21
 
 
22
    def _norm(self, cfg, distro):
 
23
        return distros.normalize_users_groups(cfg, distro)
 
24
 
 
25
    def test_basic_groups(self):
 
26
        distro = self._make_distro('ubuntu')
 
27
        ug_cfg = {
 
28
            'groups': ['bob'],
 
29
        }
 
30
        (users, groups) = self._norm(ug_cfg, distro)
 
31
        self.assertIn('bob', groups)
 
32
        self.assertEquals({}, users)
 
33
 
 
34
    def test_csv_groups(self):
 
35
        distro = self._make_distro('ubuntu')
 
36
        ug_cfg = {
 
37
            'groups': 'bob,joe,steve',
 
38
        }
 
39
        (users, groups) = self._norm(ug_cfg, distro)
 
40
        self.assertIn('bob', groups)
 
41
        self.assertIn('joe', groups)
 
42
        self.assertIn('steve', groups)
 
43
        self.assertEquals({}, users)
 
44
 
 
45
    def test_more_groups(self):
 
46
        distro = self._make_distro('ubuntu')
 
47
        ug_cfg = {
 
48
            'groups': ['bob', 'joe', 'steve']
 
49
        }
 
50
        (users, groups) = self._norm(ug_cfg, distro)
 
51
        self.assertIn('bob', groups)
 
52
        self.assertIn('joe', groups)
 
53
        self.assertIn('steve', groups)
 
54
        self.assertEquals({}, users)
 
55
 
 
56
    def test_member_groups(self):
 
57
        distro = self._make_distro('ubuntu')
 
58
        ug_cfg = {
 
59
            'groups': {
 
60
                'bob': ['s'],
 
61
                'joe': [],
 
62
                'steve': [],
 
63
            }
 
64
        }
 
65
        (users, groups) = self._norm(ug_cfg, distro)
 
66
        self.assertIn('bob', groups)
 
67
        self.assertEquals(['s'], groups['bob'])
 
68
        self.assertEquals([], groups['joe'])
 
69
        self.assertIn('joe', groups)
 
70
        self.assertIn('steve', groups)
 
71
        self.assertEquals({}, users)
 
72
 
 
73
    def test_users_simple_dict(self):
 
74
        distro = self._make_distro('ubuntu', 'bob')
 
75
        ug_cfg = {
 
76
            'users': {
 
77
                'default': True,
 
78
            }
 
79
        }
 
80
        (users, _groups) = self._norm(ug_cfg, distro)
 
81
        self.assertIn('bob', users)
 
82
        ug_cfg = {
 
83
            'users': {
 
84
                'default': 'yes',
 
85
            }
 
86
        }
 
87
        (users, _groups) = self._norm(ug_cfg, distro)
 
88
        self.assertIn('bob', users)
 
89
        ug_cfg = {
 
90
            'users': {
 
91
                'default': '1',
 
92
            }
 
93
        }
 
94
        (users, _groups) = self._norm(ug_cfg, distro)
 
95
        self.assertIn('bob', users)
 
96
 
 
97
    def test_users_simple_dict_no(self):
 
98
        distro = self._make_distro('ubuntu', 'bob')
 
99
        ug_cfg = {
 
100
            'users': {
 
101
                'default': False,
 
102
            }
 
103
        }
 
104
        (users, _groups) = self._norm(ug_cfg, distro)
 
105
        self.assertEquals({}, users)
 
106
        ug_cfg = {
 
107
            'users': {
 
108
                'default': 'no',
 
109
            }
 
110
        }
 
111
        (users, _groups) = self._norm(ug_cfg, distro)
 
112
        self.assertEquals({}, users)
 
113
 
 
114
    def test_users_simple_csv(self):
 
115
        distro = self._make_distro('ubuntu')
 
116
        ug_cfg = {
 
117
            'users': 'joe,bob',
 
118
        }
 
119
        (users, _groups) = self._norm(ug_cfg, distro)
 
120
        self.assertIn('joe', users)
 
121
        self.assertIn('bob', users)
 
122
        self.assertEquals({'default': False}, users['joe'])
 
123
        self.assertEquals({'default': False}, users['bob'])
 
124
 
 
125
    def test_users_simple(self):
 
126
        distro = self._make_distro('ubuntu')
 
127
        ug_cfg = {
 
128
            'users': [
 
129
                'joe',
 
130
                'bob'
 
131
            ],
 
132
        }
 
133
        (users, _groups) = self._norm(ug_cfg, distro)
 
134
        self.assertIn('joe', users)
 
135
        self.assertIn('bob', users)
 
136
        self.assertEquals({'default': False}, users['joe'])
 
137
        self.assertEquals({'default': False}, users['bob'])
 
138
 
 
139
    def test_users_old_user(self):
 
140
        distro = self._make_distro('ubuntu', 'bob')
 
141
        ug_cfg = {
 
142
            'user': 'zetta',
 
143
            'users': 'default'
 
144
        }
 
145
        (users, _groups) = self._norm(ug_cfg, distro)
 
146
        self.assertIn('bob', users)
 
147
        self.assertIn('zetta', users)
 
148
        self.assertNotIn('default', users)
 
149
        ug_cfg = {
 
150
            'user': 'zetta',
 
151
            'users': 'default, joe'
 
152
        }
 
153
        (users, _groups) = self._norm(ug_cfg, distro)
 
154
        self.assertIn('bob', users)
 
155
        self.assertIn('joe', users)
 
156
        self.assertIn('zetta', users)
 
157
        self.assertNotIn('default', users)
 
158
        ug_cfg = {
 
159
            'user': 'zetta',
 
160
            'users': ['bob', 'joe']
 
161
        }
 
162
        (users, _groups) = self._norm(ug_cfg, distro)
 
163
        self.assertNotIn('bob', users)
 
164
        self.assertIn('joe', users)
 
165
        self.assertIn('zetta', users)
 
166
        ug_cfg = {
 
167
            'user': 'zetta',
 
168
            'users': {
 
169
                'bob': True,
 
170
                'joe': True,
 
171
            }
 
172
        }
 
173
        (users, _groups) = self._norm(ug_cfg, distro)
 
174
        self.assertIn('bob', users)
 
175
        self.assertIn('joe', users)
 
176
        self.assertIn('zetta', users)
 
177
        ug_cfg = {
 
178
            'user': 'zetta',
 
179
        }
 
180
        (users, _groups) = self._norm(ug_cfg, distro)
 
181
        self.assertIn('zetta', users)
 
182
        ug_cfg = {}
 
183
        (users, groups) = self._norm(ug_cfg, distro)
 
184
        self.assertEquals({}, users)
 
185
        self.assertEquals({}, groups)
 
186
 
 
187
    def test_users_dict_default_additional(self):
 
188
        distro = self._make_distro('ubuntu', 'bob')
 
189
        ug_cfg = {
 
190
            'users': [
 
191
                {'name': 'default', 'blah': True}
 
192
            ],
 
193
        }
 
194
        (users, _groups) = self._norm(ug_cfg, distro)
 
195
        self.assertIn('bob', users)
 
196
        self.assertEquals(",".join(distro.get_default_user()['groups']),
 
197
                          users['bob']['groups'])
 
198
        self.assertEquals(True,
 
199
                          users['bob']['blah'])
 
200
        self.assertEquals(True,
 
201
                          users['bob']['default'])
 
202
 
 
203
    def test_users_dict_extract(self):
 
204
        distro = self._make_distro('ubuntu', 'bob')
 
205
        ug_cfg = {
 
206
            'users': [
 
207
                'default',
 
208
            ],
 
209
        }
 
210
        (users, _groups) = self._norm(ug_cfg, distro)
 
211
        self.assertIn('bob', users)
 
212
        (name, config) = distros.extract_default(users)
 
213
        self.assertEquals(name, 'bob')
 
214
        expected_config = {}
 
215
        def_config = None
 
216
        try:
 
217
            def_config = distro.get_default_user()
 
218
        except NotImplementedError:
 
219
            pass
 
220
        if not def_config:
 
221
            def_config = {}
 
222
        expected_config.update(def_config)
 
223
 
 
224
        # Ignore these for now
 
225
        expected_config.pop('name', None)
 
226
        expected_config.pop('groups', None)
 
227
        config.pop('groups', None)
 
228
        self.assertEquals(config, expected_config)
 
229
 
 
230
    def test_users_dict_default(self):
 
231
        distro = self._make_distro('ubuntu', 'bob')
 
232
        ug_cfg = {
 
233
            'users': [
 
234
                'default',
 
235
            ],
 
236
        }
 
237
        (users, _groups) = self._norm(ug_cfg, distro)
 
238
        self.assertIn('bob', users)
 
239
        self.assertEquals(",".join(distro.get_default_user()['groups']),
 
240
                          users['bob']['groups'])
 
241
        self.assertEquals(True,
 
242
                          users['bob']['default'])
 
243
 
 
244
    def test_users_dict_trans(self):
 
245
        distro = self._make_distro('ubuntu')
 
246
        ug_cfg = {
 
247
            'users': [
 
248
                {'name': 'joe',
 
249
                 'tr-me': True},
 
250
                {'name': 'bob'},
 
251
            ],
 
252
        }
 
253
        (users, _groups) = self._norm(ug_cfg, distro)
 
254
        self.assertIn('joe', users)
 
255
        self.assertIn('bob', users)
 
256
        self.assertEquals({'tr_me': True, 'default': False}, users['joe'])
 
257
        self.assertEquals({'default': False}, users['bob'])
 
258
 
 
259
    def test_users_dict(self):
 
260
        distro = self._make_distro('ubuntu')
 
261
        ug_cfg = {
 
262
            'users': [
 
263
                {'name': 'joe'},
 
264
                {'name': 'bob'},
 
265
            ],
 
266
        }
 
267
        (users, _groups) = self._norm(ug_cfg, distro)
 
268
        self.assertIn('joe', users)
 
269
        self.assertIn('bob', users)
 
270
        self.assertEquals({'default': False}, users['joe'])
 
271
        self.assertEquals({'default': False}, users['bob'])