aa-intel-tool 2.6.1__py3-none-any.whl → 2.6.2__py3-none-any.whl

aa_intel_tool/tests/test_helper_eve_character.py

@@ -0,0 +1,405 @@
+"""
+Tests for the helper functions in the eve_character module.
+"""
+
+# Standard Library
+from unittest.mock import Mock, patch
+
+# Django
+from django.test import TestCase
+
+# Alliance Auth
+from allianceauth.eveonline.models import (
+    EveAllianceInfo,
+    EveCharacter,
+    EveCorporationInfo,
+)
+
+# AA Intel Tool
+from aa_intel_tool.helper.eve_character import (
+    _create_alliance,
+    _create_character,
+    _create_corporation,
+    get_or_create_character,
+)
+
+
+class TestCreateAlliance(TestCase):
+    """
+    Test the _create_alliance function.
+    """
+
+    def test_creates_new_alliances(self):
+        """
+        Test that new alliances are created when they do not exist in the database.
+
+        :return:
+        :rtype:
+        """
+
+        alliance_ids = [1001, 1002, 1003]
+
+        with (
+            patch.object(
+                EveAllianceInfo.objects,
+                "filter",
+                return_value=EveAllianceInfo.objects.none(),
+            ),
+            patch.object(
+                EveAllianceInfo.objects, "create_alliance"
+            ) as mock_create_alliance,
+        ):
+            _create_alliance(alliance_ids)
+
+            self.assertEqual(mock_create_alliance.call_count, 3)
+
+    def test_does_not_create_existing_alliances(self):
+        """
+        Test that existing alliances are not created again.
+
+        :return:
+        :rtype:
+        """
+
+        alliance_ids = [1001, 1002, 1003]
+
+        # Create existing alliances in the database
+        EveAllianceInfo.objects.create(
+            alliance_id=1001, alliance_name="Alliance 1001", executor_corp_id=2001
+        )
+        EveAllianceInfo.objects.create(
+            alliance_id=1002, alliance_name="Alliance 1002", executor_corp_id=2002
+        )
+
+        with (
+            patch.object(
+                EveAllianceInfo.objects,
+                "filter",
+                wraps=EveAllianceInfo.objects.filter,
+            ),
+            patch.object(
+                EveAllianceInfo.objects, "create_alliance"
+            ) as mock_create_alliance,
+        ):
+            _create_alliance(alliance_ids)
+
+            mock_create_alliance.assert_called_once_with(alliance_id=1003)
+
+    def test_handles_empty_alliance_ids(self):
+        """
+        Test that no alliances are created when the input list is empty.
+
+        :return:
+        :rtype:
+        """
+
+        alliance_ids = []
+
+        with (
+            patch.object(EveAllianceInfo.objects, "filter"),
+            patch.object(
+                EveAllianceInfo.objects, "create_alliance"
+            ) as mock_create_alliance,
+        ):
+            _create_alliance(alliance_ids)
+
+            mock_create_alliance.assert_not_called()
+
+
+class TestCreateCorporation(TestCase):
+    """
+    Test the _create_corporation function.
+    """
+
+    def test_creates_new_corporations(self):
+        """
+        Test that new corporations are created when they do not exist in the database.
+
+        :return:
+        :rtype:
+        """
+
+        corporation_ids = [2001, 2002, 2003]
+
+        with (
+            patch.object(
+                EveCorporationInfo.objects,
+                "filter",
+                return_value=EveCorporationInfo.objects.none(),
+            ),
+            patch.object(
+                EveCorporationInfo.objects, "create_corporation"
+            ) as mock_create_corporation,
+        ):
+            _create_corporation(corporation_ids)
+
+            self.assertEqual(mock_create_corporation.call_count, 3)
+
+    def test_does_not_create_existing_corporations(self):
+        """
+        Test that existing corporations are not created again.
+
+        :return:
+        :rtype:
+        """
+
+        corporation_ids = [2001, 2002, 2003]
+
+        EveCorporationInfo.objects.create(
+            corporation_id=2001, corporation_name="Corporation 2001", member_count=10
+        )
+        EveCorporationInfo.objects.create(
+            corporation_id=2002, corporation_name="Corporation 2002", member_count=20
+        )
+
+        with (
+            patch.object(
+                EveCorporationInfo.objects,
+                "filter",
+                wraps=EveCorporationInfo.objects.filter,
+            ),
+            patch.object(
+                EveCorporationInfo.objects, "create_corporation"
+            ) as mock_create_corporation,
+        ):
+            _create_corporation(corporation_ids)
+
+            mock_create_corporation.assert_called_once_with(corp_id=2003)
+
+    def test_handles_empty_corporation_ids(self):
+        """
+        Test that no corporations are created when the input list is empty.
+
+        :return:
+        :rtype:
+        """
+
+        corporation_ids = []
+
+        with (
+            patch.object(EveCorporationInfo.objects, "filter"),
+            patch.object(
+                EveCorporationInfo.objects, "create_corporation"
+            ) as mock_create_corporation,
+        ):
+            _create_corporation(corporation_ids)
+
+            mock_create_corporation.assert_not_called()
+
+
+class TestCreateCharacter(TestCase):
+    """
+    Test the _create_character function.
+    """
+
+    @patch("aa_intel_tool.helper.eve_character.EveCharacter.objects.create_character")
+    @patch("aa_intel_tool.helper.eve_character.EveAllianceInfo.objects.create_alliance")
+    @patch("allianceauth.eveonline.providers.provider.get_corp")
+    def test_creates_new_characters(
+        self, mock_get_corp, mock_create_alliance, mock_create_character
+    ):
+        # Setup mock return values
+        mock_create_character.side_effect = [
+            Mock(character_id=1001, alliance_id=3001, corporation_id=2001),
+            Mock(character_id=1002, alliance_id=3001, corporation_id=2002),
+            Mock(character_id=1003, alliance_id=None, corporation_id=2003),
+        ]
+
+        mock_get_corp_side_effect = [
+            Mock(
+                id=2001,
+                name="Corporation 2001",
+                ticker="TICK1",
+                alliance_id=3001,
+                members=10,
+            ),
+            Mock(
+                id=2002,
+                name="Corporation 2002",
+                ticker="TICK2",
+                alliance_id=3001,
+                members=20,
+            ),
+            Mock(
+                id=2003,
+                name="Corporation 2003",
+                ticker="TICK3",
+                alliance_id=None,
+                members=30,
+            ),
+        ]
+
+        # Ensure the mock objects return plain values for attributes
+        for mock_corp in mock_get_corp_side_effect:
+            mock_corp.name = "Corporation " + str(mock_corp.id)
+            mock_corp.ticker = "TICK" + str(mock_corp.id % 1000)
+            mock_corp.members = mock_corp.members
+
+        mock_get_corp.side_effect = (
+            lambda *args, **kwargs: mock_get_corp_side_effect.pop(0)
+        )
+
+        # Call the function under test
+        _create_character(character_ids=[1, 2, 3], with_affiliation=True)
+
+        # Assert that create_character was called three times
+        self.assertEqual(mock_create_character.call_count, 3)
+
+        # Assert that create_alliance was called once with the correct ID
+        mock_create_alliance.assert_called_once_with(alliance_id=3001)
+
+    def test_handles_empty_character_ids(self):
+        """
+        Test that no characters are created when the input list is empty.
+
+        :return:
+        :rtype:
+        """
+
+        character_ids = []
+
+        with (
+            patch.object(EveCharacter.objects, "filter"),
+            patch.object(
+                EveCharacter.objects, "create_character"
+            ) as mock_create_character,
+        ):
+            _create_character(character_ids)
+
+            mock_create_character.assert_not_called()
+
+    @patch("aa_intel_tool.helper.eve_character.EveCharacter.objects.create_character")
+    @patch("aa_intel_tool.helper.eve_character.EveAllianceInfo.objects.create_alliance")
+    @patch("allianceauth.eveonline.providers.provider.get_corp")
+    def creates_characters_without_affiliation(
+        self, mock_get_corp, mock_create_alliance, mock_create_character
+    ):
+        # Setup mock return values
+        mock_create_character.side_effect = [
+            Mock(character_id=1001, alliance_id=3001, corporation_id=2001),
+            Mock(character_id=1002, alliance_id=3001, corporation_id=2002),
+            Mock(character_id=1003, alliance_id=None, corporation_id=2003),
+        ]
+
+        mock_get_corp_side_effect = [
+            Mock(
+                id=2001,
+                name="Corporation 2001",
+                ticker="TICK1",
+                alliance_id=3001,
+                members=10,
+            ),
+            Mock(
+                id=2002,
+                name="Corporation 2002",
+                ticker="TICK2",
+                alliance_id=3001,
+                members=20,
+            ),
+            Mock(
+                id=2003,
+                name="Corporation 2003",
+                ticker="TICK3",
+                alliance_id=None,
+                members=30,
+            ),
+        ]
+
+        # Ensure the mock objects return plain values for attributes
+        for mock_corp in mock_get_corp_side_effect:
+            mock_corp.name = "Corporation " + str(mock_corp.id)
+            mock_corp.ticker = "TICK" + str(mock_corp.id % 1000)
+            mock_corp.members = mock_corp.members
+
+        mock_get_corp.side_effect = (
+            lambda *args, **kwargs: mock_get_corp_side_effect.pop(0)
+        )
+
+        # Call the function under test
+        _create_character(character_ids=[1, 2, 3], with_affiliation=False)
+
+        # Assert that create_character was called three times
+        self.assertEqual(mock_create_character.call_count, 3)
+
+        # Assert that create_alliance was called once with the correct ID
+        mock_create_alliance.assert_called_once_with(alliance_id=3001)
+
+
+class TestGetOrCreateCharacter(TestCase):
+    """
+    Test the get_or_create_character function.
+    """
+
+    @patch("aa_intel_tool.helper.eve_character._create_character")
+    def test_returns_existing_characters(self, mock_create_character):
+        """
+        Test that existing characters are returned without creating new ones.
+
+        :param mock_create_character:
+        :type mock_create_character:
+        :return:
+        :rtype:
+        """
+
+        character_ids = [3001, 3002]
+        EveCharacter.objects.create(
+            character_id=3001,
+            character_name="Character 3001",
+            corporation_id=2001,
+            alliance_id=1001,
+        )
+        EveCharacter.objects.create(
+            character_id=3002,
+            character_name="Character 3002",
+            corporation_id=2002,
+            alliance_id=1002,
+        )
+
+        characters = get_or_create_character(character_ids)
+
+        self.assertEqual(characters.count(), 2)
+        mock_create_character.assert_not_called()
+
+    @patch("aa_intel_tool.helper.eve_character._create_character")
+    def test_creates_missing_characters(self, mock_create_character):
+        """
+        Test that missing characters are created when they do not exist in the database.
+
+        :param mock_create_character:
+        :type mock_create_character:
+        :return:
+        :rtype:
+        """
+
+        character_ids = [3001, 3002, 3003]
+        EveCharacter.objects.create(
+            character_id=3001,
+            character_name="Character 3001",
+            corporation_id=2001,
+            alliance_id=1001,
+        )
+
+        characters = get_or_create_character(character_ids)
+
+        self.assertEqual(characters.count(), 1)
+        mock_create_character.assert_called_once_with(
+            character_ids={3002, 3003}, with_affiliation=True
+        )
+
+    @patch("aa_intel_tool.helper.eve_character._create_character")
+    def handles_empty_character_ids(self, mock_create_character):
+        character_ids = []
+
+        characters = get_or_create_character(character_ids)
+
+        self.assertEqual(characters.count(), 0)
+        mock_create_character.assert_not_called()
+
+    @patch("aa_intel_tool.helper.eve_character._create_character")
+    def handles_none_character_ids(self, mock_create_character):
+        character_ids = None
+
+        characters = get_or_create_character(character_ids)
+
+        self.assertEqual(characters.count(), 0)
+        mock_create_character.assert_not_called()

