Integrasi langsung ke instance RPKI validator eksternal (seperti Routinator, OctoRPKI, atau StayRTR) pada automated testing pipeline sering kali memicu flaky test. Uji coba berbasis jaringan publik rentan terhadap latensi rsync/RRDP, keterlambatan propagasi Validated ROA Payloads (VRP), serta connection timeout. Masalah ini semakin jelas ketika tim menjalankan validator ringan dalam kontainer pengujian tanpa alokasi CPU atau memori yang memadai.

Solusi deterministik untuk mengatasi masalah ini adalah mengisolasi dependensi validator menggunakan pola mocking cache RTR lokal. Protokol RPKI-to-Router (RTR, RFC 6810 / RFC 8210) menggunakan struktur biner sederhana di atas transport TCP. Membangun mock server RTR lokal memungkinkan pipeline CI/CD memverifikasi logika validasi rute (Valid, Invalid, NotFound) serta skenario fallback secara cepat tanpa dependensi eksternal.

Anatomi Paket RTR dan Masalah Flaky Test

Flaky test pada sistem validasi rute terjadi akibat tiga faktor utama:

  • Sinkronisasi VRP Asinkron: Repository RPKI global membutuhkan waktu sinkronisasi berkala. Pengujian yang bergantung pada rute publik baru dapat menghasilkan status NotFound sebelum sinkronisasi selesai.
  • Beban Komputasi Validasi Kriptografi: Validator RPKI harus memvalidasi rantai sertifikat X.509 dan manifest CMS. Proses ini memicu CPU spike pada runner CI/CD yang berujung pada socket timeout.
  • Kegagalan Transpor Eksternal: Dependensi ke port RTR remote (default port 323 atau 8282) memperbesar risiko kegagalan handshake akibat filter firewall atau degradasi rute internet.

Protokol RTR v0 (RFC 6810) dan v1 (RFC 8210) berkomunikasi via Protocol Data Unit (PDU) biner. Ketika router atau client service mengirim Reset Query (PDU Type 2), server RTR merespons dengan urutan: Cache Response (PDU Type 3), satu atau beberapa IPv4/IPv6 Prefix (PDU Type 4/6), dan diakhiri dengan End of Data (PDU Type 7).

Implementasi Mock Server RTR Lokal

Mock server berikut mengimplementasikan sebagian kecil spesifikasi RFC 6810 menggunakan Python standard library. Server ini menyajikan sekumpulan VRP statis untuk IPv4 Prefix PDU guna memastikan hasil pengujian deterministik.

import socket
import struct
import threading

class LocalRTRMock:
    def __init__(self, host="127.0.0.1", port=8323):
        self.host = host
        self.port = port
        self.sock = None
        self.thread = None
        self.is_running = False

    def _pack_cache_response(self, session_id=1):
        # Protocol Version: 0, PDU Type: 3 (Cache Response), Session ID: 1, Length: 8
        return struct.pack("!BBHH", 0, 3, session_id, 8)

    def _pack_ipv4_prefix(self, ip_bytes, prefix_len, max_len, asn, flags=1):
        # PDU Type: 4 (IPv4 Prefix), Length: 20
        # Flags: 1 (Announcement), 0 (Withdrawal)
        return struct.pack("!BBBB4sII", 0, 4, 0, flags, ip_bytes, prefix_len, max_len, asn)

    def _pack_end_of_data(self, session_id=1, serial=1):
        # Protocol Version: 0, PDU Type: 7 (End of Data), Session ID: 1, Length: 12
        return struct.pack("!BBHII", 0, 7, session_id, 12, serial)

    def _handle_client(self, conn):
        try:
            while self.is_running:
                header = conn.recv(8)
                if not header or len(header) < 8:
                    break
                version, pdu_type, session_id, length = struct.unpack("!BBHH", header)

                # Reset Query (Type 2) or Serial Query (Type 1)
                if pdu_type in (1, 2):
                    payload = bytearray()
                    payload.extend(self._pack_cache_response(session_id=100))
                    
                    # ROA 1: 198.51.100.0/24 MaxLen 24 ASN 64496
                    ip_roa1 = socket.inet_aton("198.51.100.0")
                    payload.extend(self._pack_ipv4_prefix(ip_roa1, 24, 24, 64496))

                    # ROA 2: 203.0.113.0/24 MaxLen 28 ASN 64497
                    ip_roa2 = socket.inet_aton("203.0.113.0")
                    payload.extend(self._pack_ipv4_prefix(ip_roa2, 24, 28, 64497))

                    payload.extend(self._pack_end_of_data(session_id=100, serial=1))
                    conn.sendall(payload)
        except (socket.error, struct.error):
            pass
        finally:
            conn.close()

    def start(self):
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.sock.bind((self.host, self.port))
        self.sock.listen(5)
        self.is_running = True
        self.thread = threading.Thread(target=self._run)
        self.thread.daemon = True
        self.thread.start()

    def _run(self):
        while self.is_running:
            try:
                conn, _ = self.sock.accept()
                threading.Thread(target=self._handle_client, args=(conn,), daemon=True).start()
            except socket.error:
                break

    def stop(self):
        self.is_running = False
        if self.sock:
            self.sock.close()

