kbf/test/test_net.cpp

#include <unity.h>
#include <kbf/wifi_legacy.h>
#include <kbf/rtos.h>
#include <kbf/uart.h>

#include "kbf/net.h"

#define KBF_TEST_MDNS_SSID         "kbf_test_wifi_ap"
#define KBF_TEST_MDNS_PASS         "Pas$w0Rd1337"
#define KBF_TEST_MDNS_MASTER       "master"
#define KBF_TEST_MDNS_SLAVE        "slave"
#define KBF_TEST_MDNS_SIGNAL       "ready"

#define KBF_TEST_SERVICE1_TYPE "_hax"
#define KBF_TEST_SERVICE1_PORT 1337
#define KBF_TEST_SERVICE1_INST "Test TCP service"

#define KBF_TEST_SERVICE2_TYPE "_http"
#define KBF_TEST_SERVICE2_PORT 80
#define KBF_TEST_SERVICE2_INST "Test TCP/HTTP service"

#define KBF_TEST_SERVICE3_TYPE "_hax"
#define KBF_TEST_SERVICE3_PORT 31337
#define KBF_TEST_SERVICE3_INST "Test UDP service"

using namespace kbf;

TEST_CASE("MAC address functions", "[kbf_net]") {
    uint8_t addr[] = {0, 0, 11, 128, 176, 255};

    auto mac = net::MAC(addr);
    TEST_ASSERT_EQUAL_STRING_MESSAGE("00:00:0B:80:B0:FF", mac.str().c_str(), "ctor / str()");

    net::setMac(mac);

    TEST_ASSERT_EQUAL_STRING_MESSAGE(mac.str().c_str(), net::getMac().str().c_str(), "getMac");
}

TEST_CASE("IP address functions", "[kbf_net]") {
    esp_ip4_addr testAddr = {2952898752};
    static const char *const testIP = "192.168.1.176";

    auto ipFromAddr = net::IP(testAddr);
    TEST_ASSERT_TRUE(ipFromAddr)
    TEST_ASSERT_EQUAL_STRING(testIP, ipFromAddr.str().c_str());
    TEST_ASSERT_EQUAL(0  , ipFromAddr[-1]);
    TEST_ASSERT_EQUAL(192, ipFromAddr[0]);
    TEST_ASSERT_EQUAL(168, ipFromAddr[1]);
    TEST_ASSERT_EQUAL(1  , ipFromAddr[2]);
    TEST_ASSERT_EQUAL(176, ipFromAddr[3]);
    TEST_ASSERT_EQUAL(0  , ipFromAddr[4]);

    auto ipFromString = net::IP(testIP);
    TEST_ASSERT_TRUE(ipFromString)
    TEST_ASSERT_EQUAL_STRING(testIP, ipFromString.str().c_str());

    TEST_ASSERT_TRUE_MESSAGE(ipFromAddr == ipFromString, "operator==")
    TEST_ASSERT_EQUAL_STRING(ipFromAddr.str().c_str(), ipFromString.str().c_str());

    for (const auto &invalidIP : {"", "invalid", "255.255.255.256", "123.123.123.", "0.0.-1.0"}) {
        auto ip = net::IP(invalidIP);
        TEST_ASSERT_FALSE(ip)
        TEST_ASSERT_EQUAL_STRING("", ip.str().c_str());
    }

    for (const auto &validIp : {"0.0.0.0", "255.255.255.255"}) {
        auto ip = net::IP(validIp);
        TEST_ASSERT_TRUE(ip)
        TEST_ASSERT_EQUAL_STRING(validIp, ip.str().c_str());
    }
}

using std::shared_ptr;

static rtos::EventGroup eventGroup;

static shared_ptr<kbf::UART> setupUart() {
    auto uart1 = new kbf::UART(1);
    uart1->setPins(33, 32, 25, 26); // TODO use Kconfig
    return shared_ptr<kbf::UART>(uart1);
}

