Test cases inherit from either unittest2 or django.test.TestCase
I should be able to use skip tests in the future.
I learned inheriting from django.test.TestCase will properly set up
the database for django tests. (Well at least mostly, I'm having
some possible errors on 1.4)
44 files changed:
#!/usr/bin/env python
from datetime import datetime
import os
#!/usr/bin/env python
from datetime import datetime
import os
+from unittest2 import TestCase
SOURCE_PATH = os.path.split(os.path.abspath(__file__))[0]
print SOURCE_PATH
SOURCE_PATH = os.path.split(os.path.abspath(__file__))[0]
print SOURCE_PATH
-class TestEncodeFind(unittest.TestCase):
+class TestEncodeFind(TestCase):
def setUp(self):
self.model = get_model()
add_default_schemas(self.model)
def setUp(self):
self.model = get_model()
add_default_schemas(self.model)
- return unittest.makeSuite(TestEncodeFind, "test")
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestEncodeFind))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main()
+from unittest2 import TestCase, TestSuite, defaultTestLoader
-class testUCSCGather(unittest.TestCase):
+class testUCSCGather(TestCase):
- return unittest.makeSuite(testUCSCGather,"test")
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testUCSCGather))
+ return suite
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest='suite')
+from unittest2 import TestCase
import os
from htsworkflow.automation.solexa import is_runfolder
import os
from htsworkflow.automation.solexa import is_runfolder
return runfolder_path
return None
return runfolder_path
return None
class Event(object):
def __init__(self, path=None, name=None):
self.path = path
self.name = name
class Event(object):
def __init__(self, path=None, name=None):
self.path = path
self.name = name
-class testRunner(unittest.TestCase):
+class testRunner(TestCase):
def test_extract_runfolder(self):
watchdir = os.path.join('root', 'server', 'mount')
runfolder = os.path.join(watchdir, '080909_HWI-EAS229_0052_1234ABCD')
def test_extract_runfolder(self):
watchdir = os.path.join('root', 'server', 'mount')
runfolder = os.path.join(watchdir, '080909_HWI-EAS229_0052_1234ABCD')
event = Event( path=other)
self.failUnlessEqual(extract_runfolder_path(watchdir, event), None )
event = Event( path=other)
self.failUnlessEqual(extract_runfolder_path(watchdir, event), None )
- return unittest.makeSuite(testRunner,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testRunner))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from htsworkflow.automation import solexa
from htsworkflow.automation import solexa
-class testSolexaRunfolderUtils(unittest.TestCase):
+class testSolexaRunfolderUtils(TestCase):
def test_is_runfolder(self):
self.failUnlessEqual(solexa.is_runfolder(""), False)
self.failUnlessEqual(solexa.is_runfolder("1345_23"), False)
def test_is_runfolder(self):
self.failUnlessEqual(solexa.is_runfolder(""), False)
self.failUnlessEqual(solexa.is_runfolder("1345_23"), False)
for root, path, response in test_data:
self.failUnlessEqual(solexa.get_top_dir(root, path), response)
for root, path, response in test_data:
self.failUnlessEqual(solexa.get_top_dir(root, path), response)
- return unittest.makeSuite(testSolexaRunfolderUtils, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testSolexaRunfolderUtils))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
-
+ from unittest2 import main
+ main(defaultTest="suite")
from django.test import TestCase
from django.contrib.auth.models import User
from django.test import TestCase
from django.contrib.auth.models import User
return flowcells
def suite():
return flowcells
def suite():
- return unittest.makeSuite(InventoryTestCase, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(InventoryTestCase))
+ return suite
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
-
+ from unittest2 import main
+ main(defaultTest="suite")
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(SimpleTest))
+ return suite
+
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
"""More direct synthetic test cases for the eland output file processing
"""
from StringIO import StringIO
"""More direct synthetic test cases for the eland output file processing
"""
from StringIO import StringIO
+from unittest2 import TestCase
from htsworkflow.pipelines.eland import ELAND, ElandLane, ElandMatches, \
SampleKey, MatchCodes, MappedReads
from htsworkflow.pipelines.eland import ELAND, ElandLane, ElandMatches, \
SampleKey, MatchCodes, MappedReads
-class MatchCodeTests(unittest.TestCase):
+class MatchCodeTests(TestCase):
def test_initializer(self):
self.assertRaises(ValueError, MatchCodes, {'foo':'bar'})
self.assertRaises(ValueError, MatchCodes, 3)
def test_initializer(self):
self.assertRaises(ValueError, MatchCodes, {'foo':'bar'})
self.assertRaises(ValueError, MatchCodes, 3)
self.assertEqual(mc1['U0'], 100)
self.assertEqual(mc1['U0'], 100)
-class TestMappedReads(unittest.TestCase):
+class TestMappedReads(TestCase):
def test_initializer(self):
mr1 = MappedReads()
self.assertEqual(len(mr1), 0)
def test_initializer(self):
mr1 = MappedReads()
self.assertEqual(len(mr1), 0)
mr3['Lambda3'] = 2
self.assertEqual(mr3['Lambda3'], 2)
mr3['Lambda3'] = 2
self.assertEqual(mr3['Lambda3'], 2)
-class ElandTests(unittest.TestCase):
+class ElandTests(TestCase):
"""Test specific Eland modules
"""
def compare_match_array(self, current, expected):
"""Test specific Eland modules
"""
def compare_match_array(self, current, expected):
self.assertEqual(e_list[1], 'Lane3')
self.assertEqual(e_list[2], 'Lane5')
self.assertEqual(e_list[1], 'Lane3')
self.assertEqual(e_list[2], 'Lane5')
-class TestElandMatches(unittest.TestCase):
+class TestElandMatches(TestCase):
def test_eland_replacing(self):
key = SampleKey(1, 1, 's')
e = ELAND()
def test_eland_replacing(self):
key = SampleKey(1, 1, 's')
e = ELAND()
self.assertEqual(len(em[key11111]), 3)
self.assertEqual(len(em[key11112]), 2)
self.assertEqual(len(em[key11111]), 3)
self.assertEqual(len(em[key11112]), 2)
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(MatchCodeTests))
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestMappedReads))
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(ElandTests))
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestElandMatches))
+ return suite
+
+
if __name__ == "__main__":
if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import tempfile
import shutil
import sys
import tempfile
import shutil
import sys
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderExtractTests(unittest.TestCase):
+class RunfolderExtractTests(TestCase):
"""
Test the extract result code.
"""
"""
Test the extract result code.
"""
self.failUnlessEqual(len(archive), 34)
self.failUnless('asite_090608_HWI-EAS229_0117_4286GAAXX_l6_r1.tar.bz2' in archive)
self.failUnlessEqual(len(archive), 34)
self.failUnless('asite_090608_HWI-EAS229_0117_4286GAAXX_l6_r1.tar.bz2' in archive)
- return unittest.makeSuite(RunfolderExtractTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderExtractTests))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from StringIO import StringIO
from htsworkflow.pipelines import genome_mapper
from StringIO import StringIO
from htsworkflow.pipelines import genome_mapper
-class testGenomeMapper(unittest.TestCase):
+class testGenomeMapper(TestCase):
def test_construct_mapper(self):
genomes = {
'Arabidopsis thaliana': {'v01212004': '/arabidopsis'},
def test_construct_mapper(self):
genomes = {
'Arabidopsis thaliana': {'v01212004': '/arabidopsis'},
- return unittest.makeSuite(testGenomeMapper,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testGenomeMapper))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
from StringIO import StringIO
import shutil
import tempfile
from StringIO import StringIO
import shutil
import tempfile
+from unittest2 import TestCase
from htsworkflow.pipelines.runfolder import ElementTree
from htsworkflow.pipelines import genomemap
from htsworkflow.pipelines.runfolder import ElementTree
from htsworkflow.pipelines import genomemap
<chromosome fileName="chr1.fa" contigName="chr1" totalBases="197195432"/>
</sequenceSizes>
'''
<chromosome fileName="chr1.fa" contigName="chr1" totalBases="197195432"/>
</sequenceSizes>
'''
-class TestGenomeMap(unittest.TestCase):
+class TestGenomeMap(TestCase):
def test_genomesizes_xml(self):
xml = ElementTree.fromstring(MINI_GENOME_XML)
g = genomemap.GenomeMap()
def test_genomesizes_xml(self):
xml = ElementTree.fromstring(MINI_GENOME_XML)
g = genomemap.GenomeMap()
self.assertEqual(g['chr1.fa'], '{0}/chr1.fa'.format(tempgenome))
self.assertEqual(g['chr1.fa'], '{0}/chr1.fa'.format(tempgenome))
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestGenomeMap))
+ return suite
+
+
if __name__ == "__main__":
if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from StringIO import StringIO
from simulate_runfolder import TESTDATA_DIR
from htsworkflow.pipelines.runfolder import load_pipeline_run_xml
from htsworkflow.pipelines.eland import SampleKey
from StringIO import StringIO
from simulate_runfolder import TESTDATA_DIR
from htsworkflow.pipelines.runfolder import load_pipeline_run_xml
from htsworkflow.pipelines.eland import SampleKey
-class testLoadRunXML(unittest.TestCase):
+
+class testLoadRunXML(TestCase):
def _check_run_xml(self, run_xml_name, results, eland_results=8):
run_xml_path = os.path.join(TESTDATA_DIR, run_xml_name)
run = load_pipeline_run_xml(run_xml_path)
def _check_run_xml(self, run_xml_name, results, eland_results=8):
run_xml_path = os.path.join(TESTDATA_DIR, run_xml_name)
run = load_pipeline_run_xml(run_xml_path)
}
self._check_run_xml(run_xml_name, results, eland_results=8)
}
self._check_run_xml(run_xml_name, results, eland_results=8)
- return unittest.makeSuite(testLoadRunXML,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testLoadRunXML))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
f.write(eland_result)
f.close()
f.write(eland_result)
f.close()
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
-
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import eland
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
-
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import bustard
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
from htsworkflow.pipelines import firecrest
from htsworkflow.pipelines import bustard
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
self.failIfEqual(r2.gerald, None)
self.failIfEqual(r2.gerald, None)
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
from htsworkflow.pipelines import eland
from htsworkflow.pipelines import ipar
obj.gerald_dir = gerald_dir
obj.gerald_dir = gerald_dir
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import tempfile
import shutil
import os
import tempfile
import shutil
+from unittest2 import TestCase
from htsworkflow.pipelines import eland
from htsworkflow.pipelines.samplekey import SampleKey
from htsworkflow.pipelines import eland
from htsworkflow.pipelines.samplekey import SampleKey
-class RunfolderTests(unittest.TestCase):
+class RunfolderTests(TestCase):
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
"""
Test components of the runfolder processing code
which includes firecrest, bustard, and gerald
self.failIfEqual(r2.gerald, None)
def suite():
self.failIfEqual(r2.gerald, None)
def suite():
- return unittest.makeSuite(RunfolderTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(RunfolderTests))
+ return suite
-if __name__ == "__main__":
- logging.basicConfig(level=logging.WARN)
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
"""More direct synthetic test cases for the eland output file processing
"""
from StringIO import StringIO
"""More direct synthetic test cases for the eland output file processing
"""
from StringIO import StringIO
+from unittest2 import TestCase
from htsworkflow.pipelines.samplekey import SampleKey
from htsworkflow.pipelines.samplekey import SampleKey
-class TestSampleKey(unittest.TestCase):
+class TestSampleKey(TestCase):
def test_equality(self):
k1 = SampleKey(lane=1, read='1', sample='12345')
k2 = SampleKey(lane=1, read=1, sample='12345')
def test_equality(self):
k1 = SampleKey(lane=1, read='1', sample='12345')
k2 = SampleKey(lane=1, read=1, sample='12345')
self.assertTrue(k2.matches(q3))
self.assertTrue(k3.matches(q3))
self.assertTrue(k2.matches(q3))
self.assertTrue(k3.matches(q3))
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestSampleKey))
+ return suite
+
+
if __name__ == "__main__":
if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import shutil
import tempfile
import os
import shutil
import tempfile
+from unittest2 import TestCase
from htsworkflow.util.rdfhelp import get_model, load_string_into_model, \
rdfNS, libraryOntology, dump_model, fromTypedNode
from htsworkflow.util.rdfhelp import get_model, load_string_into_model, \
rdfNS, libraryOntology, dump_model, fromTypedNode
-class SequenceFileTests(unittest.TestCase):
+class SequenceFileTests(TestCase):
"""
Make sure the sequence archive class works
"""
"""
Make sure the sequence archive class works
"""
- return unittest.makeSuite(SequenceFileTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(SequenceFileTests))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
#!/usr/bin/env python
import os
from StringIO import StringIO
#!/usr/bin/env python
import os
from StringIO import StringIO
+from unittest2 import TestCase
from htsworkflow.pipelines import summary
from simulate_runfolder import TESTDATA_DIR
from htsworkflow.pipelines import summary
from simulate_runfolder import TESTDATA_DIR
-class SummaryTests(unittest.TestCase):
+class SummaryTests(TestCase):
"""Test elements of the summary file parser
"""
def test_is_xml(self):
"""Test elements of the summary file parser
"""
def test_is_xml(self):
pathname = os.path.join(TESTDATA_DIR, 'sample_summary_1_12.htm')
s = summary.SummaryGA(pathname)
pathname = os.path.join(TESTDATA_DIR, 'sample_summary_1_12.htm')
s = summary.SummaryGA(pathname)
- return unittest.makeSuite(SummaryTests,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(SummaryTests))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
from pprint import pprint
import shutil
import tempfile
from pprint import pprint
import shutil
import tempfile
+
+from django.test import TestCase
from htsworkflow.submission.condorfastq import CondorFastqExtract
from htsworkflow.submission.results import ResultMap
from htsworkflow.submission.condorfastq import CondorFastqExtract
from htsworkflow.submission.results import ResultMap
"""
HOST = "http://localhost"
"""
HOST = "http://localhost"
-class TestCondorFastq(unittest.TestCase):
+class TestCondorFastq(TestCase):
def setUp(self):
self.cwd = os.getcwd()
def setUp(self):
self.cwd = os.getcwd()
- suite = unittest.makeSuite(TestCondorFastq, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestCondorFastq))
return suite
if __name__ == "__main__":
return suite
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
-
+ from unittest2 import main
+ main(defaultTest='suite')
from StringIO import StringIO
import shutil
import tempfile
from StringIO import StringIO
import shutil
import tempfile
+from unittest2 import TestCase, TestSuite, defaultTestLoader
from htsworkflow.submission import daf, results
from htsworkflow.util.rdfhelp import \
from htsworkflow.submission import daf, results
from htsworkflow.util.rdfhelp import \
-class TestDAF(unittest.TestCase):
+class TestDAF(TestCase):
def test_parse(self):
parsed = daf.fromstring(test_daf)
def test_parse(self):
parsed = daf.fromstring(test_daf)
-class TestUCSCSubmission(unittest.TestCase):
+class TestUCSCSubmission(TestCase):
def setUp(self):
test_results.generate_sample_results_tree(self)
def setUp(self):
test_results.generate_sample_results_tree(self)
os.close(fd)
os.unlink(pathname)
os.close(fd)
os.unlink(pathname)
- suite = unittest.makeSuite(TestDAF, 'test')
- suite.addTest(unittest.makeSuite(TestUCSCSubmission, 'test'))
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestUCSCInfo))
return suite
if __name__ == "__main__":
return suite
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest='suite')
from pprint import pprint
import shutil
import tempfile
from pprint import pprint
import shutil
import tempfile
+
+from unittest2 import TestCase, defaultTestLoader
from htsworkflow.submission.results import ResultMap
from htsworkflow.submission.results import ResultMap
stream.write(f)
stream.close()
stream.write(f)
stream.close()
-class TestResultMap(unittest.TestCase):
+class TestResultMap(TestCase):
def setUp(self):
generate_sample_results_tree(self)
def setUp(self):
generate_sample_results_tree(self)
os.path.join(self.resultdir, f)))
os.path.join(self.resultdir, f)))
- suite = unittest.makeSuite(TestResultMap, 'test')
+ suite = defaultTestLoader.loadTestsFromTestCase(TestResultMap)
return suite
if __name__ == "__main__":
return suite
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
-
+ from unittest2 import main
+ main(defaultTest='suite')
+from unittest2 import TestCase, TestSuite, defaultTestLoader
from StringIO import StringIO
from htsworkflow.submission import ucsc
from StringIO import StringIO
from htsworkflow.submission import ucsc
-class TestUCSCInfo(unittest.TestCase):
+class TestUCSCInfo(TestCase):
def test_parse_encodedcc_file(self):
stream = StringIO(ENCODE_FILES)
file_index = ucsc.parse_ucsc_file_index(stream, 'http://example.com/files')
def test_parse_encodedcc_file(self):
stream = StringIO(ENCODE_FILES)
file_index = ucsc.parse_ucsc_file_index(stream, 'http://example.com/files')
self.assertEquals(attributes['project'], 'wgEncode')
def suite():
self.assertEquals(attributes['project'], 'wgEncode')
def suite():
- suite = unittest.makeSuite(TestUCSCInfo, 'test')
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestUCSCInfo))
return suite
if __name__ == "__main__":
return suite
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
-
+ from unittest2 import main
+ main(defaultTest='suite')
+from unittest2 import TestCase
from htsworkflow.util.alphanum import alphanum
from htsworkflow.util.alphanum import alphanum
-class testAlphanum(unittest.TestCase):
+class testAlphanum(TestCase):
def test_string(self):
unsorted = ['z5', 'b3', 'b10', 'a001', 'a2']
sorted = [ 'a001', 'a2', 'b3', 'b10', 'z5']
def test_string(self):
unsorted = ['z5', 'b3', 'b10', 'a001', 'a2']
sorted = [ 'a001', 'a2', 'b3', 'b10', 'z5']
- return unittest.makeSuite(testAlphanum, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testAlphanum))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from htsworkflow.util import api
from htsworkflow.util import api
-class testApi(unittest.TestCase):
+class testApi(TestCase):
def test_make_key(self):
k1 = api.make_django_secret_key()
k2 = api.make_django_secret_key()
def test_make_key(self):
k1 = api.make_django_secret_key()
k2 = api.make_django_secret_key()
self.failUnless(k1 != k2)
def suite():
self.failUnless(k1 != k2)
def suite():
- return unittest.makeSuite(testApi, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestApi))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from htsworkflow.util import conversion
from htsworkflow.util import conversion
-class TestConversion(unittest.TestCase):
+class TestConversion(TestCase):
def test_parse_slice(self):
s = conversion.parse_slice("1:")
self.failUnlessEqual(s.start, 1)
def test_parse_slice(self):
s = conversion.parse_slice("1:")
self.failUnlessEqual(s.start, 1)
self.failUnlessEqual(s.stop, 2)
def suite():
self.failUnlessEqual(s.stop, 2)
def suite():
- return unittest.makeSuite(TestConversion, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestConversion))
+ return suite
-if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
try:
from xml.etree import ElementTree
try:
from xml.etree import ElementTree
from htsworkflow.util.ethelp import indent, flatten
from htsworkflow.util.ethelp import indent, flatten
-class testETHelper(unittest.TestCase):
+class testETHelper(TestCase):
def setUp(self):
self.foo = '<foo><bar>asdf</bar><br/></foo>'
self.foo_tree = ElementTree.fromstring(self.foo)
def setUp(self):
self.foo = '<foo><bar>asdf</bar><br/></foo>'
self.foo_tree = ElementTree.fromstring(self.foo)
self.failUnless(flatten(self.foo_tree), 'asdf')
def suite():
self.failUnless(flatten(self.foo_tree), 'asdf')
def suite():
- return unittest.makeSuite(testETHelper, 'test')
-
-if __name__ == "__main__":
- unittest.main(defaultTest='suite')
-
-
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testETHelper))
+ return suite
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
from StringIO import StringIO
import os
from StringIO import StringIO
+from unittest2 import TestCase
from htsworkflow.util import makebed
from htsworkflow.util import makebed
-class testMakeBed(unittest.TestCase):
+class testMakeBed(TestCase):
def test_multi_1_0_0_limit_1(self):
instream = StringIO('>HWI-EAS229_26_209LVAAXX:7:3:112:383 TCAAATCTTATGCTANGAATCNCAAATTTTCT 1:0:0 mm9_chr13_random.fa:1240R0')
out = StringIO()
def test_multi_1_0_0_limit_1(self):
instream = StringIO('>HWI-EAS229_26_209LVAAXX:7:3:112:383 TCAAATCTTATGCTANGAATCNCAAATTTTCT 1:0:0 mm9_chr13_random.fa:1240R0')
out = StringIO()
print out
self.failUnlessEqual(len(out), 1)
print out
self.failUnlessEqual(len(out), 1)
-def suite():
- return unittest.makeSuite(testMakeBed, 'test')
-if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testMakeBed))
+ return suite
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
import os
import logging
import time
import os
import logging
import time
+from unittest2 import TestCase
from htsworkflow.util.queuecommands import QueueCommands
from htsworkflow.util.queuecommands import QueueCommands
-class testQueueCommands(unittest.TestCase):
+class testQueueCommands(TestCase):
def setUp(self):
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(name)-8s %(message)s')
def setUp(self):
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(name)-8s %(message)s')
def test_unlimited_run_slow(self):
"""
Run everything at once
def test_unlimited_run_slow(self):
"""
Run everything at once
self.failUnless( end > 3.9 and end < 4.1,
"took %s seconds, expected ~4" % (end,))
self.failUnless( end > 3.9 and end < 4.1,
"took %s seconds, expected ~4" % (end,))
-def suite():
- return unittest.makeSuite(testQueueCommands, 'test')
-
-if __name__ == "__main__":
- unittest.main(defaultTest='suite')
-
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testQueueCommands))
+ return suite
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from datetime import datetime
from datetime import datetime
- class TestRDFHelp(unittest.TestCase):
+ class TestRDFHelp(TestCase):
def test_from_none(self):
self.failUnlessEqual(fromTypedNode(None), None)
def test_from_none(self):
self.failUnlessEqual(fromTypedNode(None), None)
for contenttype, url, parser in DATA:
self.assertEqual(guess_parser(contenttype, url), parser)
for contenttype, url, parser in DATA:
self.assertEqual(guess_parser(contenttype, url), parser)
- class TestRDFSchemas(unittest.TestCase):
+ class TestRDFSchemas(TestCase):
def test_rdf_schema(self):
"""Does it basically work?
"""
def test_rdf_schema(self):
"""Does it basically work?
"""
self.assertTrue(model.contains_statement(s))
self.assertTrue(model.contains_statement(s))
- def suite():
- return unittest.makeSuite(TestRDFHelp, 'test')
except ImportError, e:
print "Unable to test rdfhelp"
except ImportError, e:
print "Unable to test rdfhelp"
- def suite():
- return None
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
-class TestInfer(unittest.TestCase):
+class TestInfer(TestCase):
def setUp(self):
self.model = get_model()
add_default_schemas(self.model)
def setUp(self):
self.model = get_model()
add_default_schemas(self.model)
print errmsg
self.failUnlessEqual(len(errmsg), 0)
print errmsg
self.failUnlessEqual(len(errmsg), 0)
- return unittest.makeSuite(TestInfer, 'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestInfer))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+ from unittest2 import main
+ main(defaultTest="suite")
import os
from StringIO import StringIO
import os
from StringIO import StringIO
+from unittest2 import TestCase
from htsworkflow.util import validate
from htsworkflow.util import validate
-class TestValidate(unittest.TestCase):
+class TestValidate(TestCase):
def test_phred33_works(self):
q = StringIO(u"@ abc\nAGCT\n+\nBBBB\n")
errors = validate.validate_fastq(q)
def test_phred33_works(self):
q = StringIO(u"@ abc\nAGCT\n+\nBBBB\n")
errors = validate.validate_fastq(q)
errors = validate.validate_fastq(q)
self.failUnlessEqual(1, errors)
errors = validate.validate_fastq(q)
self.failUnlessEqual(1, errors)
-def suite():
- return unittest.makeSuite(testValidate, 'test')
-if __name__ == "__main__":
- unittest.main(defaultTest='suite')
+def suite():
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testValidate))
+ return suite
+if __name__ == "__main__":
+ from unittest2 import main
+ main(defaultTest="suite")
+from unittest2 import TestCase
from StringIO import StringIO
from htsworkflow.automation import copier
from htsworkflow.automation.solexa import is_runfolder
from StringIO import StringIO
from htsworkflow.automation import copier
from htsworkflow.automation.solexa import is_runfolder
-class testCopier(unittest.TestCase):
+class testCopier(TestCase):
def test_empty_config(self):
cfg = StringIO("""[fake]
something: unrelated
def test_empty_config(self):
cfg = StringIO("""[fake]
something: unrelated
self.failUnlessEqual(len(result), 1)
self.failUnlessEqual(result[0][-1], '4')
self.failUnlessEqual(len(result), 1)
self.failUnlessEqual(result[0][-1], '4')
- return unittest.makeSuite(testCopier,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testCopier))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")
import os
from StringIO import StringIO
import sys
import os
from StringIO import StringIO
import sys
+from unittest2 import TestCase
_module_path, _module_name = os.path.split(__file__)
sys.path.append(os.path.join(_module_path, '..', 'scripts'))
_module_path, _module_name = os.path.split(__file__)
sys.path.append(os.path.join(_module_path, '..', 'scripts'))
from htsworkflow.pipelines import srf2fastq
from htsworkflow.pipelines import srf2fastq
-class testSrf2Fastq(unittest.TestCase):
+class testSrf2Fastq(TestCase):
def test_split_good(self):
source = StringIO("""@header
AGCTTTTT
def test_split_good(self):
source = StringIO("""@header
AGCTTTTT
self.failUnlessEqual(is_cnf1(cnf4_path), False)
self.failUnlessEqual(is_cnf1(cnf1_path), True)
self.failUnlessEqual(is_cnf1(cnf4_path), False)
self.failUnlessEqual(is_cnf1(cnf1_path), True)
- return unittest.makeSuite(testSrf2Fastq,'test')
+ from unittest2 import TestSuite, defaultTestLoader
+ suite = TestSuite()
+ suite.addTests(defaultTestLoader.loadTestsFromTestCase(testSrf2Fastq))
+ return suite
+
if __name__ == "__main__":
if __name__ == "__main__":
- unittest.main(defaultTest="suite")
+ from unittest2 import main
+ main(defaultTest="suite")