Major refactoring - avoid use of 'from XX import *' in favor of more

normal 'import XXX' syntax.  The previous way was an artifact from
earlier versions where the whole program fit in one file.


git-svn-id: http://svn.savannah.nongnu.org/svn/rdiff-backup/trunk@252 2b77aa54-bcbc-44c9-a7ec-4f6cf2b41109

1 files changed, 217 insertions, 41 deletions

diff --git a/rdiff-backup/testing/rorpitertest.py b/rdiff-backup/testing/rorpitertest.py
index e1e0926..ec786c2 100644
--- a/rdiff-backup/testing/rorpitertest.py
+++ b/rdiff-backup/testing/rorpitertest.py
@@ -1,10 +1,7 @@
-import unittest
+from __future__ import generators
+import unittest, time, pickle
 from commontest import *
-from rdiff_backup.log import *
-from rdiff_backup.rpath import *
-from rdiff_backup.rorpiter import *
-from rdiff_backup import Globals
-
+from rdiff_backup import log, rpath, rorpiter, Globals, lazy
 
 #Log.setverbosity(8)
 
@@ -17,10 +14,10 @@ class index:
 class RORPIterTest(unittest.TestCase):
 	def setUp(self):
 		self.lc = Globals.local_connection
-		self.inc0rp = RPath(self.lc, "testfiles/empty", ())
-		self.inc1rp = RPath(self.lc, "testfiles/inc-reg-perms1", ())
-		self.inc2rp = RPath(self.lc, "testfiles/inc-reg-perms2", ())
-		self.output = RPath(self.lc, "testfiles/output", ())
+		self.inc0rp = rpath.RPath(self.lc, "testfiles/empty", ())
+		self.inc1rp = rpath.RPath(self.lc, "testfiles/inc-reg-perms1", ())
+		self.inc2rp = rpath.RPath(self.lc, "testfiles/inc-reg-perms2", ())
+		self.output = rpath.RPath(self.lc, "testfiles/output", ())
 
 	def testCollateIterators(self):
 		"""Test basic collating"""
@@ -31,44 +28,47 @@ class RORPIterTest(unittest.TestCase):
 		makeiter2 = lambda: iter(map(helper, [0,1,3]))
 		makeiter3 = lambda: iter(map(helper, [1,2]))
 
-		outiter = RORPIter.CollateIterators(makeiter1(), makeiter2())
-		assert Iter.equal(outiter,
-						  iter([(indicies[0], indicies[0]),
-								(indicies[1], indicies[1]),
-								(indicies[2], None),
-								(indicies[3], indicies[3])]))
-
-		assert Iter.equal(RORPIter.CollateIterators(makeiter1(),
-													makeiter2(),
-													makeiter3()),
-						  iter([(indicies[0], indicies[0], None),
-								(indicies[1], indicies[1], indicies[1]),
-								(indicies[2], None, indicies[2]),
-								(indicies[3], indicies[3], None)]))
-
-		assert Iter.equal(RORPIter.CollateIterators(makeiter1(), iter([])),
-						  iter(map(lambda i: (i, None),
-								   indicies)))
-		assert Iter.equal(iter(map(lambda i: (i, None), indicies)),
-						  RORPIter.CollateIterators(makeiter1(), iter([])))
+		outiter = rorpiter.CollateIterators(makeiter1(), makeiter2())
+		assert lazy.Iter.equal(outiter,
+							   iter([(indicies[0], indicies[0]),
+									 (indicies[1], indicies[1]),
+									 (indicies[2], None),
+									 (indicies[3], indicies[3])]))
+
+		assert lazy.Iter.equal(rorpiter.CollateIterators(makeiter1(),
+														 makeiter2(),
+														 makeiter3()),
+							   iter([(indicies[0], indicies[0], None),
+									 (indicies[1], indicies[1], indicies[1]),
+									 (indicies[2], None, indicies[2]),
+									 (indicies[3], indicies[3], None)]))
+
+		assert lazy.Iter.equal(rorpiter.CollateIterators(makeiter1(),
+														 iter([])),
+							   iter(map(lambda i: (i, None),
+										indicies)))
+		assert lazy.Iter.equal(iter(map(lambda i: (i, None), indicies)),
+							   rorpiter.CollateIterators(makeiter1(),
+														 iter([])))
 		
 
 	def testCombinedPatching(self):
 		"""Combined signature, patch, and diff operations"""
