tst_oauthhttpserverreplyhandler.cpp

// Copyright (C) 2017 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

#include <QtNetworkAuth/qoauth2authorizationcodeflow.h>

#include <QtNetworkAuth/qoauthhttpserverreplyhandler.h>

#include <QtCore>

#include <QtTest>

#include <QtNetwork>

#include "webserver.h"

typedef QSharedPointer<QNetworkReply> QNetworkReplyPtr;

static constexpr std::chrono::seconds Timeout(20);

using namespace Qt::StringLiterals;

class tst_QOAuthHttpServerReplyHandler : public QObject

    Q_OBJECT

private Q_SLOTS:

    void initTestCase();

    void tokenReplyErrors_data();

    void tokenReplyErrors();

    void tokenReplyContentFormats_data();

    void tokenReplyContentFormats();

    void callback_data();

    void callback();

    void callbackCaching();

    void callbackWithQuery();

    void badCallbackUris_data();

    void badCallbackUris();

    void badCallbackWrongMethod();

    void callbackDataReceived_data();

    void callbackDataReceived();

#ifndef QT_NO_SSL

    void localhostHttps();

#endif

    void callbackHost_data();

    void callbackHost();

private:

    QString testDataDir;

    [[nodiscard]] auto useTemporaryKeychain()

#ifndef QT_NO_SSL

        // Set the same environment value as CI uses, so that it's possible

        // to run autotests locally without macOS asking for permission to use

        // a private key in keychain (with TLS sockets)

        auto value = qEnvironmentVariable("QT_SSL_USE_TEMPORARY_KEYCHAIN");

        qputenv("QT_SSL_USE_TEMPORARY_KEYCHAIN", "1");

        auto envRollback = qScopeGuard([value](){

            if (value.isEmpty())

                qunsetenv("QT_SSL_USE_TEMPORARY_KEYCHAIN");

            else

                qputenv("QT_SSL_USE_TEMPORARY_KEYCHAIN", value.toUtf8());

});

        return envRollback;

#else

        // avoid maybe-unused warnings from callers

        return qScopeGuard([]{});

#endif // QT_NO_SSL

};

void tst_QOAuthHttpServerReplyHandler::initTestCase()

#ifdef BUILTIN_TESTDATA

    testDataDir = QStringLiteral(":/shared/");

#else

    testDataDir = QFileInfo(QFINDTESTDATA("certs")).absolutePath();

    if (testDataDir.isEmpty())

        testDataDir = QCoreApplication::applicationDirPath();

    if (!testDataDir.endsWith(QLatin1String("/")))

        testDataDir += QLatin1String("/");

#endif

void tst_QOAuthHttpServerReplyHandler::tokenReplyErrors_data()

    using Error = QAbstractOAuth::Error;

    QString tokenResponse;

    QTest::addColumn<QString>("tokenResponse");

    QTest::addColumn<Error>("expectedError");

    // Note: For some rows the 'warning detail' is left empty, because the detail is from

    // QNetworkReply, and could change over time

    QTest::addColumn<QString>("expectedWarningDetails");

    tokenResponse = "\0"_L1;

    QTest::addRow("network-error") << tokenResponse << Error::NetworkError << QString();

    tokenResponse = "HTTP/1.1 400 Bad Request\r\n"_L1

                    "\r\n"_L1;

    QTest::addRow("400-bad-request") << tokenResponse << Error::ServerError << QString();

    tokenResponse = "HTTP/1.1 200 OK\r\n"_L1

                    "\r\n"_L1;

    QTest::addRow("missing-content-type")

        << tokenResponse << Error::ServerError << u"Empty Content-type header"_s;

    tokenResponse = "HTTP/1.1 200 OK\r\n"_L1

                    "Content-Type: application/json\r\n"_L1

                    "\r\n"_L1;

    QTest::addRow("missing-body-data")

        << tokenResponse << Error::ServerError << u"No data received"_s;

    tokenResponse = "HTTP/1.1 200 OK\r\n"_L1

                    "Content-Type: application/json\r\n"_L1

                    "\r\n"_L1

                    "not valid json"_L1;

    QTest::addRow("content-not-valid-json")

        << tokenResponse << Error::ServerError << u"Received data is not a JSON object"_s;

    tokenResponse = "HTTP/1.1 200 OK\r\n"_L1

                    "Content-Type: application/json\r\n"_L1

                    "\r\n"_L1

                    "{}"_L1;

    QTest::addRow("empty-json")

        << tokenResponse << Error::ServerError << u"Received an empty JSON object"_s;

    tokenResponse = "HTTP/1.1 200 OK\r\n"_L1

                    "Content-Type: application/x-quantum-data-stream\r\n"_L1

                    "\r\n"_L1

                    "this statement is false"_L1;

    QTest::addRow("unknown-content-type")

        << tokenResponse << Error::ServerError << u"Unknown Content-type"_s;

