QGCUASFileManagerTest.cc 15.4 KB
Newer Older
Don Gagne's avatar
Don Gagne committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*=====================================================================
 
 QGroundControl Open Source Ground Control Station
 
 (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 
 This file is part of the QGROUNDCONTROL project
 
 QGROUNDCONTROL is free 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.
 
 QGROUNDCONTROL 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 QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
 
 ======================================================================*/

#include "QGCUASFileManagerTest.h"

/// @file
27 28 29
///     @brief QGCUASFileManager unit test. Note: All code here assumes all work between
///             the unit test, mack mavlink file server and file manager is happening on
///             the same thread.
Don Gagne's avatar
Don Gagne committed
30 31 32
///
///     @author Don Gagne <don@thegagnes.com>

Don Gagne's avatar
Don Gagne committed
33 34
UT_REGISTER_TEST(QGCUASFileManagerUnitTest)

Don Gagne's avatar
Don Gagne committed
35
QGCUASFileManagerUnitTest::QGCUASFileManagerUnitTest(void) :
36
    _mockFileServer(_systemIdQGC, _systemIdServer),
Don Gagne's avatar
Don Gagne committed
37 38 39 40 41 42 43 44
    _fileManager(NULL),
    _multiSpy(NULL)
{
}

// Called once before all test cases are run
void QGCUASFileManagerUnitTest::initTestCase(void)
{
45 46 47 48 49 50 51 52 53 54
    _mockUAS = new MockUAS();
    Q_CHECK_PTR(_mockUAS);
    
    _mockUAS->setMockSystemId(_systemIdServer);
    _mockUAS->setMockMavlinkPlugin(&_mockFileServer);
}

void QGCUASFileManagerUnitTest::cleanupTestCase(void)
{
    delete _mockUAS;
Don Gagne's avatar
Don Gagne committed
55 56 57 58 59
}

// Called before every test case
void QGCUASFileManagerUnitTest::init(void)
{
Don Gagne's avatar
Don Gagne committed
60 61
    UnitTest::init();
    
Don Gagne's avatar
Don Gagne committed
62 63
    Q_ASSERT(_multiSpy == NULL);
    
64
    _fileManager = new QGCUASFileManager(NULL, _mockUAS, _systemIdQGC);
Don Gagne's avatar
Don Gagne committed
65 66
    Q_CHECK_PTR(_fileManager);
    
67 68 69 70
    // Reset any internal state back to normal
    _mockFileServer.setErrorMode(MockMavlinkFileServer::errModeNone);
    _fileListReceived.clear();
    
71
    connect(&_mockFileServer, &MockMavlinkFileServer::messageReceived, _fileManager, &QGCUASFileManager::receiveMessage);
Don Gagne's avatar
Don Gagne committed
72

73
    connect(_fileManager, &QGCUASFileManager::listEntry, this, &QGCUASFileManagerUnitTest::listEntry);
Don Gagne's avatar
Don Gagne committed
74

75
    _rgSignals[listEntrySignalIndex] = SIGNAL(listEntry(const QString&));
76
    _rgSignals[listCompleteSignalIndex] = SIGNAL(listComplete(void));
77 78 79

    _rgSignals[downloadFileLengthSignalIndex] = SIGNAL(downloadFileLength(unsigned int));
    _rgSignals[downloadFileCompleteSignalIndex] = SIGNAL(downloadFileComplete(void));
Don Gagne's avatar
Don Gagne committed
80
    
81 82
    _rgSignals[errorMessageSignalIndex] = SIGNAL(errorMessage(const QString&));

Don Gagne's avatar
Don Gagne committed
83 84 85 86 87 88 89 90
    _multiSpy = new MultiSignalSpy();
    Q_CHECK_PTR(_multiSpy);
    QCOMPARE(_multiSpy->init(_fileManager, _rgSignals, _cSignals), true);
}

// Called after every test case
void QGCUASFileManagerUnitTest::cleanup(void)
{
Don Gagne's avatar
Don Gagne committed
91 92
    UnitTest::cleanup();
    
Don Gagne's avatar
Don Gagne committed
93 94 95 96 97 98 99 100 101 102
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_fileManager);
    
    delete _fileManager;
    delete _multiSpy;
    
    _fileManager = NULL;
    _multiSpy = NULL;
}

