move code linting to a stricter pep8-esque auto-formatting tool, black

awx/sso/tests/functional/test_get_or_set_enterprise_user.py

@@ -19,9 +19,7 @@ def test_fetch_user_if_exist(existing_tacacsplus_user):
 def test_create_user_if_not_exist(existing_tacacsplus_user):
     with mock.patch('awx.sso.backends.logger') as mocked_logger:
         new_user = _get_or_set_enterprise_user("bar", "password", "tacacs+")
-        mocked_logger.debug.assert_called_once_with(
-            u'Created enterprise user bar via TACACS+ backend.'
-        )
+        mocked_logger.debug.assert_called_once_with(u'Created enterprise user bar via TACACS+ backend.')
         assert new_user != existing_tacacsplus_user
 
 
@@ -35,7 +33,5 @@ def test_created_user_has_no_usable_password():
 def test_non_enterprise_user_does_not_get_pass(existing_normal_user):
     with mock.patch('awx.sso.backends.logger') as mocked_logger:
         new_user = _get_or_set_enterprise_user("alice", "password", "tacacs+")
-        mocked_logger.warn.assert_called_once_with(
-            u'Enterprise user alice already defined in Tower.'
-        )
+        mocked_logger.warn.assert_called_once_with(u'Enterprise user alice already defined in Tower.')
         assert new_user is None

awx/sso/tests/functional/test_ldap.py

@@ -5,20 +5,15 @@ import pytest
 from awx.sso.backends import LDAPSettings
 
 
-@override_settings(AUTH_LDAP_CONNECTION_OPTIONS = {ldap.OPT_NETWORK_TIMEOUT: 60})
+@override_settings(AUTH_LDAP_CONNECTION_OPTIONS={ldap.OPT_NETWORK_TIMEOUT: 60})
 @pytest.mark.django_db
 def test_ldap_with_custom_timeout():
     settings = LDAPSettings()
-    assert settings.CONNECTION_OPTIONS == {
-        ldap.OPT_NETWORK_TIMEOUT: 60
-    }
+    assert settings.CONNECTION_OPTIONS == {ldap.OPT_NETWORK_TIMEOUT: 60}
 
 
-@override_settings(AUTH_LDAP_CONNECTION_OPTIONS = {ldap.OPT_REFERRALS: 0})
+@override_settings(AUTH_LDAP_CONNECTION_OPTIONS={ldap.OPT_REFERRALS: 0})
 @pytest.mark.django_db
 def test_ldap_with_missing_timeout():
     settings = LDAPSettings()
-    assert settings.CONNECTION_OPTIONS == {
-        ldap.OPT_REFERRALS: 0,
-        ldap.OPT_NETWORK_TIMEOUT: 30
-    }
+    assert settings.CONNECTION_OPTIONS == {ldap.OPT_REFERRALS: 0, ldap.OPT_NETWORK_TIMEOUT: 30}

awx/sso/tests/functional/test_pipeline.py

@@ -1,20 +1,10 @@
-
 import pytest
 import re
 from unittest import mock
 
-from awx.sso.pipeline import (
-    update_user_orgs,
-    update_user_teams,
-    update_user_orgs_by_saml_attr,
-    update_user_teams_by_saml_attr,
-)
+from awx.sso.pipeline import update_user_orgs, update_user_teams, update_user_orgs_by_saml_attr, update_user_teams_by_saml_attr
 
-from awx.main.models import (
-    User,
-    Team,
-    Organization
-)
+from awx.main.models import User, Team, Organization
 
 
 @pytest.fixture
@@ -26,33 +16,13 @@ def users():
 
 
 @pytest.mark.django_db
