testexpressnext.cpp File Reference

#include "core/SNodeC.h"
#include "core/timer/Timer.h"
#include "express/legacy/in/WebApp.h"
#include "log/Logger.h"
#include "web/http/legacy/in/Client.h"
#include <cstddef>
#include <deque>

Include dependency graph for testexpressnext.cpp:

Go to the source code of this file.

Classes
struct	TestCase
class	NextTester

Functions
int	main (int argc, char *argv[])

Function Documentation

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 184 of file testexpressnext.cpp.

                                 {
    core::SNodeC::init(argc, argv);
 
    const express::legacy::in::WebApp app("testexpressnext-server");
 
    app.get(
        "/next/basic",
        [] MIDDLEWARE(req, res, next) {
            req->setAttribute<std::string>("middleware-seen", "yes");
            next();
        },
        [] APPLICATION(req, res) {
            std::string marker = "no";
            req->getAttribute<std::string>(
                [&](const std::string& value) {
                    marker = value;
                },
                "middleware-seen");
            res->status(200).send("next() reached final handler (middleware=" + marker + ")");
        });
 
    app.get(
        "/next/async/basic",
        [] MIDDLEWARE(req, res, next) {
            req->setAttribute<std::string>("middleware-seen-async", "yes");
            core::EventReceiver::atNextTick([next] {
                next();
            });
        },
        [] APPLICATION(req, res) {
            std::string marker = "no";
            req->getAttribute<std::string>(
                [&](const std::string& value) {
                    marker = value;
                },
                "middleware-seen-async");
            res->status(200).send("next(async) reached final handler (middleware=" + marker + ")");
        });
 
    app.get(
        "/next/route/:id(\\d+)",
        [] MIDDLEWARE(req, res, next) {
            if (req->params["id"] == "0") {
                next("route");
                return;
            }
            next();
        },
        [] APPLICATION(req, res) {
            res->status(200).send("next(route) primary for id=" + req->params["id"]);
        });
 
    app.get("/next/route/:id(\\d+)", [] APPLICATION(req, res) {
        res->status(200).send("next(route) fallback for id=" + req->params["id"]);
    });
 
    app.get(
        "/next/async/route/:id(\\d+)",
        [] MIDDLEWARE(req, res, next) {
            if (req->params["id"] == "0") {
                core::EventReceiver::atNextTick([next] {
                    next("route");
                });
                return;
            }
            core::EventReceiver::atNextTick([next] {
                next();
            });
        },
        [] APPLICATION(req, res) {
            res->status(200).send("next(async route) primary for id=" + req->params["id"]);
        });
 
    app.get("/next/async/route/:id(\\d+)", [] APPLICATION(req, res) {
        res->status(200).send("next(async route) fallback for id=" + req->params["id"]);
    });
 
    const Router guarded;
    guarded.use([] MIDDLEWARE(req, res, next) {
        if (req->queries["allow"] != "true") {
            next("router");
            return;
        }
        next();
    });
    guarded.get("/resource", [] APPLICATION(req, res) {
        res->status(200).send("next(router) router handler");
    });
 
    app.use("/next/router", guarded);
    app.get("/next/router/:rest(.*)", [] APPLICATION(req, res) {
        res->status(403).send("next(router) denied by fallback");
    });
 
    const Router guardedAsync;
    guardedAsync.use([] MIDDLEWARE(req, res, next) {
        if (req->queries["allow"] != "true") {
            core::EventReceiver::atNextTick([next] {
                next("router");
            });
            return;
        }
        core::EventReceiver::atNextTick([next] {
            next();
        });
    });
    guardedAsync.get("/resource", [] APPLICATION(req, res) {
        res->status(200).send("next(async router) router handler");
    });
 
    app.use("/next/async/router", guardedAsync);
    app.get("/next/async/router/:rest(.*)", [] APPLICATION(req, res) {
        res->status(403).send("next(async router) denied by fallback");
    });
 
    app.getConfig()->setReuseAddress();
 
    app.listen(18080, [](const express::legacy::in::WebApp::SocketAddress& socketAddress, const core::socket::State& state) {
        switch (state) {
            case core::socket::State::OK:
                VLOG(1) << "testexpressnext listening on '" << socketAddress.toString() << "'";
                break;
            case core::socket::State::DISABLED:
                VLOG(1) << "testexpressnext disabled";
                break;
            case core::socket::State::ERROR:
                LOG(ERROR) << "testexpressnext " << socketAddress.toString() << ": " << state.what();
                break;
            case core::socket::State::FATAL:
                LOG(FATAL) << "testexpressnext " << socketAddress.toString() << ": " << state.what();
                break;
        }
    });
 
    NextTester nextTester;
    core::timer::Timer::singleshotTimer(
        [&nextTester] {
            nextTester.run();
        },
        1);
 
    const int rc = core::SNodeC::start();
    if (nextTester.getFailures() > 0) {
        LOG(ERROR) << "testexpressnext finished with failures=" << nextTester.getFailures();
        return 1;
    }
 
    LOG(INFO) << "testexpressnext finished successfully";
    return rc;
}

References core::EventReceiver::atNextTick(), core::socket::State::DISABLED, core::socket::State::ERROR, logger::ERROR, core::socket::State::FATAL, logger::FATAL, express::Router::get(), utils::MultibleAttributeInjector::getAttribute(), core::socket::Socket< ConfigT >::getConfig(), NextTester::getFailures(), logger::INFO, core::SNodeC::init(), net::in::stream::SocketServer< SocketAcceptorT, ConfigSocketServerT, SocketContextFactoryT, Args >::listen(), logger::LogMessage::LogMessage(), core::socket::State::OK, express::Next::operator()(), express::Request::params, NextTester::run(), express::Response::send(), utils::MultibleAttributeInjector::setAttribute(), net::in::stream::config::ConfigSocketServer::setReuseAddress(), core::timer::Timer::singleshotTimer(), core::SNodeC::start(), express::Response::status(), net::in::SocketAddress::toString(), express::WebAppT< ServerT >::WebAppT(), and core::socket::State::what().

Here is the call graph for this function: