Cyclone-Team/gramps
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

2008-01-09 Raphael Ackermann <raphael.ackermann@gmail.com> From PEP8 Always use 'self' for the first argument to instance methods.

Browse Source 
svn: r9767
This commit is contained in:
Raphael Ackermann 2008-01-09 16:47:56 +00:00
parent c6a8810305
commit 2857943955
11 changed files with 181 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ChangeLog
View File

@ -1,3 +1,16 @@
2008-01-09 Raphael Ackermann <raphael.ackermann@gmail.com>
* src/gen/utils/callback.py
* src/ObjectSelector/_FamilyFilterFrame.py
* src/test/test/test_util_test.py
* src/test/test/gedread_util_test.py
* src/test/test_util.py
* src/test/gramps_cli_test.py
* src/test/ansel_utf8_test.py
* src/GrampsDbUtils/test/_GedcomChar_test.py
* src/GrampsDbUtils/test/_GrampsDbWRFactories_test.py
* src/GrampsDbUtils/test/GR_test.py
From PEP8 Always use 'self' for the first argument to instance methods.
2008-01-09 Raphael Ackermann <raphael.ackermann@gmail.com>
* src/plugins/ExportVCard.py: in write_person use b_date instead of date
0001497: small typo and imports cleanup in ExportVCard.py

50
src/GrampsDbUtils/test/GR_test.py
View File

