Remove EveManager, refactor into model managers

Lots of unused methods removed.
Unit tests added for those that are left.

allianceauth/authentication/managers.py

@@ -2,7 +2,6 @@ import logging
 
 from django.db import transaction
 from django.db.models import Manager, QuerySet, Q
-from allianceauth.eveonline.managers import EveManager
 
 from allianceauth.eveonline.models import EveCharacter
 
@@ -23,7 +22,7 @@ def available_states_query(character):
 class CharacterOwnershipManager(Manager):
     def create_by_token(self, token):
         if not EveCharacter.objects.filter(character_id=token.character_id).exists():
-            EveManager.create_character(token.character_id)
+            EveCharacter.objects.create_character(token.character_id)
         return self.create(character=EveCharacter.objects.get(character_id=token.character_id), user=token.user,
                            owner_hash=token.character_owner_hash)
 

allianceauth/authentication/signals.py

@@ -6,7 +6,6 @@ from django.db.models import Q
 from django.db.models.signals import post_save, pre_delete, m2m_changed, pre_save
 from django.dispatch import receiver, Signal
 from esi.models import Token
-from allianceauth.eveonline.managers import EveManager
 
 from allianceauth.eveonline.models import EveCharacter
 
@@ -81,7 +80,7 @@ def record_character_ownership(sender, instance, created, *args, **kwargs):
         CharacterOwnership.objects.filter(character__character_id=instance.character_id).exclude(query).delete()
         # create character if needed
         if EveCharacter.objects.filter(character_id=instance.character_id).exists() is False:
-            EveManager.create_character(instance.character_id)
+            EveCharacter.objects.create_character(instance.character_id)
         char = EveCharacter.objects.get(character_id=instance.character_id)
         # check if we need to create ownership
         if instance.user and not CharacterOwnership.objects.filter(character__character_id=instance.character_id).exists():

allianceauth/corputils/views.py

@@ -8,7 +8,6 @@ from django.db import IntegrityError
 from django.shortcuts import render, redirect, get_object_or_404
 from django.utils.translation import ugettext_lazy as _
 from esi.decorators import token_required
-from allianceauth.eveonline.managers import EveManager
 from allianceauth.eveonline.models import EveCharacter, EveCorporationInfo
 
 from .models import CorpStats
@@ -36,7 +35,7 @@ def corpstats_add(request, token):
         try:
             corp = EveCorporationInfo.objects.get(corporation_id=corp_id)
         except EveCorporationInfo.DoesNotExist:
-            corp = EveManager.create_corporation(corp_id)
+            corp = EveCorporationInfo.objects.create_corporation(corp_id)
         cs = CorpStats.objects.create(token=token, corp=corp)
         try:
             cs.update()

allianceauth/eveonline/admin.py

@@ -1,7 +1,6 @@
 from django import forms
 from django.contrib import admin
 from django.core.exceptions import ObjectDoesNotExist
-from .managers import EveManager
 from .providers import ObjectNotFound
 
 from .models import EveAllianceInfo
@@ -9,51 +8,87 @@ from .models import EveCharacter
 from .models import EveCorporationInfo
 
 
+class EveEntityExistsError(forms.ValidationError):
+    def __init__(self, entity_type_name, id):
+        super(EveEntityExistsError, self).__init__(
+            message='{} with ID {} already exists.'.format(entity_type_name, id))
+
+
+class EveEntityNotFoundError(forms.ValidationError):
+    def __init__(self, entity_type_name, id):
+        super(EveEntityNotFoundError, self).__init__(
+            message='{} with ID {} not found.'.format(entity_type_name, id))
+
+
 class EveEntityForm(forms.ModelForm):
     id = forms.IntegerField(min_value=1)
-    entity_type_name = None  # override in subclass
     entity_model_class = None
 
     def clean_id(self):
