def setUp(self):
self.member = AuthUtils.create_user('auth_member',
disconnect_signals=True)
AuthUtils.add_main_character(self.member, 'Test', '1', '2',
'Test Corp', 'TEST')
self.none_user = AuthUtils.create_user('none_user',
disconnect_signals=True)
def setUp(self):
self.member = AuthUtils.create_member('auth_member')
self.member.email = '*****@*****.**'
self.member.save()
AuthUtils.add_main_character(self.member, 'auth_member', '12345', corp_id='111', corp_name='Test Corporation',
corp_ticker='TESTR')
add_permissions()
def setUpClass(cls):
cls.factory = RequestFactory()
EveCharacter.objects.all().delete()
EveCharacter.objects.all().delete()
User.objects.all().delete()
CharacterOwnership.objects.all().delete()
gb_models.SmartGroup.objects.all().delete()
cls.test_group, _ = Group.objects.update_or_create(name="Test_Group_2")
cls.test_group3, _ = Group.objects.update_or_create(
name="Test_Group_3")
cls.test_group4, _ = Group.objects.update_or_create(
name="Test_Group_4")
cls.tst4 = EveCorporationInfo.objects.create(
corporation_id=4,
corporation_name="Test Corp 4",
corporation_ticker="TST4",
member_count=100,
)
tst2 = EveCorporationInfo.objects.create(
corporation_id=2,
corporation_name="Test Corp 2",
corporation_ticker="TST2",
member_count=100,
)
cls.user = AuthUtils.create_user(f"User_transactions_test")
main_char = AuthUtils.add_main_character_2(
cls.user,
f"Main Trans",
cls.user.id,
corp_id=1,
corp_name="Test Corp 1",
corp_ticker="TST1",
)
CharacterOwnership.objects.create(
user=cls.user, character=main_char, owner_hash="main123"
)
character = EveCharacter.objects.create(
character_name=f"Alt 9999",
character_id=9999,
corporation_name="Test Corp 2",
corporation_id=2,
corporation_ticker="TST2",
)
CharacterOwnership.objects.create(
character=character, user=cls.user, owner_hash="ownalt321"
)
cls._sf = gb_models.AltCorpFilter.objects.create(
name="Test Corp 2 Alt", description="Have Alt in TST2", alt_corp_id=tst2.pk
)
_sf = gb_models.SmartFilter.objects.all().last()
test_s_group = gb_models.SmartGroup.objects.create(
group=cls.test_group4,
can_grace=True,
auto_group=False,
include_in_updates=True,
)
test_s_group.filters.add(_sf)
cls.user.groups.add(cls.test_group4)
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
AuthUtils.add_main_character(cls.user,
'Test Character',
'1',
corp_id='1',
alliance_id='1',
corp_name='Test Corp',
alliance_name='Test Alliance')
cls.guest_state = get_guest_state()
cls.test_character = EveCharacter.objects.get(character_id='1')
cls.test_corporation = EveCorporationInfo.objects.create(
corporation_id='1',
corporation_name='Test Corp',
corporation_ticker='TEST',
member_count=1)
cls.test_alliance = EveAllianceInfo.objects.create(
alliance_id='1',
alliance_name='Test Alliance',
alliance_ticker='TEST',
executor_corp_id='1')
cls.member_state = State.objects.create(
name='Test Member',
priority=150,
)
def test_m2m_changed_group_permissions(self, services_hook, transaction):
from django.contrib.contenttypes.models import ContentType
svc = mock.Mock()
svc.validate_user.return_value = None
svc.access_perm = 'auth.access_testsvc'
services_hook.get_services.return_value = [svc]
# Overload transaction.on_commit so everything happens synchronously
transaction.on_commit = lambda fn: fn()
test_group = Group.objects.create(name="Test group")
AuthUtils.disconnect_signals()
self.member.groups.add(test_group)
AuthUtils.connect_signals()
ct = ContentType.objects.get(app_label='auth', model='permission')
perm = Permission.objects.create(name="Test perm",
codename="access_testsvc",
content_type=ct)
test_group.permissions.add(perm)
# Act, should trigger m2m change
test_group.permissions.remove(perm)
# Assert
self.assertTrue(services_hook.get_services.called)
self.assertTrue(svc.validate_user.called)
args, kwargs = svc.validate_user.call_args
self.assertEqual(self.member, args[0])
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test')
AuthUtils.add_main_character(cls.user,
'test character',
'1',
corp_id='2',
corp_name='test_corp',
corp_ticker='TEST',
alliance_id='3',
alliance_name='TEST')
cls.user.profile.refresh_from_db()
cls.token = Token.objects.create(user=cls.user,
access_token='a',
character_id='1',
character_name='test character',
character_owner_hash='a')
cls.corp = EveCorporationInfo.objects.create(
corporation_id='2',
corporation_name='test corp',
corporation_ticker='TEST',
member_count=1)
cls.corpstats = CorpStats.objects.create(token=cls.token,
corp=cls.corp)
cls.member = CorpMember.objects.create(
corpstats=cls.corpstats,
character_id='2',
character_name='other test character')
def test_main_character(self):
AuthUtils.disconnect_signals()
# test when member.character is None
self.assertIsNone(self.member.main_character)
# test when member.character is not None but also not a main
character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
self.member.refresh_from_db()
self.assertNotEqual(self.member.main_character, self.member.character)
self.assertEquals(self.member.main_character, self.user.profile.main_character)
# test when is main
old_main = self.user.profile.main_character
self.user.profile.main_character = character
self.user.profile.save()
self.member.refresh_from_db()
self.assertEqual(self.member.main_character, self.member.character)
self.assertEqual(self.user.profile.main_character, self.member.main_character)
# transaction won't roll this back
self.user.profile.main_character = old_main
self.user.profile.save()
AuthUtils.connect_signals()
def test_registered(self):
self.assertFalse(self.member.registered)
AuthUtils.disconnect_signals()
character = EveCharacter.objects.create(character_id='2', character_name='other test character', corporation_id='2', corporation_name='test corp', corporation_ticker='TEST')
CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
self.assertTrue(self.member.registered)
AuthUtils.connect_signals()
def test_main_character(self):
AuthUtils.disconnect_signals()
# test when member.character is None
self.assertIsNone(self.member.main_character)
# test when member.character is not None but also not a main
character = EveCharacter.objects.create(
character_id='2',
character_name='other test character',
corporation_id='2',
corporation_name='test corp',
corporation_ticker='TEST')
CharacterOwnership.objects.create(character=character,
user=self.user,
owner_hash='b')
self.member.refresh_from_db()
self.assertNotEqual(self.member.main_character, self.member.character)
self.assertEquals(self.member.main_character,
self.user.profile.main_character)
# test when is main
old_main = self.user.profile.main_character
self.user.profile.main_character = character
self.user.profile.save()
self.member.refresh_from_db()
self.assertEqual(self.member.main_character, self.member.character)
self.assertEqual(self.user.profile.main_character,
self.member.main_character)
# transaction won't roll this back
self.user.profile.main_character = old_main
self.user.profile.save()
AuthUtils.connect_signals()
def test_m2m_changed_group_permissions(self, services_hook, transaction):
from django.contrib.contenttypes.models import ContentType
svc = mock.Mock()
svc.validate_user.return_value = None
svc.access_perm = 'auth.access_testsvc'
services_hook.get_services.return_value = [svc]
# Overload transaction.on_commit so everything happens synchronously
transaction.on_commit = lambda fn: fn()
test_group = Group.objects.create(name="Test group")
AuthUtils.disconnect_signals()
self.member.groups.add(test_group)
AuthUtils.connect_signals()
ct = ContentType.objects.get(app_label='auth', model='permission')
perm = Permission.objects.create(name="Test perm", codename="access_testsvc", content_type=ct)
test_group.permissions.add(perm)
# Act, should trigger m2m change
test_group.permissions.remove(perm)
# Assert
self.assertTrue(services_hook.get_services.called)
self.assertTrue(svc.validate_user.called)
args, kwargs = svc.validate_user.call_args
self.assertEqual(self.member, args[0])
def setUp(self):
# Disconnect signals
disconnect_signals()
state = AuthUtils.get_member_state()
self.alliance = EveAllianceInfo.objects.create(
alliance_id='3456',
alliance_name='alliance name',
alliance_ticker='TIKR',
executor_corp_id='2345',
)
self.corp = EveCorporationInfo.objects.create(
corporation_id='2345',
corporation_name='corp name',
corporation_ticker='TIKK',
member_count=10,
alliance=self.alliance,
)
state.member_alliances.add(self.alliance)
state.member_corporations.add(self.corp)
self.member = AuthUtils.create_member('test user')
def setUpTestData(cls):
cls.main_character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.alt_character = EveCharacter.objects.create(
character_id=2,
character_name='Alt Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.unclaimed_character = EveCharacter.objects.create(
character_id=3,
character_name='Unclaimed Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
AuthUtils.disconnect_signals()
CharacterOwnership.objects.create(user=cls.user,
character=cls.main_character,
owner_hash='1')
CharacterOwnership.objects.create(user=cls.user,
character=cls.alt_character,
owner_hash='2')
UserProfile.objects.update_or_create(
user=cls.user, defaults={'main_character': cls.main_character})
AuthUtils.connect_signals()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
MumbleUser.objects.create(user=member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = MumbleService
add_permissions()
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test')
AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
cls.user.profile.refresh_from_db()
cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='a')
cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', member_count=1)
cls.corpstats = CorpStats.objects.create(token=cls.token, corp=cls.corp)
cls.member = CorpMember.objects.create(corpstats=cls.corpstats, character_id='2', character_name='other test character')
def test_user_count(self):
AuthUtils.disconnect_signals()
co = CharacterOwnership.objects.create(character=self.character, user=self.user, owner_hash='a')
AuthUtils.connect_signals()
CorpMember.objects.create(corpstats=self.corpstats, character_id='4', character_name='test character')
self.assertEqual(self.corpstats.user_count, 1)
co.delete()
self.assertEqual(self.corpstats.user_count, 0)
def test_no_ownership(self):
user = AuthUtils.create_user('v1 user', disconnect_signals=True)
AuthUtils.add_main_character(user, 'v1 character', '10', '20', 'test corp', 'test')
self.assertFalse(UserProfile.objects.filter(main_character__isnull=True).count())
call_command('checkmains', stdout=self.stdout)
self.assertEqual(UserProfile.objects.filter(main_character__isnull=True).count(), 1)
self.assertIn(user.username, self.stdout.getvalue())
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
DiscordUser.objects.create(user=member, uid='12345')
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = DiscordService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
Ips4User.objects.create(user=member, id='12345', username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = Ips4Service
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
SeatUser.objects.create(user=member, username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user, disconnect_signals=True)
self.service = SeatService
add_permissions()
def setUp(self):
self.member = AuthUtils.create_member('auth_member')
AuthUtils.add_main_character(self.member,
'auth_member',
'12345',
corp_id='111',
corp_name='Test Corporation')
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
DiscourseUser.objects.create(user=member, enabled=True)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = DiscourseService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
SmfUser.objects.create(user=member, username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = SmfService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
Ips4User.objects.create(user=member, id='12345', username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = Ips4Service
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
DiscordUser.objects.create(user=member, uid='12345')
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = DiscordService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
MumbleUser.objects.create(user=member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = MumbleService
add_permissions()
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test user', disconnect_signals=True)
AuthUtils.add_main_character(cls.user, 'test character', '1', '2',
'test corp', 'test')
character = UserProfile.objects.get(user=cls.user).main_character
CharacterOwnership.objects.create(user=cls.user,
character=character,
owner_hash='test')
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
DiscourseUser.objects.create(user=member, enabled=True)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = DiscourseService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
Phpbb3User.objects.create(user=member, username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = Phpbb3Service
add_permissions()
def setUpTestData(cls):
EveCharacter.objects.all().delete()
User.objects.all().delete()
CharacterOwnership.objects.all().delete()
a_models.StatsCharacter.objects.all().delete()
a_models.zKillMonth.objects.all().delete()
userids = range(1,11)
users = []
characters = []
for uid in userids:
user = AuthUtils.create_user(f"User_{uid}")
main_char = AuthUtils.add_main_character_2(user,
f"Main {uid}",
uid,
corp_id=1,
corp_name='Test Corp 1',
corp_ticker='TST1')
CharacterOwnership.objects.create(user=user, character=main_char, owner_hash=f"main{uid}")
characters.append(main_char)
users.append(user)
# add some extra characters to users in 2 corps/alliance
for uid in range(0,5): # test corp 2
character = EveCharacter.objects.create(character_name=f'Alt {uid}',
character_id=11+uid,
corporation_name='Test Corp 2',
corporation_id=2,
corporation_ticker='TST2')
CharacterOwnership.objects.create(character=character,
user=users[uid],
owner_hash=f'ownalt{11+uid}')
characters.append(character)
for uid in range(5,10): # Test alliance 1
character = EveCharacter.objects.create(character_name=f'Alt {uid}',
character_id=11+uid,
corporation_name='Test Corp 3',
corporation_id=3,
corporation_ticker='TST3',
alliance_id=1,
alliance_name="Test Alliance 1",
alliance_ticker="TSTA1")
CharacterOwnership.objects.create(character=character,
user=users[uid],
owner_hash=f'ownalt{11+uid}')
characters.append(character)
zkc = a_models.StatsCharacter.objects.create(character=characters[2],
zk_12m=500, zk_6m=250, zk_3m=100)
zkc2 = a_models.StatsCharacter.objects.create(character=characters[4],
zk_12m=0, zk_6m=0, zk_3m=0)
date_str= str(timezone.now().year)+str(timezone.now().month).zfill(2)
a_models.zKillMonth.objects.create(char=zkc2, ships_destroyed=5, date_str=date_str, month=timezone.now().month, year=timezone.now().year)
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
SeatUser.objects.create(user=member, username=self.member)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user,
disconnect_signals=True)
self.service = SeatService
add_permissions()
def setUp(self):
self.member = 'member_user'
member = AuthUtils.create_member(self.member)
WikiJs.objects.create(user=member, uid=3)
self.none_user = '******'
none_user = AuthUtils.create_user(self.none_user)
self.service = WikiJSService
self.del_user = '******'
del_user = AuthUtils.create_user(self.del_user)
add_permissions()
def setUpTestData(cls):
cls.user = AuthUtils.create_user('user', disconnect_signals=True)
cls.alt_user = AuthUtils.create_user('alt_user', disconnect_signals=True)
cls.character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
def test_sync_nickname(self, manager):
service = self.service()
member = User.objects.get(username=self.member)
AuthUtils.add_main_character(member, 'test user', '12345', corp_ticker='AAUTH')
service.sync_nickname(member)
self.assertTrue(manager.update_nickname.called)
args, kwargs = manager.update_nickname.call_args
self.assertEqual(args[0], member.discord.uid)
self.assertEqual(args[1], 'test user')
def test_unregistered_members(self):
member = CorpMember.objects.create(corpstats=self.corpstats, character_id='4', character_name='test character')
self.corpstats.refresh_from_db()
self.assertIn(member, self.corpstats.unregistered_members)
self.assertEqual(self.corpstats.unregistered_member_count, 1)
AuthUtils.disconnect_signals()
CharacterOwnership.objects.create(character=self.character, user=self.user, owner_hash='a')
AuthUtils.connect_signals()
self.assertNotIn(member, self.corpstats.unregistered_members)
self.assertEqual(self.corpstats.unregistered_member_count, 0)
def setUp(self):
self.member = AuthUtils.create_member('auth_member')
self.member.email = '*****@*****.**'
self.member.save()
AuthUtils.add_main_character(self.member,
'auth_member',
'12345',
corp_id='111',
corp_name='Test Corporation',
corp_ticker='TESTR')
add_permissions()
def setUpTestData(cls):
cls.user = AuthUtils.create_user('user', disconnect_signals=True)
cls.alt_user = AuthUtils.create_user('alt_user',
disconnect_signals=True)
cls.character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
def test_no_ownership(self):
user = AuthUtils.create_user('v1 user', disconnect_signals=True)
AuthUtils.add_main_character(user, 'v1 character', '10', '20',
'test corp', 'test')
self.assertFalse(
UserProfile.objects.filter(main_character__isnull=True).count())
call_command('checkmains', stdout=self.stdout)
self.assertEqual(
UserProfile.objects.filter(main_character__isnull=True).count(), 1)
self.assertIn(user.username, self.stdout.getvalue())
def setUpTestData(cls):
cls.main_user = AuthUtils.create_user('main_user', disconnect_signals=True)
cls.no_main_user = AuthUtils.create_user('no_main_user', disconnect_signals=True)
main_character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
CharacterOwnership.objects.create(user=cls.main_user, character=main_character, owner_hash='1')
cls.main_user.profile.main_character = main_character
def test_user_count(self):
AuthUtils.disconnect_signals()
co = CharacterOwnership.objects.create(character=self.character,
user=self.user,
owner_hash='a')
AuthUtils.connect_signals()
CorpMember.objects.create(corpstats=self.corpstats,
character_id='4',
character_name='test character')
self.assertEqual(self.corpstats.user_count, 1)
co.delete()
self.assertEqual(self.corpstats.user_count, 0)
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
AuthUtils.add_main_character(cls.user, 'Test Character', '1', corp_id='1', alliance_id='1',
corp_name='Test Corp', alliance_name='Test Alliance')
cls.character = EveCharacter.objects.get(character_id='1')
cls.token = Token.objects.create(
user=cls.user,
character_id='1',
character_name='Test',
character_owner_hash='1',
)
cls.ownership = CharacterOwnership.objects.get(character=cls.character)
def test_registered(self):
self.assertFalse(self.member.registered)
AuthUtils.disconnect_signals()
character = EveCharacter.objects.create(
character_id='2',
character_name='other test character',
corporation_id='2',
corporation_name='test corp',
corporation_ticker='TEST')
CharacterOwnership.objects.create(character=character,
user=self.user,
owner_hash='b')
self.assertTrue(self.member.registered)
AuthUtils.connect_signals()
def test_mains(self):
# test when is a main
member = CorpMember.objects.create(corpstats=self.corpstats, character_id='1', character_name='test character')
self.assertIn(member, self.corpstats.mains)
self.assertEqual(self.corpstats.main_count, 1)
# test when is an alt
old_main = self.user.profile.main_character
character = EveCharacter.objects.create(character_name='other character', character_id=10, corporation_name='test corp', corporation_id='2', corporation_ticker='TEST')
AuthUtils.disconnect_signals()
co = CharacterOwnership.objects.create(character=character, user=self.user, owner_hash='b')
self.user.profile.main_character = character
self.user.profile.save()
AuthUtils.connect_signals()
self.assertNotIn(member, self.corpstats.mains)
self.assertEqual(self.corpstats.main_count, 0)
# test when no ownership
co.delete()
self.assertNotIn(member, self.corpstats.mains)
self.assertEqual(self.corpstats.main_count, 0)
# transaction won't roll this back
AuthUtils.disconnect_signals()
self.user.profile.main_character = old_main
self.user.profile.save()
AuthUtils.connect_signals()
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
AuthUtils.add_main_character(cls.user, 'Test Character', '1', corp_id='1', alliance_id='1',
corp_name='Test Corp', alliance_name='Test Alliance')
cls.guest_state = get_guest_state()
cls.test_character = EveCharacter.objects.get(character_id='1')
cls.test_corporation = EveCorporationInfo.objects.create(corporation_id='1', corporation_name='Test Corp',
corporation_ticker='TEST', member_count=1)
cls.test_alliance = EveAllianceInfo.objects.create(alliance_id='1', alliance_name='Test Alliance',
alliance_ticker='TEST', executor_corp_id='1')
cls.member_state = State.objects.create(
name='Test Member',
priority=150,
)
def test_unregistered_members(self):
member = CorpMember.objects.create(corpstats=self.corpstats,
character_id='4',
character_name='test character')
self.corpstats.refresh_from_db()
self.assertIn(member, self.corpstats.unregistered_members)
self.assertEqual(self.corpstats.unregistered_member_count, 1)
AuthUtils.disconnect_signals()
CharacterOwnership.objects.create(character=self.character,
user=self.user,
owner_hash='a')
AuthUtils.connect_signals()
self.assertNotIn(member, self.corpstats.unregistered_members)
self.assertEqual(self.corpstats.unregistered_member_count, 0)
def test_update_alliance_group_membership(self):
obj = AutogroupsConfig.objects.create(alliance_groups=True)
obj.states.add(AuthUtils.get_member_state())
char = EveCharacter.objects.create(
character_id='1234',
character_name='test character',
corporation_id='2345',
corporation_name='test corp',
corporation_ticker='tickr',
alliance_id='3456',
alliance_name='alliance name',
)
self.member.profile.main_character = char
self.member.profile.save()
pre_groups = self.member.groups.all()
# Act
obj.update_alliance_group_membership(self.member)
obj.update_corp_group_membership(
self.member) # check for no side effects
group = obj.create_alliance_group(self.alliance)
group_qs = Group.objects.filter(pk=group.pk)
self.assertIn(group, self.member.groups.all())
self.assertQuerysetEqual(self.member.groups.all(),
map(repr, pre_groups | group_qs),
ordered=False)
def setUp(self):
self.member = AuthUtils.create_user('auth_member', disconnect_signals=True)
self.alliance = EveAllianceInfo.objects.create(
alliance_id='3456',
alliance_name='alliance name',
alliance_ticker='TIKR',
executor_corp_id='2345',
)
self.corp = EveCorporationInfo.objects.create(
corporation_id='2345',
corporation_name='corp name',
corporation_ticker='TIKK',
member_count=10,
alliance=self.alliance,
)
self.char = EveCharacter.objects.create(
character_id='1234',
character_name='test character',
corporation_id='2345',
corporation_name='test corp',
corporation_ticker='TIKK',
alliance_id='3456',
alliance_name='alliance name',
alliance_ticker='TIKR',
)
self.member.profile.main_character = self.char
self.member.profile.save()
def setUp(self):
self.member = AuthUtils.create_user('auth_member',
disconnect_signals=True)
self.alliance = EveAllianceInfo.objects.create(
alliance_id='3456',
alliance_name='alliance name',
alliance_ticker='TIKR',
executor_corp_id='2345',
)
self.corp = EveCorporationInfo.objects.create(
corporation_id='2345',
corporation_name='corp name',
corporation_ticker='TIKK',
member_count=10,
alliance=self.alliance,
)
self.char = EveCharacter.objects.create(
character_id='1234',
character_name='test character',
corporation_id='2345',
corporation_name='test corp',
corporation_ticker='TIKK',
alliance_id='3456',
alliance_name='alliance name',
alliance_ticker='TIKR',
)
self.member.profile.main_character = self.char
self.member.profile.save()
def setUpTestData(cls):
cls.main_user = AuthUtils.create_user('main_user',
disconnect_signals=True)
cls.no_main_user = AuthUtils.create_user('no_main_user',
disconnect_signals=True)
main_character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
CharacterOwnership.objects.create(user=cls.main_user,
character=main_character,
owner_hash='1')
cls.main_user.profile.main_character = main_character
def test_check_groups_on_profile_update_state(self, update_groups_for_user):
# Trigger signal
self.member.profile.assign_state(state=AuthUtils.get_guest_state())
self.assertTrue(update_groups_for_user.called)
self.assertEqual(update_groups_for_user.call_count, 1)
args, kwargs = update_groups_for_user.call_args
self.assertEqual(args[0], self.member)
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
AuthUtils.add_main_character(cls.user,
'Test Character',
'1',
corp_id='1',
alliance_id='1',
corp_name='Test Corp',
alliance_name='Test Alliance')
cls.character = EveCharacter.objects.get(character_id='1')
cls.token = Token.objects.create(
user=cls.user,
character_id='1',
character_name='Test',
character_owner_hash='1',
)
cls.ownership = CharacterOwnership.objects.get(character=cls.character)
def test_check_groups_on_profile_update_state(self,
update_groups_for_user):
# Trigger signal
self.member.profile.assign_state(state=AuthUtils.get_guest_state())
self.assertTrue(update_groups_for_user.called)
self.assertEqual(update_groups_for_user.call_count, 1)
args, kwargs = update_groups_for_user.call_args
self.assertEqual(args[0], self.member)
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(DEFAULT_AUTH_GROUP, groups)
self.assertEqual(user_id, member.discord.uid)
# Check none user does not have groups updated
with mock.patch(MODULE_PATH + '.tasks.DiscordOAuthManager') as manager:
service = self.service()
none_user = User.objects.get(username=self.none_user)
service.update_groups(none_user)
self.assertFalse(manager.update_groups.called)
def test_update_groups_for_state(self):
member = AuthUtils.create_member('test member')
obj = AutogroupsConfig.objects.create()
obj.states.add(member.profile.state)
with patch('.models.AutogroupsConfig.update_group_membership_for_user') as update_group_membership_for_user:
AutogroupsConfig.objects.update_groups_for_state(member.profile.state)
self.assertTrue(update_group_membership_for_user.called)
self.assertEqual(update_group_membership_for_user.call_count, 1)
args, kwargs = update_group_membership_for_user.call_args
self.assertEqual(args[0], member)
def setUpTestData(cls):
cls.main_character = EveCharacter.objects.create(
character_id=1,
character_name='Main Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.alt_character = EveCharacter.objects.create(
character_id=2,
character_name='Alt Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.unclaimed_character = EveCharacter.objects.create(
character_id=3,
character_name='Unclaimed Character',
corporation_id=1,
corporation_name='Corp',
corporation_ticker='CORP',
)
cls.user = AuthUtils.create_user('test_user', disconnect_signals=True)
cls.old_user = AuthUtils.create_user('old_user', disconnect_signals=True)
AuthUtils.disconnect_signals()
CharacterOwnership.objects.create(user=cls.user, character=cls.main_character, owner_hash='1')
CharacterOwnership.objects.create(user=cls.user, character=cls.alt_character, owner_hash='2')
UserProfile.objects.update_or_create(user=cls.user, defaults={'main_character': cls.main_character})
AuthUtils.connect_signals()
def test_autogroups_states_changed_add(self, update_group_membership_for_state):
"""
Test update_group_membership_for_state is called when a state is added to
the AutogroupsConfig
"""
obj = AutogroupsConfig.objects.create(alliance_groups=True)
state = AuthUtils.get_member_state()
# Trigger
obj.states.add(state)
self.assertTrue(update_group_membership_for_state.called)
self.assertEqual(update_group_membership_for_state.call_count, 1)
args, kwargs = update_group_membership_for_state.call_args
self.assertEqual(args[0], state)
def test_check_groups_on_character_update(self, update_groups_for_user):
"""
Test update_groups_for_user is called when main_character properties
are changed.
"""
# Trigger signal
self.member.profile.main_character.corporation_id = '2300'
self.member.profile.main_character.save()
self.assertTrue(update_groups_for_user.called)
self.assertEqual(update_groups_for_user.call_count, 1)
args, kwargs = update_groups_for_user.call_args
self.assertEqual(args[0], self.member)
member = User.objects.get(pk=self.member.pk)
self.assertEqual(member.profile.state, AuthUtils.get_member_state())
def test_update_groups_no_config(self, remove_corp, remove_alliance, update_groups):
member = AuthUtils.create_member('test member')
obj = AutogroupsConfig.objects.create()
# Corp and alliance groups should be removed from users if their state has no config
AutogroupsConfig.objects.update_groups_for_user(member)
self.assertFalse(update_groups.called)
self.assertTrue(remove_alliance.called)
self.assertTrue(remove_corp.called)
# The normal group assignment should occur if there state has a config
obj.states.add(member.profile.state)
AutogroupsConfig.objects.update_groups_for_user(member)
self.assertTrue(update_groups.called)
def setUpTestData(cls):
cls.user = AuthUtils.create_user('test')
AuthUtils.add_main_character(cls.user, 'test character', '1', corp_id='2', corp_name='test_corp', corp_ticker='TEST', alliance_id='3', alliance_name='TEST')
cls.user.profile.refresh_from_db()
cls.alliance = EveAllianceInfo.objects.create(alliance_id='3', alliance_name='test alliance', alliance_ticker='TEST', executor_corp_id='2')
cls.corp = EveCorporationInfo.objects.create(corporation_id='2', corporation_name='test corp', corporation_ticker='TEST', alliance=cls.alliance, member_count=1)
cls.token = Token.objects.create(user=cls.user, access_token='a', character_id='1', character_name='test character', character_owner_hash='z')
cls.corpstats = CorpStats.objects.create(corp=cls.corp, token=cls.token)
cls.view_corp_permission = Permission.objects.get_by_natural_key('view_corp_corpstats', 'corputils', 'corpstats')
cls.view_alliance_permission = Permission.objects.get_by_natural_key('view_alliance_corpstats', 'corputils', 'corpstats')
cls.view_state_permission = Permission.objects.get_by_natural_key('view_state_corpstats', 'corputils', 'corpstats')
cls.state = AuthUtils.create_state('test state', 500)
AuthUtils.assign_state(cls.user, cls.state, disconnect_signals=True)
def test_check_groups_on_profile_update_main_character(self, update_groups_for_user):
char = EveCharacter.objects.create(
character_id='1266',
character_name='test character2',
corporation_id='2345',
corporation_name='test corp',
corporation_ticker='tickr',
alliance_id='3456',
alliance_name='alliance name',
)
# Trigger signal
self.member.profile.main_character = char
self.member.profile.save()
self.assertTrue(update_groups_for_user.called)
self.assertEqual(update_groups_for_user.call_count, 1)
args, kwargs = update_groups_for_user.call_args
self.assertEqual(args[0], self.member)
member = User.objects.get(pk=self.member.pk)
self.assertEqual(member.profile.state, AuthUtils.get_member_state())
