← Back to branch summary

~ubuntu-branches/ubuntu/trusty/apparmor/trusty-proposed

« back to all changes in this revision

Viewing changes to utils/test/test-regex_matches.py

  • Committer: Package Import Robot
  • Author(s): Jamie Strandboge
  • Date: 2014-04-04 01:07:24 UTC
  • Revision ID: package-import@ubuntu.com-20140404010724-n7pyk2cd5er3gi6m
Tags: 2.8.95~2430-0ubuntu5
debian/control: add versioned Breaks to apparmor for lxc, libvirt-bin,
lightdm and apparmor-easyprof-ubuntu

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/test/test-regex_matches.py
41
41
    ('audit "/tmp/foo, # bar" rw%s # comment', 'comment embedded in quote 02'),
42
42
 
43
43
    # lifted from parser/tst/simple_tests/vars/vars_alternation_3.sd
44
 
    ('/does/not/@{BAR},exist,notexist} r%s', 'partial alternation')
 
44
    ('/does/not/@{BAR},exist,notexist} r%s', 'partial alternation'),
 
45
 
 
46
    ('signal%s', 'bare signal'),
 
47
    ('signal receive%s', 'simple signal'),
 
48
    ('signal (send, receive)%s', 'embedded parens signal 01'),
 
49
    ('signal (send, receive) set=(hup, quit)%s', 'embedded parens signal 02'),
 
50
 
 
51
    ('ptrace%s', 'bare ptrace'),
 
52
    ('ptrace trace%s', 'simple ptrace'),
 
53
    ('ptrace (tracedby, readby)%s', 'embedded parens ptrace 01'),
 
54
    ('ptrace (trace) peer=/usr/bin/foo%s', 'embedded parens ptrace 02'),
 
55
 
 
56
    ('pivot_root%s', 'bare pivot_root'),
 
57
    ('pivot_root /old%s', 'pivot_root with old'),
 
58
    ('pivot_root /old new%s', 'pivot_root with new'),
 
59
    ('pivot_root /old /new -> child%s', 'pivot_root with child'),
45
60
 
46
61
    # the following fail due to inadequacies in the regex
47
62
    # ('dbus (r, w, %s', 'incomplete dbus action'),
96
111
    ('dbus send member=no_comment, ', False),
97
112
    ('audit "/tmp/foo, # bar" rw', False),
98
113
    ('audit "/tmp/foo, # bar" rw # comment', ('audit "/tmp/foo, # bar" rw ', '# comment')),
 
114
    ('file,', False),
 
115
    ('file, # bare', ('file, ', '# bare')),
 
116
    ('file /tmp/foo rw, # read-write', ('file /tmp/foo rw, ', '# read-write')),
 
117
    ('signal, # comment', ('signal, ', '# comment')),
 
118
    ('signal receive set=(usr1 usr2) peer=foo,', False),
 
119
    ('ptrace, # comment', ('ptrace, ', '# comment')),
 
120
    ('ptrace (trace read) peer=/usr/bin/foo,', False),
 
121
    ('pivot_root, # comment', ('pivot_root, ', '# comment')),
 
122
    ('pivot_root /old /new -> child,', False),
99
123
]
100
124
 
101
125
def setup_split_comment_testcases():
110
134
        stub_test.__doc__ = "test '%s'" % (test_string)
111
135
        setattr(AARegexSplitComment, 'test_split_comment_%d' % (i), stub_test)
112
136
 
 
137
class AARegexPath(unittest.TestCase):
 
138
    '''Tests for RE_PROFILE_PATH_ENTRY'''
 
139
 
 
140
    def test_simple_path_01(self):
 
141
        '''test '   /tmp/foo r,' '''
 
142
 
 
143
        line = '   /tmp/foo r,'
 
144
        result = aa.RE_PROFILE_PATH_ENTRY.search(line)
 
145
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
146
        mode = result.groups()[4].strip()
 
147
        self.assertEqual(mode, 'r', 'Expected mode "r", got "%s"' % (mode))
 
148
 
 
149
    def test_simple_path_02(self):
 
150
        '''test '   audit /tmp/foo rw,' '''
 
151
 
 
152
        line = '   audit /tmp/foo rw,'
 
153
        result = aa.RE_PROFILE_PATH_ENTRY.search(line)
 
154
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
155
        audit = result.groups()[0].strip()
 
156
        self.assertEqual(audit, 'audit', 'Couldn\t find audit modifier')
 
157
        mode = result.groups()[4].strip()
 
158
        self.assertEqual(mode, 'rw', 'Expected mode "rw", got "%s"' % (mode))
 
159
 
 
160
    def test_simple_path_03(self):
 
