StarMirror/qTox
1
0
Fork 0
mirror of https://github.com/qTox/qTox.git synced 2024-03-22 14:00:36 +08:00
Code Issues Projects Releases Wiki Activity

test(toxmedata): Add test for toxmedata class

Browse Source
This commit is contained in:
Diadlo 2017-10-09 00:12:55 +03:00
parent 9a543548e0
commit d3babb3fbe
No known key found for this signature in database
GPG Key ID: 5AF9F2E29107C727
2 changed files with 290 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cmake/Testing.cmake
View File

@ -21,4 +21,5 @@ endfunction()
auto_test(core toxpk) auto_test(core toxpk)
auto_test(core toxid) auto_test(core toxid)
auto_test(chatlog textformatter) auto_test(chatlog textformatter)
auto_test(net toxmedata)
auto_test(platform posixsignalnotifier) auto_test(platform posixsignalnotifier)

289
test/net/toxmedata_test.cpp Normal file
View File

@ -0,0 +1,289 @@
/*
Copyright © 2017 by The qTox Project Contributors
This file is part of qTox, a Qt-based graphical interface for Tox.
qTox is libre software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
qTox is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with qTox. If not, see <http://www.gnu.org/licenses/>.
*/
#include "src/net/toxmedata.h"
#include <ctime>
#include <QtTest/QtTest>
#include <QString>
#include <QJsonDocument>
#include <QJsonObject>
const QByteArray testToxId =
QByteArrayLiteral("\xC7\x71\x9C\x68\x08\xC1\x4B\x77\x34\x80\x04\x95\x6D\x1D\x98\x04"
"\x6C\xE0\x9A\x34\x37\x0E\x76\x08\x15\x0E\xAD\x74\xC3\x81\x5D\x30"
"\xC8\xBA\x3A\xB9\xBE\xB9");
const QByteArray testPublicKey =
QByteArrayLiteral("\xC7\x71\x9C\x68\x08\xC1\x4B\x77\x34\x80\x04\x95\x6D\x1D\x98\x04"
"\x6C\xE0\x9A\x34\x37\x0E\x76\x08\x15\x0E\xAD\x74\xC3\x81\x5D\x30");
class TestToxmeData : public QObject
{
Q_OBJECT
private slots:
void parsePublicKeyTest();
void encryptedJsonTest();
void lookupRequestTest();
void lookup_data();
void lookup();
void extractCode_data();
void extractCode();
void createAddressRequest();
void getPassTest_data();
void getPassTest();
void deleteAddressRequestTest();
};
/**
* @brief Test if parse public key works correctly.
*/
void TestToxmeData::parsePublicKeyTest()
{
ToxmeData data;
QString publicKeyStr = testPublicKey.toHex();
QString json = QStringLiteral(R"({"key": "%1"})").arg(publicKeyStr);
QByteArray result = data.parsePublicKey(json);
QCOMPARE(result, testPublicKey);
json = QStringLiteral("Some wrong string");
result = data.parsePublicKey(json);
QVERIFY(result.isEmpty());
}
/**
* @brief Test if generation action json with encrypted payload is correct.
*/
void TestToxmeData::encryptedJsonTest()
{
ToxmeData data;
int action = 123;
QByteArray encrypted{QStringLiteral("sometext").toLatin1()};
QByteArray nonce{QStringLiteral("nonce").toLatin1()};
QString text = data.encryptedJson(action, testPublicKey, encrypted, nonce);
QJsonObject json = QJsonDocument::fromJson(text.toLatin1()).object();
int actionRes = json["action"].toInt();
QCOMPARE(actionRes, 123);
QByteArray pkRes = QByteArray::fromHex(json["public_key"].toString().toLatin1());
QCOMPARE(pkRes, testPublicKey);
QByteArray encRes = QByteArray::fromBase64(json["encrypted"].toString().toLatin1());
QCOMPARE(encRes, encrypted);
QByteArray nonceRes = QByteArray::fromBase64(json["nonce"].toString().toLatin1());
QCOMPARE(nonceRes, nonce);
}
/**
* @brief Test if request for lookup generated correctly.
*/
void TestToxmeData::lookupRequestTest()
{
ToxmeData data;
QString json = QStringLiteral(R"({"action":3,"name":"testname"})");
QString result = data.lookupRequest("testname");
QCOMPARE(result, json);
}
Q_DECLARE_METATYPE(ToxId)
/**
* @brief Data function for lookup test.
*/
void TestToxmeData::lookup_data()
{
qRegisterMetaType<ToxId>("ToxId");
QTest::addColumn<QString>("input");
QTest::addColumn<ToxId>("result");
QString sToxId = testToxId.toHex();
QTest::newRow("Valid ToxId") << QStringLiteral(R"({"tox_id": "%1"})").arg(sToxId)
<< ToxId(testToxId);
QTest::newRow("Invalid ToxId") << QStringLiteral(R"({"tox_id": "SomeTextHere"})")
<< ToxId{};
QTest::newRow("Not json") << QStringLiteral("Not json string")
<< ToxId{};
}
/**
* @brief Test if ToxId parsed from lookup response correcly.
*/
void TestToxmeData::lookup()
{
QFETCH(QString, input);
QFETCH(ToxId, result);
ToxmeData data;
ToxId toxId = data.lookup(input);
QCOMPARE(result, toxId);
}
Q_DECLARE_METATYPE(ToxmeData::ExecCode)
/**
* @brief Data function for extractCode test.
*/
void TestToxmeData::extractCode_data()
{
qRegisterMetaType<ToxmeData::ExecCode>("ToxmeData::ExecCode");
QTest::addColumn<QString>("input");
QTest::addColumn<ToxmeData::ExecCode>("result");
QTest::newRow("Custom code") << QStringLiteral(R"({"c": 123})")
<< ToxmeData::ExecCode(123);
QTest::newRow("Ok code") << QStringLiteral(R"({"c": 0})")
<< ToxmeData::ExecCode::Ok;
QTest::newRow("String code") << QStringLiteral(R"({"c": "string here"})")
<< ToxmeData::ExecCode::IncorrectResponse;
QTest::newRow("Invalid code") << QStringLiteral(R"({"c": text})")
<< ToxmeData::ExecCode::IncorrectResponse;
QTest::newRow("Not json") << QStringLiteral("Not json string")
<< ToxmeData::ExecCode::ServerError;
}
/**
* @brief Test if exec code extracts correctly.
*/
void TestToxmeData::extractCode()
{
QFETCH(QString, input);
QFETCH(ToxmeData::ExecCode, result);
ToxmeData data;
ToxmeData::ExecCode code = data.extractCode(input);
QCOMPARE(result, code);
}
/**
* @brief Test if request for address creation is correct.
*/
void TestToxmeData::createAddressRequest()
{
ToxmeData data;
ToxId id{testToxId};
QString name{"Test address"};
QString bio{"Bio text"};
bool keepPrivate = true;
int timestamp = static_cast<int>(time(nullptr));
QString text = data.createAddressRequest(id, name, bio, keepPrivate);
QJsonObject json = QJsonDocument::fromJson(text.toLatin1()).object();
QByteArray toxIdData = QByteArray::fromHex(json["tox_id"].toString().toLatin1());
ToxId toxIdRes{toxIdData};
QCOMPARE(toxIdRes, id);
QString nameRes = json["name"].toString();
QCOMPARE(nameRes, name);
bool privRes = json["privacy"].toInt();
QCOMPARE(privRes, privRes);
QString bioRes = json["bio"].toString();
QCOMPARE(bioRes, bio);
int timeRes = json["timestamp"].toInt();
// Test will be failed if `createAddressRequest` will take more
// than 100 seconds
QVERIFY(qAbs(timeRes - timestamp) < 100);
}
/**
* @brief Data function for getPassTest.
*/
void TestToxmeData::getPassTest_data()
{
qRegisterMetaType<ToxmeData::ExecCode>("ToxmeData::ExecCode");
QTest::addColumn<QString>("input");
QTest::addColumn<QString>("result");
QTest::addColumn<ToxmeData::ExecCode>("code");
QTest::newRow("Valid password") << QStringLiteral(R"({"password": "123qwe"})")
<< QStringLiteral("123qwe")
<< ToxmeData::ExecCode::Ok;
QTest::newRow("Null password") << QStringLiteral(R"({"password": null})")
<< QStringLiteral("")
<< ToxmeData::ExecCode::Updated;
QTest::newRow("Valid password with null") << QStringLiteral(R"({"password": "null"})")
<< QStringLiteral("null")
<< ToxmeData::ExecCode::Ok;
// ERROR: password value with invalid text, but started with 'null' interpreted as Update
#if 0
QTest::newRow("Invalid null password") << QStringLiteral(R"({"password": nulla})")
<< QStringLiteral("")
<< ToxmeData::ExecCode::IncorrectResponse;
#endif
QTest::newRow("Invalid int password") << QStringLiteral(R"({"password": 123})")
<< QStringLiteral("")
<< ToxmeData::ExecCode::IncorrectResponse;
QTest::newRow("Not json") << QStringLiteral("Not json")
<< QStringLiteral("")
<< ToxmeData::ExecCode::NoPassword;
}
/**
* @brief Test if password extraction is correct.
*/
void TestToxmeData::getPassTest()
{
QFETCH(QString, input);
QFETCH(QString, result);
QFETCH(ToxmeData::ExecCode, code);
ToxmeData data;
ToxmeData::ExecCode resCode = ToxmeData::ExecCode::Ok;
QString password = data.getPass(input, resCode);
QCOMPARE(password, result);
QCOMPARE(resCode, code);
}
/**
* @brief Test if request for address deletation generated correct.
*/
void TestToxmeData::deleteAddressRequestTest()
{
ToxmeData data;
ToxPk pk{testPublicKey};
int timestamp = static_cast<int>(time(nullptr));
QString text = data.deleteAddressRequest(pk);
QJsonObject json = QJsonDocument::fromJson(text.toLatin1()).object();
QByteArray pkRes = QByteArray::fromHex(json["public_key"].toString().toLatin1());
QCOMPARE(pkRes, testPublicKey);
int timeRes = json["timestamp"].toInt();
// Test will be failed if `deleteAddressRequest` will take more
// than 100 seconds
QVERIFY(qAbs(timeRes - timestamp) < 100);
}
QTEST_GUILESS_MAIN(TestToxmeData)
#include "toxmedata_test.moc"