2 Created on Jul 21, 2010
8 import sqlite3 as sqlite
9 from erange import ReadDataset
11 testDBName = "testRDS.rds"
12 rnaTestDBName = "testRDSRNA.rds"
14 class TestReadDataset(unittest.TestCase):
18 self.rds = ReadDataset.ReadDataset(testDBName, initialize=True, datasetType="DNA", verbose=False)
19 self.rnaRds = ReadDataset.ReadDataset(rnaTestDBName, initialize=True, datasetType="RNA", verbose=False)
26 os.remove(rnaTestDBName)
29 #TODO: rename and integrate
30 def testZeeNewStuff(self):
31 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", ""),
32 ("dup start", "chr1", 1, 150, "+", 1.0, "", ""),
33 ("new read", "chr1", 80, 100, "+", 1.0, "", ""),
34 ("testRead", "chr2", 201, 400, "+", 1.0, "", ""),
35 ("dup start", "chr2", 201, 450, "+", 1.0, "", ""),
36 ("new read", "chr2", 280, 400, "+", 1.0, "", ""),
37 ("three up", "chr3", 1, 80, "+", 1.0, "", ""),
38 ("three two", "chr3", 201, 230, "+", 1.0, "", "")
40 self.rds.insertUniqs(rdsEntryList)
41 dbcon = sqlite.connect(testDBName)
43 sql.execute("select chrom,start from uniqs group by chrom,start having ( count(start) > 1 and count(chrom) > 1)")
44 result = [("chr1", 1), ("chr2", 201)]
45 for eachEntry in sql.fetchall():
46 self.assertTrue(eachEntry in result)
48 sql.execute("select chrom,start from uniqs group by chrom,start having ( count(start) = 1 and count(chrom) = 1)")
49 result = [("chr1", 80), ("chr2", 280), ("chr3", 1), ("chr3", 201)]
50 for eachEntry in sql.fetchall():
51 self.assertTrue(eachEntry in result)
53 sql.execute("select * from uniqs group by chrom,start having ( count(start) > 1 and count(chrom) > 1) union select * from uniqs group by chrom,start having ( count(start) = 1 and count(chrom) = 1)")
54 result = [(2, "dup start", "chr1", 1, 150, "+", 1.0, "", ""),
55 (3, "new read", "chr1", 80, 100, "+", 1.0, "", ""),
56 (5, "dup start", "chr2", 201, 450, "+", 1.0, "", ""),
57 (6, "new read", "chr2", 280, 400, "+", 1.0, "", ""),
58 (7, "three up", "chr3", 1, 80, "+", 1.0, "", ""),
59 (8, "three two", "chr3", 201, 230, "+", 1.0, "", "")
61 for eachEntry in sql.fetchall():
62 self.assertTrue(eachEntry in result)
64 sql.execute("select chrom,start from uniqs where start > 100 group by chrom,start having ( count(start) > 1 and count(chrom) > 1) order by chrom,start")
65 result = [("chr2", 201)]
66 for eachEntry in sql.fetchall():
67 self.assertTrue(eachEntry in result)
70 rdsEntryList = [("testMultiRead", "chr1", 1, 200, "+", 0.5, "", ""),
71 ("testMultiRead", "chr1", 1, 200, "+", 0.5, "", ""),
72 ("testMultiRead", "chr2", 80, 200, "+", 0.5, "", ""),
73 ("testMultiRead", "chr2", 1, 200, "+", 0.5, "", ""),
74 ("testMultiRead", "chr2", 5000, 25000, "+", 0.5, "", ""),
75 ("testMultiRead", "chr3", 1, 200, "+", 0.5, "", ""),
76 ("testMultiRead", "chr3", 70, 500, "+", 0.5, "", "")
78 self.rds.insertMulti(rdsEntryList)
79 sql.execute("select chrom,start from (select chrom,start from uniqs union all select chrom,start from multi) group by chrom,start having ( count(start) > 1 and count(chrom) > 1)")
80 result = [("chr1", 1), ("chr2", 201), ("chr3", 1)]
81 for eachEntry in sql.fetchall():
82 self.assertTrue(eachEntry in result)
84 sql.execute("select chrom,start from (select chrom,start from uniqs union all select chrom,start from multi) group by chrom,start having ( count(start) = 1 and count(chrom) = 1)")
85 result = [("chr1", 80),
86 ("chr2", 1), ("chr2", 80), ("chr2", 280), ("chr2", 5000),
87 ("chr3", 70), ("chr3", 201)
89 for eachEntry in sql.fetchall():
90 self.assertTrue(eachEntry in result)
92 sql.execute("select chrom,start from (select chrom,start from uniqs union all select chrom,start from multi) group by chrom,start having ( count(start) > 1 and count(chrom) > 1) union select chrom,start from (select chrom,start from uniqs union all select chrom,start from multi) group by chrom,start having ( count(start) = 1 and count(chrom) = 1)")
93 result = sql.fetchall()
94 result = [("chr1", 1), ("chr1", 80),
95 ("chr2", 1), ("chr2", 80), ("chr2", 201), ("chr2", 280), ("chr2", 5000),
96 ("chr3", 1), ("chr3", 70), ("chr3", 201)
98 for eachEntry in sql.fetchall():
99 self.assertTrue(eachEntry in result)
101 result = {"1": [{"start": 1, "sense": "+"}, {"start": 80, "sense": "+"}],
102 "3": [{"start": 1, "sense": "+"}, {"start": 70, "sense": "+"}, {"start": 201, "sense": "+"}],
103 "2": [{"start": 1, "sense": "+"}, {"start": 80, "sense": "+"}, {"start": 201, "sense": "+"}, {"start": 280, "sense": "+"}, {"start": 5000, "sense": "+"}]
105 self.assertEquals(result, self.rds.getReadsDict(combine5p=True, doMulti=True))
107 print self.rds.getReadsDict(combine5p=True, doMulti=True, withWeight=True)
109 def testReadDatasetBuiltIns(self):
110 # Initialize an existing rds file
111 self.assertRaises(sqlite.OperationalError, ReadDataset.ReadDataset, testDBName, initialize=True, datasetType="DNA", verbose=True)
112 self.assertEquals(0, len(self.rds))
114 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
115 self.rds.insertUniqs(rdsEntryList)
116 self.assertEquals(1, len(self.rds))
118 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
119 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
120 self.rds.insertMulti(rdsEntryList)
121 self.assertEquals(2, len(self.rds))
123 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
124 self.assertRaises(sqlite.OperationalError, self.rds.insertSplices, rdsEntryList)
125 self.rnaRds.insertSplices(rdsEntryList)
126 self.assertEquals(2, len(self.rds))
127 self.assertEquals(1, len(self.rnaRds))
130 def testInsertUniqs(self):
131 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
132 self.rds.insertUniqs(rdsEntryList)
133 self.assertEquals(1, len(self.rds))
135 rdsEntryList = [("testRead2", "chr1", 200, 300, "+", 1.0, "", "")]
136 self.rds.insertUniqs(rdsEntryList)
137 self.assertEquals(2, len(self.rds))
140 def testInsertMulti(self):
141 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
142 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
143 self.rds.insertMulti(rdsEntryList)
144 self.assertEquals(1, len(self.rds))
147 def testInsertSplices(self):
148 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
149 self.assertRaises(sqlite.OperationalError, self.rds.insertSplices, rdsEntryList)
150 self.rnaRds.insertSplices(rdsEntryList)
151 self.assertEquals(0, len(self.rds))
152 self.assertEquals(1, len(self.rnaRds))
155 def testGetChromosomes(self):
157 self.assertEqual(result, self.rds.getChromosomes(table="uniqs", fullChrom=True))
159 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
160 self.rds.insertUniqs(rdsEntryList)
162 self.assertEqual(result, self.rds.getChromosomes(table="uniqs", fullChrom=True))
164 self.assertRaises(sqlite.OperationalError, self.rds.getChromosomes, table="badTableName")
167 #TODO: write unit test
168 def testAttachDB(self):
172 #TODO: write unit test
173 def testDetachDB(self):
177 #TODO: write unit test
178 def testImportFromDB(self):
182 def testGetTables(self):
183 result = ["metadata", "uniqs", "multi"]
184 self.assertEquals(result, self.rds.getTables())
186 result = ["metadata", "uniqs", "multi", "splices"]
187 self.assertEquals(result, self.rnaRds.getTables())
190 def testHasIndex(self):
191 self.assertFalse(self.rds.hasIndex())
192 self.rds.buildIndex()
193 self.assertTrue(self.rds.hasIndex())
196 def testGetMetadata(self):
197 returnDict = self.rds.getMetadata()
198 self.assertTrue(returnDict.has_key("rdsVersion"))
199 self.assertEquals(returnDict["dataType"], "DNA")
201 result = {"dataType": "RNA"}
202 self.assertEquals(result, self.rnaRds.getMetadata("dataType"))
205 self.assertEquals(result, self.rds.getMetadata("badMetaDataName"))
208 def testGetReadSize(self):
209 self.assertRaises(ReadDataset.ReadDatasetError, self.rds.getReadSize)
211 self.rds.insertMetadata([("readsize", "100")])
212 self.assertEquals(100, self.rds.getReadSize())
214 self.rds.updateMetadata("readsize", 100)
215 self.assertEquals(100, self.rds.getReadSize())
217 self.rds.updateMetadata("readsize", "100 import")
218 self.assertEquals(100, self.rds.getReadSize())
220 self.rds.updateMetadata("readsize", "badReadSize")
221 self.assertRaises(ValueError, self.rds.getReadSize)
224 def testGetDefaultCacheSize(self):
225 self.assertEquals(100000, self.rds.getDefaultCacheSize())
228 def testGetMaxCoordinate(self):
229 self.assertEquals(0, self.rnaRds.getMaxCoordinate("chr1"))
231 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
232 self.rnaRds.insertUniqs(rdsEntryList)
233 self.assertEquals(1, self.rnaRds.getMaxCoordinate("chr1"))
234 self.assertEquals(0, self.rnaRds.getMaxCoordinate("chr2"))
235 self.assertEquals(0, self.rnaRds.getMaxCoordinate("chr1", doUniqs=False))
237 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
238 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
239 self.rnaRds.insertMulti(rdsEntryList)
240 self.assertEquals(1, self.rnaRds.getMaxCoordinate("chr1"))
241 self.assertEquals(101, self.rnaRds.getMaxCoordinate("chr1", doMulti=True))
243 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
244 self.rnaRds.insertSplices(rdsEntryList)
245 self.assertEquals(1, self.rnaRds.getMaxCoordinate("chr1"))
246 self.assertEquals(101, self.rnaRds.getMaxCoordinate("chr1", doMulti=True))
247 self.assertEquals(1150, self.rnaRds.getMaxCoordinate("chr1", doSplices=True))
250 def testGetReadsDict(self):
251 self.assertEquals({}, self.rds.getReadsDict())
253 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
254 self.rds.insertUniqs(rdsEntryList)
255 reads = self.rds.getReadsDict()
256 self.assertEquals(1, len(reads))
257 self.assertEquals(1, len(reads["1"]))
259 self.assertEquals(["start", "sense"], read.keys())
260 self.assertEquals(1, read["start"])
261 self.assertEquals("+", read["sense"])
263 reads = self.rds.getReadsDict(bothEnds=True, noSense=False, fullChrom=True,
264 withWeight=True, withFlag=True, withMismatch=True, withID=True,
265 withChrom=True, readIDDict=True)
266 self.assertEquals(1, len(reads))
267 self.assertEquals(1, len(reads["testRead"]))
268 read = reads["testRead"][0]
269 self.assertEquals(["readID", "weight", "stop", "mismatch","start", "flag","sense", "chrom"], read.keys())
270 self.assertEquals("testRead", read["readID"])
271 self.assertEquals(1.0, read["weight"])
272 self.assertEquals(100, read["stop"])
273 self.assertEquals("", read["mismatch"])
274 self.assertEquals(1, read["start"])
275 self.assertEquals("", read["flag"])
276 self.assertEquals("+", read["sense"])
277 self.assertEquals("chr1", read["chrom"])
279 self.assertEquals({}, self.rds.getReadsDict(hasMismatch=True))
280 self.assertEquals({}, self.rds.getReadsDict(strand="-"))
281 self.assertEquals(1, len(self.rds.getReadsDict(strand="+")))
283 rdsEntryList = [("testRead2", "chr1", 201, 300, "-", 1.0, "A", "G22A")]
284 self.rds.insertUniqs(rdsEntryList)
285 reads = self.rds.getReadsDict()
286 self.assertEquals(1, len(reads))
287 reads = self.rds.getReadsDict()
288 self.assertEquals(2, len(reads["1"]))
290 self.assertEquals(201, read["start"])
291 reads = self.rds.getReadsDict(strand="+")
292 self.assertEquals(1, len(reads))
294 self.assertEquals("+", read["sense"])
295 reads = self.rds.getReadsDict(strand="-")
296 self.assertEquals(1, len(reads))
297 reads = self.rds.getReadsDict(start=199)
298 self.assertEquals(1, len(reads["1"]))
299 reads = self.rds.getReadsDict(hasMismatch=True)
300 self.assertEquals(1, len(reads["1"]))
302 rdsEntryList = [("testMultiRead", "chr2", 101, 200, "+", 0.5, "", ""),
303 ("testMultiRead", "chr2", 101, 200, "+", 0.5, "", "")]
304 self.rds.insertMulti(rdsEntryList)
305 reads = self.rds.getReadsDict()
306 self.assertEquals(1, len(reads))
307 reads = self.rds.getReadsDict(doMulti=True)
308 self.assertEquals(2, len(reads))
309 reads = self.rds.getReadsDict(doUniqs=False, doMulti=True)
310 self.assertFalse(reads.has_key("1"))
313 def testGetSplicesDict(self):
314 self.assertRaises(sqlite.OperationalError, self.rds.getSplicesDict)
316 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
317 self.rnaRds.insertSplices(rdsEntryList)
318 reads = self.rnaRds.getSplicesDict()
319 self.assertEquals(1, len(reads))
320 self.assertEquals(1, len(reads["1"]))
322 result = ["startR", "stopL", "sense", "startL", "stopR"]
323 self.assertEquals(result, read.keys())
324 self.assertEquals(1000, read["startL"])
325 self.assertEquals("+", read["sense"])
326 reads = self.rnaRds.getSplicesDict(splitRead=True)
327 self.assertEquals(2, len(reads["1"]))
328 self.assertEquals(1000, reads["1"][0]["startL"])
329 self.assertFalse(reads["1"][0].has_key("startR"))
330 self.assertFalse(reads["1"][0].has_key("stopR"))
331 self.assertEquals(1150, reads["1"][1]["startR"])
332 self.assertFalse(reads["1"][1].has_key("startL"))
333 self.assertFalse(reads["1"][1].has_key("stopL"))
334 self.assertEquals(reads["1"][0]["sense"], reads["1"][1]["sense"])
336 reads = self.rnaRds.getSplicesDict(noSense=False, fullChrom=True,
337 withWeight=True, withFlag=True, withMismatch=True, withID=True,
338 withChrom=True, readIDDict=True)
339 self.assertEquals(1, len(reads))
340 self.assertEquals(1, len(reads["testSpliceRead"]))
341 read = reads["testSpliceRead"][0]
342 result = ["readID", "weight", "startR", "mismatch","stopR", "stopL", "flag", "startL", "sense", "chrom"]
343 self.assertEquals(result, read.keys())
344 self.assertEquals("testSpliceRead", read["readID"])
345 self.assertEquals(1.0, read["weight"])
346 self.assertEquals(1150, read["startR"])
347 self.assertEquals("", read["mismatch"])
348 self.assertEquals(1200, read["stopR"])
349 self.assertEquals(1100, read["stopL"])
350 self.assertEquals("", read["flag"])
351 self.assertEquals(1000, read["startL"])
352 self.assertEquals("+", read["sense"])
353 self.assertEquals("chr1", read["chrom"])
355 self.assertEquals({}, self.rnaRds.getSplicesDict(hasMismatch=True))
356 self.assertEquals({}, self.rnaRds.getSplicesDict(strand="-"))
357 self.assertEquals(1, len(self.rnaRds.getSplicesDict(strand="+")))
359 rdsEntryList = [("testSpliceRead2", "chr1", 2000, 2100, 2150, 2200, "-", 1.0, "A", "G20T")]
360 self.rnaRds.insertSplices(rdsEntryList)
361 reads = self.rnaRds.getSplicesDict()
362 self.assertEquals(1, len(reads))
363 reads = self.rnaRds.getSplicesDict()
364 self.assertEquals(2, len(reads["1"]))
366 self.assertEquals(2000, read["startL"])
367 reads = self.rnaRds.getSplicesDict(strand="+")
368 self.assertEquals(1, len(reads))
370 self.assertEquals("+", read["sense"])
371 reads = self.rnaRds.getSplicesDict(strand="-")
372 self.assertEquals(1, len(reads))
373 reads = self.rnaRds.getSplicesDict(start=1199)
374 self.assertEquals(1, len(reads["1"]))
375 reads = self.rnaRds.getSplicesDict(hasMismatch=True)
376 self.assertEquals(1, len(reads["1"]))
378 rdsEntryList = [("testSpliceRead3", "chr2", 2000, 2100, 2150, 2200, "-", 1.0, "A", "G20T")]
379 self.rnaRds.insertSplices(rdsEntryList)
380 reads = self.rnaRds.getSplicesDict()
381 self.assertEquals(2, len(reads))
382 self.assertEquals(2, len(reads["1"]))
383 self.assertEquals(1, len(reads["2"]))
384 reads = self.rnaRds.getSplicesDict(withID=True, chrom="chr2")
385 self.assertFalse(reads.has_key("1"))
386 self.assertEquals("testSpliceRead3", reads["2"][0]["readID"])
389 def testGetCounts(self):
390 self.assertEquals(0, self.rds.getCounts())
391 self.assertEquals((0, 0, 0), self.rds.getCounts(multi=True, reportCombined=False))
393 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
394 self.rds.insertUniqs(rdsEntryList)
395 self.assertEquals(1, self.rds.getCounts())
396 self.assertEquals((1, 0, 0), self.rds.getCounts(multi=True, reportCombined=False))
398 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
399 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
400 self.rds.insertMulti(rdsEntryList)
401 self.assertEquals(2, self.rds.getCounts(multi=True))
402 self.assertEquals((1, 1, 0), self.rds.getCounts(multi=True, reportCombined=False))
404 self.assertEquals(1, self.rds.getCounts(chrom="chr1"))
405 self.assertEquals(0, self.rds.getCounts(chrom="chr2"))
406 self.assertEquals(1, self.rds.getCounts(rmin=1))
407 self.assertEquals(1, self.rds.getCounts(rmin=1, rmax=1000))
408 self.assertEquals(1, self.rds.getCounts(rmax=1000))
409 self.assertEquals(0, self.rds.getCounts(rmin=1000))
410 self.assertEquals(0, self.rds.getCounts(rmax=0))
411 self.assertEquals(1, self.rds.getCounts(sense="+"))
412 self.assertEquals(0, self.rds.getCounts(sense="-"))
414 self.assertEquals(0, self.rnaRds.getCounts())
415 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
416 self.rnaRds.insertSplices(rdsEntryList)
417 self.assertEquals(1, self.rnaRds.getCounts(splices=True))
420 def testGetTotalCounts(self):
421 self.assertEquals(0, self.rds.getTotalCounts())
423 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
424 self.rds.insertUniqs(rdsEntryList)
425 self.assertEquals(1, self.rds.getTotalCounts())
427 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
428 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
429 self.rds.insertMulti(rdsEntryList)
431 self.assertEquals(2, self.rds.getTotalCounts())
432 self.assertEquals(2, self.rds.getTotalCounts(chrom="chr1"))
433 self.assertEquals(0, self.rds.getTotalCounts(chrom="chr2"))
434 self.assertEquals(2, self.rds.getTotalCounts(rmin=1))
435 self.assertEquals(2, self.rds.getTotalCounts(rmax=1000))
436 self.assertEquals(1, self.rds.getTotalCounts(rmin=101, rmax=1000))
437 self.assertEquals(1, self.rds.getTotalCounts(rmin=1, rmax=100))
438 self.assertEquals(0, self.rds.getTotalCounts(rmin=1000))
439 self.assertEquals(0, self.rds.getTotalCounts(rmax=0))
442 def testGetTableEntryCount(self):
444 self.assertEquals(0, self.rds.getTableEntryCount(table))
446 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
447 self.rds.insertUniqs(rdsEntryList)
448 self.assertEquals(1, self.rds.getTableEntryCount(table))
450 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
451 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
452 self.rds.insertMulti(rdsEntryList)
454 self.assertEquals(1, self.rds.getTableEntryCount(table))
455 self.assertEquals(1, self.rds.getTableEntryCount(table, chrom="chr1"))
456 self.assertEquals(0, self.rds.getTableEntryCount(table, chrom="chr2"))
457 self.assertEquals(1, self.rds.getTableEntryCount(table, rmin=1))
458 self.assertEquals(1, self.rds.getTableEntryCount(table, rmax=1000))
459 self.assertEquals(0, self.rds.getTableEntryCount(table, rmin=101, rmax=1000))
460 self.assertEquals(0, self.rds.getTableEntryCount(table, rmin=1000))
461 self.assertEquals(0, self.rds.getTableEntryCount(table, rmax=0))
462 self.assertEquals(1, self.rds.getTableEntryCount(table, restrict=" sense ='+' "))
463 self.assertEquals(0, self.rds.getTableEntryCount(table, restrict=" sense ='-' "))
464 self.assertEquals(1, self.rds.getTableEntryCount(table, distinct=True))
467 self.assertEquals(1, self.rds.getTableEntryCount(table))
468 self.assertEquals(1, self.rds.getTableEntryCount(table, chrom="chr1"))
469 self.assertEquals(0, self.rds.getTableEntryCount(table, chrom="chr2"))
470 self.assertEquals(1, self.rds.getTableEntryCount(table, rmin=1))
471 self.assertEquals(1, self.rds.getTableEntryCount(table, rmax=1000))
472 self.assertEquals(1, self.rds.getTableEntryCount(table, rmin=101, rmax=1000))
473 self.assertEquals(0, self.rds.getTableEntryCount(table, rmin=1000))
474 self.assertEquals(0, self.rds.getTableEntryCount(table, rmax=0))
475 self.assertEquals(1, self.rds.getTableEntryCount(table, restrict=" sense ='+' "))
476 self.assertEquals(0, self.rds.getTableEntryCount(table, restrict=" sense ='-' "))
477 self.assertEquals(1, self.rds.getTableEntryCount(table, distinct=True))
479 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
480 self.rnaRds.insertSplices(rdsEntryList)
482 self.assertEquals(1, self.rnaRds.getTableEntryCount(table))
483 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, chrom="chr1"))
484 self.assertEquals(0, self.rnaRds.getTableEntryCount(table, chrom="chr2"))
485 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, rmin=1, startField="startL"))
486 self.assertRaises(sqlite.OperationalError, self.rnaRds.getTableEntryCount, table, rmin=1)
487 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, rmax=2000, startField="startL"))
488 self.assertRaises(sqlite.OperationalError, self.rnaRds.getTableEntryCount, table, rmax=2000)
489 self.assertEquals(0, self.rnaRds.getTableEntryCount(table, rmax=999, startField="startL"))
490 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, rmin=1000, startField="startL"))
491 self.assertEquals(0, self.rnaRds.getTableEntryCount(table, rmax=0, startField="startL"))
492 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, restrict=" sense ='+' "))
493 self.assertEquals(0, self.rnaRds.getTableEntryCount(table, restrict=" sense ='-' "))
494 self.assertEquals(1, self.rnaRds.getTableEntryCount(table, distinct=True, startField="startL"))
495 self.assertRaises(sqlite.OperationalError, self.rnaRds.getTableEntryCount, table, distinct=True)
498 def testGetUniqsCount(self):
499 self.assertEquals(0, self.rds.getUniqsCount())
501 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
502 self.rds.insertUniqs(rdsEntryList)
503 self.assertEquals(1, self.rds.getUniqsCount())
505 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
506 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
507 self.rds.insertMulti(rdsEntryList)
509 self.assertEquals(1, self.rds.getUniqsCount())
510 self.assertEquals(1, self.rds.getUniqsCount(chrom="chr1"))
511 self.assertEquals(0, self.rds.getUniqsCount(chrom="chr2"))
512 self.assertEquals(1, self.rds.getUniqsCount(rmin=1))
513 self.assertEquals(1, self.rds.getUniqsCount(rmax=1000))
514 self.assertEquals(0, self.rds.getUniqsCount(rmin=101, rmax=1000))
515 self.assertEquals(0, self.rds.getUniqsCount(rmin=1000))
516 self.assertEquals(0, self.rds.getUniqsCount(rmax=0))
517 self.assertEquals(1, self.rds.getUniqsCount(restrict=" sense ='+' "))
518 self.assertEquals(0, self.rds.getUniqsCount(restrict=" sense ='-' "))
519 self.assertEquals(1, self.rds.getUniqsCount(distinct=True))
522 def testGetSplicesCount(self):
523 self.assertEquals(0, self.rnaRds.getSplicesCount())
525 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
526 self.rnaRds.insertUniqs(rdsEntryList)
527 self.assertEquals(0, self.rnaRds.getSplicesCount())
529 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
530 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
531 self.rnaRds.insertMulti(rdsEntryList)
532 self.assertEquals(0, self.rnaRds.getSplicesCount())
534 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
535 self.rnaRds.insertSplices(rdsEntryList)
537 self.assertEquals(1, self.rnaRds.getSplicesCount())
538 self.assertEquals(1, self.rnaRds.getSplicesCount(chrom="chr1"))
539 self.assertEquals(0, self.rnaRds.getSplicesCount(chrom="chr2"))
540 self.assertEquals(1, self.rnaRds.getSplicesCount(rmin=1))
541 self.assertEquals(1, self.rnaRds.getSplicesCount(rmax=2000))
542 self.assertEquals(0, self.rnaRds.getSplicesCount(rmax=999))
543 self.assertEquals(1, self.rnaRds.getSplicesCount(rmin=1000))
544 self.assertEquals(0, self.rnaRds.getSplicesCount(rmax=0))
545 self.assertEquals(1, self.rnaRds.getSplicesCount(restrict=" sense ='+' "))
546 self.assertEquals(0, self.rnaRds.getSplicesCount(restrict=" sense ='-' "))
547 self.assertEquals(1, self.rnaRds.getSplicesCount(distinct=True))
550 def testGetMultiCount(self):
551 self.assertEquals(0, self.rds.getMultiCount())
553 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
554 self.rds.insertUniqs(rdsEntryList)
555 self.assertEquals(0, self.rds.getMultiCount())
557 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
558 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
559 self.rds.insertMulti(rdsEntryList)
561 self.assertEquals(1, self.rds.getMultiCount())
562 self.assertEquals(1, self.rds.getMultiCount(chrom="chr1"))
563 self.assertEquals(0, self.rds.getMultiCount(chrom="chr2"))
564 self.assertEquals(1, self.rds.getMultiCount(rmin=1))
565 self.assertEquals(1, self.rds.getMultiCount(rmax=1000))
566 self.assertEquals(0, self.rds.getMultiCount(rmin=1, rmax=100))
567 self.assertEquals(0, self.rds.getMultiCount(rmin=1000))
568 self.assertEquals(0, self.rds.getMultiCount(rmax=0))
569 self.assertEquals(1, self.rds.getMultiCount(restrict=" sense ='+' "))
570 self.assertEquals(0, self.rds.getMultiCount(restrict=" sense ='-' "))
571 self.assertEquals(1, self.rds.getMultiCount(distinct=True))
574 def testGetReadIDs(self):
575 self.assertEquals([], self.rnaRds.getReadIDs())
577 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
578 self.rnaRds.insertUniqs(rdsEntryList)
579 result = ["testRead"]
580 self.assertEquals(result, self.rnaRds.getReadIDs())
582 rdsEntryList = [("testMultiRead", "chr1", 101, 200, "+", 0.5, "", ""),
583 ("testMultiRead", "chr1", 101, 200, "+", 0.5, "", "")]
584 self.rnaRds.insertMulti(rdsEntryList)
585 result = ["testRead"]
586 self.assertEquals(result, self.rnaRds.getReadIDs())
587 result = ["testMultiRead", "testRead"]
588 self.assertEquals(result, self.rnaRds.getReadIDs(multi=True))
590 rdsEntryList = [("testRead2", "chr1", 201, 300, "+", 1.0, "", "")]
591 self.rnaRds.insertUniqs(rdsEntryList)
592 result = ["testRead", "testRead2"]
593 self.assertEquals(result, self.rnaRds.getReadIDs())
594 result = ["testRead"]
595 self.assertEquals(result, self.rnaRds.getReadIDs(limit=1))
596 result = ["testMultiRead"]
597 self.assertEquals(result, self.rnaRds.getReadIDs(multi=True, limit=1))
599 rdsEntryList = [("testPair/1", "chr1", 301, 400, "+", 1.0, "", "")]
600 self.rnaRds.insertUniqs(rdsEntryList)
601 result = ["testPair", "testRead", "testRead2"]
602 self.assertEquals(result, self.rnaRds.getReadIDs(paired=True))
604 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
605 self.rnaRds.insertSplices(rdsEntryList)
606 result = ["testSpliceRead"]
607 self.assertEquals(result, self.rnaRds.getReadIDs(uniqs=False, splices=True))
608 result = ["testPair/1", "testRead", "testRead2", "testSpliceRead"]
609 self.assertEquals(result, self.rnaRds.getReadIDs(splices=True))
612 def testGetMismatches(self):
613 self.assertRaises(ReadDataset.ReadDatasetError, self.rds.getMismatches)
614 self.rds.insertMetadata([("readsize", "5")])
616 rdsEntryList = [("testRead", "chr1", 1, 5, "+", 1.0, "", "")]
617 self.rds.insertUniqs(rdsEntryList)
618 result = {"chr1": []}
619 self.assertEquals(result, self.rds.getMismatches())
621 rdsEntryList = [("testRead", "chr1", 1, 5, "+", 1.0, "", "C3T")]
622 self.rds.insertUniqs(rdsEntryList)
623 result = {"chr1": [[1, 3, "T", "C"]]}
624 self.assertEquals(result, self.rds.getMismatches())
625 result = {"chr2": []}
626 self.assertEquals(result, self.rds.getMismatches(mischrom="chr2"))
628 rdsEntryList = [("testRead", "chr1", 10, 15, "+", 1.0, "", "C3T")]
629 self.rds.insertUniqs(rdsEntryList)
630 result = {"chr1": [[1, 3, "T", "C"], [10, 12, "T", "C"]]}
631 self.assertEquals(result, self.rds.getMismatches())
633 rdsEntryList = [("testRead", "chr2", 10, 15, "+", 1.0, "", "C3T")]
634 self.rds.insertUniqs(rdsEntryList)
635 result = {"chr1": [[1, 3, "T", "C"], [10, 12, "T", "C"]],
636 "chr2": [[10, 12, "T", "C"]]}
637 self.assertEquals(result, self.rds.getMismatches())
639 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "C41T")]
640 self.rnaRds.insertSplices(rdsEntryList)
641 self.rnaRds.insertMetadata([("readsize", "150")])
642 result = {"chr1": [[1000, 1040, "T", "C"]]}
643 #TODO: This test case fails. If there are only splice entries for a chromosome it shouldn't
644 # be necessary to specify the chromosome.
645 #self.assertEquals(result, self.rnaRds.getMismatches())
646 self.assertEquals(result, self.rnaRds.getMismatches(mischrom="chr1"))
649 #TODO: needs fixing up
650 def testGetChromProfile(self):
651 chromProfile = self.rds.getChromProfile("chr1")
653 self.assertEquals(result, chromProfile.tolist())
655 rdsEntryList = [("testRead", "chr1", 1, 5, "+", 1.0, "", "")]
656 self.rds.insertUniqs(rdsEntryList)
657 chromProfile = self.rds.getChromProfile("chr1")
659 self.assertEquals(result, chromProfile.tolist())
661 self.rds.insertMetadata([("readsize", "5")])
662 chromProfile = self.rds.getChromProfile("chr1")
663 result = [0.0, 1.0, 1.0, 1.0, 1.0]
664 self.assertEquals(result, chromProfile.tolist())
666 rdsEntryList = [("testRead2", "chr1", 7, 11, "+", 1.0, "", "")]
667 self.rds.insertUniqs(rdsEntryList)
668 # This doesn't seem to make sense the default behavior is to only get the first readlen bases
669 chromProfile = self.rds.getChromProfile("chr1")
670 result = [0.0, 1.0, 1.0, 1.0, 1.0]
671 self.assertEquals(result, chromProfile.tolist())
673 # as it stands this doesn't see right either. Getting an indexError at currentpos 5.
674 chromProfile = self.rds.getChromProfile("chr1", cstop=11)
675 result = [0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
676 self.assertEquals(result, chromProfile.tolist())
679 def testInsertMetadata(self):
681 self.assertEquals(result, self.rds.getMetadata("testMeta"))
683 self.rds.insertMetadata([("testMeta", "100")])
684 result = {"testMeta": "100"}
685 self.assertEquals(result, self.rds.getMetadata("testMeta"))
687 self.rds.insertMetadata([("testMeta", "200")])
688 result = {"testMeta:2": "200", "testMeta": "100"}
689 self.assertEquals(result, self.rds.getMetadata("testMeta"))
692 def testUpdateMetadata(self):
694 self.assertEquals(result, self.rds.getMetadata("testMeta"))
696 self.rds.insertMetadata([("testMeta", "100")])
697 result = {"testMeta": "100"}
698 self.assertEquals(result, self.rds.getMetadata("testMeta"))
700 self.rds.updateMetadata("testMeta", "200")
701 result = {"testMeta": "200"}
702 self.assertEquals(result, self.rds.getMetadata("testMeta"))
704 self.rds.updateMetadata("testMeta", "300", "200")
705 result = {"testMeta": "300"}
706 self.assertEquals(result, self.rds.getMetadata("testMeta"))
708 self.rds.updateMetadata("testMeta", "200", "200")
709 result = {"testMeta": "300"}
710 self.assertEquals(result, self.rds.getMetadata("testMeta"))
713 def testFlagReads(self):
714 readData = self.rnaRds.getReadsDict(withFlag=True)
715 self.assertEquals({}, readData)
717 rdsEntryList = [("testRead", "chr1", 1, 100, "+", 1.0, "", "")]
718 self.rnaRds.insertUniqs(rdsEntryList)
720 flags = self.getRDSFlags("1", self.rnaRds)
721 self.assertEquals(result, flags)
724 self.assertRaises(sqlite.ProgrammingError, self.rnaRds.flagReads, regions)
726 regions = [("test", "chr1", "0", "1000")]
727 self.rnaRds.flagReads(regions)
729 flags = self.getRDSFlags("1", self.rnaRds)
730 self.assertEquals(result, flags)
732 regions = [("test2", "chr1", "600", "1000")]
733 self.rnaRds.flagReads(regions)
735 flags = self.getRDSFlags("1", self.rnaRds)
736 self.assertEquals(result, flags)
738 rdsEntryList = [("testRead2", "chr1", 101, 200, "+", 1.0, "", "")]
739 self.rnaRds.insertUniqs(rdsEntryList)
740 regions = [("test2", "chr1", "101", "1000")]
741 self.rnaRds.flagReads(regions)
742 result = ["test", "test2"]
743 flags = self.getRDSFlags("1", self.rnaRds)
744 self.assertEquals(result, flags)
746 rdsEntryList = [("testMultiRead", "chr1", 201, 300, "+", 0.5, "", ""),
747 ("testMultiRead", "chr1", 201, 300, "+", 0.5, "", "")]
748 self.rnaRds.insertMulti(rdsEntryList)
749 regions = [("test", "chr1", "0", "1000")]
750 self.rnaRds.flagReads(regions)
751 result = ["test", "test", "", ""]
752 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True)
753 self.assertEquals(result, flags)
755 regions = [("multi", "chr1", "1", "1000")]
756 self.rnaRds.flagReads(regions, uniqs=False, multi=True)
757 result = ["test", "test", "multi", "multi"]
758 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True)
759 self.assertEquals(result, flags)
761 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "", "")]
762 self.rnaRds.insertSplices(rdsEntryList)
763 regions = [("test", "chr1", "0", "1500")]
764 self.rnaRds.flagReads(regions)
765 result = ["", "test", "test", "multi", "multi"]
766 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True, splice=True)
767 self.assertEquals(result, flags)
769 regions = [("splice", "chr1", "1", "1500")]
770 self.rnaRds.flagReads(regions, uniqs=False, multi=False, splices=True)
771 result = [" L:splice R:splice", "test", "test", "multi", "multi"]
772 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True, splice=True)
773 self.assertEquals(result, flags)
775 rdsEntryList = [("testNegSense", "chr1", 301, 400, "-", 1.0, "", "")]
776 self.rnaRds.insertUniqs(rdsEntryList)
777 regions = [("test", "chr1", "0", "1500", "+")]
778 self.rnaRds.flagReads(regions, sense="anythingBut'Both'")
779 result = ["test", "test", ""]
780 flags = self.getRDSFlags("1", self.rnaRds)
781 self.assertEquals(result, flags)
783 regions = [("neg", "chr1", "0", "1500", "-")]
784 self.rnaRds.flagReads(regions, sense="anythingBut'Both'")
785 result = ["test", "test", "neg"]
786 flags = self.getRDSFlags("1", self.rnaRds)
787 self.assertEquals(result, flags)
790 def getRDSFlags(self, chromosome, rds, doMulti=False, splice=False):
792 readData = rds.getSplicesDict(withFlag=True)
794 readData = rds.getReadsDict(withFlag=True, doMulti=doMulti)
797 for read in readData[chromosome]:
798 flags.append(read["flag"])
801 nonSplice = self.getRDSFlags(chromosome, rds, doMulti, splice=False)
802 for flag in nonSplice:
808 def testSetFlags(self):
809 rdsEntryList = [("test", "chr1", 1, 100, "+", 1.0, "uniq", "")]
810 self.rds.insertUniqs(rdsEntryList)
811 self.rnaRds.insertUniqs(rdsEntryList)
812 rdsEntryList = [("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", ""),
813 ("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", "")]
814 self.rnaRds.insertMulti(rdsEntryList)
815 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "splice", "")]
816 self.rnaRds.insertSplices(rdsEntryList)
819 self.rds.setFlags("reset")
820 flags = self.getRDSFlags("1", self.rds)
821 self.assertEquals(result, flags)
823 result = ["splice", "uniq", "resetMulti", "resetMulti"]
824 self.rnaRds.setFlags("resetMulti", uniqs=False, splices=False)
825 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True, splice=True)
826 self.assertEquals(result, flags)
828 result = ["resetAll", "resetAll", "resetAll", "resetAll"]
829 self.rnaRds.setFlags("resetAll")
830 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True, splice=True)
831 self.assertEquals(result, flags)
834 def testResetFlags(self):
835 rdsEntryList = [("test", "chr1", 1, 100, "+", 1.0, "uniq", "")]
836 self.rds.insertUniqs(rdsEntryList)
837 self.rnaRds.insertUniqs(rdsEntryList)
838 rdsEntryList = [("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", ""),
839 ("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", "")]
840 self.rnaRds.insertMulti(rdsEntryList)
841 rdsEntryList = [("testSpliceRead", "chr1", 1000, 1100, 1150, 1200, "+", 1.0, "splice", "")]
842 self.rnaRds.insertSplices(rdsEntryList)
844 self.rds.resetFlags()
846 flags = self.getRDSFlags("1", self.rds)
847 self.assertEquals(result, flags)
849 self.rnaRds.resetFlags()
850 result = ["", "", ""]
851 flags = self.getRDSFlags("1", self.rnaRds, doMulti=True)
852 self.assertEquals(result, flags)
854 self.rnaRds.resetFlags()
856 flags = self.getRDSFlags("1", self.rnaRds, splice=True)
857 self.assertEquals(result, flags)
860 def testReweighMultireads(self):
861 rdsEntryList = [("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", ""),
862 ("testMultiRead", "chr1", 201, 300, "+", 0.5, "multi", "")]
863 self.rds.insertMulti(rdsEntryList)
864 readData = ("0.25", "chr1", "201", "testMultiRead")
865 self.rds.reweighMultireads([readData])
866 readDict = self.rds.getReadsDict(withWeight=True, doMulti=True)
867 read = readDict["1"][0]
868 self.assertEquals(0.25, read["weight"])
871 #TODO: write unit test
872 def testSetSynchronousPragma(self):
876 #TODO: write unit test
877 def testSetDBcache(self):
881 #TODO: write unit test
882 def testExecute(self):
886 #TODO: write unit test
887 def testExecuteCommit(self):
891 def testBuildIndex(self):
892 self.assertFalse(self.rds.hasIndex())
893 self.rds.buildIndex()
894 self.assertTrue(self.rds.hasIndex())
897 def testDropIndex(self):
898 self.assertFalse(self.rds.hasIndex())
899 self.rds.buildIndex()
900 self.assertTrue(self.rds.hasIndex())
902 self.assertFalse(self.rds.hasIndex())
904 self.assertFalse(self.rnaRds.hasIndex())
905 self.rnaRds.buildIndex()
906 self.assertTrue(self.rnaRds.hasIndex())
907 self.rnaRds.dropIndex()
908 self.assertFalse(self.rnaRds.hasIndex())
911 #TODO: write unit test
912 def testMemSync(self):
916 #TODO: write unit test
917 def testCopyDBEntriesToMemory(self):
921 #TODO: write unit test
922 def testCopySpliceDBEntriesToMemory(self):
927 suite = unittest.TestSuite()
928 suite.addTest(unittest.makeSuite(TestReadDataset))
933 if __name__ == "__main__":
934 #import sys;sys.argv = ['', 'Test.testName']