remove trailing whitespaces

allianceauth/groupmanagement/admin.py

@@ -10,8 +10,8 @@ from django.dispatch import receiver
 from .models import AuthGroup
 from .models import GroupRequest
 
-if 'eve_autogroups' in apps.app_configs:    
-    _has_auto_groups = True    
+if 'eve_autogroups' in apps.app_configs:
+    _has_auto_groups = True
 else:
     _has_auto_groups = False
 
@@ -20,12 +20,12 @@ class AuthGroupInlineAdmin(admin.StackedInline):
     model = AuthGroup
     filter_horizontal = ('group_leaders', 'group_leader_groups', 'states',)
     fields = (
-        'description', 
-        'group_leaders', 
-        'group_leader_groups', 
-        'states', 'internal', 
-        'hidden', 
-        'open', 
+        'description',
+        'group_leaders',
+        'group_leader_groups',
+        'states', 'internal',
+        'hidden',
+        'open',
         'public'
     )
     verbose_name_plural = 'Auth Settings'
@@ -64,12 +64,12 @@ if _has_auto_groups:
             value = self.value()
             if value == 'yes':
                 return queryset.exclude(
-                    managedalliancegroup__isnull=True, 
+                    managedalliancegroup__isnull=True,
                     managedcorpgroup__isnull=True
                 )
             elif value == 'no':
                 return queryset.filter(
-                    managedalliancegroup__isnull=True, 
+                    managedalliancegroup__isnull=True,
                     managedcorpgroup__isnull=True
                 )
             else:
@@ -96,36 +96,36 @@ class HasLeaderFilter(admin.SimpleListFilter):
             return queryset
 
 
-class GroupAdmin(admin.ModelAdmin):    
+class GroupAdmin(admin.ModelAdmin):
     list_select_related = ('authgroup',)
     ordering = ('name',)
     list_display = (
-        'name', 
-        '_description', 
-        '_properties', 
-        '_member_count', 
+        'name',
+        '_description',
+        '_properties',
+        '_member_count',
         'has_leader'
     )
     list_filter = [
-        'authgroup__internal', 
-        'authgroup__hidden', 
-        'authgroup__open', 
-        'authgroup__public',        
+        'authgroup__internal',
+        'authgroup__hidden',
+        'authgroup__open',
+        'authgroup__public',
     ]
     if _has_auto_groups:
         list_filter.append(IsAutoGroupFilter)
     list_filter.append(HasLeaderFilter)
 
     search_fields = ('name', 'authgroup__description')
-        
+
     def get_queryset(self, request):
-        qs = super().get_queryset(request)                
+        qs = super().get_queryset(request)
         if _has_auto_groups:
             qs = qs.prefetch_related('managedalliancegroup_set', 'managedcorpgroup_set')
         qs = qs.prefetch_related('authgroup__group_leaders')
         qs = qs.annotate(
             member_count=Count('user', distinct=True),
-        )        
+        )
         return qs
 
     def _description(self, obj):
@@ -136,16 +136,16 @@ class GroupAdmin(admin.ModelAdmin):
 
     _member_count.short_description = 'Members'
     _member_count.admin_order_field = 'member_count'
-    
+
     def has_leader(self, obj):
         return obj.authgroup.group_leaders.exists()
-    
-    has_leader.boolean = True    
+
+    has_leader.boolean = True
 
     def _properties(self, obj):
-        properties = list()       
+        properties = list()
         if _has_auto_groups and (
-            obj.managedalliancegroup_set.exists() 
+            obj.managedalliancegroup_set.exists()
             or obj.managedcorpgroup_set.exists()
         ):
             properties.append('Auto Group')
@@ -160,7 +160,7 @@ class GroupAdmin(admin.ModelAdmin):
                 properties.append('Public')
         if not properties:
             properties.append('Default')
-                    
+
         return properties
 
     _properties.short_description = "properties"
@@ -183,19 +183,19 @@ finally:
 
 
 @admin.register(GroupRequest)
