def test_get_users_duplicate_uids(self):
"""
Get users should return data for all users found on the system,
including users with duplicated uids.
"""
data = [("joe1", "x", 1000, 1000, "JD,,,,", "/home/joe1", "/bin/zsh"),
("joe2", "x", 1000, 1000, "JD,,,,", "/home/joe2", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"name": u"JD",
"uid": 1000,
"enabled": True,
"location": None,
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}, {
"username": "******",
"name": u"JD",
"uid": 1000,
"enabled": True,
"location": None,
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}])
def test_get_gid(self):
"""
Given a username L{UserProvider.get_gid} returns the GID or
raises a L{UserProviderError} if a match isn't found.
"""
provider = FakeUserProvider(groups=[("jdoe", "x", 1000, [])])
self.assertEqual(provider.get_gid("jdoe"), 1000)
self.assertRaises(GroupNotFoundError, provider.get_gid, "john")
def test_get_uid(self):
"""
Given a username L{UserProvider.get_uid} returns the UID or
raises a L{UserProviderError} if a match isn't found.
"""
data = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
self.assertEqual(provider.get_uid("jdoe"), 1000)
self.assertRaises(UserNotFoundError, provider.get_uid, "john")
def test_group_without_members(self):
"""
L{UserProvider.get_groups} should include groups without
members.
"""
provider = FakeUserProvider(groups=[("jdoe", "x", 1000, [])])
self.assertEqual(provider.get_groups(), [{
"name": "jdoe",
"gid": 1000,
"members": []
}])
def test_group_with_members(self):
"""L{UserProvider.get_groups} should include groups with members."""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
groups = [("sales", "x", 50, ["jdoe"])]
provider = FakeUserProvider(users=users,
shadow_file=self.shadow_file,
groups=groups)
self.assertEqual(provider.get_groups(), [{
"name": "sales",
"gid": 50,
"members": ["jdoe"]
}])
def test_user_not_in_shadow_file(self):
"""
Given a username that doesn't exist in the shadow file, we should get a
UserProvider error rather than a KeyError.
raises a L{UserProviderError} if a match isn't found.
"""
data = [("johndoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe",
"/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(len(users), 1)
self.assertEqual(sorted([x[0] for x in data]), ["johndoe"])
def test_group_with_unknown_members(self):
"""L{UserProvider.get_groups} should include groups with members.
If a member's userid isn't known to the system, it shouldn't be
returned.
"""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
groups = [("sales", "x", 50, ["jdoe", "kevin"])]
provider = FakeUserProvider(users=users,
shadow_file=self.shadow_file,
groups=groups)
self.assertEqual(provider.get_groups(), [{
"name": "sales",
"gid": 50,
"members": ["jdoe"]
}])
def test_add_user(self):
"""
L{UserChanges.create_diff} should report new users created
externally with C{adduser} or similar tools.
"""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
provider = FakeUserProvider(users=users)
FakeUserInfo(provider=provider)
changes = UserChanges(self.persist, provider)
changes.create_diff()
changes.snapshot()
users.append(("bo", "x", 1001, 1001, "Bo,,,,", "/home/bo", "/bin/sh"))
self.assertEqual(
changes.create_diff(), {
"create-users": [{
"username": "******",
"home-phone": None,
"name": u"Bo",
"enabled": True,
"location": None,
"work-phone": None,
"uid": 1001,
"primary-gid": 1001
}]
})
def test_update_user(self):
"""
L{UserChanges.create_diff} should report users modified
externally with C{usermod} or similar tools.
"""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
provider = FakeUserProvider(users=users)
FakeUserInfo(provider=provider)
changes = UserChanges(self.persist, provider)
changes.create_diff()
changes.snapshot()
users[0] = ("jdoe", "x", 1000, 1001, "John Doe,Here,789WORK,321HOME",
"/home/john", "/bin/zsh")
self.assertEqual(
changes.create_diff(), {
"update-users": [{
"username": "******",
"home-phone": u"321HOME",
"name": u"John Doe",
"enabled": True,
"location": "Here",
"work-phone": "789WORK",
"uid": 1000,
"primary-gid": 1001
}]
})
def test_no_existing_snapshot(self):
"""
The diff created by L{UserChanges.create_diff} contains data
for all users and groups if an existing snapshot isn't
available.
"""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
groups = [("webdev", "x", 1000, ["jdoe"])]
provider = FakeUserProvider(users=users, groups=groups)
FakeUserInfo(provider=provider)
changes = UserChanges(self.persist, provider)
self.assertEqual(
changes.create_diff(), {
"create-users": [{
"username": "******",
"home-phone": None,
"name": u"JD",
"enabled": True,
"location": None,
"work-phone": None,
"uid": 1000,
"primary-gid": 1000
}],
"create-groups": [{
"gid": 1000,
"name": "webdev"
}],
"create-group-members": {
"webdev": ["jdoe"]
}
})
def test_no_fetch_users_in_monitor_only_mode(self):
"""
If we're in monitor_only mode, then all users are assumed to be
unlocked.
"""
self.config.monitor_only = True
def got_result(result):
self.assertMessages(
self.broker_service.message_store.get_pending_messages(),
[{"create-group-members": {u"webdev": [u"jdoe"]},
"create-groups": [{"gid": 1000, "name": u"webdev"}],
"create-users": [{"enabled": True, "home-phone": None,
"location": None, "name": u"JD",
"primary-gid": 1000, "uid": 1000,
"username": u"jdoe", "work-phone": None}],
"type": "users"}])
plugin.stop()
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/sh")]
groups = [("webdev", "x", 1000, ["jdoe"])]
provider = FakeUserProvider(users=users, groups=groups)
plugin = UserMonitor(provider=provider)
plugin.register(self.monitor)
self.broker_service.message_store.set_accepted_types(["users"])
result = plugin.run()
result.addCallback(got_result)
return result
def test_four_gecos_fields(self):
"""If a GECOS field only has four fields it should still work."""
data = [("jdoe", "x", 1000, 1000, "JD,Everywhere,7654321,123HOME",
"/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"name": u"JD",
"uid": 1000,
"enabled": True,
"location": u"Everywhere",
"home-phone": u"123HOME",
"work-phone": u"7654321",
"primary-gid": 1000
}])
def test_remove_user_with_unknown_username(self):
"""
L{UserManagement.remove_user} should raise a
L{UserManagementError} if the user being removed doesn't exist.
"""
provider = FakeUserProvider(popen=MockPopen(""))
management = UserManagement(provider=provider)
self.assertRaises(UserNotFoundError, management.remove_user, "smith")
def test_add_group_handles_errors(self):
"""
If the system tool C{addgroup} returns a non-0 exit code,
L{UserManagement.add_group} should raise an L{UserManagementError}.
"""
provider = FakeUserProvider(popen=MockPopen("Error Result", [1]))
management = UserManagement(provider=provider)
self.assertRaises(UserManagementError, management.add_group, "kaboom")
def test_group_with_duplicate_members(self):
"""
L{UserProvider.get_groups} should only report groups once.
If duplicates exist they should be removed. The problem
reported in bug #118799 is related to duplicates being
reported to the server.
"""
users = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
groups = [("sales", "x", 50, ["jdoe", "jdoe"])]
provider = FakeUserProvider(users=users,
shadow_file=self.shadow_file,
groups=groups)
self.assertEqual(provider.get_groups(), [{
"name": "sales",
"gid": 50,
"members": ["jdoe"]
}])
def test_lock_user(self):
"""L{UserManagement.lock_user} should use C{usermod} to lock users."""
data = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file,
popen=MockPopen("no output"))
management = UserManagement(provider=provider)
management.lock_user("jdoe")
self.assertEqual(provider.popen.popen_inputs,
[["usermod", "-L", "jdoe"]])
def test_set_user_details_with_unknown_username(self):
"""
L{UserManagement.set_user_details} should raise a
L{UserManagementError} if the user being edited doesn't exist.
"""
provider = FakeUserProvider(popen=MockPopen(""))
management = UserManagement(provider=provider)
self.assertRaises(UserNotFoundError, management.set_user_details,
"kevin", name=u"John Doe")
def test_no_gecos_data(self):
"""
When no data is provided in the GECOS field we should report
all optional fields as C{None}.
"""
data = [("jdoe", "x", 1000, 1000, "", "/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"uid": 1000,
"enabled": True,
"name": None,
"location": None,
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}])
def test_get_disabled_user(self):
"""The C{enabled} field should be C{False} for disabled users."""
data = [("psmith", "x", 1000, 1000, "Peter Smith,,,,", "/home/psmith",
"/bin/bash")]
provider = FakeUserProvider(users=data,
shadow_file=self.shadow_file,
locked_users=["psmith"])
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"name": u"Peter Smith",
"uid": 1000,
"enabled": False,
"location": None,
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}])
def test_remove_group_with_unknown_groupname(self):
"""
L{UserManagement.remove_group} should raise a
L{GroupMissingError} if the group being removed doesn't exist.
"""
provider = FakeUserProvider(popen=MockPopen(""))
management = UserManagement(provider=provider)
self.assertRaises(
GroupNotFoundError, management.remove_group, "ubuntu")
def test_set_group_details_with_unknown_groupname(self):
"""
L{UserManagement.set_group_details} should raise a
L{UserManagementError} if the group being updated doesn't exist.
"""
provider = FakeUserProvider(popen=MockPopen(""))
management = UserManagement(provider=provider)
self.assertRaises(GroupNotFoundError, management.set_group_details,
"sales", u"newsales")
def test_unlock_user_fails(self):
"""
L{UserManagement.unlock_user} should raise an
L{UserManagementError} if a C{usermod} fails.
"""
data = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file,
popen=MockPopen("", [1]))
management = UserManagement(provider=provider)
self.assertRaises(UserNotFoundError, management.unlock_user, 1000)
def test_weird_gecos_data(self):
"""
If GECOS data is malformed in a way that contains less than
four fields, read as many as are available.
"""
data = [("jdoe", "x", 1000, 1000, "John Doe,Everywhere", "/home/jdoe",
"/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"uid": 1000,
"enabled": True,
"name": "John Doe",
"location": "Everywhere",
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}])
def test_add_user_error(self):
"""
L{UserManagement.add_user} should raise an L{UserManagementError} if
C{adduser} fails.
"""
provider = FakeUserProvider(popen=MockPopen("", return_codes=[1, 0]))
management = UserManagement(provider=provider)
self.assertRaises(UserManagementError, management.add_user,
"jdoe", u"John Doe", "password", False, None, None,
None, None)
def test_add_group(self):
"""
L{UserManagement.add_group} should use the system tool
C{addgroup} to create groups.
"""
provider = FakeUserProvider(popen=MockPopen("Result"))
management = UserManagement(provider=provider)
result = management.add_group("webdev")
self.assertEqual(provider.popen.popen_inputs, [["addgroup", "webdev"]])
self.assertEqual(result, "Result")
def test_gecos_data(self):
"""
Location, home phone number, and work phone number should be
correctly parsed out of the GECOS field, and included in the
users message.
"""
data = [("jdoe", "x", 1000, 1000, "JD,Everywhere,7654321,123HOME,",
"/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"name": u"JD",
"uid": 1000,
"enabled": True,
"location": u"Everywhere",
"home-phone": u"123HOME",
"work-phone": u"7654321",
"primary-gid": 1000
}])
def test_add_member_with_unknown_username(self):
"""
L{UserManagement.add_group_member} should raise a
L{UserManagementError} if the user being associated doesn't
exist.
"""
groups = [("bizdev", "x", 1001, [])]
provider = FakeUserProvider(groups=groups, popen=MockPopen(""))
management = UserManagement(provider=provider)
self.assertRaises(UserNotFoundError, management.add_group_member,
"bizdev", "smith")
def test_set_user_details_fails(self):
"""
L{UserManagement.set_user_details} should raise an
L{EditUserError} if C{chfn} fails.
"""
data = [("jdoe", "x", 1000, 1000, "JD,,,,", "/home/jdoe", "/bin/zsh")]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file,
popen=MockPopen("", return_codes=[1]))
management = UserManagement(provider=provider)
self.assertRaises(UserNotFoundError, management.set_user_details, 1000,
name="John Doe")
def test_expire_password_error(self):
"""
L{UserManagement.add_user} should raise an L{UserManagementError} if
C{passwd} fails.
"""
provider = FakeUserProvider(
popen=MockPopen("", return_codes=[0, 0, 1]))
management = UserManagement(provider=provider)
self.assertRaises(UserManagementError, management.add_user,
"jdoe", u"John Doe", "password", True, None, None,
None, None)
def test_old_school_gecos_data(self):
"""
If C{useradd} is used to add users to a system the GECOS field
will be written as a comment. The client must be resilient to
this situation.
"""
data = [("jdoe", "x", 1000, 1000, "John Doe", "/home/jdoe", "/bin/zsh")
]
provider = FakeUserProvider(users=data, shadow_file=self.shadow_file)
users = provider.get_users()
self.assertEqual(users, [{
"username": "******",
"uid": 1000,
"enabled": True,
"name": u"John Doe",
"location": None,
"home-phone": None,
"work-phone": None,
"primary-gid": 1000
}])
