aa-intel-tool 2.10.1__py3-none-any.whl → 2.11.1__py3-none-any.whl

aa_intel_tool/tests/test_parser_module_feetcomp.py

@@ -0,0 +1,230 @@
+# Standard Library
+from unittest.mock import MagicMock, patch
+
+# AA Intel Tool
+from aa_intel_tool.exceptions import ParserError
+from aa_intel_tool.parser.module.fleetcomp import get_fleet_composition, parse
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestParse(BaseTestCase):
+    def test_raises_error_when_fleetcomp_module_is_disabled(self):
+        """
+        Test that ParserError is raised when the fleet composition module is disabled.
+
+        :return:
+        :rtype:
+        """
+
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            False,
+        ):
+            with self.assertRaises(ParserError):
+                parse(scan_data=[])
+
+    def test_returns_empty_data_for_empty_scan(self):
+        """
+        Test that an empty scan returns empty parsed data.
+
+        :return:
+        :rtype:
+        """
+
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+            ) as mock_safe_scan:
+                mock_safe_scan.return_value = {}
+
+                result = parse(scan_data=[])
+
+                self.assertEqual(result, {})
+
+    def test_parses_valid_scan_data_correctly(self):
+        """
+        Test that valid scan data is parsed correctly.
+
+        :return:
+        :rtype:
+        """
+
+        scan_data = [
+            "Rounon Dax\tJita\tOmen\tCruiser\tFleet Commander (Boss)\t5 - 5 - 5",
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+        ]
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch:
+                mock_qs = MagicMock()
+                mock_qs.filter.return_value = mock_qs
+                mock_qs.__iter__.return_value = iter([])
+                mock_fetch.return_value = mock_qs
+                with patch(
+                    "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+                ) as mock_safe_scan:
+                    mock_safe_scan.return_value = {"parsed": "data"}
+                    result = parse(scan_data=scan_data)
+                    self.assertEqual(result, {"parsed": "data"})
+
+    def tst_handles_duplicate_pilot_entries_in_scan(self):
+        scan_data = [
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+            "Arodem Artemis\tPerimeter\tLeopard\tShuttle\tSquad Member\t0 - 0 - 5\tWing 1 / Squad 1",
+        ]
+        with patch(
+            "aa_intel_tool.app_settings.AppSettings.INTELTOOL_ENABLE_MODULE_FLEETCOMP",
+            True,
+        ):
+            with patch(
+                "aa_intel_tool.parser.module.fleetcomp.safe_scan_to_db"
+            ) as mock_safe_scan:
+                mock_safe_scan.return_value = {"parsed": "data"}
+                result = parse(scan_data=scan_data)
+                self.assertEqual(result, {"parsed": "data"})
+
+
+class TestGetFleetComposition(BaseTestCase):
+    """
+    Testing the get_fleet_composition function
+    """
+
+    def test_returns_correct_fleet_composition_for_valid_data(self):
+        """
+        Test that the fleet composition is returned correctly for valid data.
+
+        :return:
+        :rtype:
+        """
+
+        pilots = {
+            "Pilot1": {"ship": "Omen"},
+            "Pilot2": {"ship": "Zealot"},
+        }
+        ships = {
+            "class": {"Omen": {"count": 1}, "Zealot": {"count": 1}},
+            "type": {"Cruiser": {"count": 1}, "Heavy Assault Cruiser": {"count": 1}},
+        }
+
+        ship1 = MagicMock()
+        ship1.id = 1
+        ship1.name = "Omen"
+        ship1.eve_group__id = 10
+        ship1.eve_group__name = "Cruiser"
+        ship1.mass = 1000
+
+        ship2 = MagicMock()
+        ship2.id = 2
+        ship2.name = "Zealot"
+        ship2.eve_group__id = 20
+        ship2.eve_group__name = "Heavy Assault Cruiser"
+        ship2.mass = 500
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = [
+                1,
+                2,
+            ]
+            mock_bulk.return_value.values_list.return_value = [ship1, ship2]
+            mock_get_character_info.return_value = [
+                MagicMock(
+                    character_name="Pilot1",
+                    character_id=1001,
+                    portrait_url_32="portrait1.png",
+                ),
+                MagicMock(
+                    character_name="Pilot2",
+                    character_id=1002,
+                    portrait_url_32="portrait2.png",
+                ),
+            ]
+
+            result = get_fleet_composition(pilots=pilots, ships=ships)
+
+            self.assertEqual(len(result["classes"]), 2)
+            self.assertEqual(len(result["types"]), 2)
+            self.assertEqual(len(result["pilots"]), 2)
+
+    def test_handles_empty_pilots_and_ships(self):
+        """
+        Test that empty pilots and ships return empty fleet composition.
+        :return:
+        :rtype:
+        """
+
+        pilots = {}
+        ships = {"class": {}, "type": {}}
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = []
+            mock_bulk.return_value.values_list.return_value = []
+            mock_get_character_info.return_value = []
+
+            result = get_fleet_composition(pilots=pilots, ships=ships)
+
+            self.assertEqual(result["classes"], [])
+            self.assertEqual(result["types"], [])
+            self.assertEqual(result["pilots"], [])
+
+    def test_raises_error_for_missing_ship_class_in_pilots(self):
+        """
+        Test that an error is raised when a ship class in pilots is missing.
+
+        :return:
+        :rtype:
+        """
+
+        pilots = {"Pilot1": {"ship": "Unknown"}}
+        ships = {"class": {}, "type": {}}
+        mock_ship_class_details = []
+
+        with (
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveEntity.objects.fetch_by_names_esi"
+            ) as mock_fetch,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp.EveType.objects.bulk_get_or_create_esi"
+            ) as mock_bulk,
+            patch(
+                "aa_intel_tool.parser.module.fleetcomp._get_character_info"
+            ) as mock_get_character_info,
+        ):
+            mock_fetch.return_value.filter.return_value.values_list.return_value = []
+            mock_bulk.return_value.values_list.return_value = mock_ship_class_details
+            mock_get_character_info.return_value = [
+                MagicMock(
+                    character_name="Pilot1",
+                    character_id=1001,
+                    portrait_url_32="portrait1.png",
+                )
+            ]
+
+            with self.assertRaises(StopIteration):
+                get_fleet_composition(pilots=pilots, ships=ships)