161
        '''test '   audit deny /tmp/foo rw,' '''
 
162
 
 
163
        line = '   audit deny /tmp/foo rw,'
 
164
        result = aa.RE_PROFILE_PATH_ENTRY.search(line)
 
165
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
166
        audit = result.groups()[0].strip()
 
167
        self.assertEqual(audit, 'audit', 'Couldn\t find audit modifier')
 
168
        deny = result.groups()[1].strip()
 
169
        self.assertEqual(deny, 'deny', 'Couldn\t find deny modifier')
 
170
        mode = result.groups()[4].strip()
 
171
        self.assertEqual(mode, 'rw', 'Expected mode "rw", got "%s"' % (mode))
 
172
 
 
173
    def test_simple_bad_path_01(self):
 
174
        '''test '   file,' '''
 
175
 
 
176
        line = '   file,'
 
177
        result = aa.RE_PROFILE_PATH_ENTRY.search(line)
 
178
        self.assertFalse(result, 'RE_PROFILE_PATH_ENTRY unexpectedly matched "%s"' % line)
 
179
 
 
180
    def test_simple_bad_path_02(self):
 
181
        '''test '   file /tmp/foo rw,' '''
 
182
 
 
183
        line = '   file /tmp/foo rw,'
 
184
        result = aa.RE_PROFILE_PATH_ENTRY.search(line)
 
185
        self.assertFalse(result, 'RE_PROFILE_PATH_ENTRY unexpectedly matched "%s"' % line)
 
186
 
 
187
class AARegexFile(unittest.TestCase):
 
188
    '''Tests for RE_PROFILE_FILE_ENTRY'''
 
189
 
 
190
    def _assertEqualStrings(self, str1, str2):
 
191
        self.assertEqual(str1, str2, 'Expected %s, got "%s"' % (str1, str2))
 
192
 
 
193
    def test_simple_file_01(self):
 
194
        '''test '   file /tmp/foo rw,' '''
 
195
 
 
196
        path = '/tmp/foo'
 
197
        mode = 'rw'
 
198
        line = '   file %s %s,' % (path, mode)
 
199
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
200
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
201
        self._assertEqualStrings(path, result.groups()[3].strip())
 
202
        self._assertEqualStrings(mode, result.groups()[4].strip())
 
203
 
 
204
    def test_simple_file_02(self):
 
205
        '''test '   file,' '''
 
206
 
 
207
        line = '   file,'
 
208
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
209
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
210
        path = result.groups()[3]
 
211
        self.assertEqual(path, None, 'Unexpected path, got "%s"' % path)
 
212
        mode = result.groups()[4]
 
213
        self.assertEqual(mode, None, 'Unexpected mode, got "%s"' % (mode))
 
214
 
 
215
    def test_simple_file_03(self):
 
216
        '''test '   audit file,' '''
 
217
 
 
218
        line = '   audit file,'
 
219
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
220
        self.assertTrue(result, 'Couldn\'t find file rule in "%s"' % line)
 
221
        audit = result.groups()[0].strip()
 
222
        self.assertEqual(audit, 'audit', 'Couldn\t find audit modifier')
 
223
        path = result.groups()[3]
 
224
        self.assertEqual(path, None, 'Unexpected path, got "%s"' % path)
 
225
        mode = result.groups()[4]
 
226
        self.assertEqual(mode, None, 'Unexpected mode, got "%s"' % (mode))
 
227
 
 
228
    def test_simple_bad_file_01(self):
 
229
        '''test '   dbus,' '''
 
230
 
 
231
        line = '   dbus,'
 
232
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
233
        self.assertFalse(result, 'RE_PROFILE_FILE_ENTRY unexpectedly matched "%s"' % line)
 
234
 
 
235
    def test_simple_bad_file_02(self):
 
236
        '''test '   /tmp/foo rw,' '''
 
237
 
 
238
        line = '   /tmp/foo rw,'
 
239
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
240
        self.assertFalse(result, 'RE_PROFILE_FILE_ENTRY unexpectedly matched "%s"' % line)
 
241
 
 
242
    def test_simple_bad_file_03(self):
 
243
        '''test '   file /tmp/foo,' '''
 
244
 
 
245
        line = '   file /tmp/foo,'
 
246
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
247
        self.assertFalse(result, 'RE_PROFILE_FILE_ENTRY unexpectedly matched "%s"' % line)
 
248
 
 
249
    def test_simple_bad_file_04(self):
 
250
        '''test '   file r,' '''
 
251
 
 
252
        line = '   file r,'
 
253
        result = aa.RE_PROFILE_FILE_ENTRY.search(line)
 