-		if self.output.lstat(): self.output.delete()
+		if self.output.lstat():
+			Myrm(self.output.path)
+			self.output.setdata()
 
 		def turninto(final_rp):
-			sigfile = RORPIter.ToFile(RORPIter.GetSignatureIter(self.output))
-			diff_file = RORPIter.ToFile(
-				RORPIter.GetDiffIter(RORPIter.FromFile(sigfile),
-									 RORPIter.IterateRPaths(final_rp)))
-			RORPIter.PatchIter(self.output, RORPIter.FromFile(diff_file))
+			sigfile = rorpiter.ToFile(rorpiter.GetSignatureIter(self.output))
+			diff_file = rorpiter.ToFile(rorpiter.GetDiffIter(
+				rorpiter.FromFile(sigfile), rorpiter.IterateRPaths(final_rp)))
+			rorpiter.PatchIter(self.output, rorpiter.FromFile(diff_file))
 
 		turninto(self.inc1rp)
-		RPath.copy_attribs(self.inc1rp, self.output) # Update time
+		rpath.copy_attribs(self.inc1rp, self.output) # Update time
 		assert self.compare_no_times(self.inc1rp, self.output)
 		turninto(self.inc2rp)
-		RPath.copy_attribs(self.inc2rp, self.output)
+		rpath.copy_attribs(self.inc2rp, self.output)
 		assert self.compare_no_times(self.inc2rp, self.output)
 
 	def compare_no_times(self, src_rp, dest_rp):
@@ -83,8 +83,8 @@ class RORPIterTest(unittest.TestCase):
 class IndexedTupleTest(unittest.TestCase):
 	def testTuple(self):
 		"""Test indexed tuple"""
-		i = IndexedTuple((1,2,3), ("a", "b"))
-		i2 = IndexedTuple((), ("hello", "there", "how are you"))
+		i = rorpiter.IndexedTuple((1,2,3), ("a", "b"))
+		i2 = rorpiter.IndexedTuple((), ("hello", "there", "how are you"))
 
 		assert i[0] == "a"
 		assert i[1] == "b"
@@ -93,10 +93,186 @@ class IndexedTupleTest(unittest.TestCase):
 		assert i2 < i, i2 < i
 
 	def testTupleAssignment(self):
-		a, b, c = IndexedTuple((), (1, 2, 3))
+		a, b, c = rorpiter.IndexedTuple((), (1, 2, 3))
 		assert a == 1
 		assert b == 2
 		assert c == 3
 