-class TestSAMLMap():
-
+class TestSAMLMap:
     @pytest.fixture
     def backend(self):
         class Backend:
             s = {
-                'ORGANIZATION_MAP': {
-                    'Default': {
-                        'remove': True,
-                        'admins': 'foobar',
-                        'remove_admins': True,
-                        'users': 'foo',
-                        'remove_users': True,
-                    }
-                },
-                'TEAM_MAP': {
-                    'Blue': {
-                        'organization': 'Default',
-                        'remove': True,
-                        'users': '',
-                    },
-                    'Red': {
-                        'organization': 'Default',
-                        'remove': True,
-                        'users': '',
-                    }
-                }
+                'ORGANIZATION_MAP': {'Default': {'remove': True, 'admins': 'foobar', 'remove_admins': True, 'users': 'foo', 'remove_users': True}},
+                'TEAM_MAP': {'Blue': {'organization': 'Default', 'remove': True, 'users': ''}, 'Red': {'organization': 'Default', 'remove': True, 'users': ''}},
             }
 
             def setting(self, key):
@@ -132,17 +102,13 @@ class TestSAMLMap():
 
 
 @pytest.mark.django_db
-class TestSAMLAttr():
-
+class TestSAMLAttr:
     @pytest.fixture
     def kwargs(self):
         return {
             'username': u'cmeyers@redhat.com',
             'uid': 'idp:cmeyers@redhat.com',
-            'request': {
-                u'SAMLResponse': [],
-                u'RelayState': [u'idp']
-            },
+            'request': {u'SAMLResponse': [], u'RelayState': [u'idp']},
             'is_new': False,
             'response': {
                 'session_index': '_0728f0e0-b766-0135-75fa-02842b07c044',
@@ -156,14 +122,14 @@ class TestSAMLAttr():
                     'User.LastName': ['Meyers'],
                     'name_id': 'cmeyers@redhat.com',
                     'User.FirstName': ['Chris'],
-                    'PersonImmutableID': []
-                }
+                    'PersonImmutableID': [],
+                },
             },
             #'social': <UserSocialAuth: cmeyers@redhat.com>,
             'social': None,
             #'strategy': <awx.sso.strategies.django_strategy.AWXDjangoStrategy object at 0x8523a10>,
             'strategy': None,
-            'new_association': False
+            'new_association': False,
         }
 
     @pytest.fixture
@@ -181,7 +147,7 @@ class TestSAMLAttr():
         else:
             autocreate = True
 
-        class MockSettings():
+        class MockSettings:
             SAML_AUTO_CREATE_OBJECTS = autocreate
             SOCIAL_AUTH_SAML_ORGANIZATION_ATTR = {
                 'saml_attr': 'memberOf',
@@ -200,12 +166,10 @@ class TestSAMLAttr():
                     {'team': 'Red', 'organization': 'Default1'},
                     {'team': 'Green', 'organization': 'Default1'},
                     {'team': 'Green', 'organization': 'Default3'},
-                    {
-                        'team': 'Yellow', 'team_alias': 'Yellow_Alias',
-                        'organization': 'Default4', 'organization_alias': 'Default4_Alias'
-                    },
-                ]
+                    {'team': 'Yellow', 'team_alias': 'Yellow_Alias', 'organization': 'Default4', 'organization_alias': 'Default4_Alias'},
+                ],
             }
+
         return MockSettings()
 
     def test_update_user_orgs_by_saml_attr(self, orgs, users, kwargs, mock_settings):
@@ -308,8 +272,7 @@ class TestSAMLAttr():
 
             assert Team.objects.filter(name='Yellow', organization__name='Default4').count() == 0
             assert Team.objects.filter(name='Yellow_Alias', organization__name='Default4_Alias').count() == 1
-            assert Team.objects.get(
-                name='Yellow_Alias', organization__name='Default4_Alias').member_role.members.count() == 1
+            assert Team.objects.get(name='Yellow_Alias', organization__name='Default4_Alias').member_role.members.count() == 1
 
     @pytest.mark.fixture_args(autocreate=False)
     def test_autocreate_disabled(self, users, kwargs, mock_settings):

awx/sso/tests/test_env.py

@@ -1,5 +1,3 @@
-
-
 # Ensure that our autouse overwrites are working
 def test_cache(settings):
     assert settings.CACHES['default']['BACKEND'] == 'django.core.cache.backends.locmem.LocMemCache'