-class GroupRequestAdmin(admin.ModelAdmin):        
+class GroupRequestAdmin(admin.ModelAdmin):
     search_fields = ('user__username', )
     list_display = ('id', 'group', 'user', '_leave_request', 'status')
     list_filter = (
         ('group', admin.RelatedOnlyFieldListFilter),
         ('user', admin.RelatedOnlyFieldListFilter),
-        'leave_request', 
+        'leave_request',
         'status'
     )
 
     def _leave_request(self, obj) -> True:
         return obj.leave_request
-    
+
     _leave_request.short_description = 'is leave request'
     _leave_request.boolean = True
 

allianceauth/groupmanagement/managers.py

@@ -11,7 +11,7 @@ logger = logging.getLogger(__name__)
 
 
 class GroupManager:
-    
+
     @classmethod
     def get_joinable_groups_for_user(
         cls, user: User, include_hidden = True
@@ -21,7 +21,7 @@ class GroupManager:
 
         if not user.has_perm('groupmanagement.request_groups'):
             groups_qs = groups_qs.filter(authgroup__public=True)
-        
+
         if not include_hidden:
             groups_qs = groups_qs.filter(authgroup__hidden=False)
 
@@ -57,7 +57,7 @@ class GroupManager:
         :param state: allianceauth.authentication.State object
         :return: bool True if its joinable, False otherwise
         """
-        if (len(group.authgroup.states.all()) != 0 
+        if (len(group.authgroup.states.all()) != 0
             and state not in group.authgroup.states.all()
         ):
             return False
@@ -106,7 +106,7 @@ class GroupManager:
     @classmethod
     def pending_requests_count_for_user(cls, user: User) -> int:
         """Returns the number of pending group requests for the given user"""
-        
+
         if cls.has_management_permission(user):
             return GroupRequest.objects.filter(status="pending").count()
         else:

allianceauth/groupmanagement/signals.py

@@ -10,7 +10,7 @@ logger = logging.getLogger(__name__)
 def check_groups_on_state_change(sender, user, state, **kwargs):
     logger.debug(
         "Checking group memberships for %s based on new state %s" % (user, state)
-    )        
+    )
     state_groups = (
         user.groups.select_related("authgroup").exclude(authgroup__states=None)
     )
@@ -18,5 +18,5 @@ def check_groups_on_state_change(sender, user, state, **kwargs):
         if not group.authgroup.states.filter(id=state.id).exists():
             logger.info(
                 "Removing user %s from group %s due to missing state" % (user, group)
-            )        
+            )
             user.groups.remove(group)

allianceauth/groupmanagement/templates/groupmanagement/index.html

@@ -42,9 +42,9 @@
 
         <div class="panel panel-default panel-tabs-aa">
             <div class="panel-body">
-                <div class="tab-content">                    
-                    
-                    <div id="add" class="tab-pane active">                
+                <div class="tab-content">
+
+                    <div id="add" class="tab-pane active">
                         {% if acceptrequests %}
                             <div class="table-responsive">
                                 <table class="table table-aa">
@@ -98,9 +98,9 @@
                         {% else %}
                             <div class="alert alert-warning text-center">{% trans "No group add requests." %}</div>
                         {% endif %}
-                    </div>            
-                    
-                    <div id="leave" class="tab-pane">                
+                    </div>
+
+                    <div id="leave" class="tab-pane">
                         {% if leaverequests %}
                             <div class="table-responsive">
                                 <table class="table table-aa">

allianceauth/groupmanagement/tests/test_admin.py

@@ -26,7 +26,7 @@ MODULE_PATH = 'allianceauth.groupmanagement.admin'
 
 
 class MockRequest(object):
-    
+
     def __init__(self, user=None):
         self.user = user
 
@@ -38,7 +38,7 @@ class TestGroupAdmin(TestCase):
         super().setUpClass()
 
         # group 1 - has leader
-        cls.group_1 = Group.objects.create(name='Group 1')        
+        cls.group_1 = Group.objects.create(name='Group 1')
         cls.group_1.authgroup.description = 'Default Group'
         cls.group_1.authgroup.internal = False
         cls.group_1.authgroup.hidden = False
@@ -47,7 +47,7 @@ class TestGroupAdmin(TestCase):
         # group 2 - no leader
         cls.group_2 = Group.objects.create(name='Group 2')
         cls.group_2.authgroup.description = 'Internal Group'
-        cls.group_2.authgroup.internal = True        
+        cls.group_2.authgroup.internal = True
         cls.group_2.authgroup.save()
 
         # group 3 - has leader
@@ -81,7 +81,7 @@ class TestGroupAdmin(TestCase):
         cls.group_6.authgroup.open = True
         cls.group_6.authgroup.public = True
         cls.group_6.authgroup.save()
-        
+
         # user 1 - corp and alliance, normal user
         cls.character_1 = EveCharacter.objects.create(
             character_id=1001,
@@ -106,16 +106,16 @@ class TestGroupAdmin(TestCase):
         alliance = EveAllianceInfo.objects.create(
             alliance_id=3001,
             alliance_name='Wayne Enterprises',
-            alliance_ticker='WE',            
+            alliance_ticker='WE',
             executor_corp_id=2001
         )
         EveCorporationInfo.objects.create(
             corporation_id=2001,
             corporation_name='Wayne Technologies',
-            corporation_ticker='WT',            
+            corporation_ticker='WT',
             member_count=42,
             alliance=alliance
-        )        
+        )
         cls.user_1 = User.objects.create_user(
             cls.character_1.character_name.replace(' ', '_'),
             'abc@example.com',
@@ -148,7 +148,7 @@ class TestGroupAdmin(TestCase):
         EveCorporationInfo.objects.create(
             corporation_id=2002,
             corporation_name='Daily Plane',
-            corporation_ticker='DP',            
+            corporation_ticker='DP',
             member_count=99,
             alliance=None
         )
@@ -167,7 +167,7 @@ class TestGroupAdmin(TestCase):
         cls.user_2.groups.add(cls.group_2)
         cls.user_2.is_staff = True
         cls.user_2.save()
-        
+
         # user 3 - no main, no group, superuser
         cls.character_3 = EveCharacter.objects.create(
             character_id=1101,
@@ -180,7 +180,7 @@ class TestGroupAdmin(TestCase):
         EveCorporationInfo.objects.create(
             corporation_id=2101,
             corporation_name='Lex Corp',
-            corporation_ticker='LC',            
+            corporation_ticker='LC',
             member_count=666,
             alliance=None
         )
@@ -222,7 +222,7 @@ class TestGroupAdmin(TestCase):
             for state in State.objects.all():
                 autogroups_config.states.add(state)
             autogroups_config.update_corp_group_membership(self.user_1)
-    
+
     # column rendering
 
     def test_description(self):
@@ -230,14 +230,14 @@ class TestGroupAdmin(TestCase):
         result = self.modeladmin._description(self.group_1)
         self.assertEqual(result, expected)
 
-    def test_member_count(self):        
+    def test_member_count(self):
         expected = 1
         obj = self.modeladmin.get_queryset(MockRequest(user=self.user_1))\
             .get(pk=self.group_1.pk)
         result = self.modeladmin._member_count(obj)
         self.assertEqual(result, expected)
 
-    def test_has_leader(self):        
+    def test_has_leader(self):
         result = self.modeladmin.has_leader(self.group_1)
         self.assertTrue(result)
 
@@ -283,17 +283,17 @@ class TestGroupAdmin(TestCase):
             self.assertListEqual(result, expected)
 
     # actions
-   
+
     # filters
-    
+
     if _has_auto_groups:
         @patch(MODULE_PATH + '._has_auto_groups', True)
         def test_filter_is_auto_group(self):
-            
-            class GroupAdminTest(admin.ModelAdmin): 
+
+            class GroupAdminTest(admin.ModelAdmin):
                 list_filter = (IsAutoGroupFilter,)
-                    
-            self._create_autogroups()        
+
+            self._create_autogroups()
             my_modeladmin = GroupAdminTest(Group, AdminSite())
 
             # Make sure the lookups are correct
@@ -333,17 +333,17 @@ class TestGroupAdmin(TestCase):
             changelist = my_modeladmin.get_changelist_instance(request)
             queryset = changelist.get_queryset(request)
             expected = Group.objects.exclude(
-                managedalliancegroup__isnull=True, 
+                managedalliancegroup__isnull=True,
                 managedcorpgroup__isnull=True
             )
             self.assertSetEqual(set(queryset), set(expected))
-         
+
     def test_filter_has_leader(self):
-        
-        class GroupAdminTest(admin.ModelAdmin): 
+
+        class GroupAdminTest(admin.ModelAdmin):
             list_filter = (HasLeaderFilter,)
-                
-        self._create_autogroups()        
+
+        self._create_autogroups()
         my_modeladmin = GroupAdminTest(Group, AdminSite())
 
         # Make sure the lookups are correct
@@ -378,16 +378,16 @@ class TestGroupAdmin(TestCase):
         changelist = my_modeladmin.get_changelist_instance(request)
         queryset = changelist.get_queryset(request)
         expected = [
-            self.group_1,            
+            self.group_1,
             self.group_3
         ]
         self.assertSetEqual(set(queryset), set(expected))
-    
+
     def test_change_view_loads_normally(self):
         User.objects.create_superuser(
             username='superuser', password='secret', email='admin@example.com'
         )
         c = Client()
-        c.login(username='superuser', password='secret')                
+        c.login(username='superuser', password='secret')
         response = c.get(get_admin_change_view_url(self.group_1))
         self.assertEqual(response.status_code, 200)

allianceauth/groupmanagement/tests/test_managers.py

@@ -46,7 +46,7 @@ class GroupManagementVisibilityTestCase(TestCase):
 
         self.assertIn(self.group1, groups)  #avail due to user
         self.assertNotIn(self.group2, groups)  #not avail due to group
-        self.assertNotIn(self.group3, groups)  #not avail at all 
+        self.assertNotIn(self.group3, groups)  #not avail at all
 
         self.user.groups.add(self.group1)
         self._refresh_user()
@@ -60,7 +60,7 @@ class GroupManagementVisibilityTestCase(TestCase):
         self.assertTrue(GroupManager.can_manage_group(self.user, self.group1))
         self.assertFalse(GroupManager.can_manage_group(self.user, self.group2))
         self.assertFalse(GroupManager.can_manage_group(self.user, self.group3))
-        
+
         self.group2.authgroup.group_leader_groups.add(self.group1)
         self.group1.authgroup.group_leaders.remove(self.user)
         self._refresh_user()
@@ -71,13 +71,13 @@ class GroupManagementVisibilityTestCase(TestCase):
 
 
 class TestGroupManager(TestCase):
-        
+
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
 
         # group 1
-        cls.group_default = Group.objects.create(name='default')        
+        cls.group_default = Group.objects.create(name='default')
         cls.group_default.authgroup.description = 'Default Group'
         cls.group_default.authgroup.internal = False
         cls.group_default.authgroup.hidden = False
@@ -86,7 +86,7 @@ class TestGroupManager(TestCase):
         # group 2
         cls.group_internal = Group.objects.create(name='internal')
         cls.group_internal.authgroup.description = 'Internal Group'
-        cls.group_internal.authgroup.internal = True        
+        cls.group_internal.authgroup.internal = True
         cls.group_internal.authgroup.save()
 
         # group 3
@@ -133,19 +133,19 @@ class TestGroupManager(TestCase):
             AuthUtils.get_member_state()
         )
         cls.group_default_member.authgroup.save()
-    
+
     def setUp(self):
         self.user = AuthUtils.create_user('Bruce Wayne')
 
-    def test_get_joinable_group_member(self):        
+    def test_get_joinable_group_member(self):
         result = GroupManager.get_joinable_groups(
             AuthUtils.get_member_state()
         )
         expected = {
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
             self.group_public_2,
             self.group_default_member
         }
@@ -156,10 +156,10 @@ class TestGroupManager(TestCase):
             AuthUtils.get_guest_state()
         )
         expected = {
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
             self.group_public_2
         }
         self.assertSetEqual(set(result), expected)
@@ -167,27 +167,27 @@ class TestGroupManager(TestCase):
     def test_joinable_group_member(self):
         member_state = AuthUtils.get_member_state()
         for x in [
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
             self.group_public_2,
             self.group_default_member
         ]:
             self.assertTrue(GroupManager.joinable_group(x, member_state))
 
         for x in [
-            self.group_internal,             
+            self.group_internal,
         ]:
             self.assertFalse(GroupManager.joinable_group(x, member_state))
 
     def test_joinable_group_guest(self):
         guest_state = AuthUtils.get_guest_state()
         for x in [
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
             self.group_public_2
         ]:
             self.assertTrue(GroupManager.joinable_group(x, guest_state))
@@ -201,11 +201,11 @@ class TestGroupManager(TestCase):
     def test_get_all_non_internal_groups(self):
         result = GroupManager.get_all_non_internal_groups()
         expected = {
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
-            self.group_public_2, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
+            self.group_public_2,
             self.group_default_member
         }
         self.assertSetEqual(set(result), expected)
@@ -231,10 +231,10 @@ class TestGroupManager(TestCase):
         )
         result = GroupManager.get_joinable_groups_for_user(self.user)
         expected = {
-            self.group_default, 
-            self.group_hidden, 
-            self.group_open, 
-            self.group_public_1, 
+            self.group_default,
+            self.group_hidden,
+            self.group_open,
+            self.group_public_1,
             self.group_public_2
         }
         self.assertSetEqual(set(result), expected)
@@ -265,69 +265,69 @@ class TestGroupManager(TestCase):
         )
         expected = {
             self.group_default,
-            self.group_open, 
-            self.group_public_1,            
+            self.group_open,
+            self.group_public_1,
             self.group_default_member
         }
         self.assertSetEqual(set(result), expected)
 
-    def test_has_management_permission(self):        
+    def test_has_management_permission(self):
         user = AuthUtils.create_user('Clark Kent')
         AuthUtils.add_permission_to_user_by_name(
             'auth.group_management', user
-        )        
+        )
         self.assertTrue(GroupManager.has_management_permission(user))
 
-    def test_can_manage_groups_no_perm_no_group(self):        
+    def test_can_manage_groups_no_perm_no_group(self):
         user = AuthUtils.create_user('Clark Kent')
         self.assertFalse(GroupManager.can_manage_groups(user))
 
-    def test_can_manage_groups_user_not_authenticated(self):        
+    def test_can_manage_groups_user_not_authenticated(self):
         user = MockUserNotAuthenticated()
         self.assertFalse(GroupManager.can_manage_groups(user))
 
-    def test_can_manage_groups_has_perm(self):        
+    def test_can_manage_groups_has_perm(self):
         user = AuthUtils.create_user('Clark Kent')
         AuthUtils.add_permission_to_user_by_name(
             'auth.group_management', user
-        )        
+        )
         self.assertTrue(GroupManager.can_manage_groups(user))
 
-    def test_can_manage_groups_no_perm_leads_group(self):        
+    def test_can_manage_groups_no_perm_leads_group(self):
         user = AuthUtils.create_user('Clark Kent')
         self.group_default.authgroup.group_leaders.add(user)
         self.assertTrue(GroupManager.can_manage_groups(user))
 
-    def test_can_manage_group_no_perm_no_group(self):        
+    def test_can_manage_group_no_perm_no_group(self):
         user = AuthUtils.create_user('Clark Kent')
         self.assertFalse(
             GroupManager.can_manage_group(user, self.group_default)
         )
 
-    def test_can_manage_group_has_perm(self):        
+    def test_can_manage_group_has_perm(self):
         user = AuthUtils.create_user('Clark Kent')
         AuthUtils.add_permission_to_user_by_name(
             'auth.group_management', user
-        )        
+        )
         self.assertTrue(
             GroupManager.can_manage_group(user, self.group_default)
         )
 
-    def test_can_manage_group_no_perm_leads_correct_group(self):        
+    def test_can_manage_group_no_perm_leads_correct_group(self):
         user = AuthUtils.create_user('Clark Kent')
         self.group_default.authgroup.group_leaders.add(user)
         self.assertTrue(
             GroupManager.can_manage_group(user, self.group_default)
         )
 
-    def test_can_manage_group_no_perm_leads_other_group(self):        
+    def test_can_manage_group_no_perm_leads_other_group(self):
         user = AuthUtils.create_user('Clark Kent')
         self.group_hidden.authgroup.group_leaders.add(user)
         self.assertFalse(
             GroupManager.can_manage_group(user, self.group_default)
         )
 
-    def test_can_manage_group_user_not_authenticated(self):        
+    def test_can_manage_group_user_not_authenticated(self):
         user = MockUserNotAuthenticated()
         self.assertFalse(
             GroupManager.can_manage_group(user, self.group_default)
@@ -335,7 +335,7 @@ class TestGroupManager(TestCase):
 
 
 class TestPendingRequestsCountForUser(TestCase):
-            
+
     def setUp(self) -> None:
         self.group_1 = Group.objects.create(name="Group 1")
         self.group_2 = Group.objects.create(name="Group 2")
@@ -345,8 +345,8 @@ class TestPendingRequestsCountForUser(TestCase):
         self.group_2.authgroup.group_leaders.add(self.user_leader_2)
         self.user_requestor = AuthUtils.create_member('Bruce Wayne')
 
-    def test_single_request_for_leader(self):        
-        # given user_leader_1 is leader of group_1 
+    def test_single_request_for_leader(self):
+        # given user_leader_1 is leader of group_1
         # and user_leader_2 is leader of group_2
         # when user_requestor is requesting access to group 1
         # then return 1 for user_leader 1 and 0 for user_leader_2
@@ -359,7 +359,7 @@ class TestPendingRequestsCountForUser(TestCase):
         self.assertEqual(
             GroupManager.pending_requests_count_for_user(self.user_leader_2), 0
         )
-  
+
     def test_return_none_for_none_leader(self):
         # given user_requestor is leader of no group
         # when user_requestor is requesting access to group 1
@@ -370,7 +370,7 @@ class TestPendingRequestsCountForUser(TestCase):
         self.assertEqual(
             GroupManager.pending_requests_count_for_user(self.user_requestor), 0
         )
-   
+
     def test_single_leave_request(self):
         # given user_leader_2 is leader of group_2
         # and user_requestor is member of group 2
@@ -379,9 +379,9 @@ class TestPendingRequestsCountForUser(TestCase):
         self.user_requestor.groups.add(self.group_2)
 
         GroupRequest.objects.create(
-            status="pending", 
-            user=self.user_requestor, 
-            group=self.group_2, 
+            status="pending",
+            user=self.user_requestor,
+            group=self.group_2,
             leave_request=True
         )
         self.assertEqual(
@@ -391,31 +391,31 @@ class TestPendingRequestsCountForUser(TestCase):
     def test_join_and_leave_request(self):
         # given user_leader_2 is leader of group_2
         # and user_requestor is member of group 2
-        # when user_requestor is requesting to leave group 2 
+        # when user_requestor is requesting to leave group 2
         # and user_requestor_2 is requesting to join group 2
         # then return 2 for user_leader_2
         self.user_requestor.groups.add(self.group_2)
         user_requestor_2 = AuthUtils.create_member("Lex Luther")
         GroupRequest.objects.create(
-            status="pending", 
-            user=user_requestor_2, 
-            group=self.group_2             
+            status="pending",
+            user=user_requestor_2,
+            group=self.group_2
         )
         GroupRequest.objects.create(
-            status="pending", 
-            user=self.user_requestor, 
-            group=self.group_2, 
+            status="pending",
+            user=self.user_requestor,
+            group=self.group_2,
             leave_request=True
         )
         self.assertEqual(
             GroupManager.pending_requests_count_for_user(self.user_leader_2), 2
         )
 
-    def test_single_request_for_user_with_management_perm(self):        
+    def test_single_request_for_user_with_management_perm(self):
         # given user_leader_4 which is leafer of no group
         # but has the management permissions
         # when user_requestor is requesting access to group 1
-        # then return 1 for user_leader_4        
+        # then return 1 for user_leader_4
         user_leader_4 = AuthUtils.create_member("Lex Luther")
         AuthUtils.add_permission_to_user_by_name("auth.group_management", user_leader_4)
         user_leader_4 = User.objects.get(pk=user_leader_4.pk)

allianceauth/groupmanagement/tests/test_models.py

@@ -11,7 +11,7 @@ from allianceauth.eveonline.models import (
 from ..models import GroupRequest, RequestLog
 
 
-def create_testdata():    
+def create_testdata():
     # clear DB
     User.objects.all().delete()
     Group.objects.all().delete()
@@ -20,13 +20,13 @@ def create_testdata():
     EveAllianceInfo.objects.all().delete()
 
     # group 1
-    group = Group.objects.create(name='Superheros')        
+    group = Group.objects.create(name='Superheros')
     group.authgroup.description = 'Default Group'
     group.authgroup.internal = False
     group.authgroup.hidden = False
     group.authgroup.save()
-    
-    # user 1        
+
+    # user 1
     user_1 = AuthUtils.create_user('Bruce Wayne')
     AuthUtils.add_main_character_2(
         user_1,
@@ -34,7 +34,7 @@ def create_testdata():
         character_id=1001,
         corp_id=2001,
         corp_name='Wayne Technologies'
-    )        
+    )
     user_1.groups.add(group)
     group.authgroup.group_leaders.add(user_1)
 
@@ -46,13 +46,13 @@ def create_testdata():
         character_id=1002,
         corp_id=2002,
         corp_name='Wayne Technologies'
-    )            
+    )
     return group, user_1, user_2
 
 
 
 class TestGroupRequest(TestCase):
-    
+
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
@@ -78,7 +78,7 @@ class TestGroupRequest(TestCase):
 
 
 class TestRequestLog(TestCase):
-    
+
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
@@ -124,7 +124,7 @@ class TestRequestLog(TestCase):
         self.assertEqual(request_log.type_to_str(), expected)
 
     def test_action_to_str_accept(self):
-        request_log = RequestLog.objects.create(            
+        request_log = RequestLog.objects.create(
             group=self.group,
             request_info='Clark Kent:Superheros',
             request_actor=self.user_1,
@@ -134,7 +134,7 @@ class TestRequestLog(TestCase):
         self.assertEqual(request_log.action_to_str(), expected)
 
     def test_action_to_str_reject(self):
-        request_log = RequestLog.objects.create(            
+        request_log = RequestLog.objects.create(
             group=self.group,
             request_info='Clark Kent:Superheros',
             request_actor=self.user_1,
@@ -144,7 +144,7 @@ class TestRequestLog(TestCase):
         self.assertEqual(request_log.action_to_str(), expected)
 
     def test_req_char(self):
-        request_log = RequestLog.objects.create(            
+        request_log = RequestLog.objects.create(
             group=self.group,
             request_info='Clark Kent:Superheros',
             request_actor=self.user_1,
@@ -157,7 +157,7 @@ class TestRequestLog(TestCase):
 class TestAuthGroup(TestCase):
 
     def test_str(self):
-        group = Group.objects.create(name='Superheros')        
+        group = Group.objects.create(name='Superheros')
         group.authgroup.description = 'Default Group'
         group.authgroup.internal = False
         group.authgroup.hidden = False

allianceauth/groupmanagement/tests/test_signals.py

@@ -14,7 +14,7 @@ class TestCheckGroupsOnStateChange(TestCase):
         cls.character = AuthUtils.add_main_character_2(
             cls.user, 'test character', 1001, corp_id=2001, corp_name='test corp 1', corp_ticker='TEST'
         )
-        cls.user.profile.refresh_from_db()        
+        cls.user.profile.refresh_from_db()
         cls.corp_1 = EveCorporationInfo.objects.create(
             corporation_id=2001, corporation_name='test corp 1', corporation_ticker='C1', member_count=1
         )
@@ -24,13 +24,13 @@ class TestCheckGroupsOnStateChange(TestCase):
         cls.guest_state = AuthUtils.get_guest_state()
         cls.test_state_1 = AuthUtils.create_state('test_state_1', 500)
         cls.test_state_2 = AuthUtils.create_state('test_state_2', 600)
-        
+
     def setUp(self):
-        self.user.refresh_from_db()        
+        self.user.refresh_from_db()
 
     def _refresh_user(self):
         self.user = User.objects.get(pk=self.user.pk)
-    
+
     def test_drop_state_group(self):
         """
         given user is member of: state group, normal group and auto group
@@ -39,29 +39,29 @@ class TestCheckGroupsOnStateChange(TestCase):
         and remains member of normal group and auto group
         """
         # setup
-        state_group = Group.objects.create(name='state_group')        
+        state_group = Group.objects.create(name='state_group')
         state_group.authgroup.states.add(self.test_state_1)
         state_group.authgroup.internal = False
         state_group.save()
         normal_group = Group.objects.create(name='normal_group')
         normal_group.authgroup.internal = False
         normal_group.save()
-        internal_group = Group.objects.create(name='internal_group')        
+        internal_group = Group.objects.create(name='internal_group')
         autogroup_config = AutogroupsConfig.objects.create(corp_groups=True)
         autogroup_config.states.add(self.test_state_1)
         autogroup_config.states.add(self.guest_state)
         auto_group = autogroup_config.corp_managed_groups.first()
-        internal_state_group = Group.objects.create(name='internal_state_group')        
+        internal_state_group = Group.objects.create(name='internal_state_group')
         internal_state_group.authgroup.states.add(self.test_state_1)
         self.test_state_1.member_corporations.add(self.corp_1)
         self.user.groups.add(normal_group)
         self.user.groups.add(internal_group)
-        self.user.groups.add(state_group)        
-        self.user.groups.add(internal_state_group)        
-        
+        self.user.groups.add(state_group)
+        self.user.groups.add(internal_state_group)
+
         # user changes state back to guest
         self.test_state_1.member_corporations.clear()
-        
+
         # assert
         self._refresh_user()
         self.assertEqual(self.user.profile.state, self.guest_state)
@@ -79,22 +79,21 @@ class TestCheckGroupsOnStateChange(TestCase):
         then user remains member of that group
         """
         # setup
-        state_group = Group.objects.create(name='state_group')        
+        state_group = Group.objects.create(name='state_group')
         state_group.authgroup.states.add(self.test_state_1)
         state_group.authgroup.states.add(self.test_state_2)
-                
+
         self.test_state_1.member_corporations.add(self.corp_1)
         self.test_state_2.member_corporations.add(self.corp_2)
         self.user.groups.add(state_group)
-        
+
         # user changes state back to guest
         self.character.corporation_id = 2002
         self.character.corporation_name = "test corp 2"
         self.character.save()
-        
+
         # assert
         self._refresh_user()
         self.assertEqual(self.user.profile.state, self.test_state_2)
-        groups = self.user.groups.all()        
+        groups = self.user.groups.all()
         self.assertIn(state_group, groups)
-        

allianceauth/groupmanagement/tests/test_views.py

@@ -10,13 +10,13 @@ from .. import views
 
 
 class TestViews(TestCase):
-        
+
     def setUp(self):
         self.factory = RequestFactory()
-        self.user = AuthUtils.create_user('Bruce Wayne')        
+        self.user = AuthUtils.create_user('Bruce Wayne')
 
     def test_groups_view_can_load(self):
         request = self.factory.get(reverse('groupmanagement:groups'))
         request.user = self.user
         response = views.groups_view(request)
-        self.assertEqual(response.status_code, 200)        
+        self.assertEqual(response.status_code, 200)