FileManagerTest.cc 17.1 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/>.
 
 ======================================================================*/

/// @file
///     @author Don Gagne <don@thegagnes.com>

27
#include "FileManagerTest.h"
28
#include "MultiVehicleManager.h"
29
#include "UAS.h"
30
#include "QGCApplication.h"
31

32 33 34 35
FileManagerTest::FileManagerTest(void)
    : _fileServer(NULL)
    , _fileManager(NULL)
    , _multiSpy(NULL)
Don Gagne's avatar
Don Gagne committed
36
{
37

Don Gagne's avatar
Don Gagne committed
38 39 40
}

// Called before every test case
41
void FileManagerTest::init(void)
Don Gagne's avatar
Don Gagne committed
42
{
Don Gagne's avatar
Don Gagne committed
43 44
    UnitTest::init();
    
45
    _connectMockLink();
46 47 48

    _fileServer = _mockLink->getFileServer();
    QVERIFY(_fileServer != NULL);
Don Gagne's avatar
Don Gagne committed
49
    
50
    _fileManager = qgcApp()->toolbox()->multiVehicleManager()->activeVehicle()->uas()->getFileManager();
51 52 53
    QVERIFY(_fileManager != NULL);
    
    Q_ASSERT(_multiSpy == NULL);
Don Gagne's avatar
Don Gagne committed
54
    
55
    // Reset any internal state back to normal
56
    _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
57
    _fileListReceived.clear();
Don Gagne's avatar
Don Gagne committed
58

59
    connect(_fileManager, &FileManager::listEntry, this, &FileManagerTest::listEntry);
Don Gagne's avatar
Don Gagne committed
60

61
    _rgSignals[listEntrySignalIndex] = SIGNAL(listEntry(const QString&));
62 63
    _rgSignals[commandCompleteSignalIndex] = SIGNAL(commandComplete(void));
    _rgSignals[commandErrorSignalIndex] = SIGNAL(commandError(const QString&));
64

Don Gagne's avatar
Don Gagne committed
65 66 67 68 69 70
    _multiSpy = new MultiSignalSpy();
    Q_CHECK_PTR(_multiSpy);
    QCOMPARE(_multiSpy->init(_fileManager, _rgSignals, _cSignals), true);
}

// Called after every test case
71
void FileManagerTest::cleanup(void)
Don Gagne's avatar
Don Gagne committed
72 73 74 75
{
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_fileManager);
    
76 77
    // Disconnecting the link will prompt for log file save
    setExpectedFileDialog(getSaveFileName, QStringList());
78 79
    _disconnectMockLink();

80 81 82
    _fileServer = NULL;
    _fileManager = NULL;
    
Don Gagne's avatar
Don Gagne committed
83 84 85
    delete _multiSpy;
    
    _multiSpy = NULL;
Don Gagne's avatar
Don Gagne committed
86 87
    
    UnitTest::cleanup();
Don Gagne's avatar
Don Gagne committed
88 89
}

90 91
/// @brief Connected to FileManager listEntry signal in order to catch list entries
void FileManagerTest::listEntry(const QString& entry)
Don Gagne's avatar
Don Gagne committed
92 93
{
    // Keep a list of all names received so we can test it for correctness
94
    _fileListReceived += entry;
Don Gagne's avatar
Don Gagne committed
95 96 97
}


98
void FileManagerTest::_ackTest(void)
Don Gagne's avatar
Don Gagne committed
99 100 101 102 103 104 105 106
{
    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());
107
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
Don Gagne's avatar
Don Gagne committed
108
    QVERIFY(_multiSpy->checkNoSignals());
109
    
110
    // Setup for no response from ack. This should cause a timeout error
111
    _fileServer->setErrorMode(MockLinkFileServer::errModeNoResponse);
112
    QVERIFY(_fileManager->_sendCmdTestAck());
113 114
    _multiSpy->waitForSignalByIndex(commandErrorSignalIndex, _ackTimerTimeoutMsecs);
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
115 116 117
    _multiSpy->clearAllSignals();

    // Setup for a bad sequence number in the ack. This should cause an error;
118
    _fileServer->setErrorMode(MockLinkFileServer::errModeBadSequence);