254
        self.assertFalse(result, 'RE_PROFILE_FILE_ENTRY unexpectedly matched "%s"' % line)
 
255
 
 
256
class AARegexSignal(unittest.TestCase):
 
257
    '''Tests for RE_PROFILE_SIGNAL'''
 
258
 
 
259
    def test_bare_signal_01(self):
 
260
        '''test '   signal,' '''
 
261
 
 
262
        rule = 'signal,'
 
263
        line = '   %s' % rule
 
264
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
265
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
266
        parsed = result.groups()[2].strip()
 
267
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
268
                         % (rule, parsed))
 
269
 
 
270
    def test_bare_signal_02(self):
 
271
        '''test '   audit signal,' '''
 
272
 
 
273
        rule = 'signal,'
 
274
        line = '   audit %s' % rule
 
275
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
276
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
277
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
278
        parsed = result.groups()[2].strip()
 
279
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
280
                         % (rule, parsed))
 
281
 
 
282
    def test_simple_signal_01(self):
 
283
        '''test '   signal receive,' '''
 
284
 
 
285
        rule = 'signal receive,'
 
286
        line = '   %s' % rule
 
287
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
288
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
289
        parsed = result.groups()[2].strip()
 
290
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
291
                         % (rule, parsed))
 
292
 
 
293
    def test_simple_signal_02(self):
 
294
        '''test '   signal (send, receive),' '''
 
295
 
 
296
        rule = 'signal (send, receive),'
 
297
        line = '   %s' % rule
 
298
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
299
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
300
        parsed = result.groups()[2].strip()
 
301
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
302
                         % (rule, parsed))
 
303
 
 
304
    def test_simple_signal_03(self):
 
305
        '''test '   audit signal (receive),' '''
 
306
 
 
307
        rule = 'signal (receive),'
 
308
        line = '   audit %s' % rule
 
309
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
310
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
311
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
312
        parsed = result.groups()[2].strip()
 
313
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
314
                         % (rule, parsed))
 
315
 
 
316
    def test_set_signal_01(self):
 
317
        '''test '   signal (send, receive) set=(usr1 usr2),' '''
 
318
 
 
319
        rule = 'signal (send, receive) set=(usr1 usr2),'
 
320
        line = '   %s' % rule
 
321
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
322
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
323
        parsed = result.groups()[2].strip()
 
324
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
325
                         % (rule, parsed))
 
326
 
 
327
    def test_peer_signal_01(self):
 
328
        '''test '   signal send set=(hup, quit) peer=/usr/sbin/daemon,' '''
 
329
 
 
330
        rule = 'signal send set=(hup, quit) peer=/usr/sbin/daemon,'
 
331
        line = '   %s' % rule
 
332
        result = aa.RE_PROFILE_SIGNAL.search(line)
 
333
        self.assertTrue(result, 'Couldn\'t find signal rule in "%s"' % line)
 
334
        parsed = result.groups()[2].strip()
 
335
        self.assertEqual(parsed, rule, 'Expected signal rule "%s", got "%s"'
 
336
                         % (rule, parsed))
 
337
 
 
338
class AARegexPtrace(unittest.TestCase):
 
339
    '''Tests for RE_PROFILE_PTRACE'''
 
340
 
 
341
    def test_bare_ptrace_01(self):
 
342
        '''test '   ptrace,' '''
 
343
 
 
344
        rule = 'ptrace,'
 
345
        line = '   %s' % rule
 
346
        result = aa.RE_PROFILE_PTRACE.search(line)
 
347
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
348
        parsed = result.groups()[2].strip()
 
349
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
350
                         % (rule, parsed))
 
351
 
 
352
    def test_bare_ptrace_02(self):
 
353
        '''test '   audit ptrace,' '''
 
354
 
 
355
        rule = 'ptrace,'
 
356
        line = '   audit %s' % rule
 
357
        result = aa.RE_PROFILE_PTRACE.search(line)
 
358
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
359
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
360
        parsed = result.groups()[2].strip()
 
361
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
362
                         % (rule, parsed))
 
363
 
 
364
    def test_simple_ptrace_01(self):
 
365
        '''test '   ptrace trace,' '''
 
366
 
 
367
        rule = 'ptrace trace,'
 
368
        line = '   %s' % rule
 
369
        result = aa.RE_PROFILE_PTRACE.search(line)
 
370
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
371
        parsed = result.groups()[2].strip()
 
372
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
373
                         % (rule, parsed))
 
374
 
 
375
    def test_simple_ptrace_02(self):
 
376
        '''test '   ptrace (tracedby, readby),' '''
 
377
 
 
378
        rule = 'ptrace (tracedby, readby),'
 