aa_intel_tool/tests/test_models.py

@@ -2,18 +2,106 @@
 Tests for our models
 """
 
+# Standard Library
+from unittest.mock import patch
+
 # Django
+from django.db import IntegrityError
 from django.test import TestCase
 
 # AA Intel Tool
-from aa_intel_tool.models import Scan
+from aa_intel_tool.models import Scan, ScanData
 
 
-class TestScan(TestCase):
+class TestScanModel(TestCase):
     """
-    Tests for the board model
+    Test the Scan model
     """
 
+    def test_generates_unique_hash(self):
+        """
+        Test that the hash is unique
+
+        :return:
+        :rtype:
+        """
+
+        hash1 = Scan.generate_scan_hash()
+        hash2 = Scan.generate_scan_hash()
+
+        self.assertNotEqual(hash1, hash2)
+
+    def test_generates_hash_of_correct_length(self):
+        """
+        Test that the hash is of the correct length
+
+        :return:
+        :rtype:
+        """
+
+        scan_hash = Scan.generate_scan_hash()
+
+        self.assertEqual(len(scan_hash), 30)
+
+    def test_generates_hash_not_in_database(self):
+        """
+        Test that the generated hash is not in the database
+
+        :return:
+        :rtype:
+        """
+
+        existing_scan = Scan.objects.create(raw_data="test data")
+        scan_hash = Scan.generate_scan_hash()
+
+        self.assertNotEqual(scan_hash, existing_scan.hash)
+
+    def test_handles_collision_by_generating_new_hash(self):
+        """
+        Test that the hash collision is handled by generating a new hash
+
+        :return:
+        :rtype:
+        """
+
+        with patch("aa_intel_tool.models.Scan.objects.filter") as mock_filter:
+            # Simulate hash collision by returning True for the first two calls
+            mock_filter.return_value.exists.side_effect = [True, True, False]
+
+            new_hash = Scan.generate_scan_hash()
+
+            self.assertIsNotNone(new_hash)
+            self.assertEqual(len(new_hash), 30)
+            self.assertNotIn(new_hash, ["collision_hash1", "collision_hash2"])
+
+    def test_saves_with_generated_hash(self):
+        """
+        Test that the hash is generated on save
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan(raw_data="test data")
+        scan.save()
+
+        self.assertIsNotNone(scan.hash)
+        self.assertEqual(len(scan.hash), 30)
+
+    def test_generates_new_hash_if_empty_on_save(self):
+        """
+        Test that a new hash is generated if the hash is empty on save
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan(hash="", raw_data="test data")
+        scan.save()
+
+        self.assertNotEqual(scan.hash, "")
+        self.assertEqual(len(scan.hash), 30)
+
     def test_model_string_names(self):
         """
         Test model string name
