#!/usr/bin/python3
# ----------------------------------------------------------------------
#    Copyright (C) 2015 Christian Boltz <apparmor@cboltz.de>
#
#    This program is free software; you can redistribute it and/or
#    modify it under the terms of version 2 of the GNU General Public
#    License as published by the Free Software Foundation.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
# ----------------------------------------------------------------------

import unittest
from collections import namedtuple

import apparmor.severity as severity
from apparmor.common import AppArmorBug, AppArmorException
from apparmor.logparser import ReadLog
from apparmor.rule.file import FileRule, FileRuleset
from apparmor.translations import init_translation
from common_test import AATest, setup_all_loops

_ = init_translation()

exp = namedtuple(
    'exp', ('audit', 'allow_keyword', 'deny', 'comment', 'path', 'all_paths',
            'perms', 'all_perms', 'exec_perms', 'target', 'all_targets',
            'owner', 'file_keyword', 'leading_perms'))


# --- tests for single FileRule --- #

class FileTest(AATest):
    def _compare_obj(self, obj, expected):
        self.assertEqual(obj.allow_keyword, expected.allow_keyword)
        self.assertEqual(obj.audit, expected.audit)
        self.assertEqual(obj.deny, expected.deny)
        self.assertEqual(obj.comment, expected.comment)

        self._assertEqual_aare(obj.path, expected.path)
        self.assertEqual(obj.perms, expected.perms)
        self.assertEqual(obj.exec_perms, expected.exec_perms)
        self._assertEqual_aare(obj.target, expected.target)
        self.assertEqual(obj.owner, expected.owner)
        self.assertEqual(obj.file_keyword, expected.file_keyword)
        self.assertEqual(obj.leading_perms, expected.leading_perms)

        # Note: there's no all_ field for exec_perms, owner, file_keyword and leading_perms
        self.assertEqual(obj.all_paths, expected.all_paths)
        self.assertEqual(obj.all_perms, expected.all_perms)
        self.assertEqual(obj.all_targets, expected.all_targets)

    def _assertEqual_aare(self, obj, expected):
        if obj:
            self.assertEqual(obj.regex, expected)
        else:
            self.assertEqual(obj, expected)


class FileTestParse(FileTest):
    tests = (
        # FileRule object                    audit  allow  deny   comment   path               all_paths  perms               all?   exec_perms  target  all?   owner  file keyword  leading perms

        # bare file rules
        ('file,',                        exp(False, False, False, '',       None,              True,      None,               True,  None,       None,   True,  False, False,        False)),
        ('allow file,',                  exp(False, True,  False, '',       None,              True,      None,               True,  None,       None,   True,  False, False,        False)),
        ('audit deny owner file, # cmt', exp(True,  False, True,  ' # cmt', None,              True,      None,               True,  None,       None,   True,  True,  False,        False)),

        # "normal" file rules
        ('/foo r,',                      exp(False, False, False, '',       '/foo',            False,     {'r'},              False, None,       None,   True,  False, False,        False)),
        ('file /foo rwix,',              exp(False, False, False, '',       '/foo',            False,     {'r', 'w'},         False, 'ix',       None,   True,  False, True,         False)),
        ('/foo Px -> bar,',              exp(False, False, False, '',       '/foo',            False,     set(),              False, 'Px',       'bar',  False, False, False,        False)),
        ('@{PROC}/[a-z]** mr,',          exp(False, False, False, '',       '@{PROC}/[a-z]**', False,     {'r', 'm'},         False, None,       None,   True,  False, False,        False)),

        ('audit /tmp/foo r,',            exp(True,  False, False, '',       '/tmp/foo',        False,     {'r'},              False, None,       None,   True,  False, False,        False)),
        ('audit deny /tmp/foo r,',       exp(True,  False, True,  '',       '/tmp/foo',        False,     {'r'},              False, None,       None,   True,  False, False,        False)),
        ('audit deny /tmp/foo rx,',      exp(True,  False, True,  '',       '/tmp/foo',        False,     {'r'},              False, 'x',        None,   True,  False, False,        False)),
        ('allow /tmp/foo ra,',           exp(False, True,  False, '',       '/tmp/foo',        False,     {'r', 'a'},         False, None,       None,   True,  False, False,        False)),
        ('audit allow /tmp/foo ra,',     exp(True,  True,  False, '',       '/tmp/foo',        False,     {'r', 'a'},         False, None,       None,   True,  False, False,        False)),


        # file rules with leading permission
        ('r /foo,',                      exp(False, False, False, '',       '/foo',            False,     {'r'},              False, None,       None,   True,  False, False,        True)),
        ('file rwix /foo,',              exp(False, False, False, '',       '/foo',            False,     {'r', 'w'},         False, 'ix',       None,   True,  False, True,         True)),
        ('Px /foo -> bar,',              exp(False, False, False, '',       '/foo',            False,     set(),              False, 'Px',       'bar',  False, False, False,        True)),
        ('mr @{PROC}/[a-z]**,',          exp(False, False, False, '',       '@{PROC}/[a-z]**', False,     {'r', 'm'},         False, None,       None,   True,  False, False,        True)),

        ('audit r /tmp/foo,',            exp(True,  False, False, '',       '/tmp/foo',        False,     {'r'},              False, None,       None,   True,  False, False,        True)),
        ('audit deny r /tmp/foo,',       exp(True,  False, True,  '',       '/tmp/foo',        False,     {'r'},              False, None,       None,   True,  False, False,        True)),
        ('allow ra /tmp/foo,',           exp(False, True,  False, '',       '/tmp/foo',        False,     {'r', 'a'},         False, None,       None,   True,  False, False,        True)),
        ('audit allow ra /tmp/foo,',     exp(True,  True,  False, '',       '/tmp/foo',        False,     {'r', 'a'},         False, None,       None,   True,  False, False,        True)),

        # duplicated (but not conflicting) permissions
        ('/foo PxPxPxPxrwPx -> bar,',    exp(False, False, False, '',       '/foo',            False,     {'r', 'w'},         False, 'Px',       'bar',  False, False, False,        False)),
        ('/foo CixCixrwCix -> bar, ',    exp(False, False, False, '',       '/foo',            False,     {'r', 'w'},         False, 'Cix',      'bar',  False, False, False,        False)),

        # link rules
        ('link /foo -> /bar,',           exp(False, False, False, '',       '/foo',            False,     {'link'},           False, None,       '/bar', False, False, False,        True)),
        ('link subset /foo -> /bar,',    exp(False, False, False, '',       '/foo',            False,     {'link', 'subset'}, False, None,       '/bar', False, False, False,        True)),
    )

    def _run_test(self, rawrule, expected):
        self.assertTrue(FileRule.match(rawrule))
        obj = FileRule.create_instance(rawrule)
        self.assertEqual(rawrule.strip(), obj.raw_rule)
        self._compare_obj(obj, expected)


