TPT-4285: Implement integration tests for ReservedIP for IPv4

.github/workflows/dependency-review.yml

@@ -13,6 +13,6 @@ jobs:
       - name: 'Checkout repository'
         uses: actions/checkout@v6
       - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v4
+        uses: actions/dependency-review-action@v5
         with:
           comment-summary-in-pr: on-failure

linode_api4/groups/networking.py

@@ -491,10 +491,10 @@ def ip_addresses_assign(self, assignments, region):
         :param assignments: Any number of assignments to make.  See
                             :any:`IPAddress.to` for details on how to construct
                             assignments.
-        :type assignments: dct
+        :type assignments: list
         """
 
-        for a in assignments["assignments"]:
+        for a in assignments:
             if not "address" in a or not "linode_id" in a:
                 raise ValueError("Invalid assignment: {}".format(a))
 

test/integration/conftest.py

@@ -25,6 +25,7 @@
     PlacementGroupPolicy,
     PlacementGroupType,
     PostgreSQLDatabase,
+    ReservedIPAddress,
 )
 from linode_api4.errors import ApiError
 from linode_api4.linode_client import LinodeClient, MonitorClient
@@ -727,3 +728,47 @@ def test_monitor_client(get_monitor_token_for_db_entities):
     )
 
     return client, entity_ids
+
+
+@pytest.fixture
+def create_reserved_ip(test_linode_client):
+    client = test_linode_client
+    region = get_region(client, {"Linodes", "Cloud Firewall"}, site_type="core")
+    reserved_ip = client.networking.reserved_ip_create(
+        region=region, tags=["test"]
+    )
+
+    yield reserved_ip
+
+    # Delete only if IP exists (some tests delete it earlier)
+    if client.networking.reserved_ips(
+        ReservedIPAddress.address == reserved_ip.address
+    ):
+        reserved_ip.delete()
+
+
+@pytest.fixture
+def create_reserved_ip_assigned(test_linode_client, create_linode):
+    client = test_linode_client
+    linode = create_linode
+    reserved_ip = client.networking.reserved_ip_create(
+        region=linode.region,
+        tags=["test", "assigned"],
+    )
+
+    client.networking.ip_addresses_assign(
+        assignments=[{"address": reserved_ip.address, "linode_id": linode.id}],
+        region=linode.region,
+    )
+
+    reserved_ip = test_linode_client.load(
+        ReservedIPAddress, reserved_ip.address
+    )
+
+    yield linode, reserved_ip
+
+    # Delete only if IP exists (some tests delete it earlier)
+    if client.networking.reserved_ips(
+        ReservedIPAddress.address == reserved_ip.address
+    ):
+        reserved_ip.delete()

test/integration/models/linode/interfaces/test_interfaces.py

@@ -1,13 +1,16 @@
 import copy
 import ipaddress
+from test.integration.helpers import get_test_label
 
 import pytest
 
 from linode_api4 import (
     ApiError,
     Instance,
+    InterfaceGeneration,
     LinodeInterface,
     LinodeInterfaceDefaultRouteOptions,
+    LinodeInterfaceOptions,
     LinodeInterfacePublicIPv4AddressOptions,
     LinodeInterfacePublicIPv4Options,
     LinodeInterfacePublicIPv6Options,
@@ -18,9 +21,28 @@
     LinodeInterfaceVPCIPv4Options,
     LinodeInterfaceVPCIPv4RangeOptions,
     LinodeInterfaceVPCOptions,
+    ReservedIPAddress,
 )
 
 
+def build_interface_public_ipv4(firewall, ip_address):
+    return LinodeInterfaceOptions(
+        firewall_id=firewall,
+        default_route=LinodeInterfaceDefaultRouteOptions(
+            ipv4=True,
+        ),
+        public=LinodeInterfacePublicOptions(
+            ipv4=LinodeInterfacePublicIPv4Options(
+                addresses=[
+                    LinodeInterfacePublicIPv4AddressOptions(
+                        address=ip_address, primary=True
+                    )
+                ],
+            ),
+        ),
+    )
+
+
 def test_linode_create_with_linode_interfaces(
     create_vpc_with_subnet,
     linode_with_linode_interfaces,
@@ -359,3 +381,59 @@ def test_linode_interface_firewalls(e2e_test_firewall, linode_interface_public):
     firewall = firewalls[0]
     assert firewall.id == e2e_test_firewall.id
     assert firewall.label == e2e_test_firewall.label
+
+
+@pytest.mark.parametrize(
+    "iface_type",
+    [InterfaceGeneration.LEGACY_CONFIG, InterfaceGeneration.LINODE],
+)
+def test_linode_interfaces_with_reserved_ips(
+    test_linode_client, e2e_test_firewall, create_reserved_ip, iface_type
+):
+    client = test_linode_client
+    reserved_ip = create_reserved_ip
+    label = get_test_label(length=8)
+
+    if iface_type == InterfaceGeneration.LEGACY_CONFIG:
+        linode, _ = client.linode.instance_create(
+            "g6-nanode-1",
+            reserved_ip.region,
+            image="linode/debian12",
+            label=label,
+            firewall=e2e_test_firewall,
+            interface_generation=iface_type,
+            ipv4=[reserved_ip.address],
+        )
+    else:
+        interface = build_interface_public_ipv4(
+            e2e_test_firewall.id, reserved_ip.address
+        )
+        linode, _ = client.linode.instance_create(
+            "g6-nanode-1",
+            reserved_ip.region,
+            image="linode/debian12",
+            label=label,
+            interface_generation=iface_type,
+            interfaces=[interface],
+        )
+
+    linode_ips = linode.ips.ipv4.public
+    assert len(linode_ips) == 1
+    assert linode_ips[0].address == reserved_ip.address
+    assert linode_ips[0].reserved == True
+    assert linode_ips[0].linode_id == linode.id
+    assert linode_ips[0].assigned_entity.id == linode.id
+    assert linode_ips[0].assigned_entity.type == "linode"
+    assert linode_ips[0].assigned_entity.label == linode.label
+    assert (
+        linode_ips[0].assigned_entity.url == f"/v4/linode/instances/{linode.id}"
+    )
+
+    linode.delete()
+    reserved_ips_list = client.networking.reserved_ips(
+        ReservedIPAddress.address == reserved_ip.address
+    )
+    assert len(reserved_ips_list) == 1
+    assert reserved_ips_list[0].reserved == True
+    assert reserved_ips_list[0].linode_id is None
+    assert reserved_ips_list[0].assigned_entity is None

test/integration/models/linode/test_linode.py

@@ -19,6 +19,7 @@
     Instance,
     InterfaceGeneration,
     LinodeInterface,
+    ReservedIPAddress,
     Type,
 )
 from linode_api4.objects.linode import InstanceDiskEncryptionType, MigrationType
@@ -1156,3 +1157,42 @@ def test_update_linode_maintenance_policy(create_linode, test_linode_client):
     linode.invalidate()
     assert result
     assert linode.maintenance_policy_id == non_default_policy.slug
+
+
+def test_update_linode_with_reserved_ip_in_address(
+    test_linode_client, e2e_test_firewall, create_reserved_ip
+):
+    label = get_test_label(length=8)
+    client = test_linode_client
+    reserved_ip = create_reserved_ip
+
+    linode, _ = client.linode.instance_create(
+        "g6-nanode-1",
+        reserved_ip.region,
+        image="linode/debian12",
+        label=label,
+        firewall=e2e_test_firewall,
+    )
+
+    linode_ips = linode.ips.ipv4.public
+    assert len(linode_ips) == 1
+    assert linode_ips[0].address != reserved_ip.address
+
+    linode.ip_allocate(True, reserved_ip.address)
+    delattr(linode, "_ips")
+    linode_ips = linode.ips.ipv4.public
+    assert len(linode_ips) == 2
+    assert reserved_ip.address in [ip.address for ip in linode_ips]
+
+    reserved_ip = client.networking.reserved_ips(
+        ReservedIPAddress.address == reserved_ip.address
+    )[0]
+    assert reserved_ip.linode_id == linode.id
+    assert reserved_ip.assigned_entity.id == linode.id
+    assert reserved_ip.assigned_entity.type == "linode"
+    assert reserved_ip.assigned_entity.label == linode.label
+    assert (
+        reserved_ip.assigned_entity.url == f"/v4/linode/instances/{linode.id}"
+    )
+
+    linode.delete()