aa-structures 2.12.0__py3-none-any.whl → 2.14.0__py3-none-any.whl

structures/models/owners.py

@@ -37,6 +37,7 @@ from structures.app_settings import (
     STRUCTURES_DEVELOPER_MODE,
     STRUCTURES_ESI_DIRECTOR_ERROR_MAX_RETRIES,
     STRUCTURES_FEATURE_CUSTOMS_OFFICES,
+    STRUCTURES_FEATURE_SKYHOOKS,
     STRUCTURES_FEATURE_STARBASES,
     STRUCTURES_HOURS_UNTIL_STALE_NOTIFICATION,
     STRUCTURES_NOTIFICATION_SYNC_GRACE_MINUTES,
@@ -545,14 +546,14 @@ class Owner(models.Model):
                 )
 
     def _remove_structures_not_returned_from_esi(
-        self, structures_qs: models.QuerySet, new_structures: Iterable
+        self, existing_structures: models.QuerySet, new_structures: Iterable[dict]
     ):
         """Remove structures no longer returned from ESI."""
-        ids_local = {x.id for x in structures_qs}
+        ids_local = {x.id for x in existing_structures}
         ids_from_esi = {x["structure_id"] for x in new_structures}
         ids_to_remove = ids_local - ids_from_esi
         if len(ids_to_remove) > 0:
-            structures_qs.filter(id__in=ids_to_remove).delete()
+            existing_structures.filter(id__in=ids_to_remove).delete()
             logger.info(
                 "Removed %d structures which apparently no longer exist.",
                 len(ids_to_remove),
@@ -650,7 +651,7 @@ class Owner(models.Model):
             self._store_raw_data("structures", structures)
 
         self._remove_structures_not_returned_from_esi(
-            structures_qs=self.structures.filter_upwell_structures(),
+            existing_structures=self.structures.filter_upwell_structures(),
             new_structures=structures,
         )
         return is_ok
@@ -701,7 +702,7 @@ class Owner(models.Model):
             return False
 
         self._remove_structures_not_returned_from_esi(
-            structures_qs=self.structures.filter_customs_offices(),
+            existing_structures=self.structures.filter_customs_offices(),
             new_structures=structures.values(),
         )
         return True
@@ -868,7 +869,7 @@ class Owner(models.Model):
             return False
 
         self._remove_structures_not_returned_from_esi(
-            structures_qs=self.structures.filter_starbases(),
+            existing_structures=self.structures.filter_starbases(),
             new_structures=structures,
         )
         character.reset_error_counter()
@@ -1214,15 +1215,18 @@ class Owner(models.Model):
     def update_asset_esi(self, user: Optional[User] = None):
         """Update assets from ESI."""
         token = self.fetch_token()
-        assets_data = self._fetch_structure_assets_from_esi(token)
+        assets_data = self._fetch_owner_assets_from_esi(token)
         self._store_items_for_upwell_structures(assets_data)
         self._store_items_for_starbases(assets_data)
+        if STRUCTURES_FEATURE_SKYHOOKS:
+            self._update_skyhooks_from_assets(assets_data)
+            self._resolve_skyhook_planets()
         if user:
             self._send_report_to_user(
                 topic="assets", topic_count=self.structures.count(), user=user
             )
 
-    def _fetch_structure_assets_from_esi(self, token: Token) -> dict:
+    def _fetch_owner_assets_from_esi(self, token: Token) -> dict:
         assets_raw = esi.client.Assets.get_corporations_corporation_id_assets(
             corporation_id=self.corporation.corporation_id,
             token=token.valid_access_token(),
@@ -1306,6 +1310,62 @@ class Owner(models.Model):
                     )
             structure.update_items(structure_items)
 
+    def _update_skyhooks_from_assets(self, assets_data: dict):
+        skyhooks = {
+            item_id: item
+            for item_id, item in assets_data.items()
+            if item["type_id"] == EveTypeId.ORBITAL_SKYHOOK
+            and item["location_type"] == "solar_system"
+            and item["location_flag"] == "AutoFit"
+            and item["is_singleton"]
+            and item["position"]
+        }
+        structures = []
+        for item in skyhooks.values():
+            structures.append(
+                {
+                    "corporation_id": self.corporation.corporation_id,
+                    "type_id": item["type_id"],
+                    "position": item["position"],
+                    "structure_id": item["item_id"],
+                    "system_id": item["location_id"],
+                }
+            )
+
+        for s in structures:
+            Structure.objects.update_or_create_from_dict(s, self)
+
+        self._remove_structures_not_returned_from_esi(
+            existing_structures=self.structures.filter_skyhooks(),
+            new_structures=structures,
+        )
+
+    def _resolve_skyhook_planets(self):
+        """Add planets to all unresolved Skyhooks."""
+        s: Structure
+        for s in self.structures.filter_skyhooks().filter(
+            eve_planet__isnull=True,
+            position_x__isnull=False,
+            position_y__isnull=False,
+            position_z__isnull=False,
+        ):
+            try:
+                celestial = s.eve_solar_system.nearest_celestial(
+                    x=s.position_x,
+                    y=s.position_y,
+                    z=s.position_z,
+                    group_id=EveGroupId.PLANET,
+                )
+            except OSError:
+                continue
+
+            if not celestial or not isinstance(celestial.eve_object, EvePlanet):
+                continue
+
+            s.eve_planet = celestial.eve_object
+            s.name = celestial.eve_type.name
+            s.save()
+
     @staticmethod
     def get_esi_scopes() -> List[str]:
         """Return all required ESI scopes."""

structures/models/structures_1.py

@@ -464,6 +464,11 @@ class Structure(models.Model):  # pylint: disable = too-many-public-methods
         """Return True if this structure is a starbase, else False."""
         return starbases.is_starbase(self.eve_type)
 
+    @property
+    def is_skyhook(self) -> bool:
+        """Return True if this structure is a skyhook, else False."""
+        return self.eve_type_id == EveTypeId.ORBITAL_SKYHOOK
+
     @cached_property
     def is_upwell_structure(self) -> bool:
         """Return True if this structure is an upwell structure, else False."""

structures/templates/structures/public.html

@@ -28,7 +28,7 @@
     <ul id="public-tabs" class="nav nav-tabs" role="tablist">
 
         <li role="presentation" class="active">
-            <a href="#pocos" aria-controls="pocos" role="tab" data-toggle="tab">
+            <a href="#pocos" aria-controls="orbitals" role="tab" data-toggle="tab">
                 {% translate "Customs Offices" %} <small>({{ pocos_count|default:"-" }})</small>
             </a>
         </li>
@@ -39,7 +39,7 @@
         <div class="panel-body">
             <div class="tab-content">
 
-                <div role="tabpanel" class="tab-pane active" id="pocos">
+                <div role="tabpanel" class="tab-pane active" id="orbitals">
                     {% include "structures/partials/public/poco_list.html" %}
                 </div>
 

structures/templates/structures/structures.html

@@ -48,8 +48,8 @@
         </li>
 
         <li role="presentation">
-            <a href="#pocos" aria-controls="pocos" role="tab" data-toggle="tab">
-                {% trans "Customs Offices" %} <small>({{ pocos_count|default:"-" }})</small>
+            <a href="#orbitals" aria-controls="orbitals" role="tab" data-toggle="tab">
+                {% trans "Orbitals" %} <small>({{ orbitals_count|default:"-" }})</small>
             </a>
         </li>
 
@@ -77,7 +77,7 @@
                     {% include "structures/partials/structures/structure_list.html" %}
                 </div>
 
-                <div role="tabpanel" class="tab-pane" id="pocos">
+                <div role="tabpanel" class="tab-pane" id="orbitals">
                     {% include "structures/partials/structures/poco_list.html" %}
                 </div>
 

structures/tests/core/test_notification_types.py

@@ -118,6 +118,11 @@ class TestNotificationType(TestCase):
             "CorpWarInvalidatedMsg",
             "CorpWarRetractedMsg",
             "CorpWarSurrenderMsg",
+            "CorporationGoalClosed",
+            "CorporationGoalCompleted",
+            "CorporationGoalCreated",
+            "CorporationGoalNameChange",
+            "CorporationLeft",
             "CustomsMsg",
             "DeclareWar",
             "DistrictAttacked",
@@ -172,6 +177,7 @@ class TestNotificationType(TestCase):
             "KillRightUnavailable",
             "KillRightUnavailableOpen",
             "KillRightUsed",
+            "LPAutoRedeemed",
             "LocateCharMsg",
             "MadeWarMutual",
             "MercOfferRetractedMsg",
@@ -205,7 +211,14 @@ class TestNotificationType(TestCase):
             "ReimbursementMsg",
             "ResearchMissionAvailableMsg",
             "RetractsWar",
+            "SPAutoRedeemed",
             "SeasonalChallengeCompleted",
+            "SkinSequencingCompleted",
+            "SkyhookDeployed",
+            "SkyhookDestroyed",
+            "SkyhookLostShields",
+            "SkyhookOnline",
+            "SkyhookUnderAttack",
             "SovAllClaimAquiredMsg",
             "SovAllClaimLostMsg",
             "SovCommandNodeEventStarted",
@@ -237,7 +250,10 @@ class TestNotificationType(TestCase):
             "StructureItemsMovedToSafety",
             "StructureLostArmor",
             "StructureLostShields",
+            "StructureLowReagentsAlert",
+            "StructureNoReagentsAlert",
             "StructureOnline",
+            "StructurePaintPurchased",
             "StructureServicesOffline",
             "StructureUnanchoring",
             "StructureUnderAttack",

structures/tests/core/{test_notifications_timerboard.py → test_notifications_timers.py}

@@ -4,6 +4,7 @@ from app_utils.django import app_labels
 from app_utils.testing import NoSocketsTestCase
 
 from structures.core import notification_timers
+from structures.core.notification_types import NotificationType
 from structures.models import Notification
 from structures.tests.testdata.factories import (
     GeneratedNotificationFactory,
@@ -107,7 +108,11 @@ if "timerboard" in app_labels():
         @patch(MODULE_PATH + ".STRUCTURES_MOON_EXTRACTION_TIMERS_ENABLED", True)
         def test_run_all(self):
             for obj in Notification.objects.all():
-                obj.add_or_remove_timer()
+                timer_types = NotificationType.relevant_for_timerboard()
+                with self.subTest(notif_type=obj.notif_type):
+                    is_timer = obj.notif_type in timer_types
+                    is_added = obj.add_or_remove_timer()
+                    self.assertEqual(is_timer, is_added)
 
         @patch(MODULE_PATH + ".STRUCTURES_TIMERS_ARE_CORP_RESTRICTED", False)
         def test_corp_restriction_1(self):

structures/tests/integration/test_tasks.py

@@ -7,7 +7,7 @@ import yaml
 
 from django.test import TestCase, override_settings
 from django.utils.timezone import now
-from eveuniverse.models import EveSolarSystem
+from eveuniverse.models import EvePlanet, EveSolarSystem
 
 from app_utils.django import app_labels
 from app_utils.esi import EsiStatus
@@ -22,11 +22,13 @@ from structures.tests.testdata.factories import (
     NotificationFactory,
     OwnerFactory,
     RawNotificationFactory,
+    SkyhookFactory,
     StarbaseFactory,
     StructureFactory,
     WebhookFactory,
     datetime_to_esi,
 )
+from structures.tests.testdata.helpers import NearestCelestial
 from structures.tests.testdata.load_eveuniverse import load_eveuniverse
 
 if "structuretimers" in app_labels():
@@ -613,3 +615,102 @@ class TestTasks(TestCase):
         self.assertEqual(len(embeds), 1)
         embed = embeds[0]
         self.assertIn("Territorial Claim Unit", embed.title)
+
+    @patch(OWNERS_PATH + ".STRUCTURES_FEATURE_SKYHOOKS", True)
+    def test_should_fetch_new_skyhooks_from_esi(
+        self, mock_esi_2, mock_esi, mock_execute
+    ):
+        # given
+        owner = OwnerFactory()
+        structure = SkyhookFactory(owner=owner)
+        eve_planet = EvePlanet.objects.get(id=40161469)
+        corporation_id = owner.corporation.corporation_id
+        endpoints = [
+            EsiEndpoint(
+                "Assets",
+                "get_corporations_corporation_id_assets",
+                "corporation_id",
+                needs_token=True,
+                data={
+                    str(corporation_id): [
+                        {
+                            "is_singleton": True,
+                            "item_id": structure.id,
+                            "location_flag": "AutoFit",
+                            "location_id": 30002537,
+                            "location_type": "solar_system",
+                            "quantity": 1,
+                            "type_id": 81080,
+                        },
+                    ]
+                },
+            ),
+            EsiEndpoint(
+                "Assets",
+                "post_corporations_corporation_id_assets_names",
+                "corporation_id",
+                needs_token=True,
+                data={str(corporation_id): []},
+            ),
+            EsiEndpoint(
+                "Assets",
+                "post_corporations_corporation_id_assets_locations",
+                "corporation_id",
+                needs_token=True,
+                data={
+                    str(corporation_id): [
+                        {"item_id": structure.id, "position": {"x": 1, "y": 2, "z": 3}}
+                    ]
+                },
+            ),
+            EsiEndpoint(
+                "Corporation",
+                "get_corporations_corporation_id_starbases",
+                "corporation_id",
+                needs_token=True,
+                data={str(corporation_id): []},
+            ),
+            EsiEndpoint(
+                "Corporation",
+                "get_corporations_corporation_id_structures",
+                "corporation_id",
+                needs_token=True,
+                data={str(corporation_id): []},
+            ),
+            EsiEndpoint(
+                "Planetary_Interaction",
+                "get_corporations_corporation_id_customs_offices",
+                "corporation_id",
+                needs_token=True,
+                data={str(corporation_id): []},
+            ),
+            EsiEndpoint(
+                "Sovereignty",
+                "get_sovereignty_map",
+                needs_token=False,
+                data=[],
+            ),
+            EsiEndpoint(
+                "Universe",
+                "get_universe_structures_structure_id",
+                "structure_id",
+                needs_token=True,
+                data={},
+            ),
+        ]
+        mock_esi.client = mock_esi_2.client = EsiClientStub.create_from_endpoints(
+            endpoints
+        )
+        structure_id = structure.id
+        structure.delete()
+        # when
+
+        with patch(OWNERS_PATH + ".EveSolarSystem.nearest_celestial") as m:
+            m.return_value = NearestCelestial(
+                eve_object=eve_planet,
+                distance=35_000_000,
+                eve_type=eve_planet.eve_type,
+            )
+            tasks.update_all_structures.delay()
+        # then
+        self.assertTrue(owner.structures.filter(id=structure_id).exists())

structures/tests/integration/test_views.py

@@ -46,7 +46,7 @@ class TestStructureListView(TestCase):
         # then
         self.assertEqual(response.status_code, 200)
         self.assertEqual(response.context["structures_count"], 2)
-        self.assertEqual(response.context["pocos_count"], 1)
+        self.assertEqual(response.context["orbitals_count"], 1)
         self.assertEqual(response.context["starbases_count"], 1)
         self.assertEqual(response.context["jump_gates_count"], 1)
         self.assertIn("data_export", response.context)

structures/tests/models/test_owners_5.py

@@ -7,18 +7,20 @@ from pytz import utc
 from django.test import override_settings
 from django.utils.timezone import now
 from esi.models import Token
+from eveuniverse.models import EvePlanet
 
 from app_utils.esi_testing import EsiClientStub, EsiEndpoint
 from app_utils.testing import BravadoResponseStub, NoSocketsTestCase, queryset_pks
 
 from structures.core.notification_types import NotificationType
-from structures.models import Notification, StructureItem
+from structures.models import Notification, Structure, StructureItem
 from structures.tests.testdata.factories import (
     EveCharacterFactory,
     EveCorporationInfoFactory,
     EveEntityCorporationFactory,
     JumpFuelAlertConfigFactory,
     OwnerFactory,
+    SkyhookFactory,
     StarbaseFactory,
     StructureFactory,
     StructureItemFactory,
@@ -27,6 +29,7 @@ from structures.tests.testdata.factories import (
     datetime_to_esi,
 )
 from structures.tests.testdata.helpers import (
+    NearestCelestial,
     load_eve_entities,
     load_notification_entities,
 )
@@ -711,6 +714,137 @@ class TestOwnerUpdateAssetEsi(NoSocketsTestCase):
         self.assertTrue(structure.items.filter(id=1300000003001).exists())
 
 
+@patch(OWNERS_PATH + ".STRUCTURES_FEATURE_SKYHOOKS", True)
+@patch(OWNERS_PATH + ".EveSolarSystem.nearest_celestial")
+@patch(OWNERS_PATH + ".esi")
+class TestOwnerUpdateSkyhooks(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+        cls.corporation = EveCharacterFactory()
+        character = EveCharacterFactory(corporation=cls.corporation)
+        cls.user = UserMainDefaultOwnerFactory(main_character__character=character)
+        cls.planet = EvePlanet.objects.get(id=40161469)
+        endpoints = [
+            EsiEndpoint(
+                "Assets",
+                "get_corporations_corporation_id_assets",
+                "corporation_id",
+                needs_token=True,
+                data={
+                    f"{cls.corporation.corporation_id}": [
+                        {
+                            "is_singleton": True,
+                            "item_id": 1000000010001,
+                            "location_flag": "AutoFit",
+                            "location_id": 30002537,
+                            "location_type": "solar_system",
+                            "quantity": 1,
+                            "type_id": 81080,
+                        },
+                    ],
+                },
+            ),
+            EsiEndpoint(
+                "Assets",
+                "post_corporations_corporation_id_assets_locations",
+                "corporation_id",
+                needs_token=True,
+                data={
+                    f"{cls.corporation.corporation_id}": [
+                        {"item_id": 1000000010001, "position": {"x": 1, "y": 2, "z": 3}}
+                    ]
+                },
+            ),
+        ]
+        cls.esi_client_stub = EsiClientStub.create_from_endpoints(endpoints)
+
+    def test_should_create_new_skyhooks_from_scratch(
+        self, mock_esi, mock_nearest_celestial
+    ):
+        # given
+        mock_esi.client = self.esi_client_stub
+        mock_nearest_celestial.return_value = NearestCelestial(
+            eve_object=self.planet, distance=35_000_000, eve_type=self.planet.eve_type
+        )
+        owner = OwnerFactory(user=self.user, assets_last_update_at=None)
+        # when
+        owner.update_asset_esi()
+        # then
+        owner.refresh_from_db()
+        self.assertEqual(owner.structures.count(), 1)
+        obj: Structure = owner.structures.get(pk=1000000010001)
+        self.assertTrue(obj.is_skyhook)
+        self.assertEqual(obj.eve_planet, self.planet)
+
+    def test_should_remove_obsolete_skyhooks(self, mock_esi, mock_nearest_celestial):
+        # given
+        mock_esi.client = self.esi_client_stub
+        mock_nearest_celestial.return_value = NearestCelestial(
+            eve_object=self.planet, distance=35_000_000, eve_type=self.planet.eve_type
+        )
+        owner = OwnerFactory(user=self.user, assets_last_update_at=None)
+        SkyhookFactory.create(owner=owner)
+        # when
+        owner.update_asset_esi()
+        # then
+        owner.refresh_from_db()
+        self.assertEqual(owner.structures.count(), 1)
+        obj: Structure = owner.structures.get(pk=1000000010001)
+        self.assertTrue(obj.is_skyhook)
+        self.assertEqual(obj.eve_planet, self.planet)
+
+    def test_should_update_existing_skyhook(self, mock_esi, mock_nearest_celestial):
+        # given
+        mock_esi.client = self.esi_client_stub
+        mock_nearest_celestial.return_value = NearestCelestial(
+            eve_object=self.planet, distance=35_000_000, eve_type=self.planet.eve_type
+        )
+        owner = OwnerFactory(user=self.user, assets_last_update_at=None)
+        SkyhookFactory.create(owner=owner, id=1000000010001, eve_planet_name="Thera I")
+        # when
+        owner.update_asset_esi()
+        # then
+        owner.refresh_from_db()
+        self.assertEqual(owner.structures.count(), 1)
+        obj: Structure = owner.structures.get(pk=1000000010001)
+        self.assertTrue(obj.is_skyhook)
+        self.assertEqual(obj.eve_planet, self.planet)
+
+    def test_should_ignore_os_error_when_resolving_planet(
+        self, mock_esi, mock_nearest_celestial
+    ):
+        # given
+        mock_esi.client = self.esi_client_stub
+        mock_nearest_celestial.side_effect = OSError
+        owner = OwnerFactory(user=self.user, assets_last_update_at=None)
+        # when
+        owner.update_asset_esi()
+        # then
+        owner.refresh_from_db()
+        self.assertEqual(owner.structures.count(), 1)
+        obj: Structure = owner.structures.get(pk=1000000010001)
+        self.assertTrue(obj.is_skyhook)
+        self.assertIsNone(obj.eve_planet)
+
+    def test_should_ignore_no_reply_when_resolving_planet(
+        self, mock_esi, mock_nearest_celestial
+    ):
+        # given
+        mock_esi.client = self.esi_client_stub
+        mock_nearest_celestial.return_value = None
+        owner = OwnerFactory(user=self.user, assets_last_update_at=None)
+        # when
+        owner.update_asset_esi()
+        # then
+        owner.refresh_from_db()
+        self.assertEqual(owner.structures.count(), 1)
+        obj: Structure = owner.structures.get(pk=1000000010001)
+        self.assertTrue(obj.is_skyhook)
+        self.assertIsNone(obj.eve_planet)
+
+
 class TestOwnerToken(NoSocketsTestCase):
     def test_should_return_valid_token(self):
         # given

structures/tests/models/test_structures.py

@@ -29,6 +29,7 @@ from structures.tests.testdata.factories import (
     OwnerFactory,
     PocoDetailsFactory,
     PocoFactory,
+    SkyhookFactory,
     StarbaseFactory,
     StructureFactory,
     StructureItemFactory,
@@ -367,48 +368,6 @@ class TestStructure(NoSocketsTestCase):
         # when/then
         self.assertEqual(obj.location_name, "?")
 
-    def test_is_poco(self):
-        # given
-        structure = StructureFactory.build(owner=self.owner)
-        poco = PocoFactory.build(owner=self.owner)
-        starbase = StarbaseFactory.build(owner=self.owner)
-        # then
-        self.assertFalse(structure.is_poco)
-        self.assertTrue(poco.is_poco)
-        self.assertFalse(starbase.is_poco)
-
-    def test_is_starbase(self):
-        # given
-        structure = StructureFactory.build(owner=self.owner)
-        poco = PocoFactory.build(owner=self.owner)
-        starbase = StarbaseFactory.build(owner=self.owner)
-        # then
-        self.assertFalse(structure.is_starbase)
-        self.assertFalse(poco.is_starbase)
-        self.assertTrue(starbase.is_starbase)
-
-    def test_is_upwell_structure(self):
-        # given
-        structure = StructureFactory.build(owner=self.owner)
-        poco = PocoFactory.build(owner=self.owner)
-        starbase = StarbaseFactory.build(owner=self.owner)
-        # then
-        self.assertTrue(structure.is_upwell_structure)
-        self.assertFalse(poco.is_upwell_structure)
-        self.assertFalse(starbase.is_upwell_structure)
-
-    def test_is_jump_gate(self):
-        # given
-        normal_structure = StructureFactory.build(owner=self.owner)
-        poco = PocoFactory.build(owner=self.owner)
-        starbase = StarbaseFactory.build(owner=self.owner)
-        jump_gate = JumpGateFactory.build(owner=self.owner)
-        # then
-        self.assertFalse(normal_structure.is_jump_gate)
-        self.assertFalse(poco.is_jump_gate)
-        self.assertFalse(starbase.is_jump_gate)
-        self.assertTrue(jump_gate.is_jump_gate)
-
     # TODO: activate
     # def test_is_upwell_structure_data_error(self):
     #     # group without a category
@@ -490,6 +449,54 @@ class TestStructure(NoSocketsTestCase):
         self.assertFalse(obj.owner_has_sov())
 
 
+class TestStructureIsX(NoSocketsTestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        load_eveuniverse()
+        cls.owner = OwnerFactory()
+        cls.jump_gate = JumpGateFactory.build(owner=cls.owner)
+        cls.poco = PocoFactory.build(owner=cls.owner)
+        cls.skyhook = SkyhookFactory.build(owner=cls.owner)
+        cls.starbase = StarbaseFactory.build(owner=cls.owner)
+        cls.upwell_structure = StructureFactory.build(owner=cls.owner)
+
+    def test_is_jump_gate(self):
+        self.assertFalse(self.upwell_structure.is_jump_gate)
+        self.assertFalse(self.poco.is_jump_gate)
+        self.assertFalse(self.starbase.is_jump_gate)
+        self.assertTrue(self.jump_gate.is_jump_gate)
+        self.assertFalse(self.skyhook.is_jump_gate)
+
+    def test_is_poco(self):
+        self.assertFalse(self.upwell_structure.is_poco)
+        self.assertTrue(self.poco.is_poco)
+        self.assertFalse(self.starbase.is_poco)
+        self.assertFalse(self.jump_gate.is_poco)
+        self.assertFalse(self.skyhook.is_poco)
+
+    def test_is_starbase(self):
+        self.assertFalse(self.upwell_structure.is_starbase)
+        self.assertFalse(self.poco.is_starbase)
+        self.assertTrue(self.starbase.is_starbase)
+        self.assertFalse(self.jump_gate.is_starbase)
+        self.assertFalse(self.skyhook.is_starbase)
+
+    def test_is_skyhook(self):
+        self.assertFalse(self.upwell_structure.is_skyhook)
+        self.assertFalse(self.poco.is_skyhook)
+        self.assertFalse(self.starbase.is_skyhook)
+        self.assertFalse(self.jump_gate.is_skyhook)
+        self.assertTrue(self.skyhook.is_skyhook)
+
+    def test_is_upwell_structure(self):
+        self.assertTrue(self.upwell_structure.is_upwell_structure)
+        self.assertFalse(self.poco.is_upwell_structure)
+        self.assertFalse(self.starbase.is_upwell_structure)
+        self.assertTrue(self.jump_gate.is_upwell_structure)
+        self.assertFalse(self.skyhook.is_upwell_structure)
+
+
 class TestStructureFuel(NoSocketsTestCase):
     @classmethod
     def setUpClass(cls):