aa_intel_tool/tests/test_tasks.py

@@ -0,0 +1,56 @@
+"""
+Unit tests for the tasks in aa_intel_tool.
+"""
+
+# Standard Library
+from datetime import timedelta
+from unittest.mock import patch
+
+# Django
+from django.utils.timezone import now
+
+# AA Intel Tool
+from aa_intel_tool.tasks import housekeeping
+from aa_intel_tool.tests import BaseTestCase
+
+
+class TestHousekeeping(BaseTestCase):
+    """
+    Tests for the housekeeping task
+    """
+
+    def test_removes_scans_older_than_retention_time(self):
+        """
+        Test that scans older than the retention time are removed.
+
+        :return:
+        :rtype:
+        """
+
+        with (
+            patch("aa_intel_tool.tasks.AppSettings.INTELTOOL_SCAN_RETENTION_TIME", 7),
+            patch("aa_intel_tool.tasks.Scan.objects.filter") as mock_filter,
+        ):
+            housekeeping()
+            mock_filter.assert_called_once()
+            called_kwargs = mock_filter.call_args.kwargs
+            created_lte = called_kwargs.get("created__lte")
+            expected = now() - timedelta(days=7)
+
+            self.assertTrue(abs(created_lte - expected) < timedelta(seconds=1))
+            mock_filter.return_value.delete.assert_called_once()
+
+    def test_does_not_remove_scans_when_retention_time_is_zero(self):
+        """
+        Test that no scans are removed when retention time is set to zero.
+
+        :return:
+        :rtype:
+        """
+
+        with (
+            patch("aa_intel_tool.tasks.AppSettings.INTELTOOL_SCAN_RETENTION_TIME", 0),
+            patch("aa_intel_tool.tasks.Scan.objects.filter") as mock_filter,
+        ):
+            housekeeping()
+            mock_filter.assert_not_called()

aa_intel_tool/tests/test_views_ajax.py