119
    QVERIFY(_fileManager->_sendCmdTestAck());
120 121
    _multiSpy->waitForSignalByIndex(commandErrorSignalIndex, _ackTimerTimeoutMsecs);
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
122
    _multiSpy->clearAllSignals();
Don Gagne's avatar
Don Gagne committed
123 124
}

125
void FileManagerTest::_noAckTest(void)
Don Gagne's avatar
Don Gagne committed
126 127 128 129 130 131 132
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
    // This should not get the ack back and timeout.
    QVERIFY(_fileManager->_sendCmdTestNoAck());
133
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
134
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
Don Gagne's avatar
Don Gagne committed
135 136
}

137
void FileManagerTest::_listTest(void)
Don Gagne's avatar
Don Gagne committed
138 139 140 141 142
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
143
    // FileManager::listDirectory signalling as follows:
144
    //  Emits a listEntry signal for each list entry
145
    //  Emits an commandError signal if:
146 147 148 149
    //      It gets a Nak back
    //      Sequence number is incorrrect on any response
    //      CRC is incorrect on any responses
    //      List entry is formatted incorrectly
150 151 152
    //  It is possible to get a number of good listEntry signals, followed by an commandError signal
    //  Emits commandComplete after it receives the final list entry
    //      If an commandError signal is signalled no listComplete is signalled
153
    
Don Gagne's avatar
Don Gagne committed
154
    // Send a bogus path
155
    //  We should get a single commandError signal
156
    _fileManager->listDirectory("/bogus");
157 158
    _multiSpy->waitForSignalByIndex(commandErrorSignalIndex, _ackTimerTimeoutMsecs);
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
Don Gagne's avatar
Don Gagne committed
159 160
    _multiSpy->clearAllSignals();

161
    // Setup the mock file server with a valid directory list
Don Gagne's avatar
Don Gagne committed
162 163
    QStringList fileList;
    fileList << "Ddir" << "Ffoo" << "Fbar";
164 165 166 167 168 169 170 171 172 173 174 175 176
    _fileServer->setFileList(fileList);
    
    // Send a list command at the root of the directory tree which should succeed
    _fileManager->listDirectory("/");
    QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
    QCOMPARE(_multiSpy->checkSignalByMask(commandCompleteSignalMask), true);
    QCOMPARE(_multiSpy->checkNoSignalByMask(commandErrorSignalMask), true);
    QCOMPARE(_multiSpy->getSpyByIndex(listEntrySignalIndex)->count(), fileList.count());
    QVERIFY(_fileListReceived == fileList);
    
    // Set everything back to initial state
    _fileListReceived.clear();
    _multiSpy->clearAllSignals();
Don Gagne's avatar
Don Gagne committed
177
    
178
    // Run through the various server side failure modes
179 180
    for (size_t i=0; i<MockLinkFileServer::cFailureModes; i++) {
        MockLinkFileServer::ErrorMode_t errMode = MockLinkFileServer::rgFailureModes[i];
181
        qDebug() << "Testing failure mode:" << errMode;
182
        _fileServer->setErrorMode(errMode);
183 184 185 186
        
        _fileManager->listDirectory("/");
        QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
        
187
        if (errMode == MockLinkFileServer::errModeNoSecondResponse || errMode == MockLinkFileServer::errModeNakSecondResponse) {
188 189 190
            // 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.
191 192
            QCOMPARE(_multiSpy->getSpyByIndex(listEntrySignalIndex)->count(), fileList.count());
            _multiSpy->clearSignalByIndex(listEntrySignalIndex);
193 194
            
            // And then it should have errored out because the next list Request would have failed.
195
            QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
196 197 198
        } else {
            // For the simulated errors which failed the intial response we should not have gotten any results back at all.
            // Just an error.
199
            QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
200 201 202 203 204
        }

        // Set everything back to initial state
        _fileListReceived.clear();
        _multiSpy->clearAllSignals();
205
        _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
206
    }
Don Gagne's avatar
Don Gagne committed
207
}
208

