def test_rename(self):
client = TestClient()
tmpdir = client.current_folder
sub_space_dir = "sub dir"
with chdir(tmpdir):
os.makedirs(sub_space_dir)
os.makedirs(os.path.join(sub_space_dir, "dir.pdb"))
os.makedirs(os.path.join(sub_space_dir, "middir"))
os.makedirs(os.path.join(sub_space_dir, "middir", "deepdir"))
client.save({
os.path.join(sub_space_dir, "1.txt"):
"",
os.path.join(sub_space_dir, "1.pdb"):
"",
os.path.join(sub_space_dir, "1.pdb1"):
"",
os.path.join(sub_space_dir, "dir.pdb", "2.txt"):
"",
os.path.join(sub_space_dir, "dir.pdb", "2.pdb"):
"",
os.path.join(sub_space_dir, "dir.pdb", "2.pdb1"):
"",
os.path.join(sub_space_dir, "middir", "3.txt"):
"",
os.path.join(sub_space_dir, "middir", "3.pdb"):
"",
os.path.join(sub_space_dir, "middir", "3.pdb1"):
"",
os.path.join(sub_space_dir, "middir", "deepdir", "4.txt"):
"",
os.path.join(sub_space_dir, "middir", "deepdir", "4.pdb"):
"",
os.path.join(sub_space_dir, "middir", "deepdir", "4.pdb1"):
""
})
self.verify_dir(os.path.join(tmpdir, sub_space_dir))
with chdir(tmpdir):
rename(sub_space_dir, "dst dir")
self.verify_dir(os.path.join(tmpdir, "dst dir"))
rename("dst dir", "subdir")
self.verify_dir(os.path.join(tmpdir, "subdir"))
rename(os.path.join("subdir", "1.txt"), "t.txt")
self.assertTrue(os.path.isfile(os.path.join(tmpdir, "t.txt")))
self.assertFalse(
os.path.isfile(os.path.join(tmpdir, "subdir", "1.txt")))
def create_project(self,
files,
rel_project_path=None,
commit_msg='default commit message',
delete_checkout=True):
tmp_dir = self.gimme_tmp()
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=self.repo_url, path=tmp_dir),
shell=True)
tmp_project_dir = os.path.join(tmp_dir, rel_project_path)
os.makedirs(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)
rev = subprocess.check_output("svn info --show-item revision",
shell=True).decode().strip()
project_url = self.repo_url + "/" + quote(
rel_project_path.replace("\\", "/"))
return project_url, rev
finally:
if delete_checkout:
shutil.rmtree(tmp_dir,
ignore_errors=False,
onerror=handleRemoveReadonly)
def test_link_folder(self):
# If there is a linked folder in the current directory that matches one file in the tar.
# https://github.com/conan-io/conan/issues/4959
# Once unpackaged, this is the content of the destination directory
def check_files(destination_dir):
d = os.listdir(destination_dir)
self.assertListEqual(d, ["folder", "file1"])
d_folder = os.listdir(os.path.join(destination_dir, "folder"))
self.assertEqual(d_folder, ["file2"])
working_dir = temp_folder()
with chdir(working_dir):
# Unpack and check
destination_dir = os.path.join(self.tmp_folder, "dest")
with open(self.tgz_file, 'rb') as file_handler:
tar_extract(file_handler, destination_dir)
check_files(destination_dir)
# Unpack and check (now we have a symlinked local folder)
os.symlink(temp_folder(), "folder")
destination_dir = os.path.join(self.tmp_folder, "dest2")
with open(self.tgz_file, 'rb') as file_handler:
tar_extract(file_handler, destination_dir)
check_files(destination_dir)
def configure(self, source_folder=None):
# TODO: environment?
if not self._conanfile.should_configure:
return
source = self._conanfile.source_folder
if source_folder:
source = os.path.join(self._conanfile.source_folder, source_folder)
build_folder = self._conanfile.build_folder
if self._build_folder:
build_folder = os.path.join(self._conanfile.build_folder,
self._build_folder)
mkdir(build_folder)
arg_list = '-DCMAKE_TOOLCHAIN_FILE="{}" -DCMAKE_INSTALL_PREFIX="{}" "{}"'.format(
CMakeToolchainBase.filename,
self._conanfile.package_folder.replace("\\", "/"), source)
generator = '-G "{}" '.format(
self._generator) if self._generator else ""
command = "%s %s%s" % (self._cmake_program, generator, arg_list)
is_windows_mingw = platform.system(
) == "Windows" and self._generator == "MinGW Makefiles"
self._conanfile.output.info("CMake command: %s" % command)
with chdir(build_folder):
if is_windows_mingw:
with tools.remove_from_path("sh"):
self._conanfile.run(command)
else:
self._conanfile.run(command)
def test_skip_toolset(self):
settings = MockSettings({"build_type": "Debug",
"compiler": "Visual Studio",
"compiler.version": "15",
"arch": "x86_64"})
class Runner(object):
def __init__(self):
self.commands = []
def __call__(self, *args, **kwargs):
self.commands.append(args[0])
with chdir(tools.mkdir_tmp()):
runner = Runner()
conanfile = MockConanfile(settings, runner=runner)
msbuild = MSBuild(conanfile)
msbuild.build("myproject", toolset=False)
self.assertEqual(len(runner.commands), 1)
self.assertNotIn("PlatformToolset", runner.commands[0])
runner = Runner()
conanfile = MockConanfile(settings, runner=runner)
msbuild = MSBuild(conanfile)
msbuild.build("myproject", toolset="mytoolset")
self.assertEqual(len(runner.commands), 1)
self.assertIn('/p:PlatformToolset="mytoolset"', runner.commands[0])
def configure(self, source_folder=None):
# TODO: environment?
if not self._conanfile.should_configure:
return
source = self._conanfile.source_folder
if source_folder:
source = os.path.join(self._conanfile.source_folder, source_folder)
build_folder = self._conanfile.build_folder
if self._build_folder:
build_folder = os.path.join(self._conanfile.build_folder, self._build_folder)
defs = {"CMAKE_TOOLCHAIN_FILE": CMakeToolchainBase.filename}
mkdir(build_folder)
arg_list = join_arguments([
defs_to_string(defs),
args_to_string([source])
])
generator = '-G "{}" '.format(self._generator) if self._generator else ""
command = "%s %s%s" % (self._cmake_program, generator, arg_list)
is_windows_mingw = platform.system() == "Windows" and self._generator == "MinGW Makefiles"
self._conanfile.output.info("CMake command: %s" % command)
with chdir(build_folder):
if is_windows_mingw:
with tools.remove_from_path("sh"):
self._conanfile.run(command)
else:
self._conanfile.run(command)
def configure(self, source_folder=None):
# TODO: environment?
if not self._conanfile.should_configure:
return
source = self._conanfile.source_folder
if source_folder:
source = os.path.join(self._conanfile.source_folder, source_folder)
build_folder = self._conanfile.build_folder
if self._build_folder:
build_folder = os.path.join(self._conanfile.build_folder,
self._build_folder)
mkdir(build_folder)
arg_list = '-DCMAKE_TOOLCHAIN_FILE="{}" -DCMAKE_INSTALL_PREFIX="{}" "{}"'.format(
CMakeToolchain.filename,
self._conanfile.package_folder.replace("\\", "/"), source)
if platform.system(
) == "Windows" and self._generator == "MinGW Makefiles":
arg_list += ' -DCMAKE_SH="CMAKE_SH-NOTFOUND"'
generator = '-G "{}" '.format(
self._generator) if self._generator else ""
command = "%s %s%s" % (self._cmake_program, generator, arg_list)
self._conanfile.output.info("CMake command: %s" % command)
with chdir(build_folder):
vcvars = os.path.join(self._conanfile.install_folder,
"conanvcvars")
self._conanfile.run(command, env=["conanbuildenv", vcvars])
def test_plain_tgz_common_base(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
# Create a couple of files
ori_files_dir = os.path.join(tmp_folder, "subfolder-1.2.3")
file1 = os.path.join(ori_files_dir, "folder", "file1")
file2 = os.path.join(ori_files_dir, "folder", "file2")
file3 = os.path.join(ori_files_dir, "folder", "file3")
save(file1, "")
save(file2, "")
save(file3, "")
tgz_folder = temp_folder()
tgz_file = os.path.join(tgz_folder, "file.tar.gz")
self._compress_folder(tmp_folder, tgz_file)
# Tgz unzipped regularly
extract_folder = temp_folder()
untargz(tgz_file, destination=extract_folder, strip_root=True)
self.assertFalse(
os.path.exists(os.path.join(extract_folder, "subfolder-1.2.3")))
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "folder", "file1")))
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "folder", "file2")))
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "folder", "file3")))
def validate_additional_dependencies(libname, additional_dep):
tempdir = temp_folder()
with chdir(tempdir):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.libs = [libname]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
settings = Settings.loads(get_default_settings_yml())
settings.os = "Windows"
settings.arch = "x86_64"
settings.build_type = "Release"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.compiler.runtime = "MD"
settings.compiler.toolset = "v141"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertIn('conanbuildinfo_release_x64_v141.props', content.keys())
content_release = content['conanbuildinfo_release_x64_v141.props']
self.assertIn("<ConanLibraries>%s;</ConanLibraries>" % additional_dep,
content_release)
self.assertIn("<AdditionalDependencies>"
"$(ConanLibraries)%(AdditionalDependencies)"
"</AdditionalDependencies>", content_release)
def _run_muted(cmd, folder=None):
with chdir(folder) if folder else no_op():
process = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
process.communicate()
return process.returncode
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 configure(self, source_folder=None):
# TODO: environment?
if not self._conanfile.should_configure:
return
source = self._conanfile.source_folder
if source_folder:
source = os.path.join(self._conanfile.source_folder, source_folder)
build_folder = self._conanfile.build_folder
generator_folder = self._conanfile.generators_folder
mkdir(build_folder)
arg_list = [self._cmake_program]
if self._generator:
arg_list.append('-G "{}"'.format(self._generator))
if self._toolchain_file:
if os.path.isabs(self._toolchain_file):
toolpath = self._toolchain_file
else:
toolpath = os.path.join(generator_folder, self._toolchain_file)
arg_list.append('-DCMAKE_TOOLCHAIN_FILE="{}"'.format(toolpath.replace("\\", "/")))
if self._conanfile.package_folder:
pkg_folder = self._conanfile.package_folder.replace("\\", "/")
arg_list.append('-DCMAKE_INSTALL_PREFIX="{}"'.format(pkg_folder))
if platform.system() == "Windows" and self._generator == "MinGW Makefiles":
arg_list.append('-DCMAKE_SH="CMAKE_SH-NOTFOUND"')
arg_list.append('"{}"'.format(source))
command = " ".join(arg_list)
self._conanfile.output.info("CMake command: %s" % command)
with chdir(build_folder):
self._conanfile.run(command)
def test_api_conanfile_loader_shouldnt_cache(self):
tmp = temp_folder()
with environment_append({"CONAN_USER_HOME": tmp}):
with chdir(tmp):
try:
old_stdout = sys.stdout
result = StringIO()
sys.stdout = result
api, _, _ = ConanAPIV1.factory()
api._user_io.out = TestBufferConanOutput()
conanfile = dedent("""
from conans import ConanFile
class Pkg(ConanFile):
def build(self):
self.output.info("NUMBER 42!!")
""")
save("conanfile.py", conanfile)
api.create(".", "pkg", "version", "user", "channel")
self.assertIn("pkg/version@user/channel: NUMBER 42!!",
result.getvalue())
save("conanfile.py", conanfile.replace("42", "123"))
api.create(".", "pkg", "version", "user", "channel")
self.assertIn("pkg/version@user/channel: NUMBER 123!!",
result.getvalue())
finally:
sys.stdout = old_stdout
def test_invalid_flat(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
# Not a single dir containing everything
file1 = os.path.join(tmp_folder, "subfolder-1.2.3", "folder2",
"file1")
file2 = os.path.join(tmp_folder, "other-1.2.3", "folder", "file2")
save(file1, "")
save(file2, "")
zip_folder = temp_folder()
zip_file = os.path.join(zip_folder, "file.zip")
self._zipdir(tmp_folder, zip_file)
# Extract without the subfolder
extract_folder = temp_folder()
with six.assertRaisesRegex(
self, ConanException,
"The zip file contains more than 1 folder "
"in the root"):
unzip(zip_file,
destination=extract_folder,
strip_root=True,
output=Mock())
def run(self, command):
command = "%s %s" % (self.cmd_command, command)
with chdir(self.folder) if self.folder else no_op():
with environment_append({"LC_ALL": "en_US.UTF-8"}) if self._force_eng else no_op():
if not self._runner:
return decode_text(subprocess.check_output(command, shell=True).strip())
else:
return self._runner(command)
def run(self, command):
command = "%s %s" % (self.cmd_command, command)
with chdir(self.folder) if self.folder else no_op():
with environment_append({"LC_ALL": "en_US.UTF-8"}) if self._force_eng else no_op():
with pyinstaller_bundle_env_cleaned():
if not self._runner:
return check_output_runner(command).strip()
else:
return self._runner(command)
def remove_files_by_mask_test(self):
tmpdir = temp_folder()
with chdir(tmpdir):
os.makedirs("subdir")
os.makedirs("dir.pdb")
os.makedirs(os.path.join("subdir", "deepdir"))
save_files(
tmpdir, {
"1.txt": "",
"1.pdb": "",
"1.pdb1": "",
os.path.join("subdir", "2.txt"): "",
os.path.join("subdir", "2.pdb"): "",
os.path.join("subdir", "2.pdb1"): "",
os.path.join("subdir", "deepdir", "3.txt"): "",
os.path.join("subdir", "deepdir", "3.pdb"): "",
os.path.join("subdir", "deepdir", "3.pdb1"): ""
})
removed_files = remove_files_by_mask(tmpdir, "*.sh")
self.assertEqual(removed_files, [])
removed_files = remove_files_by_mask(tmpdir, "*.pdb")
self.assertTrue(os.path.isdir(os.path.join(tmpdir, "dir.pdb")))
self.assertTrue(os.path.isfile(os.path.join(tmpdir, "1.txt")))
self.assertFalse(os.path.isfile(os.path.join(tmpdir, "1.pdb")))
self.assertTrue(os.path.isfile(os.path.join(tmpdir, "1.pdb1")))
self.assertTrue(os.path.isfile(os.path.join(tmpdir, "subdir",
"2.txt")))
self.assertFalse(
os.path.isfile(os.path.join(tmpdir, "subdir", "2.pdb")))
self.assertTrue(
os.path.isfile(os.path.join(tmpdir, "subdir", "2.pdb1")))
self.assertTrue(
os.path.isfile(os.path.join(tmpdir, "subdir", "deepdir", "3.txt")))
self.assertFalse(
os.path.isfile(os.path.join(tmpdir, "subdir", "deepdir", "3.pdb")))
self.assertTrue(
os.path.isfile(os.path.join(tmpdir, "subdir", "deepdir",
"3.pdb1")))
self.assertEqual(
set(removed_files), {
"1.pdb",
os.path.join("subdir", "2.pdb"),
os.path.join("subdir", "deepdir", "3.pdb")
})
removed_files = remove_files_by_mask(tmpdir, "*.pdb")
self.assertEqual(removed_files, [])
def _run_test(self, tuples):
tmp_folder = temp_folder()
with chdir(tmp_folder):
for f, _ in tuples:
save(f, "")
apple_dot_clean(".")
for f, expected_after in tuples:
self.assertEqual(expected_after, os.path.exists(f))
def _parse_conanfile(conan_file_path):
""" From a given path, obtain the in memory python import module
"""
if not os.path.exists(conan_file_path):
raise NotFoundException("%s not found!" % conan_file_path)
module_id = str(uuid.uuid1())
current_dir = os.path.dirname(conan_file_path)
sys.path.insert(0, current_dir)
try:
old_modules = list(sys.modules.keys())
with chdir(current_dir):
old_dont_write_bytecode = sys.dont_write_bytecode
sys.dont_write_bytecode = True
loaded = imp.load_source(module_id, conan_file_path)
sys.dont_write_bytecode = old_dont_write_bytecode
required_conan_version = getattr(loaded, "required_conan_version",
None)
if required_conan_version:
validate_conan_version(required_conan_version)
# These lines are necessary, otherwise local conanfile imports with same name
# collide, but no error, and overwrite other packages imports!!
added_modules = set(sys.modules).difference(old_modules)
for added in added_modules:
module = sys.modules[added]
if module:
try:
try:
# Most modules will have __file__ != None
folder = os.path.dirname(module.__file__)
except (AttributeError, TypeError):
# But __file__ might not exist or equal None
# Like some builtins and Namespace packages py3
folder = module.__path__._path[0]
except AttributeError: # In case the module.__path__ doesn't exist
pass
else:
if folder.startswith(current_dir):
module = sys.modules.pop(added)
sys.modules["%s.%s" % (module_id, added)] = module
except ConanException:
raise
except Exception:
import traceback
trace = traceback.format_exc().split('\n')
raise ConanException("Unable to load conanfile in %s\n%s" %
(conan_file_path, '\n'.join(trace[3:])))
finally:
sys.path.pop(0)
return loaded, module_id
def tgz_with_contents(files):
with chdir(mkdir_tmp()):
import tarfile
file_path = os.path.abspath("myfile.tar.gz")
tar_file = tarfile.open(file_path, "w:gz")
for name, content in files.items():
info = tarfile.TarInfo(name=name)
data = content.encode('utf-8')
info.size = len(data)
tar_file.addfile(tarinfo=info, fileobj=BytesIO(data))
tar_file.close()
return file_path
def _call_package(conanfile, package_id, source_folder, build_folder,
package_folder, install_folder, hook_manager, conanfile_path,
ref, local, copy_info):
output = conanfile.output
try:
hook_manager.execute("pre_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=ref,
package_id=package_id)
output.highlight("Calling package()")
folders = [source_folder, build_folder
] if source_folder != build_folder else [build_folder]
conanfile.copy = FileCopier(folders, package_folder)
with conanfile_exception_formatter(str(conanfile), "package"):
with chdir(build_folder):
with conan_v2_property(
conanfile, 'info',
"'self.info' access in package() method is deprecated"
):
conanfile.package()
except Exception as e:
if not local:
os.chdir(build_folder)
try:
rmdir(package_folder)
except Exception as e_rm:
output.error("Unable to remove package folder %s\n%s" %
(package_folder, str(e_rm)))
output.warn("**** Please delete it manually ****")
if isinstance(e, ConanExceptionInUserConanfileMethod):
raise
raise ConanException(e)
hook_manager.execute("post_package",
conanfile=conanfile,
conanfile_path=conanfile_path,
reference=ref,
package_id=package_id)
manifest = _create_aux_files(install_folder, package_folder, conanfile,
copy_info)
package_output = ScopedOutput("%s package()" % output.scope, output)
_report_files_from_manifest(package_output, manifest)
package_id = package_id or os.path.basename(package_folder)
output.success("Package '%s' created" % package_id)
prev = manifest.summary_hash
output.info("Created package revision %s" % prev)
return prev
def test_invalid_flat_single_file(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
save("file1", "contentsfile1")
zip_folder = temp_folder()
zip_file = os.path.join(zip_folder, "file.zip")
self._zipdir(tmp_folder, zip_file)
# Extract without the subfolder
extract_folder = temp_folder()
with six.assertRaisesRegex(self, ConanException, "The zip file contains a file in the root"):
unzip(zip_file, destination=extract_folder, strip_root=True)
def test_invalid_flat_single_file(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
save("file1", "contentsfile1")
zip_folder = temp_folder()
tgz_file = os.path.join(zip_folder, "file.tar.gz")
self._compress_folder(tmp_folder, tgz_file)
# Extract without the subfolder
extract_folder = temp_folder()
with six.assertRaisesRegex(self, ConanException, "The tgz file contains a file in the root"):
unzip(tgz_file, destination=extract_folder, strip_root=True, output=Mock())
def test_plain_zip(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
ori_files_dir = os.path.join(tmp_folder, "subfolder-1.2.3")
file1 = os.path.join(ori_files_dir, "file1")
file2 = os.path.join(ori_files_dir, "folder", "file2")
file3 = os.path.join(ori_files_dir, "file3")
save(file1, "")
save(file2, "")
save(file3, "")
zip_file = os.path.join(tmp_folder, "myzip.zip")
# Zip with a "folder_entry" in the zip (not only for the files)
self._zipdir(tmp_folder, zip_file, folder_entry="subfolder-1.2.3")
# ZIP unzipped regularly
extract_folder = temp_folder()
output = TestBufferConanOutput()
unzip(zip_file,
destination=extract_folder,
strip_root=False,
output=output)
self.assertNotIn("ERROR: Error extract", output)
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "subfolder-1.2.3")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "file1")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "folder",
"file2")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "file3")))
# Extract without the subfolder
extract_folder = temp_folder()
output = TestBufferConanOutput()
unzip(zip_file,
destination=extract_folder,
strip_root=True,
output=output)
self.assertNotIn("ERROR: Error extract", output)
self.assertFalse(
os.path.exists(os.path.join(extract_folder, "subfolder-1.2.3")))
self.assertTrue(os.path.exists(os.path.join(extract_folder, "file1")))
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "folder", "file2")))
self.assertTrue(os.path.exists(os.path.join(extract_folder, "file3")))
def test_propset_own(self):
""" Apply svn:needs-lock property to every file in the own working-copy of the repository """
conanfile = base_svn.format(directory="None", url=_quoted("auto"), revision="auto")
project_url, _ = self.create_project(files={"conanfile.py": conanfile,})
project_url = project_url.replace(" ", "%20")
# Add property needs-lock to my own copy
client = TestClient()
client.runner('svn co "{url}" "{path}"'.format(url=project_url,
path=client.current_folder))
with chdir(client.current_folder):
for item in ['conanfile.py', ]:
client.runner('svn propset svn:needs-lock yes {}'.format(item))
client.runner('svn commit -m "lock some files"')
client.run("export . user/channel")
def test_invalid_flat(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
# Not a single dir containing everything
file1 = os.path.join(tmp_folder, "subfolder-1.2.3", "folder2", "file1")
file2 = os.path.join(tmp_folder, "other-1.2.3", "folder", "file2")
save(file1, "")
save(file2, "")
tgz_folder = temp_folder()
tgz_file = os.path.join(tgz_folder, "file.tar.gz")
self._compress_folder(tmp_folder, tgz_file)
extract_folder = temp_folder()
with six.assertRaisesRegex(self, ConanException, "The tgz file contains more than 1 folder "
"in the root"):
untargz(tgz_file, destination=extract_folder, strip_root=True)
def test_preprocessor_called_second_api_call(self):
""""When calling twice to conan create with the Conan python API, the default
settings shouldn't be cached. To test that the default profile is not cached,
this test is verifying that the setting preprocessor is adjusting the runtime
to MDd when build_type=Debug after a different call to conan create that could
cache the runtime to MD (issue reported at: #4246) """
tmp = temp_folder()
with environment_append({"CONAN_USER_HOME": tmp}):
with chdir(tmp):
api = ConanAPIV1(output=TestBufferConanOutput())
api.new(name="lib/1.0@conan/stable", bare=True)
def get_conaninfo(info):
package_id = info["installed"][0]["packages"][0]["id"]
pref = PackageReference.loads("lib/1.0@conan/stable:%s" %
package_id)
cache = ClientCache(api.cache_folder,
TestBufferConanOutput())
folder = cache.package_layout(pref.ref).package(pref)
return load(os.path.join(folder, "conaninfo.txt"))
settings = [
"compiler=Visual Studio", "compiler.version=15",
"build_type=Release"
]
info = api.create(".",
name=None,
version=None,
user="******",
channel="stable",
settings=settings)
self.assertIn("compiler.runtime=MD", get_conaninfo(info))
settings = [
"compiler=Visual Studio", "compiler.version=15",
"build_type=Debug"
]
info = api.create(".",
name=None,
version=None,
user="******",
channel="stable",
settings=settings)
self.assertIn("compiler.runtime=MDd", get_conaninfo(info))
def test_api_conanfile_loader_shouldnt_cache(self):
tmp = temp_folder()
with environment_append({"CONAN_USER_HOME": tmp}):
with chdir(tmp):
output = TestBufferConanOutput()
api = ConanAPIV1(output=output)
conanfile = dedent("""
from conans import ConanFile
class Pkg(ConanFile):
def build(self):
self.output.info("NUMBER 42!!")
""")
save("conanfile.py", conanfile)
api.create(".", "pkg", "version", "user", "channel")
self.assertIn("pkg/version@user/channel: NUMBER 42!!", output)
save("conanfile.py", conanfile.replace("42", "123"))
api.create(".", "pkg", "version", "user", "channel")
self.assertIn("pkg/version@user/channel: NUMBER 123!!", output)
def _load_module_from_file(hook_path):
""" From a given path, obtain the in memory python import module
"""
if not os.path.exists(hook_path):
raise NotFoundException
filename = os.path.splitext(os.path.basename(hook_path))[0]
current_dir = os.path.dirname(hook_path)
old_dont_write_bytecode = sys.dont_write_bytecode
try:
sys.path.append(current_dir)
old_modules = list(sys.modules.keys())
with chdir(current_dir):
sys.dont_write_bytecode = True
loaded = __import__(filename)
# Put all imported files under a new package name
module_id = uuid.uuid1()
added_modules = set(sys.modules).difference(old_modules)
for added in added_modules:
module = sys.modules[added]
if module:
try:
try:
# Most modules will have __file__ != None
folder = os.path.dirname(module.__file__)
except (AttributeError, TypeError):
# But __file__ might not exist or equal None
# Like some builtins and Namespace packages py3
folder = module.__path__._path[0]
except AttributeError: # In case the module.__path__ doesn't exist
pass
else:
if folder.startswith(current_dir):
module = sys.modules.pop(added)
sys.modules["%s.%s" % (module_id, added)] = module
except Exception:
trace = traceback.format_exc().split('\n')
raise ConanException("Unable to load Hook in %s\n%s" %
(hook_path, '\n'.join(trace[3:])))
finally:
sys.dont_write_bytecode = old_dont_write_bytecode
sys.path.pop()
return loaded
def _create_and_load(myfunc, value, subdir_name, add_subdir_init):
subdir_content = textwrap.dedent("""
def get_value():
return {value}
def {myfunc}():
return "{myfunc}"
""")
side_content = textwrap.dedent("""
def get_side_value():
return {value}
def side_{myfunc}():
return "{myfunc}"
""")
conanfile = textwrap.dedent("""
import pickle
from {subdir}.api import get_value, {myfunc}
from file import get_side_value, side_{myfunc}
from fractions import Fraction
def conanfile_func():
return get_value(), {myfunc}(), get_side_value(), side_{myfunc}(), str(Fraction(1,1))
""")
expected_return = (value, myfunc, value, myfunc, "1")
tmp = temp_folder()
with chdir(tmp):
save(
"conanfile.py",
conanfile.format(value=value,
myfunc=myfunc,
subdir=subdir_name))
save("file.py", side_content.format(value=value, myfunc=myfunc))
save("{}/api.py".format(subdir_name),
subdir_content.format(value=value, myfunc=myfunc))
if add_subdir_init:
save("__init__.py", "")
save("{}/__init__.py".format(subdir_name), "")
loaded, module_id = _parse_conanfile(os.path.join(tmp, "conanfile.py"))
return loaded, module_id, expected_return
