1 /**
2 * UGENE - Integrated Bioinformatics Tools.
3 * Copyright (C) 2008-2021 UniPro <ugene@unipro.ru>
4 * http://ugene.net
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version 2
9 * of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19 * MA 02110-1301, USA.
20 */
21
22 #include "SequenceDbiSQLiteSpecificUnitTests.h"
23
24 #include <U2Core/DNAAlphabet.h>
25 #include <U2Core/U2Mod.h>
26 #include <U2Core/U2OpStatusUtils.h>
27 #include <U2Core/U2SequenceDbi.h>
28 #include <U2Core/U2SequenceUtils.h>
29
30 #include <U2Formats/SQLiteDbi.h>
31 #include <U2Formats/SQLiteObjectDbi.h>
32
33 namespace U2 {
34
35 TestDbiProvider SequenceSQLiteSpecificTestData::dbiProvider = TestDbiProvider();
36 const QString &SequenceSQLiteSpecificTestData::SQLITE_SEQUENCE_DB_URL("sqlite-sequence-dbi.ugenedb");
37 SQLiteDbi *SequenceSQLiteSpecificTestData::sqliteDbi = nullptr;
38
39 const QString SequenceSQLiteSpecificTestData::TEST_SEQUENCE_NAME = "Test sequence";
40
init()41 void SequenceSQLiteSpecificTestData::init() {
42 SAFE_POINT(nullptr == sqliteDbi, "sqliteDbi has already been initialized!", );
43
44 // Get URL
45 bool ok = dbiProvider.init(SQLITE_SEQUENCE_DB_URL, false);
46 SAFE_POINT(ok, "Dbi provider failed to initialize!", );
47
48 U2Dbi *dbi = dbiProvider.getDbi();
49 QString url = dbi->getDbiRef().dbiId;
50 dbiProvider.close();
51
52 // Init DBI
53 sqliteDbi = new SQLiteDbi();
54 QHash<QString, QString> initProperties;
55 initProperties[U2DbiOptions::U2_DBI_OPTION_URL] = url;
56 U2OpStatusImpl os;
57 sqliteDbi->init(initProperties, QVariantMap(), os);
58 SAFE_POINT_OP(os, );
59
60 // Get sequences IDs
61 QList<U2DataId> ids = sqliteDbi->getObjectDbi()->getObjects(U2Type::Sequence, 0, U2DbiOptions::U2_DBI_NO_LIMIT, os);
62 SAFE_POINT_OP(os, );
63 }
64
shutdown()65 void SequenceSQLiteSpecificTestData::shutdown() {
66 if (nullptr != sqliteDbi) {
67 U2OpStatusImpl os;
68 sqliteDbi->shutdown(os);
69 SAFE_POINT_OP(os, );
70 delete sqliteDbi;
71 sqliteDbi = nullptr;
72 }
73 }
74
getSQLiteDbi()75 SQLiteDbi *SequenceSQLiteSpecificTestData::getSQLiteDbi() {
76 if (nullptr == sqliteDbi) {
77 init();
78 }
79 return sqliteDbi;
80 }
81
createTestSequence(bool enableModTracking,qint64 seqLength,U2OpStatus & os)82 U2DataId SequenceSQLiteSpecificTestData::createTestSequence(bool enableModTracking, qint64 seqLength, U2OpStatus &os) {
83 U2Sequence sequence;
84 sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
85 sequence.visualName = TEST_SEQUENCE_NAME;
86 if (false == enableModTracking) {
87 sequence.trackModType = NoTrack;
88 } else {
89 sequence.trackModType = TrackOnUpdate;
90 }
91 sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
92 CHECK_OP(os, "");
93
94 QByteArray seq;
95 seq.fill('A', seqLength);
96
97 sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, U2_REGION_MAX, seq, QVariantMap(), os);
98 CHECK_OP(os, "");
99
100 return sequence.id;
101 }
102
createTestSequence(bool enableModTracking,const QByteArray & seqData,U2OpStatus & os)103 U2DataId SequenceSQLiteSpecificTestData::createTestSequence(bool enableModTracking, const QByteArray &seqData, U2OpStatus &os) {
104 U2Sequence sequence;
105 sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
106 sequence.visualName = "Test sequence";
107 if (false == enableModTracking) {
108 sequence.trackModType = NoTrack;
109 } else {
110 sequence.trackModType = TrackOnUpdate;
111 }
112 sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
113 CHECK_OP(os, "");
114
115 sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, U2_REGION_MAX, seqData, QVariantMap(), os);
116 CHECK_OP(os, "");
117
118 return sequence.id;
119 }
120
getModStepsNum(const U2DataId & objId,U2OpStatus & os)121 qint64 SequenceSQLiteSpecificTestData::getModStepsNum(const U2DataId &objId, U2OpStatus &os) {
122 SQLiteReadQuery qModSteps("SELECT COUNT(*) FROM SingleModStep WHERE object = ?1", sqliteDbi->getDbRef(), os);
123 qModSteps.bindDataId(1, objId);
124 return qModSteps.selectInt64();
125 }
126
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_noModTrack)127 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_noModTrack) {
128 U2OpStatusImpl os;
129 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
130
131 U2Sequence sequence;
132 sequence.alphabet = BaseDNAAlphabetIds::NUCL_DNA_DEFAULT();
133 sequence.visualName = SequenceSQLiteSpecificTestData::TEST_SEQUENCE_NAME;
134 sequence.trackModType = NoTrack;
135 sqliteDbi->getSequenceDbi()->createSequenceObject(sequence, "", os);
136 CHECK_NO_ERROR(os);
137
138 // Some base values
139 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(sequence.id, os);
140 CHECK_NO_ERROR(os);
141 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(sequence.id, os);
142 CHECK_NO_ERROR(os);
143 CHECK_EQUAL(sequence.trackModType, baseSeqModType, "sequence track mod type");
144 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(sequence.id, os);
145 CHECK_NO_ERROR(os);
146
147 // Prepare test data
148 QByteArray data("AAAAAAA");
149 U2Region region = U2_REGION_MAX;
150 QVariantMap hints;
151
152 // Call test function
153 sqliteDbi->getSequenceDbi()->updateSequenceData(sequence.id, region, data, hints, os);
154 CHECK_NO_ERROR(os);
155
156 // Verify version
157 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(sequence.id, os);
158 CHECK_NO_ERROR(os);
159 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
160
161 // Verify mod type
162 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(sequence.id, os);
163 CHECK_NO_ERROR(os);
164 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
165
166 // Verify mod steps num
167 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(sequence.id, os);
168 CHECK_NO_ERROR(os);
169 CHECK_EQUAL(baseModStepsNum, finalModStepsNum, "mod steps num");
170
171 // Verify sequence object
172 U2Sequence finalSeq = sqliteDbi->getSequenceDbi()->getSequenceObject(sequence.id, os);
173 CHECK_NO_ERROR(os);
174 CHECK_EQUAL(sequence.alphabet.id, finalSeq.alphabet.id, "sequence alphabet");
175 CHECK_EQUAL(sequence.visualName, finalSeq.visualName, "sequence name");
176
177 // Verify sequence data
178 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(sequence.id, U2_REGION_MAX, os);
179 CHECK_NO_ERROR(os);
180 CHECK_EQUAL(data, QString(finalData), "sequence data");
181 }
182
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint)183 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint) {
184 U2OpStatusImpl os;
185 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
186
187 qint64 seqLength = 0;
188 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
189 CHECK_NO_ERROR(os);
190
191 // Some base values
192 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
193 CHECK_NO_ERROR(os);
194 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
195 CHECK_NO_ERROR(os);
196 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
197 CHECK_NO_ERROR(os);
198
199 // Prepare test data
200 QByteArray data("AAAAAAA");
201 U2Region region = U2_REGION_MAX;
202 QVariantMap hints;
203 hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
204
205 // Call test function
206 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
207 CHECK_NO_ERROR(os);
208
209 // Verify version
210 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
211 CHECK_NO_ERROR(os);
212 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
213
214 // Verify mod type
215 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
216 CHECK_NO_ERROR(os);
217 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
218
219 // Verify mod steps num
220 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
221 CHECK_NO_ERROR(os);
222 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
223
224 // Verify modSteps
225 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
226 CHECK_NO_ERROR(os);
227 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
228 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
229 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
230 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
231
232 // Verify sequence data
233 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
234 CHECK_NO_ERROR(os);
235 CHECK_EQUAL(data, QString(finalData), "sequence data");
236 }
237
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint)238 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint) {
239 U2OpStatusImpl os;
240 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
241
242 qint64 seqLength = 0;
243 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
244 CHECK_NO_ERROR(os);
245
246 // Some base values
247 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
248 CHECK_NO_ERROR(os);
249 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
250 CHECK_NO_ERROR(os);
251 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
252 CHECK_NO_ERROR(os);
253
254 // Prepare test data
255 QByteArray data("AAAAAAA");
256 U2Region region = U2_REGION_MAX;
257 QVariantMap hints;
258
259 // Call test function
260 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
261 CHECK_NO_ERROR(os);
262
263 // Verify version
264 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
265 CHECK_NO_ERROR(os);
266 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
267
268 // Verify mod type
269 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
270 CHECK_NO_ERROR(os);
271 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
272
273 // Verify mod steps num
274 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
275 CHECK_NO_ERROR(os);
276 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
277
278 // Verify modSteps
279 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
280 CHECK_NO_ERROR(os);
281 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
282 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
283 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
284 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
285
286 // Verify sequence data
287 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
288 CHECK_NO_ERROR(os);
289 CHECK_EQUAL(data, QString(finalData), "sequence data");
290 }
291
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear)292 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear) {
293 U2OpStatusImpl os;
294 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
295
296 QByteArray baseData("AAAAAAA");
297 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
298 CHECK_NO_ERROR(os);
299
300 // Some base values
301 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
302 CHECK_NO_ERROR(os);
303 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
304 CHECK_NO_ERROR(os);
305 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
306 CHECK_NO_ERROR(os);
307
308 // Prepare test data
309 QByteArray data("");
310 U2Region region = U2_REGION_MAX;
311 QVariantMap hints;
312
313 // Call test function
314 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
315 CHECK_NO_ERROR(os);
316
317 // Verify version
318 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
319 CHECK_NO_ERROR(os);
320 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
321
322 // Verify mod type
323 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
324 CHECK_NO_ERROR(os);
325 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
326
327 // Verify mod steps num
328 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
329 CHECK_NO_ERROR(os);
330 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
331
332 // Verify modSteps
333 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
334 CHECK_NO_ERROR(os);
335 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
336 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
337 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
338 CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
339
340 // Verify sequence data
341 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
342 CHECK_NO_ERROR(os);
343 CHECK_EQUAL(data, QString(finalData), "sequence data");
344 }
345
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin)346 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin) {
347 U2OpStatusImpl os;
348 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
349
350 QByteArray baseData("AAAAAAA");
351 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
352 CHECK_NO_ERROR(os);
353
354 // Some base values
355 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
356 CHECK_NO_ERROR(os);
357 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
358 CHECK_NO_ERROR(os);
359 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
360 CHECK_NO_ERROR(os);
361
362 // Prepare test data
363 QByteArray data("CC");
364 U2Region region = U2Region(0, 3);
365 QVariantMap hints;
366
367 // Prepare expected data
368 QByteArray expectedData = "CCAAAA";
369
370 // Call test function
371 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
372 CHECK_NO_ERROR(os);
373
374 // Verify version
375 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
376 CHECK_NO_ERROR(os);
377 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
378
379 // Verify mod type
380 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
381 CHECK_NO_ERROR(os);
382 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
383
384 // Verify mod steps num
385 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
386 CHECK_NO_ERROR(os);
387 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
388
389 // Verify modSteps
390 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
391 CHECK_NO_ERROR(os);
392 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
393 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
394 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
395 CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
396
397 // Verify sequence data
398 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
399 CHECK_NO_ERROR(os);
400 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
401 }
402
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle)403 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle) {
404 U2OpStatusImpl os;
405 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
406
407 QByteArray baseData("AAAAAAA");
408 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
409 CHECK_NO_ERROR(os);
410
411 // Some base values
412 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
413 CHECK_NO_ERROR(os);
414 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
415 CHECK_NO_ERROR(os);
416 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
417 CHECK_NO_ERROR(os);
418
419 // Prepare test data
420 QByteArray data("CC");
421 U2Region region = U2Region(2, 3);
422 QVariantMap hints;
423
424 // Prepare expected data
425 QByteArray expectedData = "AACCAA";
426
427 // Call test function
428 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
429 CHECK_NO_ERROR(os);
430
431 // Verify version
432 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
433 CHECK_NO_ERROR(os);
434 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
435
436 // Verify mod type
437 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
438 CHECK_NO_ERROR(os);
439 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
440
441 // Verify mod steps num
442 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
443 CHECK_NO_ERROR(os);
444 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
445
446 // Verify modSteps
447 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
448 CHECK_NO_ERROR(os);
449 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
450 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
451 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
452 CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
453
454 // Verify sequence data
455 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
456 CHECK_NO_ERROR(os);
457 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
458 }
459
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength)460 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength) {
461 U2OpStatusImpl os;
462 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
463
464 QByteArray baseData("AAAAAAA");
465 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
466 CHECK_NO_ERROR(os);
467
468 // Some base values
469 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
470 CHECK_NO_ERROR(os);
471 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
472 CHECK_NO_ERROR(os);
473 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
474 CHECK_NO_ERROR(os);
475
476 // Prepare test data
477 QByteArray data("CC");
478 U2Region region = U2Region(2, 2);
479 QVariantMap hints;
480 hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
481
482 // Prepare expected data
483 QByteArray expectedData = "AACCAAA";
484
485 // Call test function
486 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
487 CHECK_NO_ERROR(os);
488
489 // Verify version
490 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
491 CHECK_NO_ERROR(os);
492 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
493
494 // Verify mod type
495 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
496 CHECK_NO_ERROR(os);
497 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
498
499 // Verify mod steps num
500 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
501 CHECK_NO_ERROR(os);
502 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
503
504 // Verify modSteps
505 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
506 CHECK_NO_ERROR(os);
507 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
508 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
509 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
510 CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
511
512 // Verify sequence data
513 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
514 CHECK_NO_ERROR(os);
515 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
516 }
517
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end)518 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end) {
519 U2OpStatusImpl os;
520 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
521
522 QByteArray baseData("AAAAAAA");
523 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
524 CHECK_NO_ERROR(os);
525
526 // Some base values
527 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
528 CHECK_NO_ERROR(os);
529 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
530 CHECK_NO_ERROR(os);
531 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
532 CHECK_NO_ERROR(os);
533
534 // Prepare test data
535 QByteArray data("CC");
536 U2Region region = U2Region(4, 3);
537 QVariantMap hints;
538
539 // Prepare expected data
540 QByteArray expectedData = "AAAACC";
541
542 // Call test function
543 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
544 CHECK_NO_ERROR(os);
545
546 // Verify version
547 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
548 CHECK_NO_ERROR(os);
549 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
550
551 // Verify mod type
552 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
553 CHECK_NO_ERROR(os);
554 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
555
556 // Verify mod steps num
557 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
558 CHECK_NO_ERROR(os);
559 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
560
561 // Verify modSteps
562 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
563 CHECK_NO_ERROR(os);
564 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
565 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
566 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
567 CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
568
569 // Verify sequence data
570 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
571 CHECK_NO_ERROR(os);
572 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
573 }
574
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint_undo)575 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint_undo) {
576 U2OpStatusImpl os;
577 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
578
579 qint64 seqLength = 0;
580 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
581 CHECK_NO_ERROR(os);
582
583 // Some base values
584 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
585 CHECK_NO_ERROR(os);
586 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
587 CHECK_NO_ERROR(os);
588 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
589 CHECK_NO_ERROR(os);
590
591 // Prepare test data
592 QByteArray data("AAAAAAA");
593 U2Region region = U2_REGION_MAX;
594 QVariantMap hints;
595 hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
596
597 // Call test function, undo changes
598 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
599 CHECK_NO_ERROR(os);
600 sqliteDbi->getObjectDbi()->undo(seqId, os);
601 CHECK_NO_ERROR(os);
602
603 // Verify version
604 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
605 CHECK_NO_ERROR(os);
606 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
607
608 // Verify mod type
609 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
610 CHECK_NO_ERROR(os);
611 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
612
613 // Verify mod steps num
614 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
615 CHECK_NO_ERROR(os);
616 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
617
618 // Verify modSteps
619 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
620 CHECK_NO_ERROR(os);
621 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
622 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
623 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
624 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
625
626 // Verify sequence data
627 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
628 CHECK_NO_ERROR(os);
629 CHECK_EQUAL("", QString(finalData), "sequence data");
630 }
631
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint_undo)632 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint_undo) {
633 U2OpStatusImpl os;
634 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
635
636 qint64 seqLength = 0;
637 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
638 CHECK_NO_ERROR(os);
639
640 // Some base values
641 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
642 CHECK_NO_ERROR(os);
643 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
644 CHECK_NO_ERROR(os);
645 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
646 CHECK_NO_ERROR(os);
647
648 // Prepare test data
649 QByteArray data("AAAAAAA");
650 U2Region region = U2_REGION_MAX;
651 QVariantMap hints;
652
653 // Call test function, undo changes
654 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
655 CHECK_NO_ERROR(os);
656 sqliteDbi->getObjectDbi()->undo(seqId, os);
657 CHECK_NO_ERROR(os);
658
659 // Verify version
660 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
661 CHECK_NO_ERROR(os);
662 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
663
664 // Verify mod type
665 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
666 CHECK_NO_ERROR(os);
667 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
668
669 // Verify mod steps num
670 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
671 CHECK_NO_ERROR(os);
672 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
673
674 // Verify modSteps
675 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
676 CHECK_NO_ERROR(os);
677 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
678 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
679 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
680 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
681
682 // Verify sequence data
683 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
684 CHECK_NO_ERROR(os);
685 CHECK_EQUAL("", QString(finalData), "sequence data");
686 }
687
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear_undo)688 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear_undo) {
689 U2OpStatusImpl os;
690 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
691
692 QByteArray baseData("AAAAAAA");
693 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
694 CHECK_NO_ERROR(os);
695
696 // Some base values
697 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
698 CHECK_NO_ERROR(os);
699 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
700 CHECK_NO_ERROR(os);
701 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
702 CHECK_NO_ERROR(os);
703
704 // Prepare test data
705 QByteArray data("");
706 U2Region region = U2_REGION_MAX;
707 QVariantMap hints;
708
709 // Call test function, undo changes
710 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
711 CHECK_NO_ERROR(os);
712 sqliteDbi->getObjectDbi()->undo(seqId, os);
713 CHECK_NO_ERROR(os);
714
715 // Verify version
716 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
717 CHECK_NO_ERROR(os);
718 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
719
720 // Verify mod type
721 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
722 CHECK_NO_ERROR(os);
723 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
724
725 // Verify mod steps num
726 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
727 CHECK_NO_ERROR(os);
728 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
729
730 // Verify modSteps
731 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
732 CHECK_NO_ERROR(os);
733 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
734 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
735 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
736 CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
737
738 // Verify sequence data
739 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
740 CHECK_NO_ERROR(os);
741 CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
742 }
743
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin_undo)744 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin_undo) {
745 U2OpStatusImpl os;
746 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
747
748 QByteArray baseData("AAAAAAA");
749 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
750 CHECK_NO_ERROR(os);
751
752 // Some base values
753 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
754 CHECK_NO_ERROR(os);
755 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
756 CHECK_NO_ERROR(os);
757 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
758 CHECK_NO_ERROR(os);
759
760 // Prepare test data
761 QByteArray data("CC");
762 U2Region region = U2Region(0, 3);
763 QVariantMap hints;
764
765 // Call test function, undo changes
766 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
767 CHECK_NO_ERROR(os);
768 sqliteDbi->getObjectDbi()->undo(seqId, os);
769 CHECK_NO_ERROR(os);
770
771 // Verify version
772 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
773 CHECK_NO_ERROR(os);
774 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
775
776 // Verify mod type
777 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
778 CHECK_NO_ERROR(os);
779 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
780
781 // Verify mod steps num
782 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
783 CHECK_NO_ERROR(os);
784 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
785
786 // Verify modSteps
787 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
788 CHECK_NO_ERROR(os);
789 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
790 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
791 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
792 CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
793
794 // Verify sequence data
795 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
796 CHECK_NO_ERROR(os);
797 CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
798 }
799
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_undo)800 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_undo) {
801 U2OpStatusImpl os;
802 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
803
804 QByteArray baseData("AAAAAAA");
805 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
806 CHECK_NO_ERROR(os);
807
808 // Some base values
809 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
810 CHECK_NO_ERROR(os);
811 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
812 CHECK_NO_ERROR(os);
813 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
814 CHECK_NO_ERROR(os);
815
816 // Prepare test data
817 QByteArray data("CC");
818 U2Region region = U2Region(2, 3);
819 QVariantMap hints;
820
821 // Call test function, undo changes
822 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
823 CHECK_NO_ERROR(os);
824 sqliteDbi->getObjectDbi()->undo(seqId, os);
825 CHECK_NO_ERROR(os);
826
827 // Verify version
828 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
829 CHECK_NO_ERROR(os);
830 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
831
832 // Verify mod type
833 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
834 CHECK_NO_ERROR(os);
835 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
836
837 // Verify mod steps num
838 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
839 CHECK_NO_ERROR(os);
840 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
841
842 // Verify modSteps
843 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
844 CHECK_NO_ERROR(os);
845 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
846 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
847 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
848 CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
849
850 // Verify sequence data
851 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
852 CHECK_NO_ERROR(os);
853 CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
854 }
855
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength_undo)856 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength_undo) {
857 U2OpStatusImpl os;
858 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
859
860 QByteArray baseData("AAAAAAA");
861 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
862 CHECK_NO_ERROR(os);
863
864 // Some base values
865 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
866 CHECK_NO_ERROR(os);
867 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
868 CHECK_NO_ERROR(os);
869 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
870 CHECK_NO_ERROR(os);
871
872 // Prepare test data
873 QByteArray data("CC");
874 U2Region region = U2Region(2, 2);
875 QVariantMap hints;
876 hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
877
878 // Call test function, undo changes
879 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
880 CHECK_NO_ERROR(os);
881 sqliteDbi->getObjectDbi()->undo(seqId, os);
882 CHECK_NO_ERROR(os);
883
884 // Verify version
885 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
886 CHECK_NO_ERROR(os);
887 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
888
889 // Verify mod type
890 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
891 CHECK_NO_ERROR(os);
892 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
893
894 // Verify mod steps num
895 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
896 CHECK_NO_ERROR(os);
897 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
898
899 // Verify modSteps
900 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
901 CHECK_NO_ERROR(os);
902 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
903 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
904 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
905 CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
906
907 // Verify sequence data
908 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
909 CHECK_NO_ERROR(os);
910 CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
911 }
912
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end_undo)913 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end_undo) {
914 U2OpStatusImpl os;
915 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
916
917 QByteArray baseData("AAAAAAA");
918 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
919 CHECK_NO_ERROR(os);
920
921 // Some base values
922 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
923 CHECK_NO_ERROR(os);
924 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
925 CHECK_NO_ERROR(os);
926 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
927 CHECK_NO_ERROR(os);
928
929 // Prepare test data
930 QByteArray data("CC");
931 U2Region region = U2Region(4, 3);
932 QVariantMap hints;
933
934 // Call test function, undo changes
935 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
936 CHECK_NO_ERROR(os);
937 sqliteDbi->getObjectDbi()->undo(seqId, os);
938 CHECK_NO_ERROR(os);
939
940 // Verify version
941 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
942 CHECK_NO_ERROR(os);
943 CHECK_EQUAL(baseSeqVersion, finalSeqVersion, "sequence version");
944
945 // Verify mod type
946 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
947 CHECK_NO_ERROR(os);
948 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
949
950 // Verify mod steps num
951 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
952 CHECK_NO_ERROR(os);
953 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
954
955 // Verify modSteps
956 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion, os);
957 CHECK_NO_ERROR(os);
958 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
959 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
960 CHECK_EQUAL(finalSeqVersion, modStep.version, "modStep version");
961 CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
962
963 // Verify sequence data
964 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
965 CHECK_NO_ERROR(os);
966 CHECK_EQUAL(QString(baseData), QString(finalData), "sequence data");
967 }
968
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyHint_redo)969 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyHint_redo) {
970 U2OpStatusImpl os;
971 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
972
973 qint64 seqLength = 0;
974 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
975 CHECK_NO_ERROR(os);
976
977 // Some base values
978 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
979 CHECK_NO_ERROR(os);
980 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
981 CHECK_NO_ERROR(os);
982 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
983 CHECK_NO_ERROR(os);
984
985 // Prepare test data
986 QByteArray data("AAAAAAA");
987 U2Region region = U2_REGION_MAX;
988 QVariantMap hints;
989 hints.insert(U2SequenceDbiHints::EMPTY_SEQUENCE, true);
990
991 // Call test function, undo and redo changes
992 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
993 CHECK_NO_ERROR(os);
994 sqliteDbi->getObjectDbi()->undo(seqId, os);
995 CHECK_NO_ERROR(os);
996 CHECK_NO_ERROR(os);
997 sqliteDbi->getObjectDbi()->redo(seqId, os);
998 CHECK_NO_ERROR(os);
999
1000 // Verify version
1001 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1002 CHECK_NO_ERROR(os);
1003 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1004
1005 // Verify mod type
1006 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1007 CHECK_NO_ERROR(os);
1008 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1009
1010 // Verify mod steps num
1011 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1012 CHECK_NO_ERROR(os);
1013 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1014
1015 // Verify modSteps
1016 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1017 CHECK_NO_ERROR(os);
1018 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1019 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1020 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1021 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"empty-sequence,true\"", QString(modStep.details), "modStep details");
1022
1023 // Verify sequence data
1024 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1025 CHECK_NO_ERROR(os);
1026 CHECK_EQUAL(data, QString(finalData), "sequence data");
1027 }
1028
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_emptyNoHint_redo)1029 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_emptyNoHint_redo) {
1030 U2OpStatusImpl os;
1031 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1032
1033 qint64 seqLength = 0;
1034 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, seqLength, os);
1035 CHECK_NO_ERROR(os);
1036
1037 // Some base values
1038 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1039 CHECK_NO_ERROR(os);
1040 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1041 CHECK_NO_ERROR(os);
1042 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1043 CHECK_NO_ERROR(os);
1044
1045 // Prepare test data
1046 QByteArray data("AAAAAAA");
1047 U2Region region = U2_REGION_MAX;
1048 QVariantMap hints;
1049
1050 // Call test function, undo and redo changes
1051 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1052 CHECK_NO_ERROR(os);
1053 sqliteDbi->getObjectDbi()->undo(seqId, os);
1054 CHECK_NO_ERROR(os);
1055 CHECK_NO_ERROR(os);
1056 sqliteDbi->getObjectDbi()->redo(seqId, os);
1057 CHECK_NO_ERROR(os);
1058
1059 // Verify version
1060 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1061 CHECK_NO_ERROR(os);
1062 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1063
1064 // Verify mod type
1065 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1066 CHECK_NO_ERROR(os);
1067 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1068
1069 // Verify mod steps num
1070 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1071 CHECK_NO_ERROR(os);
1072 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1073
1074 // Verify modSteps
1075 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1076 CHECK_NO_ERROR(os);
1077 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1078 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1079 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1080 CHECK_EQUAL("0\t0\t\tAAAAAAA\t\"\"", QString(modStep.details), "modStep details");
1081
1082 // Verify sequence data
1083 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1084 CHECK_NO_ERROR(os);
1085 CHECK_EQUAL(data, QString(finalData), "sequence data");
1086 }
1087
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_clear_redo)1088 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_clear_redo) {
1089 U2OpStatusImpl os;
1090 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1091
1092 QByteArray baseData("AAAAAAA");
1093 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1094 CHECK_NO_ERROR(os);
1095
1096 // Some base values
1097 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1098 CHECK_NO_ERROR(os);
1099 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1100 CHECK_NO_ERROR(os);
1101 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1102 CHECK_NO_ERROR(os);
1103
1104 // Prepare test data
1105 QByteArray data("");
1106 U2Region region = U2_REGION_MAX;
1107 QVariantMap hints;
1108
1109 // Call test function, undo and redo changes
1110 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1111 CHECK_NO_ERROR(os);
1112 sqliteDbi->getObjectDbi()->undo(seqId, os);
1113 CHECK_NO_ERROR(os);
1114 CHECK_NO_ERROR(os);
1115 sqliteDbi->getObjectDbi()->redo(seqId, os);
1116 CHECK_NO_ERROR(os);
1117
1118 // Verify version
1119 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1120 CHECK_NO_ERROR(os);
1121 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1122
1123 // Verify mod type
1124 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1125 CHECK_NO_ERROR(os);
1126 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1127
1128 // Verify mod steps num
1129 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1130 CHECK_NO_ERROR(os);
1131 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1132
1133 // Verify modSteps
1134 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1135 CHECK_NO_ERROR(os);
1136 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1137 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1138 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1139 CHECK_EQUAL("0\t0\tAAAAAAA\t\t\"\"", QString(modStep.details), "modStep details");
1140
1141 // Verify sequence data
1142 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1143 CHECK_NO_ERROR(os);
1144 CHECK_EQUAL(data, QString(finalData), "sequence data");
1145 }
1146
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_begin_redo)1147 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_begin_redo) {
1148 U2OpStatusImpl os;
1149 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1150
1151 QByteArray baseData("AAAAAAA");
1152 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1153 CHECK_NO_ERROR(os);
1154
1155 // Some base values
1156 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1157 CHECK_NO_ERROR(os);
1158 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1159 CHECK_NO_ERROR(os);
1160 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1161 CHECK_NO_ERROR(os);
1162
1163 // Prepare test data
1164 QByteArray data("CC");
1165 U2Region region = U2Region(0, 3);
1166 QVariantMap hints;
1167
1168 // Prepare expected data
1169 QByteArray expectedData = "CCAAAA";
1170
1171 // Call test function, undo and redo changes
1172 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1173 CHECK_NO_ERROR(os);
1174 sqliteDbi->getObjectDbi()->undo(seqId, os);
1175 CHECK_NO_ERROR(os);
1176 CHECK_NO_ERROR(os);
1177 sqliteDbi->getObjectDbi()->redo(seqId, os);
1178 CHECK_NO_ERROR(os);
1179
1180 // Verify version
1181 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1182 CHECK_NO_ERROR(os);
1183 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1184
1185 // Verify mod type
1186 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1187 CHECK_NO_ERROR(os);
1188 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1189
1190 // Verify mod steps num
1191 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1192 CHECK_NO_ERROR(os);
1193 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1194
1195 // Verify modSteps
1196 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1197 CHECK_NO_ERROR(os);
1198 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1199 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1200 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1201 CHECK_EQUAL("0\t0\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1202
1203 // Verify sequence data
1204 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1205 CHECK_NO_ERROR(os);
1206 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1207 }
1208
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_redo)1209 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_redo) {
1210 U2OpStatusImpl os;
1211 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1212
1213 QByteArray baseData("AAAAAAA");
1214 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1215 CHECK_NO_ERROR(os);
1216
1217 // Some base values
1218 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1219 CHECK_NO_ERROR(os);
1220 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1221 CHECK_NO_ERROR(os);
1222 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1223 CHECK_NO_ERROR(os);
1224
1225 // Prepare test data
1226 QByteArray data("CC");
1227 U2Region region = U2Region(2, 3);
1228 QVariantMap hints;
1229
1230 // Prepare expected data
1231 QByteArray expectedData = "AACCAA";
1232
1233 // Call test function, undo and redo changes
1234 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1235 CHECK_NO_ERROR(os);
1236 sqliteDbi->getObjectDbi()->undo(seqId, os);
1237 CHECK_NO_ERROR(os);
1238 CHECK_NO_ERROR(os);
1239 sqliteDbi->getObjectDbi()->redo(seqId, os);
1240 CHECK_NO_ERROR(os);
1241
1242 // Verify version
1243 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1244 CHECK_NO_ERROR(os);
1245 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1246
1247 // Verify mod type
1248 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1249 CHECK_NO_ERROR(os);
1250 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1251
1252 // Verify mod steps num
1253 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1254 CHECK_NO_ERROR(os);
1255 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1256
1257 // Verify modSteps
1258 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1259 CHECK_NO_ERROR(os);
1260 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1261 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1262 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1263 CHECK_EQUAL("0\t2\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1264
1265 // Verify sequence data
1266 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1267 CHECK_NO_ERROR(os);
1268 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1269 }
1270
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_middle_middleNoLength_redo)1271 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_middle_middleNoLength_redo) {
1272 U2OpStatusImpl os;
1273 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1274
1275 QByteArray baseData("AAAAAAA");
1276 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1277 CHECK_NO_ERROR(os);
1278
1279 // Some base values
1280 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1281 CHECK_NO_ERROR(os);
1282 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1283 CHECK_NO_ERROR(os);
1284 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1285 CHECK_NO_ERROR(os);
1286
1287 // Prepare test data
1288 QByteArray data("CC");
1289 U2Region region = U2Region(2, 2);
1290 QVariantMap hints;
1291 hints.insert(U2SequenceDbiHints::UPDATE_SEQUENCE_LENGTH, false);
1292
1293 // Prepare expected data
1294 QByteArray expectedData = "AACCAAA";
1295
1296 // Call test function, undo and redo changes
1297 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1298 CHECK_NO_ERROR(os);
1299 sqliteDbi->getObjectDbi()->undo(seqId, os);
1300 CHECK_NO_ERROR(os);
1301 CHECK_NO_ERROR(os);
1302 sqliteDbi->getObjectDbi()->redo(seqId, os);
1303 CHECK_NO_ERROR(os);
1304
1305 // Verify version
1306 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1307 CHECK_NO_ERROR(os);
1308 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1309
1310 // Verify mod type
1311 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1312 CHECK_NO_ERROR(os);
1313 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1314
1315 // Verify mod steps num
1316 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1317 CHECK_NO_ERROR(os);
1318 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1319
1320 // Verify modSteps
1321 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1322 CHECK_NO_ERROR(os);
1323 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1324 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1325 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1326 CHECK_EQUAL("0\t2\tAA\tCC\t\"update-length,false\"", QString(modStep.details), "modStep details");
1327
1328 // Verify sequence data
1329 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1330 CHECK_NO_ERROR(os);
1331 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1332 }
1333
IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests,updateSeqData_end_redo)1334 IMPLEMENT_TEST(SequenceDbiSQLiteSpecificUnitTests, updateSeqData_end_redo) {
1335 U2OpStatusImpl os;
1336 SQLiteDbi *sqliteDbi = SequenceSQLiteSpecificTestData::getSQLiteDbi();
1337
1338 QByteArray baseData("AAAAAAA");
1339 U2DataId seqId = SequenceSQLiteSpecificTestData::createTestSequence(true, baseData, os);
1340 CHECK_NO_ERROR(os);
1341
1342 // Some base values
1343 qint64 baseSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1344 CHECK_NO_ERROR(os);
1345 U2TrackModType baseSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1346 CHECK_NO_ERROR(os);
1347 qint64 baseModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1348 CHECK_NO_ERROR(os);
1349
1350 // Prepare test data
1351 QByteArray data("CC");
1352 U2Region region = U2Region(4, 3);
1353 QVariantMap hints;
1354
1355 // Prepare expected data
1356 QByteArray expectedData = "AAAACC";
1357
1358 // Call test function, undo and redo changes
1359 sqliteDbi->getSequenceDbi()->updateSequenceData(seqId, region, data, hints, os);
1360 CHECK_NO_ERROR(os);
1361 sqliteDbi->getObjectDbi()->undo(seqId, os);
1362 CHECK_NO_ERROR(os);
1363 CHECK_NO_ERROR(os);
1364 sqliteDbi->getObjectDbi()->redo(seqId, os);
1365 CHECK_NO_ERROR(os);
1366
1367 // Verify version
1368 qint64 finalSeqVersion = sqliteDbi->getObjectDbi()->getObjectVersion(seqId, os);
1369 CHECK_NO_ERROR(os);
1370 CHECK_EQUAL(baseSeqVersion + 1, finalSeqVersion, "sequence version");
1371
1372 // Verify mod type
1373 U2TrackModType finalSeqModType = sqliteDbi->getObjectDbi()->getTrackModType(seqId, os);
1374 CHECK_NO_ERROR(os);
1375 CHECK_EQUAL(baseSeqModType, finalSeqModType, "sequence track mod type");
1376
1377 // Verify mod steps num
1378 qint64 finalModStepsNum = SequenceSQLiteSpecificTestData::getModStepsNum(seqId, os);
1379 CHECK_NO_ERROR(os);
1380 CHECK_EQUAL(baseModStepsNum + 1, finalModStepsNum, "mod steps num");
1381
1382 // Verify modSteps
1383 U2SingleModStep modStep = sqliteDbi->getModDbi()->getModStep(seqId, finalSeqVersion - 1, os);
1384 CHECK_NO_ERROR(os);
1385 CHECK_EQUAL(U2ModType::sequenceUpdatedData, modStep.modType, "mod type");
1386 CHECK_EQUAL(seqId, modStep.objectId, "object ID");
1387 CHECK_EQUAL(finalSeqVersion - 1, modStep.version, "modStep version");
1388 CHECK_EQUAL("0\t4\tAAA\tCC\t\"\"", QString(modStep.details), "modStep details");
1389
1390 // Verify sequence data
1391 QByteArray finalData = sqliteDbi->getSequenceDbi()->getSequenceData(seqId, U2_REGION_MAX, os);
1392 CHECK_NO_ERROR(os);
1393 CHECK_EQUAL(expectedData, QString(finalData), "sequence data");
1394 }
1395
1396 } // namespace U2
1397