← Back to branch summary

~ahasenack/landscape-client/landscape-client-1.5.5-0ubuntu0.9.04.0

« back to all changes in this revision

Viewing changes to landscape/user/tests/test_changes.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080908163557-l3ixzj5dxz37wnw2
Tags: 1.0.18-0ubuntu1
New upstream release 

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/user/tests/test_changes.py
 
1
from landscape.lib.persist import Persist
 
2
from landscape.user.changes import UserChanges
 
3
from landscape.user.tests.helpers import FakeUserInfo, FakeUserProvider
 
4
 
 
5
from landscape.tests.helpers import (LandscapeTest, MonitorHelper,
 
6
    MakePathHelper)
 
7
 
 
8
 
 
9
class UserChangesTest(LandscapeTest):
 
10
 
 
11
    helpers = [MonitorHelper, MakePathHelper]
 
12
 
 
13
    def setUp(self):
 
14
        super(UserChangesTest, self).setUp()
 
15
        self.persist = Persist()
 
16
        self.shadow_file = self.make_path("""\
 
17
jdoe:$1$xFlQvTqe$cBtrNEDOIKMy/BuJoUdeG0:13348:0:99999:7:::
 
18
psmith:!:13348:0:99999:7:::
 
19
sbarnes:$1$q7sz09uw$q.A3526M/SHu8vUb.Jo1A/:13349:0:99999:7:::
 
20
""")
 
21
 
 
22
    def test_no_existing_snapshot(self):
 
23
        """
 
24
        The diff created by L{UserChanges.create_diff} contains data
 
25
        for all users and groups if an existing snapshot isn't
 
26
        available.
 
27
        """
 
28
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
29
        groups = [("webdev", "x", 1000, ["jdoe"])]
 
30
        provider = FakeUserProvider(users=users, groups=groups)
 
31
        userinfo = FakeUserInfo(provider=provider)
 
32
 
 
33
        changes = UserChanges(self.persist, provider)
 
34
        self.assertEquals(changes.create_diff(),
 
35
                          {"create-users": [{"username": "jdoe",
 
36
                                             "home-phone": None,
 
37
                                             "name": u"JD",
 
38
                                             "enabled": True,
 
39
                                             "location": None,
 
40
                                             "work-phone": None,
 
41
                                             "uid": 1000,
 
42
                                             "primary-gid": 1000}],
 
43
                           "create-groups": [{"gid": 1000, "name": "webdev"}],
 
44
                           "create-group-members": {"webdev": ["jdoe"]}})
 
45
 
 
46
    def test_snapshot(self):
 
47
        """
 
48
        When a snapshot is taken it should persist beyond instance
 
49
        invocations and be used as the baseline in
 
50
        L{UserChanges.create_diff} until another snapshot is taken.
 
51
        """
 
52
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
53
        groups = [("webdev", "x", 1000, ["jdoe"])]
 
54
        provider = FakeUserProvider(users=users, groups=groups)
 
55
        userinfo = FakeUserInfo(provider=provider)
 
56
 
 
57
        changes1 = UserChanges(self.persist, provider)
 
58
        self.assertTrue(changes1.create_diff())
 
59
        changes1.snapshot()
 
60
        changes2 = UserChanges(self.persist, provider)
 
61
        self.assertFalse(changes2.create_diff())
 
62
 
 
63
    def test_snapshot_before_diff(self):
 
64
        """
 
65
        A valid snapshot should be created if L{UserChanges.snapshot}
 
66
        is called before L{UserChanges.create_diff}.  When
 
67
        L{UserChanges.create_diff} is called it shouln't report any
 
68
        changes.
 
69
        """
 
70
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
71
        groups = [("webdev", "x", 1000, ["jdoe"])]
 
72
        provider = FakeUserProvider(users=users, groups=groups)
 
73
        userinfo = FakeUserInfo(provider=provider)
 
74
        changes = UserChanges(self.persist, provider)
 
75
        changes.snapshot()
 
76
        self.assertFalse(changes.create_diff())
 
77
 
 
78
    def test_clear(self):
 
79
        """
 
80
        L{UserChanges.clear} removes a snapshot, if present, returning
 
81
        the object to a pristine state.
 
82
        """
 
83
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
84
        groups = [("webdev", "x", 1000, ["jdoe"])]
 
85
        provider = FakeUserProvider(users=users, groups=groups)
 
86
        userinfo = FakeUserInfo(provider=provider)
 
87
 
 
88
        changes = UserChanges(self.persist, provider)
 
89
        self.assertTrue(changes.create_diff())
 
90
        changes.snapshot()
 
91
        self.assertFalse(changes.create_diff())
 
92
        changes.clear()
 
93
        self.assertTrue(changes.create_diff())
 
94
 
 
95
    def test_create_diff_without_changes(self):
 