@@ -27,15 +115,111 @@ class TestScan(TestCase):
         )
         scan.save()
         expected_hash = scan.hash
+
         self.assertEqual(first=str(scan), second=expected_hash)
 
         scan.raw_data = "BarFoo"
         scan.save()
+
         self.assertEqual(first=str(scan), second=expected_hash)
 
         scan.hash = ""
         scan.save()
+
         self.assertNotEqual(first=str(scan), second="")
         self.assertNotEqual(first=str(scan), second=expected_hash)
 
-        scan.save()
+
+class TestScanDataModel(TestCase):
+    """
+    Test the ScanData model
+    """
+
+    def test_creates_scan_data_with_valid_section(self):
+        """
+        Test that the ScanData model can be created with a valid section
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan.objects.create(raw_data="test data")
+        scan_data = ScanData.objects.create(
+            scan=scan,
+            section=ScanData.Section.PILOTLIST,
+            processed_data={"key": "value"},
+        )
+
+        self.assertEqual(scan_data.section, ScanData.Section.PILOTLIST)
+        self.assertEqual(scan_data.processed_data, {"key": "value"})
+
+    def test_defaults_to_invalid_section(self):
+        """
+        Test that the ScanData model defaults to INVALID section if not specified
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan.objects.create(raw_data="test data")
+        scan_data = ScanData.objects.create(scan=scan, processed_data={"key": "value"})
+
+        self.assertEqual(scan_data.section, ScanData.Section.INVALID)
+
+    def test_allows_null_scan(self):
+        """
+        Test that the ScanData model allows null scan
+
+        :return:
+        :rtype:
+        """
+
+        scan_data = ScanData.objects.create(
+            section=ScanData.Section.PILOTLIST, processed_data={"key": "value"}
+        )
+
+        self.assertIsNone(scan_data.scan)
+
+    def test_enforces_unique_together_constraint(self):
+        """
+        Test that the ScanData model enforces unique together constraint on scan and section and raises IntegrityError
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan.objects.create(raw_data="test data")
+        ScanData.objects.create(
+            scan=scan,
+            section=ScanData.Section.PILOTLIST,
+            processed_data={"key": "value"},
+        )
+
+        with self.assertRaises(IntegrityError):
+            ScanData.objects.create(
+                scan=scan,
+                section=ScanData.Section.PILOTLIST,
+                processed_data={"key": "another value"},
+            )
+
+    def test_allows_different_sections_for_same_scan(self):
+        """
+        Test that the ScanData model allows different sections for the same scan
+
+        :return:
+        :rtype:
+        """
+
+        scan = Scan.objects.create(raw_data="test data")
+        scan_data1 = ScanData.objects.create(
+            scan=scan,
+            section=ScanData.Section.PILOTLIST,
+            processed_data={"key": "value"},
+        )
+        scan_data2 = ScanData.objects.create(
+            scan=scan,
+            section=ScanData.Section.CORPORATIONLIST,
+            processed_data={"key": "value"},
+        )
+
+        self.assertNotEqual(scan_data1.section, scan_data2.section)