Pengujian Determinik Validitas Rute BGP

Dengan mock cache RTR lokal yang berjalan di port 8323, client service dapat mengonsumsi VRP statis untuk mengevaluasi status rute BGP RFC 6811 tanpa interaksi validator eksternal. Logika evaluasi menghasilkan tiga kondisi deterministik:

  • Valid: Prefix BGP cocok dengan ROA dan ASN pengirim sesuai batas max_length.
  • Invalid: Prefix BGP tercakup dalam ROA, namun ASN pengirim berbeda atau panjang subnet melebihi max_length.
  • NotFound: Prefix BGP tidak terdaftar dalam tabel VRP cache RTR.
import unittest
from ipaddress import ip_network

# Menggunakan mock server dari implementasi sebelumnya
class TestRouteValidation(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.server = LocalRTRMock(port=8323)
        cls.server.start()
        # Inisialisasi client RTR hipotetis terhadap localhost:8323
        cls.client = MockBGPRouteValidator(host="127.0.0.1", port=8323)
        cls.client.sync()

    @classmethod
    def tearDownClass(cls):
        cls.server.stop()

    def test_route_valid(self):
        # Cocok persis dengan ROA 1
        status = self.client.validate(asn=64496, prefix="198.51.100.0/24")
        self.assertEqual(status, "Valid")

    def test_route_invalid_asn(self):
        # Prefix sesuai ROA 1, tapi ASN salah
        status = self.client.validate(asn=65000, prefix="198.51.100.0/24")
        self.assertEqual(status, "Invalid")

    def test_route_invalid_length(self):
        # ASN sesuai ROA 1, tapi panjang prefix /25 melebihi MaxLen 24
        status = self.client.validate(asn=64496, prefix="198.51.100.0/25")
        self.assertEqual(status, "Invalid")

    def test_route_not_found(self):
        # Prefix tidak ada di database VRP
        status = self.client.validate(asn=64496, prefix="192.0.2.0/24")
        self.assertEqual(status, "NotFound")

Pola Pengujian Skema Fallback Offline

Layanan routing modern wajib menangani skenario saat RTR server mendadak tidak responsif. RFC mengamanatkan penggunaan fallback seperti expire timer atau beralih ke cache sekunder tanpa langsung membatalkan seluruh rute BGP aktif.

Mock server lokal memungkinkan pengujian skenario ini secara presisi melalui simulasi pemutusan soket:

def test_rtr_server_offline_fallback():
    server = LocalRTRMock(port=8324)
    server.start()

    client = MockBGPRouteValidator(host="127.0.0.1", port=8324)
    client.sync()
    assert client.is_connected() is True

    # Matikan server secara paksa
    server.stop()

    # Client mencoba re-sync, harus fallback ke stale cache tanpa panic
    result = client.sync_with_retry(max_retries=1)
    assert result == "USED_STALE_CACHE"
    
    # Validasi rute tetap berfungsi menggunakan cache lokal lama
    status = client.validate(asn=64496, prefix="198.51.100.0/24")
    assert status == "Valid"

Trade-off dan Batasan

Meskipun mock cache RTR lokal menghilangkan ketergantungan eksternal dan mempercepat pipeline CI/CD hingga hitungan milidetik, pertimbangkan batasan berikut:

  • Tidak Menguji Kriptografi Nyata: Mock server memotong layer validasi X.509, RPKI Manifest (.mft), dan CMS signature. Pengujian kriptografi sebaiknya ditempatkan di level integration/e2e test terjadwal terpisah (nightly build).
  • Implementasi Protokol Terbatas: Contoh di atas hanya menangani PDU IPv4. Untuk pengujian dual-stack, tambahkan parsing IPv6 Prefix PDU (Type 6) dan pemrosesan Serial Notify (Type 0).
  • Sinkronisasi Incremental: Pengujian kompleks yang membutuhkan update delta via Serial Query perlu menyimpan state serial secara berurutan di dalam instance mock.