void tst_QOAuthHttpServerReplyHandler::tokenReplyErrors()

    using Error = QAbstractOAuth::Error;

    QFETCH(const QString, tokenResponse);

    QFETCH(Error, expectedError);

    QFETCH(const QString, expectedWarningDetails);

    WebServer authorizationServer([&](const WebServer::HttpRequest &request, QTcpSocket *socket) {

        if (request.url.path() == QLatin1String("/tokenEndpoint"))

            socket->write(tokenResponse.toUtf8());

});

    constexpr auto expectWarning = [](const QString &warningText) {

        const QRegularExpression warning{u"Token request failed: \""_s + warningText};

        QTest::ignoreMessage(QtWarningMsg, warning);

};

    QOAuth2AuthorizationCodeFlow oauth2;

    QOAuthHttpServerReplyHandler replyHandler;

    oauth2.setReplyHandler(&replyHandler);

    oauth2.setAuthorizationUrl(QUrl{"authorizationEndpoint"_L1});

    oauth2.setTokenUrl(authorizationServer.url("tokenEndpoint"_L1));

    oauth2.setState("a-state"_L1);

    QSignalSpy tokenErrorSpy(&replyHandler, &QAbstractOAuthReplyHandler::tokenRequestErrorOccurred);

    oauth2.grant();

    // Conclude authorization stage so that authorization server gets a token request

    emit replyHandler.callbackReceived({{ "code"_L1, "a-code"_L1 }, { "state"_L1, "a-state"_L1 }});

    expectWarning(expectedWarningDetails);

    QTRY_COMPARE(tokenErrorSpy.size(), 1);

    QCOMPARE(tokenErrorSpy.at(0).at(0).value<Error>(), expectedError);

void tst_QOAuthHttpServerReplyHandler::tokenReplyContentFormats_data()

    QTest::addColumn<QByteArray>("tokenResponse");

    QByteArray tokenResponse =

            "HTTP/1.1 200 OK\r\n"

            "Content-Type: application/json\r\n"

            "\r\n"

R"(

                "access_token": "an-access-token",

                "refresh_token": "a-refresh-token",

                "expires_in": 3600

            })";

    QTest::addRow("application/json") << tokenResponse;

    tokenResponse =

        "HTTP/1.1 200 OK\r\n"

        "Content-Type: text/html\r\n"

        "\r\n"

        "access_token=an-access-token&"

        "refresh_token=a-refresh-token&"

        "expires_in=3600";

    QTest::addRow("text/html") << tokenResponse;

    tokenResponse =

        "HTTP/1.1 200 OK\r\n"

        "Content-Type: application/x-www-form-urlencoded\r\n"

        "\r\n"

        "access_token=an-access-token&"

        "refresh_token=a-refresh-token&"

        "expires_in=3600";

    QTest::addRow("application/x-www-form-urlencoded") << tokenResponse;

