diff --git a/oslo_policy/tests/test_checks.py b/oslo_policy/tests/test_checks.py index bb8ab138..f004fa2d 100644 --- a/oslo_policy/tests/test_checks.py +++ b/oslo_policy/tests/test_checks.py @@ -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) diff --git a/oslo_policy/tests/test_parser.py b/oslo_policy/tests/test_parser.py index 66c64320..554278e2 100644 --- a/oslo_policy/tests/test_parser.py +++ b/oslo_policy/tests/test_parser.py @@ -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']]) diff --git a/oslo_policy/tests/test_policy.py b/oslo_policy/tests/test_policy.py index 3d3fe9e1..43a0d929 100644 --- a/oslo_policy/tests/test_policy.py +++ b/oslo_policy/tests/test_policy.py @@ -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')