def test_auto_svn(self):
conanfile = base_svn.format(directory="None", url=_quoted("auto"), revision="auto")
project_url, _ = self.create_project(files={"conanfile.py": conanfile,
"myfile.txt": "My file is copied"})
project_url = project_url.replace(" ", "%20")
self.client.run_command('svn co "{url}" "{path}"'.format(url=project_url,
path=self.client.current_folder))
curdir = self.client.current_folder.replace("\\", "/")
# Create the package, will copy the sources from the local folder
self.client.run("create . user/channel")
self.assertIn("Repo origin deduced by 'auto': {}".format(project_url).lower(),
str(self.client.out).lower())
self.assertIn("Revision deduced by 'auto'", self.client.out)
self.assertIn("SCM: Getting sources from folder: %s" % curdir, self.client.out)
self.assertIn("My file is copied", self.client.out)
# Export again but now with absolute reference, so no pointer file is created nor kept
svn = SVN(curdir)
self.client.save({"conanfile.py": base_svn.format(url=_quoted(svn.get_remote_url()),
revision=svn.get_revision())})
self.client.run("create . user/channel")
self.assertNotIn("Repo origin deduced by 'auto'", self.client.out)
self.assertNotIn("Revision deduced by 'auto'", self.client.out)
self.assertIn("SCM: Getting sources from url: '{}'".format(project_url).lower(),
str(self.client.out).lower())
self.assertIn("My file is copied", self.client.out)
def work_on_project(tmp_folder):
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
self.assertTrue(svn.is_pristine())
with open(os.path.join(tmp_folder, "myfile"), "a") as f:
f.write("random content: {}".format(uuid.uuid4()))
return svn
def test_checkout_project(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
self.assertTrue(svn.is_pristine())
def test_modified_file(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
with open(os.path.join(tmp_folder, "myfile"), "a") as f:
f.write("new content")
self.assertFalse(svn.is_pristine())
def run(self, *args, **kwargs):
try:
setattr(SVN, '_version', Version("1.5"))
self.assertTrue(SVN().version < SVN.API_CHANGE_VERSION)
super(SVNToolTestsBasicOldVersion, self).run(*args, **kwargs)
finally:
delattr(SVN, '_version')
assert SVN().version == SVN.get_version(), \
"{} != {}".format(SVN().version, SVN.get_version())
def test_repo_url(self):
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=self.repo_url)
remote_url = svn.get_remote_url()
self.assertEqual(remote_url.lower(), self.repo_url.lower())
svn2 = SVN(folder=self.gimme_tmp(create=False))
svn2.checkout(url=remote_url) # clone using quoted url
self.assertEqual(svn2.get_remote_url().lower(), self.repo_url.lower())
def setUp(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
project2_url, rev = self.create_project(files={'nestedfile': "contents"})
self.svn = SVN(folder=self.gimme_tmp())
self.svn.checkout(url=project_url)
self.svn.run(self._propset_cmd("subrepo_nestedfile", rev, project2_url + '/nestedfile'))
self.svn.run('commit -m "add external"')
self.svn.update()
self.assertTrue(self.svn.is_pristine())
def test_ignored_file(self):
tmp_folder = self.gimme_tmp()
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=self.repo_url)
file_to_ignore = "secret.txt"
with open(os.path.join(tmp_folder, file_to_ignore), "w") as f:
f.write("content")
svn.run("propset svn:ignore {} .".format(file_to_ignore))
self.assertFalse(svn.is_pristine()) # Folder properties have been modified
svn.run('commit -m "add ignored file"')
self.assertTrue(svn.is_pristine())
def test_remove_credentials(self):
""" Check that the 'remove_credentials' argument is taken into account """
expected_url = 'https://myrepo.com/path/to/repo'
origin_url = 'https://*****:*****@myrepo.com/path/to/repo'
svn = SVN(folder=temp_folder())
# Mocking, as we cannot change SVN remote to a non-existing url
with patch.object(svn, '_show_item', return_value=origin_url):
self.assertEqual(svn.get_remote_url(), origin_url)
self.assertEqual(svn.get_remote_url(remove_credentials=True), expected_url)
def test_local_source(self):
curdir = self.client.current_folder.replace("\\", "/")
conanfile = base_svn.format(url=_quoted("auto"), revision="auto")
conanfile += """
def source(self):
self.output.warn("SOURCE METHOD CALLED")
"""
project_url, _ = self.create_project(files={
"conanfile.py": conanfile,
"myfile.txt": "My file is copied"
})
project_url = project_url.replace(" ", "%20")
self.client.run_command('svn co "{url}" "{path}"'.format(
url=project_url, path=self.client.current_folder))
self.client.save({"aditional_file.txt": "contents"})
self.client.run("source . --source-folder=./source")
self.assertTrue(
os.path.exists(os.path.join(curdir, "source", "myfile.txt")))
self.assertIn("SOURCE METHOD CALLED", self.client.out)
# Even the not commited files are copied
self.assertTrue(
os.path.exists(os.path.join(curdir, "source",
"aditional_file.txt")))
self.assertIn("SCM: Getting sources from folder: %s" % curdir,
self.client.out)
# Export again but now with absolute reference, so no pointer file is created nor kept
svn = SVN(curdir)
conanfile = base_svn.format(url=_quoted(svn.get_remote_url()),
revision=svn.get_revision())
conanfile += """
def source(self):
self.output.warn("SOURCE METHOD CALLED")
"""
self.client.save({
"conanfile.py": conanfile,
"myfile2.txt": "My file is copied"
})
self.client.run_command("svn add myfile2.txt")
self.client.run_command('svn commit -m "commiting"')
self.client.run("source . --source-folder=./source2")
# myfile2 is no in the specified commit
self.assertFalse(
os.path.exists(os.path.join(curdir, "source2", "myfile2.txt")))
self.assertTrue(
os.path.exists(os.path.join(curdir, "source2", "myfile.txt")))
self.assertIn(
"SCM: Getting sources from url: '{}'".format(project_url).lower(),
str(self.client.out).lower())
self.assertIn("SOURCE METHOD CALLED", self.client.out)
def test_verify_ssl(self):
class MyRunner(object):
def __init__(self, svn):
self.calls = []
self._runner = svn._runner
svn._runner = self
def __call__(self, command, *args, **kwargs):
self.calls.append(command)
return self._runner(command, *args, **kwargs)
project_url, _ = self.create_project(files={'myfile': "contents",
'subdir/otherfile': "content"})
svn = SVN(folder=self.gimme_tmp(), username="******", password="******", verify_ssl=True)
runner = MyRunner(svn)
svn.checkout(url=project_url)
self.assertNotIn("--trust-server-cert-failures=unknown-ca", runner.calls[1])
svn = SVN(folder=self.gimme_tmp(), username="******", password="******", verify_ssl=False)
runner = MyRunner(svn)
svn.checkout(url=project_url)
if svn.version >= SVN.API_CHANGE_VERSION:
self.assertIn("--trust-server-cert-failures=unknown-ca", runner.calls[1])
else:
self.assertIn("--trust-server-cert", runner.calls[1])
def test_revision_number(self):
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=self.repo_url)
rev = int(svn.get_revision())
self.create_project(files={'another_file': "content"})
svn.run("update")
rev2 = int(svn.get_revision())
self.assertEqual(rev2, rev + 1)
def test_version(self, mocked_open):
svn_version_string = """svn, version 1.10.3 (r1842928)
compiled Apr 5 2019, 18:59:58 on x86_64-apple-darwin17.0.0"""
mocked_open.return_value.communicate.return_value = (
svn_version_string.encode(), None)
version = SVN.get_version()
self.assertEqual(version, "1.10.3")
def create_local_svn_checkout(files, repo_url, rel_project_path=None,
commit_msg='default commit message', delete_checkout=True,
folder=None):
tmp_dir = folder or temp_folder()
try:
rel_project_path = rel_project_path or str(uuid.uuid4())
# Do not use SVN class as it is what we will be testing
subprocess.check_output('svn co "{url}" "{path}"'.format(url=repo_url,
path=tmp_dir),
shell=True)
tmp_project_dir = os.path.join(tmp_dir, rel_project_path)
mkdir(tmp_project_dir)
save_files(tmp_project_dir, files)
with chdir(tmp_project_dir):
subprocess.check_output("svn add .", shell=True)
subprocess.check_output('svn commit -m "{}"'.format(commit_msg), shell=True)
if SVN.get_version() >= SVN.API_CHANGE_VERSION:
rev = check_output_runner("svn info --show-item revision").strip()
else:
import xml.etree.ElementTree as ET
output = check_output_runner("svn info --xml").strip()
root = ET.fromstring(output)
rev = root.findall("./entry")[0].get("revision")
project_url = repo_url + "/" + quote(rel_project_path.replace("\\", "/"))
return project_url, rev
finally:
if delete_checkout:
shutil.rmtree(tmp_dir, ignore_errors=False, onerror=try_remove_readonly)
def test_checkout(self):
# Ensure we have several revisions in the repository
self.create_project(files={'file': "content"})
self.create_project(files={'file': "content"})
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=self.repo_url)
rev = int(svn.get_revision())
svn.update(revision=rev - 1) # Checkout previous revision
self.assertTrue(int(svn.get_revision()), rev - 1)
def test_check_svn_repo(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
with six.assertRaisesRegex(self, ConanException, "Not a valid 'svn' repository"):
svn.check_repo()
svn.checkout(url=project_url)
try:
svn.check_repo()
except Exception:
self.fail("After checking out, it should be a valid SVN repository")
def test_mixed_revisions(self):
project_url, _ = self.create_project(files={'myfile': "cc", 'another': 'aa'})
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=project_url)
with open(os.path.join(svn.folder, 'myfile'), "a") as f:
f.write('more')
svn.run('commit -m "up version"')
self.assertFalse(svn.is_pristine())
class SVNToolTestsPristineWithExternalFile(SVNLocalRepoTestCase):
def _propset_cmd(self, relpath, rev, url):
return 'propset svn:externals "{} -r{} {}" .'.format(relpath, rev, url)
def setUp(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
project2_url, rev = self.create_project(files={'nestedfile': "contents"})
self.svn = SVN(folder=self.gimme_tmp())
self.svn.checkout(url=project_url)
self.svn.run(self._propset_cmd("subrepo_nestedfile", rev, project2_url + '/nestedfile'))
self.svn.run('commit -m "add external"')
self.svn.update()
self.assertTrue(self.svn.is_pristine())
def test_modified_external(self):
with open(os.path.join(self.svn.folder, "subrepo_nestedfile"), "a") as f:
f.write("cosass")
self.assertFalse(self.svn.is_pristine())
def test_repo_root(self):
project_url, _ = self.create_project(files={'myfile': "contents",
'subdir/otherfile': "content"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
path = os.path.realpath(tmp_folder).replace('\\', '/').lower()
self.assertEqual(path, svn.get_repo_root().lower())
# SVN instantiated in a subfolder
svn2 = SVN(folder=os.path.join(tmp_folder, 'subdir'))
self.assertFalse(svn2.folder == tmp_folder)
path = os.path.realpath(tmp_folder).replace('\\', '/').lower()
self.assertEqual(path, svn2.get_repo_root().lower())
def test_untracked_file(self):
self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=self.repo_url)
self.assertTrue(svn.is_pristine())
with open(os.path.join(tmp_folder, "not_tracked.txt"), "w") as f:
f.write("content")
self.assertFalse(svn.is_pristine())
def test_excluded_files(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
# Add untracked file
new_file = os.path.join(tmp_folder, str(uuid.uuid4()))
with open(new_file, "w") as f:
f.write("content")
# Add ignore file
file_to_ignore = str(uuid.uuid4())
with open(os.path.join(tmp_folder, file_to_ignore), "w") as f:
f.write("content")
svn.run("propset svn:ignore {} .".format(file_to_ignore))
svn.run('commit -m "add ignored file"')
excluded_files = svn.excluded_files()
self.assertIn(file_to_ignore, excluded_files)
self.assertNotIn('.svn', excluded_files)
self.assertEqual(len(excluded_files), 1)
def test_missing_remote(self):
repo_url = self.gimme_tmp()
subprocess.check_output('svnadmin create "{}"'.format(repo_url), shell=True)
project_url = SVN.file_protocol + quote(repo_url.replace("\\", "/"), safe='/:')
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=project_url)
self.assertTrue(svn.is_pristine())
shutil.rmtree(repo_url, ignore_errors=False, onerror=try_remove_readonly)
self.assertFalse(os.path.exists(repo_url))
self.assertFalse(svn.is_pristine())
def test_clone_over_dirty_directory(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
new_file = os.path.join(tmp_folder, "new_file")
with open(new_file, "w") as f:
f.write("content")
mod_file = os.path.join(tmp_folder, "myfile")
with open(mod_file, "a") as f:
f.write("new content")
self.assertFalse(svn.is_pristine())
# SVN::clone over a dirty repo reverts all changes
# (but it doesn't delete non versioned files)
svn.checkout(url=project_url)
self.assertEqual(open(mod_file).read(), "contents")
self.assertFalse(svn.is_pristine())
def setUp(self):
unittest.skipUnless(SVN.get_version() >= SVN.API_CHANGE_VERSION,
"SVN::is_pristine not implemented")
def svn_revision_message_test(self):
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=self.repo_url)
self.assertIsNone(svn.get_revision_message())
new_file = os.path.join(tmp_folder, "new_file")
with open(new_file, "w") as f:
f.write("content")
svn.run('add new_file')
svn.run('commit -m "add to file"')
svn.run('update')
self.assertEqual("add to file", svn.get_revision_message())
def test_clone(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
tmp_folder = self.gimme_tmp()
svn = SVN(folder=tmp_folder)
svn.checkout(url=project_url)
self.assertTrue(os.path.exists(os.path.join(tmp_folder, 'myfile')))
class SVNToolTestsPristineWithExternalsFixed(SVNLocalRepoTestCase):
def _propset_cmd(self, relpath, rev, url):
return 'propset svn:externals "{} -r{} {}" .'.format(relpath, rev, url)
def setUp(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
project2_url, rev = self.create_project(
files={'nestedfile': "contents"})
self.svn = SVN(folder=self.gimme_tmp())
self.svn.checkout(url=project_url)
self.svn.run(self._propset_cmd("subrepo", rev, project2_url))
self.svn.run('commit -m "add external"')
self.svn.update()
self.assertTrue(self.svn.is_pristine())
self.svn_subrepo = SVN(folder=os.path.join(self.svn.folder, 'subrepo'))
self.assertTrue(self.svn_subrepo.is_pristine())
def test_modified_external(self):
with open(os.path.join(self.svn.folder, "subrepo", "nestedfile"),
"a") as f:
f.write("cosass")
self.assertFalse(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
def test_commit_external(self):
with open(os.path.join(self.svn.folder, "subrepo", "nestedfile"),
"a") as f:
f.write("cosass")
self.svn_subrepo.run('commit -m "up external"')
self.assertFalse(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
self.svn_subrepo.update()
self.assertTrue(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
def test_untracked_external(self):
with open(os.path.join(self.svn.folder, "subrepo", "other_file"),
"w") as f:
f.write("cosass")
self.assertFalse(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
def test_ignored_external(self):
file_to_ignore = "secret.txt"
with open(os.path.join(self.svn_subrepo.folder, file_to_ignore),
"w") as f:
f.write("cosas")
self.svn_subrepo.run("propset svn:ignore {} .".format(file_to_ignore))
self.assertFalse(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
self.svn_subrepo.run('commit -m "add ignored file"')
self.assertTrue(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
subrepo_rev = self.svn_subrepo.get_revision()
self.svn.run(
self._propset_cmd("subrepo", subrepo_rev,
self.svn_subrepo.get_remote_url()))
self.assertTrue(self.svn_subrepo.is_pristine())
self.assertFalse(self.svn.is_pristine())
self.svn.run('commit -m "change property"')
self.svn.update()
self.assertTrue(self.svn.is_pristine())
def test_version_invalid(self, mocked_open):
mocked_open.return_value.communicate.return_value = ('failed'.encode(),
None)
with self.assertRaises(ConanException):
SVN.get_version()
class SVNToolTestsPristineWithExternalsNotFixed(SVNLocalRepoTestCase):
def _propset_cmd(self, relpath, url):
return 'propset svn:externals "{} {}" .'.format(relpath, url)
def setUp(self):
project_url, _ = self.create_project(files={'myfile': "contents"})
project2_url, _ = self.create_project(files={'nestedfile': "contents"})
self.svn = SVN(folder=self.gimme_tmp())
self.svn.checkout(url=project_url)
self.svn.run(self._propset_cmd("subrepo", project2_url))
self.svn.run('commit -m "add external"')
self.svn.update()
self.assertTrue(self.svn.is_pristine())
self.svn2 = SVN(folder=self.gimme_tmp())
self.svn2.checkout(url=project2_url)
self.assertTrue(self.svn.is_pristine())
def test_modified_external(self):
with open(os.path.join(self.svn2.folder, "nestedfile"), "a") as f:
f.write("cosass")
self.svn2.run('commit -m "another"')
self.svn2.update()
self.assertTrue(self.svn2.is_pristine())
# Known: without fixed external, it won't be pristine if there is something new in remote.
self.assertFalse(self.svn.is_pristine())
def test_checkout(self):
svn = SVN(folder=self.gimme_tmp())
svn.checkout(url=self.repo_url)
self.assertTrue(svn.is_pristine())
