QuasarApp/Snake
4
1
Fork 0
mirror of https://github.com/QuasarApp/Snake.git synced 2025-04-28 10:44:42 +00:00
Code Issues Projects Releases Wiki Activity

client refactor

Browse Source
This commit is contained in:
Andrei Yankovich 2019-03-05 00:48:32 +03:00
parent 5226e82acf
commit 3320263d77
16 changed files with 267 additions and 364 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
SnakeServer/ClientProtocol/ClientProtocol.pro
View File

@ -47,7 +47,8 @@ SOURCES += \
server.cpp \
streamers.cpp \
networkobjects.cpp \
networkclasses.cpp
networkclasses.cpp \
factorynetobjects.cpp
HEADERS += \
@ -59,5 +60,6 @@ HEADERS += \
config.h \
streamers.h \
networkobjects.h \
networkclasses.h
networkclasses.h \
factorynetobjects.h

73
SnakeServer/ClientProtocol/client.cpp
View File

@ -4,12 +4,13 @@
#include <QVariantMap>
#include <QDateTime>
#include <quasarapp.h>
#include "factorynetobjects.h"
namespace ClientProtocol {
bool Client::receiveData(QVariantMap map) {
auto command = static_cast<Command>(map.value("command", Undefined).toInt());
auto command = static_cast<NetworkClasses::Type>(map.value("command", Undefined).toInt());
auto type = static_cast<Type>(map.value("type", 2).toInt());
int index = map.value("sig", -1).toInt();
@ -18,7 +19,9 @@ bool Client::receiveData(QVariantMap map) {
#define idx static_cast<quint8>(index)
if (!(_requestsMap.contains(idx) && _requestsMap[idx].isEmpty())) {
auto expectedCommand = static_cast<NetworkClasses::Type>(_requestsMap[idx].value("expected", NetworkClasses::Undefined).toInt());
if (!expectedCommand || (command != expectedCommand) || type != Responke) {
QuasarAppUtils::Params::verboseLog("wrong sig of package");
return false;
}
@ -26,9 +29,10 @@ bool Client::receiveData(QVariantMap map) {
map["time"] = QDateTime::currentMSecsSinceEpoch();
_requestsMap[idx] = map;
if ((command == Login || command == PlayerData) && type == Responke) {
if (expectedCommand != NetworkClasses::Undefined &&
(command == expectedCommand) && type == Responke) {
_online = map.value("token", "").toByteArray().size() ==
_online = static_cast<quint32>(map.value("token", "").toByteArray().size()) ==
NetworkClasses::getSizeType(NetworkClasses::SHA256);
emit onlineChanged(_online);
}
@ -97,7 +101,7 @@ bool Client::sendPackage(Package &pkg) {
}
auto index = nextIndex();
_requestsMap[index] = {};
_requestsMap[index] = {{"expected", static_cast<const unsigned short>(pkg.hdr.command)}};
pkg.hdr.sig = index;
auto bytes = pkg.toBytes();
@ -110,6 +114,23 @@ unsigned char Client::nextIndex() {
return static_cast<unsigned char>((currentIndex++) % 256);
}
bool Client::ping() {
Package pcg;
auto map = FactoryNetObjects::build(NetworkClasses::Ping);
if (!pcg.create(map, Request)) {
return false;
};
if (!sendPackage(pcg)) {
return false;
}
return true;
}
bool Client::login(const QString &gmail, const QByteArray &pass) {
if (!pass.size()) {
return false;
@ -120,13 +141,12 @@ bool Client::login(const QString &gmail, const QByteArray &pass) {
}
Package pcg;
QVariantMap map;
map["gmail"] = gmail;
map["type"] = Request;
map["hash"] = pass;
map["command"] = Command::Login;
if (!pcg.create(map)) {
auto map = FactoryNetObjects::build(NetworkClasses::Login);
map["gmail"] = gmail;
map["hashPass"] = pass;
if (!pcg.create(map, Request)) {
return false;
};
@ -145,12 +165,11 @@ bool Client::updateData() {
}
Package pcg;
QVariantMap map;
map["type"] = Request;
map["token"] = _token;
map["command"] = Command::PlayerData;
if (!pcg.create(map)) {
auto map = FactoryNetObjects::build(NetworkClasses::UpdatePlayerData);
map["token"] = _token;
if (!pcg.create(map, Request)) {
return false;
};
@ -162,17 +181,18 @@ bool Client::updateData() {
return true;
}
bool Client::savaData(QVariantMap gameData) {
bool Client::savaData(const QList<int>& gameData) {
if (!isOnline()) {
return false;
}
Package pcg;
gameData["type"] = Request;
gameData["token"] = _token;
gameData["command"] = Command::ApplyData;
if (!pcg.create(gameData)) {
auto map = FactoryNetObjects::build(NetworkClasses::Game);
map["token"] = _token;
map["time"] = FactoryNetObjects::buildArray(gameData);
if (!pcg.create(map, Request)) {
return false;
};
@ -194,13 +214,12 @@ bool Client::getItem(int id) {
}
Package pcg;
QVariantMap map;
map["id"] = id;
map["type"] = Request;
map["token"] = _token;
map["command"] = Command::Item;
if (!pcg.create(map)) {
auto map = FactoryNetObjects::build(NetworkClasses::GetItem);
map["token"] = _token;
map["id"] = id;
if (!pcg.create(map, Request)) {
return false;
};

4
SnakeServer/ClientProtocol/client.h
View File

@ -29,6 +29,8 @@ private:
bool sendPackage(Package &pkg);
inline unsigned char nextIndex();
bool ping();
private slots:
void incommingData();
@ -57,7 +59,7 @@ public:
* @param gameData - data of lvl
* @return true if all good
*/
bool savaData(QVariantMap gameData);
bool savaData(const QList<int> &gameData);
/**
* @brief getItem

312
SnakeServer/ClientProtocol/clientprotocol.cpp
View File

@ -16,61 +16,63 @@ Header::Header() {
bool Header::isValid() const {
if (sizeof (*this) != 4) {
if (sizeof (*this) != 8) {
return false;
}
switch (command) {
case Ping: {
return isValidSize(static_cast<NetworkClasses::Type>(command) , size);
if (type > 1 || size > 0)
return false;
// switch (command) {
// case Ping: {
return true;
}
// if (type > 1 || size > 0)
// return false;
case Item: {
// return true;
// }
switch (type) {
case Request: return size == 36; // key sha256 (32byte) + id item 4
case Responke: return true;
}
// case Item: {
return false;
}
// switch (type) {
// case Request: return size == 36; // key sha256 (32byte) + id item 4
// case Responke: return true;
// }
case Login: {
// return false;
// }
switch (type) {
case Request: return size > 36; // key sha256 (32byte) + 4 size array + maxsize of name of gmail (64)
case Responke: return isValidSize(NetworkClasses::Player, size);
}
// case Login: {
return false;
}
// switch (type) {
// case Request: return size > 36; // key sha256 (32byte) + 4 size array + maxsize of name of gmail (64)
// case Responke: return isValidSize(NetworkClasses::Player, size);
// }
case PlayerData: {
// return false;
// }
switch (type) {
case Request: return size == 36; // key sha256 (32byte + size of array)
case Responke: return isValidSize(NetworkClasses::Player, size);
}
// case PlayerData: {
return false;
}
// switch (type) {
// case Request: return size == 36; // key sha256 (32byte + size of array)
// case Responke: return isValidSize(NetworkClasses::Player, size);
// }
case ApplyData: {
// return false;
// }
switch (type) {
case Request: return isValidSize(NetworkClasses::Game, size);; // key sha256 (32byte) + maxsize of name of gmail (64)
case Responke: return isValidSize(NetworkClasses::Player, size);
}
// case SaveData: {
return false;
}
// switch (type) {
// case Request: return isValidSize(NetworkClasses::Game, size);; // key sha256 (32byte) + maxsize of name of gmail (64)
// case Responke: return isValidSize(NetworkClasses::Player, size);
// }
default: return false;
}
// return false;
// }
// default: return false;
// }
}
void Header::reset() {
@ -88,7 +90,7 @@ bool Package::isValid() const {
return false;
}
return hdr.size == data.size();
return hdr.size == static_cast<unsigned int> (data.size());
}
bool Package::parse(QVariantMap& res) const {
@ -99,192 +101,28 @@ bool Package::parse(QVariantMap& res) const {
res["type"] = hdr.type;
res["sig"] = hdr.sig;
switch (hdr.command) {
case Ping: {
if (hdr.type == Responke) {
res["res"] = "Pong";
} else {
res["value"] = "Ping";
}
break;
}
QDataStream stream(data);
case Item: {
if (hdr.type == Responke) {
QDataStream stream(data);
if (!Streamers::read(stream, res)) {
return false;
}
} else {
res["token"] = data.left(32);
res["id"] = data.right(4).toInt();
}
break;
}
case Login: {
if (hdr.type == Responke) {
QDataStream stream(data);
if (!Streamers::read(stream, res)) {
return false;
}
} else {
QDataStream stream(data);
QString gmail;
QByteArray hash;
stream >> gmail;
stream >> hash;
res["gmail"] = gmail;
res["hash"] = hash;
}
break;
}
case PlayerData: {
if (hdr.type == Responke) {
QDataStream stream(data);
if (!Streamers::read(stream, res)) {
return false;
}
} else {
QDataStream stream(data);
QByteArray token;
stream >> token;
res["token"] = token;
}
break;
}
case ApplyData: {
if (hdr.type == Responke) {
if (data.size() != 1) {
return false;
}
res["res"] = static_cast<bool>(data.at(0));
} else {
QDataStream stream(data);
if (!Streamers::read(stream, res, NetworkClasses::Game)) {
return false;
}
}
break;
}
default:
if (!Streamers::read(stream, res, static_cast<NetworkClasses::Type>(hdr.command))) {
return false;
}
return true;
}
bool Package::create(const QVariantMap &map) {
bool Package::create(const QVariantMap &map, Type type) {
auto command = static_cast<unsigned char>(map.value("command", 0xff).toInt());
auto type = static_cast<unsigned char>(map.value("type", 0xff).toInt());
if (command == 0xff || type == 0xff) {
if (!(command & NetworkClasses::CustomType) || type == Type::Undefined) {
return false;
}
switch (command) {
case Ping: {
break;
}
case Item: {
if (type == Responke) {
QDataStream stream(&data, QIODevice::ReadWrite);
if (!Streamers::write(stream, map)) {
return false;
}
} else {
QDataStream stream(&data, QIODevice::ReadWrite);
QByteArray hash = map.value("token", "").toByteArray();
int id = map.value("id", 0).toInt();
if (hash.size() != 32 || !id) {
return false;
}
data.append(hash.data());
data.append(reinterpret_cast<char*>(&id), sizeof (id));
}
break;
}
case Login: {
if (type == Responke) {
QDataStream stream(&data, QIODevice::ReadWrite);
if (!Streamers::write(stream, map)) {
return false;
}
} else {
QDataStream stream(&data, QIODevice::ReadWrite);
QByteArray hash = map.value("hash", "").toByteArray();
QString gmail = map.value("gmail", "").toString();
if (hash.size() != 32 || gmail.isEmpty()) {
return false;
}
stream << gmail;
stream << hash;
}
break;
}
case PlayerData: {
if (type == Responke) {
QDataStream stream(&data, QIODevice::ReadWrite);
if (!Streamers::write(stream, map)) {
return false;
}
} else {
QDataStream stream(&data, QIODevice::ReadWrite);
QByteArray token = map.value("token", "").toByteArray();
stream << token;
}
break;
}
default: return false;
QDataStream stream(&data, QIODevice::ReadWrite);
if (!Streamers::write(stream, map)) {
return false;
}
hdr.command = command;
@ -308,52 +146,58 @@ void Package::reset() {
data.clear();
}
int getSize(NetworkClasses::Type type, bool isMax) {
unsigned int getSize(NetworkClasses::Type type, bool isMax) {
auto size = NetworkClasses::getSizeType(type);
if (size) {
return size;
}
if (type == NetworkClasses::String) {
return 255;
return (isMax)? 255: 5;
} else if (type == NetworkClasses::Variant) {
return 16;
return (isMax)? 16 : 6;
}
if (NetworkClasses::isArray(type)) {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
auto sizeItem = NetworkClasses::getSizeType(arrayType);
if (arrayType == NetworkClasses::String) {
sizeItem = (isMax)? 255: 5;
} else if (arrayType == NetworkClasses::Variant) {
sizeItem = (isMax)? 16 : 6;
}
constexpr int description = sizeof(int);
size += description + sizeItem * ((isMax)? MAX_SIZE: MIN_SIZE);
return size;
}
if (type & NetworkClasses::CustomType) {
constexpr auto baseSize = sizeof (short) + sizeof (int);
size += baseSize;
}
auto listPropertyes = networkObjects.value(type);
size = 0;
for (auto &&i : listPropertyes) {
if (NetworkClasses::isArray(i)) {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
auto sizeItem = NetworkClasses::getSizeType(arrayType);
if (arrayType == NetworkClasses::String) {
sizeItem = 255;
} else if (arrayType == NetworkClasses::Variant) {
sizeItem = 16;
}
size += sizeItem * ((isMax)? MAX_SIZE: MIN_SIZE);
}
size += getSize(i, isMax);
}
return size;
}
bool isStaticObject(NetworkClasses::Type type, int &max, int &min) {
max = getSize(type);
min = getSize(type, false);
bool isStaticObject(NetworkClasses::Type type, unsigned int &max, unsigned int &min) {
max = getSize(type, true);
min = getSize(type);
return max == min;
}
bool isValidSize(NetworkClasses::Type type, int size) {
int max;
int min;
bool isValidSize(NetworkClasses::Type type, unsigned int size) {
unsigned int max;
unsigned int min;
if (isStaticObject(type, max, min)) {
return size == max;
}

40
SnakeServer/ClientProtocol/clientprotocol.h
View File

@ -11,41 +11,43 @@
namespace ClientProtocol {
enum Type: unsigned char {
Responke = 0,
Request = 1
};
enum Command: unsigned char {
Undefined = 0x00,
Ping = 0x01,
Item = 0x02,
Login = 0x03,
PlayerData = 0x04,
ApplyData = 0x05
Responke = 0x01,
Request = 0x02,
Stream = 0x03,
};
int getSize(NetworkClasses::Type type, bool isMax = true);
bool isStaticObject(NetworkClasses::Type type, int& max, int &min);
bool isValidSize(NetworkClasses::Type type, int size);
//enum class Command: unsigned char {
// Undefined = 0x00,
// Ping = 0x01,
// Item = 0x02,
// Login = 0x03,
// PlayerData = 0x04,
// SaveData = 0x05
//};
unsigned int getSize(NetworkClasses::Type type, bool isMax = false);
bool isStaticObject(NetworkClasses::Type type, unsigned int &max, unsigned int &min);
bool isValidSize(NetworkClasses::Type type, unsigned int size);
/**
* @brief The Header struct 4 byte
* @brief The Header struct 8 byte
*/
struct CLIENTPROTOCOLSHARED_EXPORT Header {
/**
* @brief size - size of package data (not header)
*/
unsigned int size: 20;
unsigned int size: 32;
/**
* @brief type of package see Type
*/
unsigned char type: 1;
unsigned char type: 8;
/**
* @brief command of pacage see Command
*/
unsigned char command: 3;
unsigned short command: 16;
/**
* @brief sig
@ -104,7 +106,7 @@ struct CLIENTPROTOCOLSHARED_EXPORT Package {
* @param data - data of filled
* @return true if all done
*/
bool create(const QVariantMap &data);
bool create(const QVariantMap &data, Type type);
/**
* @brief toBytes

18
SnakeServer/ClientProtocol/factorynetobjects.cpp Normal file
View File

@ -0,0 +1,18 @@
#include "factorynetobjects.h"
#include "clientprotocol.h"
QVariantMap ClientProtocol::FactoryNetObjects::build(
ClientProtocol::NetworkClasses::Type type) {
auto obj = ClientProtocol::networkObjects.value(type);
QVariantMap res;
res ["command"] = type;
for (auto &&i: obj.keys()) {
res[i] = "";
}
return res;
}

29
SnakeServer/ClientProtocol/factorynetobjects.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef FACTORYNETOBJECTS_H
#define FACTORYNETOBJECTS_H
#include "clientprotocol_global.h"
#include "networkobjects.h"
namespace ClientProtocol {
class CLIENTPROTOCOLSHARED_EXPORT FactoryNetObjects {
public:
FactoryNetObjects() = delete;
static QVariantMap build(NetworkClasses::Type type);
template <typename T>
static QVariantList buildArray(const T& array) {
QVariantList res;
for (auto &&i : array) {
res.push_back(i);
}
return res;
}
};
}
#endif // FACTORYNETOBJECTS_H

2
SnakeServer/ClientProtocol/networkclasses.cpp
View File

@ -38,7 +38,7 @@ bool NetworkClasses::isVariant(NetworkClasses::Type type) {
return type == Variant;
}
int NetworkClasses::getSizeType(NetworkClasses::Type type) {
unsigned int NetworkClasses::getSizeType(NetworkClasses::Type type) {
switch (type) {
case Char:
case UChar: return sizeof (char);

14
SnakeServer/ClientProtocol/networkclasses.h
View File

@ -50,10 +50,14 @@ public:
BEGIN_CUSTOM_TYPE
// custom types
Snake = 0x0100,
Player = 0x0200,
Map = 0x0300,
Game = 0x0400,
Ping = 0x0100,
Snake = 0x0200,
Player = 0x0300,
Map = 0x0400,
Game = 0x0500,
Login = 0x0600,
UpdatePlayerData = 0x0700,
GetItem = 0x0800,
END_CUSTOM_TYPE
// general objects
@ -71,7 +75,7 @@ public:
static bool isNumber(Type);
static bool isStream(Type);
static int getSizeType(Type);
static unsigned int getSizeType(Type);
NetworkClasses();
};
}

16
SnakeServer/ClientProtocol/networkobjects.cpp
View File

@ -3,6 +3,8 @@
namespace ClientProtocol {
const QHash<NetworkClasses::Type, QMap<QString, NetworkClasses::Type>> networkObjects = {
{NetworkClasses::Type::Ping, {}
},
{NetworkClasses::Type::Snake, {
{"spead", NetworkClasses::UChar},
{"class", NetworkClasses::UChar},
@ -19,6 +21,15 @@ const QHash<NetworkClasses::Type, QMap<QString, NetworkClasses::Type>> networkOb
{"currentSnake", NetworkClasses::UInt}
}
},
{NetworkClasses::Type::Login, {
{"gmail", NetworkClasses::String},
{"hashPass", NetworkClasses::SHA256}
}
},
{NetworkClasses::Type::UpdatePlayerData, {
{"token", NetworkClasses::SHA256}
}
},
{NetworkClasses::Type::Map, {
{"lvl", NetworkClasses::UChar},
{"long", NetworkClasses::UShort},
@ -32,6 +43,11 @@ const QHash<NetworkClasses::Type, QMap<QString, NetworkClasses::Type>> networkOb
{"token", NetworkClasses::SHA256},
{"time", NetworkClasses::ArrayInt}
}
},
{NetworkClasses::Type::GetItem, {
{"token", NetworkClasses::SHA256},
{"id", NetworkClasses::Int}
}
}
};

30
SnakeServer/ClientProtocol/server.cpp
View File

@ -16,14 +16,14 @@ bool Server::parsePackage(const Package &pkg, QTcpSocket* sender) {
}
switch (pkg.hdr.command) {
case Ping: {
case NetworkClasses::Ping: {
if (pkg.hdr.type != Responke) {
return false;
}
Package resp;
resp.hdr.command = Ping;
resp.hdr.command = NetworkClasses::Ping;
resp.hdr.sig = pkg.hdr.sig;
auto bytes = resp.toBytes();
@ -34,23 +34,23 @@ bool Server::parsePackage(const Package &pkg, QTcpSocket* sender) {
break;
}
case Item:
case PlayerData:
case Login:{
// case Item:
// case PlayerData:
// case Login:{
if (pkg.hdr.type != Responke) {
return false;
}
// if (pkg.hdr.type != Responke) {
// return false;
// }
QVariantMap data;
if (!pkg.parse(data)) {
return false;
}
// QVariantMap data;
// if (!pkg.parse(data)) {
// return false;
// }
emit incomingReques (data, sender);
// emit incomingReques (data, sender);
break;
}
// break;
// }
default:{
QuasarAppUtils::Params::verboseLog("!responce not sendet!");

37
SnakeServer/ClientProtocol/streamers.cpp
View File

@ -12,32 +12,32 @@ namespace ClientProtocol {
NetworkClasses::Type Streamers::baseRead(QDataStream &stream, QVariantMap &map,
const NetworkClasses::Type checkType) {
unsigned int id;
unsigned short _class;
unsigned short command;
stream >> _class;
stream >> command;
stream >> id;
map["id"] = id;
map["class"] = _class;
map["command"] = command;
if (id) {
return NetworkClasses::Undefined;
}
return static_cast<NetworkClasses::Type>(_class & checkType);
return static_cast<NetworkClasses::Type>(command & checkType);
}
NetworkClasses::Type Streamers::baseWrite(QDataStream &stream, const QVariantMap &map) {
unsigned int id = map.value("id", 0).toUInt();
unsigned short _class = static_cast<unsigned short>(map.value("class").toUInt());
unsigned short command = static_cast<unsigned short>(map.value("command").toUInt());
if (id) {
return NetworkClasses::Undefined;
}
stream << _class;
stream << command;
stream << id;
return static_cast<NetworkClasses::Type>(_class & NetworkClasses::CustomType);
return static_cast<NetworkClasses::Type>(command & NetworkClasses::CustomType);
}
bool Streamers::read(QDataStream &stream, QVariantMap &map, const NetworkClasses::Type checkType) {
@ -68,27 +68,27 @@ bool Streamers::read(QDataStream &stream, QVariantMap &map, const NetworkClasses
map.insert(property, QVariant::fromValue(QByteArray(data, size)));
}
else if (NetworkClasses::isString(type)) {
else if (NetworkClasses::isString(typeItem)) {
QStringList val;
stream >> val;
map.insert(property, val);
}
else if (NetworkClasses::isArray(type)) {
else if (NetworkClasses::isArray(typeItem)) {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
if (type & NetworkClasses::String) {
if (arrayType & NetworkClasses::String) {
QStringList list;
stream >> list;
map.insert(property, list);
} else {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
QByteArray array;
stream >> array;
QVariantList varList;
auto size = NetworkClasses::getSizeType(arrayType);
auto size = static_cast<int>(NetworkClasses::getSizeType(arrayType));
for (int i = 0; i < array.size(); i+= size) {
varList.push_back(QVariant::fromValue(array.mid(i, size)));
}
@ -124,21 +124,24 @@ bool Streamers::write(QDataStream &stream, const QVariantMap &map) {
return false;
}
}
else if (NetworkClasses::isString(type)) {
else if (NetworkClasses::isString(typeItem)) {
stream << value.toString();
}
else if (NetworkClasses::isArray(type)) {
if (type & NetworkClasses::String) {
else if (NetworkClasses::isArray(typeItem)) {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
if (arrayType & NetworkClasses::String) {
stream << value.toStringList();
} else {
NetworkClasses::Type arrayType = static_cast<NetworkClasses::Type>(type & ~NetworkClasses::Array);
QByteArray array;
auto varList = value.toList();
for (auto &&i : varList) {
auto temp = i.toByteArray();
if (temp.size() != NetworkClasses::getSizeType(arrayType)) {
if (static_cast<quint32>(temp.size())
!= NetworkClasses::getSizeType(arrayType)) {
return false;
}

17
SnakeServer/serverProtocolTests/randomobjectfactory.cpp
View File

@ -1,17 +0,0 @@
#include "randomobjectfactory.h"
#include "networkobjects.h"
#include <clientprotocol.h>
QVariantMap RandomObjectFactory::build(ClientProtocol::NetworkClasses::Type type) {
auto obj = ClientProtocol::networkObjects.value(type);
QVariantMap res;
for (auto &&i: obj.keys()) {
auto size = ClientProtocol::getSize(obj.value(i));
QByteArray array;
array.append(size, 'c');
res[i] = array;
}
return res;
}

12
SnakeServer/serverProtocolTests/randomobjectfactory.h
View File

@ -1,12 +0,0 @@
#ifndef RANDOMOBJECTFACTORY_H
#define RANDOMOBJECTFACTORY_H
#include <networkobjects.h>
class RandomObjectFactory
{
public:
RandomObjectFactory() = delete;
static QVariantMap build(ClientProtocol::NetworkClasses::Type);
};
#endif // RANDOMOBJECTFACTORY_H

6
SnakeServer/serverProtocolTests/serverProtocolTests.pro
View File

@ -7,8 +7,7 @@ CONFIG -= app_bundle
TEMPLATE = app
SOURCES += \
tst_testsnakeserver.cpp \
randomobjectfactory.cpp
tst_testsnakeserver.cpp
CONFIG(release, debug|release): {
DESTDIR = $$PWD/build/release
@ -22,5 +21,4 @@ include($$PWD/../ServerProtocol/ServerProtocol.pri)
include($$PWD/../ClientProtocol/ClientProtocol.pri)
include($$PWD/../../SnakeUtils/SnakeUtils.pri)
HEADERS += \
randomobjectfactory.h
HEADERS +=

15
SnakeServer/serverProtocolTests/tst_testsnakeserver.cpp
View File

@ -7,7 +7,7 @@
#include <streamers.h>
#include <QCryptographicHash>
#include "randomobjectfactory.h"
#include "factorynetobjects.h"
// add necessary includes here
@ -126,10 +126,7 @@ void testSankeServer::testPingClientProtockol() {
});
ClientProtocol::Package pkg;
pkg.hdr.command = ClientProtocol::Ping;
QVERIFY(client->sendPackage(pkg));
client->ping();
QTimer::singleShot(1000, [&app](){
app.exit(0);
@ -180,18 +177,16 @@ void testSankeServer::testApplyData() {
ClientProtocol::Client cle;
QVERIFY(!cle.updateData());
auto token = QCryptographicHash::hash("testtoken", QCryptographicHash::Sha256);
cle._token = token;
cle._online = true;
QVERIFY(!cle.savaData(QVariantMap()));
QVERIFY(!cle.savaData(QList<int>()));
QVariantMap data = RandomObjectFactory::build(ClientProtocol::NetworkClasses::Game);
QVERIFY(cle.savaData(data));
QList<int> listData = {1};
QVERIFY(cle.savaData(listData));
}
void testSankeServer::testServerProtockol() {