aa-ledger 1.0.4__py3-none-any.whl → 2.0.0__py3-none-any.whl

ledger/tests/test_views/test_planetary.py

@@ -1,137 +0,0 @@
-"""TestView class."""
-
-# Standard Library
-from http import HTTPStatus
-from unittest.mock import Mock, patch
-
-# Django
-from django.contrib.sessions.middleware import SessionMiddleware
-from django.test import RequestFactory, TestCase
-from django.urls import reverse
-
-# AA Ledger
-from ledger.tests.testdata.generate_characteraudit import (
-    add_characteraudit_character_to_user,
-    create_user_from_evecharacter_with_access,
-)
-from ledger.tests.testdata.generate_planets import (
-    _planetary_data,
-    create_character_planet,
-    create_character_planet_details,
-)
-from ledger.tests.testdata.load_allianceauth import load_allianceauth
-from ledger.tests.testdata.load_eveuniverse import load_eveuniverse
-from ledger.views.character import planetary
-
-PLANETARY_PATH = "ledger.views.character.planetary"
-
-
-class TestViewSwitchAlarm(TestCase):
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        load_allianceauth()
-        load_eveuniverse()
-
-        cls.planet_params = {
-            "upgrade_level": 5,
-            "num_pins": 5,
-        }
-
-        cls.factory = RequestFactory()
-        cls.user, cls.character_ownership = create_user_from_evecharacter_with_access(
-            1001
-        )
-        cls.user_nopermission, cls.character_ownership_no_pm = (
-            create_user_from_evecharacter_with_access(1002)
-        )
-        cls.audit = add_characteraudit_character_to_user(cls.user, 1001)
-        cls.planetary = create_character_planet(cls.audit, 4001, **cls.planet_params)
-        cls.planetarydetails = create_character_planet_details(
-            cls.planetary, **_planetary_data
-        )
-
-    def test_switch_alarm(self):
-        character_id = self.audit.eve_character.character_id
-        form_data = {
-            "character_id": character_id,
-            "planet_id": 4001,
-            "confirm": "yes",
-        }
-
-        request = self.factory.post(
-            reverse("ledger:switch_alarm"),
-            data=form_data,
-        )
-        request.user = self.user
-
-        response = planetary.switch_alarm(request)
-
-        self.assertEqual(response.status_code, HTTPStatus.OK)
-
-    def test_switch_alarm_all(self):
-        form_data = {
-            "character_id": 0,
-            "planet_id": 0,
-            "confirm": "yes",
-        }
-
-        request = self.factory.post(
-            reverse("ledger:switch_alarm"),
-            data=form_data,
-        )
-        request.user = self.user
-
-        response = planetary.switch_alarm(request)
-
-        self.assertEqual(response.status_code, HTTPStatus.OK)
-
-    @patch(PLANETARY_PATH + ".CharacterPlanetDetails.objects.filter")
-    def test_switch_alarm_doesnotexist(self, mock_planetdetails_filter):
-        form_data = {
-            "character_id": 1001,
-            "planet_id": 0,
-            "confirm": "yes",
-        }
-
-        mock_queryset = Mock()
-        mock_queryset.exists.return_value = False
-        mock_planetdetails_filter.return_value = mock_queryset
-
-        request = self.factory.post(
-            reverse("ledger:switch_alarm"),
-            data=form_data,
-        )
-        request.user = self.user
-
-        response = planetary.switch_alarm(request)
-
-        self.assertEqual(response.status_code, HTTPStatus.NOT_FOUND)
-        mock_planetdetails_filter.assert_called_once()
-
-    def test_switch_alarm_no_permission(self):
-        form_data = {
-            "character_id": 1001,
-            "planet_id": 4001,
-            "confirm": "yes",
-        }
-        request = self.factory.post(
-            reverse("ledger:switch_alarm"),
-            data=form_data,
-        )
-        request.user = self.user_nopermission
-
-        response = planetary.switch_alarm(request)
-
-        self.assertEqual(response.status_code, HTTPStatus.FORBIDDEN)
-
-    def test_switch_alarm_invalid(self):
-        request = self.factory.post(
-            reverse("ledger:switch_alarm"),
-            data=None,
-        )
-        request.user = self.user
-
-        response = planetary.switch_alarm(request)
-
-        self.assertEqual(response.status_code, HTTPStatus.BAD_REQUEST)

