def test_create_with_username_starting_with_numeric(self):
"""Successfully create a user with name starting with numeric chars"""
testuser = UserTracker(
name=u'1234user', givenname=u'First1234', sn=u'Surname1234',
)
testuser.create()
testuser.delete()
def test_create_with_uppercase_principal(self):
""" Create user with upper-case principal """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
krbprincipalname=u'tuser1'.upper()
)
testuser.create()
testuser.delete()
def test_add_user_with_singlevalue_addattr(self):
""" Try to add a user with single-value attribute
set via option and --addattr """
user = UserTracker(name=u'user', givenname=u'Test', sn=u'User1',
addattr=u'sn=User2')
command = user.make_create_command()
with raises_exact(errors.OnlyOneValueAllowed(attr='sn')):
command()
def test_create_with_full_address(self):
""" Create user with full address set """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
street=u'123 Maple Rd', l=u'Anytown', st=u'MD',
postalcode=u'01234-5678', mobile=u'410-555-1212'
)
testuser.create()
testuser.delete()
def user_radius(request):
""" User tracker fixture for testing users with radius user name """
tracker = UserTracker(name=u'radiususer', givenname=u'radiususer',
sn=u'radiususer1',
ipatokenradiususername=u'radiususer')
tracker.track_create()
tracker.attrs.update(
objectclass=objectclasses.user + [u'ipatokenradiusproxyuser']
)
return tracker.make_fixture(request)
def test_create_with_krb_ticket_policy(self):
""" Try to create user with krbmaxticketlife set """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test',
sn=u'Tuser1', setattr=u'krbmaxticketlife=88000'
)
command = testuser.make_create_command()
with raises_exact(errors.ObjectclassViolation(
info=u'attribute "%s" not allowed' % 'krbmaxticketlife')):
command()
def test_create_with_too_long_login(self):
""" Try to create user with too long login string """
testuser = UserTracker(
name=invaliduser2, givenname=u'Test', sn=u'User1'
)
command = testuser.make_create_command()
with raises_exact(errors.ValidationError(
name=u'login',
error=u'can be at most 255 characters')):
command()
def test_create_without_upg(self):
""" Try to create user without User's Primary GID """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
noprivate=True
)
command = testuser.make_create_command()
with raises_exact(errors.NotFound(
reason=u'Default group for new users is not POSIX')):
command()
def test_create_with_bad_realm_in_principal(self):
""" Try to create user with a bad realm in principal """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
krbprincipalname=u'*****@*****.**'
)
command = testuser.make_create_command()
with raises_exact(errors.RealmMismatch()):
command()
def test_add_user_coliding_with_alias(self, krbalias_user):
krbalias_user.ensure_exists()
user_alias = u'conflicting_name'
krbalias_user.add_principal([user_alias])
conflict_user = UserTracker(user_alias, u'test', u'conflict')
with pytest.raises(errors.DuplicateEntry):
conflict_user.create()
def test_create_with_numeric_only_username(self):
"""Try to create a user with name only contains numeric chars"""
testuser = UserTracker(
name=u'1234', givenname=u'NumFirst1234', sn=u'NumSurname1234',
)
with raises_exact(errors.ValidationError(
name=u'login',
error=u'may only include letters, numbers, _, -, . and $',
)):
testuser.create()
def test_create_with_invalid_login(self):
""" Try to create user with an invalid login string """
testuser = UserTracker(
name=invaliduser1, givenname=u'Test', sn=u'User1'
)
command = testuser.make_create_command()
with raises_exact(errors.ValidationError(
name=u'login',
error=u'may only include letters, numbers, _, -, . and $')):
command()
def test_create_with_malformed_principal(self):
""" Try to create user with wrongly formed principal """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
krbprincipalname=u'tuser1@[email protected]'
)
command = testuser.make_create_command()
with raises_exact(errors.MalformedUserPrincipal(
principal=u'tuser1@[email protected]')):
command()
def user_npg2(request, group):
""" User tracker fixture for testing users with no private group """
tracker = UserTracker(name=u'npguser2', givenname=u'Npguser',
sn=u'Npguser2', noprivate=True, gidnumber=1000)
tracker.track_create()
del tracker.attrs['mepmanagedentry']
tracker.attrs.update(
gidnumber=[u'1000'], description=[], memberof_group=[group.cn],
objectclass=add_oc(objectclasses.user_base, u'ipantuserattrs')
)
return tracker.make_fixture(request)
def test_create_with_malformed_principal(self):
""" Try to create user with wrongly formed principal """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
krbprincipalname=u'tuser1@[email protected]'
)
command = testuser.make_create_command()
with raises_exact(errors.ConversionError(
name='principal', error="Malformed principal: '{}'".format(
testuser.kwargs['krbprincipalname']))):
command()
def test_create_with_attr(self, stageduser2, user, user_activated):
""" Tests creating a user with various valid attributes listed
in 'options_ok' list"""
# create staged user with specified parameters
user.ensure_exists() # necessary for manager test
stageduser2.ensure_missing()
command = stageduser2.make_create_command()
result = command()
stageduser2.track_create()
stageduser2.check_create(result)
# activate user, verify that specified values were preserved
# after activation
user_activated.ensure_missing()
user_activated = UserTracker(
stageduser2.uid, stageduser2.givenname,
stageduser2.sn, **stageduser2.kwargs)
user_activated.create_from_staged(stageduser2)
command = stageduser2.make_activate_command()
result = command()
user_activated.check_activate(result)
# verify the staged user does not exist after activation
command = stageduser2.make_retrieve_command()
with raises_exact(errors.NotFound(
reason=u'%s: stage user not found' % stageduser2.uid)):
command()
user_activated.delete()
def test_create_with_ssh_pubkey(self):
""" Create user with an assigned SSH public key """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test',
sn=u'Tuser1', ipasshpubkey=sshpubkey
)
testuser.track_create()
# fingerprint is expected in the tracker attrs
testuser.attrs.update(sshpubkeyfp=[sshpubkeyfp])
command = testuser.make_create_command()
result = command()
testuser.check_create(result)
testuser.delete()
def test_create_with_uid_999(self):
""" Check that server return uid and gid 999
when a new client asks for uid 999 """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1', uidnumber=999
)
testuser.track_create()
testuser.attrs.update(
uidnumber=[u'999'],
gidnumber=[u'999']
)
command = testuser.make_create_command()
result = command()
testuser.check_create(result)
testuser.delete()
def test_create_with_old_DNA_MAGIC_999(self):
""" Check that server picks suitable uid and gid
when an old client asks for the magic uid 999 """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
uidnumber=999, version=u'2.49'
)
testuser.track_create()
testuser.attrs.update(
uidnumber=[lambda v: int(v) != 999],
gidnumber=[lambda v: int(v) != 999],
)
command = testuser.make_create_command()
result = command()
testuser.check_create(result)
testuser.delete()
def test_create_without_upg_with_gid_set(self):
""" Create user without User's Primary GID with GID set """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1',
noprivate=True, gidnumber=1000
)
testuser.track_create()
del testuser.attrs['mepmanagedentry']
testuser.attrs.update(gidnumber=[u'1000'])
testuser.attrs.update(
description=[],
objectclass=add_oc(objectclasses.user_base, u'ipantuserattrs')
)
command = testuser.make_create_command()
result = command()
testuser.check_create(result, [u'description'])
testuser.delete()
def test_create_with_random_passwd(self):
""" Create user with random password """
testuser = UserTracker(
name=u'tuser1', givenname=u'Test', sn=u'Tuser1', random=True
)
testuser.track_create()
testuser.attrs.update(
randompassword=fuzzy_password,
has_keytab=True, has_password=True,
krbextradata=[Fuzzy(type=bytes)],
krbpasswordexpiration=[fuzzy_dergeneralizedtime],
krblastpwdchange=[fuzzy_dergeneralizedtime]
)
command = testuser.make_create_command()
result = command()
testuser.check_create(result)
testuser.delete()
def test_activate(self, stageduser3, user2):
stageduser3.ensure_exists()
user2.ensure_missing()
user2 = UserTracker(
stageduser3.uid, stageduser3.givenname, stageduser3.sn)
user2.create_from_staged(stageduser3)
command = stageduser3.make_activate_command()
result = command()
user2.check_activate(result)
command = stageduser3.make_retrieve_command()
with raises_exact(errors.NotFound(
reason=u'%s: stage user not found' % stageduser3.uid)):
command()
user2.delete()
def admin2(request, xmlrpc_setup):
tracker = UserTracker(name=u'admin2', givenname=u'Second', sn=u'Admin')
return tracker.make_fixture(request)
def user_min(request, xmlrpc_setup):
""" User tracker fixture for testing user with uid no specified """
tracker = UserTracker(givenname=u'Testmin', sn=u'Usermin')
return tracker.make_fixture(request)
def user(request, xmlrpc_setup):
tracker = UserTracker(name=u'user1', givenname=u'Test', sn=u'User1')
return tracker.make_fixture(request)
def certmap_user(request):
user = UserTracker(CERTMAP_USER, u'certmap', u'user')
return user.make_fixture(request)
def user7(request, xmlrpc_setup):
tracker = UserTracker(u'puser1', u'preserved', u'user')
return tracker.make_fixture_restore(request)
def user_activated(request):
tracker = UserTracker(u'suser2', u'staged', u'user')
return tracker.make_fixture(request)
def user3(request, xmlrpc_setup):
tracker = UserTracker(u'auser2', u'active', u'user')
return tracker.make_fixture(request)
def user5(request, xmlrpc_setup):
tracker = UserTracker(u'tuser', u'test', u'user')
return tracker.make_fixture(request)
def user6(request, xmlrpc_setup):
tracker = UserTracker(u'suser2', u'staged', u'user')
return tracker.make_fixture(request)
def user2(request):
tracker = UserTracker(name=u'user2', givenname=u'Test2', sn=u'User2')
return tracker.make_fixture(request)
def manager1(request):
""" User tracker used as a manager account """
tracker = UserTracker(name=u'mscott', sn=u'Manager1',
givenname=u'Automember test manager user1')
return tracker.make_fixture(request)
def user5(request):
tracker = UserTracker(u'tuser', u'test', u'user')
return tracker.make_fixture(request)
def user7(request):
tracker = UserTracker(u'puser1', u'preserved', u'user')
return tracker.make_fixture_restore(request)
def user4(request):
tracker = UserTracker(name=u"tuser4", givenname=u"Test4", sn=u"User4")
return tracker.make_fixture(request)
def renameduser(request, xmlrpc_setup):
tracker = UserTracker(name=u'ruser1', givenname=u'Ruser', sn=u'Ruser1')
return tracker.make_fixture(request)
def manager1(request, xmlrpc_setup):
""" User tracker used as a manager account """
tracker = UserTracker(name=u'mscott',
sn=u'Manager1',
givenname=u'Automember test manager user1')
return tracker.make_fixture(request)
def certmap_user(request):
user = UserTracker(CERTMAP_USER, u'certmap', u'user')
return user.make_fixture(request)
def test_stageduser_customattr(self, stageduser_customattr):
# Create a staged user with attributes not accessible
# through the options
# --setattr is needed here
command = stageduser_customattr.make_create_command()
result = command()
stageduser_customattr.check_create(result, [u'businesscategory'])
# Activate the staged user
user_customattr = UserTracker(stageduser_customattr.uid,
stageduser_customattr.givenname,
stageduser_customattr.sn)
user_customattr.create_from_staged(stageduser_customattr)
user_customattr.attrs[u'businesscategory'] = [u'BusinessCat']
command = stageduser_customattr.make_activate_command()
result = command()
user_customattr.check_activate(result)
# Check that the user contains businesscategory
command = user_customattr.make_retrieve_command(all=True)
result = command()
assert 'BusinessCat' in result['result'][u'businesscategory']
# delete the user with --preserve
command = user_customattr.make_delete_command(no_preserve=False,
preserve=True)
result = command()
user_customattr.check_delete(result)
# Check that the preserved user contains businesscategory
command = user_customattr.make_retrieve_command(all=True)
result = command()
assert 'BusinessCat' in result['result'][u'businesscategory']
# Move the user from preserved to stage
command = user_customattr.make_stage_command()
result = command()
stageduser_customattr.check_restore_preserved(result)
# Check that the stage user contains businesscategory
command = stageduser_customattr.make_retrieve_command(all=True)
result = command()
assert 'BusinessCat' in result['result'][u'businesscategory']
def krb_user(request):
tracker = UserTracker(u'krb_user', u'krb', u'test_user')
return tracker.make_fixture(request)
def user1(request):
tracker = UserTracker(name=u'tuser1', givenname=u'Test1', sn=u'User1')
return tracker.make_fixture(request)
def user1(request, manager1):
""" User tracker with assigned manager """
tracker = UserTracker(name=u'tuser1', sn=u'User1', manager=manager1.name,
givenname=u'Automember test user1')
return tracker.make_fixture(request)
def krbalias_user_c(request):
tracker = UserTracker(u'krbalias_user_conflict', u'krbalias', u'test')
return tracker.make_fixture(request)