@@ -0,0 +1,72 @@
+"""
+Tests for the AJAX views in aa_intel_tool.views.ajax.
+"""
+
+# Standard Library
+from http import HTTPStatus
+from unittest.mock import Mock, patch
+
+# Django
+from django.test import RequestFactory
+from django.urls import reverse
+
+# AA Intel Tool
+from aa_intel_tool.models import ScanData
+from aa_intel_tool.tests import BaseTestCase
+from aa_intel_tool.views.ajax import get_scan_data
+
+
+class TestGetScanData(BaseTestCase):
+    """
+    Tests for the get_scan_data AJAX view
+    """
+
+    def test_returns_processed_data_for_valid_scan_hash_and_section(self):
+        """
+        Testing return of processed data for valid scan hash and section
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get(
+            reverse(
+                "aa_intel_tool:ajax_get_scan_data",
+                kwargs={"scan_hash": "valid-hash", "scan_section": "valid-section"},
+            )
+        )
+
+        with patch("aa_intel_tool.views.ajax.ScanData.objects.filter") as mock_filter:
+            mock_scan_data = Mock()
+            mock_scan_data.processed_data = {"key": "value"}
+            mock_filter.return_value.get.return_value = mock_scan_data
+
+            response = get_scan_data(request, "valid-hash", "valid-section")
+
+            self.assertEqual(response.status_code, HTTPStatus.OK)
+            self.assertJSONEqual(response.content, {"key": "value"})
+
+    def test_returns_empty_dict_when_scan_data_does_not_exist(self):
+        """
+        Testing return of empty dict when scan data does not exist
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get(
+            reverse(
+                "aa_intel_tool:ajax_get_scan_data",
+                kwargs={"scan_hash": "invalid-hash", "scan_section": "invalid-section"},
+            )
+        )
+
+        with patch("aa_intel_tool.views.ajax.ScanData.objects.filter") as mock_filter:
+            mock_filter.return_value.get.side_effect = ScanData.DoesNotExist
+
+            response = get_scan_data(request, "invalid-hash", "invalid-section")
+
+            self.assertEqual(response.status_code, HTTPStatus.OK)
+            self.assertJSONEqual(response.content, {})

aa_intel_tool/tests/test_views_general.py