class FileTestParseInvalid(FileTest):
    tests = (
        ('/foo x,',       AppArmorException),  # should be *x
        ('/foo raw,',     AppArmorException),  # r and a conflict
        ('deny /foo ix,', AppArmorException),  # endy only allows x, but not *x
        ('deny /foo Px,', AppArmorException),  # deny only allows x, but not *x
        ('deny /foo Pi,', AppArmorException),  # missing 'x', and P not allowed
        ('allow /foo x,', AppArmorException),  # should be *x
        ('/foo Pxrix,',   AppArmorException),  # exec mode conflict
        ('/foo PixUx,',   AppArmorException),  # exec mode conflict
        ('/foo PxUx,',    AppArmorException),  # exec mode conflict
        ('/foo PUxPix,',  AppArmorException),  # exec mode conflict
        ('/foo Pi,',      AppArmorException),  # missing 'x'
    )

    def _run_test(self, rawrule, expected):
        self.assertTrue(FileRule.match(rawrule))  # the above invalid rules still match the main regex!
        with self.assertRaises(expected):
            FileRule.create_instance(rawrule)


class FileTestNonMatch(AATest):
    tests = (
        ('file /foo,',        False),
        ('file rw,',          False),
        ('file -> bar,',      False),
        ('file Px -> bar,',   False),
        ('/foo bar,',         False),
        ('dbus /foo,',        False),
        ('link /foo,',        False),  # missing '-> /target'
        ('link -> /bar,',     False),  # missing path
        ('/foo -> bar link,', False),  # link has to be leading keyword
        ('link,',             False),  # link isn't available as bare keyword
    )

    def _run_test(self, rawrule, expected):
        self.assertFalse(FileRule.match(rawrule))


class FileTestParseFromLog(FileTest):
    def test_file_from_log(self):
        parser = ReadLog('', '', '')
        event = 'Nov 11 07:33:07 myhost kernel: [50812.879558] type=1502 audit(1236774787.169:369): operation="inode_permission" requested_mask="::r" denied_mask="::r" fsuid=1000 name="/bin/dash" pid=13726 profile="/bin/foobar"'

        parsed_event = parser.parse_event(event)

        self.assertEqual(parsed_event, {
            'request_mask': '::r',
            'denied_mask': '::r',
            'error_code': 0,
            'magic_token': 0,
            'parent': 0,
            'profile': '/bin/foobar',
            'operation': 'inode_permission',
            'name': '/bin/dash',
            'name2': None,
            'resource': None,
            'info': None,
            'aamode': 'PERMITTING',
            'time': 1236774787,
            'active_hat': None,
            'pid': 13726,
            'task': 0,
            'attr': None,
            'family': None,
            'protocol': None,
            'sock_type': None,
            'class': None,
        })

        #     FileRule path,                 perms,                         exec_perms, target,       owner, file_keyword, leading_perms
        # obj = FileRule(parsed_event['name'], parsed_event['denied_mask'],   None,       FileRule.ALL, False, False,        False,)
        obj = FileRule(parsed_event['name'], 'r',                           None,       FileRule.ALL, False, False,        False,)
        # XXX handle things like '::r'
        # XXX split off exec perms?

        #              audit  allow  deny   comment  path          all_paths  perms  all?   exec_perms  target  all?   owner  file keyword  leading perms
        expected = exp(False, False, False, '',      '/bin/dash',  False,     {'r'}, False, None,       None,   True,  False, False,        False)

        self._compare_obj(obj, expected)

        self.assertEqual(obj.get_raw(1), '  /bin/dash r,')


# TODO: add logparser example for link event

class FileFromInit(FileTest):
    tests = (

        #         path,    perms, exec_perms, target,       owner, file_keyword, leading_perms
        (FileRule('/foo', 'rw',   None,       FileRule.ALL, False, False,        False,       audit=True, deny=True),
                  #  audit  allow   deny  comment  path   all_paths perms       all?   exec_perms target all?  owner  file keyword  leading perms
                  exp(True,  False, True, '',     '/foo', False,    {'r', 'w'}, False, None,      None,  True, False, False,        False)),

        #         path,   perms, exec_perms, target,     owner, file_keyword, leading_perms
        (FileRule('/foo', None,  'Pix',      'bar_prof', True,  True,         True,        allow_keyword=True),
                  #   audit  allow  deny   comment  path     all_paths  perms  all?   exec_perms  target      all?   owner  file keyword  leading perms
                  exp(False, True,  False, '',      '/foo',  False,     set(), False, 'Pix',      'bar_prof', False, True,  True,         True)),

        #         path,   perms,              exec_perms, target, owner, file_keyword, leading_perms
        (FileRule('/foo', {'link', 'subset'}, None,       '/bar', False, False,        True,        audit=True, deny=True),
                  #   audit  allow  deny  comment  path    all_paths  perms               all?   exec_perms  target  all?   owner  file keyword leading perms
                  exp(True,  False, True, '',      '/foo', False,     {'link', 'subset'}, False, None,       '/bar', False, False, False,       True)),

    )

    def _run_test(self, obj, expected):
        self._compare_obj(obj, expected)


