Fix the order of args to assertEqual in tests
The order of parameters needs to be (expected, actual) and many of the tests in test_checks, test_parser, and test_policy were not following that convention. Closes-bug: 1277104 Change-Id: I2259972de4961bf9d5f9c6742d81eb083b770fba
This commit is contained in:
Ian Cordasco
parent
41d8bf1c07
commit
29cf374caf
@ -33,7 +33,7 @@ class CheckRegisterTestCase(test_base.BaseTestCase):
|
||||
|
||||
_checks.register('spam', TestCheck)
|
||||
|
||||
self.assertEqual(_checks.registered_checks, dict(spam=TestCheck))
|
||||
self.assertEqual(dict(spam=TestCheck), _checks.registered_checks)
|
||||
|
||||
@mock.patch.object(_checks, 'registered_checks', {})
|
||||
def test_register_check_decorator(self):
|
||||
@ -41,7 +41,7 @@ class CheckRegisterTestCase(test_base.BaseTestCase):
|
||||
class TestCheck(_checks.Check):
|
||||
pass
|
||||
|
||||
self.assertEqual(_checks.registered_checks, dict(spam=TestCheck))
|
||||
self.assertEqual(dict(spam=TestCheck), _checks.registered_checks)
|
||||
|
||||
|
||||
class RuleCheckTestCase(base.PolicyBaseTestCase):
|
||||
@ -49,14 +49,14 @@ class RuleCheckTestCase(base.PolicyBaseTestCase):
|
||||
self.enforcer.rules = {}
|
||||
check = _checks.RuleCheck('rule', 'spam')
|
||||
|
||||
self.assertEqual(check('target', 'creds', self.enforcer), False)
|
||||
self.assertEqual(False, check('target', 'creds', self.enforcer))
|
||||
|
||||
def test_rule_false(self):
|
||||
self.enforcer.rules = dict(spam=mock.Mock(return_value=False))
|
||||
|
||||
check = _checks.RuleCheck('rule', 'spam')
|
||||
|
||||
self.assertEqual(check('target', 'creds', self.enforcer), False)
|
||||
self.assertEqual(False, check('target', 'creds', self.enforcer))
|
||||
self.enforcer.rules['spam'].assert_called_once_with('target', 'creds',
|
||||
self.enforcer)
|
||||
|
||||
@ -64,7 +64,7 @@ class RuleCheckTestCase(base.PolicyBaseTestCase):
|
||||
self.enforcer.rules = dict(spam=mock.Mock(return_value=True))
|
||||
check = _checks.RuleCheck('rule', 'spam')
|
||||
|
||||
self.assertEqual(check('target', 'creds', self.enforcer), True)
|
||||
self.assertEqual(True, check('target', 'creds', self.enforcer))
|
||||
self.enforcer.rules['spam'].assert_called_once_with('target', 'creds',
|
||||
self.enforcer)
|
||||
|
||||
@ -73,13 +73,13 @@ class RoleCheckTestCase(base.PolicyBaseTestCase):
|
||||
def test_accept(self):
|
||||
check = _checks.RoleCheck('role', 'sPaM')
|
||||
|
||||
self.assertEqual(check('target', dict(roles=['SpAm']),
|
||||
self.enforcer), True)
|
||||
self.assertEqual(True,
|
||||
check('target', dict(roles=['SpAm']), self.enforcer))
|
||||
|
||||
def test_reject(self):
|
||||
check = _checks.RoleCheck('role', 'spam')
|
||||
|
||||
self.assertEqual(check('target', dict(roles=[]), self.enforcer), False)
|
||||
self.assertEqual(False, check('target', dict(roles=[]), self.enforcer))
|
||||
|
||||
|
||||
class HttpCheckTestCase(base.PolicyBaseTestCase):
|
||||
@ -95,38 +95,38 @@ class HttpCheckTestCase(base.PolicyBaseTestCase):
|
||||
return_value=six.StringIO('True'))
|
||||
def test_accept(self, mock_urlopen):
|
||||
check = _checks.HttpCheck('http', '//example.com/%(name)s')
|
||||
self.assertEqual(check(dict(name='target', spam='spammer'),
|
||||
self.assertEqual(True,
|
||||
check(dict(name='target', spam='spammer'),
|
||||
dict(user='user', roles=['a', 'b', 'c']),
|
||||
self.enforcer),
|
||||
True)
|
||||
self.assertEqual(mock_urlopen.call_count, 1)
|
||||
self.enforcer))
|
||||
self.assertEqual(1, mock_urlopen.call_count)
|
||||
|
||||
args = mock_urlopen.call_args[0]
|
||||
|
||||
self.assertEqual(args[0], 'http://example.com/target')
|
||||
self.assertEqual(self.decode_post_data(args[1]), dict(
|
||||
self.assertEqual('http://example.com/target', args[0])
|
||||
self.assertEqual(dict(
|
||||
target=dict(name='target', spam='spammer'),
|
||||
credentials=dict(user='user', roles=['a', 'b', 'c']),
|
||||
))
|
||||
), self.decode_post_data(args[1]))
|
||||
|
||||
@mock.patch.object(urlrequest, 'urlopen',
|
||||
return_value=six.StringIO('other'))
|
||||
def test_reject(self, mock_urlopen):
|
||||
check = _checks.HttpCheck('http', '//example.com/%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='target', spam='spammer'),
|
||||
self.assertEqual(False,
|
||||
check(dict(name='target', spam='spammer'),
|
||||
dict(user='user', roles=['a', 'b', 'c']),
|
||||
self.enforcer),
|
||||
False)
|
||||
self.assertEqual(mock_urlopen.call_count, 1)
|
||||
self.enforcer))
|
||||
self.assertEqual(1, mock_urlopen.call_count)
|
||||
|
||||
args = mock_urlopen.call_args[0]
|
||||
|
||||
self.assertEqual(args[0], 'http://example.com/target')
|
||||
self.assertEqual(self.decode_post_data(args[1]), dict(
|
||||
self.assertEqual('http://example.com/target', args[0])
|
||||
self.assertEqual(dict(
|
||||
target=dict(name='target', spam='spammer'),
|
||||
credentials=dict(user='user', roles=['a', 'b', 'c']),
|
||||
))
|
||||
), self.decode_post_data(args[1]))
|
||||
|
||||
@mock.patch.object(urlrequest, 'urlopen',
|
||||
return_value=six.StringIO('True'))
|
||||
@ -136,10 +136,10 @@ class HttpCheckTestCase(base.PolicyBaseTestCase):
|
||||
target = {'a': object(),
|
||||
'name': 'target',
|
||||
'b': 'test data'}
|
||||
self.assertEqual(check(target,
|
||||
self.assertEqual(True,
|
||||
check(target,
|
||||
dict(user='user', roles=['a', 'b', 'c']),
|
||||
self.enforcer),
|
||||
True)
|
||||
self.enforcer))
|
||||
|
||||
@mock.patch.object(urlrequest, 'urlopen',
|
||||
return_value=six.StringIO('True'))
|
||||
@ -148,75 +148,83 @@ class HttpCheckTestCase(base.PolicyBaseTestCase):
|
||||
target = {'a': 'some_string',
|
||||
'name': 'target',
|
||||
'b': 'test data'}
|
||||
self.assertEqual(check(target,
|
||||
self.assertEqual(True,
|
||||
check(target,
|
||||
dict(user='user', roles=['a', 'b', 'c']),
|
||||
self.enforcer),
|
||||
True)
|
||||
self.enforcer))
|
||||
|
||||
|
||||
class GenericCheckTestCase(base.PolicyBaseTestCase):
|
||||
def test_no_cred(self):
|
||||
check = _checks.GenericCheck('name', '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='spam'), {}, self.enforcer), False)
|
||||
self.assertEqual(False, check(dict(name='spam'), {}, self.enforcer))
|
||||
|
||||
def test_cred_mismatch(self):
|
||||
check = _checks.GenericCheck('name', '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='spam'),
|
||||
self.assertEqual(False,
|
||||
check(dict(name='spam'),
|
||||
dict(name='ham'),
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
def test_accept(self):
|
||||
check = _checks.GenericCheck('name', '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='spam'),
|
||||
self.assertEqual(True,
|
||||
check(dict(name='spam'),
|
||||
dict(name='spam'),
|
||||
self.enforcer), True)
|
||||
self.enforcer))
|
||||
|
||||
def test_no_key_match_in_target(self):
|
||||
check = _checks.GenericCheck('name', '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name1='spam'),
|
||||
self.assertEqual(False,
|
||||
check(dict(name1='spam'),
|
||||
dict(name='spam'),
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
def test_constant_string_mismatch(self):
|
||||
check = _checks.GenericCheck("'spam'", '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='ham'),
|
||||
self.assertEqual(False,
|
||||
check(dict(name='ham'),
|
||||
{},
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
def test_constant_string_accept(self):
|
||||
check = _checks.GenericCheck("'spam'", '%(name)s')
|
||||
|
||||
self.assertEqual(check(dict(name='spam'),
|
||||
self.assertEqual(True,
|
||||
check(dict(name='spam'),
|
||||
{},
|
||||
self.enforcer), True)
|
||||
self.enforcer))
|
||||
|
||||
def test_constant_literal_mismatch(self):
|
||||
check = _checks.GenericCheck('True', '%(enabled)s')
|
||||
|
||||
self.assertEqual(check(dict(enabled=False),
|
||||
self.assertEqual(False,
|
||||
check(dict(enabled=False),
|
||||
{},
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
def test_constant_literal_accept(self):
|
||||
check = _checks.GenericCheck('True', '%(enabled)s')
|
||||
|
||||
self.assertEqual(check(dict(enabled=True),
|
||||
self.assertEqual(True,
|
||||
check(dict(enabled=True),
|
||||
{},
|
||||
self.enforcer), True)
|
||||
self.enforcer))
|
||||
|
||||
def test_deep_credentials_dictionary_lookup(self):
|
||||
check = _checks.GenericCheck('a.b.c.d', 'APPLES')
|
||||
|
||||
credentials = {'a': {'b': {'c': {'d': 'APPLES'}}}}
|
||||
|
||||
self.assertEqual(check({},
|
||||
self.assertEqual(True,
|
||||
check({},
|
||||
credentials,
|
||||
self.enforcer), True)
|
||||
self.enforcer))
|
||||
|
||||
def test_missing_credentials_dictionary_lookup(self):
|
||||
credentials = {'a': 'APPLES', 'o': {'t': 'ORANGES'}}
|
||||
@ -225,45 +233,48 @@ class GenericCheckTestCase(base.PolicyBaseTestCase):
|
||||
# Should prove the basic credentials structure before we test
|
||||
# for failure cases.
|
||||
check = _checks.GenericCheck('o.t', 'ORANGES')
|
||||
self.assertEqual(check({},
|
||||
self.assertEqual(True,
|
||||
check({},
|
||||
credentials,
|
||||
self.enforcer), True)
|
||||
self.enforcer))
|
||||
|
||||
# Case where final key is missing
|
||||
check = _checks.GenericCheck('o.v', 'ORANGES')
|
||||
self.assertEqual(check({},
|
||||
self.assertEqual(False,
|
||||
check({},
|
||||
credentials,
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
# Attempt to access key under a missing dictionary
|
||||
check = _checks.GenericCheck('q.v', 'APPLES')
|
||||
self.assertEqual(check({},
|
||||
self.assertEqual(False,
|
||||
check({},
|
||||
credentials,
|
||||
self.enforcer), False)
|
||||
self.enforcer))
|
||||
|
||||
|
||||
class FalseCheckTestCase(test_base.BaseTestCase):
|
||||
def test_str(self):
|
||||
check = _checks.FalseCheck()
|
||||
|
||||
self.assertEqual(str(check), '!')
|
||||
self.assertEqual('!', str(check))
|
||||
|
||||
def test_call(self):
|
||||
check = _checks.FalseCheck()
|
||||
|
||||
self.assertEqual(check('target', 'creds', None), False)
|
||||
self.assertEqual(False, check('target', 'creds', None))
|
||||
|
||||
|
||||
class TrueCheckTestCase(test_base.BaseTestCase):
|
||||
def test_str(self):
|
||||
check = _checks.TrueCheck()
|
||||
|
||||
self.assertEqual(str(check), '@')
|
||||
self.assertEqual('@', str(check))
|
||||
|
||||
def test_call(self):
|
||||
check = _checks.TrueCheck()
|
||||
|
||||
self.assertEqual(check('target', 'creds', None), True)
|
||||
self.assertEqual(True, check('target', 'creds', None))
|
||||
|
||||
|
||||
class CheckForTest(_checks.Check):
|
||||
@ -275,38 +286,38 @@ class CheckTestCase(test_base.BaseTestCase):
|
||||
def test_init(self):
|
||||
check = CheckForTest('kind', 'match')
|
||||
|
||||
self.assertEqual(check.kind, 'kind')
|
||||
self.assertEqual(check.match, 'match')
|
||||
self.assertEqual('kind', check.kind)
|
||||
self.assertEqual('match', check.match)
|
||||
|
||||
def test_str(self):
|
||||
check = CheckForTest('kind', 'match')
|
||||
|
||||
self.assertEqual(str(check), 'kind:match')
|
||||
self.assertEqual('kind:match', str(check))
|
||||
|
||||
|
||||
class NotCheckTestCase(test_base.BaseTestCase):
|
||||
def test_init(self):
|
||||
check = _checks.NotCheck('rule')
|
||||
|
||||
self.assertEqual(check.rule, 'rule')
|
||||
self.assertEqual('rule', check.rule)
|
||||
|
||||
def test_str(self):
|
||||
check = _checks.NotCheck('rule')
|
||||
|
||||
self.assertEqual(str(check), 'not rule')
|
||||
self.assertEqual('not rule', str(check))
|
||||
|
||||
def test_call_true(self):
|
||||
rule = mock.Mock(return_value=True)
|
||||
check = _checks.NotCheck(rule)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), False)
|
||||
self.assertEqual(False, check('target', 'cred', None))
|
||||
rule.assert_called_once_with('target', 'cred', None)
|
||||
|
||||
def test_call_false(self):
|
||||
rule = mock.Mock(return_value=False)
|
||||
check = _checks.NotCheck(rule)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), True)
|
||||
self.assertEqual(True, check('target', 'cred', None))
|
||||
rule.assert_called_once_with('target', 'cred', None)
|
||||
|
||||
|
||||
@ -314,24 +325,24 @@ class AndCheckTestCase(test_base.BaseTestCase):
|
||||
def test_init(self):
|
||||
check = _checks.AndCheck(['rule1', 'rule2'])
|
||||
|
||||
self.assertEqual(check.rules, ['rule1', 'rule2'])
|
||||
self.assertEqual(['rule1', 'rule2'], check.rules)
|
||||
|
||||
def test_add_check(self):
|
||||
check = _checks.AndCheck(['rule1', 'rule2'])
|
||||
check.add_check('rule3')
|
||||
|
||||
self.assertEqual(check.rules, ['rule1', 'rule2', 'rule3'])
|
||||
self.assertEqual(['rule1', 'rule2', 'rule3'], check.rules)
|
||||
|
||||
def test_str(self):
|
||||
check = _checks.AndCheck(['rule1', 'rule2'])
|
||||
|
||||
self.assertEqual(str(check), '(rule1 and rule2)')
|
||||
self.assertEqual('(rule1 and rule2)', str(check))
|
||||
|
||||
def test_call_all_false(self):
|
||||
rules = [mock.Mock(return_value=False), mock.Mock(return_value=False)]
|
||||
check = _checks.AndCheck(rules)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), False)
|
||||
self.assertEqual(False, check('target', 'cred', None))
|
||||
rules[0].assert_called_once_with('target', 'cred', None)
|
||||
self.assertFalse(rules[1].called)
|
||||
|
||||
@ -356,24 +367,24 @@ class OrCheckTestCase(test_base.BaseTestCase):
|
||||
def test_init(self):
|
||||
check = _checks.OrCheck(['rule1', 'rule2'])
|
||||
|
||||
self.assertEqual(check.rules, ['rule1', 'rule2'])
|
||||
self.assertEqual(['rule1', 'rule2'], check.rules)
|
||||
|
||||
def test_add_check(self):
|
||||
check = _checks.OrCheck(['rule1', 'rule2'])
|
||||
check.add_check('rule3')
|
||||
|
||||
self.assertEqual(check.rules, ['rule1', 'rule2', 'rule3'])
|
||||
self.assertEqual(['rule1', 'rule2', 'rule3'], check.rules)
|
||||
|
||||
def test_str(self):
|
||||
check = _checks.OrCheck(['rule1', 'rule2'])
|
||||
|
||||
self.assertEqual(str(check), '(rule1 or rule2)')
|
||||
self.assertEqual('(rule1 or rule2)', str(check))
|
||||
|
||||
def test_call_all_false(self):
|
||||
rules = [mock.Mock(return_value=False), mock.Mock(return_value=False)]
|
||||
check = _checks.OrCheck(rules)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), False)
|
||||
self.assertEqual(False, check('target', 'cred', None))
|
||||
rules[0].assert_called_once_with('target', 'cred', None)
|
||||
rules[1].assert_called_once_with('target', 'cred', None)
|
||||
|
||||
@ -381,7 +392,7 @@ class OrCheckTestCase(test_base.BaseTestCase):
|
||||
rules = [mock.Mock(return_value=True), mock.Mock(return_value=False)]
|
||||
check = _checks.OrCheck(rules)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), True)
|
||||
self.assertEqual(True, check('target', 'cred', None))
|
||||
rules[0].assert_called_once_with('target', 'cred', None)
|
||||
self.assertFalse(rules[1].called)
|
||||
|
||||
@ -389,6 +400,6 @@ class OrCheckTestCase(test_base.BaseTestCase):
|
||||
rules = [mock.Mock(return_value=False), mock.Mock(return_value=True)]
|
||||
check = _checks.OrCheck(rules)
|
||||
|
||||
self.assertEqual(check('target', 'cred', None), True)
|
||||
self.assertEqual(True, check('target', 'cred', None))
|
||||
rules[0].assert_called_once_with('target', 'cred', None)
|
||||
rules[1].assert_called_once_with('target', 'cred', None)
|
||||
|
||||
@ -51,7 +51,7 @@ class ParseCheckTestCase(test_base.BaseTestCase):
|
||||
def test_check(self):
|
||||
result = _parser._parse_check('spam:handler')
|
||||
|
||||
self.assertEqual(result, 'spam_check')
|
||||
self.assertEqual('spam_check', result)
|
||||
_checks.registered_checks['spam'].assert_called_once_with('spam',
|
||||
'handler')
|
||||
self.assertFalse(_checks.registered_checks[None].called)
|
||||
@ -62,7 +62,7 @@ class ParseCheckTestCase(test_base.BaseTestCase):
|
||||
def test_check_default(self):
|
||||
result = _parser._parse_check('spam:handler')
|
||||
|
||||
self.assertEqual(result, 'none_check')
|
||||
self.assertEqual('none_check', result)
|
||||
_checks.registered_checks[None].assert_called_once_with('spam',
|
||||
'handler')
|
||||
|
||||
@ -72,52 +72,52 @@ class ParseListRuleTestCase(test_base.BaseTestCase):
|
||||
result = _parser._parse_list_rule([])
|
||||
|
||||
self.assertTrue(isinstance(result, _checks.TrueCheck))
|
||||
self.assertEqual(str(result), '@')
|
||||
self.assertEqual('@', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_oneele_zeroele(self):
|
||||
result = _parser._parse_list_rule([[]])
|
||||
|
||||
self.assertTrue(isinstance(result, _checks.FalseCheck))
|
||||
self.assertEqual(str(result), '!')
|
||||
self.assertEqual('!', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_oneele_bare(self):
|
||||
result = _parser._parse_list_rule(['rule'])
|
||||
|
||||
self.assertTrue(isinstance(result, base.FakeCheck))
|
||||
self.assertEqual(result.result, 'rule')
|
||||
self.assertEqual(str(result), 'rule')
|
||||
self.assertEqual('rule', result.result)
|
||||
self.assertEqual('rule', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_oneele_oneele(self):
|
||||
result = _parser._parse_list_rule([['rule']])
|
||||
|
||||
self.assertTrue(isinstance(result, base.FakeCheck))
|
||||
self.assertEqual(result.result, 'rule')
|
||||
self.assertEqual(str(result), 'rule')
|
||||
self.assertEqual('rule', result.result)
|
||||
self.assertEqual('rule', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_oneele_multi(self):
|
||||
result = _parser._parse_list_rule([['rule1', 'rule2']])
|
||||
|
||||
self.assertTrue(isinstance(result, _checks.AndCheck))
|
||||
self.assertEqual(len(result.rules), 2)
|
||||
self.assertEqual(2, len(result.rules))
|
||||
for i, value in enumerate(['rule1', 'rule2']):
|
||||
self.assertTrue(isinstance(result.rules[i], base.FakeCheck))
|
||||
self.assertEqual(result.rules[i].result, value)
|
||||
self.assertEqual(str(result), '(rule1 and rule2)')
|
||||
self.assertEqual(value, result.rules[i].result)
|
||||
self.assertEqual('(rule1 and rule2)', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_multi_oneele(self):
|
||||
result = _parser._parse_list_rule([['rule1'], ['rule2']])
|
||||
|
||||
self.assertTrue(isinstance(result, _checks.OrCheck))
|
||||
self.assertEqual(len(result.rules), 2)
|
||||
self.assertEqual(2, len(result.rules))
|
||||
for i, value in enumerate(['rule1', 'rule2']):
|
||||
self.assertTrue(isinstance(result.rules[i], base.FakeCheck))
|
||||
self.assertEqual(result.rules[i].result, value)
|
||||
self.assertEqual(str(result), '(rule1 or rule2)')
|
||||
self.assertEqual(value, result.rules[i].result)
|
||||
self.assertEqual('(rule1 or rule2)', str(result))
|
||||
|
||||
@mock.patch.object(_parser, '_parse_check', base.FakeCheck)
|
||||
def test_multi_multi(self):
|
||||
@ -125,16 +125,16 @@ class ParseListRuleTestCase(test_base.BaseTestCase):
|
||||
['rule3', 'rule4']])
|
||||
|
||||
self.assertTrue(isinstance(result, _checks.OrCheck))
|
||||
self.assertEqual(len(result.rules), 2)
|
||||
self.assertEqual(2, len(result.rules))
|
||||
for i, values in enumerate([['rule1', 'rule2'], ['rule3', 'rule4']]):
|
||||
self.assertTrue(isinstance(result.rules[i], _checks.AndCheck))
|
||||
self.assertEqual(len(result.rules[i].rules), 2)
|
||||
self.assertEqual(2, len(result.rules[i].rules))
|
||||
for j, value in enumerate(values):
|
||||
self.assertTrue(isinstance(result.rules[i].rules[j],
|
||||
base.FakeCheck))
|
||||
self.assertEqual(result.rules[i].rules[j].result, value)
|
||||
self.assertEqual(str(result),
|
||||
'((rule1 and rule2) or (rule3 and rule4))')
|
||||
self.assertEqual(value, result.rules[i].rules[j].result)
|
||||
self.assertEqual('((rule1 and rule2) or (rule3 and rule4))',
|
||||
str(result))
|
||||
|
||||
|
||||
class ParseTokenizeTestCase(test_base.BaseTestCase):
|
||||
@ -154,7 +154,7 @@ class ParseTokenizeTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = list(_parser._parse_tokenize(exemplar))
|
||||
|
||||
self.assertEqual(result, expected)
|
||||
self.assertEqual(expected, result)
|
||||
|
||||
|
||||
class ParseStateMetaTestCase(test_base.BaseTestCase):
|
||||
@ -165,7 +165,7 @@ class ParseStateMetaTestCase(test_base.BaseTestCase):
|
||||
pass
|
||||
|
||||
self.assertTrue(hasattr(spam, 'reducers'))
|
||||
self.assertEqual(spam.reducers, [['d', 'e', 'f'], ['a', 'b', 'c']])
|
||||
self.assertEqual([['d', 'e', 'f'], ['a', 'b', 'c']], spam.reducers)
|
||||
|
||||
def test_parse_state_meta(self):
|
||||
@six.add_metaclass(_parser.ParseStateMeta)
|
||||
@ -184,9 +184,9 @@ class ParseStateMetaTestCase(test_base.BaseTestCase):
|
||||
for reduction, reducer in FakeState.reducers:
|
||||
if (reduction == ['a', 'b', 'c'] or
|
||||
reduction == ['d', 'e', 'f']):
|
||||
self.assertEqual(reducer, 'reduce1')
|
||||
self.assertEqual('reduce1', reducer)
|
||||
elif reduction == ['g', 'h', 'i']:
|
||||
self.assertEqual(reducer, 'reduce2')
|
||||
self.assertEqual('reduce2', reducer)
|
||||
else:
|
||||
self.fail('Unrecognized reducer discovered')
|
||||
|
||||
@ -195,8 +195,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
def test_init(self):
|
||||
state = _parser.ParseState()
|
||||
|
||||
self.assertEqual(state.tokens, [])
|
||||
self.assertEqual(state.values, [])
|
||||
self.assertEqual([], state.tokens)
|
||||
self.assertEqual([], state.values)
|
||||
|
||||
@mock.patch.object(_parser.ParseState, 'reducers', [(['tok1'], 'meth')])
|
||||
@mock.patch.object(_parser.ParseState, 'meth', create=True)
|
||||
@ -207,8 +207,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
state.reduce()
|
||||
|
||||
self.assertEqual(state.tokens, ['tok2'])
|
||||
self.assertEqual(state.values, ['val2'])
|
||||
self.assertEqual(['tok2'], state.tokens)
|
||||
self.assertEqual(['val2'], state.values)
|
||||
self.assertFalse(mock_meth.called)
|
||||
|
||||
@mock.patch.object(_parser.ParseState, 'reducers',
|
||||
@ -221,8 +221,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
state.reduce()
|
||||
|
||||
self.assertEqual(state.tokens, ['tok1'])
|
||||
self.assertEqual(state.values, ['val1'])
|
||||
self.assertEqual(['tok1'], state.tokens)
|
||||
self.assertEqual(['val1'], state.values)
|
||||
self.assertFalse(mock_meth.called)
|
||||
|
||||
@mock.patch.object(_parser.ParseState, 'reducers',
|
||||
@ -236,8 +236,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
state.reduce()
|
||||
|
||||
self.assertEqual(state.tokens, ['tok3'])
|
||||
self.assertEqual(state.values, ['val3'])
|
||||
self.assertEqual(['tok3'], state.tokens)
|
||||
self.assertEqual(['val3'], state.values)
|
||||
mock_meth.assert_called_once_with('val1', 'val2')
|
||||
|
||||
@mock.patch.object(_parser.ParseState, 'reducers', [
|
||||
@ -255,8 +255,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
state.reduce()
|
||||
|
||||
self.assertEqual(state.tokens, ['tok5'])
|
||||
self.assertEqual(state.values, ['val5'])
|
||||
self.assertEqual(['tok5'], state.tokens)
|
||||
self.assertEqual(['val5'], state.values)
|
||||
mock_meth1.assert_called_once_with('val2', 'val3')
|
||||
mock_meth2.assert_called_once_with('val1', 'val4')
|
||||
|
||||
@ -271,8 +271,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
state.reduce()
|
||||
|
||||
self.assertEqual(state.tokens, ['tok3', 'tok4'])
|
||||
self.assertEqual(state.values, ['val3', 'val4'])
|
||||
self.assertEqual(['tok3', 'tok4'], state.tokens)
|
||||
self.assertEqual(['val3', 'val4'], state.values)
|
||||
mock_meth.assert_called_once_with('val1', 'val2')
|
||||
|
||||
def test_shift(self):
|
||||
@ -281,8 +281,8 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
with mock.patch.object(_parser.ParseState, 'reduce') as mock_reduce:
|
||||
state.shift('token', 'value')
|
||||
|
||||
self.assertEqual(state.tokens, ['token'])
|
||||
self.assertEqual(state.values, ['value'])
|
||||
self.assertEqual(['token'], state.tokens)
|
||||
self.assertEqual(['value'], state.values)
|
||||
mock_reduce.assert_called_once_with()
|
||||
|
||||
def test_result_empty(self):
|
||||
@ -302,14 +302,14 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
state.tokens = ['token']
|
||||
state.values = ['value']
|
||||
|
||||
self.assertEqual(state.result, 'value')
|
||||
self.assertEqual('value', state.result)
|
||||
|
||||
def test_wrap_check(self):
|
||||
state = _parser.ParseState()
|
||||
|
||||
result = state._wrap_check('(', 'the_check', ')')
|
||||
|
||||
self.assertEqual(result, [('check', 'the_check')])
|
||||
self.assertEqual([('check', 'the_check')], result)
|
||||
|
||||
@mock.patch.object(_checks, 'AndCheck', lambda x: x)
|
||||
def test_make_and_expr(self):
|
||||
@ -317,7 +317,7 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = state._make_and_expr('check1', 'and', 'check2')
|
||||
|
||||
self.assertEqual(result, [('and_expr', ['check1', 'check2'])])
|
||||
self.assertEqual([('and_expr', ['check1', 'check2'])], result)
|
||||
|
||||
def test_extend_and_expr(self):
|
||||
state = _parser.ParseState()
|
||||
@ -326,7 +326,7 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = state._extend_and_expr(mock_expr, 'and', 'check')
|
||||
|
||||
self.assertEqual(result, [('and_expr', 'newcheck')])
|
||||
self.assertEqual([('and_expr', 'newcheck')], result)
|
||||
mock_expr.add_check.assert_called_once_with('check')
|
||||
|
||||
@mock.patch.object(_checks, 'OrCheck', lambda x: x)
|
||||
@ -335,7 +335,7 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = state._make_or_expr('check1', 'or', 'check2')
|
||||
|
||||
self.assertEqual(result, [('or_expr', ['check1', 'check2'])])
|
||||
self.assertEqual([('or_expr', ['check1', 'check2'])], result)
|
||||
|
||||
def test_extend_or_expr(self):
|
||||
state = _parser.ParseState()
|
||||
@ -344,7 +344,7 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = state._extend_or_expr(mock_expr, 'or', 'check')
|
||||
|
||||
self.assertEqual(result, [('or_expr', 'newcheck')])
|
||||
self.assertEqual([('or_expr', 'newcheck')], result)
|
||||
mock_expr.add_check.assert_called_once_with('check')
|
||||
|
||||
@mock.patch.object(_checks, 'NotCheck', lambda x: 'not %s' % x)
|
||||
@ -353,7 +353,7 @@ class ParseStateTestCase(test_base.BaseTestCase):
|
||||
|
||||
result = state._make_not_expr('not', 'check')
|
||||
|
||||
self.assertEqual(result, [('check', 'not check')])
|
||||
self.assertEqual([('check', 'not check')], result)
|
||||
|
||||
|
||||
class ParseTextRuleTestCase(test_base.BaseTestCase):
|
||||
@ -369,7 +369,7 @@ class ParseTextRuleTestCase(test_base.BaseTestCase):
|
||||
def test_shifts(self, mock_shift, mock_parse_tokenize):
|
||||
result = _parser._parse_text_rule('test rule')
|
||||
|
||||
self.assertEqual(result, 'result')
|
||||
self.assertEqual('result', result)
|
||||
mock_parse_tokenize.assert_called_once_with('test rule')
|
||||
mock_shift.assert_has_calls(
|
||||
[mock.call('tok1', 'val1'), mock.call('tok2', 'val2')])
|
||||
@ -389,7 +389,7 @@ class ParseRuleTestCase(test_base.BaseTestCase):
|
||||
mock_parse_text_rule):
|
||||
result = _parser.parse_rule('a string')
|
||||
|
||||
self.assertEqual(result, 'text rule')
|
||||
self.assertEqual('text rule', result)
|
||||
self.assertFalse(mock_parse_list_rule.called)
|
||||
mock_parse_text_rule.assert_called_once_with('a string')
|
||||
|
||||
@ -398,6 +398,6 @@ class ParseRuleTestCase(test_base.BaseTestCase):
|
||||
def test_parse_rule_list(self, mock_parse_list_rule, mock_parse_text_rule):
|
||||
result = _parser.parse_rule([['a'], ['list']])
|
||||
|
||||
self.assertEqual(result, 'list rule')
|
||||
self.assertEqual('list rule', result)
|
||||
self.assertFalse(mock_parse_text_rule.called)
|
||||
mock_parse_list_rule.assert_called_once_with([['a'], ['list']])
|
||||
|
||||
@ -64,14 +64,14 @@ class RulesTestCase(test_base.BaseTestCase):
|
||||
def test_init_basic(self):
|
||||
rules = policy.Rules()
|
||||
|
||||
self.assertEqual(rules, {})
|
||||
self.assertEqual({}, rules)
|
||||
self.assertIsNone(rules.default_rule)
|
||||
|
||||
def test_init(self):
|
||||
rules = policy.Rules(dict(a=1, b=2, c=3), 'a')
|
||||
|
||||
self.assertEqual(rules, dict(a=1, b=2, c=3))
|
||||
self.assertEqual(rules.default_rule, 'a')
|
||||
self.assertEqual(dict(a=1, b=2, c=3), rules)
|
||||
self.assertEqual('a', rules.default_rule)
|
||||
|
||||
def test_no_default(self):
|
||||
rules = policy.Rules(dict(a=1, b=2, c=3))
|
||||
@ -86,14 +86,14 @@ class RulesTestCase(test_base.BaseTestCase):
|
||||
def test_with_default(self):
|
||||
rules = policy.Rules(dict(a=1, b=2, c=3), 'b')
|
||||
|
||||
self.assertEqual(rules['d'], 2)
|
||||
self.assertEqual(2, rules['d'])
|
||||
|
||||
def test_retrieval(self):
|
||||
rules = policy.Rules(dict(a=1, b=2, c=3), 'b')
|
||||
|
||||
self.assertEqual(rules['a'], 1)
|
||||
self.assertEqual(rules['b'], 2)
|
||||
self.assertEqual(rules['c'], 3)
|
||||
self.assertEqual(1, rules['a'])
|
||||
self.assertEqual(2, rules['b'])
|
||||
self.assertEqual(3, rules['c'])
|
||||
|
||||
@mock.patch.object(_parser, 'parse_rule', lambda x: x)
|
||||
def test_load_json(self):
|
||||
@ -103,11 +103,11 @@ class RulesTestCase(test_base.BaseTestCase):
|
||||
}"""
|
||||
rules = policy.Rules.load_json(exemplar, 'default')
|
||||
|
||||
self.assertEqual(rules.default_rule, 'default')
|
||||
self.assertEqual(rules, dict(
|
||||
self.assertEqual('default', rules.default_rule)
|
||||
self.assertEqual(dict(
|
||||
admin_or_owner=[['role:admin'], ['project_id:%(project_id)s']],
|
||||
default=[],
|
||||
))
|
||||
), rules)
|
||||
|
||||
def test_str(self):
|
||||
exemplar = """{
|
||||
@ -117,7 +117,7 @@ class RulesTestCase(test_base.BaseTestCase):
|
||||
admin_or_owner='role:admin or project_id:%(project_id)s',
|
||||
))
|
||||
|
||||
self.assertEqual(str(rules), exemplar)
|
||||
self.assertEqual(exemplar, str(rules))
|
||||
|
||||
def test_str_true(self):
|
||||
exemplar = """{
|
||||
@ -127,7 +127,7 @@ class RulesTestCase(test_base.BaseTestCase):
|
||||
admin_or_owner=_checks.TrueCheck(),
|
||||
))
|
||||
|
||||
self.assertEqual(str(rules), exemplar)
|
||||
self.assertEqual(exemplar, str(rules))
|
||||
|
||||
|
||||
class EnforcerTest(base.PolicyBaseTestCase):
|
||||
@ -205,9 +205,9 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
self.enforcer.rules = 'spam'
|
||||
filename = self.enforcer.policy_path
|
||||
self.enforcer.clear()
|
||||
self.assertEqual(self.enforcer.rules, {})
|
||||
self.assertEqual(self.enforcer.default_rule, None)
|
||||
self.assertEqual(self.enforcer.policy_path, None)
|
||||
self.assertEqual({}, self.enforcer.rules)
|
||||
self.assertEqual(None, self.enforcer.default_rule)
|
||||
self.assertEqual(None, self.enforcer.policy_path)
|
||||
fileutils.delete_cached_file.assert_called_once_with(filename)
|
||||
|
||||
def test_rule_with_check(self):
|
||||
@ -219,7 +219,7 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
self.enforcer.set_rules(rules)
|
||||
action = 'cloudwatch:PutMetricData'
|
||||
creds = {'roles': ''}
|
||||
self.assertEqual(self.enforcer.enforce(action, {}, creds), True)
|
||||
self.assertEqual(True, self.enforcer.enforce(action, {}, creds))
|
||||
|
||||
def test_enforcer_with_default_rule(self):
|
||||
rules_json = """{
|
||||
@ -232,7 +232,7 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
enforcer.set_rules(rules)
|
||||
action = 'cloudwatch:PutMetricData'
|
||||
creds = {'roles': ''}
|
||||
self.assertEqual(enforcer.enforce(action, {}, creds), True)
|
||||
self.assertEqual(True, enforcer.enforce(action, {}, creds))
|
||||
|
||||
def test_enforcer_force_reload_with_overwrite(self):
|
||||
self.create_config_file('policy.d/a.conf', POLICY_A_CONTENTS)
|
||||
@ -261,7 +261,7 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
self.assertIn('default', self.enforcer.rules)
|
||||
self.assertIn('admin', self.enforcer.rules)
|
||||
loaded_rules = jsonutils.loads(str(self.enforcer.rules))
|
||||
self.assertEqual(len(loaded_rules), 2)
|
||||
self.assertEqual(2, len(loaded_rules))
|
||||
self.assertIn('role:fakeB', loaded_rules['default'])
|
||||
self.assertIn('is_admin:True', loaded_rules['admin'])
|
||||
|
||||
@ -294,7 +294,7 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
self.assertIn('default', self.enforcer.rules)
|
||||
self.assertIn('admin', self.enforcer.rules)
|
||||
loaded_rules = jsonutils.loads(str(self.enforcer.rules))
|
||||
self.assertEqual(len(loaded_rules), 3)
|
||||
self.assertEqual(3, len(loaded_rules))
|
||||
self.assertIn('role:test', loaded_rules['test'])
|
||||
self.assertIn('role:fakeB', loaded_rules['default'])
|
||||
self.assertIn('is_admin:True', loaded_rules['admin'])
|
||||
@ -340,13 +340,13 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
def test_enforcer_overwrite_rules(self):
|
||||
self.enforcer.set_rules({'test': 'test'})
|
||||
self.enforcer.set_rules({'test': 'test1'}, overwrite=True)
|
||||
self.assertEqual(self.enforcer.rules, {'test': 'test1'})
|
||||
self.assertEqual({'test': 'test1'}, self.enforcer.rules)
|
||||
|
||||
def test_enforcer_update_rules(self):
|
||||
self.enforcer.set_rules({'test': 'test'})
|
||||
self.enforcer.set_rules({'test1': 'test1'}, overwrite=False)
|
||||
self.assertEqual(self.enforcer.rules, {'test': 'test',
|
||||
'test1': 'test1'})
|
||||
self.assertEqual({'test': 'test', 'test1': 'test1'},
|
||||
self.enforcer.rules)
|
||||
|
||||
def test_enforcer_with_default_policy_file(self):
|
||||
enforcer = policy.Enforcer(self.conf)
|
||||
@ -367,7 +367,7 @@ class EnforcerTest(base.PolicyBaseTestCase):
|
||||
self.enforcer.load_rules()
|
||||
self.enforcer.set_rules({'test': 'test1'})
|
||||
self.enforcer.load_rules()
|
||||
self.assertEqual(self.enforcer.rules, {'test': 'test1'})
|
||||
self.assertEqual({'test': 'test1'}, self.enforcer.rules)
|
||||
|
||||
def test_enforcer_default_rule_name(self):
|
||||
enforcer = policy.Enforcer(self.conf, default_rule='foo_rule')
|
||||
@ -389,7 +389,7 @@ class CheckFunctionTestCase(base.PolicyBaseTestCase):
|
||||
def test_check_explicit(self):
|
||||
rule = base.FakeCheck()
|
||||
result = self.enforcer.enforce(rule, 'target', 'creds')
|
||||
self.assertEqual(result, ('target', 'creds', self.enforcer))
|
||||
self.assertEqual(('target', 'creds', self.enforcer), result)
|
||||
|
||||
def test_check_no_rules(self):
|
||||
# Clear the policy.json file created in setUp()
|
||||
@ -397,13 +397,13 @@ class CheckFunctionTestCase(base.PolicyBaseTestCase):
|
||||
self.enforcer.default_rule = None
|
||||
self.enforcer.load_rules()
|
||||
result = self.enforcer.enforce('rule', 'target', 'creds')
|
||||
self.assertEqual(result, False)
|
||||
self.assertEqual(False, result)
|
||||
|
||||
def test_check_with_rule(self):
|
||||
self.enforcer.set_rules(dict(default=base.FakeCheck()))
|
||||
result = self.enforcer.enforce('default', 'target', 'creds')
|
||||
|
||||
self.assertEqual(result, ('target', 'creds', self.enforcer))
|
||||
self.assertEqual(('target', 'creds', self.enforcer), result)
|
||||
|
||||
def test_check_raises(self):
|
||||
self.enforcer.set_rules(dict(default=_checks.FalseCheck()))
|
||||
@ -413,7 +413,7 @@ class CheckFunctionTestCase(base.PolicyBaseTestCase):
|
||||
True, MyException, 'arg1',
|
||||
'arg2', kw1='kwarg1', kw2='kwarg2')
|
||||
except MyException as exc:
|
||||
self.assertEqual(exc.args, ('arg1', 'arg2'))
|
||||
self.assertEqual(exc.kwargs, dict(kw1='kwarg1', kw2='kwarg2'))
|
||||
self.assertEqual(('arg1', 'arg2'), exc.args)
|
||||
self.assertEqual(dict(kw1='kwarg1', kw2='kwarg2'), exc.kwargs)
|
||||
else:
|
||||
self.fail('enforcer.enforce() failed to raise requested exception')
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user