6
|
1 # Copyright INRA (Institut National de la Recherche Agronomique)
|
|
2 # http://www.inra.fr
|
|
3 # http://urgi.versailles.inra.fr
|
|
4 #
|
|
5 # This software is governed by the CeCILL license under French law and
|
|
6 # abiding by the rules of distribution of free software. You can use,
|
|
7 # modify and/ or redistribute the software under the terms of the CeCILL
|
|
8 # license as circulated by CEA, CNRS and INRIA at the following URL
|
|
9 # "http://www.cecill.info".
|
|
10 #
|
|
11 # As a counterpart to the access to the source code and rights to copy,
|
|
12 # modify and redistribute granted by the license, users are provided only
|
|
13 # with a limited warranty and the software's author, the holder of the
|
|
14 # economic rights, and the successive licensors have only limited
|
|
15 # liability.
|
|
16 #
|
|
17 # In this respect, the user's attention is drawn to the risks associated
|
|
18 # with loading, using, modifying and/or developing or reproducing the
|
|
19 # software by the user in light of its specific status of free software,
|
|
20 # that may mean that it is complicated to manipulate, and that also
|
|
21 # therefore means that it is reserved for developers and experienced
|
|
22 # professionals having in-depth computer knowledge. Users are therefore
|
|
23 # encouraged to load and test the software's suitability as regards their
|
|
24 # requirements in conditions enabling the security of their systems and/or
|
|
25 # data to be ensured and, more generally, to use and operate it in the
|
|
26 # same conditions as regards security.
|
|
27 #
|
|
28 # The fact that you are presently reading this means that you have had
|
|
29 # knowledge of the CeCILL license and that you accept its terms.
|
|
30
|
|
31
|
|
32 import unittest
|
|
33 import os
|
|
34 import ConfigParser
|
|
35 from commons.core.checker.CheckerUtils import CheckerUtils
|
|
36 from commons.core.checker.CheckerException import CheckerException
|
|
37 from ConfigParser import NoOptionError
|
|
38 from ConfigParser import NoSectionError
|
|
39
|
|
40 class Test_CheckerUtils( unittest.TestCase ):
|
|
41
|
|
42 def setUp(self):
|
|
43 self.queueFileName = "queueName.txt"
|
|
44 self.configFileName = "dummyConfig.cfg"
|
|
45
|
|
46 def tearDown(self):
|
|
47 if os.path.exists(self.queueFileName):
|
|
48 os.remove(self.queueFileName)
|
|
49 if os.path.exists(self.configFileName):
|
|
50 os.remove(self.configFileName)
|
|
51
|
|
52 def test_isBlastNameInBlastValues( self ):
|
|
53 correctValueList = [ "blastn", "blastp", "blastx", "tblastn", "tblastx" ]
|
|
54 for value in correctValueList:
|
|
55 self.assertFalse( CheckerUtils.isBlastNameNotInBlastValues( value ) )
|
|
56
|
|
57 incorrectValueList = [ "badbalst", "wublast" ]
|
|
58 for value in incorrectValueList:
|
|
59 self.assertTrue( CheckerUtils.isBlastNameNotInBlastValues( value ) )
|
|
60
|
|
61 def test_isNotTRUEisNotFALSE( self ):
|
|
62 correctValueList = [ "TRUE", "FALSE" ]
|
|
63 for value in correctValueList:
|
|
64 self.assertFalse( CheckerUtils.isNotTRUEisNotFALSE( value ) )
|
|
65
|
|
66 incorrectValueList = [ "True", "False" ]
|
|
67 for value in incorrectValueList:
|
|
68 self.assertTrue( CheckerUtils.isNotTRUEisNotFALSE( value ) )
|
|
69
|
|
70 def test_isRessourceNotExists( self ):
|
|
71 fileName = "dummyFile.txt"
|
|
72 self.assertTrue( CheckerUtils.isRessourceNotExits( fileName ) )
|
|
73 os.system( "touch %s" % ( fileName ) )
|
|
74 self.assertFalse( CheckerUtils.isRessourceNotExits( fileName ) )
|
|
75 os.remove( fileName )
|
|
76
|
|
77 def test_isNotAeValueWithOneDigit2DecimalsAtLeast( self ):
|
|
78 correctEValueList = [ "5e-32", "7e-45", "1e-2122", "9e-32" ]
|
|
79 for value in correctEValueList:
|
|
80 self.assertFalse( CheckerUtils.isNotAeValueWithOneDigit2DecimalsAtLeast( value ) )
|
|
81
|
|
82 incorrecEValueStr = [ "10e-32", "2e-3", "2e-2", "1", "cxhhe" ]
|
|
83 for value in incorrecEValueStr:
|
|
84 self.assertTrue( CheckerUtils.isNotAeValueWithOneDigit2DecimalsAtLeast( value ) )
|
|
85
|
|
86 def test_isNotADigit( self ):
|
|
87 correctDigitList = [ "1", "21", "345" ]
|
|
88 for value in correctDigitList:
|
|
89 self.assertFalse( CheckerUtils.isNotANumber( value ) )
|
|
90
|
|
91 incorrectDigitList = [ "A", "dfdf", "((((" ]
|
|
92 for value in incorrectDigitList:
|
|
93 self.assertTrue( CheckerUtils.isNotANumber( value ) )
|
|
94
|
|
95 def test_isExecutableInUserPath( self ):
|
|
96 exeName = "ls"
|
|
97 self.assertTrue( CheckerUtils.isExecutableInUserPath( exeName ) )
|
|
98
|
|
99 exeName = "hsvegdtefaobfbcheta"
|
|
100 self.assertFalse( CheckerUtils.isExecutableInUserPath( exeName ) )
|
|
101
|
|
102 def test_isExecutableInUserPath_case_endsWith( self ):
|
|
103 exeName = "s"
|
|
104 self.assertFalse( CheckerUtils.isExecutableInUserPath( exeName ) )
|
|
105
|
|
106 def test_isQueueNameValid_valid(self):
|
|
107 cmd = "qconf -sql > " + self.queueFileName
|
|
108 os.system(cmd)
|
|
109 f = open(self.queueFileName, "r")
|
|
110 lQueueNames = f.readlines()
|
|
111 f.close()
|
|
112 if lQueueNames == []:
|
|
113 print "Warning you need SGE installed\n"
|
|
114 else:
|
|
115 self.assertTrue(CheckerUtils.isQueueNameValid(lQueueNames[0].strip()))
|
|
116
|
|
117 def test_isQueueNameValid_not_valid(self):
|
|
118 cmd = "qconf -sql > " + self.queueFileName
|
|
119 os.system(cmd)
|
|
120 f = open(self.queueFileName, "r")
|
|
121 lQueueNames = f.readlines()
|
|
122 f.close()
|
|
123 if lQueueNames == []:
|
|
124 print "Warning you need SGE installed\n"
|
|
125 else:
|
|
126 self.assertFalse(CheckerUtils.isQueueNameValid("dummyQueueName"))
|
|
127
|
|
128 def test_isQueueNameValid_valid_with_parameter(self):
|
|
129 cmd = "qconf -sql > " + self.queueFileName
|
|
130 os.system(cmd)
|
|
131 f = open(self.queueFileName, "r")
|
|
132 lQueueNames = f.readlines()
|
|
133 f.close()
|
|
134 if lQueueNames == []:
|
|
135 print "Warning you need SGE installed\n"
|
|
136 else:
|
|
137 queueNameWithParameter = lQueueNames[0].strip() + " test=TRUE"
|
|
138 self.assertTrue(CheckerUtils.isQueueNameValid(queueNameWithParameter))
|
|
139
|
|
140 def test_isCharAlphanumOrUnderscore_valid(self):
|
|
141 project_name = "Project_Name"
|
|
142 self.assertTrue(CheckerUtils.isCharAlphanumOrUnderscore(project_name))
|
|
143
|
|
144 def test_isCharAlphanumOrUnderscore_not_valid(self):
|
|
145 project_name = "Project_Name,"
|
|
146 self.assertFalse(CheckerUtils.isCharAlphanumOrUnderscore(project_name))
|
|
147
|
|
148 def test_isMax15Char_valid(self):
|
|
149 project_name = "Project_Name"
|
|
150 self.assertTrue(CheckerUtils.isMax15Char(project_name))
|
|
151
|
|
152 def test_isMax15Char_not_valid(self):
|
|
153 project_name = "Project_Name_tooLong"
|
|
154 self.assertFalse(CheckerUtils.isMax15Char(project_name))
|
|
155
|
|
156 def test_checkSectionInConfigFile_empty_section(self):
|
|
157 sectionName = "sectionName"
|
|
158 line = "[" + sectionName + "]"
|
|
159 configFile = open(self.configFileName, "w")
|
|
160 configFile.write(line)
|
|
161 configFile.close()
|
|
162 configFile = open(self.configFileName, "r")
|
|
163
|
|
164 config = ConfigParser.ConfigParser()
|
|
165 config.readfp(configFile)
|
|
166
|
|
167 isSectionExceptionRaised = False
|
|
168 try:
|
|
169 CheckerUtils.checkSectionInConfigFile(config, sectionName)
|
|
170 except NoSectionError:
|
|
171 isSectionExceptionRaised = True
|
|
172 configFile.close()
|
|
173 self.assertFalse(isSectionExceptionRaised)
|
|
174
|
|
175 def test_checkSectionInConfigFile(self):
|
|
176 sectionName = "sectionName"
|
|
177 lines = "[" + sectionName + "]\ndummyOption : dummyOption\n"
|
|
178 configFile = open(self.configFileName, "w")
|
|
179 configFile.write(lines)
|
|
180 configFile.close()
|
|
181 configFile = open(self.configFileName, "r")
|
|
182
|
|
183 config = ConfigParser.ConfigParser()
|
|
184 config.readfp(configFile)
|
|
185
|
|
186 isSectionExceptionRaised = False
|
|
187 try:
|
|
188 CheckerUtils.checkSectionInConfigFile(config, sectionName)
|
|
189 except NoSectionError:
|
|
190 isSectionExceptionRaised = True
|
|
191 configFile.close()
|
|
192 self.assertFalse(isSectionExceptionRaised)
|
|
193
|
|
194 def test_checkSectionInConfigFile_not_valid(self):
|
|
195 sectionName = "sectionName"
|
|
196 line = " "
|
|
197 configFile = open(self.configFileName, "w")
|
|
198 configFile.write(line)
|
|
199 configFile.close()
|
|
200 configFile = open(self.configFileName, "r")
|
|
201
|
|
202 config = ConfigParser.ConfigParser()
|
|
203 config.readfp(configFile)
|
|
204
|
|
205 isSectionExceptionRaised = False
|
|
206 try:
|
|
207 CheckerUtils.checkSectionInConfigFile(config, sectionName)
|
|
208 except NoSectionError:
|
|
209 isSectionExceptionRaised = True
|
|
210 configFile.close()
|
|
211 self.assertTrue(isSectionExceptionRaised)
|
|
212
|
|
213 def test_checkOptionInSectionInConfigFile(self):
|
|
214 optionName = "optionName"
|
|
215 sectionName = "sectionName"
|
|
216 configFile = open(self.configFileName, "w")
|
|
217 configFile.write("[" + sectionName + "]\n")
|
|
218 configFile.write(optionName + ": ")
|
|
219 configFile.close()
|
|
220 configFile = open(self.configFileName, "r")
|
|
221
|
|
222 config = ConfigParser.ConfigParser()
|
|
223 config.readfp(configFile)
|
|
224
|
|
225 isSectionExceptionRaised = False
|
|
226 try:
|
|
227 CheckerUtils.checkOptionInSectionInConfigFile(config, sectionName, optionName)
|
|
228 except NoOptionError:
|
|
229 isSectionExceptionRaised = True
|
|
230 configFile.close()
|
|
231 self.assertFalse(isSectionExceptionRaised)
|
|
232
|
|
233 def test_checkOptionInSectionInConfigFile_not_present(self):
|
|
234 optionName = " "
|
|
235 sectionName = "sectionName"
|
|
236 configFile = open(self.configFileName, "w")
|
|
237 configFile.write("[" + sectionName + "]\n")
|
|
238 configFile.write(optionName)
|
|
239 configFile.close()
|
|
240 configFile = open(self.configFileName, "r")
|
|
241
|
|
242 config = ConfigParser.ConfigParser()
|
|
243 config.readfp(configFile)
|
|
244
|
|
245 isSectionExceptionRaised = False
|
|
246 try:
|
|
247 CheckerUtils.checkOptionInSectionInConfigFile(config, sectionName, optionName)
|
|
248 except NoOptionError:
|
|
249 isSectionExceptionRaised = True
|
|
250 configFile.close()
|
|
251 self.assertTrue(isSectionExceptionRaised)
|
|
252
|
|
253 def test_checkOptionInSectionInConfigFile_not_in_the_right_section(self):
|
|
254 optionName = "optionName"
|
|
255 rightSection = "dummySection2"
|
|
256 configFile = open(self.configFileName, "w")
|
|
257 configFile.write("[dummySection1]\n")
|
|
258 configFile.write(optionName + ": \n")
|
|
259 configFile.write("[" + rightSection + "]")
|
|
260 configFile.close()
|
|
261 configFile = open(self.configFileName, "r")
|
|
262
|
|
263 config = ConfigParser.ConfigParser()
|
|
264 config.readfp(configFile)
|
|
265
|
|
266 isSectionExceptionRaised = False
|
|
267 try:
|
|
268 CheckerUtils.checkOptionInSectionInConfigFile(config, rightSection, optionName)
|
|
269 except NoOptionError:
|
|
270 isSectionExceptionRaised = True
|
|
271 configFile.close()
|
|
272 self.assertTrue(isSectionExceptionRaised)
|
|
273
|
|
274 def test_checkConfigVersion_different_version_between_changeLog_and_configFile(self):
|
|
275 changeLogFileName = "dummyCHANGELOG"
|
|
276
|
|
277 self._writeChangeLogFile(changeLogFileName)
|
|
278 self._writeConfigFile("repet_version: 1.3.5\n")
|
|
279
|
|
280 changeLogFileHandler = open(changeLogFileName, "r")
|
|
281 configFileHandler = open(self.configFileName, "r")
|
|
282 config = ConfigParser.ConfigParser()
|
|
283 config.readfp(configFileHandler)
|
|
284
|
|
285 self.assertRaises(CheckerException, CheckerUtils.checkConfigVersion, changeLogFileHandler, config)
|
|
286
|
|
287 changeLogFileHandler.close()
|
|
288 configFileHandler.close()
|
|
289 os.remove(changeLogFileName)
|
|
290
|
|
291 def test_checkConfigVersion_same_version_between_changeLog_and_configFile(self):
|
|
292 changeLogFileName = "dummyCHANGELOG"
|
|
293 self._writeChangeLogFile(changeLogFileName)
|
|
294 self._writeConfigFile("repet_version: 1.3.6\n")
|
|
295
|
|
296 changeLogFileHandler = open(changeLogFileName, "r")
|
|
297 configFileHandler = open(self.configFileName, "r")
|
|
298 config = ConfigParser.ConfigParser()
|
|
299 config.readfp(configFileHandler)
|
|
300
|
|
301 isCheckerExceptionRaised = False
|
|
302 try:
|
|
303 CheckerUtils.checkConfigVersion(changeLogFileHandler, config)
|
|
304 except CheckerException:
|
|
305 isCheckerExceptionRaised = True
|
|
306 self.assertFalse(isCheckerExceptionRaised)
|
|
307
|
|
308 changeLogFileHandler.close()
|
|
309 configFileHandler.close()
|
|
310 os.remove(changeLogFileName)
|
|
311
|
|
312 def test_getVersionFromChangelogFile(self):
|
|
313 changeLogFileName = "dummyCHANGELOG"
|
|
314 self._writeChangeLogFile(changeLogFileName)
|
|
315 obsVer = CheckerUtils.getVersionFromChangelogFile(changeLogFileName)
|
|
316 expVer = "1.3.6"
|
|
317
|
|
318 self.assertEquals(obsVer, expVer)
|
|
319
|
|
320 os.remove(changeLogFileName)
|
|
321
|
|
322 def test_checkConfigVersion_check_exception_message(self):
|
|
323 changeLogFileName = "dummyCHANGELOG"
|
|
324 self._writeChangeLogFile(changeLogFileName)
|
|
325 self._writeConfigFile("repet_version: 1.3.5\n")
|
|
326
|
|
327 changeLogFileHandler = open(changeLogFileName, "r")
|
|
328 configFileHandler = open(self.configFileName, "r")
|
|
329 config = ConfigParser.ConfigParser()
|
|
330 config.readfp(configFileHandler)
|
|
331
|
|
332 checkerExceptionInstance = None
|
|
333 try:
|
|
334 CheckerUtils.checkConfigVersion(changeLogFileHandler, config)
|
|
335 except CheckerException, e:
|
|
336 checkerExceptionInstance = e
|
|
337
|
|
338 expMessage = "*** Error: wrong config file version. Expected version num is 1.3.6 but actual in config file is 1.3.5"
|
|
339 obsMessage = checkerExceptionInstance.msg
|
|
340
|
|
341 self.assertEquals(expMessage, obsMessage)
|
|
342
|
|
343 def test_checkHeaders_first_header_with_question_mark(self):
|
|
344 fastaFileName = "dummyFasta.fa"
|
|
345 self._writeFastaFile_first_header_with_question_mark(fastaFileName)
|
|
346 fastaFileHandler = open(fastaFileName,"r")
|
|
347 isExceptionRaised = False
|
|
348 try:
|
|
349 CheckerUtils.checkHeaders(fastaFileHandler)
|
|
350 except CheckerException, e:
|
|
351 isExceptionRaised = True
|
|
352
|
|
353 fastaFileHandler.close()
|
|
354 os.remove(fastaFileName)
|
|
355
|
|
356 self.assertTrue(isExceptionRaised)
|
|
357
|
|
358 expMessages = ["DmelChr4_Bla?ster_Piler_0.0_Map_3"]
|
|
359 obsMessages = e.getMessages()
|
|
360
|
|
361 self.assertEquals(expMessages, obsMessages)
|
|
362
|
|
363 def test_checkHeaders_with_2_wrong_headers(self):
|
|
364 fastaFileName = "dummyFasta.fa"
|
|
365 self._writeFastaFile_with_2_wrong_headers(fastaFileName)
|
|
366 fastaFileHandler = open(fastaFileName,"r")
|
|
367 isExceptionRaised = False
|
|
368 try:
|
|
369 CheckerUtils.checkHeaders(fastaFileHandler)
|
|
370 except CheckerException, e:
|
|
371 isExceptionRaised = True
|
|
372
|
|
373 fastaFileHandler.close()
|
|
374 os.remove(fastaFileName)
|
|
375
|
|
376 self.assertTrue(isExceptionRaised)
|
|
377
|
|
378 expMessages = ["DmelChr4_Bla?ster_Piler_0.0_Map_3","DmelChr4_Bla!ster_Piler_1.0_Map_9"]
|
|
379 obsMessages = e.getMessages()
|
|
380
|
|
381 self.assertEquals(expMessages, obsMessages)
|
|
382
|
|
383 def test_checkHeaders_with_pipe(self):
|
|
384 fastaFileName = "dummyFasta.fa"
|
|
385 self._writeFastaFile_with_pipe(fastaFileName)
|
|
386 fastaFileHandler = open(fastaFileName,"r")
|
|
387 isExceptionRaised = False
|
|
388 try:
|
|
389 CheckerUtils.checkHeaders(fastaFileHandler)
|
|
390 except CheckerException, e:
|
|
391 isExceptionRaised = True
|
|
392
|
|
393 fastaFileHandler.close()
|
|
394 os.remove(fastaFileName)
|
|
395
|
|
396 self.assertTrue(isExceptionRaised)
|
|
397
|
|
398 expMessages = ["DmelC|hr4_Blas-ter_Piler_1.0_Map_9"]
|
|
399 obsMessages = e.getMessages()
|
|
400
|
|
401 self.assertEquals(expMessages, obsMessages)
|
|
402
|
|
403 def test_checkHeaders_with_equal(self):
|
|
404 fastaFileName = "dummyFasta.fa"
|
|
405 self._writeFastaFile_with_equal(fastaFileName)
|
|
406 fastaFileHandler = open(fastaFileName,"r")
|
|
407 isExceptionRaised = False
|
|
408 try:
|
|
409 CheckerUtils.checkHeaders(fastaFileHandler)
|
|
410 except CheckerException, e:
|
|
411 isExceptionRaised = True
|
|
412
|
|
413 fastaFileHandler.close()
|
|
414 os.remove(fastaFileName)
|
|
415
|
|
416 self.assertTrue(isExceptionRaised)
|
|
417
|
|
418 expMessages = ["DmelC:hr4_Blas=ter_Piler_1.0_Map_9"]
|
|
419 obsMessages = e.getMessages()
|
|
420
|
|
421 self.assertEquals(expMessages, obsMessages)
|
|
422
|
|
423 def test_checkHeaders_all_headers_ok(self):
|
|
424 fastaFileName = "dummyFasta.fa"
|
|
425 self._writeFastaFile_all_headers_ok(fastaFileName)
|
|
426 fastaFileHandler = open(fastaFileName,"r")
|
|
427 isExceptionRaised = False
|
|
428 try:
|
|
429 CheckerUtils.checkHeaders(fastaFileHandler)
|
|
430 except CheckerException:
|
|
431 isExceptionRaised = True
|
|
432
|
|
433 fastaFileHandler.close()
|
|
434 os.remove(fastaFileName)
|
|
435
|
|
436 self.assertFalse(isExceptionRaised)
|
|
437
|
|
438 def _writeFastaFile_first_header_with_question_mark(self, fastaFileName):
|
|
439 fastaFileHandler = open(fastaFileName, "w")
|
|
440 fastaFileHandler.write(">DmelChr4_Bla?ster_Piler_0.0_Map_3\n")
|
|
441 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n")
|
|
442 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n")
|
|
443 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n")
|
|
444 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n")
|
|
445 fastaFileHandler.write(">DmelChr4_Blaster_Piler_1.0_Map_9\n")
|
|
446 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n")
|
|
447 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n")
|
|
448 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n")
|
|
449 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n")
|
|
450 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n")
|
|
451 fastaFileHandler.close()
|
|
452
|
|
453 def _writeFastaFile_with_2_wrong_headers(self, fastaFileName):
|
|
454 fastaFileHandler = open(fastaFileName, "w")
|
|
455 fastaFileHandler.write(">DmelChr4_Bla?ster_Piler_0.0_Map_3\n")
|
|
456 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n")
|
|
457 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n")
|
|
458 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n")
|
|
459 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n")
|
|
460 fastaFileHandler.write(">DmelChr4_Bla!ster_Piler_1.0_Map_9\n")
|
|
461 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n")
|
|
462 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n")
|
|
463 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n")
|
|
464 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n")
|
|
465 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n")
|
|
466 fastaFileHandler.close()
|
|
467
|
|
468 def _writeFastaFile_all_headers_ok(self, fastaFileName):
|
|
469 fastaFileHandler = open(fastaFileName, "w")
|
|
470 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n")
|
|
471 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n")
|
|
472 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n")
|
|
473 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n")
|
|
474 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n")
|
|
475 fastaFileHandler.write(">DmelC:hr4_Blas-ter_Piler_1.0_Map_9\n")
|
|
476 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n")
|
|
477 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n")
|
|
478 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n")
|
|
479 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n")
|
|
480 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n")
|
|
481 fastaFileHandler.close()
|
|
482
|
|
483 def _writeFastaFile_with_pipe(self, fastaFileName):
|
|
484 fastaFileHandler = open(fastaFileName, "w")
|
|
485 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n")
|
|
486 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n")
|
|
487 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n")
|
|
488 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n")
|
|
489 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n")
|
|
490 fastaFileHandler.write(">DmelC|hr4_Blas-ter_Piler_1.0_Map_9\n")
|
|
491 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n")
|
|
492 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n")
|
|
493 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n")
|
|
494 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n")
|
|
495 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n")
|
|
496 fastaFileHandler.close()
|
|
497
|
|
498 def _writeFastaFile_with_equal(self, fastaFileName):
|
|
499 fastaFileHandler = open(fastaFileName, "w")
|
|
500 fastaFileHandler.write(">DmelChr4_Blaster_Piler_0.0_Map_3\n")
|
|
501 fastaFileHandler.write("ACCAAAGACACTAGAATAACAAGATGCGTAACGCCATACGATTTTTTGGCACACTATTTT\n")
|
|
502 fastaFileHandler.write("TTCGCCGTGGCTCTAGAGGTGGCTCCAGGCTCTCTCGAATTTTTGTTAGAGAGCGAGAGA\n")
|
|
503 fastaFileHandler.write("GCTGAGAGCGCTACAGCGAACAGCTCTTTTCTACACATAAAGTGATAGCAGACAACTGTA\n")
|
|
504 fastaFileHandler.write("TGTGTGCACACGTGTGCTCATGCATTGTAAATTTGACAAAATATGCCCTTCACCTTCAAA\n")
|
|
505 fastaFileHandler.write(">DmelC:hr4_Blas=ter_Piler_1.0_Map_9\n")
|
|
506 fastaFileHandler.write("AGTTTAAAAACCAAAGACACTAGAATAACAAGATGCGTAACGGCCATACATTGGTTTGGC\n")
|
|
507 fastaFileHandler.write("ACTATGCAGCCACTTTTTTGGTGACGGCCAAAATTACTCTCTTTCCGCTCACTCCCGCTG\n")
|
|
508 fastaFileHandler.write("AGAGCGTAAGAAATCTAAAAATATAATTTGCTTGCTTGTGTGAGTAAAAACAAGAGACGA\n")
|
|
509 fastaFileHandler.write("GAACGCGTATAAGTGTGCGTGTTGTGCTAGAAGACGATTTTCGGGACCGAAATCAATTCT\n")
|
|
510 fastaFileHandler.write("GATCGAAGAAACGAATTTACATGGTACATATTAGGGTAGTTTTTGCCAATTTCCTAGCAA\n")
|
|
511 fastaFileHandler.close()
|
|
512
|
|
513 def _writeChangeLogFile(self, changeLogFileName ):
|
|
514 changeLogFileHandler = open(changeLogFileName, "w")
|
|
515 changeLogFileHandler.write("ChangeLog of REPET\n")
|
|
516 changeLogFileHandler.write("\n")
|
|
517 changeLogFileHandler.write("\n")
|
|
518 changeLogFileHandler.write("\n")
|
|
519 changeLogFileHandler.write("REPET release 1.3.6\n")
|
|
520 changeLogFileHandler.write("(release date XX/XX/2010)\n")
|
|
521 changeLogFileHandler.write("\n")
|
|
522 changeLogFileHandler.close()
|
|
523
|
|
524 def _writeConfigFile(self, lineVersion):
|
|
525 configFileHandler = open(self.configFileName, "w")
|
|
526 configFileHandler.write("[repet_env]\n")
|
|
527 configFileHandler.write(lineVersion)
|
|
528 configFileHandler.write("repet_host: <your_MySQL_host>\n")
|
|
529 configFileHandler.close()
|
|
530
|
|
531
|
|
532 test_suite = unittest.TestSuite()
|
|
533 test_suite.addTest( unittest.makeSuite( Test_CheckerUtils ) )
|
|
534 if __name__ == "__main__":
|
|
535 unittest.TextTestRunner(verbosity=2).run( test_suite )
|