@ -58,28 +58,28 @@ class nc():
NB: name _must_ match the X names in db get_number_of_X
"""
def dbncheck(s, dbcall):
def dbncheck(self, dbcall):
err = None
got = dbcall()
if not got == s.num:
err = "%s: got %d, expected %d" % (s.name, got, s.num)
if not got == self.num:
err = "%s: got %d, expected %d" % (self.name, got, self.num)
return err
def __init__(s, name, num):
s.name = name
s.num = num
s.getname = "get_number_of_" + name
def __call__(s, db):
dbcall = getattr(db,s.getname)
s.dbncheck(dbcall)
def __init__(self, name, num):
self.name = name
self.num = num
self.getname = "get_number_of_" + name
def __call__(self, db):
dbcall = getattr(db,self.getname)
self.dbncheck(dbcall)
class fnci():
"""fnci (frag-numcheckset item) is a data container for:
a fragment of gedcom
a sequence of nc items to check
"""
def __init__(s, frag, ncset):
s.frag = frag
s.ncset = ncset
def __init__(self, frag, ncset):
self.frag = frag
self.ncset = ncset
# test data table for Test1.test1a_numchecks
fnumchecks = (
@ -119,28 +119,28 @@ def _checklog(tlogger, pat=None):
class Test1(U.TestCase):
def setUp(s):
def setUp(self):
# make a test subdir and compose some pathnames
s.tdir = tu.make_subdir("RG_test")
s.tdb = op.join(s.tdir,"test_db")
s.ifil = op.join(s.tdir,"test_in.ged")
s.lfil = op.join(s.tdir,"test.log")
self.tdir = tu.make_subdir("RG_test")
self.tdb = op.join(self.tdir,"test_db")
self.ifil = op.join(self.tdir,"test_in.ged")
self.lfil = op.join(self.tdir,"test.log")
def test1a_numchecks(s):
def test1a_numchecks(self):
tl = tu.TestLogger()
for i,f in enumerate(fnumchecks):
gr.make_gedcom_input(s.ifil, f.frag)
db = gr.create_empty_db(s.tdb)
tl.logfile_init(s.lfil)
gr.gread(db,s.ifil)
gr.make_gedcom_input(self.ifil, f.frag)
db = gr.create_empty_db(self.tdb)
tl.logfile_init(self.lfil)
gr.gread(db,self.ifil)
errs = _checklog(tl, r"Line \d+")
s.assertEquals(errs, 0,
self.assertEquals(errs, 0,
"ncset(%d): got %d unexpected log messages" %
(i,errs))
# ok, no log error message, check db counts
for call in f.ncset:
err = call(db)
s.assertFalse(err, err)
self.assertFalse(err, err)
if __name__ == "__main__":
U.main()

100
src/GrampsDbUtils/test/_GedcomChar_test.py
View File

@ -40,22 +40,22 @@ class Test1_ansi(unittest.TestCase):
fil = os.path.join(cdir,enc)
exp = utest_chars
def setUp(s):
gen_chars(s.fil, s.enc)
def setUp(self):
gen_chars(self.fil, self.enc)
def test1a_read_ansi(s):
f = open(s.fil)
def test1a_read_ansi(self):
f = open(self.fil)
ra= G.AnsiReader(f)
got = ra.readline()
s.assertEquals(got,s.exp, m(got,s.exp, "AnsiReader"))
self.assertEquals(got,self.exp, m(got,self.exp, "AnsiReader"))
def test1b_read_codec_latin1(s):
got=codecs.open(s.fil, encoding=s.enc).read()
s.assertEquals(got,s.exp, m(got,s.exp, "using codec %s" % s.enc))
def test1b_read_codec_latin1(self):
got=codecs.open(self.fil, encoding=self.enc).read()
self.assertEquals(got,self.exp, m(got,self.exp, "using codec %s" % self.enc))
def test1c_read_codec_cp1252(s):
got=codecs.open(s.fil, encoding=s.cp).read()
s.assertEquals(got,s.exp, m(got,s.exp, "using codec %s" % s.cp))
def test1c_read_codec_cp1252(self):
got=codecs.open(self.fil, encoding=self.cp).read()
self.assertEquals(got,self.exp, m(got,self.exp, "using codec %s" % self.cp))
###
class Test2_ansel(unittest.TestCase):
@ -64,14 +64,14 @@ class Test2_ansel(unittest.TestCase):
afil = os.path.join(cdir,enc)
exp = a2u
def setUp(s):
open(s.afil, "wb").write(atest_bytes)
def setUp(self):
open(self.afil, "wb").write(atest_bytes)
def test2a_read_ansel(s):
f = open(s.afil)
def test2a_read_ansel(self):
f = open(self.afil)
ra = G.AnselReader(f)
got = ra.readline()
s.assertEquals(got,s.exp, m(got,s.exp, "AnselReader"))
self.assertEquals(got,self.exp, m(got,self.exp, "AnselReader"))
###
class Test3(unittest.TestCase):
@ -86,35 +86,35 @@ class Test3(unittest.TestCase):
f1byte = os.path.join(cdir, "1byte")
exp = utest_chars
def setUp(s):
gen_chars(s.ufil, s.enc)
if not os.path.exists(s.f1byte):
open(s.f1byte, "wb").write("1")
def setUp(self):
gen_chars(self.ufil, self.enc)
if not os.path.exists(self.f1byte):
open(self.f1byte, "wb").write("1")
def test3a_u8_UTF8Reader_NO_BOM_sig(s):
f=open(s.ufil)
def test3a_u8_UTF8Reader_NO_BOM_sig(self):
f=open(self.ufil)
ra=G.UTF8Reader(f)
g = ra.readline()
s.assertEquals(g,s.exp, m(g,s.exp, "orig UTF8Reader"))
r2 = G.UTF8Reader(open(s.f1byte))
self.assertEquals(g,self.exp, m(g,self.exp, "orig UTF8Reader"))
r2 = G.UTF8Reader(open(self.f1byte))
g = r2.readline()
s.assertEquals(g,"1",
self.assertEquals(g,"1",
m(g,"1", "read 1-byte file"))
# NB: utf_8 reads data and never expects a BOM-sig
def test3b_utf8_codec_NO_BOM_sig_as_expected(s):
g=codecs.open(s.ufil, encoding=s.enc).read()
s.assertEquals(g,s.exp, m(g,s.exp, "codec utf8"))
g=codecs.open(s.f1byte, encoding=s.enc).read()
s.assertEquals(g,"1", m(g,"1", "codec utf8"))
def test3b_utf8_codec_NO_BOM_sig_as_expected(self):
g=codecs.open(self.ufil, encoding=self.enc).read()
self.assertEquals(g,self.exp, m(g,self.exp, "codec utf8"))
g=codecs.open(self.f1byte, encoding=self.enc).read()
self.assertEquals(g,"1", m(g,"1", "codec utf8"))
# NB: utf_8_sig reads data even absent a BOM-sig (GOOD!)
def test3c_utf8_sig_codec_NO_BOM_sig_tolerated_GOOD(s):
g=codecs.open(s.ufil, encoding=s.enc_sig).read()
s.assertEquals(g,s.exp,
m(g,s.exp, "codec utf_8_sig NO sig input"))
g=codecs.open(s.f1byte, encoding=s.enc_sig).read()
s.assertEquals(g,"1",
def test3c_utf8_sig_codec_NO_BOM_sig_tolerated_GOOD(self):
g=codecs.open(self.ufil, encoding=self.enc_sig).read()
self.assertEquals(g,self.exp,
m(g,self.exp, "codec utf_8_sig NO sig input"))
g=codecs.open(self.f1byte, encoding=self.enc_sig).read()
self.assertEquals(g,"1",
m(g,"1", "codec utf_8_sig NO sig input"))
###
@ -127,32 +127,32 @@ class Test4(unittest.TestCase):
ufil = os.path.join(cdir, "chars.utf8_sig")
exp = utest_chars
def setUp(s):
gen_chars(s.ufil, s.enc_sig)
def setUp(self):
gen_chars(self.ufil, self.enc_sig)
def test4a_u8_UTF8Reader_WITH_BOM_sig(s):
f=open(s.ufil)
def test4a_u8_UTF8Reader_WITH_BOM_sig(self):
f=open(self.ufil)
ra=G.UTF8Reader(f)
g = ra.readline()
s.assertEquals(g,s.exp, m(g,s.exp, "orig UTF8Reader"))
self.assertEquals(g,self.exp, m(g,self.exp, "orig UTF8Reader"))
# utf_8 reads an initial BOM-sig as data -- oops, pity
# write the test to verify this known codec behavior
# ==> Recommend: do not use utf8 as input codec (use utf_8_sig)
def test4b_utf8_codec_WITH_BOM_sig_reads_as_data_PITY(s):
g=codecs.open(s.ufil, encoding=s.enc).read()
def test4b_utf8_codec_WITH_BOM_sig_reads_as_data_PITY(self):
g=codecs.open(self.ufil, encoding=self.enc).read()
e0=u'\ufeff'
s.assertEquals(g[0], e0,
self.assertEquals(g[0], e0,
m(g[0],e0, "codec utf8 reads 'BOM'-sig as data" ))
g = g[1:]
s.assertEquals(g,s.exp,
m(g,s.exp, "codec utf8 reads rest of data ok"))
self.assertEquals(g,self.exp,
m(g,self.exp, "codec utf8 reads rest of data ok"))
# utf_8_sig reads and ignores the BOM-sig
def test4c_utf8_sig_codec_WITH_BOM_sig_as_expected(s):
g=codecs.open(s.ufil, encoding=s.enc_sig).read()
s.assertEquals(g,s.exp,
m(g,s.exp, "codec utf_8_sig NO sig input"))
def test4c_utf8_sig_codec_WITH_BOM_sig_as_expected(self):
g=codecs.open(self.ufil, encoding=self.enc_sig).read()
self.assertEquals(g,self.exp,
m(g,self.exp, "codec utf_8_sig NO sig input"))
###

6
src/GrampsDbUtils/test/_GrampsDbWRFactories_test.py
View File

@ -12,9 +12,9 @@ class Test1(unittest.TestCase):
NB: if any test fails, check imports within that module
"""
def test1a_buried_imports(s):
def test1a_buried_imports(self):
import sys
s.assertTrue(par in sys.path,
self.assertTrue(par in sys.path,
"par %r has to be in path!" % par)
ilist = (
"_WriteGrdb",
@ -28,7 +28,7 @@ class Test1(unittest.TestCase):
mod = __import__(m)
except ImportError:
mod = None
s.assertTrue(mod, "try import of module %r" % m)
self.assertTrue(mod, "try import of module %r" % m)
if __name__ == "__main__":
unittest.main()

2
src/ObjectSelector/_FamilyFilterFrame.py
View File

@ -72,7 +72,7 @@ class FamilyFilterFrame(FilterFrameBase):
self._set_filter(filter_spec)
def _set_filter(filter_spec):
def _set_filter(self):
pass
def on_apply(self,button):

4
src/gen/utils/callback.py
View File

@ -454,12 +454,12 @@ class GrampsDBCallback(object):
# Class methods
#
def __disable_all_signals(cls):
def __disable_all_signals(self):
GrampsDBCallback.__BLOCK_ALL_SIGNALS = True
disable_all_signals = classmethod(__disable_all_signals)
def __enable_all_signals(cls):
def __enable_all_signals(self):
GrampsDBCallback.__BLOCK_ALL_SIGNALS = False
enable_all_signals = classmethod(__enable_all_signals)

28
src/test/ansel_utf8_test.py
View File

@ -169,7 +169,7 @@ class Test4(unittest.TestCase):
self.assertEquals(A.ansel_to_utf8(""), u"", "empty a2u")
self.assertEquals(A.utf8_to_ansel(u""), "", "empty u2a")
def test4b_unmapped_combos(s):
def test4b_unmapped_combos(self):
""" 4b: (sample) unmapped (non-precomposed) combinations """
samples = (
# ansel, unicode, failure-report-message .. see function msg()
@ -181,17 +181,17 @@ class Test4(unittest.TestCase):
for a,u,m in samples:
# ansel to unicode and inverse
a2u=A.ansel_to_utf8(a)
s.assertEquals(a2u, u, msg(a2u, u, m, "a2u"))
self.assertEquals(a2u, u, msg(a2u, u, m, "a2u"))
a2u2a = A.utf8_to_ansel(a2u)
s.assertEquals(a2u2a, a, msg(a2u2a, a, m, "a2u2a"))
self.assertEquals(a2u2a, a, msg(a2u2a, a, m, "a2u2a"))
# unicode to ansel and inverse
u2a = A.utf8_to_ansel(u)
s.assertEquals(u2a, a, msg(u2a, a, m, "u2a"))
self.assertEquals(u2a, a, msg(u2a, a, m, "u2a"))
u2a2u = A.ansel_to_utf8(u2a)
s.assertEquals(u2a2u, u, msg(u2a2u, u, m, "u2a2u"))
self.assertEquals(u2a2u, u, msg(u2a2u, u, m, "u2a2u"))
def test4c_multiple_combos(s):
def test4c_multiple_combos(self):
""" 4c: (a2u) ignore multiple combinations (include precomposed) """
samples = (
("b\xF0\xE5Ze", u"bZ\u0304e", "b <cedilla> Z+macron e"),
@ -203,9 +203,9 @@ class Test4(unittest.TestCase):
)
for a,u,m in samples:
a2u=A.ansel_to_utf8(a)
s.assertEquals(a2u, u, msg(a2u,u,m, "a2u drop extra <combiners>"))
self.assertEquals(a2u, u, msg(a2u,u,m, "a2u drop extra <combiners>"))
def test4d_multiple_combos(s):
def test4d_multiple_combos(self):
""" 4c: (u2a) ignore multiple combinations (include precomposed) """
samples = (
("b\xE5Ze", u"bZ\u0304\u0327e", "b Z+macron <cedilla> e"),
@ -214,23 +214,23 @@ class Test4(unittest.TestCase):
)
for a,u,m in samples:
u2a=A.utf8_to_ansel(u)
s.assertEquals(u2a, a, msg(u2a,a,m, "u2a drop extra <combiners>"))
self.assertEquals(u2a, a, msg(u2a,a,m, "u2a drop extra <combiners>"))
class Test99(unittest.TestCase):
""" test regression cases """
def test_99a(s):
def test_99a(self):
""" 99a: sanity check on counts """
n1B= len(A._onebyte)
n2B= len(A._twobyte)
na = n1B+n2B
nu = len(A._utoa)
s.assertEquals(na, nu, msg(na, nu, "basic counts: a2u=u2a"))
self.assertEquals(na, nu, msg(na, nu, "basic counts: a2u=u2a"))
nac = len(A._acombiners)
nuc = len(A._ucombiners)
s.assertEquals(nac, nuc, msg(nac, nuc, "combiner counts: a2u=u2a"))
self.assertEquals(nac, nuc, msg(nac, nuc, "combiner counts: a2u=u2a"))
def test_99b(s):
def test_99b(self):
""" 99b: fix incorrect mapping for ansel 0xAE
It used-to-be U+02be but was changed March 2005 to U+02bc
@ -248,7 +248,7 @@ class Test99(unittest.TestCase):
)
for a, u, m in revs:
g = A.ansel_to_utf8(a)
s.assertEquals(g,u,
self.assertEquals(g,u,
msg(g, u, m, "spec change"))
if __name__ == '__main__':

24
src/test/gramps_cli_test.py
View File

@ -24,37 +24,37 @@ out_ged = os.path.join(ddir,"test_out.ged")
class Test(unittest.TestCase):
def setUp(s):
def setUp(self):
if not os.path.exists(min1r):
open(min1r,"wb").write(test_ged)
if os.path.exists(out_ged):
os.remove(out_ged)
# silly test just to illustrate unittest setUp behavior
def test1_setup_works(s):
s.assertTrue(os.path.exists(ddir), "data dir %r exists" % ddir)
s.assertTrue(os.path.exists(min1r), "data file %r exists" % min1r)
s.assertFalse(os.path.exists(out_ged),
def test1_setup_works(self):
self.assertTrue(os.path.exists(ddir), "data dir %r exists" % ddir)
self.assertTrue(os.path.exists(min1r), "data file %r exists" % min1r)
self.assertFalse(os.path.exists(out_ged),
"NO out file %r yet" % out_ged)
# This tests the fix for bug #1331-1334
# read trivial gedcom input, write gedcom output
def test2_exec_CLI(s):
def test2_exec_CLI(self):
ifile = min1r
ofile = out_ged
gcmd = "./gramps.py -i%s -o%s" % (ifile, ofile)
rc = os.system("cd %s && python %s" % (pdir, gcmd))
s.assertEquals(rc,0, tu.msg(rc,0, "executed CLI cmmand %r" % gcmd))
self.assertEquals(rc,0, tu.msg(rc,0, "executed CLI cmmand %r" % gcmd))
# simple validation o output
s.assertTrue(os.path.isfile(ofile), "output file created")
self.assertTrue(os.path.isfile(ofile), "output file created")
content = open(ofile).read()
g = re.search("INDI", content)
s.assertTrue(g, "found 'INDI' in output file")
self.assertTrue(g, "found 'INDI' in output file")
# this verifies that files in the temporary "import dir"
# get cleaned before (and after) running a CLI
# (eg cleanout stale files from prior crash-runs)
def test3_files_in_import_dir(s):
def test3_files_in_import_dir(self):
import const
ddir = os.path.join(const.TEMP_DIR,"import_dbdir")
os.makedirs(ddir)
@ -68,10 +68,10 @@ class Test(unittest.TestCase):
ofile = out_ged
gcmd = "./gramps.py -i%s -o%s" % (ifile, ofile)
rc = os.system("cd %s && python %s" % (pdir, gcmd))
s.assertEquals(rc,0, tu.msg(rc,0, "executed CLI cmmand %r" % gcmd))
self.assertEquals(rc,0, tu.msg(rc,0, "executed CLI cmmand %r" % gcmd))
for fn in bogofiles:
s.assertFalse(os.path.exists(fn))
self.assertFalse(os.path.exists(fn))
if __name__ == "__main__":

20
src/test/test/gedread_util_test.py
View File

@ -12,11 +12,11 @@ from test import gedread_util as gr
class Test(U.TestCase):
def setUp(s):
def setUp(self):
# make a dir to hold an input gedcom file
s.tdir = tu.make_subdir("gr_test")
self.tdir = tu.make_subdir("gr_test")
def test1(s):
def test1(self):
prec="""
0 @I1@ INDI
1 NAME GedRead TEST /Person/
@ -24,31 +24,31 @@ class Test(U.TestCase):
# create a gedcom input file
# from canned head/tail -- see gedread_util
infil = os.path.join(s.tdir,"test_in.ged")
infil = os.path.join(self.tdir,"test_in.ged")
gr.make_gedcom_input(infil, prec)
s.assertTrue(os.path.isfile(infil),
self.assertTrue(os.path.isfile(infil),
"create input file %s" % infil)
# create an empty database
dbpath = os.path.join(s.tdir,"test_db")
dbpath = os.path.join(self.tdir,"test_db")
db = gr.create_empty_db(dbpath)
s.assertTrue(os.path.isdir(dbpath),
self.assertTrue(os.path.isdir(dbpath),
"create database (dir) %s" % dbpath)
# create logfile to test for read log-messages
# (note: uses recently added test_util
log = os.path.join(s.tdir, "test_log")
log = os.path.join(self.tdir, "test_log")
tl = tu.TestLogger()
tl.logfile_init(log)
# now read the gedcom
gr.gread(db, infil)
logging.warn("nothing here")
loglines = tl.logfile_getlines()
s.assertEquals(len(loglines),1,
self.assertEquals(len(loglines),1,
"log has no unexpected content")
# verify one person in database
np = db.get_number_of_people()
s.assertEquals(np,1,
self.assertEquals(np,1,
tu.msg(np,1, "db has exactly one person"))
if __name__ == "__main__":

82
src/test/test/test_util_test.py
View File

@ -49,39 +49,39 @@ except ImportError:
# some enabling infrastructure features
class Test1(U.TestCase):
def test1a_custom_exception(s):
def test1a_custom_exception(self):
tmsg = "testing"
try:
err = None
raise tu.TestError(tmsg)
except tu.TestError,e:
emsg = e.value
s.assertEqual(emsg, tmsg,
self.assertEqual(emsg, tmsg,
"raising TestError: g=%r e=%r" % (emsg, tmsg))
def test1b_msg_reporting_utility(s):
def test1b_msg_reporting_utility(self):
g,e = "got this", "expected that"
m,p = "your message here", "pfx"
tmsg0 = m + "\n .....got:'" + g + \
"'\n expected:'" + e +"'"
tmsg1 = p + ": " + tmsg0
s.assertEqual(tu.msg(g,e,m), tmsg0, "non-prefix message")
s.assertEqual(tu.msg(g,e,m,p), tmsg1, "prefix message")
self.assertEqual(tu.msg(g,e,m), tmsg0, "non-prefix message")
self.assertEqual(tu.msg(g,e,m,p), tmsg1, "prefix message")
# path-related features (note use of tu.msg tested above)
class Test2(U.TestCase):
def test2a_context_via_traceback(s):
def test2a_context_via_traceback(self):
e = os.path.basename(__file__).rstrip(".co") # eg in *.py[co]
g = os.path.basename(tu._caller_context()[0]).rstrip('co')
s.assertEqual(g,e, tu.msg(g,e, "_caller_context"))
self.assertEqual(g,e, tu.msg(g,e, "_caller_context"))
def test2b_absdir(s):
def test2b_absdir(self):
here = tu.absdir();
g=tu.absdir(__file__)
s.assertEqual(g,here, tu.msg(g,here, "absdir"))
self.assertEqual(g,here, tu.msg(g,here, "absdir"))
def test2c_path_append_parent(s):
def test2c_path_append_parent(self):
here = tu.absdir();
par = os.path.dirname(here)
was_there = par in sys.path
@ -91,16 +91,16 @@ class Test2(U.TestCase):
np = len(sys.path)
for p in (None, __file__):
s.assertFalse(par in sys.path, "par not in initial path")
self.assertFalse(par in sys.path, "par not in initial path")
if not p:
g = tu.path_append_parent()
else:
g = tu.path_append_parent(p)
s.assertEqual(g,par, tu.msg(g,par, "path_append_parent return"))
s.assertTrue(par in sys.path, "actually appends")
self.assertEqual(g,par, tu.msg(g,par, "path_append_parent return"))
self.assertTrue(par in sys.path, "actually appends")
sys.path.remove(par)
l= len(sys.path)
s.assertEqual(l,np, tu.msg(l,np,"numpaths"))
self.assertEqual(l,np, tu.msg(l,np,"numpaths"))
if was_there:
# restore entry state (but no multiples needed!)
sys.path.append(par)
@ -113,59 +113,59 @@ class Test3(U.TestCase):
home= os.environ["HOME"]
if home:
home_junk = os.path.join(home,"test_junk")
def _rmsubs(s):
def _rmsubs(self):
import shutil
for sub in s.asubs:
for sub in self.asubs:
if os.path.isdir(sub):
shutil.rmtree(sub)
def setUp(s):
s._rmsubs()
if s.home and not os.path.isdir(s.home_junk):
os.mkdir(s.home_junk)
def setUp(self):
self._rmsubs()
if self.home and not os.path.isdir(self.home_junk):
os.mkdir(self.home_junk)
def tearDown(s):
s._rmsubs()
if s.home and os.path.isdir(s.home_junk):
os.rmdir(s.home_junk)
def tearDown(self):
self._rmsubs()
if self.home and os.path.isdir(self.home_junk):
os.rmdir(self.home_junk)
def test3a_subdir(s):
for sub in s.asubs:
s.assertFalse(os.path.isdir(sub), "init: no dir %r" % sub)
def test3a_subdir(self):
for sub in self.asubs:
self.assertFalse(os.path.isdir(sub), "init: no dir %r" % sub)
b,d = os.path.dirname(sub), os.path.basename(sub)
md = tu.make_subdir(d, b)
s.assertTrue(os.path.isdir(sub), "made dir %r" % sub)
s.assertEqual(md,sub, tu.msg(md,sub,
self.assertTrue(os.path.isdir(sub), "made dir %r" % sub)
self.assertEqual(md,sub, tu.msg(md,sub,
"make_subdir returns path"))
s2 = os.path.join(sub,"sub2")
tu.make_subdir("sub2", sub)
s.assertTrue(os.path.isdir(s2), "made dir %r" % s2)
self.assertTrue(os.path.isdir(s2), "made dir %r" % s2)
f = os.path.join(s2,"test_file")
open(f,"w").write("testing..")
s.assertTrue(os.path.isfile(f), "file %r exists" % f)
self.assertTrue(os.path.isfile(f), "file %r exists" % f)
tu.delete_tree(sub)
s.assertFalse(os.path.isdir(sub),
self.assertFalse(os.path.isdir(sub),
"delete_tree removes subdir %r" % sub )
def test3b_delete_tree_constraint(s):
if s.home:
def test3b_delete_tree_constraint(self):
if self.home:
err = None
try:
tu.delete_tree(s.home_junk)
tu.delete_tree(self.home_junk)
except tu.TestError, e:
err = e.value
s.assertFalse(err is None,
"deltree on %r raises TestError" % (s.home_junk))
self.assertFalse(err is None,
"deltree on %r raises TestError" % (self.home_junk))
else:
s.fail("Skip deltree constraint test, no '$HOME' var")
self.fail("Skip deltree constraint test, no '$HOME' var")
# logging (& misc?)
class Test4(U.TestCase):
logf = "/tmp/__tu__log__"
def test4a(s):
def test4a(self):
wmsg = "a warning message"
emsg = "an error message"
import logging
@ -173,13 +173,13 @@ class Test4(U.TestCase):
tl = tu.TestLogger()
for i in (1,2):
# 2 passes to test clearing old file
tl.logfile_init(s.logf)
tl.logfile_init(self.logf)
logging.warn(wmsg)
logging.info("nada")
logging.error(emsg)
ll = tl.logfile_getlines()
nl = len(ll)
s.assertEquals(nl,2,
self.assertEquals(nl,2,
tu.msg(nl,2, "pass %d: expected line count" % i))

20
src/test/test_util.py
View File

@ -166,24 +166,24 @@ class TestLogger():
Note that existing logging will still occur, possibly
resulting in console messages and popup dialogs
"""
def __init__(s, lvl=logging.WARN):
def __init__(self, lvl=logging.WARN):
logging.basicConfig(level=lvl)
def logfile_init(s, lfname):
def logfile_init(self, lfname):
"""init or re-init a logfile"""
if getattr(s, "lfh", None):
logging.getLogger().handlers.remove(s.lfh)
if getattr(self, "lfh", None):
logging.getLogger().handlers.remove(self.lfh)
if os.path.isfile(lfname):
os.unlink(lfname)
s.lfh = logging.FileHandler(lfname)
logging.getLogger().addHandler(s.lfh)
s.lfname = lfname
self.lfh = logging.FileHandler(lfname)
logging.getLogger().addHandler(self.lfh)
self.lfname = lfname
def logfile_getlines(s):
def logfile_getlines(self):
"""get current content of logfile as list of lines"""
txt = []
if s.lfname and os.path.isfile(s.lfname):
txt = open(s.lfname).readlines()
if self.lfname and os.path.isfile(self.lfname):
txt = open(self.lfname).readlines()
return txt
#===eof===