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_ignore_dirty_subfolder(self): # https://github.com/conan-io/conan/issues/6070 conanfile = textwrap.dedent(""" import os from conans import ConanFile, tools class ConanLib(ConanFile): name = "lib" version = "0.1" short_paths = True scm = { "type": "git", "url": "auto", "revision": "auto", } def build(self): path = os.path.join("base_file.txt") assert os.path.exists(path) """) self.client.save({ "test/main/conanfile.py": conanfile, "base_file.txt": "foo" }) create_local_git_repo(folder=self.client.current_folder) self.client.run_command('git remote add origin https://myrepo.com.git') # Introduce changes self.client.save({"dirty_file.txt": "foo"}) # The build() method will verify that the files from the repository are copied ok self.client.run("create test/main/conanfile.py user/channel") self.assertIn("Package '{}' created".format(NO_SETTINGS_PACKAGE_ID), self.client.out)
def test_double_create(self): # https://github.com/conan-io/conan/issues/5195#issuecomment-551848955 self.client = TestClient(default_server_user=True) conanfile = str(GenConanfile().with_scm({ "type": "git", "revision": "auto", "url": "auto" }).with_import("import os").with_import( "from conans import tools").with_name("lib").with_version("1.0")) conanfile += """ def build(self): contents = tools.load("bla.sh") self.output.warn("Bla? {}".format(contents)) """ self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=self.client.current_folder) self.client.run_command('git remote add origin https://myrepo.com.git') # modified blah.sh self.client.save({"bla.sh": "bla bla"}) self.client.run("create . user/channel") self.assertIn("Bla? bla bla", self.client.out) # modified blah.sh again self.client.save({"bla.sh": "bla2 bla2"}) # Run conan create again self.client.run("create . user/channel") self.assertIn("Bla? bla2 bla2", self.client.out)
def reuse_scm_test(self): client = TestClient() conanfile = textwrap.dedent(""" from conans import ConanFile class SomeBase(object): scm = {"type" : "git", "url" : "somerepo", "revision" : "auto"} class MyConanfileBase(SomeBase, ConanFile): pass """) create_local_git_repo({"conanfile.py": conanfile}, branch="my_release", folder=client.current_folder) client.run("export . base/1.1@user/testing") reuse = textwrap.dedent(""" from conans import ConanFile class PkgTest(ConanFile): python_requires = "base/1.1@user/testing" python_requires_extend = "base.SomeBase" """) client.save({"conanfile.py": reuse}) client.run("export . Pkg/0.1@user/testing") client.run("get Pkg/0.1@user/testing") self.assertNotIn("scm = base.scm", client.out) self.assertIn('scm = {"revision":', client.out) self.assertIn('"type": "git",', client.out) self.assertIn('"url": "somerepo"', client.out)
def test_upload_blocking_auto(self): client = TestClient(default_server_user=True) conanfile = base_git.format(revision="auto", url='"auto"') client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=client.current_folder) client.run_command('git remote add origin https://myrepo.com.git') # Dirty file client.save({"dirty": "you dirty contents"}) client.run("create . user/channel") self.assertIn( "WARN: There are uncommitted changes, skipping the replacement " "of 'scm.url' and 'scm.revision' auto fields. " "Use --ignore-dirty to force it.", client.out) # The upload has to fail, no "auto" fields are allowed client.run("upload lib/0.1@user/channel -r default", assert_error=True) self.assertIn( "ERROR: lib/0.1@user/channel: Upload recipe to 'default' failed:" " The recipe contains invalid data in the 'scm' attribute (some 'auto'" " values or missing fields 'type', 'url' or 'revision'). Use '--force'" " to ignore", client.out) # The upload with --force should work client.run("upload lib/0.1@user/channel -r default --force") self.assertIn("Uploaded conan recipe", client.out)
def test_deleted_source_folder(self): path, _ = create_local_git_repo({"myfile": "contents"}, branch="my_release") conanfile = base_git.format(url=_quoted("auto"), revision="auto") self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=self.client.current_folder) self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/")) self.client.run_command('git push origin master') self.client.run("export . user/channel") # delete old source, but it doesn't matter because the sources are in the cache rmdir(self.client.current_folder) new_curdir = temp_folder() self.client.current_folder = new_curdir self.client.run("install lib/0.1@user/channel --build") self.assertNotIn( "Getting sources from url: '%s'" % path.replace("\\", "/"), self.client.out) # If the remove the source folder, then it is fetched from the "remote" doing an install self.client.run("remove lib/0.1@user/channel -f -s") self.client.run("install lib/0.1@user/channel --build") self.assertIn( "SCM: Getting sources from url: '%s'" % path.replace("\\", "/"), self.client.out)
def test_clone_submodule_git(self): subsubmodule, _ = create_local_git_repo({"subsubmodule": "contents"}) submodule, _ = create_local_git_repo({"submodule": "contents"}, submodules=[subsubmodule]) path, commit = create_local_git_repo({"myfile": "contents"}, submodules=[submodule]) def _create_paths(): tmp = temp_folder() submodule_path = os.path.join( tmp, os.path.basename(os.path.normpath(submodule))) subsubmodule_path = os.path.join( submodule_path, os.path.basename(os.path.normpath(subsubmodule))) return tmp, submodule_path, subsubmodule_path # Check old (default) behaviour tmp, submodule_path, _ = _create_paths() git = Git(tmp) git.clone(path) self.assertTrue(os.path.exists(os.path.join(tmp, "myfile"))) self.assertFalse( os.path.exists(os.path.join(submodule_path, "submodule"))) # Check invalid value tmp, submodule_path, _ = _create_paths() git = Git(tmp) git.clone(path) with six.assertRaisesRegex( self, ConanException, "Invalid 'submodule' attribute value in the 'scm'."): git.checkout(commit, submodule="invalid") # Check shallow tmp, submodule_path, subsubmodule_path = _create_paths() git = Git(tmp) git.clone(path) git.checkout(commit, submodule="shallow") self.assertTrue(os.path.exists(os.path.join(tmp, "myfile"))) self.assertTrue( os.path.exists(os.path.join(submodule_path, "submodule"))) self.assertFalse( os.path.exists(os.path.join(subsubmodule_path, "subsubmodule"))) # Check recursive tmp, submodule_path, subsubmodule_path = _create_paths() git = Git(tmp) git.clone(path) git.checkout(commit, submodule="recursive") self.assertTrue(os.path.exists(os.path.join(tmp, "myfile"))) self.assertTrue( os.path.exists(os.path.join(submodule_path, "submodule"))) self.assertTrue( os.path.exists(os.path.join(subsubmodule_path, "subsubmodule")))
def reuse_scm_multiple_conandata_test(self): # https://github.com/conan-io/conan/issues/7236 # This only works when using conandata.yml, conanfile.py replace is broken client = TestClient() conanfile = textwrap.dedent(""" from conans import ConanFile class SomeBase(object): scm = {"type" : "git", "url" : "remote1", "revision" : "auto"} class MyConanfileBase(SomeBase, ConanFile): pass """) _, base_rev = create_local_git_repo({"conanfile.py": conanfile}, branch="my_release", folder=os.path.join( client.current_folder, "base")) client.run("config set general.scm_to_conandata=1") client.run("export base base/1.1@user/testing") reuse = textwrap.dedent(""" from conans import ConanFile class PkgTest(ConanFile): name = "%s" python_requires = "base/1.1@user/testing" python_requires_extend = "base.SomeBase" """) _, reuse1_rev = create_local_git_repo( {"conanfile.py": reuse % "reuse1"}, branch="release", folder=os.path.join(client.current_folder, "reuse1")) _, reuse2_rev = create_local_git_repo( {"conanfile.py": reuse % "reuse2"}, branch="release", folder=os.path.join(client.current_folder, "reuse2")) client.run("export reuse1 reuse1/1.1@user/testing") client.run("export reuse2 reuse2/1.1@user/testing") client.run("inspect base/1.1@user/testing -a=scm --json=base.json") base_json = json.loads(client.load("base.json")) client.run("inspect reuse1/1.1@user/testing -a=scm --json=reuse1.json") reuse1_json = json.loads(client.load("reuse1.json")) client.run("inspect reuse2/1.1@user/testing -a=scm --json=reuse2.json") reuse2_json = json.loads(client.load("reuse2.json")) self.assertEqual(base_json["scm"]["revision"], base_rev) self.assertEqual(reuse1_json["scm"]["revision"], reuse1_rev) self.assertEqual(reuse2_json["scm"]["revision"], reuse2_rev) self.assertNotEqual(base_rev, reuse1_rev) self.assertNotEqual(base_rev, reuse2_rev) self.assertNotEqual(reuse2_rev, reuse1_rev)
def test_third_party_git_overwrite_build_file(): """ Same as the above, but using git clone The trick: "git clone <url> ." needs an empty directory. No reason why the ``src`` folder should be polluted automatically with exports, so just removing things works """ git_repo = temp_folder().replace("\\", "/") create_local_git_repo({"CMakeLists.txt": "MISTAKE Cmake"}, folder=git_repo) conanfile = textwrap.dedent(r""" import os, shutil from conan import ConanFile from conan.tools.files import save, load class Pkg(ConanFile): name = "mypkg" version = "1.0" exports_sources = "CMakeLists.txt" def layout(self): self.folders.source = "src" self.folders.build = "build" def source(self): self.output.info("CWD: {{}}!".format(os.getcwd())) self.output.info("FILES: {{}}!".format(sorted(os.listdir(".")))) self.run('git clone "{}" .') # Now I fix it with one of the exported files shutil.copy("../CMakeLists.txt", ".") def build(self): if "MISTAKE" in load(self, os.path.join(self.source_folder, "CMakeLists.txt")): raise Exception("MISTAKE BUILD!") """.format(git_repo)) client = TestClient() client.save({ "conanfile.py": conanfile, "conandata.yml": "", "CMakeLists.txt": "My better cmake" }) client.run("install .") client.run("source .") assert "FILES: []!" in client.out client.run("build .") assert "conanfile.py (mypkg/1.0): Calling build()" in client.out # of course create should work too client.run("create .") assert "mypkg/1.0: Created package" in client.out
def test_local_source(self): curdir = self.client.current_folder.replace("\\", "/") conanfile = base_git.format(url=_quoted("auto"), revision="auto") conanfile += """ def source(self): self.output.warn("SOURCE METHOD CALLED") """ self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=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, str(self.client.out).replace("\\", "/")) # Export again but now with absolute reference, so no pointer file is created nor kept git = Git(curdir.replace("\\", "/")) conanfile = base_git.format(url=_quoted(curdir.replace("\\", "/")), revision=git.get_revision()) conanfile += """ def source(self): self.output.warn("SOURCE METHOD CALLED") """ self.client.save({ "conanfile.py": conanfile, "myfile2.txt": "My file is copied" }) create_local_git_repo(folder=self.client.current_folder) 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: '%s'" % curdir.replace("\\", "/"), self.client.out) self.assertIn("SOURCE METHOD CALLED", self.client.out)
def test_auto_is_replaced(self): conanfile = textwrap.dedent(""" import os from conans import ConanFile class Recipe(ConanFile): scm = {"type": "git", "url": "auto", "revision": "auto"} """) t = TestClient() t.save({'conanfile.py': conanfile}) _, commit = create_local_git_repo(folder=t.current_folder) t.run_command('git remote add origin https://myrepo.com.git') t.run("config set general.scm_to_conandata=1") t.run("export . name/version@") # Check exported files package_layout = t.cache.package_layout(self.ref) exported_conanfile = load(package_layout.conanfile()) self.assertEqual(exported_conanfile, conanfile) exported_conandata = load( os.path.join(package_layout.export(), DATA_YML)) conan_data = yaml.safe_load(exported_conandata) self.assertDictEqual(conan_data['.conan']['scm'], { "type": "git", "url": 'https://myrepo.com.git', "revision": commit }) # Check the recipe gets the proper values t.run("inspect name/version@ -a scm") self.assertIn("revision: {}".format(commit), t.out) self.assertIn("type: git", t.out) self.assertIn("url: https://myrepo.com.git", t.out)
def test_repeat_clone_changing_subfolder(self): tmp = ''' from conans import ConanFile, tools class ConanLib(ConanFile): name = "lib" version = "0.1" scm = {{ "type": "git", "url": "{url}", "revision": "{revision}", "subfolder": "onesubfolder" }} ''' path, commit = create_local_git_repo({"myfile": "contents"}, branch="my_release") conanfile = tmp.format(url=path, revision=commit) self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) self.client.run("create . user/channel") conanfile = conanfile.replace('"onesubfolder"', '"othersubfolder"') self.client.save({"conanfile.py": conanfile}) self.client.run("create . user/channel") folder = self.client.cache.package_layout(self.ref).source() self.assertIn("othersubfolder", os.listdir(folder)) self.assertTrue( os.path.exists(os.path.join(folder, "othersubfolder", "myfile")))
def git_to_capture_branch_test(self): conanfile = """ import re from conans import ConanFile, tools def get_version(): git = tools.Git() try: branch = git.get_branch() branch = re.sub('[^0-9a-zA-Z]+', '_', branch) return "%s_%s" % (branch, git.get_revision()) except: return None class HelloConan(ConanFile): name = "Hello" version = get_version() def build(self): assert("r3le_ase__" in self.version) assert(len(self.version) == 50) """ path, _ = create_local_git_repo({"conanfile.py": conanfile}, branch="r3le-ase-") client = TestClient() client.current_folder = path client.run("create . user/channel")
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 test_shallow_clone_remote(self, remote, revision, is_tag): # https://github.com/conan-io/conan/issues/5570 self.client = TestClient() # "remote" git if remote == "local": remote, rev = create_local_git_repo( tags=[revision] if is_tag else None, files={"conans/model/username.py": "foo"}) if revision is None: # Get the generated commit revision = rev # Use explicit URL to avoid local optimization (scm_folder.txt) conanfile = ''' import os from conans import ConanFile, tools class ConanLib(ConanFile): name = "lib" version = "0.1" scm = {"type": "git", "url": "%s", "revision": "%s"} def build(self): assert os.path.exists(os.path.join(self.build_folder, "conans", "model", "username.py")) ''' % (remote, revision) self.client.save({"conanfile.py": conanfile}) self.client.run("create . user/channel")
def test_full_scm(self): folder = os.path.join(temp_folder(), "myrepo") url, commit = create_local_git_repo(files={"conan/conanfile.py": self.conanfile, "src/myfile.h": "myheader!", "CMakeLists.txt": "mycmake"}, folder=folder) c = TestClient(default_server_user=True) c.run_command('git clone "{}" .'.format(url)) c.run("create conan") assert "pkg/0.1: MYCMAKE: mycmake" in c.out assert "pkg/0.1: MYFILE: myheader!" in c.out c.run("upload * --all -c") # Do a change and commit, this commit will not be used by package save_files(path=folder, files={"src/myfile.h": "my2header2!"}) git_add_changes_commit(folder=folder) # use another fresh client c2 = TestClient(servers=c.servers) c2.run("install pkg/0.1@ --build=pkg") assert "pkg/0.1: MYCMAKE: mycmake" in c2.out assert "pkg/0.1: MYFILE: myheader!" in c2.out # local flow c.run("install conan") c.run("build conan") assert "conanfile.py (pkg/0.1): MYCMAKE-BUILD: mycmake" in c.out assert "conanfile.py (pkg/0.1): MYFILE-BUILD: myheader!" in c.out
def test_scm_bad_filename(self): # Fixes: #3500 badfilename = "\xE3\x81\x82badfile.txt" path, _ = create_local_git_repo({"goodfile.txt": "good contents"}, branch="my_release") save( to_file_bytes(os.path.join(self.client.current_folder, badfilename)), "contents") self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/"), cwd=path) conanfile = ''' import os from conans import ConanFile, tools class ConanLib(ConanFile): name = "lib" version = "0.1" scm = { "type": "git", "url": "auto", "revision": "auto" } def build(self): pass ''' self.client.current_folder = path self.client.save({"conanfile.py": conanfile}) self.client.run("create . user/channel")
def test_source_method_export_sources_and_scm_mixed(self): path, _ = create_local_git_repo({"myfile": "contents"}, branch="my_release") conanfile = ''' import os from conans import ConanFile, tools class ConanLib(ConanFile): name = "lib" version = "0.1" exports_sources = "file.txt" scm = { "type": "git", "url": "%s", "revision": "my_release", "subfolder": "src/nested" } def source(self): self.output.warn("SOURCE METHOD CALLED") assert(os.path.exists("file.txt")) assert(os.path.exists(os.path.join("src", "nested", "myfile"))) tools.save("cosa.txt", "contents") def build(self): assert(os.path.exists("file.txt")) assert(os.path.exists("cosa.txt")) self.output.warn("BUILD METHOD CALLED") ''' % path self.client.save({"conanfile.py": conanfile, "file.txt": "My file is copied"}) self.client.run("create . user/channel") self.assertIn("SOURCE METHOD CALLED", self.client.out) self.assertIn("BUILD METHOD CALLED", self.client.out)
def test_git_delegated_function(self): conanfile = """ import os from conans import ConanFile from conans.client.tools.scm import Git def get_revision(): here = os.path.dirname(__file__) git = Git(here) return git.get_commit() def get_url(): def nested_url(): here = os.path.dirname(__file__) git = Git(here) return git.get_remote_url() return nested_url() class MyLib(ConanFile): name = "issue" version = "3831" scm = {'type': 'git', 'url': get_url(), 'revision': get_revision()} """ self.client.save({"conanfile.py": conanfile}) path, commit = create_local_git_repo(folder=self.client.current_folder) self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/")) self.client.run("export . user/channel") ref = ConanFileReference.loads("issue/3831@user/channel") exported_conanfile = self.client.cache.package_layout(ref).conanfile() content = load(exported_conanfile) self.assertIn(commit, content)
def test_source_removed_in_local_cache(self): conanfile = ''' from conans import ConanFile, tools class ConanLib(ConanFile): scm = { "type": "git", "url": "auto", "revision": "auto", } def build(self): contents = tools.load("myfile") self.output.warn("Contents: %s" % contents) ''' path, _ = create_local_git_repo( { "myfile": "contents", "conanfile.py": conanfile }, branch="my_release") self.client.current_folder = path self.client.run_command('git remote add origin https://myrepo.com.git') self.client.run("create . lib/1.0@user/channel") self.assertIn("Contents: contents", self.client.out) self.client.save({"myfile": "Contents 2"}) self.client.run("create . lib/1.0@user/channel") self.assertIn("Contents: Contents 2", self.client.out)
def test_reuse_scm(self): client = TestClient() conanfile = """from conans import ConanFile scm = {"type" : "git", "url" : "somerepo", "revision" : "auto"} class MyConanfileBase(ConanFile): scm = scm """ create_local_git_repo({"conanfile.py": conanfile}, branch="my_release", folder=client.current_folder) client.run("export . MyConanfileBase/1.1@lasote/testing") client.run("get MyConanfileBase/1.1@lasote/testing") # The global scm is left as-is self.assertIn( """scm = {"type" : "git", "url" : "somerepo", "revision" : "auto"}""", client.out) # but the class one is replaced self.assertNotIn("scm = scm", client.out) self.assertIn(' scm = {"revision":', client.out) self.assertIn('"type": "git",', client.out) self.assertIn('"url": "somerepo"', client.out) reuse = """from conans import python_requires base = python_requires("MyConanfileBase/1.1@lasote/testing") class PkgTest(base.MyConanfileBase): scm = base.scm other = 123 def _my_method(self): pass """ client.save({"conanfile.py": reuse}) # Commit changes so it replaces and exports the scm data client.run_command('git add .') client.run_command('git commit -m "Modified conanfile"') client.run("export . Pkg/0.1@lasote/testing") client.run("get Pkg/0.1@lasote/testing") self.assertNotIn("scm = base.scm", client.out) self.assertIn('scm = {"revision":', client.out) self.assertIn('"type": "git",', client.out) self.assertIn('"url": "somerepo"', client.out)
def test_auto_git(self): curdir = get_cased_path(self.client.current_folder).replace("\\", "/") conanfile = base_git.format(directory="None", url=_quoted("auto"), revision="auto") self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=self.client.current_folder) self.client.run("export . user/channel") self.assertIn( "WARN: Repo origin cannot be deduced, 'auto' fields won't be replaced", self.client.out) self.client.run_command('git remote add origin https://myrepo.com.git') # Create the package, will copy the sources from the local folder self.client.run("create . user/channel") self.assertIn("Repo origin deduced by 'auto': https://myrepo.com.git", self.client.out) 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) # check blank lines are respected in replacement self.client.run("get lib/0.1@user/channel") self.assertIn("""} def build(self):""", self.client.out) # Export again but now with absolute reference, so no sources are copied from the local dir git = Git(curdir) self.client.save({ "conanfile.py": base_git.format(url=_quoted(curdir), revision=git.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.assertNotIn("Getting sources from folder: %s" % curdir, self.client.out) self.assertIn("SCM: Getting sources from url: '%s'" % curdir, self.client.out) self.assertIn("My file is copied", self.client.out)
def init_git_repo(self, files=None, branch=None, submodules=None, folder=None, origin_url=None): if folder is not None: folder = os.path.join(self.current_folder, folder) else: folder = self.current_folder _, commit = create_local_git_repo(files, branch, submodules, folder=folder, origin_url=origin_url) return commit
def init_git_repo(self, files=None, branch=None, submodules=None, origin_url=None): _, commit = create_local_git_repo(files, branch, submodules, self.current_folder) if origin_url: self.run_command('git remote add origin {}'.format(origin_url)) return commit
def setUp(self): self.client = TestClient() # Create a local repo verify_ssl_attrib_str = "" if self.verify_ssl is not None: verify_ssl_attrib_str = '"verify_ssl": {}'.format(self.verify_ssl) files = {'conanfile.py': self.conanfile.format(verify_ssl_attrib=verify_ssl_attrib_str)} url, _ = create_local_git_repo(files=files, commits=4, tags=['v0', ]) self.client.run_command('git clone "{}" .'.format(url))
def test_revision_mode_scm(self): path, rev = create_local_git_repo( files={'conanfile.py': self.conanfile.format(revision_mode="scm")}) t = TestClient(current_folder=path) ref = ConanFileReference.loads("name/version@user/channel") t.run("export . {}".format(ref)) meta = t.cache.package_layout(ref, short_paths=False).load_metadata() self.assertEqual(meta.recipe.revision, rev)
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_repo_root(self): root_path, _ = create_local_git_repo({"myfile": "anything"}) # Initialized in the root folder git = Git(root_path) self.assertEqual(root_path, git.get_repo_root()) # Initialized elsewhere subfolder = os.path.join(root_path, 'subfolder') os.makedirs(subfolder) git = Git(subfolder) self.assertEqual(root_path, git.get_repo_root())
def test_clone_existing_folder_git(self): path, commit = create_local_git_repo({"myfile": "contents"}, branch="my_release") tmp = temp_folder() save(os.path.join(tmp, "file"), "dummy contents") git = Git(tmp) git.clone(path, branch="my_release") self.assertTrue(os.path.exists(os.path.join(tmp, "myfile"))) # Checkout a commit git.checkout(commit) self.assertEqual(git.get_revision(), commit)
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())