ledger/tests/testdata/esi_stub.py

@@ -1,109 +0,0 @@
-# Standard Library
-import json
-from pathlib import Path
-
-# Alliance Auth (External Libs)
-from app_utils.esi_testing import EsiClientStub
-
-# AA Ledger
-from ledger.tests.testdata.esi_stub_migration import EsiClientStubOpenApi, EsiEndpoint
-
-
-class CharacterJournalContext:
-    """Context for character wallet journal ESI operations."""
-
-    amount: float
-    balance: float
-    context_id: int
-    context_id_type: str
-    date: str
-    description: str
-    first_party_id: int
-    id: int
-    reason: str
-    ref_type: str
-    second_party_id: int
-    tax: float
-    tax_receiver_id: int
-
-
-def load_test_data():
-    file_path = Path(__file__).parent / "esi.json"
-    with file_path.open("r", encoding="utf-8") as fp:
-        return json.load(fp)
-
-
-_esi_data = load_test_data()
-
-_endpoints = [
-    EsiEndpoint(
-        "Character",
-        "GetCharactersCharacterIdRoles",
-        "character_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Wallet",
-        "GetCharactersCharacterIdWalletJournal",
-        "character_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Wallet",
-        "GetCharactersCharacterIdWallet",
-        "character_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Corporation",
-        "GetCorporationsCorporationIdDivisions",
-        "corporation_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Wallet",
-        "GetCorporationsCorporationIdWallets",
-        "corporation_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Wallet",
-        "GetCorporationsCorporationIdWalletsDivisionJournal",
-        "corporation_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Industry",
-        "GetCharactersCharacterIdMining",
-        "character_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Planetary_Interaction",
-        "GetCharactersCharacterIdPlanets",
-        "character_id",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Planetary_Interaction",
-        "GetCharactersCharacterIdPlanetsPlanetId",
-        ("character_id", "planet_id"),
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Universe",
-        "PostUniverseNames",
-        "body",
-        needs_token=False,
-    ),
-    EsiEndpoint(
-        "Universe",
-        "PostUniverseIds",
-        "body",
-        needs_token=False,
-    ),
-]
-
-esi_client_stub = EsiClientStub(_esi_data, endpoints=_endpoints)
-esi_client_stub_openapi = EsiClientStubOpenApi(_esi_data, endpoints=_endpoints)
-esi_client_error_stub = EsiClientStub(_esi_data, endpoints=_endpoints, http_error=502)

ledger/tests/testdata/esi_stub_migration.py