379
        line = '   %s' % rule
 
380
        result = aa.RE_PROFILE_PTRACE.search(line)
 
381
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
382
        parsed = result.groups()[2].strip()
 
383
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
384
                         % (rule, parsed))
 
385
 
 
386
    def test_simple_ptrace_03(self):
 
387
        '''test '   audit ptrace (read),' '''
 
388
 
 
389
        rule = 'ptrace (read),'
 
390
        line = '   audit %s' % rule
 
391
        result = aa.RE_PROFILE_PTRACE.search(line)
 
392
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
393
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
394
        parsed = result.groups()[2].strip()
 
395
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
396
                         % (rule, parsed))
 
397
 
 
398
    def test_peer_ptrace_01(self):
 
399
        '''test '   ptrace trace peer=/usr/sbin/daemon,' '''
 
400
 
 
401
        rule = 'ptrace trace peer=/usr/sbin/daemon,'
 
402
        line = '   %s' % rule
 
403
        result = aa.RE_PROFILE_PTRACE.search(line)
 
404
        self.assertTrue(result, 'Couldn\'t find ptrace rule in "%s"' % line)
 
405
        parsed = result.groups()[2].strip()
 
406
        self.assertEqual(parsed, rule, 'Expected ptrace rule "%s", got "%s"'
 
407
                         % (rule, parsed))
 
408
 
 
409
class AARegexPivotRoot(unittest.TestCase):
 
410
    '''Tests for RE_PROFILE_PIVOT_ROOT'''
 
411
 
 
412
    def test_bare_pivot_root_01(self):
 
413
        '''test '   pivot_root,' '''
 
414
 
 
415
        rule = 'pivot_root,'
 
416
        line = '   %s' % rule
 
417
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
418
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
419
        parsed = result.groups()[2].strip()
 
420
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
421
                         % (rule, parsed))
 
422
 
 
423
    def test_bare_pivot_root_02(self):
 
424
        '''test '   audit pivot_root,' '''
 
425
 
 
426
        rule = 'pivot_root,'
 
427
        line = '   audit %s' % rule
 
428
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
429
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
430
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
431
        parsed = result.groups()[2].strip()
 
432
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
433
                         % (rule, parsed))
 
434
 
 
435
    def test_old_pivot_root_01(self):
 
436
        '''test '   pivot_root /old,' '''
 
437
 
 
438
        rule = 'pivot_root /old,'
 
439
        line = '   %s' % rule
 
440
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
441
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
442
        parsed = result.groups()[2].strip()
 
443
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
444
                         % (rule, parsed))
 
445
 
 
446
    def test_new_pivot_root_01(self):
 
447
        '''test '   pivot_root /old /new,' '''
 
448
 
 
449
        rule = 'pivot_root /old /new,'
 
450
        line = '   %s' % rule
 
451
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
452
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
453
        parsed = result.groups()[2].strip()
 
454
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
455
                         % (rule, parsed))
 
456
 
 
457
    def test_child_pivot_root_01(self):
 
458
        '''test '   pivot_root /old /new -> child,' '''
 
459
 
 
460
        rule = 'pivot_root /old /new -> child,'
 
461
        line = '   %s' % rule
 
462
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
463
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
464
        parsed = result.groups()[2].strip()
 
465
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
466
                         % (rule, parsed))
 
467
 
 
468
    def test_child_pivot_root_02(self):
 
469
        '''test '   audit pivot_root /old /new -> child,' '''
 
470
 
 
471
        rule = 'pivot_root /old /new -> child,'
 
472
        line = '   audit %s' % rule
 
473
        result = aa.RE_PROFILE_PIVOT_ROOT.search(line)
 
474
        self.assertTrue(result, 'Couldn\'t find pivot_root rule in "%s"' % line)
 
475
        self.assertTrue(result.groups()[0], 'Couldn\'t find audit modifier in "%s"' % line)
 
476
        parsed = result.groups()[2].strip()
 
477
        self.assertEqual(parsed, rule, 'Expected pivot_root rule "%s", got "%s"'
 
478
                         % (rule, parsed))
 
479
 
113
480
if __name__ == '__main__':
114
481
    verbosity = 2
115
482
 
119
486
    test_suite = unittest.TestSuite()
120
487
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexHasComma))
121
488
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexSplitComment))
 
489
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexPath))
 
490
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexFile))
 
491
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexSignal))
 
492
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexPtrace))
 
493
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(AARegexPivotRoot))
122
494
    result = unittest.TextTestRunner(verbosity=verbosity).run(test_suite)
123
495
    if not result.wasSuccessful():
124
496
        exit(1)