ipaddons 0.3.2__tar.gz → 0.4.0__tar.gz

{ipaddons-0.3.2 → ipaddons-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipaddons
-Version: 0.3.2
+Version: 0.4.0
 Summary: Additional tools for the ipaddress standard library module
 Project-URL: documentation, https://ipaddons.readthedocs.io/
 Project-URL: homepage, https://gitlab.com/sebastianw/ipaddons/

{ipaddons-0.3.2 → ipaddons-0.4.0}/pyproject.toml

@@ -31,6 +31,7 @@ urls.repository = "https://gitlab.com/sebastianw/ipaddons/"
 
 [dependency-groups]
 dev = [
+    "coverage>=7.11.3",
     "mypy>=1.18.2",
     "pytest>=8.4.2",
 ]
@@ -68,7 +69,6 @@ lint.extend-select = [
     "BLE",    # flake8-blind-except Don't catch base exceptions
     "C4",     # flake8-comprehensions Unneccessary comprehension code
     "D",      # pydocstyle
-    "DOC",    # pydoclint
     "DTZ",    # flake8-datetimez Datetime mistakes
     "E",      # pycodestyle errors
     "EM",     # flake8-errmsg Bad message strings in exception handling
@@ -103,6 +103,8 @@ lint.extend-select = [
 ]
 lint.ignore = [
     "D100",   # Public module documentation missing
+    "D203",   # Blank line before doc-string
+    "D212",   # new-line after doc-string begins
     "E501",   # Line too long
     "G004",   # Logging statement uses f-string
     "S101",   # Use of assert detected
@@ -110,6 +112,12 @@ lint.ignore = [
     "S603",   # Subprocess call
     "SIM105", # Use contextlib.suppress({exception}) instead of try-except-pass -> slower code
 ]
+lint.per-file-ignores."tests/**/*.py" = [
+    "D",
+    "DOC",
+    "I002",
+    "INP",
+]
 lint.flake8-comprehensions.allow-dict-calls-with-keyword-arguments = true
 lint.flake8-import-conventions.aliases.datetime = "dt"
 lint.flake8-import-conventions.banned-from = [ "datetime" ]
@@ -117,13 +125,6 @@ lint.isort.required-imports = [ "from __future__ import annotations" ]
 # Enable "FA" rule fixes
 lint.future-annotations = true
 
-per-file-ignores."tests/**/*.py" = [
-    "D",
-    "DOC",
-    "I002",
-    "INP",
-]
-
 [tool.pyproject-fmt]
 max_supported_python = "3.14"
 column_width = 120

{ipaddons-0.3.2 → ipaddons-0.4.0}/src/ipaddons/__init__.py

@@ -1,6 +1,8 @@
+"""Various addons for the :doc:`ipaddress <python:library/ipaddress>` standard library module."""
+
 from __future__ import annotations
 
-from ._version import __version__, __version_tuple__
+from ._version import __version__, __version_tuple__  # noqa: F401
 from .tools import IPv4Allocation, IPv6Allocation, ip_allocation
 
 __all__ = ["IPv4Allocation", "IPv6Allocation", "ip_allocation"]

{ipaddons-0.3.2 → ipaddons-0.4.0}/src/ipaddons/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.4.0'
+__version_tuple__ = version_tuple = (0, 4, 0)
 
 __commit_id__ = commit_id = None

{ipaddons-0.3.2 → ipaddons-0.4.0}/src/ipaddons/tools.py

@@ -18,11 +18,14 @@ if TYPE_CHECKING:
 
 
 class IPAllocationError(Exception):
-    pass
+    """General Error in an IPAllocation object."""
 
 
-def ip_allocation(supernet: UnSpecNet, used_networks: UnspecNetSeq | None = None) -> IPv4Allocation | IPv6Allocation:
-    """Create an IP allocation.
+def ip_allocation(
+    supernet: UnSpecNet, used_networks: UnspecNetSeq | None = None, ignore_invalid_subnets: bool = True
+) -> IPv4Allocation | IPv6Allocation:
+    """
+    Create an IP allocation.
 
     Creates and returns an IP allocation object.
 
@@ -32,16 +35,18 @@ def ip_allocation(supernet: UnSpecNet, used_networks: UnspecNetSeq | None = None
         either as a string or an :doc:`ipaddress <python:library/ipaddress>` network object.
     :return: An :class:`IPv4Allocation` or :class:`IPv6Allocation` instance, depending on the passed
         :py:attr:`supernet` argument. Same principle as :py:func:`python:ipaddress.ip_network`.
+    :param ignore_invalid_subnets: If set to False, used subnets that do not overlap with the supernet will raise
+        a ValueError.
     """
     if used_networks is None:
         used_networks = []
     supernet = ipaddress.ip_network(supernet) if isinstance(supernet, str) else supernet
     if supernet.version == 4:
         assert isinstance(supernet, ipaddress.IPv4Network)
-        return IPv4Allocation(supernet, used_networks)
+        return IPv4Allocation(supernet, used_networks, ignore_invalid_subnets)
     if supernet.version == 6:
         assert isinstance(supernet, ipaddress.IPv6Network)
-        return IPv6Allocation(supernet, used_networks)
+        return IPv6Allocation(supernet, used_networks, ignore_invalid_subnets)
     msg = f"IP Version of Supernet is unknown: {supernet.version}"
     raise ValueError(msg)
 
@@ -51,7 +56,8 @@ def _ceildiv(a: int, b: int) -> int:
 
 
 def range_overlap(a: NetworkRange, b: NetworkRange) -> bool:
-    """Network Range Overlap Check.
+    """
+    Network Range Overlap Check.
 
     :param a: a network range
     :param b:  a network range
@@ -61,7 +67,8 @@ def range_overlap(a: NetworkRange, b: NetworkRange) -> bool:
 
 
 def range_overlaps(a: NetworkRange, b: list[NetworkRange]) -> NetworkRange | None:
-    """Overlap between a network range and a list of other network ranges.
+    """
+    Overlap between a network range and a list of other network ranges.
 
     :param a: Network range to check against.
     :param b: List of network ranges that could overlap.
@@ -74,7 +81,8 @@ def range_overlaps(a: NetworkRange, b: list[NetworkRange]) -> NetworkRange | Non
 
 
 def netrange(network: IPNetwork) -> NetworkRange:
-    """Create a network range from an :doc:python:`ipaddress <library/ipaddress>` object.
+    """
+    Create a network range from an :doc:python:`ipaddress <library/ipaddress>` object.
 
     A network range is the integer presentation of the first and last IP address of the network as a tuple.
     :param network: An :doc:`ipaddress <python:library/ipaddress>` network object.
@@ -84,30 +92,45 @@ def netrange(network: IPNetwork) -> NetworkRange:
 
 
 def free_ranges(superrange: NetworkRange, used_ranges: list[NetworkRange]) -> Generator[NetworkRange, None, None]:
-    """Get free ranges from a supernet with provided used ranges.
+    """
+    Get free ranges from a supernet with provided used ranges.
 
     :param superrange: Covering range from where free subranges should be returned.
     :param used_ranges: List of used network ranges.
     :return: An interator for free ranges.
     """
-    used_ranges = sorted(used_ranges)
-    for range in used_ranges:
-        if superrange[0] >= superrange[1]:
-            # Last range either ends at or shoots over the supernet range
+    remaining_superrange = superrange
+    # Make values unique and sort them. This is crucial when interating over them.
+    used_ranges = list(dict.fromkeys(used_ranges))
+    used_ranges = sorted(used_ranges, key=lambda x: (x[0], -x[1]))
+    for used_range in used_ranges:
+        if not range_overlap(superrange, used_range):
+            msg = f"{used_range} does not overlap with {remaining_superrange}"
+            raise ValueError(msg)
+        if used_range[0] <= remaining_superrange[0] and used_range[1] >= remaining_superrange[1]:
+            # Subrange is as large or larger than the remaining superrange so we have no more free ranges.
             return
-        if superrange[0] == range[0]:
-            # used range is at the beginning, shrink superrange
-            superrange = range[1] + 1, superrange[1]
+        if used_range[1] <= remaining_superrange[0] or used_range[0] >= remaining_superrange[1]:
+            # Subrange ends below or begins above remaining superrange, ignore.
             continue
-        free_range = superrange[0], range[0] - 1
-        superrange = range[1] + 1, superrange[1]
+        if remaining_superrange[0] == used_range[0]:
+            # Used range is at the beginning of remaining superrange, shrink it.
+            remaining_superrange = used_range[1] + 1, remaining_superrange[1]
+            continue
+        # There is a free range between the beginning of the remaining superrange and the current used range.
+        free_range = remaining_superrange[0], used_range[0] - 1
+        # Adjust remaining free superrange to begin after current used range.
+        remaining_superrange = used_range[1] + 1, remaining_superrange[1]
+        assert free_range[0] < free_range[1]
         yield free_range
     # The rest of the superrange is free when there are no more used ranges left
-    yield superrange
+    assert remaining_superrange[0] < remaining_superrange[1]
+    yield remaining_superrange
 
 
 def merge_ranges(ranges: list[NetworkRange]) -> list[NetworkRange]:
-    """Merge network ranges that overlap.
+    """
+    Merge network ranges that overlap.
 
     :param ranges: A list of network ranges.
     :return: A list of network ranges with overlapping ranges merged into one.
@@ -132,7 +155,8 @@ def merge_ranges(ranges: list[NetworkRange]) -> list[NetworkRange]:
 def net_size_iterator(
     supernet: IPNetwork, cidr: int, used_ranges: list[NetworkRange] | None = None
 ) -> Generator[NetworkRange, None, None]:
-    """Iterate over an ipaddr network object and return subnet network ranges of the specified cidr size.
+    """
+    Iterate over an ipaddr network object and return subnet network ranges of the specified cidr size.
 
     :param supernet: An ipaddr network object.
     :param cidr: CIDR size of the subnets.
@@ -154,7 +178,8 @@ def net_size_iterator(
 
 
 class _BaseIPAllocation(ABC, Generic[_N]):
-    """An IP allocation.
+    """
+    An IP allocation.
 
     The object represents a supernet (the allocation) with an optional list of used (assigned) subnets. You can also
     request an iterator for free subnets of a specific size.
@@ -163,14 +188,15 @@ class _BaseIPAllocation(ABC, Generic[_N]):
         network object.
     :param used_subnets: A list of subnets of the :py:attr:`supernet` that are already in use in this allocation,
         either as string or an :doc:`ipaddress <python:library/ipaddress>` network object.
+    :param ignore_invalid_subnets: If set to False, used subnets that do not overlap with the supernet will raise
+        a ValueError.
     """
 
-    _version: int | None = None
-    _max_prefixlen: int = 0
-
-    def __init__(self, supernet: UnSpecNet, used_subnets: UnspecNetSeq | None = None):
+    def __init__(
+        self, supernet: UnSpecNet, used_subnets: UnspecNetSeq | None = None, ignore_invalid_subnets: bool = True
+    ):
         self.lock = RLock()
-        self.merge_ranges = merge_ranges
+        self.ignore_invalid_subnets = ignore_invalid_subnets
         self.supernet: _N = self._normalize_network(supernet)
         if used_subnets is None:
             used_subnets = []
@@ -186,6 +212,16 @@ class _BaseIPAllocation(ABC, Generic[_N]):
     def _network_class(self) -> type[_N]:
         raise NotImplementedError
 
+    @property
+    @abstractmethod
+    def _version(self) -> int:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def _max_prefixlen(self) -> int:
+        raise NotImplementedError
+
     def _normalize_network(self, _network: UnSpecNet) -> _N:
         network = ipaddress.ip_network(_network) if isinstance(_network, str) else _network
         if not self._version_compatible(network):
@@ -199,9 +235,18 @@ class _BaseIPAllocation(ABC, Generic[_N]):
     def _version_compatible(self, network: IPNetwork) -> TypeGuard[_N]:
         return self._version == network.version
 
+    def _check_subnet(self, subnet: _N) -> bool:
+        if not range_overlap(netrange(self.supernet), netrange(subnet)):
+            if not self.ignore_invalid_subnets:
+                msg = f"Subnet {subnet} does not overlap with {self.supernet}"
+                raise ValueError(msg)
+            return False
+        return True
+
     @property
-    def used_subnets(self) -> Generator[IPNetwork, None, None]:
-        """Used subnets in this allocation.
+    def used_subnets(self) -> Generator[_N, None, None]:
+        """
+        Used subnets in this allocation.
 
         :getter: An iterator for used networks in this allocation.
         :setter: Sets the list of used networks.
@@ -212,17 +257,23 @@ class _BaseIPAllocation(ABC, Generic[_N]):
     @used_subnets.setter
     def used_subnets(self, subnets: UnspecNetSeq) -> None:
         with self.lock:
-            self._used_subnets = self._normalize_networks(subnets)
-            self._update_used_subnet_ranges()
+            self._used_subnets = []
+            self.add_used_subnets(subnets)
 
     def add_used_subnets(self, subnets: UnspecNetSeq) -> None:
-        """Add additional subnets to the list of used networks in this allocation.
+        """
+        Add additional subnets to the list of used networks in this allocation.
 
         :param subnets: A list of networks that are added to the in-use networks of this allocation, either as a string
             or :doc:`ipaddress <python:library/ipaddress>` network objects.
         """
         with self.lock:
-            self._used_subnets += self._normalize_networks(subnets)
+            for _subnet in subnets:
+                subnet = self._normalize_network(_subnet)
+                if not self._check_subnet(subnet):
+                    continue
+                self._used_subnets.append(subnet)
+                self._used_subnets.sort()
             self._update_used_subnet_ranges()
 
     def _update_used_subnet_ranges(self, merge: bool = True) -> None:
@@ -233,14 +284,15 @@ class _BaseIPAllocation(ABC, Generic[_N]):
             self._used_network_ranges = ranges
 
     def get_free_subnets(self, prefixlen: int) -> Generator[_N, None, None]:
-        """List free subnets of a specific size.
+        """
+        List free subnets of a specific size.
 
         :param prefixlen: Size of the free subnets returned in CIDR notation.
         :return: An iterator for free subnets of :py:attr:`prefixlen` size.
         """
         for n in net_size_iterator(self.supernet, prefixlen, self._used_network_ranges):
             if range_overlaps(n, self._used_network_ranges):
-                msg = "This should never happen!"
+                msg = "This should never happen! A free range cannot overlap with a used range."
                 raise IPAllocationError(msg)
             yield self._network_class((n[0], prefixlen))
 

ipaddons-0.4.0/tests/test_ip_allocation.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+import ipaddress
+from typing import Any, NamedTuple
+
+import pytest
+
+from ipaddons import IPv4Allocation, IPv6Allocation, ip_allocation, tools
+
+
+class Net(NamedTuple):
+    str: str
+    ipa: ipaddress.IPv4Network | ipaddress.IPv6Network
+    range: tuple[int, int]
+
+
+def make_nets(input_str: str | list[str]) -> Net | list[Net]:
+    if isinstance(input_str, str):
+        single = True
+        input_str = [input_str]
+    else:
+        single = False
+
+    ret = []
+    for input_net in input_str:
+        net = ipaddress.ip_network(input_net, strict=True)
+        ret.append(Net(str(net), net, (int(net[0]), int(net[-1]))))
+
+    if single:
+        return ret[0]
+    return ret
+
+
+def net_attr(nets: Net | list[Net], attribute: str) -> Any | list[Any]:
+    if isinstance(nets, Net):
+        return getattr(nets, attribute)
+    return [getattr(n, attribute) for n in nets]
+
+
+v4_supernet = make_nets("10.0.0.0/8")
+
+v4_subnets = make_nets(
+    [
+        "10.0.0.0/16",
+        "10.1.1.0/24",
+        "10.1.1.16/29",
+        "10.1.2.0/25",
+        "10.1.2.0/24",
+        "10.1.3.0/25",
+        "10.1.3.64/26",
+        "10.1.3.128/26",
+    ]
+)
+
+v6_supernet = make_nets("fc00::/32")
+
+v6_subnets = make_nets(
+    [
+        "fc00::/48",
+        "fc00:0:a::/56",
+        "fc00:0:b::/56",
+        "fc00:0:b:100::/56",
+        "fc00:0:b:200::/64",
+        "fc00:0:b:100::/56",
+    ]
+)
+
+
+mergeable_subnets = [
+    [
+        (int(ipaddress.IPv4Network(n)[0]), int(ipaddress.IPv4Network(n)[-1]))
+        for n in ["192.168.0.0/24", "192.168.0.0/25", "192.168.0.128/25", "192.168.0.64/29"]
+    ],
+    [
+        (int(ipaddress.IPv6Network(n)[0]), int(ipaddress.IPv6Network(n)[-1]))
+        for n in ["fc01::/32", "fc01::/64", "fc01:0:ffff::/48", "fc01:0:cafe::/64"]
+    ],
+]
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "allocation_class", "network_class"),
+    [
+        (net_attr(v4_supernet, "ipa"), net_attr(v4_subnets, "ipa"), IPv4Allocation, ipaddress.IPv4Network),
+        (net_attr(v4_supernet, "str"), net_attr(v4_subnets, "str"), IPv4Allocation, ipaddress.IPv4Network),
+        (net_attr(v6_supernet, "ipa"), net_attr(v6_subnets, "ipa"), IPv6Allocation, ipaddress.IPv6Network),
+        (net_attr(v6_supernet, "str"), net_attr(v6_subnets, "str"), IPv6Allocation, ipaddress.IPv6Network),
+        (net_attr(v4_supernet, "ipa"), net_attr(v4_subnets[:1], "ipa"), IPv4Allocation, ipaddress.IPv4Network),
+        (net_attr(v6_supernet, "ipa"), net_attr(v6_subnets[:1], "ipa"), IPv6Allocation, ipaddress.IPv6Network),
+        (net_attr(v4_supernet, "ipa"), [], IPv4Allocation, ipaddress.IPv4Network),
+        (net_attr(v6_supernet, "ipa"), [], IPv6Allocation, ipaddress.IPv6Network),
+    ],
+)
+def test_allocation_classes(supernet, subnets, allocation_class, network_class):
+    a = ip_allocation(supernet, used_networks=subnets)
+    assert isinstance(a, allocation_class)
+    assert all(isinstance(n, network_class) for n in a.used_subnets)
+
+
+def test_base_abstract_methods():
+    class TestAllocation(tools._BaseIPAllocation):
+        pass
+
+    with pytest.raises(
+        TypeError,
+        match=r"Can't instantiate abstract class TestAllocation without an implementation for abstract methods '_max_prefixlen', '_network_class', '_version'",
+    ):
+        TestAllocation()
+
+
+@pytest.mark.parametrize(
+    ("supernet", "used_nets", "cidr", "first_free", "last_free", "num_subnets"),
+    [
+        ("10.0.0.0/8", ["10.0.0.0/16", "10.1.0.0/24"], 16, "10.2.0.0/16", "10.255.0.0/16", 254),
+        ("2001:db8::/32", ["2001:db8::/48", "2001:db8:1::/120"], 48, "2001:db8:2::/48", "2001:db8:ffff::/48", 65534),
+        ("10.0.0.0/8", ["10.5.0.0/16", "10.193.0.0/24"], 16, "10.0.0.0/16", "10.255.0.0/16", 254),
+        ("2001:db8::/32", ["2001:db8:4::/48", "2001:db8:fca::/120"], 48, "2001:db8::/48", "2001:db8:ffff::/48", 65534),
+        ("10.0.0.0/8", ["10.5.0.0/16", "10.255.0.0/24"], 16, "10.0.0.0/16", "10.254.0.0/16", 254),
+        ("2001:db8::/32", ["2001:db8:4::/48", "2001:db8:ffff::/120"], 48, "2001:db8::/48", "2001:db8:fffe::/48", 65534),
+    ],
+)
+def test_free_networks(supernet, used_nets, cidr, first_free, last_free, num_subnets):
+    allocation = ip_allocation(supernet, used_nets)
+    free_nets = list(allocation.get_free_subnets(cidr))
+    assert first_free == str(free_nets[0])
+    assert last_free == str(free_nets[-1])
+    assert num_subnets == len(free_nets)
+
+
+@pytest.mark.parametrize(
+    ("subnet", "subnet_range"),
+    zip(
+        net_attr(v4_subnets, "ipa") + net_attr(v6_subnets, "ipa"),
+        net_attr(v4_subnets, "range") + net_attr(v6_subnets, "range"),
+        strict=True,
+    ),
+)
+def test_netrange(subnet, subnet_range):
+    assert tools.netrange(subnet) == subnet_range
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "subnet_ranges"),
+    [
+        (net_attr(v4_supernet, "ipa"), net_attr(v4_subnets, "ipa"), net_attr(v4_subnets, "range")),
+        (net_attr(v6_supernet, "ipa"), net_attr(v6_subnets, "ipa"), net_attr(v6_subnets, "range")),
+    ],
+)
+def test_allocation_ranges(supernet, subnets, subnet_ranges):
+    a = ip_allocation(supernet, used_networks=subnets, ignore_invalid_subnets=False)
+    a._update_used_subnet_ranges(merge=False)
+    assert sorted(a._used_network_ranges) == sorted(subnet_ranges)
+
+
+@pytest.mark.parametrize(
+    ("supernet_range", "subnet_ranges"),
+    [
+        (net_attr(v4_supernet, "range"), net_attr(v4_subnets, "range")),
+        (net_attr(v6_supernet, "range"), net_attr(v6_subnets, "range")),
+    ],
+)
+def test_range_overlaps(supernet_range, subnet_ranges):
+    assert tools.range_overlaps(supernet_range, subnet_ranges) == subnet_ranges[0]
+
+
+@pytest.mark.parametrize(
+    ("supernet_range", "subnet_ranges"),
+    [
+        (net_attr(v4_supernet, "range"), net_attr(v6_subnets, "range")),
+        (net_attr(v6_supernet, "range"), net_attr(v4_subnets, "range")),
+    ],
+)
+def test_range_no_overlaps(supernet_range, subnet_ranges):
+    assert tools.range_overlaps(supernet_range, subnet_ranges) is None
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets"),
+    [
+        (net_attr(v4_supernet, "ipa"), net_attr(v4_subnets, "ipa")),
+        (net_attr(v6_supernet, "ipa"), net_attr(v6_subnets, "ipa")),
+    ],
+)
+def test_add_used_subnets(supernet, subnets):
+    a = ip_allocation(supernet, ignore_invalid_subnets=False)
+    a.add_used_subnets([subnets[0]])
+    a.add_used_subnets(subnets[1:])
+    assert sorted(a.used_subnets) == sorted(subnets)
+
+
+@pytest.mark.parametrize(
+    "subnets",
+    mergeable_subnets,
+)
+def test_merge(subnets):
+    covering_prefix = subnets[0]
+    assert tools.merge_ranges(subnets) == [covering_prefix]
+
+
+@pytest.mark.parametrize(
+    "subnets",
+    mergeable_subnets,
+)
+def test_merge_one(subnets):
+    assert subnets[:1] == tools.merge_ranges(subnets[:1])
+
+
+def test_merge_empty():
+    assert tools.merge_ranges([]) == []
+
+
+@pytest.mark.parametrize(
+    ("supernet", "used_nets", "cidr", "first_free"),
+    [
+        ("2001:db8::/32", ["2001:db8::/48", "2001:db8:1::/120"], 64, "2001:db8:1:1::/64"),
+        ("10.0.0.0/8", ["10.0.0.0/16", "10.1.0.0/24"], 16, "10.2.0.0/16"),
+    ],
+)
+def test_netsize_iterator(supernet, used_nets, cidr, first_free):
+    supernet = ipaddress.ip_network(supernet)
+    used_nets = [(int(ipaddress.ip_network(n)[0]), int(ipaddress.ip_network(n)[-1])) for n in used_nets]
+    i = tools.net_size_iterator(supernet, cidr, used_nets)
+    first_ip, last_ip = next(i)
+    net = next(ipaddress.summarize_address_range(ipaddress.ip_address(first_ip), ipaddress.ip_address(last_ip)))
+    assert first_free == str(net)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "used_nets", "cidr", "last_free"),
+    [
+        ("10.0.0.0/24", ["10.0.0.0/29", "10.0.0.96/30"], 30, "10.0.0.252/30"),
+        ("2001:db8::/32", ["2001:db8::/48", "2001:db8:1::/120"], 48, "2001:db8:ffff::/48"),
+    ],
+)
+def test_netsize_iterator_last(supernet, used_nets, cidr, last_free):
+    supernet = ipaddress.ip_network(supernet)
+    used_nets = [(int(ipaddress.ip_network(n)[0]), int(ipaddress.ip_network(n)[-1])) for n in used_nets]
+    i = tools.net_size_iterator(supernet, cidr, used_nets)
+    first_ip, last_ip = list(i)[-1]
+    net = next(ipaddress.summarize_address_range(ipaddress.ip_address(first_ip), ipaddress.ip_address(last_ip)))
+    assert last_free == str(net)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "used_networks"),
+    [
+        ("10.0.0.0/24", ["192.168.1.0/30", "10.0.0.0/25"], ["10.0.0.0/25"]),
+        ("fc00::/32", ["fd00::/64", "fc00::/64"], ["fc00::/64"]),
+    ],
+)
+def test_outside_networks(supernet, subnets, used_networks):
+    allocation = ip_allocation(supernet, subnets)
+    assert sorted([str(s) for s in allocation.used_subnets]) == sorted(used_networks)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "used_networks"),
+    [
+        ("10.0.0.0/24", ["192.168.1.0/30", "10.0.0.0/25"], ["10.0.0.0/25"]),
+        ("fc00::/32", ["fd00::/64", "fc00::/64"], ["fc00::/64"]),
+    ],
+)
+def test_outside_networks_added(supernet, subnets, used_networks):
+    allocation = ip_allocation(supernet)
+    allocation.add_used_subnets(subnets)
+    assert sorted([str(s) for s in allocation.used_subnets]) == sorted(used_networks)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets"),
+    [
+        ("10.0.0.0/24", ["192.168.1.0/30", "10.0.0.0/25"]),
+        ("fc00::/32", ["fd00::/64", "fc00::/64"]),
+    ],
+)
+def test_outside_networks_exception(supernet, subnets):
+    with pytest.raises(ValueError, match=r"Subnet .*? does not overlap with .*?"):
+        _ = ip_allocation(supernet, subnets, ignore_invalid_subnets=False)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets"),
+    [
+        ("10.0.0.0/24", ["192.168.1.0/30", "10.0.0.0/25"]),
+        ("fc00::/32", ["fd00::/64", "fc00::/64"]),
+    ],
+)
+def test_outside_networks_added_exception(supernet, subnets):
+    allocation = ip_allocation(supernet, ignore_invalid_subnets=False)
+    with pytest.raises(ValueError, match=r" does not overlap with "):
+        allocation.add_used_subnets(subnets)
+
+
+@pytest.mark.parametrize(
+    ("supernet_range", "subnet_ranges"),
+    [
+        (net_attr(v4_supernet, "range"), net_attr(v6_subnets, "range")),
+        (net_attr(v6_supernet, "range"), net_attr(v4_subnets, "range")),
+    ],
+)
+def test_free_ranges_mismatch(supernet_range, subnet_ranges):
+    range_iterator = tools.free_ranges(supernet_range, subnet_ranges)
+    with pytest.raises(ValueError, match=r" does not overlap with "):
+        next(range_iterator)
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "free_size"),
+    [
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/8"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/16"]), 64),
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/17", "10.0.128.0/17"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/33", "fc00:0:8000::/33"]), 64),
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/17", "10.0.0.0/8"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/33", "fc00::/16"]), 64),
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/17", "10.0.0.0/17", "10.0.128.0/17"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/33", "fc00::/33", "fc00:0:8000::/33"]), 64),
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/17", "10.0.128.0/17", "10.0.128.0/17"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/33", "fc00:0:8000::/33", "fc00:0:8000::/33"]), 64),
+        (make_nets("10.0.0.0/16"), make_nets(["10.0.0.0/17", "10.0.0.0/24", "10.0.128.0/17"]), 29),
+        (make_nets("fc00::/32"), make_nets(["fc00::/33", "fc00::/64", "fc00:0:8000::/33"]), 64),
+    ],
+)
+class TestNoFreeRanges:
+    def test_no_free_ranges(self, supernet, subnets, free_size):
+        range_iterator = tools.free_ranges(supernet.range, net_attr(subnets, "range"))
+        with pytest.raises(StopIteration):
+            next(range_iterator)
+
+    def test_no_free_subnets(self, supernet, subnets, free_size):
+        allocation = ip_allocation(supernet.ipa, net_attr(subnets, "ipa"))
+        with pytest.raises(StopIteration):
+            next(allocation.get_free_subnets(free_size))
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets"),
+    [
+        (net_attr(v4_supernet, "str"), net_attr(v6_subnets, "str")),
+        (net_attr(v6_supernet, "str"), net_attr(v4_subnets, "str")),
+    ],
+)
+def test_version_mismatch(supernet, subnets):
+    with pytest.raises(ValueError, match=r"IP Version missmatch"):
+        ip_allocation(supernet, subnets)
+
+    a = ip_allocation(supernet)
+    with pytest.raises(ValueError, match=r"IP Version missmatch"):
+        a._normalize_networks(subnets)
+
+
+@pytest.mark.parametrize(
+    ("networks", "network_class"),
+    [
+        ([net_attr(v4_supernet, "str"), *net_attr(v4_subnets, "str")], ipaddress.IPv4Network),
+        ([net_attr(v6_supernet, "str"), *net_attr(v6_subnets, "str")], ipaddress.IPv6Network),
+    ],
+)
+def test_network_normalize(networks, network_class):
+    a = ip_allocation(networks[0])
+    assert all(isinstance(n, network_class) for n in a._normalize_networks(networks))
+    assert all(str(n) == networks[i] for i, n in enumerate(a._normalize_networks(networks)))
+
+
+@pytest.mark.parametrize(
+    ("supernet", "subnets", "new_subnets"),
+    [
+        ("10.0.0.0/8", ["10.0.0.0/24", "10.1.0.0/24"], ["10.255.0.0/16", "10.254.30.0/24"]),
+    ],
+)
+def test_used_subnet_setter(supernet, subnets, new_subnets):
+    allocation = ip_allocation(supernet, subnets)
+    allocation.used_subnets = new_subnets
+    assert sorted([str(n) for n in allocation.used_subnets]) == sorted(new_subnets)

ipaddons-0.3.2/tests/test_ip_allocation.py

@@ -1,142 +0,0 @@
-from __future__ import annotations
-
-import ipaddress
-
-import pytest
-
-from ipaddons import IPv4Allocation, IPv6Allocation, ip_allocation, tools
-
-v4_supernet_string = "10.0.0.0/8"
-v4_supernet = ipaddress.IPv4Network(v4_supernet_string)
-
-v4_subnet_strings = [
-    "10.0.0.0/16",
-    "10.1.1.0/24",
-    "10.1.1.16/29",
-    "10.1.2.0/25",
-    "10.1.2.0/24",
-    "10.1.3.0/25",
-    "10.1.3.64/26",
-    "10.1.3.128/26",
-]
-v4_subnets = [ipaddress.IPv4Network(n) for n in v4_subnet_strings]
-v4_subnet_ranges = [(int(n[0]), int(n[-1])) for n in v4_subnets]
-
-v6_supernet_string = "fc00::/32"
-v6_supernet = ipaddress.IPv6Network(v6_supernet_string)
-
-
-v6_subnet_strings = [
-    "fc00::/48",
-    "fc00:a::/56",
-    "fc00:b::/56",
-    "fc00:b:0:100::/56",
-    "fc00:b:0:200::/64",
-    "fc00:b:0:100::/56",
-    "fc00:c::/44",
-]
-v6_subnets = [ipaddress.IPv6Network(n) for n in v6_subnet_strings]
-v6_subnet_ranges = [(int(n[0]), int(n[-1])) for n in v6_subnets]
-
-mergeable_subnets = [
-    [
-        (int(ipaddress.IPv4Network(n)[0]), int(ipaddress.IPv4Network(n)[-1]))
-        for n in ["192.168.0.0/24", "192.168.0.0/25", "192.168.0.128/25", "192.168.0.64/29"]
-    ],
-    [
-        (int(ipaddress.IPv6Network(n)[0]), int(ipaddress.IPv6Network(n)[-1]))
-        for n in ["fc01::/32", "fc01::/64", "fc01:0:ffff::/48", "fc01:0:cafe::/64"]
-    ],
-]
-
-
-@pytest.mark.parametrize(
-    ("supernet", "subnets", "allocation_class", "network_class"),
-    [
-        (v4_supernet, v4_subnets, IPv4Allocation, ipaddress.IPv4Network),
-        (v4_supernet_string, v4_subnet_strings, IPv4Allocation, ipaddress.IPv4Network),
-        (v6_supernet, v6_subnets, IPv6Allocation, ipaddress.IPv6Network),
-        (v6_supernet_string, v6_subnet_strings, IPv6Allocation, ipaddress.IPv6Network),
-        (v4_supernet, v4_subnets[:1], IPv4Allocation, ipaddress.IPv4Network),
-        (v6_supernet, v6_subnets[:1], IPv6Allocation, ipaddress.IPv6Network),
-        (v4_supernet, [], IPv4Allocation, ipaddress.IPv4Network),
-        (v6_supernet, [], IPv6Allocation, ipaddress.IPv6Network),
-    ],
-)
-def test_allocation_classes(supernet, subnets, allocation_class, network_class):
-    a = ip_allocation(supernet, used_networks=subnets)
-    assert isinstance(a, allocation_class)
-    assert all(isinstance(n, network_class) for n in a.used_subnets)
-
-
-@pytest.mark.parametrize(
-    ("subnet", "subnet_range"),
-    zip(v4_subnets + v6_subnets, v4_subnet_ranges + v6_subnet_ranges, strict=True),
-)
-def test_netrange(subnet, subnet_range):
-    assert tools.netrange(subnet) == subnet_range
-
-
-@pytest.mark.parametrize(
-    ("supernet", "subnets", "subnet_ranges"),
-    [
-        (v4_supernet, v4_subnets, v4_subnet_ranges),
-        (v6_supernet, v6_subnets, v6_subnet_ranges),
-    ],
-)
-def test_allocation_ranges(supernet, subnets, subnet_ranges):
-    a = ip_allocation(supernet, used_networks=subnets)
-    a._update_used_subnet_ranges(merge=False)
-    assert sorted(a._used_network_ranges) == sorted(subnet_ranges)
-
-
-@pytest.mark.parametrize(
-    "subnets",
-    mergeable_subnets,
-)
-def test_merge(subnets):
-    covering_prefix = subnets[0]
-    assert tools.merge_ranges(subnets) == [covering_prefix]
-
-
-@pytest.mark.parametrize(
-    "subnets",
-    mergeable_subnets,
-)
-def test_merge_one(subnets):
-    assert subnets[:1] == tools.merge_ranges(subnets[:1])
-
-
-def test_merge_empty():
-    assert tools.merge_ranges([]) == []
-
-
-@pytest.mark.parametrize(
-    ("supernet", "used_nets", "cidr", "first_free"),
-    [
-        ("2001:db8::/32", ["2001:db8::/48", "2001:db8:1::/120"], 64, "2001:db8:1:1::/64"),
-        ("10.0.0.0/8", ["10.0.0.0/16", "10.1.0.0/24"], 16, "10.2.0.0/16"),
-    ],
-)
-def test_netsize_iterator(supernet, used_nets, cidr, first_free):
-    supernet = ipaddress.ip_network(supernet)
-    used_nets = [(int(ipaddress.ip_network(n)[0]), int(ipaddress.ip_network(n)[-1])) for n in used_nets]
-    i = tools.net_size_iterator(supernet, cidr, used_nets)
-    first_ip, last_ip = next(i)
-    net = next(ipaddress.summarize_address_range(ipaddress.ip_address(first_ip), ipaddress.ip_address(last_ip)))
-    assert first_free == str(net)
-
-
-@pytest.mark.parametrize(
-    ("supernet", "used_nets", "cidr", "last_free"),
-    [
-        ("10.0.0.0/24", ["10.0.0.0/29", "10.0.0.96/30"], 30, "10.0.0.252/30"),
-    ],
-)
-def test_netsize_iterator_last(supernet, used_nets, cidr, last_free):
-    supernet = ipaddress.ip_network(supernet)
-    used_nets = [(int(ipaddress.ip_network(n)[0]), int(ipaddress.ip_network(n)[-1])) for n in used_nets]
-    i = tools.net_size_iterator(supernet, cidr, used_nets)
-    first_ip, last_ip = list(i)[-1]
-    net = next(ipaddress.summarize_address_range(ipaddress.ip_address(first_ip), ipaddress.ip_address(last_ip)))
-    assert last_free == str(net)