103 104
/// @brief Connected to QGCUASFileManager listEntry signal in order to catch list entries
void QGCUASFileManagerUnitTest::listEntry(const QString& entry)
Don Gagne's avatar
Don Gagne committed
105 106
{
    // Keep a list of all names received so we can test it for correctness
107
    _fileListReceived += entry;
Don Gagne's avatar
Don Gagne committed
108 109 110 111 112 113 114 115 116 117 118 119
}


void QGCUASFileManagerUnitTest::_ackTest(void)
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
    // If the file manager doesn't receive an ack it will timeout and emit an error. So make sure
    // we don't get any error signals.
    QVERIFY(_fileManager->_sendCmdTestAck());
120
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
Don Gagne's avatar
Don Gagne committed
121
    QVERIFY(_multiSpy->checkNoSignals());
122
    
123
    // Setup for no response from ack. This should cause a timeout error
124 125 126 127
    _mockFileServer.setErrorMode(MockMavlinkFileServer::errModeNoResponse);
    QVERIFY(_fileManager->_sendCmdTestAck());
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
128 129 130 131 132 133 134
    _multiSpy->clearAllSignals();

    // Setup for a bad sequence number in the ack. This should cause an error;
    _mockFileServer.setErrorMode(MockMavlinkFileServer::errModeBadSequence);
    QVERIFY(_fileManager->_sendCmdTestAck());
    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
    _multiSpy->clearAllSignals();
Don Gagne's avatar
Don Gagne committed
135 136 137 138 139 140 141 142 143 144
}

void QGCUASFileManagerUnitTest::_noAckTest(void)
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
    // This should not get the ack back and timeout.
    QVERIFY(_fileManager->_sendCmdTestNoAck());
145
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
Don Gagne's avatar
Don Gagne committed
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
}

void QGCUASFileManagerUnitTest::_resetTest(void)
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
    // Send a reset command
    //  We should not get any signals back from this
    QVERIFY(_fileManager->_sendCmdReset());
    QVERIFY(_multiSpy->checkNoSignals());
}

void QGCUASFileManagerUnitTest::_listTest(void)
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
167
    // QGCUASFileManager::listDirectory signalling as follows:
168
    //  Emits a listEntry signal for each list entry
169 170 171 172 173
    //  Emits an errorMessage signal if:
    //      It gets a Nak back
    //      Sequence number is incorrrect on any response
    //      CRC is incorrect on any responses
    //      List entry is formatted incorrectly
174
    //  It is possible to get a number of good listEntry signals, followed by an errorMessage signal
175 176 177
    //  Emits listComplete after it receives the final list entry
    //      If an errorMessage signal is signalled no listComplete is signalled
    
Don Gagne's avatar
Don Gagne committed
178 179 180
    // Send a bogus path
    //  We should get a single resetStatusMessages signal
    //  We should get a single errorMessage signal
181
    _fileManager->listDirectory("/bogus");
182
    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
Don Gagne's avatar
Don Gagne committed
183 184
    _multiSpy->clearAllSignals();

185
    // Setup the mock file server with a valid directory list
Don Gagne's avatar
Don Gagne committed
186 187 188 189
    QStringList fileList;
    fileList << "Ddir" << "Ffoo" << "Fbar";
    _mockFileServer.setFileList(fileList);
    
