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_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_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_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_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_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'))