96
        """
 
97
        L{UserChanges.create_diff} should return an empty C{dict} if
 
98
        users and groups are unchanged since the last snapshot.
 
99
        """
 
100
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
101
        provider = FakeUserProvider(users=users)
 
102
        userinfo = FakeUserInfo(provider=provider)
 
103
 
 
104
        changes = UserChanges(self.persist, provider)
 
105
        changes.create_diff()
 
106
        changes.snapshot()
 
107
        self.assertEquals(changes.create_diff(), {})
 
108
 
 
109
    def test_add_user(self):
 
110
        """
 
111
        L{UserChanges.create_diff} should report new users created
 
112
        externally with C{adduser} or similar tools.
 
113
        """
 
114
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
115
        provider = FakeUserProvider(users=users)
 
116
        userinfo = FakeUserInfo(provider=provider)
 
117
 
 
118
        changes = UserChanges(self.persist, provider)
 
119
        changes.create_diff()
 
120
        changes.snapshot()
 
121
        users.append(("bo", "x", 1001, 1001, "Bo,,,,", "/home/bo", "/bin/sh"))
 
122
        self.assertEquals(changes.create_diff(),
 
123
                          {"create-users": [{"username": "bo",
 
124
                                             "home-phone": None,
 
125
                                             "name": u"Bo",
 
126
                                             "enabled": True,
 
127
                                             "location": None,
 
128
                                             "work-phone": None,
 
129
                                             "uid": 1001,
 
130
                                             "primary-gid": 1001}]})
 
131
 
 
132
    def test_update_user(self):
 
133
        """
 
134
        L{UserChanges.create_diff} should report users modified
 
135
        externally with C{usermod} or similar tools.
 
136
        """
 
137
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
138
        provider = FakeUserProvider(users=users)
 
139
        userinfo = FakeUserInfo(provider=provider)
 
140
        changes = UserChanges(self.persist, provider)
 
141
        changes.create_diff()
 
142
        changes.snapshot()
 
143
        users[0] = ("jdoe", "x", 1000, 1001, "John Doe,Here,789WORK,321HOME",
 
144
                    "/home/john", "/bin/zsh")
 
145
        self.assertEquals(changes.create_diff(),
 
146
                          {"update-users": [{"username": "jdoe",
 
147
                                             "home-phone": u"321HOME",
 
148
                                             "name": u"John Doe",
 
149
                                             "enabled": True,
 
150
                                             "location": "Here",
 
151
                                             "work-phone": "789WORK",
 
152
                                             "uid": 1000,
 
153
                                             "primary-gid": 1001}]})
 
154
 
 
155
    def test_delete_user(self):
 
156
        """
 
157
        L{UserChanges.create_diff} should report users removed
 
158
        externally with C{deluser} or similar tools.
 
159
        """
 
160
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh"),
 
161
                 ("bo", "x", 1001, 1001, "Bo,,,,", "/home/bo", "/bin/sh")]
 
162
        provider = FakeUserProvider(users=users)
 
163
        userinfo = FakeUserInfo(provider=provider)
 
164
 
 
165
        changes = UserChanges(self.persist, provider)
 
166
        changes.create_diff()
 
167
        changes.snapshot()
 
168
        users.pop()
 
169
        self.assertEquals(changes.create_diff(), {"delete-users": ["bo"]})
 
170
 
 
171
    def test_add_group(self):
 
172
        """
 
173
        L{UserChanges.create_diff} should report new groups created
 
174
        externally with C{addgroup} or similar tools.
 
175
        """
 
176
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
177
        groups = [("webdev", "x", 50, ["jdoe"])]
 
178
        provider = FakeUserProvider(users=users, groups=groups)
 
179
        userinfo = FakeUserInfo(provider=provider)
 
180
 
 
181
        changes = UserChanges(self.persist, provider)
 
182
        changes.create_diff()
 
183
        changes.snapshot()
 
184
        groups.append(("bizdev", "x", 60, []))
 
185
        self.assertEquals(changes.create_diff(),
 
186
                          {"create-groups": [{"gid": 60, "name": "bizdev"}]})
 
187
 
 
188
    def test_add_group_with_members(self):
 
189
        """
 
190
        L{UserChanges.create_diff} should report new groups and new
 
191
        members created externally with C{addgroup} or similar tools.
 
192
        """
 
193
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
194
        groups = [("webdev", "x", 50, ["jdoe"])]
 
195
        provider = FakeUserProvider(users=users, groups=groups)
 
196
        userinfo = FakeUserInfo(provider=provider)
 
197
 
 
198
        changes = UserChanges(self.persist, provider)
 
199
        changes.create_diff()
 
200
        changes.snapshot()
 
201
        groups.append(("bizdev", "x", 60, ["jdoe"]))
 
202
        self.assertEquals(changes.create_diff(),
 
203
                          {"create-groups": [{"gid": 60, "name": "bizdev"}],
 
204
                           "create-group-members": {"bizdev": ["jdoe"]}})
 