void mdnsMaster() {
    wifi_legacy::start(wifi_legacy::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
    auto mdns = new net::MDNS();
    mdns->setHostname(KBF_TEST_MDNS_MASTER);

    setupUart()->waitFor(KBF_TEST_MDNS_SIGNAL);

    auto ip = mdns->queryA(KBF_TEST_MDNS_SLAVE);
    TEST_ASSERT_NOT_NULL(ip)
    TEST_ASSERT_EQUAL_STRING("192.168.4.2", ip->str().c_str());

    delete mdns;
    wifi_legacy::stop();
}

void mdnsSlave() {
    wifi_legacy::start();
    auto sta = wifi_legacy::getSTA();
    eventGroup.clear();

    sta->onIp = {[]() {
        auto mdns = new net::MDNS(KBF_TEST_MDNS_SLAVE);

        TEST_ASSERT_NULL(mdns->queryA("nonexistent"))

        auto ip = mdns->queryA(KBF_TEST_MDNS_MASTER);
        TEST_ASSERT_NOT_NULL(ip)
        TEST_ASSERT_EQUAL_STRING("192.168.4.1", ip->str().c_str());

        delete mdns;
        setupUart()->write(KBF_TEST_MDNS_SIGNAL);
    }};

    sta->onDisconnect = {[]() {
        eventGroup.setBit(0);
    }};

    sta->connect(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS);

    eventGroup.waitForBit(0);
    wifi_legacy::stop();
}

TEST_CASE_MULTIPLE_DEVICES("mDNS", "[kbf_net]", mdnsMaster, mdnsSlave)

void mdnsServiceMaster() {
    eventGroup.clear();
    wifi_legacy::start(wifi_legacy::AP::create(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS));
    wifi_legacy::getAP()->onDisconnect = {[](wifi_legacy::AP::STA &) {
        eventGroup.setBit(0);
    }};

    auto mdns = new net::MDNS();
    mdns->setHostname(KBF_TEST_MDNS_MASTER);
    mdns->addService(KBF_TEST_SERVICE1_TYPE, KBF_TEST_SERVICE1_PORT, KBF_TEST_SERVICE1_INST);
    mdns->addService(KBF_TEST_SERVICE2_TYPE, KBF_TEST_SERVICE2_PORT, KBF_TEST_SERVICE2_INST);
    mdns->addService(KBF_TEST_SERVICE3_TYPE, KBF_TEST_SERVICE3_PORT, KBF_TEST_SERVICE3_INST, net::Proto::UDP);

    TEST_ASSERT_TRUE(eventGroup.waitForBit(0, 20000));
    delete mdns;
    wifi_legacy::stop();
}

void mdnsServiceSlave() {
    eventGroup.clear();
    wifi_legacy::start();
    wifi_legacy::getSTA()->connect(KBF_TEST_MDNS_SSID, KBF_TEST_MDNS_PASS);
    wifi_legacy::getSTA()->onIp         = {[]() {
        eventGroup.setBit(0);
    }};
    wifi_legacy::getSTA()->onDisconnect = {[]() {
        TEST_ASSERT_EQUAL_STRING("", "connection error");
    }};

    eventGroup.waitForBit(0);
    auto mdns = new net::MDNS();

    auto results = mdns->queryPTR("_nonexistent", 2000);
    TEST_ASSERT_EQUAL(0, results.size());

    results = mdns->queryPTR(KBF_TEST_SERVICE1_TYPE, 2000);
    TEST_ASSERT_EQUAL(1, results.size());
//    TEST_ASSERT_EQUAL(net::Interface::STA, results[0].interface);
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_MDNS_MASTER, results[0].hostName.c_str());
    TEST_ASSERT_EQUAL(net::Proto::TCP, results[0].protocol);
//    TEST_ASSERT_EQUAL(net::IPVersion::V4, results[0].ipVersion);
    TEST_ASSERT_EQUAL(KBF_TEST_SERVICE1_PORT, results[0].port);
    TEST_ASSERT_EQUAL(1, results[0].addresses.size());
    TEST_ASSERT_EQUAL_STRING("192.168.4.1", results[0].addresses[0].str().c_str());
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_SERVICE1_INST, results[0].instanceName.c_str());

    results = mdns->queryPTR(KBF_TEST_SERVICE2_TYPE, 2000);
    TEST_ASSERT_EQUAL(1, results.size());
//    TEST_ASSERT_EQUAL(net::Interface::STA, results[1].interface);
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_MDNS_MASTER, results[0].hostName.c_str());
    TEST_ASSERT_EQUAL(net::Proto::TCP, results[0].protocol);
//    TEST_ASSERT_EQUAL(net::IPVersion::V4, results[1].ipVersion);
    TEST_ASSERT_EQUAL(KBF_TEST_SERVICE2_PORT, results[0].port);
    TEST_ASSERT_EQUAL(1, results[0].addresses.size());
    TEST_ASSERT_EQUAL_STRING("192.168.4.1", results[0].addresses[0].str().c_str());
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_SERVICE2_INST, results[0].instanceName.c_str());

    results = mdns->queryPTR(KBF_TEST_SERVICE3_TYPE, 2000, net::Proto::UDP);
    TEST_ASSERT_EQUAL(1, results.size());
//    TEST_ASSERT_EQUAL(net::Interface::STA, results[0].interface);
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_MDNS_MASTER, results[0].hostName.c_str());
    TEST_ASSERT_EQUAL(net::Proto::UDP, results[0].protocol);
//    TEST_ASSERT_EQUAL(net::IPVersion::V4, results[0].ipVersion);
    TEST_ASSERT_EQUAL(KBF_TEST_SERVICE3_PORT, results[0].port);
    TEST_ASSERT_EQUAL(1, results[0].addresses.size());
    TEST_ASSERT_EQUAL_STRING("192.168.4.1", results[0].addresses[0].str().c_str());
    TEST_ASSERT_EQUAL_STRING(KBF_TEST_SERVICE3_INST, results[0].instanceName.c_str());

    delete mdns;
    wifi_legacy::stop();
}

TEST_CASE_MULTIPLE_DEVICES("mDNS", "[kbf_net]", mdnsServiceMaster, mdnsServiceSlave)