awx/sso/tests/unit/test_fields.py

@@ -1,51 +1,48 @@
-
 import pytest
 from unittest import mock
 
 from rest_framework.exceptions import ValidationError
 
-from awx.sso.fields import (
-    SAMLOrgAttrField,
-    SAMLTeamAttrField,
-    LDAPGroupTypeParamsField,
-    LDAPServerURIField
-)
+from awx.sso.fields import SAMLOrgAttrField, SAMLTeamAttrField, LDAPGroupTypeParamsField, LDAPServerURIField
 
 
-class TestSAMLOrgAttrField():
-
-    @pytest.mark.parametrize("data, expected", [
-        ({}, {}),
-        ({'remove': True, 'saml_attr': 'foobar'}, {'remove': True, 'saml_attr': 'foobar'}),
-        ({'remove': True, 'saml_attr': 1234}, {'remove': True, 'saml_attr': '1234'}),
-        ({'remove': True, 'saml_attr': 3.14}, {'remove': True, 'saml_attr': '3.14'}),
-        ({'saml_attr': 'foobar'}, {'saml_attr': 'foobar'}),
-        ({'remove': True}, {'remove': True}),
-        ({'remove': True, 'saml_admin_attr': 'foobar'}, {'remove': True, 'saml_admin_attr': 'foobar'}),
-        ({'saml_admin_attr': 'foobar'}, {'saml_admin_attr': 'foobar'}),
-        ({'remove_admins': True, 'saml_admin_attr': 'foobar'}, {'remove_admins': True, 'saml_admin_attr': 'foobar'}),
-        ({'remove': True, 'saml_attr': 'foo', 'remove_admins': True, 'saml_admin_attr': 'bar'},
-            {'remove': True, 'saml_attr': 'foo', 'remove_admins': True, 'saml_admin_attr': 'bar'}),
-    ])
+class TestSAMLOrgAttrField:
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            ({}, {}),
+            ({'remove': True, 'saml_attr': 'foobar'}, {'remove': True, 'saml_attr': 'foobar'}),
+            ({'remove': True, 'saml_attr': 1234}, {'remove': True, 'saml_attr': '1234'}),
+            ({'remove': True, 'saml_attr': 3.14}, {'remove': True, 'saml_attr': '3.14'}),
+            ({'saml_attr': 'foobar'}, {'saml_attr': 'foobar'}),
+            ({'remove': True}, {'remove': True}),
+            ({'remove': True, 'saml_admin_attr': 'foobar'}, {'remove': True, 'saml_admin_attr': 'foobar'}),
+            ({'saml_admin_attr': 'foobar'}, {'saml_admin_attr': 'foobar'}),
+            ({'remove_admins': True, 'saml_admin_attr': 'foobar'}, {'remove_admins': True, 'saml_admin_attr': 'foobar'}),
+            (
+                {'remove': True, 'saml_attr': 'foo', 'remove_admins': True, 'saml_admin_attr': 'bar'},
+                {'remove': True, 'saml_attr': 'foo', 'remove_admins': True, 'saml_admin_attr': 'bar'},
+            ),
+        ],
+    )
     def test_internal_value_valid(self, data, expected):
         field = SAMLOrgAttrField()
         res = field.to_internal_value(data)
         assert res == expected
 
