test_dhcp.py

#!/usr/bin/env python3
"""Тесты для DHCP-сервера (main.py)"""

import unittest
import json
import struct
from datetime import datetime, timedelta
from unittest.mock import patch, mock_open
import threading
import sys

# Импорт функций из main.py
sys.path.insert(0, '.')
from dhcp.ip_utils import ip_to_int, int_to_ip
from dhcp.ip_manager import (
    allocate_ip, release_ip, is_ip_available, leases, used_ips, mark_ip_conflict,
    save_leases_to_disk, load_leases_from_disk, cleanup_expired_leases
)
from dhcp.config import config
from dhcp.packet import build_dhcp_packet, parse_dhcp_packet


class TestIPConversion(unittest.TestCase):
    """Тесты функций ip_to_int и int_to_ip"""

    def test_ip_to_int_correct(self):
        """Проверка конвертации IP в число"""
        self.assertEqual(ip_to_int('192.168.0.1'), 3232235521)
        self.assertEqual(ip_to_int('0.0.0.0'), 0)
        self.assertEqual(ip_to_int('255.255.255.255'), 4294967295)

    def test_int_to_ip_correct(self):
        """Проверка конвертации числа в IP"""
        self.assertEqual(int_to_ip(3232235521), '192.168.0.1')
        self.assertEqual(int_to_ip(0), '0.0.0.0')
        self.assertEqual(int_to_ip(4294967295), '255.255.255.255')

    def test_roundtrip_conversion(self):
        """Проверка roundtrip конвертации"""
        for ip in ['10.0.0.1', '172.16.0.1', '192.168.1.254']:
            num = ip_to_int(ip)
            self.assertEqual(int_to_ip(num), ip)


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestAllocateIP(unittest.TestCase):
    """Тесты функции allocate_ip"""

    def setUp(self):
        """Очистка состояния перед каждым тестом"""
        leases.clear()
        used_ips.clear()
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_allocate_first_ip(self, mock_datetime, mock_save):
        """Проверка выдачи первого IP из пула"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        ip = allocate_ip('aa:bb:cc:dd:ee:ff', hostname='test-host')
        self.assertEqual(ip, '192.168.0.100')
        # Проверяем, что имя хоста сохранилось
        self.assertEqual(leases['aa:bb:cc:dd:ee:ff'][2], 'test-host')

    @patch('dhcp.ip_manager.datetime')
    def test_allocate_sequential(self, mock_datetime, mock_save):
        """Проверка последовательной выдачи IP"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        ip1 = allocate_ip('aa:bb:cc:dd:ee:ff')
        ip2 = allocate_ip('11:22:33:44:55:66')
        self.assertEqual(ip1, '192.168.0.100')
        self.assertEqual(ip2, '192.168.0.101')

    @patch('dhcp.ip_manager.datetime')
    def test_reuse_same_mac(self, mock_datetime, mock_save):
        """Проверка повторной выдачи того же IP тому же MAC"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        ip1 = allocate_ip('aa:bb:cc:dd:ee:ff')
        
        # Устанавливаем истекшую аренду для теста повторного использования
        mock_datetime.now.return_value = datetime(2023, 1, 1, 13, 0, 0)  # +1 час
        
        ip2 = allocate_ip('aa:bb:cc:dd:ee:ff')
        self.assertEqual(ip1, ip2)

    @patch('dhcp.ip_manager.datetime')
    def test_pool_exhaustion(self, mock_datetime, mock_save):
        """Проверка обработки переполнения пула"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        
        # Выдадим все IP из пула (в тесте - несколько для скорости)
        for i in range(101):  # 101 IP в пуле (от .100 до .200)
            mac = f'aa:bb:cc:dd:ee:{i:02x}'
            allocate_ip(mac)
        
        # Следующая попытка должна вернуть None
        ip = allocate_ip('ff:ee:dd:cc:bb:aa')
        self.assertIsNone(ip)


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestReleaseIP(unittest.TestCase):
    """Тесты функции release_ip"""

    def setUp(self):
        leases.clear()
        used_ips.clear()
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_release_existing_lease(self, mock_datetime, mock_save):
        """Проверка освобождения существующей аренды"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        allocate_ip('aa:bb:cc:dd:ee:ff')
        release_ip('aa:bb:cc:dd:ee:ff')
        
        self.assertNotIn('aa:bb:cc:dd:ee:ff', leases)
        # IP должен быть доступен снова
        ip = allocate_ip('aa:bb:cc:dd:ee:ff')
        self.assertEqual(ip, '192.168.0.100')

    @patch('dhcp.ip_manager.datetime')
    def test_release_nonexistent_mac(self, mock_datetime, mock_save):
        """Проверка обработки MAC без аренды"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        release_ip('aa:bb:cc:dd:ee:ff')  # Не должно вызвать ошибку


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestIsIPAvailable(unittest.TestCase):
    """Тесты функции is_ip_available"""

    def setUp(self):
        leases.clear()
        used_ips.clear()
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_ip_is_available(self, mock_datetime, mock_save):
        """Проверка что свободный IP доступен"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        self.assertTrue(is_ip_available('192.168.0.105', 'aa:bb:cc:dd:ee:ff'))

    @patch('dhcp.ip_manager.datetime')
    def test_ip_busy_different_mac(self, mock_datetime, mock_save):
        """Проверка что занятый IP недоступен для другого MAC"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        allocate_ip('aa:bb:cc:dd:ee:ff')
        
        self.assertFalse(is_ip_available('192.168.0.100', '11:22:33:44:55:66'))

    @patch('dhcp.ip_manager.datetime')
    def test_ip_busy_same_mac(self, mock_datetime, mock_save):
        """Проверка что MAC может использовать свой IP"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        allocate_ip('aa:bb:cc:dd:ee:ff')
        
        self.assertTrue(is_ip_available('192.168.0.100', 'aa:bb:cc:dd:ee:ff'))


class TestBuildDHCPPacket(unittest.TestCase):
    """Тесты функции build_dhcp_packet"""

    def setUp(self):
        leases.clear()
        used_ips.clear()

    def test_build_offer_packet(self):
        """Проверка создания OFFER пакета (type=2)"""
        # Создаем тестовый DISCOVER пакет
        discover = create_test_dhcp_discover()
        
        packet = build_dhcp_packet(discover, 2, '192.168.0.100', '192.168.0.10')
        
        self.assertEqual(len(packet), 300)
        # Проверяем оп-код (первый байт должен быть 2 = BOOTREPLY)
        self.assertEqual(packet[0], 2)

    def test_build_ack_packet(self):
        """Проверка создания ACK пакета (type=5)"""
        discover = create_test_dhcp_discover()
        
        packet = build_dhcp_packet(discover, 5, '192.168.0.100', '192.168.0.10')
        
        self.assertEqual(len(packet), 300)

    def test_build_nak_packet(self):
        """Проверка создания NAK пакета (type=6)"""
        request = create_test_dhcp_request()

        packet = build_dhcp_packet(request, 6, '0.0.0.0', '192.168.0.10')

        self.assertEqual(len(packet), 300)
        # Проверяем оп-код (первый байт должен быть 2 = BOOTREPLY)
        self.assertEqual(packet[0], 2)

        # Проверяем, что yiaddr и ciaddr равны 0
        ciaddr = struct.unpack('!I', packet[12:16])[0]
        yiaddr = struct.unpack('!I', packet[16:20])[0]
        self.assertEqual(ciaddr, 0)
        self.assertEqual(yiaddr, 0)

        # Проверяем, что в опциях есть тип сообщения NAK и ID сервера
        self.assertIn(b'\x35\x01\x06', packet)  # DHCPNAK (type 6)
        self.assertIn(b'\x36\x04' + struct.pack('!I', ip_to_int('192.168.0.10')), packet)

    def test_packet_options(self):
        """Проверка наличия правильных опций в пакете"""
        discover = create_test_dhcp_discover()
        
        packet = build_dhcp_packet(discover, 5, '192.168.0.100', '192.168.0.10')
        
        # Проверяем magic cookie (должен быть \x63\x82\x53\x63)
        self.assertEqual(packet[236:240], b'\x63\x82\x53\x63')

    def test_packet_with_extra_options(self):
        """Проверка добавления дополнительных опций"""
        discover = create_test_dhcp_discover()
        
        extra_opts = {1: b'\x01', 2: b'\x02'}
        packet = build_dhcp_packet(discover, 5, '192.168.0.100', 
                                   '192.168.0.10', extra_opts)
        
        self.assertEqual(len(packet), 300)


class TestParseDHCPPacket(unittest.TestCase):
    """Тесты функции parse_dhcp_packet"""

    def test_parse_discover(self):
        """Проверка разбора DISCOVER пакета (type=1)"""
        discover = create_test_dhcp_discover()

        msg_type, mac, requested_ip, hostname = parse_dhcp_packet(discover)
        self.assertEqual(msg_type, 1)
        self.assertEqual(mac, 'aa:bb:cc:dd:ee:ff')
        self.assertIsNone(requested_ip)
        self.assertIsNone(hostname)

    def test_parse_request_with_requested_ip(self):
        """Проверка разбора REQUEST с запрошенным IP"""
        request = create_test_dhcp_request()

        msg_type, mac, requested_ip, hostname = parse_dhcp_packet(request)

        self.assertEqual(msg_type, 3)
        self.assertEqual(mac, 'aa:bb:cc:dd:ee:ff')
        self.assertEqual(requested_ip, '192.168.0.150')
        self.assertIsNone(hostname)

    def test_parse_with_hostname(self):
        """Проверка разбора пакета с опцией Hostname (12)"""
        packet = create_test_dhcp_discover_with_hostname()
        msg_type, mac, requested_ip, hostname = parse_dhcp_packet(packet)
        self.assertEqual(msg_type, 1)
        self.assertEqual(mac, 'aa:bb:cc:dd:ee:ff')
        self.assertEqual(hostname, 'test-client')

    def test_parse_invalid_packet(self):
        """Проверка обработки невалидного пакета"""
        invalid_data = b'\x00' * 100

        msg_type, mac, requested_ip, hostname = parse_dhcp_packet(invalid_data)

        self.assertIsNone(msg_type)


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestConcurrency(unittest.TestCase):
    """Тесты потокобезопасности"""

    def setUp(self):
        leases.clear()
        used_ips.clear()
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_concurrent_allocation(self, mock_datetime, mock_save):
        """Проверка что при параллельных запросах IP не дублируются"""
        # Настраиваем mock для возвращения текущего времени
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        
        results = []
        
        def allocate():
            ip = allocate_ip(f'aa:bb:cc:dd:ee:{len(results):02x}')
            if ip:
                results.append(ip)
        
        threads = [threading.Thread(target=allocate) for _ in range(10)]
        for t in threads:
            t.start()
        for t in threads:
            t.join()
        
        # Все выданные IP должны быть уникальными
        self.assertEqual(len(results), len(set(results)))


class TestLeasePersistence(unittest.TestCase):
    """Тесты сохранения и загрузки аренд"""

    def setUp(self):
        leases.clear()
        used_ips.clear()

    @patch('dhcp.ip_manager.json.dump')
    @patch('builtins.open', new_callable=mock_open)
    def test_save_leases_to_disk(self, mock_file, mock_json_dump):
        """Проверка корректного сохранения аренд в JSON"""
        expiry_time = datetime(2023, 1, 1, 13, 0, 0)
        leases['aa:bb:cc:dd:ee:ff'] = ('192.168.0.100', expiry_time, 'my-pc')

        save_leases_to_disk()

        mock_file.assert_called_once_with(config.leases_file, "w")
        expected_data = {
            'aa:bb:cc:dd:ee:ff': ('192.168.0.100', expiry_time.isoformat(), 'my-pc')
        }
        mock_json_dump.assert_called_once_with(expected_data, mock_file(), indent=4)

    def test_load_leases_from_disk(self):
        """Проверка загрузки активных и отсеивания истекших аренд"""
        now = datetime.now()
        active_expiry = now + timedelta(hours=1)
        expired_expiry = now - timedelta(hours=1)

        mock_data = {
            "aa:bb:cc:dd:ee:ff": ["192.168.0.100", active_expiry.isoformat(), "active-pc"],
            "11:22:33:44:55:66": ["192.168.0.101", expired_expiry.isoformat(), "expired-pc"],
            "00:11:22:33:44:55": ["192.168.0.102", active_expiry.isoformat()]  # Старый формат
        }
        
        m = mock_open(read_data=json.dumps(mock_data))
        with patch('builtins.open', m):
            load_leases_from_disk()

        self.assertIn('aa:bb:cc:dd:ee:ff', leases)
        self.assertEqual(leases['aa:bb:cc:dd:ee:ff'][0], '192.168.0.100')
        self.assertEqual(leases['aa:bb:cc:dd:ee:ff'][2], 'active-pc')
        self.assertIn(ip_to_int('192.168.0.100'), used_ips)
        
        self.assertNotIn('11:22:33:44:55:66', leases)
        self.assertNotIn(ip_to_int('192.168.0.101'), used_ips)

        # Проверка обратной совместимости
        self.assertIn('00:11:22:33:44:55', leases)
        self.assertIsNone(leases['00:11:22:33:44:55'][2])

    @patch('dhcp.ip_manager.save_leases_to_disk')
    @patch('builtins.open', side_effect=FileNotFoundError)
    def test_load_leases_file_not_found(self, mock_open_func, mock_save):
        """Проверка, что при отсутствии файла он создается"""
        load_leases_from_disk()
        self.assertEqual(len(leases), 0)
        mock_save.assert_called_once()


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestLeaseCleanup(unittest.TestCase):
    """Тесты для фоновой очистки аренд"""

    def setUp(self):
        leases.clear()
        used_ips.clear()

    @patch('dhcp.ip_manager.datetime')
    def test_cleanup_removes_expired_leases(self, mock_datetime, mock_save):
        """Проверка, что очистка удаляет только истекшие аренды"""
        now = datetime(2023, 1, 1, 12, 0, 0)
        mock_datetime.now.return_value = now

        # Активная аренда
        leases['active_mac'] = ('192.168.0.100', now + timedelta(seconds=1), 'active-host')
        used_ips.add(ip_to_int('192.168.0.100'))

        # Истекшая аренда
        leases['expired_mac'] = ('192.168.0.101', now - timedelta(seconds=1), 'expired-host')
        used_ips.add(ip_to_int('192.168.0.101'))

        cleaned_count = cleanup_expired_leases()

        self.assertEqual(cleaned_count, 1)
        self.assertIn('active_mac', leases)
        self.assertNotIn('expired_mac', leases)
        self.assertIn(ip_to_int('192.168.0.100'), used_ips)
        self.assertNotIn(ip_to_int('192.168.0.101'), used_ips)
        mock_save.assert_called_once()

    def test_cleanup_with_no_expired_leases(self, mock_save):
        """Проверка, что ничего не происходит, если нет истекших аренд"""
        leases['active_mac'] = ('192.168.0.100', datetime.now() + timedelta(hours=1), 'host')
        self.assertEqual(cleanup_expired_leases(), 0)
        mock_save.assert_not_called()


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestStaticLeases(unittest.TestCase):
    """Тесты для статических аренд"""

    def setUp(self):
        leases.clear()
        used_ips.clear()
        # Mock the static leases in the config object
        self.original_static_leases = config.static_leases
        config.static_leases = {
            "aa:bb:cc:dd:ee:01": {
                "ip": "192.168.0.50",
                "lease_time": 7200
            },
            "aa:bb:cc:dd:ee:02": {
                "ip": "192.168.0.51"
                # No lease_time, should use global
            }
        }
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        # Restore original config
        config.static_leases = self.original_static_leases
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_allocate_static_ip(self, mock_datetime, mock_save):
        """Проверка выдачи статического IP с кастомным временем аренды"""
        now = datetime(2023, 1, 1, 12, 0, 0)
        mock_datetime.now.return_value = now
        
        mac = "aa:bb:cc:dd:ee:01"
        ip = allocate_ip(mac)
        
        self.assertEqual(ip, "192.168.0.50")
        self.assertIn(mac, leases)
        _, expiry, _ = leases[mac]
        expected_expiry = now + timedelta(seconds=7200)
        self.assertEqual(expiry, expected_expiry)
        mock_save.assert_called_once()

    @patch('dhcp.ip_manager.datetime')
    def test_allocate_static_ip_with_global_lease_time(self, mock_datetime, mock_save):
        """Проверка выдачи статического IP с глобальным временем аренды"""
        now = datetime(2023, 1, 1, 12, 0, 0)
        mock_datetime.now.return_value = now
        mac = "aa:bb:cc:dd:ee:02"
        ip = allocate_ip(mac)
        self.assertEqual(ip, "192.168.0.51")
        _, expiry, _ = leases[mac]
        self.assertEqual(expiry, now + timedelta(seconds=config.lease_time))

    @patch('dhcp.ip_manager.datetime')
    def test_allocate_dynamic_ip_if_no_static_lease(self, mock_datetime, mock_save):
        """Проверка выдачи динамического IP, если нет статической записи"""
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        
        mac = "ff:ff:ff:ff:ff:ff" # No static lease for this MAC
        ip = allocate_ip(mac)
        
        self.assertEqual(ip, "192.168.0.100") # First from dynamic pool

    @patch('dhcp.ip_manager.datetime')
    def test_static_ip_conflict(self, mock_datetime, mock_save):
        """Проверка, что статический IP не выдается, если он уже занят другим MAC"""
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)
        
        # Manually occupy the static IP with a different MAC
        other_mac = "ff:ff:ff:ff:ff:ff"
        static_ip_for_aa = "192.168.0.50"
        leases[other_mac] = (static_ip_for_aa, datetime.now() + timedelta(hours=1))
        used_ips.add(ip_to_int(static_ip_for_aa))
        
        # Try to allocate for the MAC that has this static reservation
        ip = allocate_ip("aa:bb:cc:dd:ee:01")
        
        self.assertIsNone(ip)


@patch('dhcp.ip_manager.save_leases_to_disk')
class TestDeclineHandling(unittest.TestCase):
    """Тесты для обработки DHCPDECLINE"""

    def setUp(self):
        leases.clear()
        used_ips.clear()
        self.ping_patcher = patch('dhcp.ip_manager.is_ip_active', return_value=False)
        self.ping_patcher.start()

    def tearDown(self):
        self.ping_patcher.stop()

    @patch('dhcp.ip_manager.datetime')
    def test_decline_marks_ip_as_conflicted(self, mock_datetime, mock_save):
        """Проверка, что DECLINE помечает IP как конфликтный и освобождает аренду"""
        mock_datetime.now.return_value = datetime(2023, 1, 1, 12, 0, 0)

        # 1. Выдаем IP
        original_mac = 'aa:bb:cc:dd:ee:ff'
        conflicted_ip = allocate_ip(original_mac, 'host-to-be-declined')
        self.assertEqual(conflicted_ip, '192.168.0.100')
        self.assertIn(original_mac.lower(), leases)

        # 2. Обрабатываем DECLINE для этого IP
        mark_ip_conflict(conflicted_ip)

        # 3. Проверяем, что аренда для оригинального MAC удалена
        self.assertNotIn(original_mac.lower(), leases)

        # 4. Проверяем, что создана конфликтная аренда
        self.assertIn(f"conflict_decline_{conflicted_ip}", leases)
        self.assertEqual(leases[f"conflict_decline_{conflicted_ip}"][2], "declined")

        # 5. Проверяем, что IP все еще считается используемым
        self.assertIn(ip_to_int(conflicted_ip), used_ips)

        # 6. Проверяем, что новый запрос на выделение не получает конфликтный IP
        new_ip = allocate_ip('11:22:33:44:55:66')
        self.assertNotEqual(new_ip, conflicted_ip)
        self.assertEqual(new_ip, '192.168.0.101')
        mock_save.assert_called()
# Вспомогательные функции для создания тестовых пакетов

def create_test_dhcp_discover():
    """Создает тестовый DHCPDISCOVER пакет"""
    # Создаем минимальный DHCP пакет (236 байт заголовка + опции)
    header_size = 240  # Размер заголовка до опций
    packet = bytearray(header_size + 10)  # Заголовок + минимум для опций
    
    # op, htype, hlen, hops
    packet[0] = 1   # BOOTREQUEST
    packet[1] = 1   # Ethernet
    packet[2] = 6   # MAC length
    
    # xid
    struct.pack_into('!I', packet, 4, 0x12345678)
    
    # chaddr (MAC)
    packet[28:34] = bytes.fromhex("aabbccddeeff")
    
    # Magic cookie и опции - смещение должно быть правильным
    packet[236:240] = b'\x63\x82\x53\x63'  # magic cookie (смещение 236)
    packet[240] = 53   # option type (message-type)
    packet[241] = 1    # length
    packet[242] = 1    # DHCPDISCOVER
    
    return bytes(packet)


def create_test_dhcp_request():
    """Создает тестовый DHCPREQUEST пакет с запрошенным IP"""
    header_size = 240
    packet = bytearray(header_size + 20)  # Заголовок + опции
    
    # op, htype, hlen, hops
    packet[0] = 1   # BOOTREQUEST
    packet[1] = 1   # Ethernet
    packet[2] = 6   # MAC length
    
    # xid
    struct.pack_into('!I', packet, 4, 0x87654321)
    
    # chaddr (MAC)
    packet[28:34] = bytes.fromhex("aabbccddeeff")
    
    # Magic cookie и опции
    packet[236:240] = b'\x63\x82\x53\x63'  # magic cookie
    
    # option type (message-type) = REQUEST
    packet[240] = 53
    packet[241] = 1
    packet[242] = 3
    
    # requested IP (option 50)
    packet[243:245] = [50, 4]
    packet[245:249] = struct.pack('!I', ip_to_int('192.168.0.150'))
    
    return bytes(packet)


def create_test_dhcp_discover_with_hostname():
    """Создает тестовый DHCPDISCOVER с опцией hostname"""
    packet = bytearray(create_test_dhcp_discover())
    # Находим конец опций (байт 255). 
    # Ищем строго после 240-го байта, чтобы не спутать с \xff внутри MAC-адреса!
    end_pos = packet.find(b'\xff', 240)
    if end_pos == -1:
        end_pos = len(packet)

    # Опция 12: Hostname
    hostname = b'test-client'
    hostname_option = bytes([12, len(hostname)]) + hostname

    # Вставляем опцию перед маркером конца
    return bytes(packet[:end_pos] + hostname_option + packet[end_pos:])


if __name__ == '__main__':
    unittest.main(verbosity=2)