def test_set_password(self):
self.create_user(username1, password1)
frm = username1 if six.PY3 else username1.encode('utf-8')
with capture() as (stdout, stderr):
restauth_user(['set-password', '--password', password2, frm])
self.assertFalse(user_backend.check_password(username1, password1))
self.assertTrue(user_backend.check_password(username1, password2))
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
# test with generated password
with capture() as (stdout, stderr):
restauth_user(['set-password', '--gen-password', frm])
stdout, stderr = self.decode(stdout, stderr)
self.assertFalse(user_backend.check_password(username1, password1))
self.assertFalse(user_backend.check_password(username1, password2))
self.assertTrue(user_backend.check_password(username1, stdout.strip()))
# invalid password
with capture() as (stdout, stderr):
restauth_user(['set-password', '--password', 'a', frm])
self.assertFalse(user_backend.check_password(username1, password1))
self.assertFalse(user_backend.check_password(username1, password2))
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
def test_add_invalid(self):
# test an invalid resource (that is, with a slash)
username = '******'
with capture() as (stdout, stderr):
try:
restauth_user(['add', '--password', password1, username])
self.fail('restauth-user allows invalid characters')
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertTrue(stderr.getvalue().startswith('usage: '))
self.assertItemsEqual(user_backend.list(), [])
self.assertRaises(UserNotFound, user_backend.check_password, username, password1)
# load a custom validator:
load_username_validators(('Users.validators.MediaWikiValidator', ))
username = '******'
with capture() as (stdout, stderr):
try:
restauth_user(['add', '--password', password1, username])
self.fail('restauth-user allows invalid characters')
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertTrue(stderr.getvalue().startswith('usage: '))
self.assertItemsEqual(user_backend.list(), [])
self.assertRaises(UserNotFound, user_backend.check_password, username, password1)
load_username_validators()
def test_rename(self):
self.create_user(username1, password1)
frm = username1 if six.PY3 else username1.encode('utf-8')
to = username2 if six.PY3 else username2.encode('utf-8')
with capture() as (stdout, stderr):
restauth_user(['rename', frm, to])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
with capture() as (stdout, stderr):
try:
restauth_user(['rename', 'foo', 'bar'])
self.fail('Renaming inexistent user succeeded.')
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertTrue(stderr.getvalue().startswith('usage: '))
self.create_user(username3, password1)
frm = username3 if six.PY3 else username3.encode('utf-8')
with capture() as (stdout, stderr):
try:
restauth_user(['rename', frm, to])
self.fail('Renaming user to existing username succeeded.')
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertTrue(stderr.getvalue().startswith('usage: '))
def test_verify(self):
self.create_user(username1, password1)
frm = username1 if six.PY3 else username1.encode('utf-8')
with capture() as (stdout, stderr):
restauth_user(['verify', '--password', password1, frm,])
self.assertEqual(stdout.getvalue(), 'Ok.\n')
self.assertEqual(stderr.getvalue(), '')
with capture() as (stdout, stderr):
try:
restauth_user(['verify', '--password', password2, frm,])
except SystemExit as e:
self.assertEqual(e.code, 1)
self.assertEqual(stdout.getvalue(), 'Failed.\n')
self.assertEqual(stderr.getvalue(), '')
def test_add_hosts(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['add-hosts', servicename5, '127.0.0.1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertCountEqual(s.hosts.values_list('address', flat=True), ['127.0.0.1'])
# test if second add doesn't overwrite the first host
with capture() as (stdout, stderr):
cli(['add-hosts', servicename5, '::1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertCountEqual(s.hosts.values_list('address', flat=True), ['127.0.0.1', '::1'])
def test_existing_groups(self):
backend.create_user(username1)
backend.create_user(username2)
backend.create_user(username3)
backend.create_user(username4) # new user
# this group already exists and has some memberships
backend.create_group(group=groupname2, service=self.service)
backend.add_member(group=groupname2, service=self.service, user=username1)
backend.add_member(group=groupname2, service=self.service, user=username4)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(
stdout, '^\* %s: Already exists, adding memberships\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# test memberships
self.assertCountEqual(backend.members(group=groupname1, service=None), [])
self.assertCountEqual(backend.members(group=groupname2, service=self.service),
[username1, username2, username4])
if backend.SUPPORTS_SUBGROUPS is True:
self.assertCountEqual(backend.members(group=groupname3, service=self.service),
[username1, username2, username3, username4])
self.assertCountEqual(backend.members(group=groupname4, service=None),
[username1, username2, username4])
else:
self.assertCountEqual(backend.members(group=groupname3, service=self.service),
[username3])
self.assertCountEqual(backend.members(group=groupname4, service=None), [])
def test_skip_existing_groups(self):
# same test-setup as above, only we skip existing groups
backend.create_user(username1)
backend.create_user(username2)
backend.create_user(username3)
backend.create_user(username4) # new user
# this group already exists and has some memberships
backend.create_group(group=groupname2, service=self.service)
backend.add_member(group=groupname2, service=self.service, user=username1)
backend.add_member(group=groupname2, service=self.service, user=username4)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
try:
restauth_import(['--skip-existing-groups', path])
except SystemExit:
self.fail(stderr.getvalue())
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(stdout, '^\* %s: Already exists, skipping\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# test memberships
self.assertCountEqual(backend.members(group=groupname1, service=None), [])
self.assertCountEqual(backend.members(group=groupname2, service=self.service),
[username1, username4])
# group3 now is not a subgroup, because group2 already existed and we skipped its data
self.assertEqual(backend.members(group=groupname3, service=self.service), [username3])
self.assertEqual(backend.members(group=groupname4, service=None), [])
def test_basic(self):
with capture() as (stdout, stderr):
try:
restauth_import(['-h'])
self.fail('-h does not exit')
except SystemExit as e:
self.assertEqual(e.code, 0)
def test_existing_properties(self):
backend.create_user(username2)
backend.create_property(user=username2, key=propkey1, value=propval3) # propval1 -> json
backend.create_property(user=username2, key="date joined", value=propval3)
path = os.path.join(self.base, 'users1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertCountEqual(backend.list_users(), [username1, username2, username3])
pattern = '^%s: Property "%s" already exists\.$' % (username2, propkey1)
self.assertHasLine(stdout, pattern)
self.assertHasLine(stdout, '^%s: Property "date joined" already exists\.$' % username2)
expected_props = {
propkey1: propval3, # propva1 is in json-file - we don't overwrite!
propkey2: propval2,
u'last login': u'2013-12-01 19:27:44', # date from json file
}
props = backend.get_properties(user=username2)
# delete 'date joined' prop because it was created by the backend and
# restauth-import doesn't overwrite in this invocation:
del props['date joined']
self.assertEqual(props, expected_props)
def test_existing_properties(self):
user = user_backend.create(username2, property_backend=property_backend)
property_backend.create(user, propkey1, propval3) # propval1 is in json file
path = os.path.join(self.base, 'users1.json')
with capture() as (stdout, stderr):
cmd = [path]
restauth_import(cmd)
self.assertItemsEqual(user_backend.list(), [username1, username2, username3])
user = user_backend.get(username2)
pattern = '^%s: Property "%s" already exists\.$' % (username2, propkey1)
self.assertHasLine(stdout, pattern)
self.assertHasLine(stdout, '^%s: Property "date joined" already exists\.$' % username2)
expected_props = {
propkey1: propval3, # propva1 is in json-file - we don't overwrite!
propkey2: propval2,
u'last login': u'2013-12-01 19:27:44', # date from json file
}
props = property_backend.list(user)
# delete 'date joined' prop because it was created by the user_backend and
# restauth-import doesn't overwrite in this invocation:
del props['date joined']
self.assertEqual(props, expected_props)
def test_groups(self):
user1 = user_backend.create(username1, property_backend=property_backend)
user2 = user_backend.create(username2, property_backend=property_backend)
user3 = user_backend.create(username3, property_backend=property_backend)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# get groups from backend
group1 = group_backend.get(groupname1)
group2 = group_backend.get(groupname2, service=self.service)
group3 = group_backend.get(groupname3, service=self.service)
group4 = group_backend.get(groupname4)
# test memberships
self.assertItemsEqual(group_backend.members(group1), [])
self.assertItemsEqual(group_backend.members(group2), [username1, username2])
self.assertItemsEqual(group_backend.members(group3), [username1, username2, username3])
self.assertItemsEqual(group_backend.members(group4), [username1, username2])
def test_existing_groups(self):
user1 = user_backend.create(username1, property_backend=property_backend)
user2 = user_backend.create(username2, property_backend=property_backend)
user3 = user_backend.create(username3, property_backend=property_backend)
user4 = user_backend.create(username4, property_backend=property_backend) # new user
# this group already exists and has some memberships
group2 = group_backend.create(groupname2, service=self.service)
group_backend.add_user(group2, user1)
group_backend.add_user(group2, user4)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(stdout, '^\* %s: Already exists, adding memberships\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# get groups from backend
group1 = group_backend.get(groupname1)
group3 = group_backend.get(groupname3, service=self.service)
group4 = group_backend.get(groupname4)
# test memberships
self.assertItemsEqual(group_backend.members(group1), [])
self.assertItemsEqual(group_backend.members(group2), [username1, username2, username4])
self.assertItemsEqual(group_backend.members(group3), [username1, username2, username3,
username4])
self.assertItemsEqual(group_backend.members(group4), [username1, username2, username4])
def test_skip_existing_groups(self):
# same test-setup as above, only we skip existing groups
user1 = user_backend.create(username1, property_backend=property_backend)
user2 = user_backend.create(username2, property_backend=property_backend)
user3 = user_backend.create(username3, property_backend=property_backend)
user4 = user_backend.create(username4, property_backend=property_backend) # new user
# this group already exists and has some memberships
group2 = group_backend.create(groupname2, service=self.service)
group_backend.add_user(group2, user1)
group_backend.add_user(group2, user4)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
try:
restauth_import(['--skip-existing-groups', path])
except SystemExit:
self.fail(stderr.getvalue())
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(stdout, '^\* %s: Already exists, skipping\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# get groups from backend
group1 = group_backend.get(groupname1)
group3 = group_backend.get(groupname3, service=self.service)
group4 = group_backend.get(groupname4)
# test memberships
self.assertItemsEqual(group_backend.members(group1), [])
self.assertItemsEqual(group_backend.members(group2), [username1, username4])
# group3 now is not a subgroup, because group2 already existed and we skipped its data
self.assertEqual(group_backend.members(group3), [username3])
self.assertEqual(group_backend.members(group4), [])
def test_add_gen_password(self):
with capture() as (stdout, stderr):
cli(['add', '--gen-password', servicename4])
self.assertEqual(stderr.getvalue(), '')
password = stdout.getvalue().strip()
self.assertTrue(len(password) > 12)
self.assertTrue(Service.objects.get(username=servicename4).check_password(password))
def test_ls(self):
with capture() as (stdout, stderr):
cli(['ls'])
hosts = ', '.join(self.service.addresses)
self.assertEqual(stdout.getvalue(),
'%s: %s\n' % (self.service.name, hosts))
self.assertEqual(stderr.getvalue(), '')
def test_empty(self):
for i in range(1, 6):
path = os.path.join(self.base, 'empty%s.json' % i)
with capture() as (stdout, stderr):
restauth_import([path])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
def test_basic(self):
with capture() as (stdout, stderr):
try:
restauth_import(['-h'])
self.fail('-h does not exit')
except SystemExit as e:
self.assertEqual(e.code, 0)
def test_groups(self):
backend.create_user(username1)
backend.create_user(username2)
backend.create_user(username3)
path = os.path.join(self.base, 'groups1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Groups:$')
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname1)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname2)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname3)
self.assertHasLine(stdout, '^\* %s: created\.$' % groupname4)
# test memberships
self.assertCountEqual(backend.members(group=groupname1, service=None), [])
self.assertCountEqual(backend.members(group=groupname2, service=self.service),
[username1, username2])
if backend.SUPPORTS_SUBGROUPS is True:
self.assertCountEqual(backend.members(group=groupname3, service=self.service),
[username1, username2, username3])
self.assertCountEqual(backend.members(group=groupname4, service=None),
[username1, username2])
else:
self.assertCountEqual(backend.members(group=groupname3, service=self.service),
[username3])
self.assertCountEqual(backend.members(group=groupname4, service=None), [])
def test_add_hosts(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['add-hosts', servicename5, '127.0.0.1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertItemsEqual(s.hosts.values_list('address', flat=True),
['127.0.0.1'])
# test if second add doesn't overwrite the first host
with capture() as (stdout, stderr):
cli(['add-hosts', servicename5, '::1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertItemsEqual(s.hosts.values_list('address', flat=True),
['127.0.0.1', '::1'])
def test_rm(self):
self.create_user(username1, password1)
frm = username1 if six.PY3 else username1.encode('utf-8')
with capture() as (stdout, stderr):
restauth_user(['rm', frm])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertEqual(user_backend.list(), [])
def test_add(self):
with capture() as (stdout, stderr):
cli(['add', '--password=foobar', servicename4])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(
Service.objects.get(
username=servicename4).check_password('foobar'))
def test_skip_existing_users(self):
user = user_backend.create(username2, property_backend=property_backend,
properties={propkey1: propval3, })
path = os.path.join(self.base, 'users1.json')
with capture() as (stdout, stderr):
restauth_import(['--skip-existing-users', path])
self.assertProperties(user, {propkey1: propval3, })
def test_rm(self):
Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['rm', servicename5])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertFalse(Service.objects.filter(username=servicename5).exists())
def test_ls(self):
with capture() as (stdout, stderr):
cli(['ls'])
hosts = ', '.join(self.service.addresses)
hosts2 = ', '.join(self.service2.addresses)
self.assertHasLine(stdout, '%s: %s' % (self.service.name, hosts))
self.assertHasLine(stdout, '%s: %s' % (self.service2.name, hosts2))
self.assertEqual(stderr.getvalue(), '')
def test_set_password(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-password', servicename5, '--password', password1])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(Service.objects.get(username=s.name).check_password(password1))
def test_gen_passwords(self):
path = os.path.join(self.base, 'users3.json')
with capture() as (stdout, stderr):
restauth_import(['--gen-passwords', path])
output = stdout.getvalue()
self.assertHasLine(output, '^\* %s: Generated password: .*' % username1)
password = re.search('Generated password: (.*)', output).groups()[0]
self.assertTrue(backend.check_password(user=username1, password=password))
def test_gen_passwords(self):
path = os.path.join(self.base, 'users3.json')
with capture() as (stdout, stderr):
restauth_import(['--gen-passwords', path])
output = stdout.getvalue()
self.assertHasLine(output, '^\* %s: Generated password: .*' % username1)
password = re.search('Generated password: (.*)', output).groups()[0]
self.assertTrue(user_backend.check_password(username1, password))
def test_skip_existing_users(self):
backend.create_user(username2)
backend.set_property(user=username2, key=propkey1, value=propval3)
backend.set_property(user=username2, key="date joined", value=propval3)
path = os.path.join(self.base, 'users1.json')
with capture() as (stdout, stderr):
restauth_import(['--skip-existing-users', path])
self.assertProperties(username2, {propkey1: propval3, })
def test_rm_permissions(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-permissions', servicename5, 'props_list', 'groups_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
# remove perm again
with capture() as (stdout, stderr):
cli(['rm-permissions', servicename5, 'props_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertFalse(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
def test_view(self):
self.maxDiff = None
with capture() as (stdout, stderr):
cli(['view', self.service.name])
self.assertEqual(stdout.getvalue(), """Last used: %s
Hosts: %s
Permissions: %s
""" % (self.service.last_login, ', '.join(self.service.addresses), ', '.join(self.service.permissions)))
self.assertEqual(stderr.getvalue(), '')
def test_set_password(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-password', servicename5, '--password', password1])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(
Service.objects.get(username=s.name).check_password(password1))
def test_add_permissions(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['add-permissions', servicename5, 'users_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.users_list'))
with capture() as (stdout, stderr):
cli(['add-permissions', servicename5, 'props_list', 'groups_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
self.assertTrue(s.has_perm('Users.users_list'))
def test_add_gen_password(self):
with capture() as (stdout, stderr):
cli(['add', '--gen-password', servicename4])
self.assertEqual(stderr.getvalue(), '')
password = stdout.getvalue().strip()
self.assertTrue(len(password) > 12)
self.assertTrue(
Service.objects.get(
username=servicename4).check_password(password))
def test_rm_hosts(self):
s = Service.objects.create(username=servicename5)
s.add_hosts('127.0.0.1')
with capture() as (stdout, stderr):
cli(['rm-hosts', servicename5, '127.0.0.1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertItemsEqual(s.hosts.values_list('address', flat=True), [])
def test_rm_permissions(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-permissions', servicename5, 'props_list', 'groups_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
# remove perm again
with capture() as (stdout, stderr):
cli(['rm-permissions', servicename5, 'props_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertFalse(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
def test_rm_hosts(self):
s = Service.objects.create(username=servicename5)
s.add_hosts('127.0.0.1')
with capture() as (stdout, stderr):
cli(['rm-hosts', servicename5, '127.0.0.1'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertCountEqual(s.hosts.values_list('address', flat=True), [])
def test_rm(self):
Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['rm', servicename5])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertFalse(
Service.objects.filter(username=servicename5).exists())
def test_add_permissions(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['add-permissions', servicename5, 'users_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.users_list'))
with capture() as (stdout, stderr):
cli(['add-permissions', servicename5, 'props_list', 'groups_list'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=servicename5)
self.assertTrue(s.has_perm('Users.props_list'))
self.assertTrue(s.has_perm('Groups.groups_list'))
self.assertTrue(s.has_perm('Users.users_list'))
def test_services(self):
# already exists:
path = os.path.join(self.base, 'services1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* %s: Already exists.$' % self.service.username)
self.assertEqual(stderr.getvalue(), '')
service_name = 'new.example.com'
# raw password
path = os.path.join(self.base, 'services2.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* %s: Set password from input data.$' % service_name)
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(Service.objects.get(username=service_name).check_password('foobar'))
def test_list(self):
with capture() as (stdout, stderr):
restauth_user(['ls'])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.create_user(username1, password1)
with capture() as (stdout, stderr):
restauth_user(['ls'])
out = stdout.getvalue() if six.PY3 else stdout.getvalue().decode('utf-8')
self.assertItemsEqual(out.strip().split('\n'), [username1, ])
self.assertEqual(stderr.getvalue(), '')
self.create_user(username2, password2)
with capture() as (stdout, stderr):
restauth_user(['ls'])
stdout, stderr = self.decode(stdout, stderr)
self.assertItemsEqual(stdout.strip().split('\n'), [username1, username2, ])
self.assertEqual(stderr, '')
def test_set_password_generated(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-password', servicename5, '--gen-password'])
gen_password = stdout.getvalue().strip()
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=s.name)
self.assertFalse(s.check_password(password1))
self.assertTrue(s.check_password(gen_password))
def test_services(self):
# already exists:
path = os.path.join(self.base, 'services1.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* %s: Already exists.$' % self.service.username)
self.assertEqual(stderr.getvalue(), '')
service_name = 'new.example.com'
# raw password
path = os.path.join(self.base, 'services2.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* %s: Set password from input data.$' % service_name)
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(Service.objects.get(username=service_name).check_password('foobar'))
def test_set_password_generated(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
cli(['set-password', servicename5, '--gen-password'])
gen_password = stdout.getvalue().strip()
self.assertEqual(stderr.getvalue(), '')
s = Service.objects.get(username=s.name)
self.assertFalse(s.check_password(password1))
self.assertTrue(s.check_password(gen_password))
def test_rename_service_not_existing(self):
with capture() as (stdout, stderr):
try:
cli(['rename', servicename5, servicename4])
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, r'Service does not exist\.$')
self.assertFalse(Service.objects.filter(username=servicename4).exists())
self.assertFalse(Service.objects.filter(username=servicename5).exists())
def test_set_hosts(self):
path = os.path.join(self.base, 'services5.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* new.example.com: Added service with no password.$')
service = Service.objects.get(username='******')
hosts = service.hosts.values_list('address', flat=True)
self.assertCountEqual(hosts, ['127.0.0.1', '::1'])
def test_add_exists(self):
self.create_user(username1, password1)
with capture() as (stdout, stderr):
try:
restauth_user(['add', '--password', password2,
username1 if six.PY3 else username1.encode('utf-8')])
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, 'User already exists\.$')
def test_add(self):
with capture() as (stdout, stderr):
restauth_user(['add', '--password', password1,
username1 if six.PY3 else username1.encode('utf-8')])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertItemsEqual(user_backend.list(), [username1])
self.assertTrue(user_backend.check_password(username1, password1))
self.assertFalse(user_backend.check_password(username1, password2))
# create anotheruser with a generated password:
gen_password = None
with capture() as (stdout, stderr):
restauth_user(['add', '--gen-password',
username2 if six.PY3 else username2.encode('utf-8')])
gen_password = stdout.getvalue().strip()
self.assertEqual(stderr.getvalue(), '')
self.assertItemsEqual(user_backend.list(), [username1, username2])
self.assertTrue(user_backend.check_password(username2, gen_password))
def test_view(self):
self.maxDiff = None
with capture() as (stdout, stderr):
cli(['view', self.service.name])
self.assertEqual(
stdout.getvalue(), """Last used: %s
Hosts: %s
Permissions: %s
""" % (self.service.last_login, ', '.join(self.service.addresses), ', '.join(
self.service.permissions)))
self.assertEqual(stderr.getvalue(), '')
def test_generate_service_hashes(self):
path = os.path.join(self.base, 'services4.json')
with capture() as (stdout, stderr):
restauth_import(['--gen-passwords', path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* new.example.com: Generated password: .*$')
match = re.search('Generated password: (.*)', stdout.getvalue())
password = match.groups()[0]
Service.objects.get(username='******').check_password(password)
def test_generate_service_hashes(self):
path = os.path.join(self.base, 'services4.json')
with capture() as (stdout, stderr):
restauth_import(['--gen-passwords', path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* new.example.com: Generated password: .*$')
match = re.search('Generated password: (.*)', stdout.getvalue())
password = match.groups()[0]
Service.objects.get(username='******').check_password(password)
def test_set_hosts(self):
path = os.path.join(self.base, 'services5.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* new.example.com: Added service with no password.$')
service = Service.objects.get(username='******')
hosts = service.hosts.values_list('address', flat=True)
self.assertItemsEqual(hosts, ['127.0.0.1', '::1'])
def test_users_django_hash(self, overwrite=False):
path = os.path.join(self.base, 'users5.json')
with capture() as (stdout, stderr):
cmd = [path]
if overwrite:
cmd = ['--overwrite-properties', path]
with override_settings(PASSWORD_HASHERS=PASSWORD_HASHERS):
restauth_import(cmd)
self.assertHasLine(stdout, '^\* %s: Set hash from input data\.$' % username3)
self.assertTrue(backend.check_password(user=username3, password='******'))
self.assertCountEqual(backend.list_users(), [username3])
def test_empty(self):
for i in range(1, 6):
path = os.path.join(self.base, 'empty%s.json' % i)
with capture() as (stdout, stderr):
restauth_import([path])
if backend.SUPPORTS_SUBGROUPS is True:
self.assertEqual(stdout.getvalue(), '')
else:
self.assertEqual(
stdout.getvalue(),
'Warning: Backend does not support subgroups, subgroups discarded.\n')
self.assertEqual(stderr.getvalue(), '')
def test_add_hosts_error(self):
s = Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
try:
cli(['add-hosts', servicename5, 'wrong hostname'])
self.fail("wrong hostname doesn't exit")
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, 'error: Enter a valid IPv4 or IPv6 address.$')
self.assertCountEqual(s.hosts.values_list('address', flat=True), [])
def test_add_invalid(self):
servicename = 'foo:bar'
with capture() as (stdout, stderr):
try:
cli(['add', '--password=%s' % password2, servicename])
self.fail("Adding an existing service should be an error.")
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, 'Service name must not contain a \':\'$')
self.assertFalse(Service.objects.filter(username=servicename).exists())
def test_rename_exists(self):
Service.objects.create(username=servicename4)
Service.objects.create(username=servicename5)
with capture() as (stdout, stderr):
try:
cli(['rename', servicename5, servicename4])
self.fail('Rename does not fail.')
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, r'error: %s: Service already exists\.$' % servicename4)
self.assertTrue(Service.objects.filter(username=servicename4).exists())
self.assertTrue(Service.objects.filter(username=servicename5).exists())
def test_add_existing(self):
s = Service.objects.create(username=servicename3)
s.set_password(password1)
s.save()
with capture() as (stdout, stderr):
with transaction.atomic():
try:
cli(['add', '--password=%s' % password2, servicename3])
self.fail("Adding an existing service should be an error.")
except SystemExit as e:
self.assertEqual(e.code, 2)
self.assertEqual(stdout.getvalue(), '')
self.assertHasLine(stderr, 'Service already exists.$')
self.assertTrue(Service.objects.get(username=servicename3).check_password(password1))
def test_service_hashes(self):
# test various passwords:
path = os.path.join(self.base, 'services3.json')
with capture() as (stdout, stderr):
restauth_import([path])
self.assertEqual(stderr.getvalue(), '')
self.assertHasLine(stdout, '^Services:$')
self.assertHasLine(stdout, '^\* new1.example.com: Set password from input data.$')
self.assertHasLine(stdout, '^\* new2.example.com: Set password from input data.$')
self.assertHasLine(stdout, '^\* new3.example.com: Set password from input data.$')
with override_settings(PASSWORD_HASHERS=PASSWORD_HASHERS):
load_hashers()
self.assertTrue(Service.objects.get(
username='******').check_password('12345678'))
self.assertTrue(Service.objects.get(
username='******').check_password('foobar'))
self.assertTrue(Service.objects.get(
username='******').check_password('foobar'))
load_hashers()
def test_users(self, overwrite=False):
path = os.path.join(self.base, 'users1.json')
cmd = [path]
if overwrite:
cmd = ['--overwrite-properties', path]
with capture() as (stdout, stderr):
with override_settings(PASSWORD_HASHERS=PASSWORD_HASHERS):
restauth_import(cmd)
self.assertHasLine(stdout, '^\* %s: Set hash from input data\.$' % username3)
self.assertTrue(backend.check_password(user=username3, password='******'))
self.assertCountEqual(backend.list_users(), [username1, username2, username3])
props = {
propkey1: propval1,
propkey2: propval2,
# timestamps of when we wrote this test:
# u'date joined': u'2013-12-01 19:27:50',
u'last login': u'2013-12-01 19:27:44',
}
self.assertProperties(username2, props)
def test_add(self):
with capture() as (stdout, stderr):
cli(['add', '--password=foobar', servicename4])
self.assertEqual(stdout.getvalue(), '')
self.assertEqual(stderr.getvalue(), '')
self.assertTrue(Service.objects.get(username=servicename4).check_password('foobar'))
