hcloud-python/tests/unit/load_balancers/test_domain.py at b6379102ba4eaa1ba3548008c67cbd50203eaeda · hetznercloud/hcloud-python · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
from __future__ import annotations

import datetime
from datetime import timezone
from unittest import mock

import pytest

from hcloud.load_balancers import (
    BoundLoadBalancer,
    IPv4Address,
    IPv6Network,
    LoadBalancer,
    LoadBalancerAlgorithm,
    LoadBalancerHealthCheck,
    LoadBalancerHealthCheckHttp,
    LoadBalancerService,
    LoadBalancerServiceHttp,
    LoadBalancerTarget,
    LoadBalancerTargetHealthStatus,
    LoadBalancerTargetIP,
    LoadBalancerTargetLabelSelector,
    PrivateNet,
    PublicNetwork,
)
from hcloud.networks import Network


@pytest.mark.parametrize(
    "value",
    [
        (LoadBalancer(id=1),),
        (LoadBalancerService,),
        (LoadBalancerServiceHttp(),),
        (LoadBalancerHealthCheck(),),
        (LoadBalancerHealthCheckHttp(),),
        (LoadBalancerTarget(),),
        (LoadBalancerTargetHealthStatus(),),
        (LoadBalancerTargetLabelSelector(),),
        (LoadBalancerTargetIP(),),
        (LoadBalancerAlgorithm(),),
        (
            PublicNetwork(
                ipv4=IPv4Address(ip="127.0.0.1", dns_ptr="example.com"),
                ipv6=IPv6Network("2001:0db8::0/64", dns_ptr="example.com"),
                enabled=True,
            ),
        ),
        (IPv4Address(ip="127.0.0.1", dns_ptr="example.com"),),
        (IPv6Network("2001:0db8::0/64", dns_ptr="example.com"),),
        (PrivateNet(network=object(), ip="127.0.0.1"),),
    ],
)
def test_eq(value):
    assert value == value


class TestLoadBalancers:
    def test_created_is_datetime(self):
        lb = LoadBalancer(id=1, created="2016-01-30T23:50+00:00")
        assert lb.created == datetime.datetime(2016, 1, 30, 23, 50, tzinfo=timezone.utc)

    def test_private_net_for(self):
        network1 = Network(id=1)
        network2 = Network(id=2)
        network3 = Network(id=3)

        load_balancer = LoadBalancer(
            id=42,
            private_net=[
                PrivateNet(network=network1, ip="127.0.0.1"),
                PrivateNet(network=network2, ip="127.0.0.1"),
            ],
        )

        assert load_balancer.private_net_for(network1).network.id == 1
        assert load_balancer.private_net_for(network3) is None

        load_balancer = BoundLoadBalancer(
            client=mock.MagicMock(),
            data={
                "id": 42,
                "private_net": [
                    {"network": 1, "ip": "127.0.0.1"},
                    {"network": 2, "ip": "127.0.0.1"},
                ],
            },
        )

        assert load_balancer.private_net_for(network1).network.id == 1
        assert load_balancer.private_net_for(network3) is None