def invalid_settings_test4(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({CONANFILE: content})
client.run("install . -s os=ChromeOS --build missing",
assert_error=True)
self.assertIn(
bad_value_msg("settings.os", "ChromeOS", [
'Android', 'Arduino', 'FreeBSD', 'Linux', 'Macos', 'SunOS',
'Windows', 'WindowsStore', 'iOS', 'tvOS', 'watchOS'
]), str(client.user_io.out))
# Now add new settings to config and try again
config = load(client.client_cache.settings_path)
config = config.replace(
"Windows:%s" % os.linesep,
"Windows:%s ChromeOS:%s" % (os.linesep, os.linesep))
save(client.client_cache.settings_path, config)
client.run("install . -s os=ChromeOS --build missing")
self.assertIn('Generated conaninfo.txt', str(client.user_io.out))
# Settings is None
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = None
"""
client.save({CONANFILE: content})
client.run("install . --build missing")
self.assertIn('Generated conaninfo.txt', str(client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
# Settings is {}
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {}
"""
client.save({CONANFILE: content})
client.run("install . --build missing")
self.assertIn('Generated conaninfo.txt', str(client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
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 invalid_settings_test4(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=ChromeOS --build missing",
ignore_error=True)
self.assertIn(
bad_value_msg(
"settings.os", "ChromeOS",
['Android', 'FreeBSD', 'Linux', 'Macos', 'Windows', 'iOS']),
str(self.client.user_io.out))
# Now add new settings to config and try again
config = load(self.client.paths.settings_path)
config = config.replace("Windows,", "Windows, ChromeOS,")
save(self.client.paths.settings_path, config)
self.client.run("install -s os=ChromeOS --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
# Settings is None
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = None
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
# Settings is {}
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {}
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
def invalid_settings_test4(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install . -s os=ChromeOS --build missing", ignore_error=True)
self.assertIn(bad_value_msg("settings.os", "ChromeOS",
['Android', 'Arduino', 'FreeBSD', 'Linux', 'Macos', 'SunOS', 'Windows',
'WindowsStore', 'iOS', 'tvOS', 'watchOS']),
str(self.client.user_io.out))
# Now add new settings to config and try again
config = load(self.client.paths.settings_path)
config = config.replace("Windows:%s" % os.linesep,
"Windows:%s ChromeOS:%s" % (os.linesep, os.linesep))
save(self.client.paths.settings_path, config)
self.client.run("install . -s os=ChromeOS --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
# Settings is None
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = None
"""
self.client.save({CONANFILE: content})
self.client.run("install . --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
# Settings is {}
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {}
"""
self.client.save({CONANFILE: content})
self.client.run("install . --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
def complete_build_flow_test(self):
"""In local user folder"""
client = TestClient()
command = os.sep.join([".", "bin", "say_hello"])
for pure_c in (False, True):
for install, lang, static in [
("install", 0, True), ("install -o language=1", 1, True),
("install -o language=1 -o static=False", 1, False),
("install -o static=False", 0, False)
]:
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0",
"0.1",
dll_export=dll_export,
pure_c=pure_c)
client.save(files, clean_first=True)
client.run(install)
time.sleep(
1) # necessary so the conaninfo.txt is flushed to disc
client.run('build')
client.runner(command, cwd=client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder,
CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def get_package_info_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads("conan3/1.0.0@private_user/testing")
self._upload_recipe(conan_reference)
# Upload an package
package_reference = PackageReference(conan_reference, "1F23223EFDA")
conan_info = """[settings]
arch=x86_64
compiler=gcc
os=Linux
[options]
386=False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
self._upload_package(package_reference, {CONANINFO: conan_info})
# Get the package info
info = self.api.get_package_info(package_reference)
self.assertIsInstance(info, ConanInfo)
self.assertEquals(info, ConanInfo.loads(conan_info))
def complete_build_flow_test(self):
"""In local user folder"""
client = TestClient()
command = os.sep.join([".", "bin", "say_hello"])
for install, lang, static in [("install", 0, True),
("install -o language=1", 1, True),
("install -o language=1 -o static=False", 1, False),
("install -o static=False", 0, False)]:
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export)
client.save(files)
client.run(install)
time.sleep(1) # necessary so the conaninfo.txt is flushed to disc
client.run('build')
client.runner(command, client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def _get_local_infos_min(server_store, ref, look_in_all_rrevs):
result = {}
rrevs = server_store.get_recipe_revisions(ref) if look_in_all_rrevs else [
None
]
for rrev in rrevs:
new_ref = ref.copy_with_rev(rrev.revision) if rrev else ref
subdirs = list_folder_subdirs(server_store.packages(new_ref), level=1)
for package_id in subdirs:
if package_id in result:
continue
# Read conaninfo
try:
pref = PackageReference(new_ref, package_id)
revision_entry = server_store.get_last_package_revision(pref)
if not revision_entry:
raise NotFoundException("")
pref = PackageReference(new_ref, package_id,
revision_entry.revision)
info_path = os.path.join(server_store.package(pref), CONANINFO)
if not os.path.exists(info_path):
raise NotFoundException("")
conan_info_content = load(info_path)
info = ConanInfo.loads(conan_info_content)
conan_vars_info = info.serialize_min()
result[package_id] = conan_vars_info
except Exception as exc: # FIXME: Too wide
logger.error("Package %s has no ConanInfo file" % str(pref))
if str(exc):
logger.error(str(exc))
return result
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_recipe(conan_reference1)
# Upload a package
conan_info = """[settings]
arch=x86_64
compiler=gcc
os=Linux
[options]
386=False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_recipe(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search_packages(conan_reference1, None)
self.assertEqual(ConanInfo.loads(conan_info).serialize_min(), info["1F23223EFDA"])
# Search packages
results = self.api.search("HelloOnly*", ignorecase=False)
self.assertEqual(results, [conan_reference1])
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@lasote/stable", "private")],
static=False)
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello3", "0.1", ["Hello1/0.1@lasote/stable"])
client.save(files3)
client.run('install . --build missing')
client.run('build .')
# assert Hello3 only depends on Hello2, and Hello1
build_info_cmake = load(os.path.join(client.current_folder, BUILD_INFO_CMAKE))
# Ensure it does not depend on Hello0 to build, as private in dlls
self.assertNotIn("Hello0", repr(build_info_cmake))
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0'],
str(client.user_io.out).splitlines()[-3:])
conan_info = ConanInfo.loads(load(os.path.join(client.current_folder, CONANINFO)))
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
# Try to upload and reuse the binaries
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
client2.save(files3)
client2.run("install .")
self.assertNotIn("Package installed in Hello0/0.1", client2.user_io.out)
self.assertNotIn("Building", client2.user_io.out)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0'],
str(client2.user_io.out).splitlines()[-3:])
# Issue 79, fixing private deps from current project
files3 = cpp_hello_conan_files("Hello3", "0.2", ["Hello1/0.1@lasote/stable",
("Hello0/0.1@lasote/stable", "private")],
language=1)
client2.save(files3, clean_first=True)
client2.run('install . -o language=1 --build missing')
client2.run('build .')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual(['Hola Hello3', 'Hola Hello1',
'Hola Hello0', 'Hola Hello0'],
str(client2.user_io.out).splitlines()[-4:])
def _get_local_infos_min(paths, reference, v2_compatibility_mode=False):
result = {}
if not reference.revision and v2_compatibility_mode:
recipe_revisions = paths.get_recipe_revisions(reference)
else:
recipe_revisions = [reference]
for recipe_revision in recipe_revisions:
packages_path = paths.packages(recipe_revision)
subdirs = list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
if package_id in result:
continue
# Read conaninfo
try:
package_reference = PackageReference(reference, package_id)
info_path = os.path.join(paths.package(package_reference,
short_paths=None), CONANINFO)
if not os.path.exists(info_path):
raise NotFoundException("")
conan_info_content = load(info_path)
info = ConanInfo.loads(conan_info_content)
conan_vars_info = info.serialize_min()
result[package_id] = conan_vars_info
except Exception as exc:
logger.error("Package %s has no ConanInfo file" % str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def test_serialize(self):
info = ConanInfo.loads(info_text)
min_serial = info.serialize_min()
expected = {
'full_requires': [
'bzip2/1.0.6@lasote/stable:c6c01ee5ea2cf4af63e7b83b722b0a2d90640641',
'zlib/1.2.8@lasote/stable:2dec3996ef8de7edb0304eaf4efdd96a0477d3a3'
],
'options': {
'shared': 'False',
'fPIC': 'True',
'header_only': 'False'
},
'recipe_hash':
"asdasdasd",
'settings': {
'arch': 'x86_64',
'compiler.libcxx': 'libstdc++11',
'compiler.version': '5.2',
'os': 'Linux',
'build_type': 'Debug',
'compiler': 'gcc'
}
}
self.assertEquals(min_serial, expected)
dump = info.dumps()
self.assertEquals(dump, info_text)
def get_package_info(self, pref, headers):
url = self.router.package_info(pref)
cache = (pref.revision != DEFAULT_REVISION_V1)
content = self._get_remote_file_contents(url,
use_cache=cache,
headers=headers)
return ConanInfo.loads(decode_text(content))
def get_package_info_test(self):
# Upload a conans
conan_reference = ConanFileReference.loads(
"conan3/1.0.0@private_user/testing")
self._upload_recipe(conan_reference)
# Upload an package
package_reference = PackageReference(conan_reference, "1F23223EFDA")
conan_info = """[settings]
arch=x86_64
compiler=gcc
os=Linux
[options]
386=False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
self._upload_package(package_reference, {CONANINFO: conan_info})
# Get the package info
info = self.api.get_package_info(package_reference)
self.assertIsInstance(info, ConanInfo)
self.assertEquals(info, ConanInfo.loads(conan_info))
def _get_local_infos_min(client_cache, reference):
result = {}
packages_path = client_cache.packages(reference)
subdirs = list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
# Read conaninfo
try:
package_reference = PackageReference(reference, package_id)
info_path = os.path.join(
client_cache.package(package_reference, short_paths=None),
CONANINFO)
if not os.path.exists(info_path):
raise NotFoundException("")
conan_info_content = load(info_path)
metadata = client_cache.load_metadata(package_reference.conan)
recipe_revision = metadata.packages[package_id].recipe_revision
info = ConanInfo.loads(conan_info_content)
if reference.revision and recipe_revision and recipe_revision != reference.revision:
continue
conan_vars_info = info.serialize_min()
result[package_id] = conan_vars_info
except Exception as exc:
logger.error("Package %s has no ConanInfo file" %
str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def _get_local_infos_min(self, reference):
result = {}
packages_path = self._paths.packages(reference)
subdirs = self._adapter.list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
# Read conaninfo
try:
package_reference = PackageReference(reference, package_id)
info_path = self._adapter.join_paths(
self._paths.package(package_reference, short_paths=None),
CONANINFO)
if not self._adapter.path_exists(info_path):
raise NotFoundException("")
conan_info_content = self._adapter.load(info_path)
conan_vars_info = ConanInfo.loads(
conan_info_content).serialize_min()
result[package_id] = conan_vars_info
except Exception as exc:
logger.error("Package %s has no ConanInfo file" %
str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def build(tester, cmd, static, pure_c, use_cmake, lang):
client = TestClient()
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0",
"0.1",
dll_export=dll_export,
pure_c=pure_c,
use_cmake=use_cmake)
client.save(files)
client.run(cmd)
client.run('build .')
ld_path = ("LD_LIBRARY_PATH=`pwd`"
if not static and not platform.system() == "Windows" else "")
if platform.system() == "Darwin":
ld_path += ' DYLD_LIBRARY_PATH="%s"' % os.path.join(
client.current_folder, 'lib')
command = os.sep.join([".", "bin", "say_hello"])
client.runner("%s %s" % (ld_path, command), cwd=client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
tester.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
tester.assertTrue(conan_info.full_options.language == lang)
if static:
tester.assertTrue(conan_info.full_options.static)
else:
tester.assertFalse(conan_info.full_options.static)
def search_packages(self, reference, query):
""" Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param conan_ref: ConanFileReference object
"""
# GET PROPERTIES FROM QUERY
properties = get_properties_from_query(query)
logger.debug("SEARCH PACKAGE PROPERTIES: %s" % properties)
result = {}
packages_path = self._paths.packages(reference)
subdirs = self._adapter.list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
try:
package_reference = PackageReference(reference, package_id)
info_path = self._adapter.join_paths(
self._paths.package(package_reference, short_paths=None),
CONANINFO)
if not self._adapter.path_exists(info_path):
raise NotFoundException("")
conan_info_content = self._adapter.load(info_path)
conan_vars_info = ConanInfo.loads(conan_info_content)
if not self._filtered_by_properties(conan_vars_info,
properties):
result[package_id] = conan_vars_info.serialize_min()
except Exception as exc:
logger.error("Package %s has not ConanInfo file" %
str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def search_packages(self, reference, query):
""" Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param conan_ref: ConanFileReference object
"""
# GET PROPERTIES FROM QUERY
properties = get_properties_from_query(query)
logger.debug("SEARCH PACKAGE PROPERTIES: %s" % properties)
result = {}
packages_path = self._paths.packages(reference)
subdirs = self._adapter.list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
try:
package_reference = PackageReference(reference, package_id)
info_path = self._adapter.join_paths(self._paths.package(package_reference,
short_paths=None),
CONANINFO)
if not self._adapter.path_exists(info_path, self._paths.store):
raise NotFoundException("")
conan_info_content = self._adapter.load(info_path)
conan_vars_info = ConanInfo.loads(conan_info_content)
if not self._filtered_by_properties(conan_vars_info, properties):
result[package_id] = conan_vars_info.serialize_min()
except Exception as exc:
logger.error("Package %s has not ConanInfo file" % str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def _single_conan_search(self, conan_ref):
""" Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param conan_ref: ConanFileReference object
"""
result = {}
packages_path = self.paths.packages(conan_ref)
subdirs = self._file_adapter.list_folder_subdirs(packages_path,
level=1)
for package_id in subdirs:
try:
package_reference = PackageReference(conan_ref, package_id)
info_path = os.path.join(self.paths.package(package_reference),
CONANINFO)
conan_info_content = self._file_adapter.get_file(info_path)
conan_vars_info = ConanInfo.loads(conan_info_content)
result[package_id] = conan_vars_info
except Exception as exc:
logger.error("Package %s has not ConanInfo file" %
str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_recipe(conan_reference1)
# Upload a package
conan_info = """[settings]
arch=x86_64
compiler=gcc
os=Linux
[options]
386=False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_recipe(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search_packages(conan_reference1, None)
self.assertEqual(ConanInfo.loads(conan_info).serialize_min(), info["1F23223EFDA"])
# Search packages
results = self.api.search("HelloOnly*", ignorecase=False)
self.assertEqual(results, [conan_reference1])
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 load_conaninfo(lib):
# Read the LIB_A conaninfo
packages_path = client.client_cache.packages(
ConanFileReference.loads("LIB_%s/1.0@lasote/stable" % lib))
package_path = os.path.join(packages_path,
os.listdir(packages_path)[0])
info = ConanInfo.loads(load(os.path.join(package_path, CONANINFO)))
return info
def test_conaninfo_filtered(self):
client = TestClient()
# Try injecting some package level ENV in the install, but without priority
self._export(client, "A", [], {}, {"VAR1": "900", "VAR2": "23", "VAR3": "-23"})
self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
self._export(client, "B2", ["A"], {}, {"VAR1": "800_2", "VAR2": "24_2"})
self._export(client, "C", ["B", "B2"], {"VAR3": "bestvalue"}, {"VAR1": "700"})
def load_conaninfo(lib):
# Read the LIB_A conaninfo
packages_path = client.client_cache.packages(ConanFileReference.loads("LIB_%s/1.0@lasote/stable" % lib))
package_path = os.path.join(packages_path, os.listdir(packages_path)[0])
info = ConanInfo.loads(load(os.path.join(package_path, CONANINFO)))
return info
# Test "A" conaninfo, should filter the FAKE_LIB
client.save({"conanfile.py": reuse})
client.run("install . --build missing -e LIB_A:VAR3=override "
"-e GLOBAL=99 -e FAKE_LIB:VAR1=-90 -e LIB_B:VAR2=222 "
"-e LIB_B2:NEWVAR=VALUE -e VAR3=[newappend]")
info = load_conaninfo("A")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({"VAR3": "override", "GLOBAL": "99"}, {}))
self.assertEquals(info.env_values.env_dicts(""), ({'GLOBAL': '99'}, {'VAR3': ['newappend']}))
info = load_conaninfo("B")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({'GLOBAL': '99', 'VAR3': "override"},
{'VAR2': ['23'], 'VAR1': ['900']}))
self.assertEquals(info.env_values.env_dicts("LIB_B"), ({'GLOBAL': '99', "VAR2": "222"},
{'VAR3': ['newappend', '-23'], 'VAR1': ["900"]}))
info = load_conaninfo("B2")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({'GLOBAL': '99', 'VAR3': 'override'},
{'VAR2': ['23'], 'VAR1': ['900']}))
self.assertEquals(info.env_values.env_dicts("LIB_B2"), ({'GLOBAL': '99', 'NEWVAR': "VALUE"},
{'VAR2': ['23'], 'VAR1': ['900'],
'VAR3': ['newappend', '-23']}))
info = load_conaninfo("C")
self.assertEquals(info.env_values.env_dicts("LIB_B2"), ({'GLOBAL': '99', 'NEWVAR': "VALUE"},
{'VAR3': ['newappend', '-23'],
'VAR1': ['800', '800_2', '900'],
'VAR2': ['24', '24_2', '23']}))
self.assertEquals(info.env_values.env_dicts("LIB_C"), ({'GLOBAL': '99'},
{'VAR2': ['24', '24_2', '23'],
'VAR1': ['800', '800_2', '900'],
'VAR3': ['newappend', "-23"]}))
# Now check the info for the project
info = ConanInfo.loads(load(os.path.join(client.current_folder, CONANINFO)))
self.assertEquals(info.env_values.env_dicts("PROJECT"), ({'GLOBAL': '99'},
{'VAR2': ['24', '24_2', '23'],
'VAR1': ['700', '800', '800_2', '900'],
'VAR3': ['newappend', 'bestvalue']}))
def test_conaninfo_filtered(self):
client = TestClient()
# Try injecting some package level ENV in the install, but without priority
self._export(client, "A", [], {}, {"VAR1": "900", "VAR2": "23", "VAR3": "-23"})
self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
self._export(client, "B2", ["A"], {}, {"VAR1": "800_2", "VAR2": "24_2"})
self._export(client, "C", ["B", "B2"], {"VAR3": "bestvalue"}, {"VAR1": "700"})
def load_conaninfo(lib):
# Read the LIB_A conaninfo
packages_path = client.client_cache.packages(ConanFileReference.loads("LIB_%s/1.0@lasote/stable" % lib))
package_path = os.path.join(packages_path, os.listdir(packages_path)[0])
info = ConanInfo.loads(load(os.path.join(package_path, CONANINFO)))
return info
# Test "A" conaninfo, should filter the FAKE_LIB
client.save({"conanfile.py": reuse})
client.run("install . --build missing -e LIB_A:VAR3=override "
"-e GLOBAL=99 -e FAKE_LIB:VAR1=-90 -e LIB_B:VAR2=222 "
"-e LIB_B2:NEWVAR=VALUE -e VAR3=[newappend]")
info = load_conaninfo("A")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({"VAR3": "override", "GLOBAL": "99"}, {}))
self.assertEquals(info.env_values.env_dicts(""), ({'GLOBAL': '99'}, {'VAR3': ['newappend']}))
info = load_conaninfo("B")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({'GLOBAL': '99', 'VAR3': "override"},
{'VAR2': ['23'], 'VAR1': ['900']}))
self.assertEquals(info.env_values.env_dicts("LIB_B"), ({'GLOBAL': '99', "VAR2": "222"},
{'VAR3': ['newappend', '-23'], 'VAR1': ["900"]}))
info = load_conaninfo("B2")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({'GLOBAL': '99', 'VAR3': 'override'},
{'VAR2': ['23'], 'VAR1': ['900']}))
self.assertEquals(info.env_values.env_dicts("LIB_B2"), ({'GLOBAL': '99', 'NEWVAR': "VALUE"},
{'VAR2': ['23'], 'VAR1': ['900'],
'VAR3': ['newappend', '-23']}))
info = load_conaninfo("C")
self.assertEquals(info.env_values.env_dicts("LIB_B2"), ({'GLOBAL': '99', 'NEWVAR': "VALUE"},
{'VAR3': ['newappend', '-23'],
'VAR1': ['800', '800_2', '900'],
'VAR2': ['24', '24_2', '23']}))
self.assertEquals(info.env_values.env_dicts("LIB_C"), ({'GLOBAL': '99'},
{'VAR2': ['24', '24_2', '23'],
'VAR1': ['800', '800_2', '900'],
'VAR3': ['newappend', "-23"]}))
# Now check the info for the project
info = ConanInfo.loads(load(os.path.join(client.current_folder, CONANINFO)))
self.assertEquals(info.env_values.env_dicts("PROJECT"), ({'GLOBAL': '99'},
{'VAR2': ['24', '24_2', '23'],
'VAR1': ['700', '800', '800_2', '900'],
'VAR3': ['newappend', 'bestvalue']}))
def settings_as_a_str_test(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.client.run("install -s os=Linux --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Linux")
def settings_as_a_str_test(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.client.run("install -s os=Linux --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Linux")
def test_serialize(self):
info = ConanInfo.loads(info_text)
min_serial = info.serialize_min()
expected = {'full_requires':
['bzip2/1.0.6@lasote/stable:c6c01ee5ea2cf4af63e7b83b722b0a2d90640641',
'zlib/1.2.8@lasote/stable:2dec3996ef8de7edb0304eaf4efdd96a0477d3a3'],
'options': {'shared': 'False', 'fPIC': 'True', 'header_only': 'False'},
'settings': {'arch': 'x86_64', 'compiler.libcxx': 'libstdc++11',
'compiler.version': '5.2', 'os': 'Linux',
'build_type': 'Debug', 'compiler': 'gcc'}}
self.assertEquals(min_serial, expected)
def test_settings_as_a_str(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({CONANFILE: content})
client.run("install . -s os=Windows --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(client.load(CONANINFO))
self.assertEqual(conan_info.settings.os, "Windows")
client.run("install . -s os=Linux --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(client.load(CONANINFO))
self.assertEqual(conan_info.settings.os, "Linux")
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_conan(conan_reference1)
# Upload an package
conan_info = """[settings]
arch: x86_64
compiler: gcc
os: Linux
[options]
386: False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_conan(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search("helloonly*")
expected_info1 = {"1F23223EFDA": ConanInfo.loads(conan_info)}
expected_info2 = {}
self.assertEqual(expected_info1, info[conan_reference1])
self.assertEqual(expected_info2, info[conan_reference2])
# Get the info about this ConanFileReference
info = self.api.search("HelloOnly*", ignorecase=False)
expected_info = {"1F23223EFDA": ConanInfo.loads(conan_info)}
self.assertEqual({conan_reference1: expected_info}, info)
def search_test(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
conan_reference1 = ConanFileReference.loads(conan_name1)
self._upload_conan(conan_reference1)
# Upload an package
conan_info = """[settings]
arch: x86_64
compiler: gcc
os: Linux
[options]
386: False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
package_reference = PackageReference(conan_reference1, "1F23223EFDA")
self._upload_package(package_reference, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
conan_reference2 = ConanFileReference.loads(conan_name2)
self._upload_conan(conan_reference2)
# Get the info about this ConanFileReference
info = self.api.search("helloonly*")
expected_info1 = {"1F23223EFDA": ConanInfo.loads(conan_info)}
expected_info2 = {}
self.assertEqual(expected_info1, info[conan_reference1])
self.assertEqual(expected_info2, info[conan_reference2])
# Get the info about this ConanFileReference
info = self.api.search("HelloOnly*", ignorecase=False)
expected_info = {"1F23223EFDA": ConanInfo.loads(conan_info)}
self.assertEqual({conan_reference1: expected_info}, info)
def test_search(self):
# Upload a conan1
conan_name1 = "HelloOnly/0.10@private_user/testing"
ref1 = ConanFileReference.loads(conan_name1)
self._upload_recipe(ref1)
# Upload a package
conan_info = """[settings]
arch=x86_64
compiler=gcc
os=Linux
[options]
386=False
[requires]
Hello
Bye/2.9
Say/2.1@user/testing
Chat/2.1@user/testing:SHA_ABC
"""
pref = PackageReference(ref1, "1F23223EFDA")
self._upload_package(pref, {CONANINFO: conan_info})
# Upload a conan2
conan_name2 = "helloonlyToo/2.1@private_user/stable"
ref2 = ConanFileReference.loads(conan_name2)
self._upload_recipe(ref2)
# Get the info about this ConanFileReference
info = self.api.search_packages(ref1)
self.assertEqual(ConanInfo.loads(conan_info).serialize_min(),
ConanInfo.loads(info["1F23223EFDA"]["content"]).serialize_min())
# Search packages
results = self.api.search("HelloOnly*", ignorecase=False)
results = [r.copy_clear_rev() for r in results]
self.assertEqual(results, [ref1])
def search_packages(self, remote, ref, query):
packages = self._call_remote(remote, "search_packages", ref)
# Avoid serializing conaninfo in server side
packages = {
pid: ConanInfo.loads(data["content"]).serialize_min()
if "content" in data else data
for pid, data in packages.items()
}
# Filter packages without recipe_hash, those are 1.X packages, the 2.0 are disregarded
packages = {
pid: data
for pid, data in packages.items() if data.get("recipe_hash")
}
packages = filter_packages(query, packages)
return packages
def get_package_info(self, package_reference):
"""Gets a ConanInfo file from a package"""
url = "%s/download_urls" % self._package_url(package_reference)
urls = self._get_file_to_url_dict(url)
if not urls:
raise NotFoundException("Package not found!")
if CONANINFO not in urls:
raise NotFoundException("Package %s doesn't have the %s file!" % (package_reference,
CONANINFO))
# Get the info (in memory)
contents = self._download_files({CONANINFO: urls[CONANINFO]}, quiet=True)
# Unroll generator and decode shas (plain text)
contents = {key: decode_text(value) for key, value in dict(contents).items()}
return ConanInfo.loads(contents[CONANINFO])
def get_package_info(self, pref):
"""Gets a ConanInfo file from a package"""
pref = pref.copy_with_revs(None, None)
url = self.router.package_download_urls(pref)
urls = self._get_file_to_url_dict(url)
if not urls:
raise PackageNotFoundException(pref)
if CONANINFO not in urls:
raise NotFoundException("Package %s doesn't have the %s file!" % (pref,
CONANINFO))
# Get the info (in memory)
contents = self._download_files({CONANINFO: urls[CONANINFO]}, quiet=True)
# Unroll generator and decode shas (plain text)
contents = {key: decode_text(value) for key, value in dict(contents).items()}
return ConanInfo.loads(contents[CONANINFO])
def settings_as_a_dict_conanfile_test(self):
"""Declare settings as a dict"""
# Now with conanfile as a dict
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": ["Windows"], "arch": ["x86_64"]}
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.assertEquals(conan_info.settings.fields, ["arch", "os"])
def settings_as_a_list_conanfile_test(self):
"""Declare settings as a list"""
# Now with conanfile as a list
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os", "arch"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.assertEquals(conan_info.settings.fields, ["arch", "os"])
def test_settings_as_a_list_conanfile(self):
# Now with conanfile as a list
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os", "arch"
"""
client = TestClient()
client.save({CONANFILE: content})
client.run("install . -s os=Windows --build missing")
conan_info = ConanInfo.loads(client.load(CONANINFO))
self.assertEqual(conan_info.settings.os, "Windows")
self.assertEqual(conan_info.settings.fields, ["arch", "os"])
def install_and_get_info(package_id_text):
self.client.run("remove * -f")
self._export("Hello", "1.2.0", package_id_text=package_id_text,
channel="user/testing",
settings='"os", "os_build", "arch", "arch_build"')
self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s os_build="Linux"'
' -s arch="x86_64"'
' -s arch_build="x86"'
' --build missing')
ref = ConanFileReference.loads("Hello/1.2.0@user/testing")
pkg = os.listdir(self.client.client_cache.packages(ref))
pid = PackageReference(ref, pkg[0])
pkg_folder = self.client.client_cache.package(pid)
return ConanInfo.loads(load(os.path.join(pkg_folder, CONANINFO)))
def settings_as_a_dict_conanfile_test(self):
"""Declare settings as a dict"""
# Now with conanfile as a dict
# XXX: this test only works on machines that default arch to "x86" or "x86_64"
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": ["Windows"], "arch": ["x86", "x86_64"]}
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
conan_info = ConanInfo.loads(load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.assertEquals(conan_info.settings.fields, ["arch", "os"])
def download_packages(self, reference, package_ids):
assert(isinstance(package_ids, list))
remote, _ = self._get_remote(reference)
conanfile_path = self._client_cache.conanfile(reference)
if not os.path.exists(conanfile_path):
raise Exception("Download recipe first")
conanfile = load_conanfile_class(conanfile_path)
# FIXME: This is a hack to provide a info object in case it fails and raise_package_not_found_error doesnt fail
conanfile.info = ConanInfo.loads("")
short_paths = conanfile.short_paths
self._registry.set_ref(reference, remote)
output = ScopedOutput(str(reference), self._out)
for package_id in package_ids:
package_ref = PackageReference(reference, package_id)
package_folder = self._client_cache.package(package_ref, short_paths=short_paths)
self._out.info("Downloading %s" % str(package_ref))
self._remote_manager.get_package(conanfile, package_ref, package_folder, remote, output, self._recorder)
def test_settings_as_a_dict_conanfile(self):
# Now with conanfile as a dict
# XXX: this test only works on machines w default arch "x86", "x86_64", "sparc" or "sparcv9"
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": ["Windows"], "arch": ["x86", "x86_64", "sparc", "sparcv9"]}
"""
client = TestClient()
client.save({CONANFILE: content})
client.run("install . -s os=Windows --build missing")
conan_info = ConanInfo.loads(client.load(CONANINFO))
self.assertEqual(conan_info.settings.os, "Windows")
self.assertEqual(conan_info.settings.fields, ["arch", "os"])
def _get_upload_modules_with_deps(uploaded_files, downloaded_files):
modules = []
deps = defaultdict(set) # Reference: [Reference, Reference]
# Extract needed information
for module_id, mod_doc in uploaded_files.items():
ref_or_pref = ConanFileReference.loads(module_id) if mod_doc["type"] == "recipe" \
else PackageReference.loads(module_id)
# Store recipe and package dependencies
if mod_doc["type"] == "package":
conan_infos = [
file_doc for file_doc in mod_doc["files"]
if file_doc["name"] == "conaninfo.txt"
]
if conan_infos:
conan_info = conan_infos[0]["path"]
info = ConanInfo.loads(load(conan_info))
for pref in info.full_requires:
clear_pref = pref.copy_clear_revs()
deps[repr(ref_or_pref.ref.copy_clear_rev())].add(
repr(clear_pref.ref))
deps[repr(ref_or_pref.copy_clear_revs())].add(
repr(clear_pref))
# Add the modules
for module_id, mod_doc in uploaded_files.items():
module = BuildInfoModule()
module.id = str(module_id)
# Add artifacts
for file_doc in mod_doc["files"]:
artifact = _get_build_info_artifact(file_doc)
module.artifacts.append(artifact)
# Add dependencies, for each module dep modules
for mod_dep_id in deps[module_id]:
if mod_dep_id in downloaded_files:
down_module = downloaded_files[mod_dep_id]
# Check if the remote from the uploaded package matches the remote
# from the downloaded dependency
if down_module.get("remote", None) == mod_doc["remote"]:
for file_doc in down_module["files"]:
module.dependencies.append(
_get_dependency(file_doc, mod_dep_id))
modules.append(module)
return modules
def get_package_info(self, package_reference):
"""Gets a ConanInfo file from a package"""
url = "%s/conans/%s/packages/%s/download_urls" % (self._remote_api_url,
"/".join(package_reference.conan),
package_reference.package_id)
urls = self._get_json(url)
if not urls:
raise NotFoundException("Package not found!")
if CONANINFO not in urls:
raise NotFoundException("Package %s doesn't have the %s file!" % (package_reference,
CONANINFO))
# Get the info (in memory)
contents = self.download_files({CONANINFO: urls[CONANINFO]})
# Unroll generator and decode shas (plain text)
contents = {key: decode_text(value) for key, value in dict(contents).items()}
return ConanInfo.loads(contents[CONANINFO])
def _build(self, cmd, static, pure_c, use_cmake, lang):
client = TestClient()
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export, pure_c=pure_c, use_cmake=use_cmake)
client.save(files)
client.run(cmd)
client.run("build")
ld_path = "LD_LIBRARY_PATH=$(pwd)" if not static and not platform.system() == "Windows" else ""
command = os.sep.join([".", "bin", "say_hello"])
client.runner("%s %s" % (ld_path, command), cwd=client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def _build(self, cmd, static, pure_c, use_cmake, lang):
dll_export = self.client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export,
pure_c=pure_c, use_cmake=use_cmake)
self.client.save(files, clean_first=True)
self.client.run(cmd)
time.sleep(1) # necessary so the conaninfo.txt is flushed to disc
self.client.run('build')
ld_path = ("LD_LIBRARY_PATH=$(pwd)"
if not static and not platform.system() == "Windows" else "")
self.client.runner("%s %s" % (ld_path, self.command), cwd=self.client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, self.client.user_io.out)
conan_info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def _single_conan_search(self, conan_ref):
""" Return a dict like this:
{package_ID: {name: "OpenCV",
version: "2.14",
settings: {os: Windows}}}
param conan_ref: ConanFileReference object
"""
result = {}
packages_path = self.paths.packages(conan_ref)
subdirs = self._file_adapter.list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
try:
package_reference = PackageReference(conan_ref, package_id)
info_path = os.path.join(self.paths.package(package_reference), CONANINFO)
conan_info_content = self._file_adapter.get_file(info_path)
conan_vars_info = ConanInfo.loads(conan_info_content)
result[package_id] = conan_vars_info
except Exception:
logger.error("Package %s has not ConanInfo file" % str(package_reference))
return result
def _get_local_infos_min(self, reference):
result = {}
packages_path = self._paths.packages(reference)
subdirs = list_folder_subdirs(packages_path, level=1)
for package_id in subdirs:
# Read conaninfo
try:
package_reference = PackageReference(reference, package_id)
info_path = os.path.join(self._paths.package(package_reference,
short_paths=None), CONANINFO)
if not os.path.exists(info_path):
raise NotFoundException("")
conan_info_content = load(info_path)
conan_vars_info = ConanInfo.loads(conan_info_content).serialize_min()
result[package_id] = conan_vars_info
except Exception as exc:
logger.error("Package %s has no ConanInfo file" % str(package_reference))
if str(exc):
logger.error(str(exc))
return result
def _get_upload_modules_with_deps(uploaded_files, downloaded_files):
modules = []
deps = defaultdict(set) # Reference: [Reference, Reference]
# Extract needed information
for module_id, mod_doc in uploaded_files.items():
module_id = ConanFileReference.loads(module_id) if mod_doc["type"] == "recipe" \
else PackageReference.loads(module_id)
# Store recipe and package dependencies
if mod_doc["type"] == "package":
conan_infos = [file_doc for file_doc in mod_doc["files"]
if file_doc["name"] == "conaninfo.txt"]
if conan_infos:
conan_info = conan_infos[0]["path"]
info = ConanInfo.loads(load(conan_info))
for package_reference in info.full_requires:
deps[str(module_id.conan)].add(str(package_reference.conan))
deps[str(module_id)].add(str(package_reference))
# Add the modules
for module_id, mod_doc in uploaded_files.items():
module = BuildInfoModule()
module.id = str(module_id)
# Add artifacts
for file_doc in mod_doc["files"]:
artifact = _get_build_info_artifact(file_doc)
module.artifacts.append(artifact)
# Add dependencies, for each module dep modules
for mod_dep_id in deps[module_id]:
if mod_dep_id in downloaded_files:
down_module = downloaded_files[mod_dep_id]
# Check if the remote from the uploaded package matches the remote from the downloaded dependency
if down_module.get("remote", None) == mod_doc["remote"]:
for file_doc in down_module["files"]:
module.dependencies.append(_get_dependency(file_doc, mod_dep_id))
modules.append(module)
return modules
def complete_build_flow_test(self):
"""In local user folder"""
files = cpp_hello_conan_files("Hello0", "0.1")
client = TestClient()
client.save(files)
command = "say_hello" if platform.system() == "Windows" else "./say_hello"
for install, lang, static in [("install", 0, True),
("install -o language=1", 1, True),
("install -o language=1 -o static=False", 1, False),
("install -o static=False", 0, False)]:
client.run(install)
time.sleep(1) # necessary so the conaninfo.txt is flushed to disc
client.run('build')
client.runner(command, client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def pythonpath_env_injection_test(self):
# Save some custom python code in custom dir
external_py = '''
def external_baz():
print("External baz")
'''
external_dir = temp_folder()
save(os.path.join(external_dir, "external.py"), external_py)
conanfile = """
import os
from conans import ConanFile, tools
class ConanToolPackage(ConanFile):
name = "conantool"
version = "1.0"
exports = "*"
build_policy = "missing"
def build(self):
with tools.pythonpath(self):
import external
external.external_baz()
def package(self):
self.copy("*")
def package_info(self):
self.env_info.PYTHONPATH.append(self.package_folder)
"""
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export lasote/stable")
# We can't build the package without our PYTHONPATH
self.assertRaises(Exception, client.run, "install conantool/1.0@lasote/stable --build missing")
# But we can inject the PYTHONPATH
client.run("install conantool/1.0@lasote/stable -e PYTHONPATH=['%s']" % external_dir)
# Now we want to reuse the package and access both external stuff and mytest.py stuff
reuse = """from conans import ConanFile, tools
class ToolsTest(ConanFile):
name = "Consumer"
version = "0.1"
requires = "conantool/1.0@lasote/stable"
def build(self):
with tools.pythonpath(self):
import mytest
mytest.foo(self.output)
import external
external.external_baz()
"""
client.save({CONANFILE: reuse})
client.run("install --build -e PYTHONPATH=['%s']" % external_dir)
client.run("build")
info = ConanInfo.loads(load(os.path.join(client.current_folder, "conaninfo.txt")))
pythonpath = info.env_values.env_dicts(None)[1]["PYTHONPATH"]
self.assertEquals(os.path.normpath(pythonpath[0]), os.path.normpath(external_dir))
self.assertTrue(len(pythonpath), 2)
def read_package_recipe_hash(self, package_folder):
filename = os.path.join(package_folder, CONANINFO)
info = ConanInfo.loads(load(filename))
return info.recipe_hash
def load_conaninfo(lib):
# Read the LIB_A conaninfo
packages_path = client.client_cache.packages(ConanFileReference.loads("LIB_%s/1.0@lasote/stable" % lib))
package_path = os.path.join(packages_path, os.listdir(packages_path)[0])
info = ConanInfo.loads(load(os.path.join(package_path, CONANINFO)))
return info
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello00", "0.2", msg="#")
self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@lasote/stable", "private")],
static=False)
self._export_upload("Hello2", "0.1", deps=[("Hello00/0.2@lasote/stable", "private")],
static=False)
client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
files3 = cpp_hello_conan_files("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs and dylib
local_install = """ def imports(self):
self.copy("*.dll", "", "bin")
self.copy("*.dylib", "", "lib")
"""
copy_dlls_conanfile = files3[CONANFILE] + local_install
files3[CONANFILE] = copy_dlls_conanfile
client.save(files3)
client.run('install --build missing')
client.run('build')
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
build_info_cmake = load(info_path)
# Ensure it does not depend on Hello0 to build, as private in dlls
self.assertNotIn("Hello0", repr(build_info_cmake))
command = "say_hello" if platform.system() == "Windows" else "./say_hello"
client.runner(command, client.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'],
str(client.user_io.out).splitlines()[-5:])
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(info_path))
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
# Try to upload and reuse the binaries
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client2 = TestClient(servers=self.servers, users=[("lasote", "mypass")])
files2 = cpp_hello_conan_files("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs
copy_dlls_conanfile = files2[CONANFILE] + local_install
files2[CONANFILE] = copy_dlls_conanfile
client2.save(files2)
client2.run("install . --build missing")
self.assertNotIn("Package installed in Hello0/0.1", client2.user_io.out)
self.assertNotIn("Building", client2.user_io.out)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, client2.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'],
str(client2.user_io.out).splitlines()[-5:])
files3 = cpp_hello_conan_files("Hello3", "0.2", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"], language=1)
copy_dlls_conanfile = files3[CONANFILE] + local_install
files3[CONANFILE] = copy_dlls_conanfile
client2.save(files3)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, client2.current_folder)
self.assertEqual(['Hola Hello3', 'Hola Hello1',
'Hola Hello0', 'Hola Hello2', 'Hola #'],
str(client2.user_io.out).splitlines()[-5:])
def test_build_settings(self):
def install_and_get_info(package_id_text):
self.client.run("remove * -f")
self._export("Hello", "1.2.0", package_id_text=package_id_text,
channel="user/testing",
settings='"os", "os_build", "arch", "arch_build"')
self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s os_build="Linux"'
' -s arch="x86_64"'
' -s arch_build="x86"'
' --build missing')
ref = ConanFileReference.loads("Hello/1.2.0@user/testing")
pkg = os.listdir(self.client.client_cache.packages(ref))
pid = PackageReference(ref, pkg[0])
pkg_folder = self.client.client_cache.package(pid)
return ConanInfo.loads(load(os.path.join(pkg_folder, CONANINFO)))
info = install_and_get_info(None) # Default
self.assertEquals(str(info.settings.os_build), "None")
self.assertEquals(str(info.settings.arch_build), "None")
# Package has to be present with only os and arch settings
self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s arch="x86_64"')
# Even with wrong build settings
self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s arch="x86_64"'
' -s os_build="Macos"'
' -s arch_build="x86_64"')
# take into account build
info = install_and_get_info("self.info.include_build_settings()")
self.assertEquals(str(info.settings.os_build), "Linux")
self.assertEquals(str(info.settings.arch_build), "x86")
# Now the build settings matter
err = self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s arch="x86_64"'
' -s os_build="Macos"'
' -s arch_build="x86_64"', ignore_error=True)
self.assertTrue(err)
self.assertIn("Can't find", self.client.out)
self.client.run('install Hello/1.2.0@user/testing '
' -s os="Windows" '
' -s arch="x86_64"'
' -s os_build="Linux"'
' -s arch_build="x86"')
# Now only settings for build
self.client.run("remove * -f")
self._export("Hello", "1.2.0",
channel="user/testing",
settings='"os_build", "arch_build"')
self.client.run('install Hello/1.2.0@user/testing '
' -s os_build="Linux"'
' -s arch_build="x86"'
' --build missing')
ref = ConanFileReference.loads("Hello/1.2.0@user/testing")
pkg = os.listdir(self.client.client_cache.packages(ref))
pid = PackageReference(ref, pkg[0])
pkg_folder = self.client.client_cache.package(pid)
info = ConanInfo.loads(load(os.path.join(pkg_folder, CONANINFO)))
self.assertEquals(str(info.settings.os_build), "Linux")
self.assertEquals(str(info.settings.arch_build), "x86")
def test_modes(self):
info_text = '''[settings]
arch=x86_64
build_type=Debug
compiler=gcc
compiler.libcxx=libstdc++11
compiler.version=5.2
os=Linux
[full_requires]
bzip2/1.2.3-alpha1+build123@lasote/testing:sha1
zlib/0.3@lasote/testing:sha2
poco/2.3.4+build123@lasote/stable:sha3
[options]
fPIC=True
header_only=False
shared=False
'''
info = ConanInfo.loads(info_text)
info.header_only()
self.assertEqual(info.settings.dumps(), "")
self.assertEqual(info.options.dumps(), "")
self.assertEqual(info.requires.dumps(), "")
info = ConanInfo.loads(info_text)
info.requires.unrelated_mode()
self.assertEqual(info.requires.dumps(), "")
info = ConanInfo.loads(info_text)
info.requires.semver_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.Y.Z\npoco/2.Y.Z\nzlib/0.3")
info = ConanInfo.loads(info_text)
info.requires.patch_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.3\npoco/2.3.4\nzlib/0.3.0")
info = ConanInfo.loads(info_text)
info.requires.minor_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.Z\npoco/2.3.Z\nzlib/0.3.Z")
info = ConanInfo.loads(info_text)
info.requires.major_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.Y.Z\npoco/2.Y.Z\nzlib/0.Y.Z")
info = ConanInfo.loads(info_text)
info.requires.base_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.3-alpha1\npoco/2.3.4\nzlib/0.3")
info = ConanInfo.loads(info_text)
info.requires.full_version_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.3-alpha1+build123\n"
"poco/2.3.4+build123\n"
"zlib/0.3")
info = ConanInfo.loads(info_text)
info.requires.full_recipe_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.3-alpha1+build123@lasote/testing\n"
"poco/2.3.4+build123@lasote/stable\n"
"zlib/0.3@lasote/testing")
info = ConanInfo.loads(info_text)
info.requires.full_package_mode()
self.assertEqual(info.requires.dumps(), "bzip2/1.2.3-alpha1+build123@lasote/testing:sha1\n"
"poco/2.3.4+build123@lasote/stable:sha3\n"
"zlib/0.3@lasote/testing:sha2")
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello00", "0.2", msg="#")
self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@lasote/stable", "private")],
static=False)
self._export_upload("Hello2", "0.1", deps=[("Hello00/0.2@lasote/stable", "private")],
static=False)
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs and dylib
client.save(files3)
client.run('install --build missing')
client.run('build')
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
build_info_cmake = load(info_path)
# Ensure it does not depend on Hello0 to build, as private in dlls
self.assertNotIn("Hello0", repr(build_info_cmake))
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'],
str(client.user_io.out).splitlines()[-5:])
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(info_path))
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
# Try to upload and reuse the binaries
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
files2 = cpp_hello_conan_files("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs
client2.save(files2)
client2.run("install . --build missing")
self.assertNotIn("Package installed in Hello0/0.1", client2.user_io.out)
self.assertNotIn("Building", client2.user_io.out)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual(['Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'],
str(client2.user_io.out).splitlines()[-5:])
files3 = cpp_hello_conan_files("Hello3", "0.2", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"], language=1)
client2.save(files3)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual(['Hola Hello3', 'Hola Hello1',
'Hola Hello0', 'Hola Hello2', 'Hola #'],
str(client2.user_io.out).splitlines()[-5:])
# Issue 79, fixing private deps from current project
files3 = cpp_hello_conan_files("Hello3", "0.2", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable",
("Hello0/0.1@lasote/stable", "private"),
("Hello00/0.2@lasote/stable", "private")],
language=1)
client2.save(files3, clean_first=True)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual(['Hola Hello3', 'Hola Hello1',
'Hola Hello0', 'Hola Hello2', 'Hola #', 'Hola Hello0', 'Hola #'],
str(client2.user_io.out).splitlines()[-7:])