void tst_QOAuthHttpServerReplyHandler::tokenReplyContentFormats()

    QFETCH(const QByteArray, tokenResponse);

    WebServer authorizationServer([&](const WebServer::HttpRequest &request, QTcpSocket *socket) {

        if (request.url.path() == QLatin1String("/tokenEndpoint"))

            socket->write(tokenResponse);

});

    QOAuth2AuthorizationCodeFlow oauth2;

    QOAuthHttpServerReplyHandler replyHandler;

    oauth2.setReplyHandler(&replyHandler);

    oauth2.setAuthorizationUrl(QUrl{"authorizationEndpoint"_L1});

    oauth2.setTokenUrl(authorizationServer.url("tokenEndpoint"_L1));

    oauth2.setState("a-state"_L1);

    QSignalSpy tokenDataReceivedSpy(&replyHandler, &QOAuthHttpServerReplyHandler::tokensReceived);

    oauth2.grant();

    // Conclude authorization stage so that authorization server gets a token request

    emit replyHandler.callbackReceived({{ "code"_L1, "a-code"_L1 }, { "state"_L1, "a-state"_L1 }});

    QTRY_COMPARE_EQ(tokenDataReceivedSpy.size(), 1);

    const auto tokenData = tokenDataReceivedSpy.at(0).at(0).toMap();

    QCOMPARE_EQ(tokenData.size(), 3);

    QCOMPARE_EQ(oauth2.token(), "an-access-token"_L1);

    QCOMPARE_EQ(tokenData.value("access_token"_L1), oauth2.token());

    QCOMPARE_EQ(oauth2.refreshToken(), "a-refresh-token"_L1);

    QCOMPARE_EQ(tokenData.value("refresh_token"_L1), oauth2.refreshToken());

    QCOMPARE_EQ(tokenData.value("expires_in"_L1), 3600);

    QVERIFY(oauth2.expirationAt().isValid());

void tst_QOAuthHttpServerReplyHandler::callback_data()

    QTest::addColumn<QString>("callbackPath");

    QTest::addColumn<QString>("uri");

    QTest::addColumn<bool>("success");

    QTest::newRow("default") << QString() << QString() << true;

    QTest::newRow("empty") << "" << QString() << true;

    QTest::newRow("ascii-path") << "/foobar" << QString() << true;

    QTest::newRow("utf8-path") << "/áéíóú" << QString() << true;

    QTest::newRow("questionmark") << "/?" << QString() << true;

    QTest::newRow("hash") << "/#" << QString() << true;

    QTest::newRow("default-fragment") << QString() << "/#shouldntsee" << true;

    QTest::newRow("default-query") << QString() << "/?some=query" << true;

    QTest::newRow("default-wrongpath") << QString() << "/foo" << false;

    QTest::newRow("changed-wrongpath") << "/foo" << "/bar" << false;

    QTest::newRow("changed-wrongpathprefix") << "/foo" << "/foobar" << false;

    QTest::newRow("changed-wrongpathprefixpath") << "/foo" << "/foo/bar" << false;

