def new(self,
name,
header=False,
pure_c=False,
test=False,
exports_sources=False,
bare=False,
cwd=None,
visual_versions=None,
linux_gcc_versions=None,
linux_clang_versions=None,
osx_clang_versions=None,
shared=None,
upload_url=None,
gitignore=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name,
header=header,
pure_c=pure_c,
test=test,
exports_sources=exports_sources,
bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions,
shared=shared,
upload_url=upload_url,
gitignore=gitignore)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def test_export_method_parent_folder(self):
folder = temp_folder()
save_files(folder, {
"subdir/subdir2/file2.txt": "",
"subdir/file1.txt": ""
})
client = TestClient(current_folder=os.path.join(folder, "recipe"))
conanfile = textwrap.dedent("""
from conans import ConanFile
class MethodConan(ConanFile):
def export(self):
self.output.info("Executing export() method")
self.copy("*.txt", src="../subdir")
""")
client.save({"conanfile.py": conanfile})
client.run("export . pkg/0.1@")
self.assertIn(
"pkg/0.1 export() method: Copied 2 '.txt' files: file1.txt, file2.txt",
client.out)
layout = client.cache.package_layout(
ConanFileReference.loads("pkg/0.1"))
self.assertTrue(
os.path.isfile(os.path.join(layout.export(), "file1.txt")))
self.assertTrue(
os.path.isfile(
os.path.join(layout.export(), "subdir2", "file2.txt")))
def test_install_remotes_json_error(self):
folder = temp_folder()
save_files(folder, {"remotes.json": ""})
self.client.run('config install "%s"' % folder, assert_error=True)
self.assertIn("ERROR: Failed conan config install: "
"remotes.json install is not supported yet. Use 'remotes.txt'",
self.client.out)
def test_parse_data(self):
conanfile = textwrap.dedent("""
import os
from conans import ConanFile
class Recipe(ConanFile):
scm = {"type": "git", "url": "auto", "revision": "auto"}
""")
conan_data = {
'something_else': {},
'.conan': {
'scm': {
'type': 'git',
'url': 'http://myrepo.com',
'shallow': False,
'revision': 'abcdefghijk'
}
}
}
test_folder = tempfile.mkdtemp()
save_files(
test_folder, {
'conanfile.py': conanfile,
DATA_YML: yaml.safe_dump(conan_data, default_flow_style=False)
})
conanfile, _ = self.loader.load_basic_module(
conanfile_path=os.path.join(test_folder, 'conanfile.py'))
self.assertDictEqual(conanfile.scm, conan_data['.conan']['scm'])
def test_error_package_xz(self):
server = TestServer()
ref = ConanFileReference.loads("Pkg/0.1@user/channel")
ref = ref.copy_with_rev(DEFAULT_REVISION_V1)
client = TestClient(servers={"default": server},
users={"default": [("lasote", "mypass")]})
server.server_store.update_last_revision(ref)
export = server.server_store.export(
ref) # *1 the path can't be known before upload a revision
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
exports_sources = "*"
"""
save_files(export, {
"conanfile.py": conanfile,
"conanmanifest.txt": "1"
})
pref = PackageReference(ref, NO_SETTINGS_PACKAGE_ID,
DEFAULT_REVISION_V1)
server.server_store.update_last_package_revision(
pref.copy_with_revs(DEFAULT_REVISION_V1, DEFAULT_REVISION_V1))
package = server.server_store.package(pref)
save_files(
package, {
"conaninfo.txt": "#",
"conanmanifest.txt": "1",
"conan_package.txz": "#"
})
client.run("install Pkg/0.1@user/channel", assert_error=True)
self.assertIn(
"ERROR: This Conan version is not prepared to handle "
"'conan_package.txz' file format", client.out)
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("svn info --show-item revision").strip()
else:
import xml.etree.ElementTree as ET
output = check_output("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 setUp(self):
self.ref = ConanFileReference.loads("openssl/2.0.3@lasote/testing#%s" % DEFAULT_REVISION_V1)
self.pref = PackageReference(self.ref, "123123123", DEFAULT_REVISION_V1)
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret", timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.server_store = ServerStore(storage_adapter=adapter)
self.service = ConanService(authorizer, self.server_store, "lasote")
self.search_service = SearchService(authorizer, self.server_store, "lasote")
files = {"conanfile.py": str(GenConanfile("test"))}
save_files(self.server_store.export(self.ref), files)
self.server_store.update_last_revision(self.ref)
manifest = FileTreeManifest.create(self.server_store.export(self.ref))
conan_digest_path = os.path.join(self.server_store.export(self.ref), CONAN_MANIFEST)
save(conan_digest_path, repr(manifest))
files = {"boost.lib": "", "boost2.lib": ""}
save_files(self.server_store.package(self.pref), files)
def config_hooks_test(self):
# Make sure the conan.conf hooks information is appended
folder = temp_folder(path_with_spaces=False)
conan_conf = textwrap.dedent("""
[hooks]
foo
custom/custom
""")
save_files(folder, {"config/conan.conf": conan_conf})
client = TestClient()
client.run('config install "%s"' % folder)
self.assertIn("Processing conan.conf", client.out)
content = load(client.cache.conan_conf_path)
self.assertEqual(1, content.count("foo"))
self.assertEqual(1, content.count("custom/custom"))
config = ConanClientConfigParser(client.cache.conan_conf_path)
hooks = config.get_item("hooks")
self.assertIn("foo", hooks)
self.assertIn("custom/custom", hooks)
self.assertIn("attribute_checker", hooks)
client.run('config install "%s"' % folder)
self.assertIn("Processing conan.conf", client.out)
content = load(client.cache.conan_conf_path)
self.assertEqual(1, content.count("foo"))
self.assertEqual(1, content.count("custom/custom"))
def _run_virtualenv(self, generator):
generator.output_path = self.test_folder
save_files(self.test_folder, generator.content)
# Generate the list of commands to execute
shell_commands = [
self.commands.dump_env.format(filename=self.env_before),
self.commands.find_program.format(program="conan",
variable="__conan_pre_path__"),
self.commands.find_program.format(program=self.app,
variable="__exec_pre_path__"),
self.commands.activate,
self.commands.dump_env.format(filename=self.env_activated),
self.commands.find_program.format(program="conan",
variable="__conan_env_path__"),
self.commands.find_program.format(program=self.app,
variable="__exec_env_path__"),
self.commands.deactivate,
self.commands.dump_env.format(filename=self.env_after),
self.commands.find_program.format(program="conan",
variable="__conan_post_path__"),
self.commands.find_program.format(program=self.app,
variable="__exec_post_path__"),
"",
]
# Execute
with environment_append({"PATH": [
self.ori_path,
]}):
shell = subprocess.Popen(self.commands.shell,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=self.test_folder)
(stdout, stderr) = shell.communicate(
to_file_bytes("\n".join(shell_commands)))
stdout, stderr = decode_text(stdout), decode_text(stderr)
# Consistency checks
self.assertFalse(
stderr, "Running shell resulted in error, output:\n%s" % stdout)
env_before = _load_env_file(
os.path.join(self.test_folder, self.env_before))
env_after = _load_env_file(
os.path.join(self.test_folder, self.env_after))
there_was_ps1 = os.getenv("PS1")
# FIXME: Not the best behavior
# The deactivate sets PS1 always, but sometimes it didn't exist previously
if platform.system() == "Darwin" or not there_was_ps1:
env_after.pop(six.u("PS1"),
None) # TODO: FIXME: Needed for the test to pass
env_after.pop("PS1",
None) # TODO: FIXME: Needed for the test to pass
self.assertDictEqual(env_before,
env_after) # Environment restored correctly
return stdout, _load_env_file(
os.path.join(self.test_folder, self.env_activated))
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 install_multiple_configs_test(self):
folder = temp_folder()
save_files(folder, {
"subf/file.txt": "hello",
"subf2/file2.txt": "bye"
})
self.client.run('config install "%s" -sf=subf' % folder)
content = load(os.path.join(self.client.cache.conan_folder,
"file.txt"))
file2 = os.path.join(self.client.cache.conan_folder, "file2.txt")
self.assertEqual(content, "hello")
self.assertFalse(os.path.exists(file2))
self.client.run('config install "%s" -sf=subf2' % folder)
content = load(file2)
self.assertEqual(content, "bye")
save_files(folder, {
"subf/file.txt": "HELLO!!",
"subf2/file2.txt": "BYE!!"
})
self.client.run('config install')
content = load(os.path.join(self.client.cache.conan_folder,
"file.txt"))
self.assertEqual(content, "HELLO!!")
content = load(file2)
self.assertEqual(content, "BYE!!")
def setUp(self):
self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference, "123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
search_adapter = DiskSearchAdapter()
self.search_manager = DiskSearchManager(self.paths, search_adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
self.search_service = SearchService(authorizer, self.search_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
def setUp(self):
self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference, "123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
search_adapter = DiskSearchAdapter()
self.search_manager = DiskSearchManager(self.paths, search_adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
self.search_service = SearchService(authorizer, self.search_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
def test_error_package_xz(self):
server = TestServer()
ref = ConanFileReference.loads("Pkg/0.1@user/channel")
client = TestClient(servers={"default": server},
users={"default": [("lasote", "mypass")]})
export = server.paths.export(ref)
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
exports_sources = "*"
"""
save_files(export, {
"conanfile.py": conanfile,
"conanmanifest.txt": "1"
})
pkg_ref = PackageReference(ref,
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package = server.paths.package(pkg_ref)
save_files(
package, {
"conaninfo.txt": "#",
"conanmanifest.txt": "1",
"conan_package.txz": "#"
})
error = client.run("install Pkg/0.1@user/channel", ignore_error=True)
self.assertTrue(error)
self.assertIn(
"ERROR: This Conan version is not prepared to handle "
"'conan_package.txz' file format", client.out)
def save(self, files, path=None, clean_first=False):
""" helper metod, will store files in the current folder
param files: dict{filename: filecontents}
"""
path = path or self.current_folder
if clean_first:
shutil.rmtree(self.current_folder, ignore_errors=True)
save_files(path, files)
def save(self, files, path=None, clean_first=False):
""" helper metod, will store files in the current folder
param files: dict{filename: filecontents}
"""
path = path or self.current_folder
if clean_first:
shutil.rmtree(self.current_folder, ignore_errors=True)
save_files(path, files)
def test_install_registry_txt_error(self):
folder = temp_folder()
save_files(folder, {"registry.txt": "myrepo1 https://myrepourl.net False"})
self.client.run('config install "%s"' % folder)
self.assertIn("WARN: registry.txt has been deprecated. Migrating to remotes.json",
self.client.out)
self.client.run("remote list")
self.assertEqual("myrepo1: https://myrepourl.net [Verify SSL: False]\n", self.client.out)
def test_repo_layouts(self):
client = TestClient()
conanfile = textwrap.dedent("""
from conans import ConanFile
class Pkg(ConanFile):
pass
""")
layout_repo = textwrap.dedent("""
[includedirs]
include_{}
""")
layout_cache = textwrap.dedent("""
[{}:includedirs]
include_{}
""")
layout_folder = os.path.join(client.cache_folder, LAYOUTS_FOLDER)
ref_str = "mytool/0.1@user/testing"
save_files(
layout_folder, {
"layout_win_cache": layout_cache.format(ref_str, "win_cache"),
"layout_linux_cache": layout_cache.format(
ref_str, "linux_cache"),
"layout_win_cache2": layout_repo.format("win_cache2"),
"layout_linux_cache2": layout_repo.format("linux_cache2")
})
client.save({
"conanfile.py": conanfile,
"layout_win": layout_repo.format("win"),
"layout_linux": layout_repo.format("linux")
})
client.run("editable add . mytool/0.1@user/testing")
client2 = TestClient(client.cache_folder)
consumer = textwrap.dedent("""
[requires]
mytool/0.1@user/testing
""")
client2.save({"conanfile.txt": consumer})
client2.run("install . -g cmake")
self.assertIn("mytool/0.1@user/testing from user folder - Editable",
client2.out)
cmake = client2.load("conanbuildinfo.cmake")
include_dirs = re.search('set\(CONAN_INCLUDE_DIRS_MYTOOL "(.*)"\)',
cmake).group(1)
self.assertTrue(include_dirs.endswith("include"))
# Using the repo file layouts
for layout in ("win", "linux", "win_cache", "linux_cache",
"win_cache2", "linux_cache2"):
client.run("editable add . mytool/0.1@user/testing -l=layout_%s" %
layout)
client2.run("install . -g cmake")
self.assertIn(
"mytool/0.1@user/testing from user folder - Editable",
client2.out)
cmake = client2.load("conanbuildinfo.cmake")
include_dirs = re.search('set\(CONAN_INCLUDE_DIRS_MYTOOL "(.*)"\)',
cmake).group(1)
self.assertTrue(include_dirs.endswith("include_%s" % layout))
def _run_virtualenv(self, generator):
with environment_append({"PATH": [
self.ori_path,
]}):
# FIXME: I need this context because restore values for the 'deactivate' script are
# generated at the 'generator.content' and not when the 'activate' is called.
save_files(self.test_folder, generator.content)
# Generate the list of commands to execute
shell_commands = [
self.commands.dump_env.format(filename=self.env_before),
self.commands.find_program.format(
program="conan", variable="__conan_pre_path__"),
self.commands.find_program.format(
program=self.app, variable="__exec_pre_path__"),
self.commands.activate,
self.commands.dump_env.format(filename=self.env_activated),
self.commands.find_program.format(
program="conan", variable="__conan_env_path__"),
self.commands.find_program.format(
program=self.app, variable="__exec_env_path__"),
self.commands.deactivate,
self.commands.dump_env.format(filename=self.env_after),
self.commands.find_program.format(
program="conan", variable="__conan_post_path__"),
self.commands.find_program.format(
program=self.app, variable="__exec_post_path__"),
"",
]
# Execute
shell = subprocess.Popen(self.commands.shell,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=self.test_folder)
(stdout, stderr) = shell.communicate(
to_file_bytes("\n".join(shell_commands)))
stdout, stderr = decode_text(stdout), decode_text(stderr)
# Consistency checks
self.assertFalse(
stderr, "Running shell resulted in error, output:\n%s" % stdout)
env_before = _load_env_file(
os.path.join(self.test_folder, self.env_before))
env_after = _load_env_file(
os.path.join(self.test_folder, self.env_after))
if platform.system() == "Darwin":
env_after.pop(six.u("PS1"),
None) # TODO: FIXME: Needed for the test to pass
env_after.pop("PS1",
None) # TODO: FIXME: Needed for the test to pass
self.assertDictEqual(env_before,
env_after) # Environment restored correctly
return stdout, _load_env_file(
os.path.join(self.test_folder, self.env_activated))
def install_source_target_folders_test(self):
folder = temp_folder()
save_files(folder, {"subf/file.txt": "hello",
"subf/subf/file2.txt": "bye"})
self.client.run('config install "%s" -sf=subf -tf=newsubf' % folder)
content = load(os.path.join(self.client.cache_folder, "newsubf/file.txt"))
self.assertEqual(content, "hello")
content = load(os.path.join(self.client.cache_folder, "newsubf/subf/file2.txt"))
self.assertEqual(content, "bye")
def test_save_sources():
tmp_dir = temp_folder()
save_files(".", {DATA_YML: data, "hello.txt": "hello world!"})
FileServer()
download_sources(".", "0.2.0")
content = load(os.path.join(".", "hello.txt"))
assert (content == "hello world!")
def _create_profile_folder(self, folder=None):
folder = folder or temp_folder(path_with_spaces=False)
save_files(folder, {"settings.yml": settings_yml,
"remotes.txt": remotes,
"profiles/linux": linux_profile,
"profiles/windows": win_profile,
"config/conan.conf": conan_conf,
"pylintrc": "#Custom pylint"})
return folder
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 new(self, *args):
""" create a new package template conanfile.py and other optional files
"""
parser = argparse.ArgumentParser(description=self.new.__doc__,
prog="conan new",
formatter_class=RawTextHelpFormatter)
parser.add_argument("name",
help='Package name, e.g.: Poco/1.7.3@user/testing')
parser.add_argument(
"-t",
"--test",
action='store_true',
default=False,
help='Create test_package skeleton to test package')
parser.add_argument("-i",
"--header",
action='store_true',
default=False,
help='Create a headers only package')
parser.add_argument(
"-c",
"--pure_c",
action='store_true',
default=False,
help='Create a C language package only package (non-headers)')
args = parser.parse_args(*args)
root_folder = os.getcwd()
try:
name, version, user, channel = ConanFileReference.loads(args.name)
except:
raise ConanException("Bad parameter, please use full package name,"
"e.g: MyLib/1.2.3@user/testing")
from conans.client.new import (conanfile, conanfile_header,
test_conanfile, test_cmake, test_main)
if args.header:
files = {
"conanfile.py": conanfile_header.format(name=name,
version=version)
}
else:
files = {
"conanfile.py": conanfile.format(name=name, version=version)
}
if args.pure_c:
config = "\n def config(self):\n del self.settings.compiler.libcxx"
files["conanfile.py"] = files["conanfile.py"] + config
if args.test:
files["test_package/conanfile.py"] = test_conanfile.format(
name=name, version=version, user=user, channel=channel)
files["test_package/CMakeLists.txt"] = test_cmake
files["test_package/example.cpp"] = test_main
save_files(root_folder, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def setUp(self):
self.test_folder = temp_folder()
self.app = "executable"
self.ori_path = os.path.join(self.test_folder, "ori")
self.env_path = os.path.join(self.test_folder, "env")
program_candidates = {os.path.join(self.ori_path, self.app): "",
os.path.join(self.env_path, self.app): ""}
save_files(self.test_folder, program_candidates)
for p, _ in program_candidates.items():
os.chmod(os.path.join(self.test_folder, p), 0o755)
def save(self, files, path=None, clean_first=False):
""" helper metod, will store files in the current folder
param files: dict{filename: filecontents}
"""
path = path or self.current_folder
if clean_first:
shutil.rmtree(self.current_folder, ignore_errors=True)
files = {f: str(content) for f, content in files.items()}
save_files(path, files)
if not files:
mkdir(self.current_folder)
def _create_profile_folder(self, folder=None):
folder = folder or temp_folder(path_with_spaces=False)
save_files(folder, {"settings.yml": settings_yml,
"remotes.txt": remotes,
"profiles/linux": linux_profile,
"profiles/windows": win_profile,
"config/conan.conf": conan_conf,
"pylintrc": "#Custom pylint",
"python/myfuncs.py": myfuncpy,
"python/__init__.py": ""})
return folder
def test_dont_duplicate_configs(self):
folder = temp_folder()
save_files(folder, {"subf/file.txt": "hello"})
self.client.run('config install "%s" -sf=subf' % folder)
self.client.run('config install "%s" -sf=subf' % folder)
content = load(self.client.cache.config_install_file)
self.assertEqual(1, content.count("subf"))
self.client.run('config install "%s" -sf=other' % folder)
content = load(self.client.cache.config_install_file)
self.assertEqual(1, content.count("subf"))
self.assertEqual(1, content.count("other"))
def create_local_git_repo(files, branch=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"')
return tmp.replace("\\", "/"), git.get_revision()
def test_install_registry_json_error(self):
folder = temp_folder()
registry_json = {"remotes": [{"url": "https://server.conan.io",
"verify_ssl": True,
"name": "conan.io"
}]}
save_files(folder, {"registry.json": json.dumps(registry_json)})
self.client.run('config install "%s"' % folder)
self.assertIn("WARN: registry.json has been deprecated. Migrating to remotes.json",
self.client.out)
self.client.run("remote list")
self.assertEqual("conan.io: https://server.conan.io [Verify SSL: True]\n", self.client.out)
def test_config_fails_no_storage(self):
folder = temp_folder(path_with_spaces=False)
save_files(folder, {"remotes.txt": remotes})
client = TestClient()
client.save({"conanfile.py": GenConanfile()})
client.run("create . pkg/1.0@")
conf = load(client.cache.conan_conf_path)
conf = conf.replace("path = ./data", "")
save(client.cache.conan_conf_path, conf)
client.run('config install "%s"' % folder)
client.run("remote list")
self.assertIn("myrepo1: https://myrepourl.net [Verify SSL: False]", client.out)
self.assertIn("my-repo-2: https://myrepo2.com [Verify SSL: True]", client.out)
def test_search(self):
""" check the dict is returned by get_packages_info service
"""
# Creating and saving conans, packages, and conans.vars
conan_ref2 = ConanFileReference("openssl", "3.0", "lasote", "stable")
conan_ref3 = ConanFileReference("Assimp", "1.10", "fenix", "stable")
conan_ref4 = ConanFileReference("assimpFake", "0.1", "phil", "stable")
package_ref2 = PackageReference(conan_ref2, "12345587754")
package_ref3 = PackageReference(conan_ref3, "77777777777")
conan_vars = """
[options]
use_Qt=%s
"""
conan_vars1 = conan_vars % "True"
conan_vars2 = conan_vars % "False"
conan_vars3 = conan_vars % "True"
save_files(self.paths.package(self.package_reference), {CONANINFO: conan_vars1})
save_files(self.paths.package(package_ref2), {CONANINFO: conan_vars2})
save_files(self.paths.package(package_ref3), {CONANINFO: conan_vars3})
save_files(self.paths.export(conan_ref4), {"dummy.txt": "//"})
info = self.service.search()
expected = {self.conan_reference: {"123123123": ConanInfo.loads("[options]\nuse_Qt=True")},
conan_ref2: {"12345587754": ConanInfo.loads("[options]\nuse_Qt=False")},
conan_ref3: {"77777777777": ConanInfo.loads("[options]\nuse_Qt=True")},
conan_ref4: {}}
self.assertEqual(expected, info)
info = self.service.search(pattern="Assimp*", ignorecase=False)
self.assertEqual(info, {conan_ref3: {"77777777777":
ConanInfo.loads("[options]\nuse_Qt=True")}})
def test_search(self):
""" check the dict is returned by get_packages_info service
"""
# Creating and saving conans, packages, and conans.vars
conan_ref2 = ConanFileReference("openssl", "3.0", "lasote", "stable")
conan_ref3 = ConanFileReference("Assimp", "1.10", "fenix", "stable")
conan_ref4 = ConanFileReference("assimpFake", "0.1", "phil", "stable")
package_ref2 = PackageReference(conan_ref2, "12345587754")
package_ref3 = PackageReference(conan_ref3, "77777777777")
conan_vars = """
[options]
use_Qt=%s
"""
conan_vars1 = conan_vars % "True"
conan_vars2 = conan_vars % "False"
conan_vars3 = conan_vars % "True"
save_files(self.server_store.package(self.package_reference),
{CONANINFO: conan_vars1})
save_files(self.server_store.package(package_ref2),
{CONANINFO: conan_vars2})
save_files(self.server_store.package(package_ref3),
{CONANINFO: conan_vars3})
save_files(self.server_store.export(conan_ref4), {"dummy.txt": "//"})
info = self.search_service.search()
expected = [conan_ref3, conan_ref4, self.conan_reference, conan_ref2]
self.assertEqual(expected, info)
info = self.search_service.search(pattern="Assimp*", ignorecase=False)
self.assertEqual(info, [conan_ref3])
info = self.search_service.search_packages(conan_ref2, None)
self.assertEqual(
info, {
'12345587754': {
'full_requires': [],
'options': {
'use_Qt': 'False'
},
'settings': {},
'recipe_hash': None
}
})
info = self.search_service.search_packages(conan_ref3, None)
self.assertEqual(
info, {
'77777777777': {
'full_requires': [],
'options': {
'use_Qt': 'True'
},
'settings': {},
'recipe_hash': None
}
})
def test_error_xz(self):
server = TestServer()
ref = ConanFileReference.loads("Pkg/0.1@user/channel")
export = server.paths.export(ref)
save_files(export, {
"conanfile.py": "#",
"conanmanifest.txt": "#",
"conan_export.txz": "#"
})
client = TestClient(servers={"default": server},
users={"default": [("lasote", "mypass")]})
error = client.run("install Pkg/0.1@user/channel", ignore_error=True)
self.assertTrue(error)
self.assertIn(
"ERROR: This Conan version is not prepared to handle "
"'conan_export.txz' file format", client.out)
def new(self, name, header=False, pure_c=False, test=False, exports_sources=False, bare=False, cwd=None,
visual_versions=None, linux_gcc_versions=None, linux_clang_versions=None, osx_clang_versions=None,
shared=None, upload_url=None, gitignore=None):
from conans.client.new import get_files
cwd = prepare_cwd(cwd)
files = get_files(name, header=header, pure_c=pure_c, test=test,
exports_sources=exports_sources, bare=bare,
visual_versions=visual_versions,
linux_gcc_versions=linux_gcc_versions,
linux_clang_versions=linux_clang_versions,
osx_clang_versions=osx_clang_versions, shared=shared,
upload_url=upload_url, gitignore=gitignore)
save_files(cwd, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def new(self, *args):
""" create a new package template conanfile.py and other optional files
"""
parser = argparse.ArgumentParser(description=self.new.__doc__, prog="conan new",
formatter_class=RawTextHelpFormatter)
parser.add_argument("name", help='Package name, e.g.: Poco/1.7.3@user/testing')
parser.add_argument("-t", "--test", action='store_true', default=False,
help='Create test_package skeleton to test package')
parser.add_argument("-i", "--header", action='store_true', default=False,
help='Create a headers only package')
parser.add_argument("-c", "--pure_c", action='store_true', default=False,
help='Create a C language package only package (non-headers)')
args = parser.parse_args(*args)
root_folder = os.getcwd()
try:
name, version, user, channel = ConanFileReference.loads(args.name)
pattern = re.compile('[\W_]+')
package_name = pattern.sub('', name).capitalize()
except:
raise ConanException("Bad parameter, please use full package name,"
"e.g: MyLib/1.2.3@user/testing")
from conans.client.new import (conanfile, conanfile_header, test_conanfile, test_cmake,
test_main)
if args.header:
files = {"conanfile.py": conanfile_header.format(name=name, version=version,
package_name=package_name)}
else:
files = {"conanfile.py": conanfile.format(name=name, version=version,
package_name=package_name)}
if args.pure_c:
config = "\n def config(self):\n del self.settings.compiler.libcxx"
files["conanfile.py"] = files["conanfile.py"] + config
if args.test:
files["test_package/conanfile.py"] = test_conanfile.format(name=name, version=version,
user=user, channel=channel,
package_name=package_name)
files["test_package/CMakeLists.txt"] = test_cmake
files["test_package/example.cpp"] = test_main
save_files(root_folder, files)
for f in sorted(files):
self._user_io.out.success("File saved: %s" % f)
def remove_test(self):
conan_ref2 = ConanFileReference("OpenCV", "3.0", "lasote", "stable")
conan_ref3 = ConanFileReference("Assimp", "1.10", "lasote", "stable")
package_ref2 = PackageReference(conan_ref2, "12345587754")
package_ref3 = PackageReference(conan_ref3, "77777777777")
save_files(self.paths.export(conan_ref2), {"fake.txt": "//fake"})
save_files(self.paths.package(package_ref2), {"fake.txt": "//fake"})
save_files(self.paths.package(package_ref3), {"fake.txt": "//fake"})
# Delete all the conans folder
self.service.remove_conanfile(self.conan_reference)
conan_path = self.paths.conan(self.conan_reference)
self.assertFalse(os.path.exists(conan_path))
# Delete one package
self.service.remove_packages(conan_ref3, ["77777777777"])
package_folder_3 = self.paths.package(PackageReference(conan_ref3, '077777777777'))
self.assertFalse(os.path.exists(package_folder_3))
# Raise an exception
self.assertRaises(NotFoundException,
self.service.remove_conanfile,
ConanFileReference("Fake", "1.0", "lasote", "stable"))
def test_search(self):
""" check the dict is returned by get_packages_info service
"""
# Creating and saving conans, packages, and conans.vars
conan_ref2 = ConanFileReference("openssl", "3.0", "lasote", "stable")
conan_ref3 = ConanFileReference("Assimp", "1.10", "fenix", "stable")
conan_ref4 = ConanFileReference("assimpFake", "0.1", "phil", "stable")
package_ref2 = PackageReference(conan_ref2, "12345587754")
package_ref3 = PackageReference(conan_ref3, "77777777777")
conan_vars = """
[options]
use_Qt=%s
"""
conan_vars1 = conan_vars % "True"
conan_vars2 = conan_vars % "False"
conan_vars3 = conan_vars % "True"
save_files(self.paths.package(self.package_reference), {CONANINFO: conan_vars1})
save_files(self.paths.package(package_ref2), {CONANINFO: conan_vars2})
save_files(self.paths.package(package_ref3), {CONANINFO: conan_vars3})
save_files(self.paths.export(conan_ref4), {"dummy.txt": "//"})
info = self.search_service.search()
expected = [conan_ref3, conan_ref4, self.conan_reference, conan_ref2]
self.assertEqual(expected, info)
info = self.search_service.search(pattern="Assimp*", ignorecase=False)
self.assertEqual(info, [conan_ref3])
info = self.search_service.search_packages(conan_ref2, None)
self.assertEqual(info, {'12345587754': {'full_requires': [],
'options': {'use_Qt': 'False'},
'settings': {},
'recipe_hash': None}})
info = self.search_service.search_packages(conan_ref3, None)
self.assertEqual(info, {'77777777777': {'full_requires': [],
'options': {'use_Qt': 'True'},
'settings': {},
'recipe_hash': None}})