-        try:
+        raise NotImplementedError()
-            assert getattr(EveManager, 'get_%s' % self.entity_type_name)(self.cleaned_data['id'])
-        except (AssertionError, ObjectNotFound):
-            raise forms.ValidationError('%s with ID %s not found.' % (self.entity_type_name, self.cleaned_data['id']))
-        if self.entity_model_class.objects.filter(
-                **{'%s_id' % self.entity_type_name: self.cleaned_data['id']}).exists():
-            raise forms.ValidationError(
-                '%s with ID %s already exists.' % (self.entity_type_name, self.cleaned_data['id']))
-        return self.cleaned_data['id']
 
     def save(self, commit=True):
-        return getattr(EveManager, 'create_%s' % self.entity_type_name)(self.cleaned_data['id'])
+        raise NotImplementedError()
 
     def save_m2m(self):
         pass
 
 
 class EveCharacterForm(EveEntityForm):
-    entity_model_class = EveCharacter
     entity_type_name = 'character'
 
+    def clean_id(self):
+        try:
+            assert self.Meta.model.provider.get_character(self.cleaned_data['id'])
+        except (AssertionError, ObjectNotFound):
+            raise EveEntityNotFoundError(self.entity_type_name, self.cleaned_data['id'])
+        if self.Meta.model.objects.filter(character_id=self.cleaned_data['id']).exists():
+            raise EveEntityExistsError(self.entity_type_name, self.cleaned_data['id'])
+        return self.cleaned_data['id']
+
+    def save(self, commit=True):
+        return self.Meta.model.objects.create_character(self.cleaned_data['id'])
+
     class Meta:
         fields = ['id']
         model = EveCharacter
 
 
 class EveCorporationForm(EveEntityForm):
-    entity_model_class = EveCorporationInfo
     entity_type_name = 'corporation'
 
+    def clean_id(self):
+        try:
+            assert self.Meta.model.provider.get_corporation(self.cleaned_data['id'])
+        except (AssertionError, ObjectNotFound):
+            raise EveEntityNotFoundError(self.entity_type_name, self.cleaned_data['id'])
+        if self.Meta.model.objects.filter(corporation_id=self.cleaned_data['id']).exists():
+            raise EveEntityExistsError(self.entity_type_name, self.cleaned_data['id'])
+        return self.cleaned_data['id']
+
+    def save(self, commit=True):
+        return self.Meta.model.objects.create_corporation(self.cleaned_data['id'])
+
     class Meta:
         fields = ['id']
         model = EveCorporationInfo
 
 
 class EveAllianceForm(EveEntityForm):
-    entity_model_class = EveAllianceInfo
     entity_type_name = 'alliance'
 
+    def clean_id(self):
+        try:
+            assert self.Meta.model.provider.get_alliance(self.cleaned_data['id'])
+        except (AssertionError, ObjectNotFound):
+            raise EveEntityNotFoundError(self.entity_type_name, self.cleaned_data['id'])
+        if self.Meta.model.objects.filter(alliance_id=self.cleaned_data['id']).exists():
+            raise EveEntityExistsError(self.entity_type_name, self.cleaned_data['id'])
+        return self.cleaned_data['id']
+
+    def save(self, commit=True):
+        return self.Meta.model.objects.create_alliance(self.cleaned_data['id'])
+
     class Meta:
         fields = ['id']
         model = EveAllianceInfo

allianceauth/eveonline/managers.py

@@ -1,26 +1,24 @@
 import logging
 
-from .providers import provider
+from django.db import models
-
+from . import providers
-from .models import EveAllianceInfo
-from .models import EveCharacter
-from .models import EveCorporationInfo
 
 logger = logging.getLogger(__name__)
 
 
-class EveManager(object):
+class EveCharacterProviderManager:
-    @classmethod
+    def get_character(self, character_id) -> providers.Character:
-    def get_character(cls, character_id):
+        return providers.provider.get_character(character_id)
-        return provider.get_character(character_id)
 
-    @staticmethod
-    def create_character(id):
-        return EveManager.create_character_obj(EveManager.get_character(id))
 