190 191 192 193 194 195 196 197 198 199 200 201 202
    // Run through the various server side failure modes
    for (size_t i=0; i<MockMavlinkFileServer::cFailureModes; i++) {
        MockMavlinkFileServer::ErrorMode_t errMode = MockMavlinkFileServer::rgFailureModes[i];
        qDebug() << "Testing failure mode:" << errMode;
        _mockFileServer.setErrorMode(errMode);
        
        _fileManager->listDirectory("/");
        QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
        
        if (errMode == MockMavlinkFileServer::errModeNoSecondResponse || errMode == MockMavlinkFileServer::errModeNakSecondResponse) {
            // For simulated server errors on subsequent Acks, the first Ack will go through. This means we should have gotten some
            // partial results. In the case of the directory list test set, all entries fit into the first ack, so we should have
            // gotten back all of them.
203 204
            QCOMPARE(_multiSpy->getSpyByIndex(listEntrySignalIndex)->count(), fileList.count());
            _multiSpy->clearSignalByIndex(listEntrySignalIndex);
205 206
            
            // And then it should have errored out because the next list Request would have failed.
207
            QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
208 209 210
        } else {
            // For the simulated errors which failed the intial response we should not have gotten any results back at all.
            // Just an error.
211
            QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
212 213 214 215 216 217 218 219
        }

        // Set everything back to initial state
        _fileListReceived.clear();
        _multiSpy->clearAllSignals();
        _mockFileServer.setErrorMode(MockMavlinkFileServer::errModeNone);
    }

220
    // Send a list command at the root of the directory tree which should succeed    
221
    _fileManager->listDirectory("/");
222
    QCOMPARE(_multiSpy->checkSignalByMask(listCompleteSignalMask), true);
223
    QCOMPARE(_multiSpy->checkNoSignalByMask(errorMessageSignalMask), true);
224
    QCOMPARE(_multiSpy->getSpyByIndex(listEntrySignalIndex)->count(), fileList.count());
225
    QVERIFY(_fileListReceived == fileList);
Don Gagne's avatar
Don Gagne committed
226
}
227 228 229 230

void QGCUASFileManagerUnitTest::_validateFileContents(const QString& filePath, uint8_t length)
{
    QFile file(filePath);
231 232 233 234 235

    // Make sure file size is correct
    QCOMPARE(file.size(), (qint64)length);

    // Read data
236 237 238 239
    QVERIFY(file.open(QIODevice::ReadOnly));
    QByteArray bytes = file.readAll();
    file.close();
    
240 241
    // Validate file contents:
    //      Repeating 0x00, 0x01 .. 0xFF until file is full
242 243
    for (uint8_t i=0; i<bytes.length(); i++) {
        QCOMPARE((uint8_t)bytes[i], (uint8_t)(i & 0xFF));
244 245 246
    }
}

247
void QGCUASFileManagerUnitTest::_downloadTest(void)
248 249 250 251 252
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
253 254 255 256
    // QGCUASFileManager::downloadPath works as follows:
    //  Sends an Open Command to the server
    //      Expects an Ack Response back from the server with the correct sequence numner
    //          Emits an errorMessage signal if it gets a Nak back
257
    //      Emits an downloadFileLength signal with the file length if it gets back a good Ack
258
    //  Sends subsequent Read commands to the server until it gets the full file contents back
259
    //      Emits a downloadFileProgress for each read command ack it gets back
260 261
    //  Sends Terminate command to server when download is complete to close Open command
    //      Mock file server will signal terminateCommandReceived when it gets a Terminate command
262
    //  Sends downloadFileComplete signal to indicate the download is complete
263 264 265 266
    //  Emits an errorMessage signal if sequence number is incorrrect on any response
    //  Emits an errorMessage signal if CRC is incorrect on any responses
    
    // Expected signals if the Open command fails for any reason
267
    quint16 signalMaskOpenFailure = errorMessageSignalMask;
268 269

    // Expected signals if the Read command fails for any reason
270
    quint16 signalMaskReadFailure = downloadFileLengthSignalMask | errorMessageSignalMask;
271 272
    
    // Expected signals if the downloadPath command succeeds
273
    quint16 signalMaskDownloadSuccess = downloadFileLengthSignalMask | downloadFileCompleteSignalMask;
274

275 276 277 278
    // Send a bogus path
    //  We should get a single resetStatusMessages signal
    //  We should get a single errorMessage signal
    _fileManager->downloadPath("bogus", QDir::temp());
279
    QCOMPARE(_multiSpy->checkOnlySignalByMask(signalMaskOpenFailure), true);
280 281 282
    _multiSpy->clearAllSignals();
    
    // Clean previous downloads
