def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path("hg"):
raise nose.SkipTest("hg not found in path")
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(["init"], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, "foo.txt"), "w")
foo.write(FOO)
foo.close()
self._hgcmd(["add", "foo.txt"])
self._hgcmd(["commit", "-m", "initial commit"])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(["clone", self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, "wb")
clone_hgrc.write(
self.CLONE_HGRC % {"hg_dir": self.hg_dir, "clone_dir": self.clone_dir, "test_server": self.TESTSERVER}
)
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file("")
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path('hg'):
raise nose.SkipTest('hg not found in path')
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(['init'], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, 'foo.txt'), 'w')
foo.write(FOO)
foo.close()
self._hgcmd(['add', 'foo.txt'])
self._hgcmd(['commit', '-m', 'initial commit'])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(['clone', self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, 'wb')
clone_hgrc.write(
self.CLONE_HGRC % {
'hg_dir': self.hg_dir,
'clone_dir': self.clone_dir,
'test_server': self.TESTSERVER,
})
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path('hg'):
raise nose.SkipTest('hg not found in path')
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(['init'], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, 'foo.txt'), 'w')
foo.write(FOO)
foo.close()
self._hgcmd(['add', 'foo.txt'])
self._hgcmd(['commit', '-m', 'initial commit'])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(['clone', self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, 'wb')
clone_hgrc.write(self.CLONE_HGRC % {
'hg_dir': self.hg_dir,
'clone_dir': self.clone_dir,
'test_server': self.TESTSERVER,
})
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
def _spin_up_client(self):
os.chdir(self.clone_dir)
self.client = MercurialClient()
class MercurialSubversionClientTests(MercurialTestBase):
TESTSERVER = "http://127.0.0.1:8080"
def __init__(self, *args, **kwargs):
self._tmpbase = ''
self.clone_dir = ''
self.svn_repo = ''
self.svn_checkout = ''
self.client = None
self._svnserve_pid = 0
self._max_svnserve_pid_tries = 12
self._svnserve_port = os.environ.get('SVNSERVE_PORT')
self._required_exes = ('svnadmin', 'svnserve', 'svn')
MercurialTestBase.__init__(self, *args, **kwargs)
def setUp(self):
MercurialTestBase.setUp(self)
self._hg_env = {'FOO': 'BAR'}
for exe in self._required_exes:
if not is_exe_in_path(exe):
raise nose.SkipTest('missing svn stuff! giving up!')
if not self._has_hgsubversion():
raise nose.SkipTest('unable to use `hgsubversion` extension! '
'giving up!')
if not self._tmpbase:
self._tmpbase = _get_tmpdir()
self._create_svn_repo()
self._fire_up_svnserve()
self._fill_in_svn_repo()
try:
self._get_testing_clone()
except (OSError, IOError):
msg = 'could not clone from svn repo! skipping...'
raise nose.SkipTest(msg), None, sys.exc_info()[2]
self._spin_up_client()
self._stub_in_config_and_options()
os.chdir(self.clone_dir)
def _has_hgsubversion(self):
output = self._hgcmd(['svn', '--help'],
ignore_errors=True, extra_ignore_errors=(255))
return not re.search("unknown command ['\"]svn['\"]", output, re.I)
def tearDown(self):
shutil.rmtree(self.clone_dir)
os.kill(self._svnserve_pid, 9)
if self._tmpbase:
shutil.rmtree(self._tmpbase)
def _svn_add_file_commit(self, filename, data, msg):
outfile = open(filename, 'w')
outfile.write(data)
outfile.close()
execute(['svn', 'add', filename])
execute(['svn', 'commit', '-m', msg])
def _create_svn_repo(self):
self.svn_repo = os.path.join(self._tmpbase, 'svnrepo')
execute(['svnadmin', 'create', self.svn_repo])
def _fire_up_svnserve(self):
if not self._svnserve_port:
self._svnserve_port = str(randint(30000, 40000))
pid_file = os.path.join(self._tmpbase, 'svnserve.pid')
execute(['svnserve', '--pid-file', pid_file, '-d',
'--listen-port', self._svnserve_port, '-r', self._tmpbase])
for i in range(0, self._max_svnserve_pid_tries):
try:
self._svnserve_pid = int(open(pid_file).read().strip())
return
except (IOError, OSError):
time.sleep(0.25)
# This will re-raise the last exception, which will be either
# IOError or OSError if the above fails and this branch is reached
raise
def _fill_in_svn_repo(self):
self.svn_checkout = os.path.join(self._tmpbase, 'checkout.svn')
execute(['svn', 'checkout', 'file://%s' % self.svn_repo,
self.svn_checkout])
os.chdir(self.svn_checkout)
for subtree in ('trunk', 'branches', 'tags'):
execute(['svn', 'mkdir', subtree])
execute(['svn', 'commit', '-m', 'filling in T/b/t'])
os.chdir(os.path.join(self.svn_checkout, 'trunk'))
for i, data in enumerate([FOO, FOO1, FOO2]):
self._svn_add_file_commit('foo.txt', data, 'foo commit %s' % i)
def _get_testing_clone(self):
self.clone_dir = os.path.join(self._tmpbase, 'checkout.hg')
self._hgcmd([
'clone', 'svn://127.0.0.1:%s/svnrepo' % self._svnserve_port,
self.clone_dir,
])
def _spin_up_client(self):
os.chdir(self.clone_dir)
self.client = MercurialClient()
def _stub_in_config_and_options(self):
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient (+svn) get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertEqual('svn', self.client._type)
self.assertEqual('/trunk', ri.base_path)
self.assertEqual('svn://127.0.0.1:%s/svnrepo' % self._svnserve_port,
ri.path)
def testScanForServerSimple(self):
"""Test MercurialClient (+svn) scan_for_server, simple case"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient (+svn) scan_for_server in .reviewboardrc"""
rc_filename = os.path.join(self.clone_dir, '.reviewboardrc')
rc = open(rc_filename, 'w')
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerProperty(self):
"""Test MercurialClient (+svn) scan_for_server in svn property"""
os.chdir(self.svn_checkout)
execute(['svn', 'update'])
execute(['svn', 'propset', 'reviewboard:url', self.TESTSERVER,
self.svn_checkout])
execute(['svn', 'commit', '-m', 'adding reviewboard:url property'])
os.chdir(self.clone_dir)
self._hgcmd(['pull'])
self._hgcmd(['update', '-C'])
ri = self.client.get_repository_info()
self.assertEqual(self.TESTSERVER, self.client.scan_for_server(ri))
def testDiffSimple(self):
"""Test MercurialClient (+svn) diff, simple case"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO4, 'edit 4')
self.assertEqual(EXPECTED_HG_SVN_DIFF_0, self.client.diff(None)[0])
def testDiffSimpleMultiple(self):
"""Test MercurialClient (+svn) diff with multiple commits"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO4, 'edit 4')
self._hg_add_file_commit('foo.txt', FOO5, 'edit 5')
self._hg_add_file_commit('foo.txt', FOO6, 'edit 6')
self.assertEqual(EXPECTED_HG_SVN_DIFF_1, self.client.diff(None)[0])
class MercurialClientTests(MercurialTestBase):
TESTSERVER = 'http://127.0.0.1:8080'
CLONE_HGRC = dedent("""
[paths]
default = %(hg_dir)s
cloned = %(clone_dir)s
[reviewboard]
url = %(test_server)s
[diff]
git = true
""").rstrip()
def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path('hg'):
raise nose.SkipTest('hg not found in path')
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(['init'], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, 'foo.txt'), 'w')
foo.write(FOO)
foo.close()
self._hgcmd(['add', 'foo.txt'])
self._hgcmd(['commit', '-m', 'initial commit'])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(['clone', self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, 'wb')
clone_hgrc.write(self.CLONE_HGRC % {
'hg_dir': self.hg_dir,
'clone_dir': self.clone_dir,
'test_server': self.TESTSERVER,
})
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
@property
def clone_hgrc_path(self):
return os.path.join(self.clone_dir, '.hg', 'hgrc')
@property
def hgrc_path(self):
return os.path.join(self.hg_dir, '.hg', 'hgrc')
def tearDown(self):
os.chdir(self.orig_dir)
shutil.rmtree(self.hg_dir)
shutil.rmtree(self.clone_dir)
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertTrue(isinstance(ri, RepositoryInfo))
self.assertEqual('', ri.base_path)
hgpath = ri.path
if os.path.basename(hgpath) == '.hg':
hgpath = os.path.dirname(hgpath)
self.assertEqual(self.hg_dir, hgpath)
self.assertTrue(ri.supports_parent_diffs)
self.assertFalse(ri.supports_changesets)
def testScanForServerSimple(self):
"""Test MercurialClient scan_for_server, simple case"""
os.rename(self.clone_hgrc_path,
os.path.join(self.clone_dir, '._disabled_hgrc'))
self.client.hgrc = {}
self.client._load_hgrc()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerWhenPresentInHgrc(self):
"""Test MercurialClient scan_for_server when present in hgrc"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient scan_for_server when in .reviewboardrc"""
rc = open(os.path.join(self.clone_dir, '.reviewboardrc'), 'w')
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testDiffSimple(self):
"""Test MercurialClient diff, simple case"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO1, 'delete and modify stuff')
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_0, None), diff_result)
def testDiffSimpleMultiple(self):
"""Test MercurialClient diff with multiple commits"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO1, 'commit 1')
self._hg_add_file_commit('foo.txt', FOO2, 'commit 2')
self._hg_add_file_commit('foo.txt', FOO3, 'commit 3')
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_1, None), diff_result)
def testDiffBranchDiverge(self):
"""Test MercurialClient diff with diverged branch"""
self._hg_add_file_commit('foo.txt', FOO1, 'commit 1')
self._hgcmd(['branch', 'diverged'])
self._hg_add_file_commit('foo.txt', FOO2, 'commit 2')
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_2, None), self.client.diff(None))
self._hgcmd(['update', '-C', 'default'])
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_3, None), self.client.diff(None))
def _spin_up_client(self):
os.chdir(self.clone_dir)
self.client = MercurialClient()
class MercurialSubversionClientTests(MercurialTestBase):
TESTSERVER = "http://127.0.0.1:8080"
def __init__(self, *args, **kwargs):
self._tmpbase = ''
self.clone_dir = ''
self.svn_repo = ''
self.svn_checkout = ''
self.client = None
self._svnserve_pid = 0
self._max_svnserve_pid_tries = 12
self._svnserve_port = os.environ.get('SVNSERVE_PORT')
self._required_exes = ('svnadmin', 'svnserve', 'svn')
MercurialTestBase.__init__(self, *args, **kwargs)
def setUp(self):
MercurialTestBase.setUp(self)
self._hg_env = {'FOO': 'BAR'}
for exe in self._required_exes:
if not is_exe_in_path(exe):
raise nose.SkipTest('missing svn stuff! giving up!')
if not self._has_hgsubversion():
raise nose.SkipTest('unable to use `hgsubversion` extension! '
'giving up!')
if not self._tmpbase:
self._tmpbase = _get_tmpdir()
self._create_svn_repo()
self._fire_up_svnserve()
self._fill_in_svn_repo()
try:
self._get_testing_clone()
except (OSError, IOError):
msg = 'could not clone from svn repo! skipping...'
raise nose.SkipTest(msg), None, sys.exc_info()[2]
self._spin_up_client()
self._stub_in_config_and_options()
os.chdir(self.clone_dir)
def _has_hgsubversion(self):
output = self._hgcmd(['svn', '--help'],
ignore_errors=True,
extra_ignore_errors=(255))
return not re.search("unknown command ['\"]svn['\"]", output, re.I)
def tearDown(self):
shutil.rmtree(self.clone_dir)
os.kill(self._svnserve_pid, 9)
if self._tmpbase:
shutil.rmtree(self._tmpbase)
def _svn_add_file_commit(self, filename, data, msg):
outfile = open(filename, 'w')
outfile.write(data)
outfile.close()
execute(['svn', 'add', filename])
execute(['svn', 'commit', '-m', msg])
def _create_svn_repo(self):
self.svn_repo = os.path.join(self._tmpbase, 'svnrepo')
execute(['svnadmin', 'create', self.svn_repo])
def _fire_up_svnserve(self):
if not self._svnserve_port:
self._svnserve_port = str(randint(30000, 40000))
pid_file = os.path.join(self._tmpbase, 'svnserve.pid')
execute([
'svnserve', '--pid-file', pid_file, '-d', '--listen-port',
self._svnserve_port, '-r', self._tmpbase
])
for i in range(0, self._max_svnserve_pid_tries):
try:
self._svnserve_pid = int(open(pid_file).read().strip())
return
except (IOError, OSError):
time.sleep(0.25)
# This will re-raise the last exception, which will be either
# IOError or OSError if the above fails and this branch is reached
raise
def _fill_in_svn_repo(self):
self.svn_checkout = os.path.join(self._tmpbase, 'checkout.svn')
execute([
'svn', 'checkout',
'file://%s' % self.svn_repo, self.svn_checkout
])
os.chdir(self.svn_checkout)
for subtree in ('trunk', 'branches', 'tags'):
execute(['svn', 'mkdir', subtree])
execute(['svn', 'commit', '-m', 'filling in T/b/t'])
os.chdir(os.path.join(self.svn_checkout, 'trunk'))
for i, data in enumerate([FOO, FOO1, FOO2]):
self._svn_add_file_commit('foo.txt', data, 'foo commit %s' % i)
def _get_testing_clone(self):
self.clone_dir = os.path.join(self._tmpbase, 'checkout.hg')
self._hgcmd([
'clone',
'svn://127.0.0.1:%s/svnrepo' % self._svnserve_port,
self.clone_dir,
])
def _spin_up_client(self):
os.chdir(self.clone_dir)
self.client = MercurialClient()
def _stub_in_config_and_options(self):
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient (+svn) get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertEqual('svn', self.client._type)
self.assertEqual('/trunk', ri.base_path)
self.assertEqual('svn://127.0.0.1:%s/svnrepo' % self._svnserve_port,
ri.path)
def testScanForServerSimple(self):
"""Test MercurialClient (+svn) scan_for_server, simple case"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient (+svn) scan_for_server in .reviewboardrc"""
rc_filename = os.path.join(self.clone_dir, '.reviewboardrc')
rc = open(rc_filename, 'w')
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerProperty(self):
"""Test MercurialClient (+svn) scan_for_server in svn property"""
os.chdir(self.svn_checkout)
execute(['svn', 'update'])
execute([
'svn', 'propset', 'reviewboard:url', self.TESTSERVER,
self.svn_checkout
])
execute(['svn', 'commit', '-m', 'adding reviewboard:url property'])
os.chdir(self.clone_dir)
self._hgcmd(['pull'])
self._hgcmd(['update', '-C'])
ri = self.client.get_repository_info()
self.assertEqual(self.TESTSERVER, self.client.scan_for_server(ri))
def testDiffSimple(self):
"""Test MercurialClient (+svn) diff, simple case"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO4, 'edit 4')
self.assertEqual(EXPECTED_HG_SVN_DIFF_0, self.client.diff(None)[0])
def testDiffSimpleMultiple(self):
"""Test MercurialClient (+svn) diff with multiple commits"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO4, 'edit 4')
self._hg_add_file_commit('foo.txt', FOO5, 'edit 5')
self._hg_add_file_commit('foo.txt', FOO6, 'edit 6')
self.assertEqual(EXPECTED_HG_SVN_DIFF_1, self.client.diff(None)[0])
class MercurialClientTests(MercurialTestBase):
TESTSERVER = 'http://127.0.0.1:8080'
CLONE_HGRC = dedent("""
[paths]
default = %(hg_dir)s
cloned = %(clone_dir)s
[reviewboard]
url = %(test_server)s
[diff]
git = true
""").rstrip()
def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path('hg'):
raise nose.SkipTest('hg not found in path')
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(['init'], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, 'foo.txt'), 'w')
foo.write(FOO)
foo.close()
self._hgcmd(['add', 'foo.txt'])
self._hgcmd(['commit', '-m', 'initial commit'])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(['clone', self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, 'wb')
clone_hgrc.write(
self.CLONE_HGRC % {
'hg_dir': self.hg_dir,
'clone_dir': self.clone_dir,
'test_server': self.TESTSERVER,
})
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file('')
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
@property
def clone_hgrc_path(self):
return os.path.join(self.clone_dir, '.hg', 'hgrc')
@property
def hgrc_path(self):
return os.path.join(self.hg_dir, '.hg', 'hgrc')
def tearDown(self):
os.chdir(self.orig_dir)
shutil.rmtree(self.hg_dir)
shutil.rmtree(self.clone_dir)
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertTrue(isinstance(ri, RepositoryInfo))
self.assertEqual('', ri.base_path)
hgpath = ri.path
if os.path.basename(hgpath) == '.hg':
hgpath = os.path.dirname(hgpath)
self.assertEqual(self.hg_dir, hgpath)
self.assertTrue(ri.supports_parent_diffs)
self.assertFalse(ri.supports_changesets)
def testScanForServerSimple(self):
"""Test MercurialClient scan_for_server, simple case"""
os.rename(self.clone_hgrc_path,
os.path.join(self.clone_dir, '._disabled_hgrc'))
self.client.hgrc = {}
self.client._load_hgrc()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerWhenPresentInHgrc(self):
"""Test MercurialClient scan_for_server when present in hgrc"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient scan_for_server when in .reviewboardrc"""
rc = open(os.path.join(self.clone_dir, '.reviewboardrc'), 'w')
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testDiffSimple(self):
"""Test MercurialClient diff, simple case"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO1, 'delete and modify stuff')
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_0, None), diff_result)
def testDiffSimpleMultiple(self):
"""Test MercurialClient diff with multiple commits"""
self.client.get_repository_info()
self._hg_add_file_commit('foo.txt', FOO1, 'commit 1')
self._hg_add_file_commit('foo.txt', FOO2, 'commit 2')
self._hg_add_file_commit('foo.txt', FOO3, 'commit 3')
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_1, None), diff_result)
def testDiffBranchDiverge(self):
"""Test MercurialClient diff with diverged branch"""
self._hg_add_file_commit('foo.txt', FOO1, 'commit 1')
self._hgcmd(['branch', 'diverged'])
self._hg_add_file_commit('foo.txt', FOO2, 'commit 2')
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_2, None), self.client.diff(None))
self._hgcmd(['update', '-C', 'default'])
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_3, None), self.client.diff(None))
class MercurialSubversionClientTests(MercurialTestBase):
TESTSERVER = "http://127.0.0.1:8080"
def __init__(self, *args, **kwargs):
self._tmpbase = ""
self.clone_dir = ""
self.svn_repo = ""
self.svn_checkout = ""
self.client = None
self._svnserve_pid = 0
self._max_svnserve_pid_tries = 12
self._svnserve_port = os.environ.get("SVNSERVE_PORT")
self._required_exes = ("svnadmin", "svnserve", "svn")
MercurialTestBase.__init__(self, *args, **kwargs)
def setUp(self):
MercurialTestBase.setUp(self)
self._hg_env = {"FOO": "BAR"}
for exe in self._required_exes:
if not is_exe_in_path(exe):
raise nose.SkipTest("missing svn stuff! giving up!")
if not self._has_hgsubversion():
raise nose.SkipTest("unable to use `hgsubversion` extension! " "giving up!")
if not self._tmpbase:
self._tmpbase = _get_tmpdir()
self._create_svn_repo()
self._fire_up_svnserve()
self._fill_in_svn_repo()
try:
self._get_testing_clone()
except (OSError, IOError):
msg = "could not clone from svn repo! skipping..."
raise nose.SkipTest(msg), None, sys.exc_info()[2]
self._spin_up_client()
self._stub_in_config_and_options()
os.chdir(self.clone_dir)
def _has_hgsubversion(self):
output = self._hgcmd(["svn", "--help"], ignore_errors=True, extra_ignore_errors=(255))
return not re.search("unknown command ['\"]svn['\"]", output, re.I)
def tearDown(self):
shutil.rmtree(self.clone_dir)
os.kill(self._svnserve_pid, 9)
if self._tmpbase:
shutil.rmtree(self._tmpbase)
def _svn_add_file_commit(self, filename, data, msg):
outfile = open(filename, "w")
outfile.write(data)
outfile.close()
execute(["svn", "add", filename])
execute(["svn", "commit", "-m", msg])
def _create_svn_repo(self):
self.svn_repo = os.path.join(self._tmpbase, "svnrepo")
execute(["svnadmin", "create", self.svn_repo])
def _fire_up_svnserve(self):
if not self._svnserve_port:
self._svnserve_port = str(randint(30000, 40000))
pid_file = os.path.join(self._tmpbase, "svnserve.pid")
execute(["svnserve", "--pid-file", pid_file, "-d", "--listen-port", self._svnserve_port, "-r", self._tmpbase])
for i in range(0, self._max_svnserve_pid_tries):
try:
self._svnserve_pid = int(open(pid_file).read().strip())
return
except (IOError, OSError):
time.sleep(0.25)
# This will re-raise the last exception, which will be either
# IOError or OSError if the above fails and this branch is reached
raise
def _fill_in_svn_repo(self):
self.svn_checkout = os.path.join(self._tmpbase, "checkout.svn")
execute(["svn", "checkout", "file://%s" % self.svn_repo, self.svn_checkout])
os.chdir(self.svn_checkout)
for subtree in ("trunk", "branches", "tags"):
execute(["svn", "mkdir", subtree])
execute(["svn", "commit", "-m", "filling in T/b/t"])
os.chdir(os.path.join(self.svn_checkout, "trunk"))
for i, data in enumerate([FOO, FOO1, FOO2]):
self._svn_add_file_commit("foo.txt", data, "foo commit %s" % i)
def _get_testing_clone(self):
self.clone_dir = os.path.join(self._tmpbase, "checkout.hg")
self._hgcmd(["clone", "svn://127.0.0.1:%s/svnrepo" % self._svnserve_port, self.clone_dir])
def _spin_up_client(self):
os.chdir(self.clone_dir)
self.client = MercurialClient()
def _stub_in_config_and_options(self):
rbtools.postreview.user_config = load_config_file("")
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient (+svn) get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertEqual("svn", self.client._type)
self.assertEqual("/trunk", ri.base_path)
self.assertEqual("svn://127.0.0.1:%s/svnrepo" % self._svnserve_port, ri.path)
def testScanForServerSimple(self):
"""Test MercurialClient (+svn) scan_for_server, simple case"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient (+svn) scan_for_server in .reviewboardrc"""
rc_filename = os.path.join(self.clone_dir, ".reviewboardrc")
rc = open(rc_filename, "w")
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerProperty(self):
"""Test MercurialClient (+svn) scan_for_server in svn property"""
os.chdir(self.svn_checkout)
execute(["svn", "update"])
execute(["svn", "propset", "reviewboard:url", self.TESTSERVER, self.svn_checkout])
execute(["svn", "commit", "-m", "adding reviewboard:url property"])
os.chdir(self.clone_dir)
self._hgcmd(["pull"])
self._hgcmd(["update", "-C"])
ri = self.client.get_repository_info()
self.assertEqual(self.TESTSERVER, self.client.scan_for_server(ri))
def testDiffSimple(self):
"""Test MercurialClient (+svn) diff, simple case"""
self.client.get_repository_info()
self._hg_add_file_commit("foo.txt", FOO4, "edit 4")
self.assertEqual(EXPECTED_HG_SVN_DIFF_0, self.client.diff(None)[0])
def testDiffSimpleMultiple(self):
"""Test MercurialClient (+svn) diff with multiple commits"""
self.client.get_repository_info()
self._hg_add_file_commit("foo.txt", FOO4, "edit 4")
self._hg_add_file_commit("foo.txt", FOO5, "edit 5")
self._hg_add_file_commit("foo.txt", FOO6, "edit 6")
self.assertEqual(EXPECTED_HG_SVN_DIFF_1, self.client.diff(None)[0])
class MercurialClientTests(MercurialTestBase):
TESTSERVER = "http://127.0.0.1:8080"
CLONE_HGRC = dedent(
"""
[paths]
default = %(hg_dir)s
cloned = %(clone_dir)s
[reviewboard]
url = %(test_server)s
[diff]
git = true
"""
).rstrip()
def setUp(self):
MercurialTestBase.setUp(self)
if not is_exe_in_path("hg"):
raise nose.SkipTest("hg not found in path")
self.orig_dir = os.getcwd()
self.hg_dir = _get_tmpdir()
os.chdir(self.hg_dir)
self._hgcmd(["init"], hg_dir=self.hg_dir)
foo = open(os.path.join(self.hg_dir, "foo.txt"), "w")
foo.write(FOO)
foo.close()
self._hgcmd(["add", "foo.txt"])
self._hgcmd(["commit", "-m", "initial commit"])
self.clone_dir = _get_tmpdir()
os.rmdir(self.clone_dir)
self._hgcmd(["clone", self.hg_dir, self.clone_dir])
os.chdir(self.clone_dir)
self.client = MercurialClient()
clone_hgrc = open(self.clone_hgrc_path, "wb")
clone_hgrc.write(
self.CLONE_HGRC % {"hg_dir": self.hg_dir, "clone_dir": self.clone_dir, "test_server": self.TESTSERVER}
)
clone_hgrc.close()
self.client.get_repository_info()
rbtools.postreview.user_config = load_config_file("")
rbtools.postreview.options = OptionsStub()
rbtools.postreview.options.parent_branch = None
os.chdir(self.clone_dir)
@property
def clone_hgrc_path(self):
return os.path.join(self.clone_dir, ".hg", "hgrc")
@property
def hgrc_path(self):
return os.path.join(self.hg_dir, ".hg", "hgrc")
def tearDown(self):
os.chdir(self.orig_dir)
shutil.rmtree(self.hg_dir)
shutil.rmtree(self.clone_dir)
def testGetRepositoryInfoSimple(self):
"""Test MercurialClient get_repository_info, simple case"""
ri = self.client.get_repository_info()
self.assertTrue(isinstance(ri, RepositoryInfo))
self.assertEqual("", ri.base_path)
hgpath = ri.path
if os.path.basename(hgpath) == ".hg":
hgpath = os.path.dirname(hgpath)
self.assertEqual(self.hg_dir, hgpath)
self.assertTrue(ri.supports_parent_diffs)
self.assertFalse(ri.supports_changesets)
def testScanForServerSimple(self):
"""Test MercurialClient scan_for_server, simple case"""
os.rename(self.clone_hgrc_path, os.path.join(self.clone_dir, "._disabled_hgrc"))
self.client.hgrc = {}
self.client._load_hgrc()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertTrue(server is None)
def testScanForServerWhenPresentInHgrc(self):
"""Test MercurialClient scan_for_server when present in hgrc"""
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testScanForServerReviewboardrc(self):
"""Test MercurialClient scan_for_server when in .reviewboardrc"""
rc = open(os.path.join(self.clone_dir, ".reviewboardrc"), "w")
rc.write('REVIEWBOARD_URL = "%s"' % self.TESTSERVER)
rc.close()
ri = self.client.get_repository_info()
server = self.client.scan_for_server(ri)
self.assertEqual(self.TESTSERVER, server)
def testDiffSimple(self):
"""Test MercurialClient diff, simple case"""
ri = self.client.get_repository_info()
self._hg_add_file_commit("foo.txt", FOO1, "delete and modify stuff")
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_0, None), diff_result)
def testDiffSimpleMultiple(self):
"""Test MercurialClient diff with multiple commits"""
ri = self.client.get_repository_info()
self._hg_add_file_commit("foo.txt", FOO1, "commit 1")
self._hg_add_file_commit("foo.txt", FOO2, "commit 2")
self._hg_add_file_commit("foo.txt", FOO3, "commit 3")
diff_result = self.client.diff(None)
self.assertEqual((EXPECTED_HG_DIFF_1, None), diff_result)
def testDiffBranchDiverge(self):
"""Test MercurialClient diff with diverged branch"""
self._hg_add_file_commit("foo.txt", FOO1, "commit 1")
self._hgcmd(["branch", "diverged"])
self._hg_add_file_commit("foo.txt", FOO2, "commit 2")
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_2, None), self.client.diff(None))
self._hgcmd(["update", "-C", "default"])
self.client.get_repository_info()
self.assertEqual((EXPECTED_HG_DIFF_3, None), self.client.diff(None))
