from __future__ import generators
import unittest, os, re, sys, time
from commontest import *
from rdiff_backup import Globals, log, rpath, robust, FilenameMapping

"""Regression tests"""

Globals.exclude_mirror_regexps = [re.compile(".*/rdiff-backup-data")]
log.Log.setverbosity(3)

lc = Globals.local_connection

class Local:
	"""This is just a place to put increments relative to the local
	connection"""
	def get_local_rp(extension):
		return rpath.RPath(Globals.local_connection, "testfiles/" + extension)

	vftrp = get_local_rp('various_file_types')
	inc1rp = get_local_rp('increment1')
	inc2rp = get_local_rp('increment2')
	inc3rp = get_local_rp('increment3')
	inc4rp = get_local_rp('increment4')

	rpout = get_local_rp('output')
	rpout_inc = get_local_rp('output_inc')
	rpout1 = get_local_rp('restoretarget1')
	rpout2 = get_local_rp('restoretarget2')
	rpout3 = get_local_rp('restoretarget3')
	rpout4 = get_local_rp('restoretarget4')

	prefix = get_local_rp('.')

	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

	wininc2 = get_local_rp('win-increment2')
	wininc3 = get_local_rp('win-increment3')

class PathSetter(unittest.TestCase):
	def setUp(self):
		self.reset_schema()

	def reset_schema(self):
		self.rb_schema = (SourceDir +
						  "/../rdiff-backup -v5 --no-compare-inode " 
						  "--remote-schema './chdir-wrapper2 %s' ")

	def refresh(self, *rp_list):
		"""Reread data for the given rps"""
		for rp in rp_list: rp.setdata()

	def set_connections(self, src_pre, src_back, dest_pre, dest_back):
		"""Set source and destination prefixes"""
		if src_pre: self.src_prefix = "%s::%s" % (src_pre, src_back)
		else: self.src_prefix = './'

		if dest_pre: self.dest_prefix = "%s::%s" % (dest_pre, dest_back)
		else: self.dest_prefix = './'

	def exec_rb(self, time, *args):
		"""Run rdiff-backup on given arguments"""
		self.exec_rb_extra_args(time, '', *args)

	def exec_rb_extra_args(self, time, extra_args, *args):
		self.exec_rb_extra_args_retval(time, extra_args, 0, *args)

	def exec_rb_extra_args_retval(self, time, extra_args, ret_val, *args):
		"""Like exec_rb_extra_args, but require return val to be ret_val

		Because of some problems I have with os.system, return val is
		only accurate to 0 or non-zero.

		"""
		arglist = []
		if time: arglist.extend(["--current-time",  str(time)])
		if args[0][0] == "/": arglist.append(args[0])
		else: arglist.append(self.src_prefix + args[0])
		if len(args) > 1:
			if args[1][0] == "/": arglist.append(args[1])
			else: arglist.append(self.dest_prefix + args[1])
			assert len(args) == 2

		arg_string = ' '.join(map(lambda s: "'%s'" % (s,), arglist))
		cmdstr = "%s %s %s" % (self.rb_schema, extra_args, arg_string)
		print "executing " + cmdstr
		actual_val = os.system(cmdstr)
		assert ((actual_val == 0 and ret_val == 0) or
				(actual_val > 0 and ret_val > 0)), \
				"Bad return val %s" % (actual_val,)

	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 exec_rb_restore_extra_args(self, time, extra_args, *args):
		"""Like exec_rb_restore, but can provide extra arguments"""
		arglist = []
		arglist.append("--restore-as-of %s" % str(time))
		arglist.append(extra_args)
		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 '
							 'testfiles/timbar.pyc testfiles/vft2_out')

	def runtest(self):
		self.delete_tmpdirs()

		# Backing up increment1
		self.exec_rb(10000, 'testfiles/increment1', 'testfiles/output')
		assert CompareRecursive(Local.inc1rp, Local.rpout)
		time.sleep(1)

		# Backing up increment2
		self.exec_rb(20000, 'testfiles/increment2', 'testfiles/output')
		assert CompareRecursive(Local.inc2rp, Local.rpout)
		time.sleep(1)

		# Backing up increment3
		self.exec_rb(30000, 'testfiles/increment3', 'testfiles/output')
		assert CompareRecursive(Local.inc3rp, Local.rpout)
		time.sleep(1)

		# Backing up increment4
		self.exec_rb(40000, 'testfiles/increment4', 'testfiles/output')
		assert CompareRecursive(Local.inc4rp, Local.rpout)

		# Getting restore rps
		inc_paths = self.getinc_paths("increments.",
									  "testfiles/output/rdiff-backup-data")
		assert len(inc_paths) == 3

		# Restoring increment1
		self.exec_rb(None, inc_paths[0], 'testfiles/restoretarget1')
		assert CompareRecursive(Local.inc1rp, Local.rpout1)

		# Restoring increment2
		self.exec_rb(None, inc_paths[1], 'testfiles/restoretarget2')
		assert CompareRecursive(Local.inc2rp, Local.rpout2)

		# Restoring increment3
		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(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(None, timbar_paths[0], 'testfiles/timbar.pyc')
		self.refresh(Local.timbar_in, Local.timbar_out)
		assert Local.timbar_in.equal_loose(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
		nochange_incs = len(self.getinc_paths("",
			"testfiles/output/rdiff-backup-data/increments/nochange"))
		assert nochange_incs == 1 or nochange_incs == 0, nochange_incs

	def getinc_paths(self, basename, directory, quoted = 0):
		"""Return increment.______.dir paths"""
		if quoted:
			FilenameMapping.set_init_quote_vals()
			dirrp = FilenameMapping.QuotedRPath(Globals.local_connection,
												  directory)
		else: dirrp = rpath.RPath(Globals.local_connection, directory)
		incbasenames = [filename for filename in robust.listrp(dirrp)
						if filename.startswith(basename)]
		incbasenames.sort()
		incrps = map(dirrp.append, incbasenames)
		return map(lambda x: x.path,
				   filter(lambda incrp: incrp.isincfile(), incrps))


class Final(PathSetter):
	def testLocal(self):
		"""Run test sequence everything local"""
		self.set_connections(None, None, None, None)
		self.runtest()

	def testRemoteAll(self):
		"""Run test sequence everything remote"""
		self.set_connections("test1/", '../', 'test2/tmp/', '../../')
		self.runtest()

	def testRemoteSource(self):
		"""Run test sequence when remote side is source"""
		self.set_connections("test1/", "../", None, None)
		self.runtest()

	def testRemoteDest(self):
		"""Run test sequence when remote side is destination"""
		self.set_connections(None, None, "test2/tmp", "../../")
		self.runtest()

	def testProcLocal(self):
		"""Test initial backup of /proc locally"""
		Myrm("testfiles/procoutput")
		procout = rpath.RPath(Globals.local_connection, 'testfiles/procoutput')
		self.set_connections(None, None, None, None)
		self.exec_rb(10000, '/proc', procout.path)
		time.sleep(1)
		self.exec_rb(20000, '/proc', procout.path)
		time.sleep(1)
		self.exec_rb(30000, Local.inc1rp.path, procout.path)
		assert CompareRecursive(Local.inc1rp, procout)
		time.sleep(1)
		self.exec_rb(40000, '/proc', procout.path)

	def testProcRemote(self):
		"""Test mirroring proc remote"""
		Myrm("testfiles/procoutput")
		procout = rpath.RPath(Globals.local_connection, 'testfiles/procoutput')
		self.set_connections(None, None, "test2/tmp/", "../../")
		self.exec_rb(10000, '/proc', procout.path)
		time.sleep(1)
		self.exec_rb(20000, '/proc', procout.path)
		time.sleep(1)
		self.exec_rb(30000, Local.inc1rp.path, procout.path)
		assert CompareRecursive(Local.inc1rp, procout)
		time.sleep(1)
		self.exec_rb(40000, '/proc', procout.path)

	def testProcRemote2(self):
		"""Test mirroring proc, this time when proc is remote, dest local"""
		Myrm("testfiles/procoutput")
		self.set_connections("test1/", "../", None, None)
		self.exec_rb(None, '/proc', 'testfiles/procoutput')

	def testWindowsMode(self):
		"""Test backup with quoting enabled

		We need to delete from the increment? directories long file
		names, because quoting adds too many extra letters.

		"""
		def delete_long(base_rp, length = 100):
			"""Delete filenames longer than length given"""
			for rp in selection.Select(base_rp).set_iter():
				if len(rp.dirsplit()[1]) > length: rp.delete()

		if not Local.wininc2.lstat() or not Local.wininc3.lstat():
			os.system("cp -a testfiles/increment2 testfiles/win-increment2")
			os.system("cp -a testfiles/increment3 testfiles/win-increment3")
			delete_long(Local.wininc2)
			delete_long(Local.wininc3)

		old_schema = self.rb_schema
		self.rb_schema = old_schema+" --override-chars-to-quote '^a-z0-9_ -.' "
		self.set_connections(None, None, None, None)

		self.delete_tmpdirs()
		# Back up increment2, this contains a file with colons
		self.exec_rb(20000, 'testfiles/win-increment2', 'testfiles/output')
		self.rb_schema = old_schema # Quoting setting should now be saved
		time.sleep(1)

		# Back up increment3
		self.exec_rb(30000, 'testfiles/win-increment3', 'testfiles/output')

		# Now check to make sure no ":" in output directory
		popen_fp = os.popen("find testfiles/output -name '*:*' | wc")
		wc_output = popen_fp.read()
		popen_fp.close()
		assert wc_output.split() == ["0", "0", "0"], wc_output

		# Start restore of increment 2
		Globals.chars_to_quote = '^a-z0-9_ -.'
		inc_paths = self.getinc_paths("increments.",
									  "testfiles/output/rdiff-backup-data", 1)
		Globals.chars_to_quote = None
		assert len(inc_paths) == 1, inc_paths
		self.exec_rb(None, inc_paths[0], 'testfiles/restoretarget2')
		assert CompareRecursive(Local.wininc2, Local.rpout2,
								compare_hardlinks = 0)

		# Restore increment 3 again, using different syntax
		self.rb_schema = old_schema + '-r 30000 '
		self.exec_rb(None, 'testfiles/output', 'testfiles/restoretarget3')
		assert CompareRecursive(Local.wininc3, Local.rpout3,
								compare_hardlinks = 0)
		self.rb_schema = old_schema

	def testLegacy(self):
		"""Test restoring directory with no mirror_metadata file"""
		self.delete_tmpdirs()
		self.set_connections(None, None, None, None)
		self.exec_rb(10000, 'testfiles/various_file_types',
					 'testfiles/output')
		self.exec_rb(20000, 'testfiles/empty', 'testfiles/output')
		assert not os.system(MiscDir + '/myrm testfiles/output/rdiff-backup-data/mirror_metadata*')
		self.exec_rb_extra_args(None, '-r0', 'testfiles/output',
								'testfiles/restoretarget1')
		assert CompareRecursive(Local.vftrp, Local.rpout1,
								compare_hardlinks = 0)


class FinalMisc(PathSetter):
	"""Test miscellaneous operations like list-increments, etc.

	Many of these just run and make sure there were no errors; they
	don't verify the output.

	"""
	def testListIncrementsLocal(self):
		"""Test --list-increments switch.  Assumes restoretest3 valid rd dir"""
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, "--list-increments",
								"testfiles/restoretest3")

	def testListIncrementsRemote(self):
		"""Test --list-increments mode remotely.  Uses restoretest3"""
		self.set_connections('test1', '../', None, None)
		self.exec_rb_extra_args(None, "--list-increments",
								"testfiles/restoretest3")

	def testListChangeSinceLocal(self):
		"""Test --list-changed-since mode locally.  Uses restoretest3"""
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, '--list-changed-since 10000',
								'testfiles/restoretest3')
		self.exec_rb_extra_args(None, '--list-changed-since 2B',
								'testfiles/restoretest3')

	def testListChangeSinceRemote(self):
		"""Test --list-changed-since mode remotely.  Uses restoretest3"""
		self.set_connections('test1', '../', None, None)
		self.exec_rb_extra_args(None, '--list-changed-since 10000',
								'testfiles/restoretest3')

	def testListAtTimeLocal(self):
		"""Test --list-at-time mode locally.  Uses restoretest3"""
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, '--list-at-time 20000',
								'testfiles/restoretest3')
		
	def testListAtTimeRemote(self):
		"""Test --list-at-time mode locally.  Uses restoretest3"""
		self.set_connections('test1', '../', None, None)
		self.exec_rb_extra_args(None, '--list-at-time 20000',
								'testfiles/restoretest3')

	def testListIncrementSizesLocal(self):
		"""Test --list-increment-sizes switch.  Uses restoretest3"""
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, "--list-increment-sizes",
								"testfiles/restoretest3")

	def testListIncrementSizesRemote(self):
		"""Test --list-increment-sizes switch.  Uses restoretest3"""
		self.set_connections('test1', '../', None, None)
		self.exec_rb_extra_args(None, "--list-increment-sizes",
								"testfiles/restoretest3")

	def testListIncrementsRemote(self):
		"""Test --list-increment-sizes mode remotely.  Uses restoretest3"""
		self.set_connections('test1', '../', None, None)
		self.exec_rb_extra_args(None, "--list-increment-sizes",
								"testfiles/restoretest3")

	def get_all_increments(self, rp):
		"""Iterate all increments at or below given directory"""
		assert rp.isdir()
		dirlist = rp.listdir()
		dirlist.sort()
		for filename in dirlist:
			subrp = rp.append(filename)
			if subrp.isincfile(): yield subrp
			elif subrp.isdir():
				for subsubrp in self.get_all_increments(subrp):
					yield subsubrp

	def testRemoveOlderThan(self):
		"""Test --remove-older-than.  Uses restoretest3"""
		Myrm("testfiles/output")
		assert not os.system("cp -a testfiles/restoretest3 testfiles/output")
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, "--remove-older-than 20000",
								"testfiles/output")
		rbdir = rpath.RPath(Globals.local_connection,
							"testfiles/output/rdiff-backup-data")
		for inc in self.get_all_increments(rbdir):
			assert inc.getinctime() >= 20000

	def testRemoveOlderThan2(self):
		"""Test --remove-older-than, but '1B'.  Uses restoretest3"""
		Myrm("testfiles/output")
		assert not os.system("cp -a testfiles/restoretest3 testfiles/output")
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, "--remove-older-than 1B --force",
								"testfiles/output")
		rbdir = rpath.RPath(Globals.local_connection,
							"testfiles/output/rdiff-backup-data")
		for inc in self.get_all_increments(rbdir):
			assert inc.getinctime() >= 30000

	def testRemoveOlderThanQuoting(self):
		"""Test --remove-older-than when dest directory is quoted"""
		Myrm("testfiles/output")
		self.set_connections(None, None, None, None)
		self.exec_rb_extra_args(None, "--override-chars-to-quote '^a-z0-9_ -.'",
								"testfiles/increment1", "testfiles/output")
		self.exec_rb_extra_args(None, "--remove-older-than now", "testfiles/output")

	def testRemoveOlderThanRemote(self):
		"""Test --remove-older-than remotely"""
		Myrm("testfiles/output")
		assert not os.system("cp -a testfiles/restoretest3 testfiles/output")
		self.set_connections("test1/", "../", None, None)
		self.exec_rb_extra_args(None, "--remove-older-than 20000",
								"testfiles/output")
		rbdir = rpath.RPath(Globals.local_connection,
							"testfiles/output/rdiff-backup-data")
		for inc in self.get_all_increments(rbdir):
			assert inc.getinctime() >= 20000

	def testCompare(self):
		"""Test --compare and --compare-older-than modes"""
		Myrm("testfiles/output")
		self.set_connections(None, None, None, None)
		self.exec_rb(10000, 'testfiles/increment1', 'testfiles/output')
		self.exec_rb(20000, 'testfiles/increment2', 'testfiles/output')

		self.exec_rb_extra_args_retval(20000, '--compare', 0,
					 'testfiles/increment2', 'testfiles/output')
		self.exec_rb_extra_args_retval(20000, '--compare', 1,
					 'testfiles/increment1', 'testfiles/output')
		self.exec_rb_extra_args_retval(20000, '--compare-at-time 10000', 1,
					 'testfiles/increment2', 'testfiles/output')
		self.exec_rb_extra_args_retval(20000, '--compare-at-time 10000', 0,
					 'testfiles/increment1', 'testfiles/output')