283 284 285 286 287
    for (size_t i=0; i<MockMavlinkFileServer::cFileTestCases; i++) {
        QString filePath = QDir::temp().absoluteFilePath(MockMavlinkFileServer::rgFileTestCases[i].filename);
        if (QFile::exists(filePath)) {
            Q_ASSERT(QFile::remove(filePath));
        }
288
    }
289
    
290 291
    // We setup a spy on the Terminate command signal of the mock file server so that we can determine that a
    // Terminate command was correctly sent after the Open/Read commands complete.
292 293
    QSignalSpy terminateSpy(&_mockFileServer, SIGNAL(terminateCommandReceived()));
    
294
    // Run through the set of file test cases
295
    for (size_t i=0; i<MockMavlinkFileServer::cFileTestCases; i++) {
296
        const MockMavlinkFileServer::FileTestCase* testCase = &MockMavlinkFileServer::rgFileTestCases[i];
297 298 299
        
        // Run through the various failure modes for this test case
        for (size_t j=0; j<MockMavlinkFileServer::cFailureModes; j++) {
300
            
301 302 303 304
            MockMavlinkFileServer::ErrorMode_t errMode = MockMavlinkFileServer::rgFailureModes[j];
            qDebug() << "Testing failure mode:" << errMode;
            _mockFileServer.setErrorMode(errMode);
            
305
            _fileManager->downloadPath(testCase->filename, QDir::temp());
306 307 308 309 310
            QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
            
            if (errMode == MockMavlinkFileServer::errModeNoSecondResponse || errMode == MockMavlinkFileServer::errModeNakSecondResponse) {
                // For simulated server errors on subsequent Acks, the first Ack will go through. We must handle things differently depending
                // on whether the downloaded file requires multiple packets to complete the download.
311
                if (testCase->fMultiPacketResponse) {
312 313
                    // The downloaded file requires multiple Acks to complete. Hence first Read should have succeeded and sent one downloadFileComplete.
                    // Second Read should have failed.
314
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(signalMaskReadFailure), true);
315 316 317 318 319 320

                    // Open command succeeded, so we should get a Terminate for the open
                    QCOMPARE(terminateSpy.count(), 1);
                } else {
                    // The downloaded file fits within a single Ack response, hence there is no second Read issued.
                    // This should result in a successful download.
321
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(signalMaskDownloadSuccess), true);
322 323 324 325 326
                    
                    // We should get a single Terminate command to close the Open session
                    QCOMPARE(terminateSpy.count(), 1);
                    
                    // Validate file contents
327 328
                    QString filePath = QDir::temp().absoluteFilePath(testCase->filename);
                    _validateFileContents(filePath, testCase->length);
329 330 331 332
                }
            } else {
                // For all the other simulated server errors the Open command should have failed. Since the Open failed
                // there is no session to terminate, hence no Terminate in this case.
333
                QCOMPARE(_multiSpy->checkOnlySignalByMask(signalMaskOpenFailure), true);
334 335 336 337 338 339 340 341 342 343
                QCOMPARE(terminateSpy.count(), 0);
            }

            // Cleanup for next iteration
            _multiSpy->clearAllSignals();
            terminateSpy.clear();
            _mockFileServer.setErrorMode(MockMavlinkFileServer::errModeNone);
        }

        // Run what should be a successful file download test case. No servers errors are being simulated.
344 345 346 347 348 349
        _fileManager->downloadPath(testCase->filename, QDir::temp());

        // This should be a succesful download
        QCOMPARE(_multiSpy->checkOnlySignalByMask(signalMaskDownloadSuccess), true);
        
        // Make sure the file length coming back through the openFileLength signal is correct
350
        QVERIFY(_multiSpy->getSpyByIndex(downloadFileLengthSignalIndex)->takeFirst().at(0).toInt() == testCase->length);
351 352 353

        _multiSpy->clearAllSignals();
        
354
        // We should get a single Terminate command to close the session
355 356 357
        QCOMPARE(terminateSpy.count(), 1);
        terminateSpy.clear();
        
358
        // Validate file contents
359 360 361
        QString filePath = QDir::temp().absoluteFilePath(MockMavlinkFileServer::rgFileTestCases[i].filename);
        _validateFileContents(filePath, MockMavlinkFileServer::rgFileTestCases[i].length);
    }
362
}