209 210 211
#if 0
// Trying to write test code for read and burst mode download as well as implement support in MockLineFileServer reached a point
// of diminishing returns where the test code and mock server were generating more bugs in themselves than finding problems.
212
void FileManagerTest::_readDownloadTest(void)
213 214 215 216 217
{
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
218 219 220
    // We setup a spy on the Reset command signal of the mock file server so that we can determine that a
    // Reset command was correctly sent after the Open/Read commands complete.
    QSignalSpy resetSpy(_fileServer, SIGNAL(resetCommandReceived()));
221
    
222 223
    // Send a bogus path
    _fileManager->downloadPath("bogus", QDir::temp());
224 225
    _multiSpy->waitForSignalByIndex(commandErrorSignalIndex, _ackTimerTimeoutMsecs);
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
226
    _multiSpy->clearAllSignals();
227 228
    QCOMPARE(resetSpy.count(), 0);

229
    // Clean previous downloads
230 231
    for (size_t i=0; i<MockLinkFileServer::cFileTestCases; i++) {
        QString filePath = QDir::temp().absoluteFilePath(MockLinkFileServer::rgFileTestCases[i].filename);
232 233 234
        if (QFile::exists(filePath)) {
            Q_ASSERT(QFile::remove(filePath));
        }
235
    }
236
    
237
    // Run through the set of file test cases
238 239
    for (size_t i=0; i<MockLinkFileServer::cFileTestCases; i++) {
        const MockLinkFileServer::FileTestCase* testCase = &MockLinkFileServer::rgFileTestCases[i];
240 241
        
        // Run through the various failure modes for this test case
242 243
        for (size_t j=0; j<MockLinkFileServer::cFailureModes; j++) {
            qDebug() << "Testing successful download";
244
			
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
            // Run what should be a successful file download test case. No servers errors are being simulated.
            _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
            _fileManager->downloadPath(testCase->filename, QDir::temp());
            QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
            
            // This should be a succesful download
            QCOMPARE(_multiSpy->checkOnlySignalByMask(commandCompleteSignalMask), true);
            _multiSpy->clearAllSignals();
            
            // We should get a single Reset command to close the session
            QCOMPARE(resetSpy.count(), 1);
            resetSpy.clear();
            
            // Validate file contents
            QString filePath = QDir::temp().absoluteFilePath(MockLinkFileServer::rgFileTestCases[i].filename);
            _validateFileContents(filePath, MockLinkFileServer::rgFileTestCases[i].length);
            MockLinkFileServer::ErrorMode_t errMode = MockLinkFileServer::rgFailureModes[j];
            
263
            qDebug() << "Testing failure mode:" << errMode;
264
            _fileServer->setErrorMode(errMode);
265
            
266
            _fileManager->downloadPath(testCase->filename, QDir::temp());
267 268
            QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
            
269 270 271 272 273 274
            if (errMode == MockLinkFileServer::errModeNakResponse) {
                // This will Nak the Open call which will fail the download, but not cause a Reset
                QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
                QCOMPARE(resetSpy.count(), 0);
            } else {
                if (testCase->packetCount == 1 && (errMode == MockLinkFileServer::errModeNoSecondResponse || errMode == MockLinkFileServer::errModeNakSecondResponse)) {
275
                    // The downloaded file fits within a single Ack response, hence there is no second Read issued.
276 277 278
                    // This should result in a successful download, followed by a Reset
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandCompleteSignalMask), true);
                    QCOMPARE(resetSpy.count(), 1);
279 280
                    
                    // Validate file contents
281 282
                    QString filePath = QDir::temp().absoluteFilePath(testCase->filename);
                    _validateFileContents(filePath, testCase->length);
283 284 285 286
                } else {
                    // Download should have failed, followed by a aReset
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
                    QCOMPARE(resetSpy.count(), 1);
287 288 289 290 291
                }
            }

            // Cleanup for next iteration
            _multiSpy->clearAllSignals();
292 293
            resetSpy.clear();
            _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
294
        }
295
    }
296
}
297 298 299