class FinalSelection(PathSetter):
	"""Test selection options"""
	def system(self, cmd):
		print "Executing: ", cmd
		assert not os.system(cmd)

	def testSelLocal(self):
		"""Quick backup testing a few selection options"""
		self.delete_tmpdirs()

		# Test --include option
		assert not \
			 self.system(self.rb_schema +
						 "--current-time 10000 "
						 "--include testfiles/increment2/various_file_types "
						 "--exclude '**' "
						 "testfiles/increment2 testfiles/output")

		assert os.lstat("testfiles/output/various_file_types/regular_file")
		self.assertRaises(OSError, os.lstat, "testfiles/output/test.py")

		# Now try reading list of files
		fp = os.popen(self.rb_schema +
					  "--current-time 20000 "
					  "--include-filelist-stdin --exclude '**' "
					  "testfiles/increment2 testfiles/output", "w")
		fp.write("""
testfiles/increment2/test.py
testfiles/increment2/changed_dir""")
		assert not fp.close()

		assert os.lstat("testfiles/output/changed_dir")
		assert os.lstat("testfiles/output/test.py")
		self.assertRaises(OSError, os.lstat,
						  "testfiles/output/various_file_types")
		self.assertRaises(OSError, os.lstat,
						  "testfiles/output/changed_dir/foo")

		# Test selective restoring
		mirror_rp = rpath.RPath(Globals.local_connection, "testfiles/output")
		restore_filename = get_increment_rp(mirror_rp, 10000).path
		self.system(self.rb_schema +
					"--include testfiles/restoretarget1/various_file_types/"
					"regular_file "
					"--exclude '**' " +
					restore_filename + " testfiles/restoretarget1")
		assert os.lstat("testfiles/restoretarget1/various_file_types/"
						"regular_file")
		self.assertRaises(OSError, os.lstat, "testfiles/restoretarget1/tester")
		self.assertRaises(OSError, os.lstat,
				 "testfiles/restoretarget1/various_file_types/executable")

		fp = os.popen(self.rb_schema +
					  "--include-filelist-stdin " + restore_filename +
					  " testfiles/restoretarget2", "w")
		fp.write("""
- testfiles/restoretarget2/various_file_types/executable""")
		assert not fp.close()
		assert os.lstat("testfiles/restoretarget2/various_file_types/"
						"regular_file")
		self.assertRaises(OSError, os.lstat,
			   "testfiles/restoretarget2/various_file_types/executable")

	def testSelFilesRemote(self):
		"""Test for bug found in 0.7.[34] - filelist where source remote"""
		self.delete_tmpdirs()
		self.set_connections("test1/", "../", 'test2/tmp/', '../../')
		self.rb_schema += ("--exclude-filelist testfiles/vft_out/exclude "
						   "--include-filelist testfiles/vft_out/include "
						   "--exclude '**' ")

		# Make an exclude list
		os.mkdir("testfiles/vft_out")
		excluderp = rpath.RPath(Globals.local_connection,
								"testfiles/vft_out/exclude")
		fp = excluderp.open("w")
		fp.write("""
../testfiles/various_file_types/regular_file
../testfiles/various_file_types/test
""")
		assert not fp.close()

		# Make an include list
		includerp = rpath.RPath(Globals.local_connection,
								"testfiles/vft_out/include")
		fp = includerp.open("w")
		fp.write("""
../testfiles/various_file_types/executable
../testfiles/various_file_types/symbolic_link
../testfiles/various_file_types/regular_file
../testfiles/various_file_types/test
""")
		assert not fp.close()

		self.exec_rb(None, 'testfiles/various_file_types', 'testfiles/output')

		self.reset_schema()
		self.exec_rb_restore("now", 'testfiles/output',
							 'testfiles/restoretarget1')
		assert os.lstat('testfiles/restoretarget1/executable')
		assert os.lstat('testfiles/restoretarget1/symbolic_link')
		self.assertRaises(OSError, os.lstat,
						  'testfiles/restoretarget1/regular_file')
		self.assertRaises(OSError, os.lstat,
						  'testfiles/restoretarget1/executable2')

	def testSelRestoreLocal(self):
		"""Test selection options when restoring locally"""
		self.set_connections(None, None, None, None)
		self.run_sel_restore_test()

	def testSelRestoreRemote(self):
		"""Test selection options when both sides are remote"""
		self.set_connections("test1/", "../", "test2/tmp/", "../../")
		self.run_sel_restore_test("../../")

	def run_sel_restore_test(self, prefix = ""):
		"""Test selection options with restore"""
		self.make_restore_sel_dir()
		existing_file = self.make_restore_existing_target()
		file1_target = Local.rpout1.append("file1")
		file2_target = Local.rpout1.append("file2")
		excludes = ("--exclude %s --exclude %s --force" %
					(prefix + file1_target.path, prefix + existing_file.path))
		self.exec_rb_restore_extra_args("now", excludes,
										Local.rpout.path, Local.rpout1.path)
		for rp in (file1_target, file2_target, existing_file):
			rp.setdata()
		assert not file1_target.lstat(), file1_target.lstat()
		assert file2_target.lstat()
		assert existing_file.lstat() # excluded file shouldn't be deleted

	def make_restore_sel_dir(self):
		"""Create rdiff-backup repository at Local.rpout"""
		self.delete_tmpdirs()
		Local.vft_in.mkdir()
		rp1 = Local.vft_in.append("file1")
		rp2 = Local.vft_in.append("file2")
		rp1.touch()
		rp2.touch()
		self.exec_rb(None, Local.vft_in.path, Local.rpout.path)
		Myrm(Local.vft_in.path)

	def make_restore_existing_target(self):
		"""Create an existing file in the restore target directory"""
		Local.rpout1.mkdir()
		existing_file = Local.rpout1.append("existing_file")
		existing_file.touch()
		return existing_file