+
+class DirHandlerTest(unittest.TestCase):
+	made_test_dir = 0 # Set to 1 once we have made the test dir
+	def make_test_dir(self):
+		"""Make the test directory"""
+		self.rootrp = RPath(Globals.local_connection, "testfiles/output")
+		self.rootrp.delete()
+		self.rootrp.mkdir()
+		
+		self.a = self.rootrp.append("a")
+		self.b = self.rootrp.append("b")
+		self.c = self.rootrp.append("c")
+		self.a.mkdir()
+		self.b.mkdir()
+		self.b.chmod(0700)
+		self.c.mkdir()
+		self.c.chmod(0500) # No write permissions to c
+
+		self.rootmtime = self.rootrp.getmtime()
+		self.amtime = self.a.getmtime()
+		self.bmtime = self.b.getmtime()
+		self.cmtime = self.c.getmtime()
+
+		self.made_test_dir = 1
+		
+	def test_times_and_writes(self):
+		"""Test writing without disrupting times, and to unwriteable dir"""
+		return
+		self.make_test_dir()
+		time.sleep(1) # make sure the mtimes would get updated otherwise
+		DH = DirHandler(self.rootrp)
+
+		new_a_rp = self.a.append("foo")
+		DH(new_a_rp)
+		new_a_rp.touch()
+
+		DH(self.b)
+		self.b.chmod(0751)
+		new_b_rp = self.b.append("aoenuth")
+		DH(new_b_rp)
+		new_b_rp.touch()
+
+		new_root_rp = self.rootrp.append("bb")
+		DH(new_root_rp)
+		new_root_rp.touch()
+
+		new_c_rp = self.c.append("bar")
+		DH(new_c_rp)
+		new_c_rp.touch()
+		DH.Finish()
+
+		assert new_a_rp.lstat() and new_b_rp.lstat() and new_c_rp.lstat()
+		self.a.setdata()
+		self.b.setdata()
+		self.c.setdata()
+		assert self.a.getmtime() == self.amtime
+		assert self.c.getmtime() == self.cmtime
+		assert self.rootrp.getmtime() == self.rootmtime
+		assert self.b.getperms() == 0751
+		assert self.c.getperms() == 0500
+
+
+class FillTest(unittest.TestCase):
+	def test_fill_in(self):
+		"""Test fill_in_iter"""
+		rootrp = RPath(Globals.local_connection, "testfiles/output")
+		def get_rpiter():
+			for int_index in [(1,2), (1,3), (1,4),
+							  (2,), (2,1),
+							  (3,4,5), (3,6)]:
+				index = tuple(map(lambda i: str(i), int_index))
+				yield rootrp.new_index(index)
+
+		filled_in = rorpiter.FillInIter(get_rpiter(), rootrp)
+		rp_list = list(filled_in)
+		index_list = map(lambda rp: tuple(map(int, rp.index)), rp_list)
+		assert index_list == [(), (1,), (1,2), (1,3), (1,4),
+							  (2,), (2,1),
+							  (3,), (3,4), (3,4,5), (3,6)], index_list
+
+
+class ITRBadder(rorpiter.ITRBranch):
+	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
+
+	def branch_process(self, subinstance):
+		#print "Adding subinstance ", subinstance.total
+		self.total += subinstance.total
+
+class ITRBadder2(rorpiter.ITRBranch):
+	def start_process(self, index):
+		self.total = 0
+
+	def end_process(self):
+		#print "Adding ", self.base_index
+		self.total += reduce(lambda x,y: x+y, self.base_index, 0)
+
+	def can_fast_process(self, index):
+		if len(index) == 3: return 1
+		else: return None
+
+	def fast_process(self, index):
+		self.total += index[0] + index[1] + index[2]
+
+	def branch_process(self, subinstance):
+		#print "Adding branch ", subinstance.total
+		self.total += subinstance.total
+
+
+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)]
+
+		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 = rorpiter.IterTreeReducer(ITRBadder, [])
+		for index in self.i1:
+			val = itm(index)
+			assert val, (val, index)
+		itm.Finish()
+		assert itm.root_branch.total == 6, itm.root_branch.total
+
+		itm2 = rorpiter.IterTreeReducer(ITRBadder2, [])
+		for index in self.i2:
+			val = itm2(index)
+			if index == (): assert not val
+			else: assert val
+		itm2.Finish()
+		assert itm2.root_branch.total == 12, itm2.root_branch.total
+
+	def testTreeReducerState(self):
+		"""Test saving and recreation of an IterTreeReducer"""
+		itm1a = rorpiter.IterTreeReducer(ITRBadder, [])
+		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.root_branch.total == 6, itm1b.root_branch.total
+
+		itm2a = rorpiter.IterTreeReducer(ITRBadder2, [])
+		for index in self.i2a:
+			val = itm2a(index)
+			if index == (): assert not val
+			else: assert val
+		itm2b = pickle.loads(pickle.dumps(itm2a))
+		for index in self.i2b:
+			val = itm2b(index)
+			if index == (): assert not val
+			else: assert val
+		itm2c = pickle.loads(pickle.dumps(itm2b))
+		for index in self.i2c:
+			val = itm2c(index)
+			if index == (): assert not val
+			else: assert val
+		itm2c.Finish()
+		assert itm2c.root_branch.total == 12, itm2c.root_branch.total
+
+
+
 if __name__ == "__main__": unittest.main()