test_main.cpp

Go to the documentation of this file.

 
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
#include "Config.h"
#include "Firewall.h"
#include "LoadBalancer.h"
#include "Logger.h"
#include "RequestGenerator.h"
#include "Switch.h"
#include "WebServer.h"
 
namespace {
 
int failures = 0;
int checks = 0;
 
void check(bool condition, const std::string& description) {
    ++checks;
    if (!condition) {
        ++failures;
        std::cout << "  FAIL: " << description << '\n';
    }
}
 
Request makeRequest(unsigned long id, unsigned int task, const std::string& source = "10.0.0.1",
                    JobType type = JobType::Processing, unsigned long arrival = 0) {
    Request request;
    request.id = id;
    request.sourceIp = source;
    request.destinationIp = "10.0.0.2";
    request.taskCycles = task;
    request.arrivalCycle = arrival;
    request.jobType = type;
    return request;
}
 
void testWebServer() {
    WebServer server(1);
    check(server.isIdle(), "new server is idle");
    server.assign(makeRequest(1, 2), 0);
    check(!server.isIdle(), "server is busy after assign");
    check(!server.tick(), "two-cycle task is not done after one tick");
    check(server.tick(), "two-cycle task is done after two ticks");
    check(server.isIdle() && server.completedCount() == 1 && server.busyCycles() == 2,
          "server returns to idle and counts the completion");
    bool threw = false;
    server.assign(makeRequest(2, 5), 0);
    try {
        server.assign(makeRequest(3, 5), 0);
    } catch (const std::logic_error&) {
        threw = true;
    }
    check(threw, "assigning to a busy server throws");
}
 
void testFirewall() {
    Firewall firewall;
    check(firewall.addRange("192.168.0.0/16"), "valid CIDR is accepted");
    check(firewall.addRange("8.8.8.8"), "single host is accepted");
    check(!firewall.addRange("300.1.1.1/8"), "octet above 255 is rejected");
    check(!firewall.addRange("10.0.0.0/33"), "prefix above 32 is rejected");
    check(firewall.isBlocked("192.168.44.9"), "address inside a range is blocked");
    check(firewall.isBlocked("8.8.8.8"), "blocked single host");
    check(!firewall.isBlocked("8.8.8.9"), "neighbor of a blocked host is allowed");
    check(!firewall.isBlocked("192.169.0.1"), "address outside the range is allowed");
    check(firewall.isBlocked("not-an-ip"), "malformed address is blocked");
}
 
void testGenerator() {
    GeneratorSettings settings;
    settings.minTaskCycles = 3;
    settings.maxTaskCycles = 7;
    settings.arrivalRate = 2.0;
    settings.waveAmplitude = 0.0;
    RequestGenerator first(settings, 99);
    RequestGenerator second(settings, 99);
    bool inRange = true;
    bool same = true;
    for (unsigned long cycle = 1; cycle <= 500; ++cycle) {
        const std::vector<Request> a = first.arrivalsFor(cycle);
        const std::vector<Request> b = second.arrivalsFor(cycle);
        same = same && a.size() == b.size();
        for (std::size_t i = 0; i < a.size() && i < b.size(); ++i) {
            inRange = inRange && a[i].taskCycles >= 3 && a[i].taskCycles <= 7;
            same = same && a[i].sourceIp == b[i].sourceIp && a[i].taskCycles == b[i].taskCycles;
        }
    }
    check(inRange, "task times stay inside the configured range");
    check(same, "the same seed reproduces the same requests");
    const double mean = static_cast<double>(first.stats().total) / 500.0;
    check(mean > 1.7 && mean < 2.3, "observed arrival rate is close to the configured mean");
 
    settings.waveAmplitude = 0.5;
    settings.wavePeriod = 100;
    RequestGenerator wave(settings, 1);
    check(wave.rateAt(25) > 2.9 && wave.rateAt(75) < 1.1, "traffic wave raises and lowers the rate");
}
 
void testScaling() {
    Logger logger(false, false);
    ScalingPolicy policy;
    policy.upperFactor = 5;
    policy.lowerFactor = 2;
    policy.cooldownCycles = 1;
    policy.maxServers = 4;
    LoadBalancer balancer("T", 2, policy, Firewall(), 0, logger);
    for (unsigned long id = 1; id <= 40; ++id) {
        balancer.admit(makeRequest(id, 50), 0);
    }
    balancer.start();
    check(balancer.busyServers() == 2 && balancer.queueSize() == 38, "start dispatches to every server");
    balancer.processCycle(1, {});
    check(balancer.liveServers() == 3, "queue above upper x servers adds a server");
    balancer.processCycle(2, {});
    balancer.processCycle(3, {});
    check(balancer.liveServers() == 4, "pool never exceeds maxServers");
 
    // Let all work drain so the queue falls below lower x servers.
    for (unsigned long cycle = 4; cycle <= 3000; ++cycle) {
        balancer.processCycle(cycle, {});
    }
    check(balancer.liveServers() == 1, "an empty queue shrinks the pool to minServers");
    check(balancer.stats().completed == 40, "every request is completed");
    check(balancer.stats().admitted ==
              balancer.stats().completed + balancer.queueSize() + balancer.inService(),
          "admitted requests are all accounted for");
}
 
void testRetiringServerFinishesWork() {
    Logger logger(false, false);
    ScalingPolicy policy;
    policy.upperFactor = 100;
    policy.lowerFactor = 1;
    policy.cooldownCycles = 1;
    LoadBalancer balancer("T", 2, policy, Firewall(), 0, logger);
    balancer.admit(makeRequest(1, 10), 0);
    balancer.admit(makeRequest(2, 3), 0);
    balancer.start();
    balancer.processCycle(1, {});
    check(balancer.retiringServers() == 1, "busy server is marked retiring instead of being dropped");
    for (unsigned long cycle = 2; cycle <= 3; ++cycle) {
        balancer.processCycle(cycle, {});
    }
    check(balancer.liveServers() == 1 && balancer.stats().completed == 1,
          "retiring server is removed only after finishing its request");
}
 
void testRejectAndDiscard() {
    Logger logger(false, false);
    Firewall firewall;
    firewall.addRange("66.0.0.0/8");
    LoadBalancer balancer("T", 1, ScalingPolicy(), firewall, 2, logger);
    check(!balancer.admit(makeRequest(1, 5, "66.1.2.3"), 0), "blocked source is rejected");
    check(balancer.admit(makeRequest(2, 5), 0) && balancer.admit(makeRequest(3, 5), 0), "allowed requests queue");
    check(!balancer.admit(makeRequest(4, 5), 0), "request beyond queue capacity is discarded");
    check(balancer.stats().rejected == 1 && balancer.stats().discarded == 1, "reject and discard are counted");
}
 
void testSwitch() {
    Logger logger(false, false);
    Switch router(std::make_unique<LoadBalancer>("P", 1, ScalingPolicy(), Firewall(), 0, logger),
                  std::make_unique<LoadBalancer>("S", 1, ScalingPolicy(), Firewall(), 0, logger));
    router.route(makeRequest(1, 5, "10.0.0.1", JobType::Processing), 0);
    router.route(makeRequest(2, 5, "10.0.0.1", JobType::Streaming), 0);
    router.route(makeRequest(3, 5, "10.0.0.1", JobType::Streaming), 0);
    check(router.processing().queueSize() == 1 && router.streaming().queueSize() == 2,
          "switch routes requests by job type");
}
 
void testConfig() {
    Config config;
    std::string error;
    const char* args[] = {"lb", "--servers", "7", "--cycles", "50", "--block", "1.2.3.0/24", "--no-default-blocks"};
    check(parseArguments(8, const_cast<char**>(args), config, error), "options parse");
    check(config.servers == 7 && config.cycles == 50, "numeric options are read");
    check(config.blockedRanges.size() == 1 && config.blockedRanges[0] == "1.2.3.0/24",
          "--no-default-blocks keeps only user ranges");
    const char* bad[] = {"lb", "--servers", "-3"};
    Config other;
    check(!parseArguments(3, const_cast<char**>(bad), other, error), "negative server count is rejected");
    Config invalid;
    invalid.minTask = 50;
    invalid.maxTask = 10;
    check(!validateConfig(invalid, error), "min task above max task is invalid");
 
    Config prompted;
    std::istringstream answers("12\n500\n\n\n\n\ny\nn\n");
    std::ostringstream questions;
    promptForSettings(prompted, answers, questions);
    check(prompted.servers == 12 && prompted.cycles == 500 && prompted.verbose && !prompted.useSwitch,
          "interactive prompts read answers and keep defaults on blank lines");
}
 
}  // namespace

int main() {
    testWebServer();
    testFirewall();
    testGenerator();
    testScaling();
    testRetiringServerFinishesWork();
    testRejectAndDiscard();
    testSwitch();
    testConfig();
    std::cout << (checks - failures) << "/" << checks << " checks passed\n";
    return failures == 0 ? 0 : 1;
}