class FinalCorrupt(PathSetter):
	"""Test messing with things a bit and making sure they still work"""
	def make_dir(self):
		self.delete_tmpdirs()
		rp1 = rpath.RPath(Globals.local_connection, 'testfiles/final_deleted1')
		if rp1.lstat(): Myrm(rp1.path)
		rp1.mkdir()
		rp1_1 = rp1.append('regfile')
		rp1_1.touch()
		rp1_2 = rp1.append('dir')
		rp1_2.mkdir()
		rp1_2_1 = rp1_2.append('regfile2')
		rp1_2_1.write_string('foo')

		rp2 = rpath.RPath(Globals.local_connection, 'testfiles/final_deleted2')
		if rp2.lstat(): Myrm(rp2.path)
		os.system('cp -a %s %s' % (rp1.path, rp2.path))
		rp2_2_1 = rp2.append('dir').append('regfile2')
		assert rp2_2_1.lstat()
		rp2_2_1.delete()
		rp2_2_1.touch()
		return rp1, rp1_2, rp2

	def test_dest_delete(self):
		"""Test deleting a directory from the destination dir

		Obviously that directory can no longer be restored, but the
		rest of the files should be OK.  Just runs locally for now.

		"""
		in_dir1, in_subdir, in_dir2 = self.make_dir()
		self.set_connections(None, None, None, None)
		self.exec_rb(10000, in_dir1.path, 'testfiles/output')

		out_subdir = rpath.RPath(Globals.local_connection,
								 'testfiles/output/%s' %
								 (in_subdir.index[-1],))
		log.Log("Deleting %s" % (out_subdir.path,), 3)
		out_subdir.delete()
		self.exec_rb(20000, in_dir2.path, 'testfiles/output')

		self.exec_rb_restore(10000, 'testfiles/output',
							 'testfiles/restoretarget1')


