TPT-4285: Implement integration tests for ReservedIP for IPv4 (#688)

* build(deps): bump actions/dependency-review-action from 4 to 5 (#695)

Bumps [actions/dependency-review-action](https://github.com/actions/dependency-review-action) from 4 to 5.
- [Release notes](https://github.com/actions/dependency-review-action/releases)
- [Commits](actions/dependency-review-action@v4...v5)

---
updated-dependencies:
- dependency-name: actions/dependency-review-action
  dependency-version: '5'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

* Change assignments type from dict to list (#687)

* TPT-4278: python-sdk: Implement support for Reserved IP for IPv4 (#672)

* TPT-4278 python-sdk: Implement support for Reserved IP for IPv4

# Conflicts:
#	conftest.py
#	linode_api4/groups/networking.py
#	linode_api4/groups/tag.py
#	linode_api4/objects/networking.py
#	test/unit/groups/networking_test.py

* TPT-4278: python-sdk: Implement support for Reserved IP for IPv4

* Create int tests for Reserved IPs networking endpoints

* Create int tests for Reserved IPs: types, allocate

* Create int tests for Reserved IPs: ephemeral

* Create int tests for Reserved IPs: linode instances

* Move fixtures for reserved IPs into conftest

* Create int tests for Reserved IPs: linode interfaces

* Create int tests for Reserved IPs: nodebalancers

* Create int tests for Reserved IPs: tags

* Refactor

* Update tests after API changes on DevCloud

* Create int tests for Reserved IPs: tags #2

* Linter fix

* Linter fix

* Remove pytest.ini

* Remove unused assertions after API Team clarifications

* Use reservedIP's region for NB

* Refactor

* Address Copilot remarks

* Linter fix

* Revert capabilities' changes in get_regions

* Linter fixes

* Address Copilot remarks

* Address PR remarks

* Use try-finally to delete resources in case of fail

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Michal Wojcik <32574975+mgwoj@users.noreply.github.com>
Co-authored-by: Michal Wojcik <miwojci@akamai.com>

Author: 3 people

.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

@@ -16,7 +16,9 @@
 from requests.exceptions import ConnectionError, RequestException
 
 from linode_api4 import (
+    Instance,
     InterfaceGeneration,
+    IPAddress,
     LinodeInterfaceDefaultRouteOptions,
     LinodeInterfaceOptions,
     LinodeInterfacePublicOptions,
@@ -25,6 +27,7 @@
     PlacementGroupPolicy,
     PlacementGroupType,
     PostgreSQLDatabase,
+    ReservedIPAddress,
 )
 from linode_api4.errors import ApiError
 from linode_api4.linode_client import LinodeClient, MonitorClient
@@ -727,3 +730,48 @@ 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,
+    )
+
+    linode = client.load(Instance, linode.id)
+    reserved_ip = test_linode_client.load(
+        ReservedIPAddress, reserved_ip.address
+    )
+
+    yield linode, reserved_ip
+
+    # Delete assigned IP address completely
+    if address := client.networking.ips(
+        IPAddress.address == reserved_ip.address
+    ):
+        address[0].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,54 @@
     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 create_linode_with_legacy_config(client, ip_address, label, firewall):
+    linode, _ = client.linode.instance_create(
+        "g6-nanode-1",
+        ip_address.region,
+        image="linode/debian12",
+        label=label,
+        firewall=firewall,
+        interface_generation=InterfaceGeneration.LEGACY_CONFIG,
+        ipv4=[ip_address.address],
+    )
+    return linode
+
+
+def create_linode_with_standard_interfaces(client, ip_address, label, firewall):
+    interface = build_interface_public_ipv4(firewall.id, ip_address.address)
+    linode, _ = client.linode.instance_create(
+        "g6-nanode-1",
+        ip_address.region,
+        image="linode/debian12",
+        label=label,
+        interface_generation=InterfaceGeneration.LINODE,
+        interfaces=[interface],
+    )
+    return linode
+
+
 def test_linode_create_with_linode_interfaces(
     create_vpc_with_subnet,
     linode_with_linode_interfaces,
@@ -359,3 +407,42 @@ 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(
+    "create_linode_fn",
+    [create_linode_with_legacy_config, create_linode_with_standard_interfaces],
+    ids=["legacy_config", "standard_interfaces"],
+)
+def test_linode_interfaces_with_reserved_ips(
+    test_linode_client, e2e_test_firewall, create_reserved_ip, create_linode_fn
+):
+    client = test_linode_client
+    reserved_ip = create_reserved_ip
+    label = get_test_label(length=8)
+
+    linode = create_linode_fn(client, reserved_ip, label, e2e_test_firewall)
+
+    try:
+        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}"
+        )
+    finally:
+        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()