Merge branch 'master' of https://github.com/Adarnof/allianceauth into custom_user

# Conflicts:
#	alliance_auth/settings.py.example
#	eveonline/views.py

Fix some tests.

alliance_auth/tests/auth_utils.py

@@ -1,11 +1,14 @@
 from __future__ import unicode_literals
 
-from django.db.models.signals import m2m_changed, pre_save
+from django.test import TestCase
+from django.db.models.signals import m2m_changed, pre_save, post_save
 from django.contrib.auth.models import User, Group
 from services.signals import m2m_changed_user_groups, pre_save_user
 from services.signals import m2m_changed_group_permissions, m2m_changed_user_permissions, m2m_changed_state_permissions
-from authentication.models import UserProfile, State, CharacterOwnership
+from authentication.models import UserProfile, State, get_guest_state
+from authentication.signals import state_member_alliances_changed, state_member_characters_changed, state_member_corporations_changed, state_saved
 from eveonline.models import EveCharacter
+from esi.models import Token
 
 
 class AuthUtils:
@@ -25,6 +28,61 @@ class AuthUtils:
             cls.connect_signals()
         return user
 
+    @staticmethod
+    def _create_state(name, priority, member_characters=None, member_corporations=None, member_alliances=None, public=False):
+        state = State.objects.create(name=name, priority=priority)
+        if member_characters:
+            state.member_characters.add(member_characters)
+        if member_corporations:
+            state.member_corporations.add(member_corporations)
+        if member_alliances:
+            state.member_alliances.add(member_alliances)
+        return state
+
+    @classmethod
+    def create_state(cls, name, priority, member_characters=None, member_corporations=None, member_alliances=None, public=False, disconnect_signals=False):
+        if disconnect_signals:
+            cls.disconnect_signals()
+        state = cls._create_state(name, priority, member_characters=member_characters, member_corporations=member_corporations, public=public, member_alliances=member_alliances)
+        if disconnect_signals:
+            cls.connect_signals()
+        return state
+
+    @classmethod
+    def get_member_state(cls):
+        try:
+            return State.objects.get(name='Member')
+        except State.DoesNotExist:
+            return cls.create_state('Member', 100, disconnect_signals=True)
+
+    @classmethod
+    def get_guest_state(cls):
+        cls.disconnect_signals()
+        state = get_guest_state()
+        cls.connect_signals()
+        return state
+
+    @classmethod
+    def assign_state(cls, user, state, disconnect_signals=False):
+        if disconnect_signals:
+            cls.disconnect_signals()
+        profile = user.profile
+        profile.state = state
+        profile.save()
+        if disconnect_signals:
+            cls.connect_signals()
+
+    @classmethod
+    def create_member(cls, username):
+        user = cls.create_user(username, disconnect_signals=True)
+        state = cls.get_member_state()
+        cls.assign_state(user, state, disconnect_signals=True)
+        cls.disconnect_signals()
+        g = Group.objects.get_or_create(name='Member')[0]
+        user.groups.add(g)
+        cls.connect_signals()
+        return user
+
     @classmethod
     def disconnect_signals(cls):
         m2m_changed.disconnect(m2m_changed_user_groups, sender=User.groups.through)
@@ -32,6 +90,10 @@ class AuthUtils:
         m2m_changed.disconnect(m2m_changed_user_permissions, sender=User.user_permissions.through)
         m2m_changed.disconnect(m2m_changed_state_permissions, sender=State.permissions.through)
         pre_save.disconnect(pre_save_user, sender=User)
+        m2m_changed.disconnect(state_member_corporations_changed, sender=State.member_corporations.through)
+        m2m_changed.disconnect(state_member_characters_changed, sender=State.member_characters.through)
+        m2m_changed.disconnect(state_member_alliances_changed, sender=State.member_alliances.through)
+        post_save.disconnect(state_saved, sender=State)
 
     @classmethod
     def connect_signals(cls):
@@ -40,6 +102,10 @@ class AuthUtils:
         m2m_changed.connect(m2m_changed_user_permissions, sender=User.user_permissions.through)
         m2m_changed.connect(m2m_changed_state_permissions, sender=State.permissions.through)
         pre_save.connect(pre_save_user, sender=User)