-    @pytest.mark.parametrize("data, expected", [
-        ({'remove': 'blah', 'saml_attr': 'foobar'},
-            {'remove': ['Must be a valid boolean.']}),
-        ({'remove': True, 'saml_attr': False},
-            {'saml_attr': ['Not a valid string.']}),
-        ({'remove': True, 'saml_attr': False, 'foo': 'bar', 'gig': 'ity'},
-            {'saml_attr': ['Not a valid string.'],
-             'foo': ['Invalid field.'],
-             'gig': ['Invalid field.']}),
-        ({'remove_admins': True, 'saml_admin_attr': False},
-            {'saml_admin_attr': ['Not a valid string.']}),
-        ({'remove_admins': 'blah', 'saml_admin_attr': 'foobar'},
-            {'remove_admins': ['Must be a valid boolean.']}),
-    ])
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            ({'remove': 'blah', 'saml_attr': 'foobar'}, {'remove': ['Must be a valid boolean.']}),
+            ({'remove': True, 'saml_attr': False}, {'saml_attr': ['Not a valid string.']}),
+            (
+                {'remove': True, 'saml_attr': False, 'foo': 'bar', 'gig': 'ity'},
+                {'saml_attr': ['Not a valid string.'], 'foo': ['Invalid field.'], 'gig': ['Invalid field.']},
+            ),
+            ({'remove_admins': True, 'saml_admin_attr': False}, {'saml_admin_attr': ['Not a valid string.']}),
+            ({'remove_admins': 'blah', 'saml_admin_attr': 'foobar'}, {'remove_admins': ['Must be a valid boolean.']}),
+        ],
+    )
     def test_internal_value_invalid(self, data, expected):
         field = SAMLOrgAttrField()
         with pytest.raises(ValidationError) as e:
@@ -53,51 +50,64 @@ class TestSAMLOrgAttrField():
         assert e.value.detail == expected
 
 
-class TestSAMLTeamAttrField():
-
-    @pytest.mark.parametrize("data", [
-        {},
-        {'remove': True, 'saml_attr': 'foobar', 'team_org_map': []},
-        {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [
-            {'team': 'Engineering', 'organization': 'Ansible'}
-        ]},
-        {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [
-            {'team': 'Engineering', 'organization': 'Ansible'},
-            {'team': 'Engineering', 'organization': 'Ansible2'},
-            {'team': 'Engineering2', 'organization': 'Ansible'},
-        ]},
-        {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [
-            {'team': 'Engineering', 'organization': 'Ansible'},
-            {'team': 'Engineering', 'organization': 'Ansible2'},
-            {'team': 'Engineering2', 'organization': 'Ansible'},
-        ]},
-        {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [
+class TestSAMLTeamAttrField:
+    @pytest.mark.parametrize(
+        "data",
+        [
+            {},
+            {'remove': True, 'saml_attr': 'foobar', 'team_org_map': []},
+            {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [{'team': 'Engineering', 'organization': 'Ansible'}]},
             {
-                'team': 'Engineering', 'team_alias': 'Engineering Team',
-                'organization': 'Ansible', 'organization_alias': 'Awesome Org'
+                'remove': True,
+                'saml_attr': 'foobar',
+                'team_org_map': [
+                    {'team': 'Engineering', 'organization': 'Ansible'},
+                    {'team': 'Engineering', 'organization': 'Ansible2'},
+                    {'team': 'Engineering2', 'organization': 'Ansible'},
+                ],
             },
-            {'team': 'Engineering', 'organization': 'Ansible2'},
-            {'team': 'Engineering2', 'organization': 'Ansible'},
-        ]},
-    ])
+            {
+                'remove': True,
+                'saml_attr': 'foobar',
+                'team_org_map': [
+                    {'team': 'Engineering', 'organization': 'Ansible'},
+                    {'team': 'Engineering', 'organization': 'Ansible2'},
+                    {'team': 'Engineering2', 'organization': 'Ansible'},
+                ],
+            },
+            {
+                'remove': True,
+                'saml_attr': 'foobar',
+                'team_org_map': [
+                    {'team': 'Engineering', 'team_alias': 'Engineering Team', 'organization': 'Ansible', 'organization_alias': 'Awesome Org'},
+                    {'team': 'Engineering', 'organization': 'Ansible2'},
+                    {'team': 'Engineering2', 'organization': 'Ansible'},
+                ],
+            },
+        ],
+    )
     def test_internal_value_valid(self, data):
         field = SAMLTeamAttrField()
         res = field.to_internal_value(data)
         assert res == data
 