void tst_QOAuthHttpServerReplyHandler::callback()

    QFETCH(QString, callbackPath);

    QFETCH(QString, uri);

    QFETCH(bool, success);

    int count = 0;

    QOAuthHttpServerReplyHandler replyHandler;

    QVERIFY(replyHandler.isListening());

    connect(&replyHandler, &QOAuthHttpServerReplyHandler::callbackReceived, this, [&](

            const QVariantMap &) {

        ++count;

        QTestEventLoop::instance().exitLoop();

});

    if (!callbackPath.isNull())

        replyHandler.setCallbackPath(callbackPath);

    QUrl callback(replyHandler.callback());

    QVERIFY(!callback.isEmpty());

    // maybe change the URL

    callback = callback.resolved(QUrl(uri));

    QNetworkAccessManager networkAccessManager;

    QNetworkRequest request(callback);

    QNetworkReplyPtr reply;

    reply.reset(networkAccessManager.get(request));

    connect(reply.get(), &QNetworkReply::finished, &QTestEventLoop::instance(),

            &QTestEventLoop::exitLoop);

    if (!success) {

        for (int i = 0; i < 2; ++i) // emitted more than once

            QTest::ignoreMessage(QtWarningMsg, "Invalid request: URL path doesn't match");

    QTestEventLoop::instance().enterLoop(Timeout);

    QCOMPARE(count > 0, success);

    QVERIFY(!QTestEventLoop::instance().timeout());

void tst_QOAuthHttpServerReplyHandler::callbackCaching()

    QOAuthHttpServerReplyHandler replyHandler;

    constexpr auto callbackPath = "/foo"_L1;

    constexpr auto callbackHost = "127.0.0.1"_L1;

    QVERIFY(replyHandler.isListening());

    replyHandler.setCallbackPath(callbackPath);

    QUrl callback{replyHandler.callback()};

    QCOMPARE(callback.path(), callbackPath);

    QCOMPARE(callback.host(), callbackHost);

    replyHandler.close();

    QVERIFY(!replyHandler.isListening());

    callback.setUrl(replyHandler.callback());

    // Should remain after close

    QCOMPARE(callback.path(), callbackPath);

    QCOMPARE(callback.host(), callbackHost);

    replyHandler.listen({QHostAddress::SpecialAddress::LocalHost});

    QVERIFY(replyHandler.isListening());

    callback.setUrl(replyHandler.callback());

    QCOMPARE(callback.path(), callbackPath);

    QCOMPARE(callback.host(), callbackHost);

void tst_QOAuthHttpServerReplyHandler::callbackWithQuery()

    int count = 0;

    QOAuthHttpServerReplyHandler replyHandler;

    QUrlQuery query("callback=test");

    QVERIFY(replyHandler.isListening());

    QUrl callback(replyHandler.callback());

    QVERIFY(!callback.isEmpty());

    callback.setQuery(query);

    connect(&replyHandler, &QOAuthHttpServerReplyHandler::callbackReceived, this, [&](

            const QVariantMap &parameters) {

        for (auto item : query.queryItems()) {

            QVERIFY(parameters.contains(item.first));

            QCOMPARE(parameters[item.first].toString(), item.second);

        count = parameters.size();

        QTestEventLoop::instance().exitLoop();

});

    QNetworkAccessManager networkAccessManager;

    QNetworkRequest request;

    request.setUrl(callback);

    QNetworkReplyPtr reply;

    reply.reset(networkAccessManager.get(request));

    connect(reply.get(), &QNetworkReply::finished, &QTestEventLoop::instance(),

            &QTestEventLoop::exitLoop);

    QTestEventLoop::instance().enterLoop(Timeout);

    QCOMPARE(count, query.queryItems().size());

    QVERIFY(!QTestEventLoop::instance().timeout());

void tst_QOAuthHttpServerReplyHandler::badCallbackUris_data()

    QTest::addColumn<QString>("uri");

    QTest::newRow("relative-path") << "foobar";

    QTest::newRow("encoded-slash") << "%2F";

    QTest::newRow("query") << "?some=query";

    QTest::newRow("full-url") << "http://localhost/";

    QTest::newRow("authority") << "//localhost";

    // requires QUrl fix

    //QTest::newRow("double-slash") << "//";

    //QTest::newRow("triple-slash") << "///";

void tst_QOAuthHttpServerReplyHandler::badCallbackUris()

    QFETCH(QString, uri);

    int count = 0;

    QOAuthHttpServerReplyHandler replyHandler;

    QVERIFY(replyHandler.isListening());

    connect(&replyHandler, &QOAuthHttpServerReplyHandler::callbackReceived, this, [&](

            const QVariantMap &) {

        ++count;

        QTestEventLoop::instance().exitLoop();

});

    QUrl callback(replyHandler.callback());

    QVERIFY(!callback.isEmpty());

    QTcpSocket socket;

    socket.connectToHost(QHostAddress::LocalHost, replyHandler.port());

    socket.write("GET " + uri.toLocal8Bit() + " HTTP/1.0\r\n"

                 "Host: localhost\r\n"

                 "\r\n");

    connect(&socket, &QTcpSocket::disconnected, &QTestEventLoop::instance(),

            &QTestEventLoop::exitLoop);

    QTest::ignoreMessage(QtWarningMsg, "Invalid request: invalid request-target");

    QTest::ignoreMessage(QtWarningMsg, "Invalid URL");

    QTestEventLoop::instance().enterLoop(Timeout);

    QCOMPARE(count, 0);

    QVERIFY(!QTestEventLoop::instance().timeout());

void tst_QOAuthHttpServerReplyHandler::badCallbackWrongMethod()

    int count = 0;

    QOAuthHttpServerReplyHandler replyHandler;

    QVERIFY(replyHandler.isListening());

    connect(&replyHandler, &QOAuthHttpServerReplyHandler::callbackReceived, this, [&](

            const QVariantMap &) {

        ++count;

        QTestEventLoop::instance().exitLoop();

});

    QUrl callback(replyHandler.callback());

    QVERIFY(!callback.isEmpty());

    QTcpSocket socket;

    socket.connectToHost(QHostAddress::LocalHost, replyHandler.port());

    socket.write("EHLO localhost\r\n");

    connect(&socket, &QTcpSocket::disconnected, &QTestEventLoop::instance(),

            &QTestEventLoop::exitLoop);

    QTest::ignoreMessage(QtWarningMsg, "Invalid operation EHLO");

    QTest::ignoreMessage(QtWarningMsg, "Invalid Method");

    QTestEventLoop::instance().enterLoop(Timeout);

    QCOMPARE(count, 0);

    QVERIFY(!QTestEventLoop::instance().timeout());

void tst_QOAuthHttpServerReplyHandler::callbackDataReceived_data()

    QTest::addColumn<QString>("redirect_response_data");

    QTest::addRow("no_data") << u""_s;

    QTest::addRow("query_parameters") << u"?k1=v1"_s;

void tst_QOAuthHttpServerReplyHandler::callbackDataReceived()

    QFETCH(const QString, redirect_response_data);

    QOAuthHttpServerReplyHandler replyHandler;

    QSignalSpy spy(&replyHandler, &QOAuthHttpServerReplyHandler::callbackDataReceived);

    QVERIFY(replyHandler.isListening());

    QString expected_response_data = replyHandler.callback() + redirect_response_data;

    QNetworkAccessManager networkAccessManager;

    QNetworkRequest request(QUrl{expected_response_data});

    QNetworkReplyPtr reply;

    reply.reset(networkAccessManager.get(request));

    QTRY_COMPARE(spy.size(), 1);

    QCOMPARE(spy.at(0).at(0).toByteArray(), expected_response_data.toLatin1());

#ifndef QT_NO_SSL

static QSslConfiguration createSslConfiguration(QString keyFileName, QString certificateFileName)

    QSslConfiguration configuration(QSslConfiguration::defaultConfiguration());

    QFile keyFile(keyFileName);

    if (keyFile.open(QIODevice::ReadOnly)) {

        QSslKey key(keyFile.readAll(), QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey);

        if (!key.isNull()) {

            configuration.setPrivateKey(key);

        } else {

            qCritical() << "Could not parse key: " << keyFileName;

    } else {

        qCritical() << "Could not find key: " << keyFileName;

    QList<QSslCertificate> localCert = QSslCertificate::fromPath(certificateFileName);

    if (!localCert.isEmpty() && !localCert.first().isNull()) {

        configuration.setLocalCertificate(localCert.first());

    } else {

        qCritical() << "Could not find certificate: " << certificateFileName;

    return configuration;

void tst_QOAuthHttpServerReplyHandler::localhostHttps()

    if (!QSslSocket::supportsSsl())

        QSKIP("This test will fail because the backend does not support TLS");

    auto rollback = useTemporaryKeychain();

    // erros may vary, depending on backend

    const QSet<QSslError::SslError> expectedSslErrors{ QSslError::SelfSignedCertificate,

                                                       QSslError::CertificateUntrusted,

                                                       QSslError::HostNameMismatch };

    auto serverConfig = createSslConfiguration(testDataDir + "certs/selfsigned-server.key",

                                               testDataDir + "certs/selfsigned-server.crt");

    QOAuthHttpServerReplyHandler replyHandler;

    replyHandler.setCallbackPath(u"/callback"_s);

    // Initially the handler is a plain 'http' handler

    QVERIFY(replyHandler.isListening());

    QCOMPARE(QUrl(replyHandler.callback()).scheme(), u"http"_s);

    // Calling listen() with SSL configuration makes handler to use 'https'

    QVERIFY(replyHandler.listen(serverConfig));

    QVERIFY(replyHandler.isListening());

    const QUrl redirectUrl{replyHandler.callback() + "?state=somestate&code=somecode"_L1};

    QCOMPARE(redirectUrl.scheme(), u"https"_s);

    // Issue a HTTP GET to the handler's server to mimic OAuth2 redirection event

    QSignalSpy spy(&replyHandler, &QOAuthHttpServerReplyHandler::callbackReceived);

    QNetworkAccessManager networkAccessManager;

    QNetworkRequest networkRequest(redirectUrl);

    QNetworkReplyPtr reply;

    connect(&networkAccessManager, &QNetworkAccessManager::sslErrors, this,

            [&expectedSslErrors](QNetworkReply *reply, const QList<QSslError> &errors) {

        for (const auto &error : errors)

            QVERIFY(expectedSslErrors.contains(error.error()));

        reply->ignoreSslErrors();

});

    reply.reset(networkAccessManager.get(networkRequest));

    QTRY_COMPARE(spy.size(), 1);

    const auto parameters = spy.at(0).at(0).toMap();

    QCOMPARE(parameters["state"_L1].toString(), u"somestate"_s);

    QCOMPARE(parameters["code"_L1].toString(), u"somecode"_s);

    // Call listen with invalid SSL configuration

    QTest::ignoreMessage(QtWarningMsg, "QSslConfiguration is null, cannot listen");

    QVERIFY(!replyHandler.listen(QSslConfiguration{}));

    QVERIFY(!replyHandler.isListening());

    // Call listen() without SSL configuration and verify it uses plain 'http' again

    QVERIFY(replyHandler.listen());

    QVERIFY(replyHandler.isListening());

    QCOMPARE(QUrl(replyHandler.callback()).scheme(), u"http"_s);

#endif // QT_NO_SSL

void tst_QOAuthHttpServerReplyHandler::callbackHost_data()

    QTest::addColumn<QHostAddress>("hostAddress");

    QTest::addColumn<QString>("hostName");

    QTest::addColumn<QUrl>("expectedCallback");

    const QString localhost = u"localhost"_s;

    const QUrl localhostCallback{u"http://localhost/"_s};

    const QString ipv4literal = u"127.0.0.1"_s;

    const QUrl ipv4literalCallback{u"http://127.0.0.1/"_s};

    const QString ipv6literal = u"::1"_s;

    const QUrl ipv6literalCallback{u"http://[::1]/"_s};

    const QString localnet = u"localhost.localnet"_s;

    const QUrl localnetCallback{u"http://localhost.localnet/"_s};

    QTest::newRow("default")

        << QHostAddress() << QString() << ipv4literalCallback;

    QTest::newRow("LocalHost")

        << QHostAddress(QHostAddress::SpecialAddress::LocalHost)

        << QString() << ipv4literalCallback;

    QTest::newRow("127.0.0.1")

        << QHostAddress(ipv4literal) << QString() << ipv4literalCallback;

    QTest::newRow("LocalHostIPv6")

        << QHostAddress(QHostAddress::SpecialAddress::LocalHostIPv6) << QString()

        << ipv6literalCallback;

    QTest::newRow("::1")

        << QHostAddress(ipv6literal) << QString() << ipv6literalCallback;

    QTest::newRow("AnyIPv4")

        << QHostAddress(QHostAddress::SpecialAddress::AnyIPv4) << QString() << localhostCallback;

    QTest::newRow("0.0.0.0")

        << QHostAddress("0.0.0.0") << QString() << localhostCallback;

    QTest::newRow("AnyIPv6")

        << QHostAddress(QHostAddress::SpecialAddress::AnyIPv6) << QString() << localhostCallback;

    QTest::newRow("::") << QHostAddress("::") << QString() << localhostCallback;

    // Following rows test that manually set hostname always takes precedence

    QTest::newRow("localhost.localnet(default)")

        << QHostAddress() << localnet << localnetCallback;

    QTest::newRow("localhost.localnet(AnyIPv4)")

        << QHostAddress(QHostAddress::SpecialAddress::AnyIPv4) << localnet << localnetCallback;

    QTest::newRow("localhost.localnet(AnyIPv6)")

        << QHostAddress(QHostAddress::SpecialAddress::AnyIPv6) << localnet << localnetCallback;

    QTest::newRow("localhost.localnet(127.0.0.1)")

        << QHostAddress(ipv4literal) << localnet << localnetCallback;

void tst_QOAuthHttpServerReplyHandler::callbackHost()

    QFETCH(const QHostAddress, hostAddress);

    QFETCH(const QString, hostName);

    QFETCH(QUrl, expectedCallback);

    QOAuthHttpServerReplyHandler replyHandler(hostAddress, 0); // 0 for any port

    if (!hostName.isEmpty())

        replyHandler.setCallbackHost(hostName);

    QVERIFY(replyHandler.isListening());

    expectedCallback.setPort(replyHandler.port());

    QCOMPARE(QUrl(replyHandler.callback()), expectedCallback);

    QCOMPARE(replyHandler.callbackHost(), expectedCallback.host());

QTEST_MAIN(tst_QOAuthHttpServerReplyHandler)

#include "tst_oauthhttpserverreplyhandler.moc"

Revision control

Copy as Markdown