@@ -0,0 +1,240 @@
+"""
+Tests for the general views of the AA Intel Tool application.
+"""
+
+# Standard Library
+from http import HTTPStatus
+from unittest.mock import Mock, patch
+
+# Django
+from django.contrib.messages import get_messages
+from django.contrib.messages.storage.fallback import FallbackStorage
+from django.contrib.sessions.middleware import SessionMiddleware
+from django.test import RequestFactory
+
+# AA Intel Tool
+from aa_intel_tool.exceptions import ParserError
+from aa_intel_tool.models import Scan
+from aa_intel_tool.tests import BaseTestCase
+from aa_intel_tool.views import general as general_view
+
+
+class TestViewIndex(BaseTestCase):
+    """
+    Tests for the index view
+    """
+
+    def test_redirects_to_scan_view_on_valid_form_submission_direct_call(self):
+        """
+        Testing redirection to scan view on valid form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "valid intel data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.return_value = "valid_scan_hash"
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+            self.assertEqual(response["Location"], "/intel/scan/valid_scan_hash/")
+
+    def test_shows_error_message_on_parser_error_direct_call(self):
+        """
+        Testing error message on parser error during form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "invalid intel data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.side_effect = ParserError("Parsing failed")
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            # ensure the general parse-failure message is present
+            self.assertTrue(
+                any("The provided data could not be parsed." in m for m in messages),
+                f"messages were: {messages}",
+            )
+            # ensure the exception detail is included somewhere
+            self.assertTrue(
+                any("Parsing failed" in m for m in messages),
+                f"messages were: {messages}",
+            )
+
+    def test_shows_error_message_on_unexpected_exception_direct_call(self):
+        """
+        Testing error message on unexpected exception during form submission
+
+        :return:
+        :rtype:
+        """
+
+        form_data = {"eve_intel": "unexpected error data"}
+        rf = RequestFactory()
+        request = rf.post("/intel/", data=form_data)
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with (
+            patch("aa_intel_tool.views.general.IntelForm") as mock_form,
+            patch("aa_intel_tool.views.general.parse_intel") as mock_parse,
+        ):
+            mock_form.return_value.is_valid.return_value = True
+            mock_form.return_value.cleaned_data = form_data
+            mock_parse.side_effect = Exception("Unexpected error")
+
+            response = general_view.index(request)
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            self.assertTrue(
+                any(
+                    "Something unexpected happened" in m or "(System Error)" in m
+                    for m in messages
+                ),
+                f"messages were: {messages}",
+            )
+            self.assertTrue(
+                any("Unexpected error" in m for m in messages),
+                f"messages were: {messages}",
+            )
+
+    def test_renders_blank_form_on_get_request_direct_call(self):
+        """
+        Testing rendering of blank form on GET request
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/")
+
+        response = general_view.index(request)
+
+        self.assertEqual(response.status_code, HTTPStatus.OK)
+        self.assertIn("<form", response.content.decode("utf-8"))
+
+
+class TestViewScan(BaseTestCase):
+    """
+    Tests for the scan view
+    """
+
+    def test_shows_error_message_when_scan_does_not_exist(self):
+        """
+        Testing error message when scan does not exist
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/scan/nonexistent-scan-hash/")
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+
+        request._messages = FallbackStorage(request)
+        with patch("aa_intel_tool.views.general.Scan.objects.exclude") as mock_exclude:
+            mock_exclude.return_value.get.side_effect = Scan.DoesNotExist
+
+            response = general_view.scan(request, scan_hash="nonexistent-scan-hash")
+
+            self.assertEqual(response.status_code, HTTPStatus.FOUND)
+
+            messages = [str(m) for m in get_messages(request)]
+
+            self.assertTrue(
+                any(
+                    "The scan you were looking for could not be found." in m
+                    for m in messages
+                ),
+                f"messages were: {messages}",
+            )
+
+    def test_renders_correct_template_for_supported_scan_type(self):
+        """
+        Testing rendering of correct template for supported scan type
+
+        :return:
+        :rtype:
+        """
+
+        rf = RequestFactory()
+        request = rf.get("/intel/scan/supported-scan-hash/")
+
+        middleware = SessionMiddleware(lambda req: None)
+        middleware.process_request(request)
+        request.session.save()
+        request._messages = FallbackStorage(request)
+
+        with patch("aa_intel_tool.views.general.Scan.objects.exclude") as mock_exclude:
+            mock_scan = Mock()
+            mock_scan.scan_type = "supported_type"
+            mock_scan.created = "2023-01-01"
+            mock_scan.raw_data = "raw intel data"
+            mock_exclude.return_value.get.return_value = mock_scan
+
+            # dummy response that mimics a rendered template response
+            dummy_response = Mock()
+            dummy_response.status_code = HTTPStatus.OK
+            dummy_response.templates = [
+                type("T", (), {"name": "supported_template.html"})()
+            ]
+
+            with (
+                patch(
+                    "aa_intel_tool.views.general.SUPPORTED_INTEL_TYPES",
+                    {
+                        "supported_type": {
+                            "name": "Supported Type",
+                            "template": "supported_template.html",
+                        }
+                    },
+                ),
+                patch(
+                    "aa_intel_tool.views.general.render", return_value=dummy_response
+                ) as mock_render,
+            ):
+                response = general_view.scan(request, scan_hash="supported-scan-hash")
+
+                self.assertEqual(response.status_code, HTTPStatus.OK)
+                self.assertTemplateUsed(response, "supported_template.html")
+                mock_render.assert_called_once()

{aa_intel_tool-2.10.1.dist-info → aa_intel_tool-2.11.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aa-intel-tool
-Version: 2.10.1
+Version: 2.11.1
 Summary: A simple parser for D-Scans and more for Alliance Auth
 Project-URL: Changelog, https://github.com/ppfeufer/aa-intel-tool/blob/master/CHANGELOG.md
 Project-URL: Codecov, https://codecov.io/gh/ppfeufer/aa-intel-tool