-    @pytest.mark.parametrize("data, expected", [
-        ({'remove': True, 'saml_attr': 'foobar', 'team_org_map': [
-            {'team': 'foobar', 'not_a_valid_key': 'blah', 'organization': 'Ansible'},
-        ]}, {'team_org_map': {0: {'not_a_valid_key': ['Invalid field.']}}}),
-        ({'remove': False, 'saml_attr': 'foobar', 'team_org_map': [
-            {'organization': 'Ansible'},
-        ]}, {'team_org_map': {0: {'team': ['This field is required.']}}}),
-        ({'remove': False, 'saml_attr': 'foobar', 'team_org_map': [
-            {},
-        ]}, {'team_org_map': {
-            0: {'organization': ['This field is required.'],
-                'team': ['This field is required.']}}}),
-    ])
+    @pytest.mark.parametrize(
+        "data, expected",
+        [
+            (
+                {'remove': True, 'saml_attr': 'foobar', 'team_org_map': [{'team': 'foobar', 'not_a_valid_key': 'blah', 'organization': 'Ansible'}]},
+                {'team_org_map': {0: {'not_a_valid_key': ['Invalid field.']}}},
+            ),
+            (
+                {'remove': False, 'saml_attr': 'foobar', 'team_org_map': [{'organization': 'Ansible'}]},
+                {'team_org_map': {0: {'team': ['This field is required.']}}},
+            ),
+            (
+                {'remove': False, 'saml_attr': 'foobar', 'team_org_map': [{}]},
+                {'team_org_map': {0: {'organization': ['This field is required.'], 'team': ['This field is required.']}}},
+            ),
+        ],
+    )
     def test_internal_value_invalid(self, data, expected):
         field = SAMLTeamAttrField()
         with pytest.raises(ValidationError) as e:
@@ -105,17 +115,19 @@ class TestSAMLTeamAttrField():
         assert e.value.detail == expected
 
 
-class TestLDAPGroupTypeParamsField():
-
-    @pytest.mark.parametrize("group_type, data, expected", [
-        ('LDAPGroupType', {'name_attr': 'user', 'bob': ['a', 'b'], 'scooter': 'hello'},
-         ['Invalid key(s): "bob", "scooter".']),
-        ('MemberDNGroupType', {'name_attr': 'user', 'member_attr': 'west', 'bob': ['a', 'b'], 'scooter': 'hello'},
-         ['Invalid key(s): "bob", "scooter".']),
-        ('PosixUIDGroupType', {'name_attr': 'user', 'member_attr': 'west', 'ldap_group_user_attr': 'legacyThing',
-         'bob': ['a', 'b'], 'scooter': 'hello'},
-         ['Invalid key(s): "bob", "member_attr", "scooter".']),
-    ])
+class TestLDAPGroupTypeParamsField:
+    @pytest.mark.parametrize(
+        "group_type, data, expected",
+        [
+            ('LDAPGroupType', {'name_attr': 'user', 'bob': ['a', 'b'], 'scooter': 'hello'}, ['Invalid key(s): "bob", "scooter".']),
+            ('MemberDNGroupType', {'name_attr': 'user', 'member_attr': 'west', 'bob': ['a', 'b'], 'scooter': 'hello'}, ['Invalid key(s): "bob", "scooter".']),
+            (
+                'PosixUIDGroupType',
+                {'name_attr': 'user', 'member_attr': 'west', 'ldap_group_user_attr': 'legacyThing', 'bob': ['a', 'b'], 'scooter': 'hello'},
+                ['Invalid key(s): "bob", "member_attr", "scooter".'],
+            ),
+        ],
+    )
     def test_internal_value_invalid(self, group_type, data, expected):
         field = LDAPGroupTypeParamsField()
         field.get_depends_on = mock.MagicMock(return_value=group_type)
@@ -125,14 +137,16 @@ class TestLDAPGroupTypeParamsField():
         assert e.value.detail == expected
 
 
