From 40fd4661d4b2a0fd2b2517408d4c5982474b2105 Mon Sep 17 00:00:00 2001 From: ben Date: Fri, 10 May 2002 23:14:57 +0000 Subject: Many changes, see changelog for 0.7.4 git-svn-id: http://svn.savannah.nongnu.org/svn/rdiff-backup/trunk@73 2b77aa54-bcbc-44c9-a7ec-4f6cf2b41109 --- rdiff-backup/testing/commontest.py | 23 +++- rdiff-backup/testing/destructive_steppingtest.py | 8 +- rdiff-backup/testing/finaltest.py | 48 ++++++-- rdiff-backup/testing/hardlinktest.py | 8 +- rdiff-backup/testing/lazytest.py | 150 ++++++++++------------- rdiff-backup/testing/makerestoretest3 | 10 ++ rdiff-backup/testing/restoretest.py | 49 +++++--- rdiff-backup/testing/selectiontest.py | 18 +-- rdiff-backup/testing/timetest.py | 9 ++ 9 files changed, 190 insertions(+), 133 deletions(-) create mode 100755 rdiff-backup/testing/makerestoretest3 diff --git a/rdiff-backup/testing/commontest.py b/rdiff-backup/testing/commontest.py index 7ecf589..b1a1dc6 100644 --- a/rdiff-backup/testing/commontest.py +++ b/rdiff-backup/testing/commontest.py @@ -97,11 +97,15 @@ def InternalMirror(source_local, dest_local, src_dir, dest_dir, _get_main().misc_setup([rpin, rpout]) _get_main().backup_init_select(rpin, rpout) if not rpout.lstat(): rpout.mkdir() - if checkpointing: # rdiff-backup-data must exist to checkpoint + if checkpointing: # use rdiff-backup-data dir to checkpoint data_dir = rpout.append("rdiff-backup-data") if not data_dir.lstat(): data_dir.mkdir() SetConnections.UpdateGlobal('rbdir', data_dir) - HighLevel.Mirror(rpin, rpout, checkpointing) + else: # just use root directory to hold checkpoints + SetConnections.UpdateGlobal('rbdir', rpout) + SetConnections.BackupInitConnections(rpin.conn, rpout.conn) + SaveState.init_filenames(None) + HighLevel.Mirror(rpin, rpout, checkpointing, None, write_finaldata = None) _get_main().cleanup() def InternalRestore(mirror_local, dest_local, mirror_dir, dest_dir, time): @@ -167,7 +171,8 @@ def CompareRecursive(src_rp, dest_rp, compare_hardlinks = 1, Log("Comparing %s and %s, hardlinks %s" % (src_rp.path, dest_rp.path, compare_hardlinks), 3) - src_select, dest_select = Select(src_rp, 1), Select(dest_rp, None) + src_select = Select(DSRPath(1, src_rp)) + dest_select = Select(DSRPath(None, dest_rp)) src_select.parse_rbdir_exclude() dest_select.parse_rbdir_exclude() src_select.set_iter() @@ -200,11 +205,13 @@ def reset_hardlink_dicts(): Hardlink._src_index_indicies = {} Hardlink._dest_inode_indicies = {} Hardlink._dest_index_indicies = {} + Hardlink._restore_index_path = {} def BackupRestoreSeries(source_local, dest_local, list_of_dirnames, compare_hardlinks = 1, dest_dirname = "testfiles/output", - restore_dirname = "testfiles/rest_out"): + restore_dirname = "testfiles/rest_out", + compare_backups = 1): """Test backing up/restoring of a series of directories The dirnames correspond to a single directory at different times. @@ -227,7 +234,8 @@ def BackupRestoreSeries(source_local, dest_local, list_of_dirnames, InternalBackup(source_local, dest_local, dirname, dest_dirname, time) time += 10000 _reset_connections(src_rp, dest_rp) - assert CompareRecursive(src_rp, dest_rp, compare_hardlinks) + if compare_backups: + assert CompareRecursive(src_rp, dest_rp, compare_hardlinks) time = 10000 for dirname in list_of_dirnames[:-1]: @@ -237,6 +245,11 @@ def BackupRestoreSeries(source_local, dest_local, list_of_dirnames, restore_dirname, time) src_rp = RPath(Globals.local_connection, dirname) assert CompareRecursive(src_rp, restore_rp) + + # Restore should default back to newest time older than it + # with a backup then. + if time == 20000: time = 21000 + time += 10000 def MirrorTest(source_local, dest_local, list_of_dirnames, diff --git a/rdiff-backup/testing/destructive_steppingtest.py b/rdiff-backup/testing/destructive_steppingtest.py index b44a999..1194835 100644 --- a/rdiff-backup/testing/destructive_steppingtest.py +++ b/rdiff-backup/testing/destructive_steppingtest.py @@ -3,7 +3,7 @@ import unittest execfile("commontest.py") rbexec("selection.py") - +Log.setverbosity(4) class DSTest(unittest.TestCase): def setUp(self): @@ -15,11 +15,11 @@ class DSTest(unittest.TestCase): def testDSIter(self): """Testing destructive stepping iterator from baserp""" for i in range(2): - sel = Select(self.noperms, 1) - sel.set_iter() + sel = Select(DSRPath(1, self.noperms)).set_iter() ds_iter = sel.iterate_with_finalizer() noperms = ds_iter.next() - assert noperms.isdir() and noperms.getperms() == 0 + assert noperms.isdir() and noperms.getperms() == 0, \ + (noperms.isdir(), noperms.getperms()) bar = ds_iter.next() assert bar.isreg() and bar.getperms() == 0, \ diff --git a/rdiff-backup/testing/finaltest.py b/rdiff-backup/testing/finaltest.py index c4c7cc6..909d1a6 100644 --- a/rdiff-backup/testing/finaltest.py +++ b/rdiff-backup/testing/finaltest.py @@ -32,6 +32,7 @@ class Local: vft_in = get_local_rp('vft_out') vft_out = get_local_rp('increment2/various_file_types') + vft2_in = get_local_rp('vft2_out') timbar_in = get_local_rp('increment1/timbar.pyc') timbar_out = get_local_rp('../timbar.pyc') # in cur directory @@ -53,9 +54,10 @@ class PathSetter(unittest.TestCase): if dest_pre: self.dest_prefix = "%s::%s" % (dest_pre, dest_back) else: self.dest_prefix = './' - def exec_rb(self, *args): + def exec_rb(self, time, *args): """Run rdiff-backup on given arguments""" arglist = [] + if time: arglist.append("--current-time %s" % str(time)) arglist.append(self.src_prefix + args[0]) if len(args) > 1: arglist.append(self.dest_prefix + args[1]) @@ -65,32 +67,45 @@ class PathSetter(unittest.TestCase): print "executing " + cmdstr assert not os.system(cmdstr) + def exec_rb_restore(self, time, *args): + """Restore using rdiff-backup's new syntax and given time""" + arglist = [] + arglist.append("--restore-as-of %s" % str(time)) + arglist.append(self.src_prefix + args[0]) + if len(args) > 1: + arglist.append(self.dest_prefix + args[1]) + assert len(args) == 2 + + cmdstr = self.rb_schema + " ".join(arglist) + print "Restoring via cmdline: " + cmdstr + assert not os.system(cmdstr) + def delete_tmpdirs(self): """Remove any temp directories created by previous tests""" assert not os.system(MiscDir + '/myrm testfiles/output* ' 'testfiles/restoretarget* testfiles/vft_out ' - 'timbar.pyc') + 'timbar.pyc testfiles/vft2_out') def runtest(self): self.delete_tmpdirs() # Backing up increment1 - self.exec_rb('testfiles/increment1', 'testfiles/output') + self.exec_rb(10000, 'testfiles/increment1', 'testfiles/output') assert CompareRecursive(Local.inc1rp, Local.rpout) time.sleep(1) # Backing up increment2 - self.exec_rb('testfiles/increment2', 'testfiles/output') + self.exec_rb(20000, 'testfiles/increment2', 'testfiles/output') assert CompareRecursive(Local.inc2rp, Local.rpout) time.sleep(1) # Backing up increment3 - self.exec_rb('testfiles/increment3', 'testfiles/output') + self.exec_rb(30000, 'testfiles/increment3', 'testfiles/output') assert CompareRecursive(Local.inc3rp, Local.rpout) time.sleep(1) # Backing up increment4 - self.exec_rb('testfiles/increment4', 'testfiles/output') + self.exec_rb(40000, 'testfiles/increment4', 'testfiles/output') assert CompareRecursive(Local.inc4rp, Local.rpout) # Getting restore rps @@ -99,30 +114,35 @@ class PathSetter(unittest.TestCase): assert len(inc_paths) == 3 # Restoring increment1 - self.exec_rb(inc_paths[0], 'testfiles/restoretarget1') + self.exec_rb(None, inc_paths[0], 'testfiles/restoretarget1') assert CompareRecursive(Local.inc1rp, Local.rpout1) # Restoring increment2 - self.exec_rb(inc_paths[1], 'testfiles/restoretarget2') + self.exec_rb(None, inc_paths[1], 'testfiles/restoretarget2') assert CompareRecursive(Local.inc2rp, Local.rpout2) # Restoring increment3 - self.exec_rb(inc_paths[2], 'testfiles/restoretarget3') + self.exec_rb(None, inc_paths[2], 'testfiles/restoretarget3') assert CompareRecursive(Local.inc3rp, Local.rpout3) # Test restoration of a few random files vft_paths = self.getinc_paths("various_file_types.", "testfiles/output/rdiff-backup-data/increments") - self.exec_rb(vft_paths[1], 'testfiles/vft_out') + self.exec_rb(None, vft_paths[1], 'testfiles/vft_out') self.refresh(Local.vft_in, Local.vft_out) assert CompareRecursive(Local.vft_in, Local.vft_out) timbar_paths = self.getinc_paths("timbar.pyc.", "testfiles/output/rdiff-backup-data/increments") - self.exec_rb(timbar_paths[0]) + self.exec_rb(None, timbar_paths[0]) self.refresh(Local.timbar_in, Local.timbar_out) assert RPath.cmp_with_attribs(Local.timbar_in, Local.timbar_out) + self.exec_rb_restore(25000, 'testfiles/output/various_file_types', + 'testfiles/vft2_out') + self.refresh(Local.vft2_in, Local.vft_out) + assert CompareRecursive(Local.vft2_in, Local.vft_out) + # Make sure too many increment files not created assert len(self.getinc_paths("nochange.", "testfiles/output/rdiff-backup-data/increments")) == 0 @@ -222,13 +242,15 @@ class FinalCorrupt(PathSetter): self.delete_tmpdirs() assert not os.system("cp -a testfiles/corruptbackup testfiles/output") self.set_connections(None, None, None, None) - self.exec_rb('testfiles/corruptbackup_source', 'testfiles/output') + self.exec_rb(None, 'testfiles/corruptbackup_source', + 'testfiles/output') def testBackupOverlayRemote(self): """Like above but destination is remote""" self.delete_tmpdirs() assert not os.system("cp -a testfiles/corruptbackup testfiles/output") self.set_connections(None, None, "test1/", '../') - self.exec_rb('testfiles/corruptbackup_source', 'testfiles/output') + self.exec_rb(None, 'testfiles/corruptbackup_source', + 'testfiles/output') if __name__ == "__main__": unittest.main() diff --git a/rdiff-backup/testing/hardlinktest.py b/rdiff-backup/testing/hardlinktest.py index 0822be6..a45e427 100644 --- a/rdiff-backup/testing/hardlinktest.py +++ b/rdiff-backup/testing/hardlinktest.py @@ -73,7 +73,7 @@ class HardlinkTest(unittest.TestCase): """See if the partial inode dictionary is correct""" Globals.preserve_hardlinks = 1 reset_hardlink_dicts() - for dsrp in Select(self.hardlink_dir3, 1).set_iter(): + for dsrp in Select(DSRPath(1, self.hardlink_dir3)).set_iter(): Hardlink.add_rorp(dsrp, 1) assert len(Hardlink._src_inode_indicies.keys()) == 3, \ @@ -90,7 +90,7 @@ class HardlinkTest(unittest.TestCase): """Same as testBuildingDict but test destination building""" Globals.preserve_hardlinks = 1 reset_hardlink_dicts() - for dsrp in Select(self.hardlink_dir3, None).set_iter(): + for dsrp in Select(DSRPath(None, self.hardlink_dir3)).set_iter(): Hardlink.add_rorp(dsrp, None) assert len(Hardlink._dest_inode_indicies.keys()) == 3, \ @@ -106,7 +106,7 @@ class HardlinkTest(unittest.TestCase): def testCompletedDict(self): """See if the hardlink dictionaries are built correctly""" reset_hardlink_dicts() - for dsrp in Select(self.hardlink_dir1, 1).set_iter(): + for dsrp in Select(DSRPath(1, self.hardlink_dir1)).set_iter(): Hardlink.add_rorp(dsrp, 1) assert Hardlink._src_inode_indicies == {}, \ Hardlink._src_inode_indicies @@ -119,7 +119,7 @@ class HardlinkTest(unittest.TestCase): assert Hardlink._src_index_indicies == dict reset_hardlink_dicts() - for dsrp in Select(self.hardlink_dir2, 1).set_iter(): + for dsrp in Select(DSRPath(1, self.hardlink_dir2)).set_iter(): Hardlink.add_rorp(dsrp, 1) assert Hardlink._src_inode_indicies == {}, \ Hardlink._src_inode_indicies diff --git a/rdiff-backup/testing/lazytest.py b/rdiff-backup/testing/lazytest.py index fb464a1..fb28604 100644 --- a/rdiff-backup/testing/lazytest.py +++ b/rdiff-backup/testing/lazytest.py @@ -1,5 +1,5 @@ from __future__ import generators -import unittest +import unittest, pickle execfile("commontest.py") rbexec("lazy.py") @@ -219,108 +219,90 @@ class MultiplexTest(Iterators): assert Iter.equal(i2, self.one_to_100()) -class index: - """This is just used below to test the iter tree reducer""" - def __init__(self, index): - self.index = index +class ITRadder(IterTreeReducer): + def start_process(self, index): + self.total = 0 + def end_process(self): + if self.base_index: + summand = self.base_index[-1] + #print "Adding ", summand + self.total += summand -class TreeReducerTest(unittest.TestCase): - def setUp(self): - self.i1 = iter(map(index, [(), (1,), (2,), (3,)])) - self.i2 = iter(map(index, [(0,), (0,1), (0,1,0), (0,1,1), - (0,2), (0,2,1), (0,3)])) + def branch_process(self, subinstance): + #print "Adding subinstance ", subinstance.total + self.total += subinstance.total - self.i1a = iter(map(index, [(), (1,)])) - self.i1b = iter(map(index, [(2,), (3,)])) - self.i2a = iter(map(index, [(0,), (0,1), (0,1,0)])) - self.i2b = iter(map(index, [(0,1,1), (0,2)])) - self.i2c = iter(map(index, [(0,2,1), (0,3)])) +class ITRadder2(IterTreeReducer): + def start_process(self, index): + self.total = 0 - # The four following are used to make an ITR later - def number_of_index(self, index_obj): - if not index_obj.index: return 0 - else: return index_obj.index[-1] + def end_process(self): + #print "Adding ", self.base_index + self.total += reduce(lambda x,y: x+y, self.base_index, 0) - def sum_index(self, index_obj): - return reduce(lambda x,y: x+y, index_obj.index, 0) + def branch_process(self, subinstance): + #print "Adding branch ", subinstance.total + self.total += subinstance.total - def add2(self, x, y): - #print "adding %d and %d" % (x,y) - return x+y +class TreeReducerTest(unittest.TestCase): + def setUp(self): + self.i1 = [(), (1,), (2,), (3,)] + self.i2 = [(0,), (0,1), (0,1,0), (0,1,1), (0,2), (0,2,1), (0,3)] - def add3(self, x,y,z): - #print "ignoring %s, adding %d and %d" % (x,y,z) - return y+z + self.i1a = [(), (1,)] + self.i1b = [(2,), (3,)] + self.i2a = [(0,), (0,1), (0,1,0)] + self.i2b = [(0,1,1), (0,2)] + self.i2c = [(0,2,1), (0,3)] def testTreeReducer(self): """testing IterTreeReducer""" - itm = IterTreeReducer(self.number_of_index, self.add2, 0, self.add3) - for elem in self.i1: - val = itm(elem) + itm = ITRadder() + for index in self.i1: + val = itm(index) assert val, elem.index - itm.calculate_final_val() - assert itm.getresult() == 6, itm.getresult() + itm.Finish() + assert itm.total == 6, itm.total - itm2 = IterTreeReducer(self.sum_index, self.add2, 0, self.add3) - for elem in self.i2: - val = itm2(elem) - if elem.index == (): assert not val + itm2 = ITRadder2() + for index in self.i2: + val = itm2(index) + if index == (): assert not val else: assert val - assert itm2.getresult() == 12, itm2.getresult() + itm2.Finish() + assert itm2.total == 12, itm2.total def testTreeReducerState(self): """Test saving and recreation of an IterTreeReducer""" - itm1a = IterTreeReducer(self.number_of_index, self.add2, 0, self.add3) - for elem in self.i1a: - val = itm1a(elem) - assert val, elem.index - itm1b = IterTreeReducer(self.number_of_index, self.add2, 0, self.add3, - itm1a.getstate()) - for elem in self.i1b: - val = itm1b(elem) - assert val, elem.index - itm1b.calculate_final_val() - assert itm1b.getresult() == 6, itm1b.getresult() - - itm2a = IterTreeReducer(self.sum_index, self.add2, 0, self.add3) - for elem in self.i2a: - val = itm2a(elem) - if elem.index == (): assert not val + itm1a = ITRadder() + for index in self.i1a: + val = itm1a(index) + assert val, index + itm1b = pickle.loads(pickle.dumps(itm1a)) + for index in self.i1b: + val = itm1b(index) + assert val, index + itm1b.Finish() + assert itm1b.total == 6, itm1b.total + + itm2a = ITRadder2() + for index in self.i2a: + val = itm2a(index) + if index == (): assert not val else: assert val - itm2b = IterTreeReducer(self.sum_index, self.add2, 0, self.add3, - itm2a.getstate()) - for elem in self.i2b: - val = itm2b(elem) - if elem.index == (): assert not val + itm2b = pickle.loads(pickle.dumps(itm2a)) + for index in self.i2b: + val = itm2b(index) + if index == (): assert not val else: assert val - itm2c = IterTreeReducer(self.sum_index, self.add2, 0, self.add3, - itm2b.getstate()) - for elem in self.i2c: - val = itm2c(elem) - if elem.index == (): assert not val + itm2c = pickle.loads(pickle.dumps(itm2b)) + for index in self.i2c: + val = itm2c(index) + if index == (): assert not val else: assert val - assert itm2c.getresult() == 12, itm2c.getresult() - - def testTreeReducer2(self): - """Another test of the tree reducer""" - assert Iter.len(self.i1) == 4 - - hit_021_02 = [None, None] - def helper(indexobj, elem_init, branch_result): - if indexobj.index == (0,2): - assert hit_021_02[0] - hit_021_02[1] = 1 - elif indexobj.index == (0,2,1): - assert not hit_021_02[1] - hit_021_02[0] = 1 - return None - itm = IterTreeReducer(lambda x: None, lambda x,y: None, None, helper) - - for elem in self.i2: itm(elem) - itm.getresult() - assert hit_021_02 == [1,1] - + itm2c.Finish() + assert itm2c.total == 12, itm2c.total if __name__ == "__main__": unittest.main() diff --git a/rdiff-backup/testing/makerestoretest3 b/rdiff-backup/testing/makerestoretest3 new file mode 100755 index 0000000..4b8da83 --- /dev/null +++ b/rdiff-backup/testing/makerestoretest3 @@ -0,0 +1,10 @@ +#!/bin/sh + +# This script will create the testing/restoretest3 directory as it +# needs to be for one of the tests in restoretest.py to work. + +rm -rf testfiles/restoretest3 +rdiff-backup --current-time 10000 testfiles/increment1 testfiles/restoretest3 +rdiff-backup --current-time 20000 testfiles/increment2 testfiles/restoretest3 +rdiff-backup --current-time 30000 testfiles/increment3 testfiles/restoretest3 +rdiff-backup --current-time 40000 testfiles/increment4 testfiles/restoretest3 diff --git a/rdiff-backup/testing/restoretest.py b/rdiff-backup/testing/restoretest.py index 597763d..1a314eb 100644 --- a/rdiff-backup/testing/restoretest.py +++ b/rdiff-backup/testing/restoretest.py @@ -11,8 +11,15 @@ class RestoreTest(unittest.TestCase): """Test Restore class""" prefix = "testfiles/restoretest/" def maketesttuples(self, basename): - """Make testing tuples from available files starting with prefix""" + """Make testing tuples from available files starting with prefix + + tuples is a sorted (oldest to newest) list of pairs (rp1, rp2) + where rp1 is an increment file and rp2 is the same but without + the final extension. incs is a list of all increment files. + + """ dirlist = os.listdir(self.prefix) + dirlist.sort() baselist = filter(lambda f: f.startswith(basename), dirlist) rps = map(lambda f: RPath(lc, self.prefix+f), baselist) incs = filter(lambda rp: rp.isincfile(), rps) @@ -31,8 +38,12 @@ class RestoreTest(unittest.TestCase): print "Processing file " + pair[0].path if rptarget.lstat(): rptarget.delete() rest_time = Time.stringtotime(pair[0].getinctime()) - sorted_incs = Restore.sortincseq(rest_time, incs) - Restore.RestoreFile(rest_time, rpbase, (), sorted_incs, rptarget) + rid = RestoreIncrementData((), rpbase, incs) + rid.sortincseq(rest_time, 10000000000) # pick some really late time + rcd = RestoreCombinedData(rid, rpbase, rptarget) + rcd.RestoreFile() + #sorted_incs = Restore.sortincseq(rest_time, incs) + #Restore.RestoreFile(rest_time, rpbase, (), sorted_incs, rptarget) rptarget.setdata() if not rptarget.lstat(): assert not pair[1].lstat() elif not pair[1].lstat(): assert not rptarget.lstat() @@ -53,17 +64,27 @@ class RestoreTest(unittest.TestCase): """ for basename in ['ocaml', 'mf']: - tuples, incs = self.maketesttuples(basename) - completed_dict = {} - for i in range(len(tuples)): - pair = tuples[i] - rest_time = Time.stringtotime(pair[0].getinctime()) - sorted_incs = Restore.sortincseq(rest_time, incs) - key = sorted_incs[-1].path - assert not completed_dict.has_key(key) - completed_dict[key] = 1 - for inc in incs: assert completed_dict[inc.path] == 1 - + tuples, unused = self.maketesttuples(basename) + incs = [tuple[0] for tuple in tuples] + + # Now we need a time newer than any inc + mirror_time = Time.stringtotime(incs[-1].getinctime()) + 10000 + + for inc, incbase in tuples: + assert inc.isincfile() + inctime = Time.stringtotime(inc.getinctime()) + rid1 = RestoreIncrementData(basename, incbase, incs) + rid2 = RestoreIncrementData(basename, incbase, incs) + rid1.sortincseq(inctime, mirror_time) + rid2.sortincseq(inctime + 5, mirror_time) + assert rid1.inc_list, rid1.inc_list + # Five seconds later shouldn't make a difference + assert rid1.inc_list == rid2.inc_list, (rid1.inc_list, + rid2.inc_list) + # oldest increment should be exactly inctime + ridtime = Time.stringtotime(rid1.inc_list[-1].getinctime()) + assert ridtime == inctime, (ridtime, inctime) + def testRestorefiles(self): """Testing restoration of files one at a time""" diff --git a/rdiff-backup/testing/selectiontest.py b/rdiff-backup/testing/selectiontest.py index 8b16193..9b306eb 100644 --- a/rdiff-backup/testing/selectiontest.py +++ b/rdiff-backup/testing/selectiontest.py @@ -5,12 +5,12 @@ rbexec("highlevel.py") class MatchingTest(unittest.TestCase): """Test matching of file names against various selection functions""" - def makedsrp(self, path): return DSRPath(Globals.local_connection, path) + def makedsrp(self, path): return DSRPath(1, Globals.local_connection, path) def makeext(self, path): return self.root.new_index(tuple(path.split("/"))) def setUp(self): - self.root = DSRPath(Globals.local_connection, "testfiles/select") - self.Select = Select(self.root, 1) + self.root = DSRPath(1, Globals.local_connection, "testfiles/select") + self.Select = Select(self.root) def testRegexp(self): """Test regular expression selection func""" @@ -177,8 +177,8 @@ testfiles/select/1/1 def testRoot(self): """testRoot - / may be a counterexample to several of these..""" - root = DSRPath(Globals.local_connection, "/") - select = Select(root, 1) + root = DSRPath(1, Globals.local_connection, "/") + select = Select(root) assert select.glob_get_sf("/", 1)(root) == 1 assert select.glob_get_sf("/foo", 1)(root) == 1 @@ -205,8 +205,8 @@ class ParseArgsTest(unittest.TestCase): """Test argument parsing""" def ParseTest(self, tuplelist, indicies): """No error if running select on tuple goes over indicies""" - self.root = DSRPath(Globals.local_connection, "testfiles/select") - self.Select = Select(self.root, 1) + self.root = DSRPath(1, Globals.local_connection, "testfiles/select") + self.Select = Select(self.root) self.Select.ParseArgs(tuplelist) self.Select.set_iter() assert Iter.equal(Iter.map(lambda dsrp: dsrp.index, self.Select), @@ -259,8 +259,8 @@ class ParseArgsTest(unittest.TestCase): def testParseStartingFrom(self): """Test parse, this time starting from inside""" - self.root = DSRPath(Globals.local_connection, "testfiles/select") - self.Select = Select(self.root, 1) + self.root = DSRPath(1, Globals.local_connection, "testfiles/select") + self.Select = Select(self.root) self.Select.ParseArgs([("--include", "testfiles/select/1/1"), ("--exclude", "**")]) self.Select.set_iter(('1', '1')) diff --git a/rdiff-backup/testing/timetest.py b/rdiff-backup/testing/timetest.py index 78c7f97..d56f420 100644 --- a/rdiff-backup/testing/timetest.py +++ b/rdiff-backup/testing/timetest.py @@ -90,5 +90,14 @@ class TimeTest(unittest.TestCase): assert g2t('2001-05-12') == t assert g2t('2001/05/12') == t assert g2t('5/12/2001') == t + assert g2t('123456') == 123456 + + def testGenericStringErrors(self): + """Test genstrtotime on some bad strings""" + g2t = Time.genstrtotime + self.assertRaises(TimeException, g2t, "hello") + self.assertRaises(TimeException, g2t, "") + self.assertRaises(TimeException, g2t, "3q") + if __name__ == '__main__': unittest.main() -- cgit v1.2.1