class FinalBugs(PathSetter):
	"""Test for specific bugs that have been reported"""
	def test_symlink_popple(self):
		"""Test for Popple's symlink bug

		Earlier, certain symlinks could cause data loss in _source_
		directory when regressing.  See mailing lists around 4/2/05
		for more info.

		"""
		self.delete_tmpdirs()
		self.set_connections(None, None, None, None)

		# Make directories
		rp1 = rpath.RPath(Globals.local_connection, 'testfiles/sym_in1')
		if rp1.lstat(): rp1.delete()
		rp1.mkdir()
		rp1_d = rp1.append('subdir')
		rp1_d.mkdir()
		rp1_d_f = rp1_d.append('file')
		rp1_d_f.touch()
		
		rp2 = rpath.RPath(Globals.local_connection, 'testfiles/sym_in2')
		if rp2.lstat(): rp2.delete()
		rp2.mkdir()
		rp2_s = rp2.append('subdir')
		rp2_s.symlink("%s/%s" % (os.getcwd(), rp1_d.path))

		# Backup
		self.exec_rb(10000, rp1.path, 'testfiles/output')
		self.exec_rb(20000, rp2.path, 'testfiles/output')

		# Make failed backup
		rbdir = rpath.RPath(Globals.local_connection,
							'testfiles/output/rdiff-backup-data')
		curmir = rbdir.append('current_mirror.%s.data' %
							  (Time.timetostring(30000),))
		curmir.touch()

		# Regress
		self.exec_rb_extra_args(30000, '--check-destination-dir',
								'testfiles/output')

		# Check to see if file still there
		rp1_d_f.setdata()
		assert rp1_d_f.isreg(), 'File %s corrupted' % (rp1_d_f.path,)

		
if __name__ == "__main__": unittest.main()