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:])