1 #pragma once
2 #include <QDebug>
3 #include <QSharedPointer>
4 #include <QTimer>
5 #include "qredisclient/command.h"
6 #include "qredisclient/response.h"
7 #include "qredisclient/transporters/abstracttransporter.h"
8 #include "qredisclient/connection.h"
9 
10 class DummyTransporter : public RedisClient::AbstractTransporter {
11   Q_OBJECT
12  public:
DummyTransporter(RedisClient::Connection * c)13   DummyTransporter(RedisClient::Connection* c)
14       : RedisClient::AbstractTransporter(c),
15         initCalls(0),
16         disconnectCalls(0),
17         addCommandCalls(0),
18         cancelCommandsCalls(0),
19         m_catchParsedResponses(false) {
20     connect(c, &RedisClient::Connection::log,
21             [](const QString& log) { qDebug() << "Connection log:" << log; });
22 
23     connect(c, &RedisClient::Connection::error,
24             [](const QString& log) { qDebug() << "Connection error:" << log; });
25 
26     infoReply = QString("redis_version:999.999.999\n");
27   }
28 
29   int initCalls;
30   int disconnectCalls;
31   int addCommandCalls;
32   int cancelCommandsCalls;
33 
34   QString infoReply;
35 
setFakeResponses(const QStringList & respList)36   void setFakeResponses(const QStringList& respList) {
37     for (QString response : respList) {
38       m_parser.feedBuffer(response.toLatin1());
39       fakeResponses.push_back(m_parser.getNextResponse());
40     }
41   }
42 
addFakeResponse(const QString & r)43   void addFakeResponse(const QString& r) {
44       m_parser.feedBuffer(r.toLatin1());
45       fakeResponses.push_back(m_parser.getNextResponse());
46   }
47 
setFakeReadBuffer(const QByteArray & buf)48   void setFakeReadBuffer(const QByteArray& buf) {
49     m_fakeBuffer = buf;
50     m_catchParsedResponses = true;
51   }
52 
53   QList<RedisClient::Command> executedCommands;
54   QList<RedisClient::Response> fakeResponses;
55   QList<RedisClient::Response> catchedResponses;
56 
57  public slots:
addCommands(const QList<RedisClient::Command> & commands)58   void addCommands(const QList<RedisClient::Command>& commands) override {
59     addCommandCalls += commands.size();
60     RedisClient::AbstractTransporter::addCommands(commands);
61   }
62 
init()63   void init() {
64     initCalls++;
65 
66     // Init command tested after socket connection
67     RedisClient::Response info(RedisClient::Response::Type::String,
68                                infoReply);
69     fakeResponses.push_front(info);
70 
71     RedisClient::Response r(RedisClient::Response::Type::String, "PONG");
72     fakeResponses.push_front(r);
73 
74     emit connected();
75   }
disconnect()76   virtual void disconnect() { disconnectCalls++; }
cancelCommands(QObject *)77   virtual void cancelCommands(QObject*) override { cancelCommandsCalls++; }
78 
79  protected:
runCommand(const RedisClient::Command & cmd)80   virtual void runCommand(const RedisClient::Command& cmd) override {
81     executedCommands.push_back(cmd);
82 
83     RedisClient::Response resp;
84 
85     if (fakeResponses.size() > 0) {
86       resp = fakeResponses.first();
87       fakeResponses.removeFirst();
88 
89       qDebug() << "cmd: " << cmd.getRawString();
90       qDebug() << "fake resp: " << resp.value().toByteArray();
91 
92     } else {
93       qDebug() << "Unexpected command: " << cmd.getRawString();
94       qDebug() << "Previous commands:";
95       for (auto cmd : executedCommands) {
96         qDebug() << "\t" << cmd.getRawString();
97       }
98       resp = RedisClient::Response();
99     }
100 
101     m_runningCommands.enqueue(
102         QSharedPointer<RunningCommand>(new RunningCommand(cmd)));
103 
104     sendResponse(resp);
105   }
106 
sendResponse(const RedisClient::Response & response)107   void sendResponse(const RedisClient::Response& response) {
108     if (m_catchParsedResponses) {
109       catchedResponses.append(response);
110     } else {
111       AbstractTransporter::sendResponse(response);
112     }
113   }
114 
reconnect()115   void  reconnect() override {
116       qDebug() << "Fake reconnect";
117       emit connected();
118   }
isInitialized()119   bool isInitialized() const override { return true; }
isSocketReconnectRequired()120   bool isSocketReconnectRequired() const override { return false; }
canReadFromSocket()121   bool canReadFromSocket() override { return !m_fakeBuffer.isEmpty(); }
readFromSocket()122   QByteArray readFromSocket() override { return m_fakeBuffer; }
initSocket()123   void initSocket() override {}
connectToHost()124   bool connectToHost() override { return true; }
sendCommand(const QByteArray &)125   void sendCommand(const QByteArray&) override {}
126 
127  private:
128   QByteArray m_fakeBuffer;
129   bool m_catchParsedResponses;
130 };
131