def test_user_space_with_local_sources(self):
output = TestBufferConanOutput()
# Need a real repo to get a working SCM object
local_sources_path = os.path.join(self.tmp_dir,
'git_repo').replace('\\', '/')
create_local_git_repo(files={'file1': "content"},
folder=local_sources_path)
git = Git(local_sources_path)
url = "https://remote.url"
git.run("remote add origin \"{}\"".format(url))
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
# Mock functions called from inside _run_scm (tests will be here)
def merge_directories(src, dst, excluded=None):
src = os.path.normpath(src)
dst = os.path.normpath(dst)
self.assertEqual(src.replace('\\', '/'), local_sources_path)
self.assertEqual(dst, self.src_folder)
with mock.patch("conans.client.source.merge_directories",
side_effect=merge_directories):
_run_local_scm(conanfile,
conanfile_folder=local_sources_path,
src_folder=self.src_folder,
output=output)
self.assertIn(
"getting sources from folder: {}".format(
local_sources_path).lower(),
str(output).lower())
def test_in_tag(self):
"""
Current checkout is on a tag
"""
git = Git(folder=self.folder)
git.run("tag 0.0.0")
tag = git.get_tag()
self.assertEqual("0.0.0", tag)
def test_remove_credentials(self):
""" Check that the 'remove_credentials' argument is taken into account """
expected_url = 'https://myrepo.com/path/to/repo.git'
origin_url = 'https://*****:*****@myrepo.com/path/to/repo.git'
git = Git(folder=temp_folder())
git.run("init .")
git.run("remote add origin {}".format(origin_url))
self.assertEqual(git.get_remote_url(), origin_url)
self.assertEqual(git.get_remote_url(remove_credentials=True), expected_url)
def test_is_pristine(self):
root_path, _ = create_local_git_repo({"myfile": "anything"})
git = Git(root_path)
self.assertTrue(git.is_pristine())
save(os.path.join(root_path, "other_file"), "content")
self.assertFalse(git.is_pristine())
git.run("add .")
self.assertFalse(git.is_pristine())
git.run('commit -m "commit"')
self.assertTrue(git.is_pristine())
def test_clone_git_shallow_with_local(self):
path, revision = create_local_git_repo({"repofile": "contents"}, commits=3)
tmp = temp_folder()
save(os.path.join(tmp, "localfile"), "contents")
save(os.path.join(tmp, "indexfile"), "contents")
git = Git(tmp)
git.run("init")
git.run("add indexfile")
git.clone("file://" + path, branch="master", shallow=True) # --depth is ignored in local clones
self.assertTrue(os.path.exists(os.path.join(tmp, "repofile")))
self.assertTrue(os.path.exists(os.path.join(tmp, "localfile")))
self.assertTrue(os.path.exists(os.path.join(tmp, "indexfile")))
self.assertEqual(git.get_revision(), revision)
self.assertEqual(git.run("rev-list --all --count"), "1")
def test_clone_git_shallow_revision(self):
path, revision = create_local_git_repo({"myfile": "contents"},
commits=3,
tags=["1.0"],
branch="develop")
tmp = temp_folder()
git = Git(tmp)
if Git.get_version() < "2.13":
# older Git versions have known bugs with "git fetch origin <sha>":
# https://github.com/git/git/blob/master/Documentation/RelNotes/2.13.0.txt
# * "git fetch" that requests a commit by object name, when the other
# side does not allow such an request, failed without much
# explanation.
# https://github.com/git/git/blob/master/Documentation/RelNotes/2.14.0.txt
# * There is no good reason why "git fetch $there $sha1" should fail
# when the $sha1 names an object at the tip of an advertised ref,
# even when the other side hasn't enabled allowTipSHA1InWant.
with self.assertRaises(subprocess.CalledProcessError):
git.clone("file://" + path, branch=revision, shallow=True)
else:
git.clone("file://" + path, branch=revision, shallow=True)
with self.assertRaises(subprocess.CalledProcessError):
git.checkout(element="HEAD~1")
self.assertTrue(os.path.exists(os.path.join(tmp, "myfile")))
self.assertEqual(git.get_revision(), revision)
self.assertEqual(git.run("rev-list --all --count"), "1")
def ensure_cache_preserved():
cache_directory = os.environ["CONAN_USER_HOME"]
git = Git(folder=cache_directory)
with open(os.path.join(cache_directory, '.gitignore'), 'w') as gitignore:
gitignore.write(".conan/data/")
git.run("init .")
git.run("add .")
try:
yield
finally:
r = git.run("diff")
if r:
writeln_console(">>> " + colorama.Fore.RED + "This is example modifies the cache!")
writeln_console(r)
raise Exception("Example modifies cache!")
def test_clone_git_shallow(self, element):
path, revision = create_local_git_repo({"myfile": "contents"}, commits=3, tags=["1.0"], branch="develop")
tmp = temp_folder()
git = Git(tmp)
git.clone("file://" + path, branch=element, shallow=True) # --depth is ignored in local clones
with self.assertRaises(subprocess.CalledProcessError):
git.checkout(element="HEAD~1")
self.assertTrue(os.path.exists(os.path.join(tmp, "myfile")))
self.assertEqual(git.get_revision(), revision)
self.assertEqual(git.run("rev-list --all --count"), "1")
def test_in_branch_with_tag(self):
"""
Tag is defined but current commit is ahead of it
"""
git = Git(folder=self.folder)
git.run("tag 0.0.0")
save(os.path.join(self.folder, "file.txt"), "")
git.run("add .")
git.run("commit -m \"new file\"")
tag = git.get_tag()
self.assertIsNone(tag)
def create_local_git_repo(files=None, branch=None, submodules=None, folder=None, commits=1,
tags=None):
tmp = folder or temp_folder()
tmp = get_cased_path(tmp)
if files:
save_files(tmp, files)
git = Git(tmp)
git.run("init .")
git.run('config user.email "*****@*****.**"')
git.run('config user.name "Your Name"')
if branch:
git.run("checkout -b %s" % branch)
git.run("add .")
for i in range(0, commits):
git.run('commit --allow-empty -m "commiting"')
tags = tags or []
for tag in tags:
git.run("tag %s" % tag)
if submodules:
for submodule in submodules:
git.run('submodule add "%s"' % submodule)
git.run('commit -m "add submodules"')
return tmp.replace("\\", "/"), git.get_revision()
def create_local_git_repo(files, branch=None, submodules=None):
tmp = temp_folder()
save_files(tmp, files)
git = Git(tmp)
git.run("init .")
if branch:
git.run("checkout -b %s" % branch)
git.run("add .")
git.run('config user.email "*****@*****.**"')
git.run('config user.name "Your Name"')
git.run('commit -m "message"')
if submodules:
for submodule in submodules:
git.run('submodule add "%s"' % submodule)
git.run('commit -m "add submodules"')
return tmp.replace("\\", "/"), git.get_revision()
class CaptureExportSCMDataTest(unittest.TestCase):
def setUp(self):
ref = ConanFileReference.loads("name/version@user/channel")
tmp_dir = temp_folder()
# Need a real repo to get a working SCM object
self.conanfile_dir = os.path.join(tmp_dir, 'git_repo').replace('\\', '/')
self.git = Git(folder=self.conanfile_dir)
self.origin, self.rev = create_local_git_repo(files={'file1': "content"},
folder=self.git.folder)
# Mock the cache item (return the cache_ref_folder)
self.cache_ref_folder = os.path.join(temp_folder(), ref.dir_repr())
@parameterized.expand([(True, ), (False, )])
def test_url_auto_revision_auto(self, _, local_origin):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
# Set the remote for the repo
url = self.git.folder if local_origin else "https://remote.url"
self.git.run("remote add origin \"{}\"".format(url))
scm_data, _ = _capture_scm_auto_fields(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
package_layout=None,
output=output,
ignore_dirty=True,
scm_to_conandata=False)
self.assertEqual(scm_data.url, url)
self.assertEqual(scm_data.revision, self.rev)
self.assertIn("Repo origin deduced by 'auto': {}".format(url), output)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev), output)
if local_origin:
self.assertIn("WARN: Repo origin looks like a local path: {}".format(url), output)
@parameterized.expand([(True, ), (False, ), ])
def test_revision_auto(self, _, is_pristine):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
url = "https://remote.url"
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': url, 'revision': 'auto'}
if not is_pristine:
save(os.path.join(self.git.folder, "other"), "ccc")
scm_data, _ = _capture_scm_auto_fields(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
package_layout=None,
output=output,
ignore_dirty=False,
scm_to_conandata=False)
self.assertEqual(scm_data.url, url)
if is_pristine:
self.assertEqual(scm_data.revision, self.rev)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev), output)
self.assertNotIn("Repo origin deduced", output)
else:
self.assertEqual(scm_data.revision, "auto")
self.assertIn("There are uncommitted changes, skipping the replacement of 'scm.url' "
"and 'scm.revision' auto fields. Use --ignore-dirty to force it.",
output)
def test_url_auto(self, _):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': "auto", 'revision': self.rev}
# Set the remote for the repo
url = "https://remote.url"
self.git.run("remote add origin \"{}\"".format(url))
scm_data, _ = _capture_scm_auto_fields(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
package_layout=None,
output=output,
ignore_dirty=True,
scm_to_conandata=False)
self.assertEqual(scm_data.url, url)
self.assertEqual(scm_data.revision, self.rev)
self.assertIn("Repo origin deduced by 'auto': {}".format(url), output)
self.assertNotIn("Revision deduced", output)
class CaptureExportSCMDataTest(unittest.TestCase):
def setUp(self):
ref = ConanFileReference.loads("name/version@user/channel")
tmp_dir = temp_folder()
# Need a real repo to get a working SCM object
self.conanfile_dir = os.path.join(tmp_dir,
'git_repo').replace('\\', '/')
self.git = Git(folder=self.conanfile_dir)
self.origin, self.rev = create_local_git_repo(
files={'file1': "content"}, folder=self.git.folder)
# Mock the cache item (return the cache_ref_folder)
self.cache_ref_folder = os.path.join(temp_folder(), ref.dir_repr())
self.paths = mock.MagicMock(side_effect=None)
self.paths.scm_folder.side_effect = lambda _: os.path.join(
self.cache_ref_folder, SCM_FOLDER)
@parameterized.expand([(True, ), (False, )])
def test_url_auto_revision_auto(self, _, local_origin):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
# Set the remote for the repo
url = self.git.folder if local_origin else "https://remote.url"
self.git.run("remote add origin \"{}\"".format(url))
scm_data, captured_revision = _capture_export_scm_data(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
destination_folder="",
output=output,
paths=self.paths,
ref=None)
self.assertTrue(captured_revision)
self.assertEquals(scm_data.url, url)
self.assertEquals(scm_data.revision, self.rev)
self.assertIn("Repo origin deduced by 'auto': {}".format(url), output)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev),
output)
if local_origin:
self.assertIn(
"WARN: Repo origin looks like a local path: {}".format(url),
output)
scm_folder_file = os.path.join(self.cache_ref_folder, SCM_FOLDER)
self.assertEqual(os.path.normcase(load(scm_folder_file)),
os.path.normcase(self.conanfile_dir))
@parameterized.expand([
(True, ),
(False, ),
])
def test_revision_auto(self, _, is_pristine):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
url = "https://remote.url"
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': url, 'revision': 'auto'}
if not is_pristine:
save(os.path.join(self.git.folder, "other"), "ccc")
scm_data, captured_revision = _capture_export_scm_data(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
destination_folder="",
output=output,
paths=self.paths,
ref=None)
self.assertTrue(captured_revision)
self.assertEquals(scm_data.url, url)
self.assertEquals(scm_data.revision, self.rev)
self.assertNotIn("Repo origin deduced", output)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev),
output)
if not is_pristine:
self.assertIn(
"Repo status is not pristine: there might be modified files",
output)
scm_folder_file = os.path.join(self.cache_ref_folder, SCM_FOLDER)
self.assertTrue(os.path.exists(scm_folder_file))
self.assertEqual(os.path.normcase(load(scm_folder_file)),
os.path.normcase(self.conanfile_dir))
def test_url_auto(self, _):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': "auto", 'revision': self.rev}
# Set the remote for the repo
url = "https://remote.url"
self.git.run("remote add origin \"{}\"".format(url))
scm_data, captured_revision = _capture_export_scm_data(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
destination_folder="",
output=output,
paths=self.paths,
ref=None)
self.assertFalse(captured_revision)
self.assertEquals(scm_data.url, url)
self.assertEquals(scm_data.revision, self.rev)
self.assertIn("Repo origin deduced by 'auto': {}".format(url), output)
self.assertNotIn("Revision deduced", output)
scm_folder_file = os.path.join(self.cache_ref_folder, SCM_FOLDER)
self.assertTrue(os.path.exists(scm_folder_file))
self.assertEqual(os.path.normcase(load(scm_folder_file)),
os.path.normcase(self.conanfile_dir))