@@ -1,80 +0,0 @@
-# Standard Library
-from types import SimpleNamespace
-from typing import Any
-
-# Django
-from django.utils import timezone
-
-# Alliance Auth (External Libs)
-from app_utils.esi_testing import (
-    BravadoOperationStub,
-    EsiClientStub,
-    EsiEndpoint,
-    _EsiMethod,
-    parse_datetime,
-)
-
-
-class EsiEndpoint(EsiEndpoint):
-    def __init__(self, *args, return_response=False, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.return_response = return_response
-
-
-class _EsiMethodOpenApi(_EsiMethod):
-    """An ESI method that can be called from the ESI client using OpenAPI client."""
-
-    @staticmethod
-    def _convert_values(data) -> Any:
-        def convert_dict(item):
-            if isinstance(item, dict):
-                for key, value in item.items():
-                    if isinstance(value, str):
-                        try:
-                            if parsed_datetime := parse_datetime(value):
-                                item[key] = parsed_datetime.replace(tzinfo=timezone.utc)
-                        except ValueError:
-                            pass
-
-        def dict_to_obj(obj):
-            if isinstance(obj, dict):
-                return SimpleNamespace(**{k: dict_to_obj(v) for k, v in obj.items()})
-            elif isinstance(obj, list):
-                return [dict_to_obj(i) for i in obj]
-            else:
-                return obj
-
-        if isinstance(data, list):
-            for row in data:
-                convert_dict(row)
-        else:
-            convert_dict(data)
-
-        return dict_to_obj(data)
-
-    def call(self, **kwargs):
-        result_obj = super().call(**kwargs)
-        if self._endpoint.return_response:
-            return BravadoOperationStub(result_obj.result(), also_return_response=True)
-        return result_obj
-
-
-class EsiClientStubOpenApi(EsiClientStub):
-    """ESI Client Stub that uses OpenAPI generated client."""
-
-    def _add_endpoint(self, endpoint: EsiEndpoint):
-        if not hasattr(self, endpoint.category):
-            setattr(self, endpoint.category, type(endpoint.category, (object,), {}))
-        endpoint_category = getattr(self, endpoint.category)
-        if not hasattr(endpoint_category, endpoint.method):
-            setattr(
-                endpoint_category,
-                endpoint.method,
-                _EsiMethodOpenApi(
-                    endpoint=endpoint,
-                    testdata=self._testdata,
-                    http_error=self._http_error,
-                ).call,
-            )
-        else:
-            raise ValueError(f"Endpoint for {endpoint} already defined!")

ledger/tests/testdata/generate_characteraudit.py

@@ -1,106 +0,0 @@
-# Django
-from django.contrib.auth.models import User
-
-# Alliance Auth
-from allianceauth.authentication.backends import StateBackend
-from allianceauth.authentication.models import CharacterOwnership
-from allianceauth.eveonline.models import EveCharacter
-from allianceauth.tests.auth_utils import AuthUtils
-
-# Alliance Auth (External Libs)
-from app_utils.testing import add_character_to_user
-from eveuniverse.models import EveType
-
-# AA Ledger
-from ledger.models.characteraudit import CharacterAudit, CharacterUpdateStatus
-
-
-def create_character(eve_character: EveCharacter, **kwargs) -> CharacterAudit:
-    """Create a Skillfarm Character from EveCharacter"""
-    params = {
-        "character_name": eve_character.character_name,
-        "eve_character": eve_character,
-    }
-    params.update(kwargs)
-    character = CharacterAudit(**params)
-    character.save()
-    return character
-
-
-def create_update_status(
-    character_audit: CharacterAudit, **kwargs
-) -> CharacterUpdateStatus:
-    """Create a Update Status for a Character Audit"""
-    params = {
-        "character": character_audit,
-    }
-    params.update(kwargs)
-    update_status = CharacterUpdateStatus(**params)
-    update_status.save()
-    return update_status
-
-
-def create_characteraudit_from_user(user: User, **kwargs) -> CharacterAudit:
-    """Create a Character Audit from a user"""
-    eve_character = user.profile.main_character
-    if not eve_character:
-        raise ValueError("User needs to have a main character.")
-
-    kwargs.update({"eve_character": eve_character})
-    return create_character(**kwargs)
-
-
-def create_user_from_evecharacter_with_access(
-    character_id: int, disconnect_signals: bool = True
-) -> tuple[User, CharacterOwnership]:
-    """Create user with access from an existing eve character and use it as main."""
-    auth_character = EveCharacter.objects.get(character_id=character_id)
-    username = StateBackend.iterate_username(auth_character.character_name)
-    user = AuthUtils.create_user(username, disconnect_signals=disconnect_signals)
-    user = AuthUtils.add_permission_to_user_by_name(
-        "ledger.basic_access", user, disconnect_signals=disconnect_signals
-    )
-    character_ownership = add_character_to_user(
-        user,
-        auth_character,
-        is_main=True,
-        scopes=CharacterAudit.get_esi_scopes(),
-        disconnect_signals=disconnect_signals,
-    )
-    return user, character_ownership
-
-
-def create_characteraudit_from_evecharacter(
-    character_id: int, **kwargs
-) -> CharacterAudit:
-    """Create a Audit Character from a existing EveCharacter"""
-
-    _, character_ownership = create_user_from_evecharacter_with_access(
-        character_id, disconnect_signals=True
-    )
-    return create_character(character_ownership.character, **kwargs)
-
-
-def add_auth_character_to_user(
-    user: User, character_id: int, disconnect_signals: bool = True
-) -> CharacterOwnership:
-    auth_character = EveCharacter.objects.get(character_id=character_id)
-    return add_character_to_user(
-        user,
-        auth_character,
-        is_main=False,
-        scopes=CharacterAudit.get_esi_scopes(),
-        disconnect_signals=disconnect_signals,
-    )
-
-
-def add_characteraudit_character_to_user(
-    user: User, character_id: int, disconnect_signals: bool = True, **kwargs
-) -> CharacterAudit:
-    """Add a Character Audit Character to a user"""
-    character_ownership = add_auth_character_to_user(
-        user,
-        character_id,
-        disconnect_signals=disconnect_signals,
-    )
-    return create_character(character_ownership.character, **kwargs)

ledger/tests/testdata/generate_corporationaudit.py

@@ -1,74 +0,0 @@
-# Django
-from django.contrib.auth.models import User
-
-# Alliance Auth
-from allianceauth.eveonline.models import EveCharacter
-
-# Alliance Auth (External Libs)
-from app_utils.testing import (
-    create_user_from_evecharacter,
-)
-
-# AA Ledger
-from ledger.models.corporationaudit import CorporationAudit, CorporationUpdateStatus
-from ledger.tests.testdata.generate_characteraudit import (
-    add_auth_character_to_user,
-    create_user_from_evecharacter_with_access,
-)
-
-
-def create_corporationaudit(eve_character: EveCharacter, **kwargs) -> CorporationAudit:
-    """Create a LedgerAudit Corporation from EveCharacter"""
-    params = {
-        "corporation_name": eve_character.corporation_name,
-        "corporation": eve_character.corporation,
-    }
-    params.update(kwargs)
-    corporation = CorporationAudit(**params)
-    corporation.save()
-    return corporation
-
-
-def create_corporation_update_status(
-    corporation_audit: CorporationAudit, **kwargs
-) -> CorporationUpdateStatus:
-    """Create a Update Status for a Character Audit"""
-    params = {
-        "corporation": corporation_audit,
-    }
-    params.update(kwargs)
-    update_status = CorporationUpdateStatus(**params)
-    update_status.save()
-    return update_status
-
-
-def create_corporationaudit_from_user(user: User, **kwargs) -> CorporationAudit:
-    """Create a Character Audit from a user"""
-    eve_character = user.profile.main_character
-    if not eve_character:
-        raise ValueError("User needs to have a main character.")
-
-    kwargs.update({"eve_character": eve_character})
-    return create_corporationaudit(**kwargs)
-
-
-def create_corporationaudit_from_evecharacter(
-    character_id: int, **kwargs
-) -> CorporationAudit:
-    """Create a Audit Character from a existing EveCharacter"""
-
-    _, character_ownership = create_user_from_evecharacter_with_access(
-        character_id, disconnect_signals=True
-    )
-    return create_corporationaudit(character_ownership.character, **kwargs)
-
-
-def add_corporationaudit_corporation_to_user(
-    user: User, character_id: int, disconnect_signals: bool = True, **kwargs
-) -> CorporationAudit:
-    character_ownership = add_auth_character_to_user(
-        user,
-        character_id,
-        disconnect_signals=disconnect_signals,
-    )
-    return create_corporationaudit(character_ownership.character, **kwargs)

ledger/tests/testdata/generate_events.py

@@ -1,31 +0,0 @@
-# Django
-from django.utils import timezone
-
-# AA Ledger
-from ledger.models.events import Events
-
-
-def create_event(char_ledger: bool, **kwargs) -> Events:
-    """Create a Event for a Corporation"""
-    params = {
-        "char_ledger": char_ledger,
-    }
-    params.update(kwargs)
-    events = Events(**params)
-    events.save()
-    return events
-
-
-def create_event_1_day(
-    char_ledger: bool, date_start: timezone.datetime, **kwargs
-) -> Events:
-    """Create a Event for a Corporation"""
-    params = {
-        "char_ledger": char_ledger,
-        "date_start": date_start,
-        "date_end": date_start + timezone.timedelta(days=1),
-    }
-    params.update(kwargs)
-    events = Events(**params)
-    events.save()
-    return events

ledger/tests/testdata/generate_miningledger.py

@@ -1,13 +0,0 @@
-# AA Ledger
-from ledger.models.characteraudit import CharacterAudit, CharacterMiningLedger
-
-
-def create_miningledger(character: CharacterAudit, **kwargs) -> CharacterMiningLedger:
-    """Create a CorporationWalletDivision"""
-    params = {
-        "character": character,
-    }
-    params.update(kwargs)
-    division = CharacterMiningLedger(**params)
-    division.save()
-    return division

ledger/tests/testdata/generate_planets.py

@@ -1,48 +0,0 @@
-"""Generate AllianceAuth test objects from allianceauth.json."""
-
-# Standard Library
-import json
-from pathlib import Path
-
-# Alliance Auth (External Libs)
-from eveuniverse.models import EvePlanet
-
-# AA Ledger
-from ledger.models.characteraudit import CharacterAudit
-from ledger.models.planetary import CharacterPlanet, CharacterPlanetDetails
-
-
-def _load_planetary_data():
-    with open(Path(__file__).parent / "planetary.json", encoding="utf-8") as fp:
-        return json.load(fp)
-
-
-_planetary_data = _load_planetary_data()
-
-
-def create_character_planet(
-    characteraudit: CharacterAudit, planet_id: int, **kwargs
-) -> CharacterPlanet:
-    """Create a CharacterPlanet from CharacterAudit and planet_id."""
-    params = {
-        "character": characteraudit,
-        "planet": EvePlanet.objects.get(id=planet_id),
-    }
-    params.update(kwargs)
-    planet = CharacterPlanet(**params)
-    planet.save()
-    return planet
-
-
-def create_character_planet_details(
-    characterplanet: CharacterPlanet, **kwargs
-) -> CharacterPlanetDetails:
-    """Create a CharacterPlanetDetails from CharacterPlanet."""
-    params = {
-        "character": characterplanet.character,
-        "planet": characterplanet,
-    }
-    params.update(kwargs)
-    planetdetails = CharacterPlanetDetails(**params)
-    planetdetails.save()
-    return planetdetails

ledger/tests/testdata/generate_walletjournal.py

@@ -1,42 +0,0 @@
-# Alliance Auth
-from allianceauth.eveonline.models import EveCharacter
-
-# Alliance Auth (External Libs)
-from app_utils.testing import (
-    create_user_from_evecharacter,
-)
-
-# AA Ledger
-from ledger.models.characteraudit import CharacterWalletJournalEntry
-from ledger.models.corporationaudit import (
-    CorporationAudit,
-    CorporationWalletDivision,
-    CorporationWalletJournalEntry,
-)
-
-
-def create_division(
-    corporation: CorporationAudit, **kwargs
-) -> CorporationWalletDivision:
-    """Create a CorporationWalletDivision"""
-    params = {
-        "corporation": corporation,
-    }
-    params.update(kwargs)
-    division = CorporationWalletDivision(**params)
-    division.save()
-    return division
-
-
-def create_wallet_journal_entry(
-    journal_type: str, **kwargs
-) -> CorporationWalletJournalEntry | CharacterWalletJournalEntry:
-    """Create a CorporationWalletJournalEntry"""
-    params = {}
-    params.update(kwargs)
-    if journal_type == "corporation":
-        journal_entry = CorporationWalletJournalEntry(**params)
-    else:
-        journal_entry = CharacterWalletJournalEntry(**params)
-    journal_entry.save()
-    return journal_entry