-    @staticmethod
+class EveCharacterManager(models.Manager):
-    def create_character_obj(character,):
+    provider = EveCharacterProviderManager()
-        return EveCharacter.objects.create(
+
+    def create_character(self, character_id):
+        return self.create_character_obj(self.provider.get_character(character_id))
+
+    def create_character_obj(self, character: providers.Character):
+        return self.create(
             character_id=character.id,
             character_name=character.name,
             corporation_id=character.corp.id,
@@ -30,76 +28,56 @@ class EveManager(object):
             alliance_name=character.alliance.name,
         )
 
-    @staticmethod
+    def update_character(self, character_id):
-    def update_character(id):
+        return self.get(character_id=character_id).update_character()
-        return EveManager.update_character_obj(EveManager.get_character(id))
 
-    @staticmethod
+    def get_character_by_id(self, char_id):
-    def update_character_obj(char):
+        if self.filter(character_id=char_id).exists():
-        model = EveCharacter.objects.get(character_id=char.id)
+            return self.get(character_id=char_id)
-        model.character_name = char.name
+        return None
-        model.corporation_id = char.corp.id
-        model.corporation_name = char.corp.name
-        model.corporation_ticker = char.corp.ticker
-        model.alliance_id = char.alliance.id
-        model.alliance_name = char.alliance.name
-        model.save()
-        return model
 
-    @classmethod
-    def get_alliance(cls, alliance_id):
-        return provider.get_alliance(alliance_id)
 
-    @staticmethod
+class EveAllianceProviderManager:
-    def create_alliance(id):
+    def get_alliance(self, alliance_id) -> providers.Alliance:
-        return EveManager.create_alliance_obj(EveManager.get_alliance(id))
+        return providers.provider.get_alliance(alliance_id)
 
-    @staticmethod
+
-    def create_alliance_obj(alliance):
+class EveAllianceManager(models.Manager):
-        return EveAllianceInfo.objects.create(
+    provider = EveAllianceProviderManager()
+
+    def create_alliance(self, alliance_id):
+        return self.create_alliance_obj(self.provider.get_alliance(alliance_id))
+
+    def create_alliance_obj(self, alliance: providers.Alliance):
+        return self.create(
             alliance_id=alliance.id,
             alliance_name=alliance.name,
             alliance_ticker=alliance.ticker,
             executor_corp_id=alliance.executor_corp_id,
         )
 
-    @staticmethod
+    def update_alliance(self, alliance_id):
-    def update_alliance(id):
+        return self.get(alliance_id=alliance_id).update_alliance()
-        return EveManager.update_alliance_obj(EveManager.get_alliance(id))
 
-    @staticmethod
-    def update_alliance_obj(alliance):
-        model = EveAllianceInfo.objects.get(alliance_id=alliance.id)
-        model.executor_corp_id = alliance.executor_corp_id
-        model.save()
-        return model
 
-    @staticmethod
+class EveCorporationProviderManager:
-    def populate_alliance(id):
+    def get_corporation(self, corp_id) -> providers.Corporation:
-        alliance_model = EveAllianceInfo.objects.get(alliance_id=id)
+        return providers.provider.get_corp(corp_id)
-        alliance = EveManager.get_alliance(id)
-        for corp_id in alliance.corp_ids:
-            if not EveCorporationInfo.objects.filter(corporation_id=corp_id).exists():
-                EveManager.create_corporation(corp_id)
-        EveCorporationInfo.objects.filter(corporation_id__in=alliance.corp_ids).update(alliance=alliance_model)
-        EveCorporationInfo.objects.filter(alliance=alliance_model).exclude(corporation_id__in=alliance.corp_ids).update(
-            alliance=None)
 
-    @classmethod
-    def get_corporation(cls, corp_id):
-        return provider.get_corp(corp_id)
 
-    @staticmethod
+class EveCorporationManager(models.Manager):
-    def create_corporation(id):
+    provider = EveCorporationProviderManager()
-        return EveManager.create_corporation_obj(EveManager.get_corporation(id))
 
-    @staticmethod
+    def create_corporation(self, corp_id):
-    def create_corporation_obj(corp):
+        return self.create_corporation_obj(self.provider.get_corporation(corp_id))
+
+    def create_corporation_obj(self, corp: providers.Corporation):
+        from .models import EveAllianceInfo
         try:
             alliance = EveAllianceInfo.objects.get(alliance_id=corp.alliance_id)
         except EveAllianceInfo.DoesNotExist:
             alliance = None
-        return EveCorporationInfo.objects.create(
+        return self.create(
             corporation_id=corp.id,
             corporation_name=corp.name,
             corporation_ticker=corp.ticker,
@@ -107,97 +85,5 @@ class EveManager(object):
             alliance=alliance,
         )
 
-    @staticmethod
+    def update_corporation(self, corp_id):
-    def update_corporation(id):
+        return self.get(corporation_id=corp_id).update_corporation(self.provider.get_corporation(id))
-        return EveManager.update_corporation_obj(EveManager.get_corporation(id))
-
-    @staticmethod
-    def update_corporation_obj(corp):
-        model = EveCorporationInfo.objects.get(corporation_id=corp.id)
-        model.member_count = corp.members
-        try:
-            model.alliance = EveAllianceInfo.objects.get(alliance_id=corp.alliance_id)
-        except EveAllianceInfo.DoesNotExist:
-            model.alliance = None
-        model.save()
-        return model
-
-    @classmethod
-    def get_itemtype(cls, type_id):
-        return provider.get_itemtype(type_id)
-
-    @staticmethod
-    def check_if_character_exist(char_name):
-        return EveCharacter.objects.filter(character_name=char_name).exists()
-
-    @staticmethod
-    def get_characters_by_owner_id(user):
-        if EveCharacter.objects.filter(user=user).exists():
-            return EveCharacter.objects.all().filter(user=user)
-
-        return None
-
-    @staticmethod
-    def get_character_by_character_name(char_name):
-        if EveCharacter.objects.filter(character_name=char_name).exists():
-            return EveCharacter.objects.get(character_name=char_name)
-
-    @staticmethod
-    def get_character_by_id(char_id):
-        if EveCharacter.objects.filter(character_id=char_id).exists():
-            return EveCharacter.objects.get(character_id=char_id)
-
-        return None
-
-    @staticmethod
-    def get_characters_by_api_id(api_id):
-        return EveCharacter.objects.filter(api_id=api_id)
-
-    @staticmethod
-    def get_charater_alliance_id_by_id(char_id):
-        if EveCharacter.objects.filter(character_id=char_id).exists():
-            return EveCharacter.objects.get(character_id=char_id).alliance_id
-
-    @staticmethod
-    def check_if_character_owned_by_user(char_id, user):
-        character = EveCharacter.objects.get(character_id=char_id)
-
-        if character.user.id == user.id:
-            return True
-
-        return False
-
-    @staticmethod
-    def check_if_alliance_exists_by_id(alliance_id):
-        return EveAllianceInfo.objects.filter(alliance_id=alliance_id).exists()
-
-    @staticmethod
-    def check_if_corporation_exists_by_id(corp_id):
-        return EveCorporationInfo.objects.filter(corporation_id=corp_id).exists()
-
-    @staticmethod
-    def get_alliance_info_by_id(alliance_id):
-        if EveManager.check_if_alliance_exists_by_id(alliance_id):
-            return EveAllianceInfo.objects.get(alliance_id=alliance_id)
-        else:
-            return None
-
-    @staticmethod
-    def get_corporation_info_by_id(corp_id):
-        if EveManager.check_if_corporation_exists_by_id(corp_id):
-            return EveCorporationInfo.objects.get(corporation_id=corp_id)
-        else:
-            return None
-
-    @staticmethod
-    def get_all_corporation_info():
-        return EveCorporationInfo.objects.all()
-
-    @staticmethod
-    def get_all_alliance_info():
-        return EveAllianceInfo.objects.all()
-
-    @staticmethod
-    def get_charater_corporation_id_by_id(char_id):
-        if EveCharacter.objects.filter(character_id=char_id).exists():
-            return EveCharacter.objects.get(character_id=char_id).corporation_id

allianceauth/eveonline/models.py

@@ -1,5 +1,10 @@
 from django.db import models
 
+from .managers import EveCharacterManager, EveCharacterProviderManager
+from .managers import EveCorporationManager, EveCorporationProviderManager
+from .managers import EveAllianceManager, EveAllianceProviderManager
+from . import providers
+
 
 class EveCharacter(models.Model):
     character_id = models.CharField(max_length=254, unique=True)
@@ -10,6 +15,21 @@ class EveCharacter(models.Model):
     alliance_id = models.CharField(max_length=254, blank=True, null=True, default='')
     alliance_name = models.CharField(max_length=254, blank=True, null=True, default='')
 
+    objects = EveCharacterManager()
+    provider = EveCharacterProviderManager()
+
+    def update_character(self, character: providers.Character = None):
+        if character is None:
+            character = self.provider.get_character(self.character_id)
+        self.character_name = character.name
+        self.corporation_id = character.corp.id
+        self.corporation_name = character.corp.name
+        self.corporation_ticker = character.corp.ticker
+        self.alliance_id = character.alliance.id
+        self.alliance_name = character.alliance.name
+        self.save()
+        return self
+
     def __str__(self):
         return self.character_name
 
@@ -20,6 +40,26 @@ class EveAllianceInfo(models.Model):
     alliance_ticker = models.CharField(max_length=254)
     executor_corp_id = models.CharField(max_length=254)
 
+    objects = EveAllianceManager()
+    provider = EveAllianceProviderManager()
+
+    def populate_alliance(self, alliance_id):
+        alliance_model = self.objects.get(alliance_id=alliance_id)
+        alliance = self.objects.get_alliance(alliance_id)
+        for corp_id in alliance.corp_ids:
+            if not EveCorporationInfo.objects.filter(corporation_id=corp_id).exists():
+                EveCorporationInfo.objects.create_corporation(corp_id)
+        EveCorporationInfo.objects.filter(corporation_id__in=alliance.corp_ids).update(alliance=alliance_model)
+        EveCorporationInfo.objects.filter(alliance=alliance_model).exclude(corporation_id__in=alliance.corp_ids).update(
+            alliance=None)
+
+    def update_alliance(self, alliance: providers.Alliance = None):
+        if alliance is None:
+            alliance = self.provider.get_alliance(self.alliance_id)
+        self.executor_corp_id = alliance.executor_corp_id
+        self.save()
+        return self
+
     def __str__(self):
         return self.alliance_name
 
@@ -31,5 +71,19 @@ class EveCorporationInfo(models.Model):
     member_count = models.IntegerField()
     alliance = models.ForeignKey(EveAllianceInfo, blank=True, null=True)
 
+    objects = EveCorporationManager()
+    provider = EveCorporationProviderManager()
+
+    def update_corporation(self, corp: providers.Corporation = None):
+        if corp is None:
+            corp = self.provider.get_corporation(self.corporation_id)
+        self.member_count = corp.members
+        try:
+            self.alliance = EveAllianceInfo.objects.get(alliance_id=corp.alliance_id)
+        except EveAllianceInfo.DoesNotExist:
+            self.alliance = None
+        self.save()
+        return self
+
     def __str__(self):
         return self.corporation_name

allianceauth/eveonline/tasks.py

@@ -1,7 +1,5 @@
 import logging
 
-from .managers import EveManager
-
 from allianceauth.celeryapp import app
 from .models import EveAllianceInfo
 from .models import EveCharacter
@@ -12,18 +10,17 @@ logger = logging.getLogger(__name__)
 
 @app.task
 def update_corp(corp_id):
-    EveManager.update_corporation(corp_id)
+    EveCorporationInfo.objects.update_corporation(corp_id)
 
 
 @app.task
 def update_alliance(alliance_id):
-    EveManager.update_alliance(alliance_id)
+    EveAllianceInfo.objects.update_alliance(alliance_id).populate_alliance(alliance_id)
-    EveManager.populate_alliance(alliance_id)
 
 
 @app.task
 def update_character(character_id):
-    EveManager.update_character(character_id)
+    EveCharacter.objects.update_character(character_id)
 
 
 @app.task

allianceauth/eveonline/tests/test_managers.py

@@ -0,0 +1,219 @@
+from unittest import mock
+
+from django.test import TestCase
+
+from ..models import EveCharacter, EveCorporationInfo, EveAllianceInfo
+from ..providers import Character, Corporation, Alliance
+
+
+class EveCharacterProviderManagerTestCase(TestCase):
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_get_character(self, provider):
+        expected = Character()
+        provider.get_character.return_value = expected
+
+        result = EveCharacter.provider.get_character('1234')
+
+        self.assertEqual(expected, result)
+
+
+class EveCharacterManagerTestCase(TestCase):
+
+    class TestCharacter(Character):
+        @property
+        def alliance(self):
+            return Alliance(id='3456', name='Test Alliance')
+
+        @property
+        def corp(self):
+            return Corporation(id='2345', name='Test Corp', alliance_id='3456', ticker='0BUGS')
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_create_character(self, provider):
+        # Also covers create_character_obj
+        expected = self.TestCharacter(id='1234', name='Test Character', corp_id='2345', alliance_id='3456')
+
+        provider.get_character.return_value = expected
+
+        result = EveCharacter.objects.create_character('1234')
+
+        self.assertEqual(result.character_id, expected.id)
+        self.assertEqual(result.character_name, expected.name)
+        self.assertEqual(result.corporation_id, expected.corp.id)
+        self.assertEqual(result.corporation_name, expected.corp.name)
+        self.assertEqual(result.corporation_ticker, expected.corp.ticker)
+        self.assertEqual(result.alliance_id, expected.alliance.id)
+        self.assertEqual(result.alliance_name, expected.alliance.name)
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_update_character(self, provider):
+        # Also covers Model.update_character
+        existing = EveCharacter.objects.create(
+            character_id='1234',
+            character_name='character.name',
+            corporation_id='character.corp.id',
+            corporation_name='character.corp.name',
+            corporation_ticker='character.corp.ticker',
+            alliance_id='character.alliance.id',
+            alliance_name='character.alliance.name',
+        )
+
+        expected = self.TestCharacter(id='1234', name='Test Character', corp_id='2345', alliance_id='3456')
+
+        provider.get_character.return_value = expected
+
+        result = EveCharacter.objects.update_character('1234')
+
+        self.assertEqual(result.character_id, expected.id)
+        self.assertEqual(result.character_name, expected.name)
+        self.assertEqual(result.corporation_id, expected.corp.id)
+        self.assertEqual(result.corporation_name, expected.corp.name)
+        self.assertEqual(result.corporation_ticker, expected.corp.ticker)
+        self.assertEqual(result.alliance_id, expected.alliance.id)
+        self.assertEqual(result.alliance_name, expected.alliance.name)
+
+    def test_get_character_by_id(self):
+        EveCharacter.objects.create(
+            character_id='1234',
+            character_name='character.name',
+            corporation_id='character.corp.id',
+            corporation_name='character.corp.name',
+            corporation_ticker='character.corp.ticker',
+            alliance_id='character.alliance.id',
+            alliance_name='character.alliance.name',
+        )
+
+        result = EveCharacter.objects.get_character_by_id('1234')
+
+        self.assertEqual(result.character_id, '1234')
+        self.assertEqual(result.character_name, 'character.name')
+
+
+class EveAllianceProviderManagerTestCase(TestCase):
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_get_alliance(self, provider):
+        expected = Alliance()
+        provider.get_alliance.return_value = expected
+
+        result = EveAllianceInfo.provider.get_alliance('1234')
+
+        self.assertEqual(expected, result)
+
+
+class EveAllianceManagerTestCase(TestCase):
+
+    class TestAlliance(Alliance):
+        def corp(self, id):
+            return self._corps[id]
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_create_alliance(self, provider):
+        # Also covers create_alliance_obj
+        expected = self.TestAlliance(id='3456', name='Test Alliance', ticker='TEST',
+                                     corp_ids=['2345'], executor_corp_id='2345')
+
+        provider.get_alliance.return_value = expected
+
+        result = EveAllianceInfo.objects.create_alliance('3456')
+
+        self.assertEqual(result.alliance_id, expected.id)
+        self.assertEqual(result.alliance_name, expected.name)
+        self.assertEqual(result.alliance_ticker, expected.ticker)
+        self.assertEqual(result.executor_corp_id, expected.executor_corp_id)
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_update_alliance(self, provider):
+        # Also covers Model.update_alliance
+        EveAllianceInfo.objects.create(
+            alliance_id='3456',
+            alliance_name='alliance.name',
+            alliance_ticker='alliance.ticker',
+            executor_corp_id='alliance.executor_corp_id',
+        )
+        expected = self.TestAlliance(id='3456', name='Test Alliance', ticker='TEST',
+                                     corp_ids=['2345'], executor_corp_id='2345')
+
+        provider.get_alliance.return_value = expected
+
+        result = EveAllianceInfo.objects.update_alliance('3456')
+
+        # This is the only thing ever updated in code
+        self.assertEqual(result.executor_corp_id, expected.executor_corp_id)
+
+
+class EveCorporationProviderManagerTestCase(TestCase):
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_get_corporation(self, provider):
+        expected = Corporation()
+        provider.get_corp.return_value = expected
+
+        result = EveCorporationInfo.provider.get_corporation('2345')
+
+        self.assertEqual(expected, result)
+
+
+class EveCorporationManagerTestCase(TestCase):
+
+    class TestCorporation(Corporation):
+        @property
+        def alliance(self):
+            return EveAllianceManagerTestCase.TestAlliance(id='3456', name='Test Alliance', ticker='TEST',
+                                                           corp_ids=['2345'], executor_corp_id='2345')
+
+        @property
+        def ceo(self):
+            return EveCharacterManagerTestCase.TestCharacter(id='1234', name='Test Character',
+                                                             corp_id='2345', alliance_id='3456')
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_create_corporation(self, provider):
+        # Also covers create_corp_obj
+        exp_alliance = EveAllianceInfo.objects.create(
+            alliance_id='3456',
+            alliance_name='alliance.name',
+            alliance_ticker='alliance.ticker',
+            executor_corp_id='alliance.executor_corp_id',
+        )
+
+        expected = self.TestCorporation(id='2345', name='Test Corp', ticker='0BUGS',
+                                        ceo_id='1234', members=1, alliance_id='3456')
+
+        provider.get_corp.return_value = expected
+
+        result = EveCorporationInfo.objects.create_corporation('2345')
+
+        self.assertEqual(result.corporation_id, expected.id)
+        self.assertEqual(result.corporation_name, expected.name)
+        self.assertEqual(result.corporation_ticker, expected.ticker)
+        self.assertEqual(result.member_count, expected.members)
+        self.assertEqual(result.alliance, exp_alliance)
+
+    @mock.patch('allianceauth.eveonline.managers.providers.provider')
+    def test_create_corporation(self, provider):
+        # Also covers Model.update_corporation
+        exp_alliance = EveAllianceInfo.objects.create(
+            alliance_id='3456',
+            alliance_name='alliance.name',
+            alliance_ticker='alliance.ticker',
+            executor_corp_id='alliance.executor_corp_id',
+        )
+
+        EveCorporationInfo.objects.create(
+            corporation_id='2345',
+            corporation_name='corp.name',
+            corporation_ticker='corp.ticker',
+            member_count=10,
+            alliance=None,
+        )
+
+        expected = self.TestCorporation(id='2345', name='Test Corp', ticker='0BUGS',
+                                        ceo_id='1234', members=1, alliance_id='3456')
+
+        provider.get_corp.return_value = expected
+
+        result = EveCorporationInfo.objects.update_corporation('2345')
+
+        self.assertEqual(result.corporation_id, expected.id)
+        # These are the only updated props
+        self.assertEqual(result.member_count, expected.members)
+        self.assertEqual(result.alliance, exp_alliance)

allianceauth/fleetactivitytracking/views.py

@@ -16,7 +16,7 @@ from django.shortcuts import render, redirect, get_object_or_404
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
 from esi.decorators import token_required
-from allianceauth.eveonline.managers import EveManager
+from allianceauth.eveonline.providers import provider
 from .forms import FatlinkForm
 from .models import Fatlink, Fat
 from slugify import slugify
@@ -248,7 +248,7 @@ def click_fatlink_view(request, token, hash, fatname):
 
     if (timezone.now() - fatlink.fatdatetime) < datetime.timedelta(seconds=(fatlink.duration * 60)):
 
-        character = EveManager.get_character_by_id(token.character_id)
+        character = EveCharacter.objects.get_character_by_id(token.character_id)
 
         if character:
             # get data
@@ -267,7 +267,7 @@ def click_fatlink_view(request, token, hash, fatname):
                         'name']
             else:
                 location['station_name'] = "No Station"
-            ship['ship_type_name'] = EveManager.get_itemtype(ship['ship_type_id']).name
+            ship['ship_type_name'] = provider.get_itemtype(ship['ship_type_id']).name
 
             fat = Fat()
             fat.system = location['solar_system_name']

allianceauth/srp/views.py

@@ -9,7 +9,7 @@ from django.http import JsonResponse
 from django.shortcuts import render, redirect, get_object_or_404
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
-from allianceauth.eveonline.managers import EveManager
+from allianceauth.eveonline.providers import provider
 from allianceauth.notifications import notify
 from .form import SrpFleetMainForm
 from .form import SrpFleetMainUpdateForm
@@ -200,7 +200,7 @@ def srp_request_view(request, fleet_srp):
                 return redirect("srp:management")
 
             if request.user.character_ownerships.filter(character__character_name=victim_name).exists():
-                srp_request.srp_ship_name = EveManager.get_itemtype(ship_type_id).name
+                srp_request.srp_ship_name = provider.get_itemtype(ship_type_id).name
                 srp_request.kb_total_loss = ship_value
                 srp_request.post_time = post_time
                 srp_request.save()

allianceauth/timerboard/views.py

@@ -8,7 +8,7 @@ from django.shortcuts import get_object_or_404
 from django.shortcuts import render, redirect
 from django.utils import timezone
 from django.utils.translation import ugettext_lazy as _
-from allianceauth.eveonline.managers import EveManager
+from allianceauth.eveonline.models import EveCorporationInfo
 
 from .form import TimerForm
 from .models import Timer
@@ -22,7 +22,7 @@ def timer_view(request):
     logger.debug("timer_view called by user %s" % request.user)
     char = request.user.profile.main_character
     if char:
-        corp = EveManager.get_corporation_info_by_id(char.corporation_id)
+        corp = EveCorporationInfo.get_corporation_info_by_id(char.corporation_id)
     else:
         corp = None
     if corp:
@@ -49,7 +49,7 @@ def add_timer_view(request):
         if form.is_valid():
             # Get character
             character = request.user.profile.main_character
-            corporation = EveManager.get_corporation_info_by_id(character.corporation_id)
+            corporation = EveCorporationInfo.get_corporation_info_by_id(character.corporation_id)
             logger.debug(
                 "Determined timer add request on behalf of character %s corporation %s" % (character, corporation))
             # calculate future time
@@ -107,7 +107,7 @@ def edit_timer(request, timer_id):
         logger.debug("Received POST request containing updated timer form, is valid: %s" % form.is_valid())
         if form.is_valid():
             character = request.user.profile.main_character
-            corporation = EveManager.get_corporation_info_by_id(character.corporation_id)
+            corporation = EveCorporationInfo.get_corporation_info_by_id(character.corporation_id)
             logger.debug(
                 "Determined timer edit request on behalf of character %s corporation %s" % (character, corporation))
             # calculate future time