void FileManagerTest::_streamDownloadTest(void)
{
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
    Q_ASSERT(_fileManager);
    Q_ASSERT(_multiSpy);
    Q_ASSERT(_multiSpy->checkNoSignals() == true);
    
    // We setup a spy on the Reset command signal of the mock file server so that we can determine that a
    // Reset command was correctly sent after the Open/Read commands complete.
    QSignalSpy resetSpy(_fileServer, SIGNAL(resetCommandReceived()));
    
    // Send a bogus path
    _fileManager->streamPath("bogus", QDir::temp());
    _multiSpy->waitForSignalByIndex(commandErrorSignalIndex, _ackTimerTimeoutMsecs);
    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
    _multiSpy->clearAllSignals();
    QCOMPARE(resetSpy.count(), 0);

    // Clean previous downloads
    for (size_t i=0; i<MockLinkFileServer::cFileTestCases; i++) {
        QString filePath = QDir::temp().absoluteFilePath(MockLinkFileServer::rgFileTestCases[i].filename);
        if (QFile::exists(filePath)) {
            Q_ASSERT(QFile::remove(filePath));
        }
    }
    
    // Run through the set of file test cases
    for (size_t i=0; i<MockLinkFileServer::cFileTestCases; i++) {
        const MockLinkFileServer::FileTestCase* testCase = &MockLinkFileServer::rgFileTestCases[i];
        
        // Run through the various failure modes for this test case
        for (size_t j=0; j<MockLinkFileServer::cFailureModes; j++) {
            qDebug() << "Testing successful download";
330
			
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
            // Run what should be a successful file download test case. No servers errors are being simulated.
            _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
            _fileManager->streamPath(testCase->filename, QDir::temp());
            QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
            
            // This should be a succesful download
            QCOMPARE(_multiSpy->checkOnlySignalByMask(commandCompleteSignalMask), true);
            _multiSpy->clearAllSignals();
            
            // We should get a single Reset command to close the session
            QCOMPARE(resetSpy.count(), 1);
            resetSpy.clear();
            
            // Validate file contents
            QString filePath = QDir::temp().absoluteFilePath(MockLinkFileServer::rgFileTestCases[i].filename);
            _validateFileContents(filePath, MockLinkFileServer::rgFileTestCases[i].length);
            MockLinkFileServer::ErrorMode_t errMode = MockLinkFileServer::rgFailureModes[j];
            
            qDebug() << "Testing failure mode:" << errMode;
            _fileServer->setErrorMode(errMode);
            
            _fileManager->downloadPath(testCase->filename, QDir::temp());
            QTest::qWait(_ackTimerTimeoutMsecs); // Let the file manager timeout
            
            if (errMode == MockLinkFileServer::errModeNakResponse) {
                // This will Nak the Open call which will fail the download, but not cause a Reset
                QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
                QCOMPARE(resetSpy.count(), 0);
            } else {
                if (testCase->packetCount == 1 && (errMode == MockLinkFileServer::errModeNoSecondResponse || errMode == MockLinkFileServer::errModeNakSecondResponse)) {
                    // The downloaded file fits within a single Ack response, hence there is no second Read issued.
                    // This should result in a successful download, followed by a Reset
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandCompleteSignalMask), true);
                    QCOMPARE(resetSpy.count(), 1);
                    
                    // Validate file contents
                    QString filePath = QDir::temp().absoluteFilePath(testCase->filename);
                    _validateFileContents(filePath, testCase->length);
                } else {
                    // Download should have failed, followed by a aReset
                    QCOMPARE(_multiSpy->checkOnlySignalByMask(commandErrorSignalMask), true);
                    QCOMPARE(resetSpy.count(), 1);
                }
            }

            // Cleanup for next iteration
            _multiSpy->clearAllSignals();
            resetSpy.clear();
            _fileServer->setErrorMode(MockLinkFileServer::errModeNone);
        }
    }
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
}

void FileManagerTest::_validateFileContents(const QString& filePath, uint8_t length)
{
	QFile file(filePath);
	
	// Make sure file size is correct
	QCOMPARE(file.size(), (qint64)length);
	
	// Read data
	QVERIFY(file.open(QIODevice::ReadOnly));
	QByteArray bytes = file.readAll();
	file.close();
	
	// Validate file contents:
	//      Repeating 0x00, 0x01 .. 0xFF until file is full
	for (uint8_t i=0; i<bytes.length(); i++) {
		QCOMPARE((uint8_t)bytes[i], (uint8_t)(i & 0xFF));
	}
}
402
#endif