class InvalidFileInit(AATest):
    tests = (
        #       path,         perms,              exec_perms, target, owner,  file_keyword, leading_perms  expected exception

        # empty fields
        (      ('',           'rw',               'ix',       '/bar', False,  False,        False),        AppArmorBug),
        #  OK  ('/foo',       '',                 'ix',       '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               '',         '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '',     False,  False,        False),        AppArmorBug),

        # whitespace fields
        (      ('   ',        'rw',               'ix',       '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       '   ',              'ix',       '/bar', False,  False,        False),        AppArmorException),
        (      ('/foo',       'rw',               '   ',      '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '   ',  False,  False,        False),        AppArmorBug),

        # wrong type - dict()
        (      (dict(),       'rw',               'ix',       '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       dict(),             'ix',       '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               dict(),     '/bar', False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       dict(), False,  False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', dict(), False,        False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', False,  dict(),       False),        AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', False,  False,        dict()),       AppArmorBug),


        # wrong type - None
        (      (None,         'rw',               'ix',       '/bar', False,  False,        False),         AppArmorBug),
        #  OK  ('/foo',       None,               'ix',       '/bar', False,  False,        False),         AppArmorBug),
        #  OK  ('/foo',       'rw',               None,       '/bar', False,  False,        False),         AppArmorBug),
        (      ('/foo',       'rw',               'ix',       None,   False,  False,        False),         AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', None,   False,        False),         AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', False,  None,         False),         AppArmorBug),
        (      ('/foo',       'rw',               'ix',       '/bar', False,  False,        None),          AppArmorBug),


        # misc
        (      ('/foo',       'rwa',              'ix',       '/bar', False,  False,        False),        AppArmorException),  # 'r' and 'a' conflict
        (      ('/foo',       None,               'rw',       '/bar', False,  False,        False),        AppArmorBug),        # file perms in exec perms parameter
        (      ('/foo',       'ix',               None,       '/bar', False,  False,        False),        AppArmorBug),        # exec perms in file perms parameter
        (      ('foo',        'rw',               'ix',       '/bar', False,  False,        False),        AppArmorException),  # path doesn't start with /
        (      ('/foo',       'rb',               'ix',       '/bar', False,  False,        False),        AppArmorException),  # invalid file mode 'b' (str)
        (      ('/foo',       {'b'},              'ix',       '/bar', False,  False,        False),        AppArmorBug),        # invalid file mode 'b' (str)
        (      ('/foo',       'rw',               'ax',       '/bar', False,  False,        False),        AppArmorBug),        # invalid exec mode 'ax'
        (      ('/foo',       'rw',               'x',        '/bar', False,  False,        False),        AppArmorException),  # plain 'x' is only allowed in deny rules
        (      (FileRule.ALL, FileRule.ALL,       None,       '/bar', False,  False,        False),        AppArmorBug),        # plain 'file,' doesn't allow exec target

        # link rules
        (      (None,         {'link'},           None,       None,   False,  False,        False),        AppArmorBug),        # missing path and target
        (      ('/foo',       {'link'},           None,       None,   False,  False,        False),        AppArmorBug),        # missing target
        (      ( None,        {'link'},           None,       '/bar', False,  False,        False),        AppArmorBug),        # missing path
        (      ('/foo',       {'subset'},         None,       '/bar', False,  False,        False),        AppArmorBug),        # subset without link
        (      ('/foo',       {'link'},           'ix',       '/bar', False,  False,        False),        AppArmorBug),        # link rule with exec perms
        (      ('/foo',       {'link', 'subset'}, 'ix',       '/bar', False,  False,        False),        AppArmorBug),        # link subset rule with exec perms
    )

    def _run_test(self, params, expected):
        with self.assertRaises(expected):
            FileRule(*params)

    def test_missing_params_1(self):
        with self.assertRaises(TypeError):
            FileRule('/foo')

    def test_missing_params_2(self):
        with self.assertRaises(TypeError):
            FileRule('/foo', 'rw')

    def test_missing_params_3(self):
        with self.assertRaises(TypeError):
            FileRule('/foo', 'rw', 'ix')

    def test_missing_params_4(self):
        with self.assertRaises(TypeError):
            FileRule('/foo', 'rw', 'ix', '/bar')

    def test_deny_ix(self):
        with self.assertRaises(AppArmorException):
            FileRule('/foo', 'rw', 'ix', '/bar', False, False, False, deny=True)


class InvalidFileTest(AATest):
    def _check_invalid_rawrule(self, rawrule):
        obj = None
        self.assertFalse(FileRule.match(rawrule))
        with self.assertRaises(AppArmorException):
            obj = FileRule.create_instance(rawrule)

        self.assertIsNone(obj, 'FileRule handed back an object unexpectedly')

    def test_invalid_file_missing_comma_1(self):
        self._check_invalid_rawrule('file')  # missing comma

    def test_invalid_non_FileRule(self):
        self._check_invalid_rawrule('signal,')  # not a file rule


class BrokenFileTest(AATest):
    def AASetup(self):
        #                   path,   perms, exec_perms, target, owner, file_keyword, leading_perms
        self.obj = FileRule('/foo', 'rw',  'ix',       '/bar', False, False,        False)

    def test_empty_data_1(self):
        self.obj.path = ''
        # no path set, and ALL not set
        with self.assertRaises(AppArmorBug):
            self.obj.get_clean(1)

    def test_empty_data_2(self):
        self.obj.perms = ''
        self.obj.exec_perms = ''
        # no perms or exec_perms set, and ALL not set
        with self.assertRaises(AppArmorBug):
            self.obj.get_clean(1)

    def test_empty_data_3(self):
        self.obj.target = ''
        # no target set, and ALL not set
        with self.assertRaises(AppArmorBug):
            self.obj.get_clean(1)

    def test_unexpected_all_1(self):
        self.obj.all_paths = FileRule.ALL
        # all_paths and all_perms must be in sync
        with self.assertRaises(AppArmorBug):
            self.obj.get_clean(1)

    def test_unexpected_all_2(self):
        self.obj.all_perms = FileRule.ALL
        # all_paths and all_perms must be in sync
        with self.assertRaises(AppArmorBug):
            self.obj.get_clean(1)


class FileGlobTest(AATest):
    def _run_test(self, params, expected):
        exp_can_glob, exp_can_glob_ext, exp_rule_glob, exp_rule_glob_ext = expected

        # test glob()
        rule_obj = FileRule.create_instance(params)
        self.assertEqual(exp_can_glob, rule_obj.can_glob)
        self.assertEqual(exp_can_glob_ext, rule_obj.can_glob_ext)

        rule_obj.glob()
        self.assertEqual(rule_obj.get_clean(), exp_rule_glob)

        # test glob_ext()
        rule_obj = FileRule.create_instance(params)
        self.assertEqual(exp_can_glob, rule_obj.can_glob)
        self.assertEqual(exp_can_glob_ext, rule_obj.can_glob_ext)

        rule_obj.glob_ext()
        self.assertEqual(rule_obj.get_clean(), exp_rule_glob_ext)

    # These tests are meant to ensure AARE integration in FileRule works as expected.
    # test-aare.py has more comprehensive globbing tests.
    tests = (
        # rule               can glob  can glob_ext  globbed rule        globbed_ext rule
        ('/foo/bar r,',      (True,    True,         '/foo/* r,',        '/foo/bar r,')),
        ('/foo/* r,',        (True,    True,         '/** r,',           '/foo/* r,')),
        ('/foo/bar.xy r,',   (True,    True,         '/foo/* r,',        '/foo/*.xy r,')),
        ('/foo/*.xy r,',     (True,    True,         '/foo/* r,',        '/**.xy r,')),
        ('file,',            (False,   False,        'file,',            'file,')),  # bare 'file,' rules can't be globbed
        ('link /a/b -> /c,', (True,    True,         'link /a/* -> /c,', 'link /a/b -> /c,')),
    )


class WriteFileTest(AATest):
    def _run_test(self, rawrule, expected):
        self.assertTrue(FileRule.match(rawrule), 'FileRule.match() failed')
        obj = FileRule.create_instance(rawrule)
        clean = obj.get_clean()
        raw = obj.get_raw()

        self.assertEqual(expected.strip(), clean, 'unexpected clean rule')
        self.assertEqual(rawrule.strip(), raw, 'unexpected raw rule')

    tests = (
        #  raw rule                                      clean rule
        ('file,',                                        'file,'),
        ('              file        ,  # foo        ',   'file, # foo'),
        ('    audit     file /foo r,',                   'audit file /foo r,'),
        ('    audit     file /foo  lwr,',                'audit file /foo rwl,'),
        ('    audit     file /foo Pxrm -> bar,',         'audit file /foo mrPx -> bar,'),
        ('    deny      file /foo r,',                   'deny file /foo r,'),
        ('    deny      file /foo  wr,',                 'deny file /foo rw,'),
        ('    allow     file /foo Pxrm -> bar,',         'allow file /foo mrPx -> bar,'),
        ('    deny    owner  /foo r,',                   'deny owner /foo r,'),
        ('    deny    owner  /foo  wr,',                 'deny owner /foo rw,'),
        ('    allow   owner  /foo Pxrm -> bar,',         'allow owner /foo mrPx -> bar,'),
        ('                   /foo r,',                   '/foo r,'),
        ('                   /foo  lwr,',                '/foo rwl,'),
        ('                   /foo Pxrm -> bar,',         '/foo mrPx -> bar,'),

        # with leading permissions
        ('    audit     file r      /foo,',              'audit file r /foo,'),
        ('    audit     file lwr    /foo,',              'audit file rwl /foo,'),
        ('    audit     file Pxrm   /foo -> bar,',       'audit file mrPx /foo -> bar,'),
        ('    deny      file r      /foo,',              'deny file r /foo,'),
        ('    deny      file wr     /foo  ,',            'deny file rw /foo,'),
        ('    allow     file Pxmr   /foo -> bar,',       'allow file mrPx /foo -> bar,'),
        ('    deny    owner  r      /foo ,',             'deny owner r /foo,'),
        ('    deny    owner  wr     /foo  ,',            'deny owner rw /foo,'),
        ('    allow   owner  Pxrm   /foo -> bar,',       'allow owner mrPx /foo -> bar,'),
        ('                   r      /foo ,',             'r /foo,'),
        ('                   klwr   /foo  ,',            'rwlk /foo,'),
        ('                   Pxrm   /foo -> bar,',       'mrPx /foo -> bar,'),

        # link rules
        ('  link    /foo    ->  /bar,',                  'link /foo -> /bar,'),
        ('  audit deny owner link subset /foo -> /bar,', 'audit deny owner link subset /foo -> /bar,'),
        ('                   link subset /foo -> /bar,', 'link subset /foo -> /bar,')
    )

    def test_write_manually_1(self):
        #              path,   perms, exec_perms, target, owner, file_keyword, leading_perms
        obj = FileRule('/foo', 'rw',  'Px',       '/bar', False, True,         False,       allow_keyword=True)

        expected = '    allow file /foo rwPx -> /bar,'

        self.assertEqual(expected, obj.get_clean(2), 'unexpected clean rule')
        self.assertEqual(expected, obj.get_raw(2), 'unexpected raw rule')

    def test_write_manually_2(self):
        #              path,   perms, exec_perms, target,       owner, file_keyword, leading_perms
        obj = FileRule('/foo', 'rw',  'x',        FileRule.ALL, True,  False,        True,        deny=True)

        expected = '    deny owner rwx /foo,'

        self.assertEqual(expected, obj.get_clean(2), 'unexpected clean rule')
        self.assertEqual(expected, obj.get_raw(2), 'unexpected raw rule')

    def test_write_any_exec(self):
        obj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, '/bar', False, False, False)
        with self.assertRaises(AppArmorBug):
            obj.get_clean()


class FileCoveredTest(AATest):
    def _run_test(self, param, expected):
        obj = FileRule.create_instance(self.rule)
        check_obj = FileRule.create_instance(param)

        self.assertTrue(FileRule.match(param))

        self.assertEqual(obj.is_equal(check_obj), expected[0], 'Mismatch in is_equal, expected {}'.format(expected[0]))
        self.assertEqual(obj.is_equal(check_obj, True), expected[1], 'Mismatch in is_equal/strict, expected {}'.format(expected[1]))

        self.assertEqual(obj.is_covered(check_obj), expected[2], 'Mismatch in is_covered, expected {}'.format(expected[2]))
        self.assertEqual(obj.is_covered(check_obj, True, True), expected[3], 'Mismatch in is_covered/exact, expected {}'.format(expected[3]))


class FileCoveredTest_01(FileCoveredTest):
    rule = 'file /foo r,'
tests = (
    #  rule                      equal  strict equal  covered  covered exact
    ('file /foo r,',            (True,  True,         True,    True)),
    ('file /foo r ,',           (True,  False,        True,    True)),
    ('allow file /foo r,',      (True,  False,        True,    True)),
    ('allow /foo r, # comment', (True,  False,        True,    True)),
    ('allow owner /foo r,',     (False, False,        True,    True)),
    ('/foo r -> bar,',          (False, False,        True,    True)),
    ('file r /foo,',            (True,  False,        True,    True)),
    ('allow file r /foo,',      (True,  False,        True,    True)),
    ('allow r /foo, # comment', (True,  False,        True,    True)),
    ('allow owner r /foo,',     (False, False,        True,    True)),
    ('r /foo -> bar,',          (False, False,        True,    True)),
    ('file,',                   (False, False,        False,   False)),
    ('file /foo w,',            (False, False,        False,   False)),
    ('file /foo rw,',           (False, False,        False,   False)),
    ('file /bar r,',            (False, False,        False,   False)),
    ('audit /foo r,',           (False, False,        False,   False)),
    ('audit file,',             (False, False,        False,   False)),
    ('audit deny /foo r,',      (False, False,        False,   False)),
    ('deny file /foo r,',       (False, False,        False,   False)),
    ('/foo rPx,',               (False, False,        False,   False)),
    ('/foo Pxr,',               (False, False,        False,   False)),
    ('/foo Px,',                (False, False,        False,   False)),
    ('/foo ix,',                (False, False,        False,   False)),
    ('/foo ix -> bar,',         (False, False,        False,   False)),
    ('/foo rPx -> bar,',        (False, False,        False,   False)),
)


class FileCoveredTest_02(FileCoveredTest):
    rule = 'audit /foo r,'

    tests = (
        #  rule                      equal  strict equal  covered  covered exact
        ('file /foo r,',            (False, False,        True,    False)),
        ('allow file /foo r,',      (False, False,        True,    False)),
        ('allow /foo r, # comment', (False, False,        True,    False)),
        ('allow owner /foo r,',     (False, False,        True,    False)),
        ('/foo r -> bar,',          (False, False,        True,    False)),
        ('file r /foo,',            (False, False,        True,    False)),
        ('allow file r /foo,',      (False, False,        True,    False)),
        ('allow r /foo, # comment', (False, False,        True,    False)),
        ('allow owner r /foo,',     (False, False,        True,    False)),
        ('r /foo -> bar,',          (False, False,        True,    False)),  # XXX exact
        ('file,',                   (False, False,        False,   False)),
        ('file /foo w,',            (False, False,        False,   False)),
        ('file /foo rw,',           (False, False,        False,   False)),
        ('file /bar r,',            (False, False,        False,   False)),
        ('audit /foo r,',           (True,  True,         True,    True)),
        ('audit file,',             (False, False,        False,   False)),
        ('audit deny /foo r,',      (False, False,        False,   False)),
        ('deny file /foo r,',       (False, False,        False,   False)),
        ('/foo rPx,',               (False, False,        False,   False)),
        ('/foo Pxr,',               (False, False,        False,   False)),
        ('/foo Px,',                (False, False,        False,   False)),
        ('/foo ix,',                (False, False,        False,   False)),
        ('/foo ix -> bar,',         (False, False,        False,   False)),
        ('/foo rPx -> bar,',        (False, False,        False,   False)),
    )


class FileCoveredTest_03(FileCoveredTest):
    rule = '/foo mrwPx,'

    tests = (
        #  rule                      equal  strict equal  covered  covered exact
        ('file /foo r,',            (False, False,        True,    True)),
        ('allow file /foo r,',      (False, False,        True,    True)),
        ('allow /foo r, # comment', (False, False,        True,    True)),
        ('allow owner /foo r,',     (False, False,        True,    True)),
        ('/foo r -> bar,',          (False, False,        True,    True)),
        ('file r /foo,',            (False, False,        True,    True)),
        ('allow file r /foo,',      (False, False,        True,    True)),
        ('allow r /foo, # comment', (False, False,        True,    True)),
        ('allow owner r /foo,',     (False, False,        True,    True)),
        ('r /foo -> bar,',          (False, False,        True,    True)),
        ('file,',                   (False, False,        False,   False)),
        ('file /foo w,',            (False, False,        True,    True)),
        ('file /foo rw,',           (False, False,        True,    True)),
        ('file /bar r,',            (False, False,        False,   False)),
        ('audit /foo r,',           (False, False,        False,   False)),
        ('audit file,',             (False, False,        False,   False)),
        ('audit deny /foo r,',      (False, False,        False,   False)),
        ('deny file /foo r,',       (False, False,        False,   False)),
        ('/foo mrwPx,',             (True,  True,         True,    True)),
        ('/foo wPxrm,',             (True,  False,        True,    True)),
        ('/foo rm,',                (False, False,        True,    True)),
        ('/foo Px,',                (False, False,        True,    True)),
        ('/foo ix,',                (False, False,        False,   False)),
        ('/foo ix -> bar,',         (False, False,        False,   False)),
        ('/foo mrwPx -> bar,',      (False, False,        False,   False)),
    )


class FileCoveredTest_04(FileCoveredTest):
    rule = '/foo mrwPx -> bar,'

    tests = (
        #  rule                      equal  strict equal  covered  covered exact
        ('file /foo r,',            (False, False,        True,    True)),
        ('allow file /foo r,',      (False, False,        True,    True)),
        ('allow /foo r, # comment', (False, False,        True,    True)),
        ('allow owner /foo r,',     (False, False,        True,    True)),
        ('/foo r -> bar,',          (False, False,        True,    True)),
        ('file r /foo,',            (False, False,        True,    True)),
        ('allow file r /foo,',      (False, False,        True,    True)),
        ('allow r /foo, # comment', (False, False,        True,    True)),
        ('allow owner r /foo,',     (False, False,        True,    True)),
        ('r /foo -> bar,',          (False, False,        True,    True)),
        ('file,',                   (False, False,        False,   False)),
        ('file /foo w,',            (False, False,        True,    True)),
        ('file /foo rw,',           (False, False,        True,    True)),
        ('file /bar r,',            (False, False,        False,   False)),
        ('audit /foo r,',           (False, False,        False,   False)),
        ('audit file,',             (False, False,        False,   False)),
        ('audit deny /foo r,',      (False, False,        False,   False)),
        ('deny file /foo r,',       (False, False,        False,   False)),
        ('/foo mrwPx,',             (False, False,        False,   False)),
        ('/foo wPxrm,',             (False, False,        False,   False)),
        ('/foo rm,',                (False, False,        True,    True)),
        ('/foo Px,',                (False, False,        False,   False)),
        ('/foo ix,',                (False, False,        False,   False)),
        ('/foo ix -> bar,',         (False, False,        False,   False)),
        ('/foo mrwPx -> bar,',      (True,  True,         True,    True)),
    )


class FileCoveredTest_05(FileCoveredTest):
    rule = 'file,'

    tests = (
        #   rule                     equal  strict equal  covered  covered exact
        ('file /foo r,',            (False, False,        True,    True)),
        ('allow file /foo r,',      (False, False,        True,    True)),
        ('allow /foo r, # comment', (False, False,        True,    True)),
        ('allow owner /foo r,',     (False, False,        True,    True)),
        ('/foo r -> bar,',          (False, False,        True,    True)),
        ('file r /foo,',            (False, False,        True,    True)),
        ('allow file r /foo,',      (False, False,        True,    True)),
        ('allow r /foo, # comment', (False, False,        True,    True)),
        ('allow owner r /foo,',     (False, False,        True,    True)),
        ('r /foo -> bar,',          (False, False,        True,    True)),
        ('file,',                   (True,  True,         True,    True)),
        ('file /foo w,',            (False, False,        True,    True)),
        ('file /foo rw,',           (False, False,        True,    True)),
        ('file /bar r,',            (False, False,        True,    True)),
        ('audit /foo r,',           (False, False,        False,   False)),
        ('audit file,',             (False, False,        False,   False)),
        ('audit deny /foo r,',      (False, False,        False,   False)),
        ('deny file /foo r,',       (False, False,        False,   False)),
        ('/foo mrwPx,',             (False, False,        False,   False)),
        ('/foo wPxrm,',             (False, False,        False,   False)),
        ('/foo rm,',                (False, False,        True,    True)),
        ('/foo Px,',                (False, False,        False,   False)),
        ('/foo ix,',                (False, False,        False,   False)),
        ('/foo ix -> bar,',         (False, False,        False,   False)),
        ('/foo mrwPx -> bar,',      (False, False,        False,   False)),
    )


class FileCoveredTest_06(FileCoveredTest):
    rule = 'deny /foo w,'

    tests = (
        #   rule          equal  strict equal  covered  covered exact
        ('/foo w,',      (False, False,        False,   False)),
        ('/foo a,',      (False, False,        False,   False)),
        ('deny /foo w,', (True,  True,         True,    True)),
        ('deny /foo a,', (False, False,        True,    True)),
    )


class FileCoveredTest_07(FileCoveredTest):
    rule = '/foo w,'

    tests = (
        #   rule          equal  strict equal  covered  covered exact
        ('/foo w,',      (True,  True,         True,    True)),
        ('/foo a,',      (False, False,        True,    True)),
        ('deny /foo w,', (False, False,        False,   False)),
        ('deny /foo a,', (False, False,        False,   False)),
    )


class FileCoveredTest_08(FileCoveredTest):
    rule = 'link /foo -> /bar,'

    tests = (
        #   rule                        equal  strict equal  covered  covered exact
        ('link /foo -> /bar,',        (True,  True,          True,    True)),
        ('link /asdf -> /bar,',       (False, False,         False,   False)),
        ('link /foo -> /asdf,',       (False, False,         False,   False)),
        ('deny link /foo -> /bar,',   (False, False,         False,   False)),
        ('deny link /foo -> /bar,',   (False, False,         False,   False)),
        ('link subset /foo -> /bar,', (False, False,         True,    True)),  # subset makes the rule more strict
        # ('/foo l -> /bar,',           (?,     ?,             ?,       ?)),  # TODO
        # ('l /foo -> /bar,',           (?,     ?,             ?,       ?)),  # TODO
    )


class FileCoveredTest_09(FileCoveredTest):
    rule = 'link subset /foo -> /bar,'
    tests = (
        #   rule                            equal  strict equal  covered  covered exact
        ('link subset /foo -> /bar,',      (True,  True,         True,    True)),
        ('link subset /asdf -> /bar,',     (False, False,        False,   False)),
        ('link subset /foo -> /asdf,',     (False, False,        False,   False)),
        ('deny link subset /foo -> /bar,', (False, False,        False,   False)),
        ('deny link subset /foo -> /bar,', (False, False,        False,   False)),
        ('link /foo -> /bar,',             (False, False,        False,   False)),  # no subset means more permissions
        # ('/foo l -> /bar,',                (?,     ?,            ?,       ?)),  # TODO
        # ('l /foo -> /bar,',                (?,     ?,            ?,       ?)),  # TODO
    )


class FileCoveredTest_ManualOrInvalid(AATest):
    def AASetup(self):
        #                   path,   perms, exec_perms, target, owner, file_keyword, leading_perms
        self.obj = FileRule('/foo', 'rw',  'ix',       '/bar', False, False,        False)
        self.testobj = FileRule('/foo', 'rw', 'ix', '/bar', False, False, False)

    def test_covered_owner_1(self):
        # testobj with 'owner'
        self.testobj = FileRule('/foo', 'rw', 'ix', '/bar', True, False, False)
        self.assertTrue(self.obj.is_covered(self.testobj))

    def test_covered_owner_2(self):
        # obj with 'owner'
        self.obj = FileRule('/foo', 'rw', 'ix', '/bar', True, False, False)
        self.assertFalse(self.obj.is_covered(self.testobj))

    def test_equal_all_perms(self):
        self.testobj.all_perms = True  # that makes testobj invalid, but that's the only way to survive the 'perms' comparison
        self.assertFalse(self.obj.is_equal(self.testobj))

    def test_equal_file_keyword(self):
        # testobj with file_keyword
        self.testobj = FileRule('/foo', 'rw', 'ix', '/bar', False, True, False)
        self.assertTrue(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_equal_file_leading_perms(self):
        # testobj with leading_perms
        self.testobj = FileRule('/foo', 'rw', 'ix', '/bar', False, False, True)
        self.assertTrue(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_1(self):
        self.obj = FileRule('/foo', 'rw', None, '/bar', False, False, False)
        self.testobj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, '/bar', False, False, False)
        self.assertFalse(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_2(self):
        self.testobj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, '/bar', False, False, False)
        self.assertTrue(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_3(self):
        # make sure a different exec target gets ignored with ANY_EXEC
        self.testobj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, '/xyz', False, False, False)
        self.assertTrue(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_4(self):
        # make sure a different exec target gets ignored with ANY_EXEC
        self.testobj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, FileRule.ALL, False, False, False)
        self.assertTrue(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_5(self):
        # even with ANY_EXEC, a different link target causes a mismatch
        self.testobj = FileRule('/foo', 'rwl', FileRule.ANY_EXEC, '/xyz', False, False, False)
        self.assertFalse(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_6(self):
        # even with ANY_EXEC, a different link target causes a mismatch
        self.testobj = FileRule('/foo', 'rwl', FileRule.ANY_EXEC, FileRule.ALL, False, False, False)
        self.assertFalse(self.obj.is_covered(self.testobj))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_covered_anyperm_7(self):
        self.obj = FileRule('/foo', 'rw', 'x', '/bar', False, False, False, deny=True)
        self.testobj = FileRule('/foo', 'rw', FileRule.ANY_EXEC, '/bar', False, False, False)
        self.assertFalse(self.obj.is_covered(self.testobj))
        self.assertTrue(self.obj.is_covered(self.testobj, check_allow_deny=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=False))
        self.assertFalse(self.obj.is_equal(self.testobj, strict=True))

    def test_borked_obj_is_covered_1(self):
        self.testobj.path = ''

        with self.assertRaises(AppArmorBug):
            self.obj.is_covered(self.testobj)

    def test_borked_obj_is_covered_2(self):
        self.testobj.perms = set()
        self.testobj.exec_perms = ''

        with self.assertRaises(AppArmorBug):
            self.obj.is_covered(self.testobj)

    def test_borked_obj_is_covered_3(self):
        self.testobj.target = ''

        with self.assertRaises(AppArmorBug):
            self.obj.is_covered(self.testobj)

    def test_invalid_is_covered(self):
        raw_rule = 'file,'
        class SomeOtherClass(FileRule):
            pass

        obj = FileRule.create_instance(raw_rule)
        testobj = SomeOtherClass.create_instance(raw_rule)  # different type
        with self.assertRaises(AppArmorBug):
            obj.is_covered(testobj)

    def test_invalid_is_equal(self):
        raw_rule = 'file,'
        class SomeOtherClass(FileRule):
            pass

        obj = FileRule.create_instance(raw_rule)
        testobj = SomeOtherClass.create_instance(raw_rule)  # different type
        with self.assertRaises(AppArmorBug):
            obj.is_equal(testobj)


class FileSeverityTest(AATest):
    tests = (
        ('/usr/bin/whatis ix,',  5),
        ('/etc ix,',             'unknown'),
        ('/dev/doublehit ix,',   0),
        ('/dev/doublehit rix,',  4),
        ('/dev/doublehit rwix,', 8),
        ('/dev/tty10 rwix,',     9),
        ('/var/adm/foo/** rix,', 3),
        ('/etc/apparmor/** r,',  6),
        ('/etc/** r,',           'unknown'),
        ('/usr/foo@bar r,',      'unknown'),  # filename containing @
        ('/home/foo@bar rw,',    6),  # filename containing @
        ('file,',                'unknown'),  # bare file rule XXX should return maximum severity
    )

    def _run_test(self, params, expected):
        sev_db = severity.Severity('../severity.db', 'unknown')
        obj = FileRule.create_instance(params)
        rank = obj.severity(sev_db)
        self.assertEqual(rank, expected)


class FileLogprofHeaderTest(AATest):
    tests = (
        # log event                        old perms ALL / owner
        (('file,',                             set(),    set()),     [                              _('Path'), _('ALL'),                                _('New Mode'), _('ALL')]),
        (('/foo r,',                           set(),    set()),     [                              _('Path'), '/foo',                                  _('New Mode'), 'r']),
        (('file /bar Px -> foo,',              set(),    set()),     [                              _('Path'), '/bar',                                  _('New Mode'), 'Px -> foo']),
        (('deny file,',                        set(),    set()),     [_('Qualifier'), 'deny',       _('Path'), _('ALL'),                                _('New Mode'), _('ALL')]),
        (('allow file /baz rwk,',              set(),    set()),     [_('Qualifier'), 'allow',      _('Path'), '/baz',                                  _('New Mode'), 'rwk']),
        (('audit file /foo mr,',               set(),    set()),     [_('Qualifier'), 'audit',      _('Path'), '/foo',                                  _('New Mode'), 'mr']),
        (('audit deny /foo wk,',               set(),    set()),     [_('Qualifier'), 'audit deny', _('Path'), '/foo',                                  _('New Mode'), 'wk']),
        (('owner file /foo ix,',               set(),    set()),     [                              _('Path'), '/foo',                                  _('New Mode'), 'owner ix']),
        (('audit deny file /foo rlx -> /baz,', set(),    set()),     [_('Qualifier'), 'audit deny', _('Path'), '/foo',                                  _('New Mode'), 'rlx -> /baz']),
        (('/foo rw,',                          set('r'), set()),     [                              _('Path'), '/foo', _('Old Mode'), _('r'),           _('New Mode'), _('rw')]),
        (('/foo rw,',                          set(),    set('rw')), [                              _('Path'), '/foo', _('Old Mode'), _('owner rw'),    _('New Mode'), _('rw')]),
        (('/foo mrw,',                         set('r'), set('k')),  [                              _('Path'), '/foo', _('Old Mode'), _('r + owner k'), _('New Mode'), _('mrw')]),
        (('/foo mrw,',                         set('r'), set('rk')), [                              _('Path'), '/foo', _('Old Mode'), _('r + owner k'), _('New Mode'), _('mrw')]),
        (('link /foo -> /bar,',                set(),    set()),     [                              _('Path'), '/foo',                                  _('New Mode'), 'link -> /bar']),
        (('link subset /foo -> /bar,',         set(),    set()),     [                              _('Path'), '/foo',                                  _('New Mode'), 'link subset -> /bar']),
    )

    def _run_test(self, params, expected):
        obj = FileRule.create_instance(params[0])
        if params[1] or params[2]:
            obj.original_perms = {'allow': {'all': params[1], 'owner': params[2]}}
        self.assertEqual(obj.logprof_header(), expected)

    def test_empty_original_perms(self):
        obj = FileRule.create_instance('/foo rw,')
        obj.original_perms = {'allow': {'all': set(), 'owner': set()}}
        self.assertEqual(obj.logprof_header(), [_('Path'), '/foo', _('New Mode'), _('rw')])


class FileEditHeaderTest(AATest):
    def _run_test(self, params, expected):
        rule_obj = FileRule.create_instance(params)
        self.assertEqual(rule_obj.can_edit, True)
        prompt, path_to_edit = rule_obj.edit_header()
        self.assertEqual(path_to_edit, expected)

    tests = (
        ('/foo/bar/baz r,',       '/foo/bar/baz'),
        ('/foo/**/baz r,',        '/foo/**/baz'),
        ('link /foo/** -> /bar,', '/foo/**'),
    )

    def test_edit_header_bare_file(self):
        rule_obj = FileRule.create_instance('file,')
        self.assertEqual(rule_obj.can_edit, False)
        with self.assertRaises(AppArmorBug):
            rule_obj.edit_header()


class FileValidateAndStoreEditTest(AATest):
    def _run_test(self, params, expected):
        rule_obj = FileRule('/foo/bar/baz', 'r', None, FileRule.ALL, False, False, False, log_event=True)

        self.assertEqual(rule_obj.validate_edit(params), expected)

        rule_obj.store_edit(params)
        self.assertEqual(rule_obj.get_raw(), params + ' r,')

    tests = (
        # edited path     match
        ('/foo/bar/baz',  True),
        ('/foo/bar/*',    True),
        ('/foo/bar/???',  True),
        ('/foo/xy**',     False),
        ('/foo/bar/baz/', False),
    )

    def test_validate_not_a_path(self):
        rule_obj = FileRule.create_instance('/foo/bar/baz r,')

        with self.assertRaises(AppArmorException):
            rule_obj.validate_edit('foo/bar/baz')

        with self.assertRaises(AppArmorException):
            rule_obj.store_edit('foo/bar/baz')

    def test_validate_edit_bare_file(self):
        rule_obj = FileRule.create_instance('file,')
        self.assertEqual(rule_obj.can_edit, False)

        with self.assertRaises(AppArmorBug):
            rule_obj.validate_edit('/foo/bar')

        with self.assertRaises(AppArmorBug):
            rule_obj.store_edit('/foo/bar')


## --- tests for FileRuleset --- #

class FileRulesTest(AATest):
    def test_empty_ruleset(self):
        ruleset = FileRuleset()
        ruleset_2 = FileRuleset()
        self.assertEqual([], ruleset.get_raw(2))
        self.assertEqual([], ruleset.get_clean(2))
        self.assertEqual([], ruleset_2.get_raw(2))
        self.assertEqual([], ruleset_2.get_clean(2))

    def test_ruleset_1(self):
        ruleset = FileRuleset()
        rules = [
            '         file             ,        ',
            '   file /foo rw,',
            '  file /bar r,',
        ]

        expected_raw = [
            'file             ,',
            'file /foo rw,',
            'file /bar r,',
            '',
        ]

        expected_clean = [
            'file /bar r,',
            'file /foo rw,',
            'file,',
            '',
        ]

        deleted = 0
        for rule in rules:
            deleted += ruleset.add(FileRule.create_instance(rule))

        self.assertEqual(deleted, 0)
        self.assertEqual(expected_raw, ruleset.get_raw())
        self.assertEqual(expected_clean, ruleset.get_clean())

    def test_ruleset_2(self):
        ruleset = FileRuleset()
        rules = [
            '/foo Px,',
            '/bar    Cx    ->     bar_child ,',
            'deny /asdf w,',
        ]

        expected_raw = [
            '  /foo Px,',
            '  /bar    Cx    ->     bar_child ,',
            '  deny /asdf w,',
            '',
        ]

        expected_clean = [
            '  deny /asdf w,',
            '',
            '  /bar Cx -> bar_child,',
            '  /foo Px,',
            '',
        ]

        deleted = 0
        for rule in rules:
            deleted += ruleset.add(FileRule.create_instance(rule))

        self.assertEqual(deleted, 0)
        self.assertEqual(expected_raw, ruleset.get_raw(1))
        self.assertEqual(expected_clean, ruleset.get_clean(1))

    def test_ruleset_cleanup_add_1(self):
        ruleset = FileRuleset()
        rules = [
            '/foo/bar r,',
            '/foo/baz rw,',
            '/foo/baz rwk,',
        ]

        rules_with_cleanup = [
            '/foo/* r,',
        ]

        expected_raw = [
            '  /foo/baz rw,',
            '  /foo/baz rwk,',
            '  /foo/* r,',
            '',
        ]

        expected_clean = [
            '  /foo/* r,',
            '  /foo/baz rw,',
            '  /foo/baz rwk,',
            '',
        ]

        deleted = 0
        for rule in rules:
            deleted += ruleset.add(FileRule.create_instance(rule))

        self.assertEqual(deleted, 0)  # rules[] are added without cleanup mode, so the superfluous '/foo/baz rw,' should be kept

        for rule in rules_with_cleanup:
            deleted += ruleset.add(FileRule.create_instance(rule), cleanup=True)

        self.assertEqual(deleted, 1)  # rules_with_cleanup made '/foo/bar r,' superfluous
        self.assertEqual(expected_raw, ruleset.get_raw(1))
        self.assertEqual(expected_clean, ruleset.get_clean(1))


# class FileDeleteTest(AATest):
#     pass


class FileGetRulesForPath(AATest):
    tests = (
        #  path                                 audit  deny    expected
        (('/etc/foo/dovecot.conf',              False, False), ['/etc/foo/* r,', '/etc/foo/dovecot.conf rw,',                                 '']),
        (('/etc/foo/foo.conf',                  False, False), ['/etc/foo/* r,',                                                              '']),
        (('/etc/foo/dovecot-database.conf.ext', False, False), ['/etc/foo/* r,', '/etc/foo/dovecot-database.conf.ext w,',                     '']),
        (('/etc/foo/auth.d/authfoo.conf',       False, False), ['/etc/foo/{auth,conf}.d/*.conf r,', '/etc/foo/{auth,conf}.d/authfoo.conf w,', '']),
        (('/etc/foo/dovecot-deny.conf',         False, False), ['deny /etc/foo/dovecot-deny.conf r,', '', '/etc/foo/* r,',                    '']),
        (('/foo/bar',                           False, True),  [                                                                                ]),
        (('/etc/foo/dovecot-deny.conf',         False, True),  ['deny /etc/foo/dovecot-deny.conf r,',                                         '']),
        (('/etc/foo/foo.conf',                  False, True),  [                                                                                ]),
        (('/etc/foo/owner.conf',                False, False), ['/etc/foo/* r,', 'owner /etc/foo/owner.conf w,',                              '']),
    )

    def _run_test(self, params, expected):
        rules = (
            '/etc/foo/* r,',
            '/etc/foo/dovecot.conf rw,',
            '/etc/foo/{auth,conf}.d/*.conf r,',
            '/etc/foo/{auth,conf}.d/authfoo.conf w,',
            '/etc/foo/dovecot-database.conf.ext w,',
            'owner /etc/foo/owner.conf w,',
            'deny /etc/foo/dovecot-deny.conf r,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        matching = ruleset.get_rules_for_path(*params)
        self. assertEqual(matching.get_clean(), expected)


class FileGetPermsForPath_1(AATest):
    tests = (
        #  path                                 audit   deny    expected
        (('/etc/foo/dovecot.conf',              False,  False), {'allow': {'all': {'r', 'w'}, 'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot.conf'}}),
        (('/etc/foo/foo.conf',                  False,  False), {'allow': {'all': {'r'},      'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': {'/etc/foo/*'}}),
        (('/etc/foo/dovecot-database.conf.ext', False,  False), {'allow': {'all': {'r', 'w'}, 'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot-database.conf.ext'}}),
        (('/etc/foo/auth.d/authfoo.conf',       False,  False), {'allow': {'all': {'r', 'w'}, 'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': {'/etc/foo/{auth,conf}.d/*.conf', '/etc/foo/{auth,conf}.d/authfoo.conf'}}),
        (('/etc/foo/dovecot-deny.conf',         False,  False), {'allow': {'all': {'r'},      'owner': set()}, 'deny': {'all': {'r'}, 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot-deny.conf'}}),
        (('/foo/bar',                           False,  True),  {'allow': {'all': set(),      'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': set()}),
        (('/etc/foo/dovecot-deny.conf',         False,  True),  {'allow': {'all': set(),      'owner': set()}, 'deny': {'all': {'r'}, 'owner': set()}, 'paths': {'/etc/foo/dovecot-deny.conf'}}),
        (('/etc/foo/foo.conf',                  False,  True),  {'allow': {'all': set(),      'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': set()}),
        (('/usr/lib/dovecot/config',            False,  False), {'allow': {'all': set(),      'owner': set()}, 'deny': {'all': set(), 'owner': set()}, 'paths': set()}),  # exec perms are not honored by get_perms_for_path()
    )

    def _run_test(self, params, expected):
        rules = (
            '/etc/foo/* r,',
            '/etc/foo/dovecot.conf rw,',
            '/etc/foo/{auth,conf}.d/*.conf r,',
            '/etc/foo/{auth,conf}.d/authfoo.conf w,',
            '/etc/foo/dovecot-database.conf.ext w,',
            'deny /etc/foo/dovecot-deny.conf r,',
            '/usr/lib/dovecot/config ix,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        perms = ruleset.get_perms_for_path(*params)
        self. assertEqual(perms, expected)


class FileGetPermsForPath_2(AATest):
    tests = (
        #  path                                 audit   deny    expected
        (('/etc/foo/dovecot.conf',              False,  False), {'allow': {'all': FileRule.ALL, 'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot.conf'}}),
        (('/etc/foo/dovecot.conf',              True,   False), {'allow': {'all': {'r', 'w'},   'owner': set()}, 'deny': {'all': set(),        'owner': set()}, 'paths': {'/etc/foo/dovecot.conf'}}),
        (('/etc/foo/foo.conf',                  False,  False), {'allow': {'all': FileRule.ALL, 'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/*'}}),
        (('/etc/foo/dovecot-database.conf.ext', False,  False), {'allow': {'all': FileRule.ALL, 'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot-database.conf.ext'}}),
        (('/etc/foo/auth.d/authfoo.conf',       False,  False), {'allow': {'all': FileRule.ALL, 'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/{auth,conf}.d/*.conf', '/etc/foo/{auth,conf}.d/authfoo.conf'}}),
        (('/etc/foo/auth.d/authfoo.conf',       True,   False), {'allow': {'all': {'w'},        'owner': set()}, 'deny': {'all': set(),        'owner': set()}, 'paths': {'/etc/foo/{auth,conf}.d/authfoo.conf'}}),
        (('/etc/foo/dovecot-deny.conf',         False,  False), {'allow': {'all': FileRule.ALL, 'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/*', '/etc/foo/dovecot-deny.conf'}}),
        (('/foo/bar',                           False,  True),  {'allow': {'all': set(),        'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': set()}),
        (('/etc/foo/dovecot-deny.conf',         False,  True),  {'allow': {'all': set(),        'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/dovecot-deny.conf'}}),
        (('/etc/foo/foo.conf',                  False,  True),  {'allow': {'all': set(),        'owner': set()}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': set()}),
        # (('/etc/foo/owner.conf',                False,  True),  {'allow': {'all': set(),        'owner': {'w'}}, 'deny': {'all': FileRule.ALL, 'owner': set()}, 'paths': {'/etc/foo/owner.conf'}}), # XXX doesn't work yet
    )

    def _run_test(self, params, expected):
        rules = (
            '/etc/foo/* r,',
            'audit /etc/foo/dovecot.conf rw,',
            '/etc/foo/{auth,conf}.d/*.conf r,',
            'audit /etc/foo/{auth,conf}.d/authfoo.conf w,',
            '/etc/foo/dovecot-database.conf.ext w,',
            'deny /etc/foo/dovecot-deny.conf r,',
            'file,',
            'owner /etc/foo/owner.conf w,',
            'deny file,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        perms = ruleset.get_perms_for_path(*params)
        self. assertEqual(perms, expected)


class FileGetExecRulesForPath_1(AATest):
    tests = (
        ('/bin/foo', ['audit /bin/foo ix,', '']),
        ('/bin/bar', ['deny /bin/bar x,', '']),
        ('/foo', []),
    )

    def _run_test(self, params, expected):
        rules = (
            '/foo r,',
            'audit /bin/foo ix,',
            '/bin/b* Px,',
            'deny /bin/bar x,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        perms = ruleset.get_exec_rules_for_path(params)
        matches = perms.get_clean()
        self. assertEqual(matches, expected)


class FileGetExecRulesForPath_2(AATest):
    tests = (
        ('/bin/foo', ['audit /bin/foo ix,', '']),
        ('/bin/bar', ['deny /bin/bar x,', '', '/bin/b* Px,', '']),
        ('/foo', []),
    )

    def _run_test(self, params, expected):
        rules = (
            '/foo r,',
            'audit /bin/foo ix,',
            '/bin/b* Px,',
            'deny /bin/bar x,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        perms = ruleset.get_exec_rules_for_path(params, only_exact_matches=False)
        matches = perms.get_clean()
        self. assertEqual(matches, expected)


class FileGetExecConflictRules_1(AATest):
    tests = (
        ('/bin/foo ix,', ['/bin/foo Px,', '']),
        ('/bin/bar Px,', ['deny /bin/bar x,', '', '/bin/bar cx,', '']),
        ('/bin/bar cx,', ['deny /bin/bar x,', '']),
        ('/bin/foo r,', []),
    )

    def _run_test(self, params, expected):
        rules = (
            '/foo r,',
            'audit /bin/foo ix,',
            '/bin/foo Px,',
            '/bin/b* Px,',
            '/bin/bar cx,',
            'deny /bin/bar x,',
        )

        ruleset = FileRuleset()
        for rule in rules:
            ruleset.add(FileRule.create_instance(rule))

        rule_obj = FileRule.create_instance(params)
        conflicts = ruleset.get_exec_conflict_rules(rule_obj)
        self. assertEqual(conflicts.get_clean(), expected)


setup_all_loops(__name__)
if __name__ == '__main__':
    unittest.main(verbosity=1)