-class TestLDAPServerURIField():
-
-    @pytest.mark.parametrize("ldap_uri, exception, expected", [
-        (r'ldap://servername.com:444', None, r'ldap://servername.com:444'),
-        (r'ldap://servername.so3:444', None, r'ldap://servername.so3:444'),
-        (r'ldaps://servername3.s300:344', None, r'ldaps://servername3.s300:344'),
-        (r'ldap://servername.-so3:444', ValidationError, None),
-    ])
+class TestLDAPServerURIField:
+    @pytest.mark.parametrize(
+        "ldap_uri, exception, expected",
+        [
+            (r'ldap://servername.com:444', None, r'ldap://servername.com:444'),
+            (r'ldap://servername.so3:444', None, r'ldap://servername.so3:444'),
+            (r'ldaps://servername3.s300:344', None, r'ldaps://servername3.s300:344'),
+            (r'ldap://servername.-so3:444', ValidationError, None),
+        ],
+    )
     def test_run_validators_valid(self, ldap_uri, exception, expected):
         field = LDAPServerURIField()
         if exception is None:

awx/sso/tests/unit/test_tacacsplus.py

@@ -10,17 +10,15 @@ def test_empty_host_fails_auth(tacacsplus_backend):
 
 def test_client_raises_exception(tacacsplus_backend):
     client = mock.MagicMock()
-    client.authenticate.side_effect=Exception("foo")
-    with mock.patch('awx.sso.backends.django_settings') as settings,\
-            mock.patch('awx.sso.backends.logger') as logger,\
-            mock.patch('tacacs_plus.TACACSClient', return_value=client):
+    client.authenticate.side_effect = Exception("foo")
+    with mock.patch('awx.sso.backends.django_settings') as settings, mock.patch('awx.sso.backends.logger') as logger, mock.patch(
+        'tacacs_plus.TACACSClient', return_value=client
+    ):
         settings.TACACSPLUS_HOST = 'localhost'
         settings.TACACSPLUS_AUTH_PROTOCOL = 'ascii'
         ret_user = tacacsplus_backend.authenticate(None, u"user", u"pass")
         assert ret_user is None
-        logger.exception.assert_called_once_with(
-            "TACACS+ Authentication Error: foo"
-        )
+        logger.exception.assert_called_once_with("TACACS+ Authentication Error: foo")
 
 
 def test_client_return_invalid_fails_auth(tacacsplus_backend):
@@ -28,8 +26,7 @@ def test_client_return_invalid_fails_auth(tacacsplus_backend):
     auth.valid = False
     client = mock.MagicMock()
     client.authenticate.return_value = auth
-    with mock.patch('awx.sso.backends.django_settings') as settings,\
-            mock.patch('tacacs_plus.TACACSClient', return_value=client):
+    with mock.patch('awx.sso.backends.django_settings') as settings, mock.patch('tacacs_plus.TACACSClient', return_value=client):
         settings.TACACSPLUS_HOST = 'localhost'
         settings.TACACSPLUS_AUTH_PROTOCOL = 'ascii'
         ret_user = tacacsplus_backend.authenticate(None, u"user", u"pass")
@@ -43,9 +40,9 @@ def test_client_return_valid_passes_auth(tacacsplus_backend):
     client.authenticate.return_value = auth
     user = mock.MagicMock()
     user.has_usable_password = mock.MagicMock(return_value=False)
-    with mock.patch('awx.sso.backends.django_settings') as settings,\
-            mock.patch('tacacs_plus.TACACSClient', return_value=client),\
-            mock.patch('awx.sso.backends._get_or_set_enterprise_user', return_value=user):
+    with mock.patch('awx.sso.backends.django_settings') as settings, mock.patch('tacacs_plus.TACACSClient', return_value=client), mock.patch(
+        'awx.sso.backends._get_or_set_enterprise_user', return_value=user
+    ):
         settings.TACACSPLUS_HOST = 'localhost'
         settings.TACACSPLUS_AUTH_PROTOCOL = 'ascii'
         ret_user = tacacsplus_backend.authenticate(None, u"user", u"pass")