MockLinkFTP.h

Go to the documentation of this file.

#pragma once
 
#include <optional>
 
#include <QtCore/QByteArray>
#include <QtCore/QFile>
#include <QtCore/QHash>
#include <QtCore/QObject>
#include <QtCore/QStringList>
 
#include "MAVLinkFTP.h"
 
class MockLink;
 
class MockLinkFTP : public QObject
{
    Q_OBJECT
 
public:
    MockLinkFTP(uint8_t systemIdServer, uint8_t componentIdServer, MockLink *mockLink);
    ~MockLinkFTP();
 
    void setFileList(const QStringList &fileList) { _fileList = fileList; }
 
    struct LogFile {
        QString name;       
        int size = 0;       
        uint32_t mtime = 0; 
    };
 
    void setLogFiles(const QList<LogFile> &logFiles);
 
    QList<LogFile> logFiles() const { return _logFiles; }
 
    QByteArray logFileContents(const QString &name) const;
 
    void setBurstReadDelayMs(int delayMs) { _burstReadDelayMs = delayMs; }
 
    void setParamPckEnabled(bool enabled) { _paramPckEnabled = enabled; }
 
    void setSingleSessionEnforced(bool enforced) { _singleSessionEnforced = enforced; }
 
    void openStaleSessionForTest();
 
    void setIgnoreResetSessions(bool ignore) { _ignoreResetSessions = ignore; }
 
    void setExpireSessionAfterBursts(int burstCount) { _expireSessionAfterBursts = burstCount; _burstsServed = 0; }
 
    void setDropBurstPacketOnce(uint32_t offset) { _dropBurstPacketOffset = offset; _dropBurstPacketPending = true; }
 
    void setReorderBurstPacketOnce(uint32_t offset) { _reorderBurstPacketOffset = offset; _reorderBurstPacketPending = true; }
 
    int openFileROCount() const { return _openFileROCount; }
 
    int readFileCount() const { return _readFileCount; }
 
    int lastBurstReadRequestSize() const { return _lastBurstReadRequestSize; }
 
    int lastReadFileRequestSize() const { return _lastReadFileRequestSize; }
 
    void mavlinkMessageReceived(const mavlink_message_t &message);
 
    void enableRandomDrops(bool enable) { _randomDropsEnabled = enable; }
 
    QStringList uploadedFiles() const { return _uploadedFiles.keys(); }
 
    QByteArray uploadedFileContents(const QString& remotePath) const { return _uploadedFiles.value(remotePath); }
 
    void clearUploadedFiles() { _uploadedFiles.clear(); }
 
    enum ErrorMode_t {
        errModeNone,                        
        errModeNoResponse,                  
        errModeNakResponse,                 
        errModeNoSecondResponse,            
        errModeNoSecondResponseAllowRetry,  
        errModeNakSecondResponse,           
        errModeBadSequence                  
    };
 
    void setErrorMode(ErrorMode_t errMode) { _errMode = errMode; };
 
    void setListDirectoryWithTimeSupported(bool supported) { _listDirectoryWithTimeSupported = supported; }
 
    void setListDirectoryWithTimeNakError(MavlinkFTP::ErrorCode_t error) { _listDirectoryWithTimeNakError = error; }
 
    void setLogDirEntriesWithTime(bool enabled) { _logDirEntriesWithTime = enabled; }
 
    void setLogDirDotEntries(bool enabled) { _logDirDotEntries = enabled; }
 
    static constexpr const ErrorMode_t rgFailureModes[] = {
        errModeNoResponse,
        errModeNakResponse,
        errModeNoSecondResponse,
        errModeNakSecondResponse,
        errModeBadSequence,
    };
 
    static constexpr const size_t cFailureModes = std::size(MockLinkFTP::rgFailureModes);
 
    static constexpr const char *sizeFilenamePrefix = "mocklink-size-";
 
    static constexpr uint32_t kMockModificationTime = 1700000000;
 
signals:
    void terminateCommandReceived();
 
    void resetCommandReceived();
 
private:
    void _sendAck(uint8_t targetSystemId, uint8_t targetComponentId, uint16_t seqNumber, MavlinkFTP::OpCode_t reqOpCode);
    void _sendNak(uint8_t targetSystemId, uint8_t targetComponentId, MavlinkFTP::ErrorCode_t error, uint16_t seqNumber, MavlinkFTP::OpCode_t reqOpCode);
    void _sendNakErrno(uint8_t targetSystemId, uint8_t targetComponentId, uint8_t nakErrno, uint16_t seqNumber, MavlinkFTP::OpCode_t reqOpCode);
    void _sendResponse(uint8_t targetSystemId, uint8_t targetComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _listCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber, bool withTime);
    void _openCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _createFileCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _openFileWOCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _readCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _burstReadCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _removeFileCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _terminateCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _resetCommand(uint8_t senderSystemId, uint8_t senderComponentId, uint16_t seqNumber);
    void _writeCommand(uint8_t senderSystemId, uint8_t senderComponentId, MavlinkFTP::Request *request, uint16_t seqNumber);
    void _finalizeActiveUpload();
    uint16_t _nextSeqNumber(uint16_t seqNumber) const;
    static QString _createTestTempFile(int size);
    QString _generateParamPck(bool withDefaults);
    QString _logFileTempPath(const QString &name);
    std::optional<QStringList> _logDirectoryEntries(const QString& subdir, bool withTime) const;
    static QByteArray _generateLogFileContents(const QString &name, int size);
 
    static void ensureNullTemination(MavlinkFTP::Request *request);
 
    const uint8_t _systemIdServer;              
    const uint8_t _componentIdServer;           
    MockLink *_mockLink;                        
 
    bool _lastReplyValid = false;
    bool _randomDropsEnabled = false;
    int _burstReadDelayMs = 0;                  
    ErrorMode_t _errMode = errModeNone;         
    bool _listDirectoryWithTimeSupported = true; 
    MavlinkFTP::ErrorCode_t _listDirectoryWithTimeNakError = MavlinkFTP::kErrUnknownCommand;
    bool _logDirEntriesWithTime = false;  
    bool _logDirDotEntries = false;       
    bool _paramPckEnabled = true;               
    bool _singleSessionEnforced = false;
    bool _ignoreResetSessions = false;
    int _expireSessionAfterBursts = 0;
    int _burstsServed = 0;
    uint32_t _dropBurstPacketOffset = 0;
    bool _dropBurstPacketPending = false;
    uint32_t _reorderBurstPacketOffset = 0;
    bool _reorderBurstPacketPending = false;
    int _openFileROCount = 0;
    int _readFileCount = 0;
    int _lastBurstReadRequestSize = -1;
    int _lastReadFileRequestSize = -1;
    mavlink_message_t _lastReply{};
    QFile _currentFile;
    QString _paramPckTempFile;
    struct UploadSession {
        bool active = false;
        QString remotePath;
        QByteArray buffer;
 
        void reset() {
            active = false;
            remotePath.clear();
            buffer.clear();
        }
    };
    UploadSession _uploadSession;
    QHash<QString, QByteArray> _uploadedFiles;
    QStringList _fileList;                      
    QList<LogFile> _logFiles;                   
    QHash<QString, QString> _logFileTempPaths;  
    uint16_t _lastReplySequence = 0;
 
    static constexpr uint8_t _sessionId = 1;    
};