Debian Codegraph @

tests/test_fprintd_utils.py

raw
1 #!/usr/bin/python3
2
3 # This program is free software; you can redistribute it and/or modify it under
4 # the terms of the GNU Lesser General Public License as published by the Free
5 # Software Foundation; either version 3 of the License, or (at your option) any
6 # later version. See http://www.gnu.org/copyleft/lgpl.html for the full text
7 # of the license.
8
9 __author__ = 'Bastien Nocera'
10 __email__ = '[email protected]'
11 __copyright__ = '(c) 2020 Red Hat Inc.'
12 __license__ = 'LGPL 3+'
13
14 import tempfile
15 import unittest
16 import sys
17 import subprocess
18 import dbus
19 import dbus.mainloop.glib
20 import dbusmock
21 import os
22 import time
23 from output_checker import OutputChecker
24
25
26 VALID_FINGER_NAMES = [
27 'left-thumb',
28 'left-index-finger',
29 'left-middle-finger',
30 'left-ring-finger',
31 'left-little-finger',
32 'right-thumb',
33 'right-index-finger',
34 'right-middle-finger',
35 'right-ring-finger',
36 'right-little-finger'
37 ]
38
39 dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
40
41 class TestFprintdUtilsBase(dbusmock.DBusTestCase):
42 '''Test fprintd utilities'''
43
44 @classmethod
45 def setUpClass(klass):
46 klass.start_system_bus()
47 klass.dbus_con = klass.get_dbus(True)
48 klass.sleep_time = 0.5
49
50 template_path = './'
51 if 'TOPSRCDIR' in os.environ:
52 template_path = os.environ['TOPSRCDIR'] + '/tests/'
53 klass.template_name = template_path + 'dbusmock/fprintd.py'
54 print ('Using template from %s' % klass.template_name)
55
56 klass.tools_prefix = ''
57 if 'FPRINT_BUILD_DIR' in os.environ:
58 klass.tools_prefix = os.environ['FPRINT_BUILD_DIR'] + '/../utils/'
59 print ('Using tools from %s' % klass.tools_prefix)
60 else:
61 print ('Using tools from $PATH')
62
63 klass.wrapper_args = []
64 klass.valgrind = False
65 if 'VALGRIND' in os.environ:
66 valgrind = os.environ['VALGRIND']
67 if valgrind is not None:
68 klass.valgrind = True
69 klass.sleep_time *= 4
70 klass.wrapper_args = ['valgrind', '--leak-check=full']
71 if os.path.exists(valgrind):
72 klass.wrapper_args += ['--suppressions={}'.format(valgrind)]
73
74 if 'ADDRESS_SANITIZER' in os.environ:
75 klass.sleep_time *= 2
76
77 def setUp(self):
78 super().setUp()
79 (self.p_mock, self.obj_fprintd_manager) = self.spawn_server_template(
80 self.template_name, {})
81 # set log to nonblocking
82 self.obj_fprintd_mock = dbus.Interface(self.obj_fprintd_manager, 'net.reactivated.Fprint.Manager.Mock')
83
84 def tearDown(self):
85 self.p_mock.terminate()
86 self.p_mock.wait()
87 super().tearDown()
88
89 def setup_device(self):
90 self.device_path = self.obj_fprintd_mock.AddDevice(
91 'FDO Trigger Finger Laser Reader', 3, 'swipe', False)
92 self.device_mock = self.dbus_con.get_object('net.reactivated.Fprint',
93 self.device_path)
94 self.set_enrolled_fingers(['left-little-finger', 'right-little-finger'])
95
96 def set_enrolled_fingers(self, fingers, user='toto'):
97 self.enrolled_fingers = fingers
98 self.device_mock.SetEnrolledFingers('toto', self.enrolled_fingers,
99 signature='sas')
100
101 def start_utility_process(self, utility_name, args=[], sleep=True):
102 utility = [ os.path.join(self.tools_prefix, 'fprintd-{}'.format(utility_name)) ]
103 output = OutputChecker()
104 process = subprocess.Popen(self.wrapper_args + utility + args,
105 stdout=output.fd,
106 stderr=subprocess.STDOUT)
107 output.writer_attached()
108
109 self.addCleanup(output.assert_closed)
110 self.addCleanup(self.try_stop_utility_process, process)
111
112 if sleep:
113 time.sleep(self.sleep_time)
114
115 return process, output
116
117 def stop_utility_process(self, process):
118 process.terminate()
119 process.wait()
120
121 def try_stop_utility_process(self, process):
122 try:
123 self.stop_utility_process(process)
124 except:
125 pass
126
127 def run_utility_process(self, utility_name, args=[], sleep=True, timeout=None):
128 proc, output = self.start_utility_process(utility_name, args=args, sleep=sleep)
129 ret = proc.wait(timeout=timeout if timeout is not None else self.sleep_time * 4)
130 self.assertLessEqual(ret, 128)
131
132 return b''.join(output.clear()), ret
133
134
135 class TestFprintdUtils(TestFprintdUtilsBase):
136 def setUp(self):
137 super().setUp()
138 self.setup_device()
139
140 def test_fprintd_enroll(self):
141 process, out = self.start_utility_process('enroll', ['-f', 'right-index-finger', 'toto'])
142
143 out.check_line(rb'right-index-finger', 0)
144
145 self.device_mock.EmitEnrollStatus('enroll-completed', True)
146
147 out.check_line(rb'Enroll result: enroll-completed', self.sleep_time)
148
149 def test_fprintd_list(self):
150 # Rick has no fingerprints enrolled
151 out, ret = self.run_utility_process('list', ['rick'])
152 self.assertRegex(out, rb'has no fingers enrolled for')
153 self.assertEqual(ret, 0)
154
155 # Toto does
156 out, ret = self.run_utility_process('list', ['toto'])
157 self.assertRegex(out, rb'right-little-finger')
158 self.assertEqual(ret, 0)
159
160 def test_fprintd_delete(self):
161 # Delete fingerprints
162 out, ret = self.run_utility_process('delete', ['toto'])
163 self.assertRegex(out, rb'Fingerprints of user toto deleted')
164 self.assertEqual(ret, 0)
165
166 # Doesn't have fingerprints
167 out, ret = self.run_utility_process('delete', ['toto'])
168 self.assertRegex(out, rb'No fingerprints to delete on')
169 self.assertEqual(ret, 0)
170
171
172 class TestFprintdUtilsNoDeviceTests(TestFprintdUtilsBase):
173 def test_fprintd_enroll(self):
174 out, ret = self.run_utility_process('enroll', ['toto'])
175 self.assertIn(b'No devices available', out)
176 self.assertEqual(ret, 1)
177
178 def test_fprintd_list(self):
179 out, ret = self.run_utility_process('list', ['toto'])
180 self.assertIn(b'No devices available', out)
181 self.assertEqual(ret, 1)
182
183 def test_fprintd_delete(self):
184 out, ret = self.run_utility_process('delete', ['toto'])
185 self.assertIn(b'No devices available', out)
186 self.assertEqual(ret, 1)
187
188 def test_fprintd_verify(self):
189 out, ret = self.run_utility_process('verify', ['toto'])
190 self.assertIn(b'No devices available', out)
191 self.assertEqual(ret, 1)
192
193
194 class TestFprintdUtilsVerify(TestFprintdUtilsBase):
195 def setUp(self):
196 super().setUp()
197 self.setup_device()
198
199 def start_verify_process(self, user='toto', finger=None, nowait=False):
200 args = [user]
201 if finger:
202 args += ['-f', finger]
203
204 self.process, self.output = self.start_utility_process('verify', args)
205 if nowait:
206 return
207
208 preamble = self.output.check_line(b'Verify started!')
209
210 out = b''.join(preamble)
211
212 self.assertNotIn(b'Verify result:', out)
213
214 if finger:
215 expected_finger = finger
216 if finger == 'any' and not self.device_mock.HasIdentification():
217 expected_finger = self.enrolled_fingers[0]
218 self.assertEqual(self.device_mock.GetSelectedFinger(), expected_finger)
219
220 def assertVerifyMatch(self, match):
221 self.output.check_line(r'Verify result: {} (done)'.format(
222 'verify-match' if match else 'verify-no-match'))
223
224 def test_fprintd_verify(self):
225 self.start_verify_process()
226
227 self.device_mock.EmitVerifyStatus('verify-match', True)
228 time.sleep(self.sleep_time)
229 self.assertVerifyMatch(True)
230
231 def test_fprintd_verify_enrolled_fingers(self):
232 for finger in self.enrolled_fingers:
233 self.start_verify_process(finger=finger)
234
235 self.device_mock.EmitVerifyStatus('verify-match', True)
236 time.sleep(self.sleep_time)
237 self.assertVerifyMatch(True)
238
239 def test_fprintd_verify_any_finger_no_identification(self):
240 self.start_verify_process(finger='any')
241
242 self.device_mock.EmitVerifyStatus('verify-match', True)
243 time.sleep(self.sleep_time)
244 self.assertVerifyMatch(True)
245
246 def test_fprintd_verify_any_finger_identification(self):
247 self.obj_fprintd_mock.RemoveDevice(self.device_path)
248 self.device_path = self.obj_fprintd_mock.AddDevice('Full powered device',
249 3, 'press', True)
250 self.device_mock = self.dbus_con.get_object('net.reactivated.Fprint',
251 self.device_path)
252 self.set_enrolled_fingers(VALID_FINGER_NAMES)
253 self.start_verify_process(finger='any')
254
255 self.device_mock.EmitVerifyStatus('verify-match', True)
256 time.sleep(self.sleep_time)
257 self.assertVerifyMatch(True)
258
259 def test_fprintd_verify_not_enrolled_fingers(self):
260 for finger in [f for f in VALID_FINGER_NAMES if f not in self.enrolled_fingers]:
261 self.start_verify_process(finger=finger, nowait=True)
262 regex = r'Finger \'{}\' not enrolled'.format(finger)
263 self.output.check_line_re(regex, timeout=self.sleep_time)
264
265 self.device_mock.Release()
266
267 def test_fprintd_verify_no_enrolled_fingers(self):
268 self.set_enrolled_fingers([])
269 self.start_verify_process(nowait=True)
270 self.output.check_line(b'No fingers enrolled for this device.', timeout=self.sleep_time)
271 self.assertEqual(self.process.poll(), 1)
272
273 def test_fprintd_list_all_fingers(self):
274 self.set_enrolled_fingers(VALID_FINGER_NAMES)
275 self.start_verify_process()
276
277 def test_fprintd_verify_script(self):
278 script = [
279 ( 'verify-match', True, 2 )
280 ]
281 self.device_mock.SetVerifyScript(script)
282 time.sleep(2)
283
284 self.start_verify_process()
285 time.sleep(2 + self.sleep_time)
286 self.assertVerifyMatch(True)
287
288 def test_fprintd_multiple_verify_fails(self):
289 self.start_verify_process()
290
291 self.start_verify_process(nowait=True)
292 self.output.check_line_re(rb'Device already in use by [A-z]+', timeout=self.sleep_time)
293
294 if __name__ == '__main__':
295 # avoid writing to stderr
296 unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout, verbosity=2))