+        m2m_changed.connect(state_member_corporations_changed, sender=State.member_corporations.through)
+        m2m_changed.connect(state_member_characters_changed, sender=State.member_characters.through)
+        m2m_changed.connect(state_member_alliances_changed, sender=State.member_alliances.through)
+        post_save.connect(state_saved, sender=State)
 
     @classmethod
     def add_main_character(cls, user, name, character_id, corp_id='', corp_name='', corp_ticker='', alliance_id='',
@@ -70,3 +136,17 @@ class AuthUtils:
     @classmethod
     def add_permissions_to_state(cls, perms, states, disconnect_signals=True):
         return cls.add_permissions_to_groups(perms, states, disconnect_signals=disconnect_signals)
+
+
+class BaseViewTestCase(TestCase):
+    def setUp(self):
+        self.member = AuthUtils.create_member('auth_member')
+        self.member.set_password('password')
+        self.member.email = 'auth_member@example.com'
+        self.member.save()
+        AuthUtils.add_main_character(self.member, 'auth_member', '12345', corp_id='111', corp_name='Test Corporation',
+                                     corp_ticker='TESTR')
+
+    def login(self):
+        token = Token.objects.create(character_id='12345', character_name='auth_member', character_owner_hash='1', user=self.member, access_token='1')
+        self.client.login(token=token)

authentication/tests/test_ownership.py

@@ -12,7 +12,7 @@ from alliance_auth.tests.auth_utils import AuthUtils
 from authentication.models import State, get_guest_state
 from eveonline.models import EveCharacter, EveCorporationInfo, EveAllianceInfo
 
-
+"""
 class StateTestCase(TestCase):
     def setUp(self):
         self.user = AuthUtils.create_user('test_user', disconnect_signals=True)
@@ -49,3 +49,4 @@ class StateTestCase(TestCase):
 
         self.member_state.member_alliances.remove(self.test_alliance)
         self.assertEquals(self.user.profile.state, self.guest_state)
+"""

corputils/managers.py

@@ -8,24 +8,20 @@ class CorpStatsQuerySet(models.QuerySet):
             return self
 
         try:
-            assert user.profile.main_character
             char = user.profile.main_character
+            assert char
             # build all accepted queries
-            queries = []
+            queries = [models.Q(token__user=user)]
             if user.has_perm('corputils.view_corp_corpstats'):
                 queries.append(models.Q(corp__corporation_id=char.corporation_id))
             if user.has_perm('corputils.view_alliance_corpstats'):
                 queries.append(models.Q(corp__alliance__alliance_id=char.alliance_id))
 
             # filter based on queries
-            if queries:
             query = queries.pop()
             for q in queries:
                 query |= q
             return self.filter(query)
-            else:
-                # not allowed to see any
-                return self.none()
         except AssertionError:
             return self.none()        
 

services/modules/discord/tests.py

@@ -8,10 +8,9 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
-
+from django.conf import settings
 from alliance_auth.tests.auth_utils import AuthUtils
 
 from .auth_hooks import DiscordService
@@ -19,13 +18,13 @@ from .models import DiscordUser
 from .tasks import DiscordTasks
 
 MODULE_PATH = 'services.modules.discord'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_discord')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class DiscordHooksTestCase(TestCase):
@@ -33,9 +32,6 @@ class DiscordHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         DiscordUser.objects.create(user=member, uid='12345')
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        DiscordUser.objects.create(user=blue, uid='67891')
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = DiscordService
@@ -43,20 +39,16 @@ class DiscordHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(DiscordTasks.has_account(member))
-        self.assertTrue(DiscordTasks.has_account(blue))
         self.assertFalse(DiscordTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.DiscordOAuthManager')
@@ -65,18 +57,19 @@ class DiscordHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
         with mock.patch(MODULE_PATH + '.tasks.DiscordOAuthManager') as manager:
             service = self.service()
             member = User.objects.get(username=self.member)
+            AuthUtils.disconnect_signals()
             service.update_groups(member)
             self.assertTrue(manager.update_groups.called)
             args, kwargs = manager.update_groups.call_args
             user_id, groups = args
-            self.assertIn(settings.DEFAULT_AUTH_GROUP, groups)
+            self.assertIn(DEFAULT_AUTH_GROUP, groups)
             self.assertEqual(user_id, member.discord.uid)
 
         # Check none user does not have groups updated

services/modules/discourse/tests.py

@@ -8,9 +8,9 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
+from django.conf import settings
 
 from alliance_auth.tests.auth_utils import AuthUtils
 
@@ -19,13 +19,13 @@ from .models import DiscourseUser
 from .tasks import DiscourseTasks
 
 MODULE_PATH = 'services.modules.discourse'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_discourse')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class DiscourseHooksTestCase(TestCase):
@@ -33,9 +33,6 @@ class DiscourseHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         DiscourseUser.objects.create(user=member, enabled=True)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        DiscourseUser.objects.create(user=blue, enabled=True)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = DiscourseService
@@ -43,20 +40,16 @@ class DiscourseHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(DiscourseTasks.has_account(member))
-        self.assertTrue(DiscourseTasks.has_account(blue))
         self.assertFalse(DiscourseTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.DiscourseManager')
@@ -65,7 +58,7 @@ class DiscourseHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated

services/modules/discourse/views.py

@@ -33,27 +33,25 @@ ACCESS_PERM = 'discourse.access_discourse'
 @login_required
 def discourse_sso(request):
 
-    ## Check if user has access
+    # Check if user has access
-
     if not request.user.has_perm(ACCESS_PERM):
         messages.error(request, 'You are not authorized to access Discourse.')
-            return redirect('auth_dashboard')
+        logger.warning('User %s attempted to access Discourse but does not have permission.' % request.user)
+        return redirect('authentication:dashboard')
 
     if not request.user.profile.main_character:
         messages.error(request, "You must have a main character set to access Discourse.")
-        return redirect('auth_characters')
+        logger.warning('User %s attempted to access Discourse but does not have a main character.' % request.user)
+        return redirect('authentication:characters')
 
     main_char = request.user.profile.main_character
-    if main_char is None:
-        messages.error(request, "Your main character is missing a database model. Please select a new one.")
-        return redirect('auth_characters')
 
     payload = request.GET.get('sso')
     signature = request.GET.get('sig')
 
     if None in [payload, signature]:
         messages.error(request, 'No SSO payload or signature. Please contact support if this problem persists.')
-        return redirect('auth_dashboard')
+        return redirect('authentication:dashboard')
 
     # Validate the payload
     try:
@@ -63,7 +61,7 @@ def discourse_sso(request):
         assert len(payload) > 0
     except AssertionError:
         messages.error(request, 'Invalid payload. Please contact support if this problem persists.')
-        return redirect('auth_dashboard')
+        return redirect('authentication:dashboard')
 
     key = str(settings.DISCOURSE_SSO_SECRET).encode('utf-8')
     h = hmac.new(key, payload, digestmod=hashlib.sha256)
@@ -71,7 +69,7 @@ def discourse_sso(request):
 
     if this_signature != signature:
         messages.error(request, 'Invalid payload. Please contact support if this problem persists.')
-        return redirect('auth_dashboard')
+        return redirect('authentication:dashboard')
 
     ## Build the return payload
 
@@ -87,7 +85,7 @@ def discourse_sso(request):
     }
 
     if main_char:
-        params['avatar_url'] = 'https://image.eveonline.com/Character/%s_256.jpg' % main_char.main_char_id
+        params['avatar_url'] = 'https://image.eveonline.com/Character/%s_256.jpg' % main_char.character_id
 
     return_payload = base64.encodestring(urlencode(params).encode('utf-8'))
     h = hmac.new(key, return_payload, digestmod=hashlib.sha256)

services/modules/ipboard/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django.contrib.auth.models import User, Group, Permission
 from django import urls
 from django.core.exceptions import ObjectDoesNotExist
@@ -21,13 +20,13 @@ from .tasks import IpboardTasks
 from .manager import IPBoardManager
 
 MODULE_PATH = 'services.modules.ipboard'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_ipboard')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class IpboardHooksTestCase(TestCase):
@@ -35,9 +34,6 @@ class IpboardHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         IpboardUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        IpboardUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = IpboardService
@@ -45,20 +41,16 @@ class IpboardHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(IpboardTasks.has_account(member))
-        self.assertTrue(IpboardTasks.has_account(blue))
         self.assertFalse(IpboardTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.IPBoardManager')
@@ -67,7 +59,7 @@ class IpboardHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -158,7 +150,8 @@ class IpboardViewsTestCase(TestCase):
         args, kwargs = manager.add_user.call_args
         self.assertEqual(args[0], 'auth_member')  # Character name
         self.assertEqual(args[1], self.member.email)
-        self.assertEqual(self.member.ipboard.username, expected_username)
+        ipboard_user = IpboardUser.objects.get(user=self.member)
+        self.assertEqual(ipboard_user.username, expected_username)
 
     @mock.patch(MODULE_PATH + '.tasks.IPBoardManager')
     def test_deactivate(self, manager):

services/modules/ips4/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import Ips4User
 from .tasks import Ips4Tasks
 
 MODULE_PATH = 'services.modules.ips4'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_ips4')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class Ips4HooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class Ips4HooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         Ips4User.objects.create(user=member, id='12345', username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        Ips4User.objects.create(user=blue, id='67891', username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = Ips4Service
@@ -44,20 +40,16 @@ class Ips4HooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(Ips4Tasks.has_account(member))
-        self.assertTrue(Ips4Tasks.has_account(blue))
         self.assertFalse(Ips4Tasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     def test_render_services_ctrl(self):

services/modules/market/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import MarketUser
 from .tasks import MarketTasks
 
 MODULE_PATH = 'services.modules.market'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_market')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class MarketHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class MarketHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         MarketUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        MarketUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = MarketService
@@ -44,20 +40,16 @@ class MarketHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(MarketTasks.has_account(member))
-        self.assertTrue(MarketTasks.has_account(blue))
         self.assertFalse(MarketTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.MarketManager')

services/modules/mumble/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import MumbleUser
 from .tasks import MumbleTasks
 
 MODULE_PATH = 'services.modules.mumble'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_mumble')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class MumbleHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class MumbleHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         MumbleUser.objects.create(user=member, username=self.member, pwhash='password', groups='Member')
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        MumbleUser.objects.create(user=blue, username=self.blue, pwhash='password', groups='Blue')
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = MumbleService
@@ -44,20 +40,16 @@ class MumbleHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(MumbleTasks.has_account(member))
-        self.assertTrue(MumbleTasks.has_account(blue))
         self.assertFalse(MumbleTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.MumbleManager')
@@ -66,7 +58,7 @@ class MumbleHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -78,7 +70,7 @@ class MumbleHooksTestCase(TestCase):
         service.update_groups(member)
 
         mumble_user = MumbleUser.objects.get(user=member)
-        self.assertIn(settings.DEFAULT_AUTH_GROUP, mumble_user.groups)
+        self.assertIn(DEFAULT_AUTH_GROUP, mumble_user.groups)
 
         # Check none user does not have groups updated
         with mock.patch(MODULE_PATH + '.tasks.MumbleManager') as manager:
@@ -153,7 +145,6 @@ class MumbleViewsTestCase(TestCase):
         mumble_user = MumbleUser.objects.get(user=self.member)
         self.assertEqual(mumble_user.username, expected_username)
         self.assertTrue(mumble_user.pwhash)
-        self.assertEqual(self.member.mumble.username, expected_username)
         self.assertEqual('Member', mumble_user.groups)
 
     def test_deactivate(self):

services/modules/openfire/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import OpenfireUser
 from .tasks import OpenfireTasks
 
 MODULE_PATH = 'services.modules.openfire'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_openfire')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class OpenfireHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class OpenfireHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         OpenfireUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        OpenfireUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = OpenfireService
@@ -44,20 +40,16 @@ class OpenfireHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(OpenfireTasks.has_account(member))
-        self.assertTrue(OpenfireTasks.has_account(blue))
         self.assertFalse(OpenfireTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.OpenfireManager')
@@ -66,7 +58,7 @@ class OpenfireHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_user_groups.called)
-        self.assertEqual(manager.update_user_groups.call_count, 2)
+        self.assertEqual(manager.update_user_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -77,7 +69,7 @@ class OpenfireHooksTestCase(TestCase):
             self.assertTrue(manager.update_user_groups.called)
             args, kwargs = manager.update_user_groups.call_args
             user_id, groups = args
-            self.assertIn(settings.DEFAULT_AUTH_GROUP, groups)
+            self.assertIn(DEFAULT_AUTH_GROUP, groups)
             self.assertEqual(user_id, member.openfire.username)
 
         # Check none user does not have groups updated

services/modules/phpbb3/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import Phpbb3User
 from .tasks import Phpbb3Tasks
 
 MODULE_PATH = 'services.modules.phpbb3'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_phpbb3')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class Phpbb3HooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class Phpbb3HooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         Phpbb3User.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        Phpbb3User.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = Phpbb3Service
@@ -44,20 +40,16 @@ class Phpbb3HooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(Phpbb3Tasks.has_account(member))
-        self.assertTrue(Phpbb3Tasks.has_account(blue))
         self.assertFalse(Phpbb3Tasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.Phpbb3Manager')
@@ -66,7 +58,7 @@ class Phpbb3HooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -77,7 +69,7 @@ class Phpbb3HooksTestCase(TestCase):
             self.assertTrue(manager.update_groups.called)
             args, kwargs = manager.update_groups.call_args
             user_id, groups = args
-            self.assertIn(settings.DEFAULT_AUTH_GROUP, groups)
+            self.assertIn(DEFAULT_AUTH_GROUP, groups)
             self.assertEqual(user_id, member.phpbb3.username)
 
         # Check none user does not have groups updated

services/modules/seat/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import SeatUser
 from .tasks import SeatTasks
 
 MODULE_PATH = 'services.modules.seat'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_seat')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class SeatHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class SeatHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         SeatUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        SeatUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user, disconnect_signals=True)
         self.service = SeatService
@@ -44,20 +40,16 @@ class SeatHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(SeatTasks.has_account(member))
-        self.assertTrue(SeatTasks.has_account(blue))
         self.assertFalse(SeatTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.SeatManager')
@@ -66,7 +58,7 @@ class SeatHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_roles.called)
-        self.assertEqual(manager.update_roles.call_count, 2)
+        self.assertEqual(manager.update_roles.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -77,7 +69,7 @@ class SeatHooksTestCase(TestCase):
             self.assertTrue(manager.update_roles.called)
             args, kwargs = manager.update_roles.call_args
             user_id, groups = args
-            self.assertIn(settings.DEFAULT_AUTH_GROUP, groups)
+            self.assertIn(DEFAULT_AUTH_GROUP, groups)
             self.assertEqual(user_id, member.seat.username)
 
         # Check none user does not have groups updated

services/modules/smf/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import SmfUser
 from .tasks import SmfTasks
 
 MODULE_PATH = 'services.modules.smf'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_smf')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class SmfHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class SmfHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         SmfUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        SmfUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = SmfService
@@ -44,20 +40,16 @@ class SmfHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(SmfTasks.has_account(member))
-        self.assertTrue(SmfTasks.has_account(blue))
         self.assertFalse(SmfTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.SmfManager')
@@ -66,7 +58,7 @@ class SmfHooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(manager.update_groups.called)
-        self.assertEqual(manager.update_groups.call_count, 2)
+        self.assertEqual(manager.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -77,7 +69,7 @@ class SmfHooksTestCase(TestCase):
             self.assertTrue(manager.update_groups.called)
             args, kwargs = manager.update_groups.call_args
             user_id, groups = args
-            self.assertIn(settings.DEFAULT_AUTH_GROUP, groups)
+            self.assertIn(DEFAULT_AUTH_GROUP, groups)
             self.assertEqual(user_id, member.smf.username)
 
         # Check none user does not have groups updated

services/modules/teamspeak3/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -22,13 +21,13 @@ from .tasks import Teamspeak3Tasks
 from .signals import m2m_changed_authts_group, post_save_authts, post_delete_authts
 
 MODULE_PATH = 'services.modules.teamspeak3'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_teamspeak3')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class Teamspeak3HooksTestCase(TestCase):
@@ -38,9 +37,6 @@ class Teamspeak3HooksTestCase(TestCase):
             self.member = 'member_user'
             member = AuthUtils.create_member(self.member)
             Teamspeak3User.objects.create(user=member, uid=self.member, perm_key='123ABC')
-            self.blue = 'blue_user'
-            blue = AuthUtils.create_blue(self.blue)
-            Teamspeak3User.objects.create(user=blue, uid=self.blue, perm_key='456DEF')
             self.none_user = 'none_user'
             none_user = AuthUtils.create_user(self.none_user)
 
@@ -49,28 +45,21 @@ class Teamspeak3HooksTestCase(TestCase):
             m2m_member_group = AuthTS.objects.create(auth_group=member.groups.all()[0])
             m2m_member_group.ts_group.add(ts_member_group)
             m2m_member_group.save()
-            m2m_blue_group = AuthTS.objects.create(auth_group=blue.groups.all()[0])
-            m2m_blue_group.ts_group.add(ts_blue_group)
-            m2m_blue_group.save()
             self.service = Teamspeak3Service
             add_permissions()
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(Teamspeak3Tasks.has_account(member))
-        self.assertTrue(Teamspeak3Tasks.has_account(blue))
         self.assertFalse(Teamspeak3Tasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
@@ -80,7 +69,7 @@ class Teamspeak3HooksTestCase(TestCase):
         service.update_all_groups()
         # Check member and blue user have groups updated
         self.assertTrue(instance.update_groups.called)
-        self.assertEqual(instance.update_groups.call_count, 2)
+        self.assertEqual(instance.update_groups.call_count, 1)
 
     def test_update_groups(self):
         # Check member has Member group updated
@@ -158,20 +147,11 @@ class Teamspeak3ViewsTestCase(TestCase):
             self.member.email = 'auth_member@example.com'
             self.member.save()
             AuthUtils.add_main_character(self.member, 'auth_member', '12345', corp_id='111', corp_name='Test Corporation')
-            self.blue_user = AuthUtils.create_blue('auth_blue')
-            self.blue_user.set_password('password')
-            self.blue_user.email = 'auth_blue@example.com'
-            self.blue_user.save()
-            AuthUtils.add_main_character(self.blue_user, 'auth_blue', '92345', corp_id='111', corp_name='Test Corporation')
 
             ts_member_group = TSgroup.objects.create(ts_group_id=1, ts_group_name='Member')
-            ts_blue_group = TSgroup.objects.create(ts_group_id=2, ts_group_name='Blue')
             m2m_member = AuthTS.objects.create(auth_group=Group.objects.get(name='Member'))
             m2m_member.ts_group.add(ts_member_group)
             m2m_member.save()
-            m2m_blue = AuthTS.objects.create(auth_group=Group.objects.get(name='Blue'))
-            m2m_blue.ts_group.add(ts_blue_group)
-            m2m_blue.save()
             add_permissions()
 
     def login(self, user=None, password=None):
@@ -195,22 +175,6 @@ class Teamspeak3ViewsTestCase(TestCase):
         self.assertTrue(teamspeak3_user.perm_key)
         self.assertRedirects(response, urls.reverse('auth_verify_teamspeak3'), target_status_code=200)
 
-    @mock.patch(MODULE_PATH + '.forms.Teamspeak3Manager')
-    @mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
-    def test_activate_blue(self, manager, forms_manager):
-        self.login(self.blue_user)
-        expected_username = 'auth_blue'
-        instance = manager.return_value.__enter__.return_value
-        instance.add_blue_user.return_value = (expected_username, 'abc123')
-
-        response = self.client.get(urls.reverse('auth_activate_teamspeak3'))
-
-        self.assertTrue(instance.add_blue_user.called)
-        teamspeak3_user = Teamspeak3User.objects.get(user=self.blue_user)
-        self.assertTrue(teamspeak3_user.uid)
-        self.assertTrue(teamspeak3_user.perm_key)
-        self.assertRedirects(response, urls.reverse('auth_verify_teamspeak3'), target_status_code=200)
-
     @mock.patch(MODULE_PATH + '.forms.Teamspeak3Manager')
     @mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
     def test_verify_submit(self, manager, forms_manager):
@@ -256,23 +220,6 @@ class Teamspeak3ViewsTestCase(TestCase):
         self.assertEqual(ts3_user.perm_key, '123abc')
         self.assertTrue(tasks_manager.return_value.__enter__.return_value.update_groups.called)
 
-    @mock.patch(MODULE_PATH + '.tasks.Teamspeak3Manager')
-    @mock.patch(MODULE_PATH + '.views.Teamspeak3Manager')
-    def test_reset_perm_blue(self, manager, tasks_manager):
-        self.login(self.blue_user)
-        Teamspeak3User.objects.create(user=self.blue_user, uid='some member')
-
-        manager.return_value.__enter__.return_value.generate_new_blue_permissionkey.return_value = ("valid_blue",
-                                                                                                    "123abc")
-
-        response = self.client.get(urls.reverse('auth_reset_teamspeak3_perm'))
-
-        self.assertRedirects(response, urls.reverse('auth_services'), target_status_code=200)
-        ts3_user = Teamspeak3User.objects.get(uid='valid_blue')
-        self.assertEqual(ts3_user.uid, 'valid_blue')
-        self.assertEqual(ts3_user.perm_key, '123abc')
-        self.assertTrue(tasks_manager.return_value.__enter__.return_value.update_groups.called)
-
 
 class Teamspeak3SignalsTestCase(TestCase):
     def setUp(self):

services/modules/xenforo/tests.py

@@ -8,7 +8,6 @@ except ImportError:
     import mock
 
 from django.test import TestCase, RequestFactory
-from django.conf import settings
 from django import urls
 from django.contrib.auth.models import User, Group, Permission
 from django.core.exceptions import ObjectDoesNotExist
@@ -20,13 +19,13 @@ from .models import XenforoUser
 from .tasks import XenforoTasks
 
 MODULE_PATH = 'services.modules.xenforo'
+DEFAULT_AUTH_GROUP = 'Member'
 
 
 def add_permissions():
     permission = Permission.objects.get(codename='access_xenforo')
-    members = Group.objects.get(name=settings.DEFAULT_AUTH_GROUP)
+    members = Group.objects.get_or_create(name=DEFAULT_AUTH_GROUP)[0]
-    blues = Group.objects.get(name=settings.DEFAULT_BLUE_GROUP)
+    AuthUtils.add_permissions_to_groups([permission], [members])
-    AuthUtils.add_permissions_to_groups([permission], [members, blues])
 
 
 class XenforoHooksTestCase(TestCase):
@@ -34,9 +33,6 @@ class XenforoHooksTestCase(TestCase):
         self.member = 'member_user'
         member = AuthUtils.create_member(self.member)
         XenforoUser.objects.create(user=member, username=self.member)
-        self.blue = 'blue_user'
-        blue = AuthUtils.create_blue(self.blue)
-        XenforoUser.objects.create(user=blue, username=self.blue)
         self.none_user = 'none_user'
         none_user = AuthUtils.create_user(self.none_user)
         self.service = XenforoService
@@ -44,20 +40,16 @@ class XenforoHooksTestCase(TestCase):
 
     def test_has_account(self):
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
         self.assertTrue(XenforoTasks.has_account(member))
-        self.assertTrue(XenforoTasks.has_account(blue))
         self.assertFalse(XenforoTasks.has_account(none_user))
 
     def test_service_enabled(self):
         service = self.service()
         member = User.objects.get(username=self.member)
-        blue = User.objects.get(username=self.blue)
         none_user = User.objects.get(username=self.none_user)
 
         self.assertTrue(service.service_active_for_user(member))
-        self.assertTrue(service.service_active_for_user(blue))
         self.assertFalse(service.service_active_for_user(none_user))
 
     @mock.patch(MODULE_PATH + '.tasks.XenForoManager')

services/tests/test_tasks.py

@@ -16,8 +16,7 @@ from services.tasks import validate_services
 
 class ServicesTasksTestCase(TestCase):
     def setUp(self):
-        self.member = AuthUtils.create_member('auth_member')
+        self.member = AuthUtils.create_user('auth_member')
-        self.none_user = AuthUtils.create_user('none_user', disconnect_signals=True)
 
     @mock.patch('services.tasks.ServicesHook')
     def test_validate_services(self, services_hook):