cookiez/pam-fprint-grosshack
1
0
Fork 0
mirror of https://gitlab.com/mishakmak/pam-fprint-grosshack.git synced 2026-04-09 04:13:33 +02:00
Code Issues Packages Projects Releases Wiki Activity

tests: Port test to use the OutputChecker

Browse Source
This commit is contained in:
Benjamin Berg
2020-12-04 18:11:41 +01:00
parent 2d98d4543f
commit 34b21fa917
1 changed files with 41 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
tests/test_fprintd_utils.py
View File

@ -18,9 +18,9 @@ import subprocess
import dbus import dbus
import dbus.mainloop.glib import dbus.mainloop.glib
import dbusmock import dbusmock
import fcntl
import os import os
import time import time
from output_checker import OutputChecker
VALID_FINGER_NAMES = [ VALID_FINGER_NAMES = [
@ -77,10 +77,8 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
def setUp(self): def setUp(self):
super().setUp() super().setUp()
(self.p_mock, self.obj_fprintd_manager) = self.spawn_server_template( (self.p_mock, self.obj_fprintd_manager) = self.spawn_server_template(
self.template_name, {}, stdout=subprocess.PIPE) self.template_name, {})
# set log to nonblocking # set log to nonblocking
flags = fcntl.fcntl(self.p_mock.stdout, fcntl.F_GETFL)
fcntl.fcntl(self.p_mock.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
self.obj_fprintd_mock = dbus.Interface(self.obj_fprintd_manager, 'net.reactivated.Fprint.Manager.Mock') self.obj_fprintd_mock = dbus.Interface(self.obj_fprintd_manager, 'net.reactivated.Fprint.Manager.Mock')
def tearDown(self): def tearDown(self):
@ -102,22 +100,21 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
def start_utility_process(self, utility_name, args=[], sleep=True): def start_utility_process(self, utility_name, args=[], sleep=True):
utility = [ os.path.join(self.tools_prefix, 'fprintd-{}'.format(utility_name)) ] utility = [ os.path.join(self.tools_prefix, 'fprintd-{}'.format(utility_name)) ]
output = OutputChecker()
process = subprocess.Popen(self.wrapper_args + utility + args, process = subprocess.Popen(self.wrapper_args + utility + args,
stdout=subprocess.PIPE, stdout=output.fd,
stderr=subprocess.STDOUT, stderr=subprocess.STDOUT)
universal_newlines=True) output.writer_attached()
flags = fcntl.fcntl(process.stdout, fcntl.F_GETFL)
fcntl.fcntl(process.stdout, fcntl.F_SETFL, flags | os.O_NONBLOCK)
self.addCleanup(output.assert_closed)
self.addCleanup(self.try_stop_utility_process, process) self.addCleanup(self.try_stop_utility_process, process)
if sleep: if sleep:
time.sleep(self.sleep_time) time.sleep(self.sleep_time)
return process return process, output
def stop_utility_process(self, process): def stop_utility_process(self, process):
print(process.stdout.read())
process.terminate() process.terminate()
process.wait() process.wait()
@ -127,17 +124,12 @@ class TestFprintdUtilsBase(dbusmock.DBusTestCase):
except: except:
pass pass
def get_process_output(self, process):
out = process.stdout.read()
self.addCleanup(print, out)
return out
def run_utility_process(self, utility_name, args=[], sleep=True, timeout=None): def run_utility_process(self, utility_name, args=[], sleep=True, timeout=None):
proc = self.start_utility_process(utility_name, args=args, sleep=sleep) proc, output = self.start_utility_process(utility_name, args=args, sleep=sleep)
ret = proc.wait(timeout=timeout if timeout is not None else self.sleep_time * 4) ret = proc.wait(timeout=timeout if timeout is not None else self.sleep_time * 4)
self.assertLessEqual(ret, 128) self.assertLessEqual(ret, 128)
return self.get_process_output(proc), ret return b''.join(output.clear()), ret
class TestFprintdUtils(TestFprintdUtilsBase): class TestFprintdUtils(TestFprintdUtilsBase):
@ -146,65 +138,62 @@ class TestFprintdUtils(TestFprintdUtilsBase):
self.setup_device() self.setup_device()
def test_fprintd_enroll(self): def test_fprintd_enroll(self):
process = self.start_utility_process('enroll', ['-f', 'right-index-finger', 'toto']) process, out = self.start_utility_process('enroll', ['-f', 'right-index-finger', 'toto'])
out = self.get_process_output(process) out.check_line(rb'right-index-finger', 0)
self.assertRegex(out, r'right-index-finger')
self.device_mock.EmitEnrollStatus('enroll-completed', True) self.device_mock.EmitEnrollStatus('enroll-completed', True)
time.sleep(self.sleep_time)
out = self.get_process_output(process) out.check_line(rb'Enroll result: enroll-completed', self.sleep_time)
self.assertRegex(out, 'Enroll result: enroll-completed')
def test_fprintd_list(self): def test_fprintd_list(self):
# Rick has no fingerprints enrolled # Rick has no fingerprints enrolled
out, ret = self.run_utility_process('list', ['rick']) out, ret = self.run_utility_process('list', ['rick'])
self.assertRegex(out, r'has no fingers enrolled for') self.assertRegex(out, rb'has no fingers enrolled for')
self.assertEqual(ret, 0) self.assertEqual(ret, 0)
# Toto does # Toto does
out, ret = self.run_utility_process('list', ['toto']) out, ret = self.run_utility_process('list', ['toto'])
self.assertRegex(out, r'right-little-finger') self.assertRegex(out, rb'right-little-finger')
self.assertEqual(ret, 0) self.assertEqual(ret, 0)
def test_fprintd_delete(self): def test_fprintd_delete(self):
# Has fingerprints enrolled # Has fingerprints enrolled
out, ret = self.run_utility_process('list', ['toto']) out, ret = self.run_utility_process('list', ['toto'])
self.assertRegex(out, r'left-little-finger') self.assertRegex(out, rb'left-little-finger')
self.assertEqual(ret, 0) self.assertEqual(ret, 0)
self.assertRegex(out, r'right-little-finger') self.assertRegex(out, rb'right-little-finger')
# Delete fingerprints # Delete fingerprints
out, ret = self.run_utility_process('delete', ['toto']) out, ret = self.run_utility_process('delete', ['toto'])
self.assertRegex(out, r'Fingerprints deleted') self.assertRegex(out, rb'Fingerprints deleted')
self.assertEqual(ret, 0) self.assertEqual(ret, 0)
# Doesn't have fingerprints # Doesn't have fingerprints
out, ret = self.run_utility_process('list', ['toto']) out, ret = self.run_utility_process('list', ['toto'])
self.assertRegex(out, r'has no fingers enrolled for') self.assertRegex(out, rb'has no fingers enrolled for')
self.assertEqual(ret, 0) self.assertEqual(ret, 0)
class TestFprintdUtilsNoDeviceTests(TestFprintdUtilsBase): class TestFprintdUtilsNoDeviceTests(TestFprintdUtilsBase):
def test_fprintd_enroll(self): def test_fprintd_enroll(self):
out, ret = self.run_utility_process('enroll', ['toto']) out, ret = self.run_utility_process('enroll', ['toto'])
self.assertIn('No devices available', out) self.assertIn(b'No devices available', out)
self.assertEqual(ret, 1) self.assertEqual(ret, 1)
def test_fprintd_list(self): def test_fprintd_list(self):
out, ret = self.run_utility_process('list', ['toto']) out, ret = self.run_utility_process('list', ['toto'])
self.assertIn('No devices available', out) self.assertIn(b'No devices available', out)
self.assertEqual(ret, 1) self.assertEqual(ret, 1)
def test_fprintd_delete(self): def test_fprintd_delete(self):
out, ret = self.run_utility_process('delete', ['toto']) out, ret = self.run_utility_process('delete', ['toto'])
self.assertIn('No devices available', out) self.assertIn(b'No devices available', out)
self.assertEqual(ret, 1) self.assertEqual(ret, 1)
def test_fprintd_verify(self): def test_fprintd_verify(self):
out, ret = self.run_utility_process('verify', ['toto']) out, ret = self.run_utility_process('verify', ['toto'])
self.assertIn('No devices available', out) self.assertIn(b'No devices available', out)
self.assertEqual(ret, 1) self.assertEqual(ret, 1)
@ -213,24 +202,20 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
super().setUp() super().setUp()
self.setup_device() self.setup_device()
def start_verify_process(self, user='toto', finger=None, checkEnrolled=True): def start_verify_process(self, user='toto', finger=None, nowait=False):
args = [user] args = [user]
if finger: if finger:
args += ['-f', finger] args += ['-f', finger]
self.process = self.start_utility_process('verify', args) self.process, self.output = self.start_utility_process('verify', args)
out = self.get_process_output(self.process) if nowait:
return
self.assertNotRegex(out, r'Device already in use by [A-z]+') preamble = self.output.check_line(b'Verify started!')
self.assertNotIn('Verify result:', out)
if checkEnrolled and finger: out = b''.join(preamble)
self.assertNotIn('''Finger '{}' not enrolled for user {}'''.format(
finger, user), out)
if checkEnrolled: self.assertNotIn(b'Verify result:', out)
for f in self.enrolled_fingers:
self.assertIn(f, out)
if finger: if finger:
expected_finger = finger expected_finger = finger
@ -239,9 +224,8 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
self.assertEqual(self.device_mock.GetSelectedFinger(), expected_finger) self.assertEqual(self.device_mock.GetSelectedFinger(), expected_finger)
def assertVerifyMatch(self, match): def assertVerifyMatch(self, match):
self.assertIn('Verify result: {} (done)'.format( self.output.check_line(r'Verify result: {} (done)'.format(
'verify-match' if match else 'verify-no-match'), 'verify-match' if match else 'verify-no-match'))
self.get_process_output(self.process))
def test_fprintd_verify(self): def test_fprintd_verify(self):
self.start_verify_process() self.start_verify_process()
@ -280,14 +264,16 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
def test_fprintd_verify_not_enrolled_fingers(self): def test_fprintd_verify_not_enrolled_fingers(self):
for finger in [f for f in VALID_FINGER_NAMES if f not in self.enrolled_fingers]: for finger in [f for f in VALID_FINGER_NAMES if f not in self.enrolled_fingers]:
self.start_verify_process(finger=finger, nowait=True)
regex = r'Finger \'{}\' not enrolled'.format(finger) regex = r'Finger \'{}\' not enrolled'.format(finger)
with self.assertRaisesRegex(AssertionError, regex): self.output.check_line_re(regex, timeout=self.sleep_time)
self.start_verify_process(finger=finger)
self.device_mock.Release() self.device_mock.Release()
def test_fprintd_verify_no_enrolled_fingers(self): def test_fprintd_verify_no_enrolled_fingers(self):
self.set_enrolled_fingers([]) self.set_enrolled_fingers([])
self.start_verify_process() self.start_verify_process(nowait=True)
self.output.check_line(b'No fingers enrolled for this device.', timeout=self.sleep_time)
self.assertEqual(self.process.poll(), 1) self.assertEqual(self.process.poll(), 1)
def test_fprintd_list_all_fingers(self): def test_fprintd_list_all_fingers(self):
@ -299,16 +285,17 @@ class TestFprintdUtilsVerify(TestFprintdUtilsBase):
( 'verify-match', True, 2 ) ( 'verify-match', True, 2 )
] ]
self.device_mock.SetVerifyScript(script) self.device_mock.SetVerifyScript(script)
time.sleep(2)
self.start_verify_process() self.start_verify_process()
time.sleep(self.sleep_time * 4) time.sleep(2 + self.sleep_time)
self.assertVerifyMatch(True) self.assertVerifyMatch(True)
def test_fprintd_multiple_verify_fails(self): def test_fprintd_multiple_verify_fails(self):
self.start_verify_process() self.start_verify_process()
with self.assertRaisesRegex(AssertionError, r'Device already in use'): self.start_verify_process(nowait=True)
self.start_verify_process() self.output.check_line_re(rb'Device already in use by [A-z]+', timeout=self.sleep_time)
if __name__ == '__main__': if __name__ == '__main__':
# avoid writing to stderr # avoid writing to stderr