205
 
 
206
    def test_update_group(self):
 
207
        """
 
208
        L{UserChanges.create_diff} should report groups modified
 
209
        externally with C{groupmod} or similar tools.
 
210
        """
 
211
        groups = [("webdev", "x", 1000, [])]
 
212
        provider = FakeUserProvider(groups=groups)
 
213
        userinfo = FakeUserInfo(provider=provider)
 
214
 
 
215
        changes = UserChanges(self.persist, provider)
 
216
        changes.create_diff()
 
217
        changes.snapshot()
 
218
        groups[0] = ("webdev", "x", 1001, [])
 
219
        self.assertEquals(changes.create_diff(),
 
220
                          {"update-groups": [{"gid": 1001, "name": "webdev"}]})
 
221
 
 
222
    def test_add_group_members(self):
 
223
        """
 
224
        L{UserChanges.create_diff} should report new members added to
 
225
        groups externally with C{gpasswd} or similar tools.
 
226
        """
 
227
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh"),
 
228
                 ("bo", "x", 1001, 1001, "Bo,,,,", "/home/bo", "/bin/sh")]
 
229
        groups = [("webdev", "x", 50, ["jdoe"])]
 
230
        provider = FakeUserProvider(users=users, groups=groups)
 
231
        userinfo = FakeUserInfo(provider=provider)
 
232
 
 
233
        changes = UserChanges(self.persist, provider)
 
234
        changes.create_diff()
 
235
        changes.snapshot()
 
236
        groups[0] = ("webdev", "x", 50, ["jdoe", "bo"])
 
237
        self.assertEquals(changes.create_diff(),
 
238
                          {"create-group-members": {"webdev": ["bo"]}})
 
239
 
 
240
    def test_delete_group_members(self):
 
241
        """
 
242
        L{UserChanges.create_diff} should report members removed from
 
243
        groups externally with C{gpasswd} or similar tools.
 
244
        """
 
245
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
246
        groups = [("webdev", "x", 50, ["jdoe"])]
 
247
        provider = FakeUserProvider(users=users, groups=groups)
 
248
        userinfo = FakeUserInfo(provider=provider)
 
249
 
 
250
        changes = UserChanges(self.persist, provider)
 
251
        changes.create_diff()
 
252
        changes.snapshot()
 
253
        groups[0] = ("webdev", "x", 50, [])
 
254
        self.assertEquals(changes.create_diff(),
 
255
                          {"delete-group-members": {"webdev": ["jdoe"]}})
 
256
 
 
257
    def test_delete_group(self):
 
258
        """
 
259
        L{UserChanges.create_diff} should report groups removed
 
260
        externally with C{delgroup} or similar tools.
 
261
        """
 
262
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
 
263
        groups = [("webdev", "x", 50, ["jdoe"]), ("sales", "x", 60, [])]
 
264
        provider = FakeUserProvider(users=users, groups=groups)
 
265
        userinfo = FakeUserInfo(provider=provider)
 
266
 
 
267
        changes = UserChanges(self.persist, provider)
 
268
        changes.create_diff()
 
269
        changes.snapshot()
 
270
        groups.pop()
 
271
        self.assertEquals(changes.create_diff(), {"delete-groups": ["sales"]})
 
272
 
 
273
    def test_complex_changes(self):
 
274
        """
 
275
        L{UserChanges.create_diff} should be able to report multiple
 
276
        kinds of changes at the same time.
 
277
        """
 
278
        users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh"),
 
279
                 ("bo", "x", 1001, 1001, "Bo,,,,", "/home/bo", "/bin/sh")]
 
280
        groups = [("webdev", "x", 50, ["jdoe"]),
 
281
                  ("bizdev", "x", 60, ["bo"])]
 
282
        provider = FakeUserProvider(users=users, groups=groups)
 
283
        userinfo = FakeUserInfo(provider=provider)
 
284
        changes = UserChanges(self.persist, provider)
 
285
        changes.create_diff()
 
286
        changes.snapshot()
 
287
        # We remove the group "webdev", and create a new group
 
288
        # "developers", adding the user "bo" at the same time.
 
289
        groups[0] = ("developers", "x", 50, ["bo"])
 
290
        # Add a new group "sales" and a new group member, "bo"
 
291
        groups.append(("sales", "x", 70, ["bo"]))
 
292
        # Remove user "jdoe"
 
293
        users.pop(0)
 
294
        self.assertEquals(changes.create_diff(),
 
295
                          {"create-groups": [{"gid": 50, "name": "developers"},
 
296
                                             {"gid": 70, "name": "sales"}],
 
297
                           "delete-users": ["jdoe"],
 
298
                           "delete-groups": ["webdev"],
 
299
                           "create-group-members": {"developers": ["bo"],
 
300
                                                    "sales": ["bo"]}})