def remove_specific_builds_test(self): client = TestClient() client.save({"conanfile.py": conanfile}) client.run("export user/channel") client.save({"conanfile.txt": consumer}, clean_first=True) client.run('install -s build_type=Debug') client.run('install -s build_type=Release') ref = ConanFileReference.loads("Pkg/0.1@user/channel") def _check_builds(): builds = client.client_cache.conan_builds(ref) self.assertEqual(1, len(builds)) packages = client.client_cache.conan_packages(ref) self.assertEqual(2, len(packages)) self.assertNotIn(builds[0], packages) return builds[0], packages build, packages = _check_builds() client.run("remove Pkg/0.1@user/channel -b %s -f" % packages[0]) _check_builds() client.run("remove Pkg/0.1@user/channel -b %s -f" % build) builds = client.client_cache.conan_builds(ref) self.assertEqual(0, len(builds)) packages = client.client_cache.conan_packages(ref) self.assertEqual(2, len(packages))
def test_profile_test_requires(self): client = TestClient() self._create(client) test_conanfile = """ import os from conans import ConanFile, tools class TestMyLib(ConanFile): requires = "MyLib/0.1@lasote/stable" def build(self): self.run("mytool") with tools.pythonpath(self): import mypythontool self.output.info(mypythontool.tool_hello_world()) def test(self): pass """ client.save({CONANFILE: lib_conanfile, "test_package/conanfile.py": test_conanfile, "profile.txt": profile, "profile2.txt": profile2}, clean_first=True) client.run("test_package --profile ./profile.txt --build missing") self.assertEqual(2, str(client.user_io.out).splitlines().count("Hello World!")) self.assertIn("MyLib/0.1@lasote/stable: Hello world from python tool!", client.user_io.out) self.assertIn("Project: Hello world from python tool!", client.user_io.out)
def test_build_mode_requires(self): client = TestClient() self._create(client) client.save({CONANFILE: lib_conanfile, "profile.txt": profile}, clean_first=True) error = client.run("install --profile ./profile.txt", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: Missing prebuilt package for 'PythonTool/0.1@lasote/stable'", client.user_io.out) error = client.run("install --profile ./profile.txt --build=PythonTool", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: Missing prebuilt package for 'Tool/0.1@lasote/stable'", client.user_io.out) client.run("install --profile ./profile.txt --build=*Tool") self.assertIn("Installed build requires: [Tool/0.1@lasote/stable, " "PythonTool/0.1@lasote/stable]", client.user_io.out) self.assertIn("Tool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out) self.assertIn("PythonTool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out) # now remove packages, ensure --build=missing also creates them client.run('remove "*" -p -f') client.run("install --profile ./profile.txt --build=missing") self.assertIn("Installed build requires: [Tool/0.1@lasote/stable, " "PythonTool/0.1@lasote/stable]", client.user_io.out) self.assertIn("Tool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out) self.assertIn("PythonTool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out)
def test_rel_path(self): base_folder = temp_folder() source_folder = os.path.join(base_folder, "source") current_folder = os.path.join(base_folder, "current") os.makedirs(current_folder) client = TestClient(current_folder=current_folder) files = cpp_hello_conan_files("Hello0", "0.1") conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable") client.save(files, path=source_folder) client.run("export lasote/stable --path=../source") reg_path = client.paths.export(conan_ref) manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref))) self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref), client.user_io.out) self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out) self.assertTrue(os.path.exists(reg_path)) for name in list(files.keys()): self.assertTrue(os.path.exists(os.path.join(reg_path, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143', 'conanfile.py': '355949fbf0b4fc32b8f1c5a338dfe1ae', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
def local_flow_test(self): """Use 'conan package' to process locally the package method""" client = TestClient() conanfile_template = """ from conans import ConanFile class MyConan(ConanFile): def package(self): self.copy(pattern="*.h", dst="include", src="include") """ files = {"include/file.h": "foo", CONANFILE: conanfile_template} client.save(files) origin_folder = client.current_folder client.run("install -g env -g txt") client.run("source") client.run("build") client.run("package .", ignore_error=True) self.assertIn("ERROR: Cannot 'conan package' to the build folder", client.user_io.out) package_folder = os.path.join(origin_folder, "package") mkdir(package_folder) client.current_folder = package_folder client.run('package .. --build_folder=..') content = load(os.path.join(client.current_folder, "include/file.h")) self.assertEqual(content, "foo")
def test_path(self): base_folder = temp_folder() source_folder = os.path.join(base_folder, "source") current_folder = os.path.join(base_folder, "current") client = TestClient(current_folder=current_folder) files = cpp_hello_conan_files("Hello0", "0.1") conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable") conanfile = files.pop("conanfile.py") client.save(files, path=source_folder) conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"') client.save({"conanfile.py": conanfile}) client.run("export lasote/stable") reg_path = client.paths.export(conan_ref) manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref))) self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref), client.user_io.out) self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out) self.assertTrue(os.path.exists(reg_path)) for name in ['conanfile.py', 'conanmanifest.txt', 'source/main.cpp', 'source/executable', 'source/hello.cpp', 'source/CMakeLists.txt', 'source/helloHello0.h']: self.assertTrue(os.path.exists(os.path.join(reg_path, name))) expected_sums = {'source/hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'source/main.cpp': '0479f3c223c9a656a718f3148e044124', 'source/CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143', 'conanfile.py': '3ac566eb5b2e4df4417003f0e606e237', 'source/executable': '68b329da9893e34099c7d8ad5cb9c940', 'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
def value_parse_test(self): # https://github.com/conan-io/conan/issues/2816 conanfile = """ from conans import ConanFile class TestConan(ConanFile): name = "test" version = "0.1" settings = "os", "compiler", "arch", "build_type" exports_sources = "header.h" def package_id(self): self.info.settings.compiler.version = "kk=kk" def package(self): self.copy("header.h", dst="include", keep_path=True) """ server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"}) servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({"conanfile.py": conanfile, "header.h": "header content"}) client.run("create . danimtb/testing") client.run("search test/0.1@danimtb/testing") self.assertIn("compiler.version: kk=kk", client.out) client.run("upload test/0.1@danimtb/testing --all") client.run("remove test/0.1@danimtb/testing --force") client.run("install test/0.1@danimtb/testing") client.run("search test/0.1@danimtb/testing") self.assertIn("compiler.version: kk=kk", client.out)
def remove_option_setting_test(self): # https://github.com/conan-io/conan/issues/2826 conanfile = """from conans import ConanFile class TestConan(ConanFile): settings = "os" options = {"opt": [True, False]} default_options = "opt=False" def package_id(self): self.output.info("OPTION OPT=%s" % self.info.options.opt) del self.info.settings.os del self.info.options.opt """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("create . Pkg/0.1@user/testing -s os=Windows") self.assertIn("Pkg/0.1@user/testing: OPTION OPT=False", client.out) self.assertIn("Pkg/0.1@user/testing: Package " "'5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' created", client.out) client.run("create . Pkg/0.1@user/testing -s os=Linux -o Pkg:opt=True") self.assertIn("Pkg/0.1@user/testing: OPTION OPT=True", client.out) self.assertIn("Pkg/0.1@user/testing: Package " "'5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' created", client.out)
def scopes_test_package_test(self): client = TestClient() conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" def build(self): self.output.info("Scope: %s" % self.scope) """ test_conanfile = """ from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): requires = "Hello/0.1@lasote/stable" def test(self): self.conanfile_directory """ client.save({"conanfile.py": conanfile, "test/conanfile.py": test_conanfile}) client.run("test_package --scope Hello:dev=True --build=missing") self.assertIn("Hello/0.1@lasote/stable: Scope: dev=True", client.user_io.out)
def basic_source_test(self): conanfile = ''' from conans import ConanFile class ConanLib(ConanFile): name = "Hello" version = "0.1" def source(self): self.output.info("Running source!") ''' client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") client.run("source Hello/0.1@lasote/stable") self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # The second call shouldn't have effect client.run("source Hello/0.1@lasote/stable") self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertNotIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # Forced should have effect client.run("source Hello/0.1@lasote/stable --force") self.assertIn("WARN: Forced removal of source folder", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
def local_source_test(self): conanfile = ''' from conans import ConanFile from conans.util.files import save class ConanLib(ConanFile): def source(self): self.output.info("Running source!") err save("file1.txt", "Hello World") ''' # First, failing source() client = TestClient() client.save({CONANFILE: conanfile}) client.run("source .", ignore_error=True) self.assertIn("PROJECT: Running source!", client.user_io.out) self.assertIn("ERROR: PROJECT: Error in source() method, line 9", client.user_io.out) # Fix the error and repeat client.save({CONANFILE: conanfile.replace("err", "")}) client.run("source .") self.assertIn("PROJECT: Configuring sources in", client.user_io.out) self.assertIn("PROJECT: WARN: Your previous source command failed", client.user_io.out) self.assertIn("PROJECT: Running source!", client.user_io.out) self.assertEqual("Hello World", load(os.path.join(client.current_folder, "file1.txt")))
def fail_test_package_test(self): client = TestClient() conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" exports = "*" def package(self): self.copy("*") """ test_conanfile = """ from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): requires = "Hello/0.1@lasote/stable" def test(self): self.conanfile_directory """ client.save({"conanfile.py": conanfile, "FindXXX.cmake": "Hello FindCmake", "test/conanfile.py": test_conanfile}) client.run("test_package") ref = PackageReference.loads("Hello/0.1@lasote/stable:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") self.assertEqual("Hello FindCmake", load(os.path.join(client.paths.package(ref), "FindXXX.cmake"))) client.save({"FindXXX.cmake": "Bye FindCmake"}) client.run("test_package") self.assertEqual("Bye FindCmake", load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
def transitive_same_name_test(self): # https://github.com/conan-io/conan/issues/1366 client = TestClient() conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): name = "HelloBar" version = "0.1" ''' test_package = ''' from conans import ConanFile class HelloTestConan(ConanFile): requires = "HelloBar/0.1@lasote/testing" def test(self): pass ''' client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_package}) client.run("test_package") self.assertIn("HelloBar/0.1@lasote/testing: WARN: Forced build from source", client.user_io.out) client.save({"conanfile.py": conanfile.replace("HelloBar", "Hello") + " requires='HelloBar/0.1@lasote/testing'", "test_package/conanfile.py": test_package.replace("HelloBar", "Hello")}) client.run("test_package") self.assertNotIn("HelloBar/0.1@lasote/testing: WARN: Forced build from source", client.user_io.out)
def test_package_env_test(self): client = TestClient() conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" def package_info(self): self.env_info.PYTHONPATH.append("new/pythonpath/value") ''' test_package = ''' import os from conans import ConanFile class HelloTestConan(ConanFile): requires = "Hello/0.1@lasote/testing" def build(self): assert("new/pythonpath/value" in os.environ["PYTHONPATH"]) def test(self): assert("new/pythonpath/value" in os.environ["PYTHONPATH"]) ''' client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_package}) client.run("test_package")
def upload_newer_recipe_test(self): servers = {} test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"}) servers["default"] = test_server client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) files = cpp_hello_conan_files("Hello0", "1.2.1", build=False) client.save(files) client.run("export frodo/stable") client.run("install Hello0/1.2.1@frodo/stable --build=missing") client.run("upload Hello0/1.2.1@frodo/stable --all") client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client2.save(files) client2.run("export frodo/stable") ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable") manifest = client2.client_cache.load_manifest(ref) manifest.time += 10 save(client2.client_cache.digestfile_conanfile(ref), str(manifest)) client2.run("install Hello0/1.2.1@frodo/stable --build=missing") client2.run("upload Hello0/1.2.1@frodo/stable --all") self.assertNotIn("conanfile", client2.user_io.out) self.assertIn("Package is up to date.", client2.user_io.out) self.assertIn("Uploading conanmanifest.txt", client2.user_io.out) # Now try again with the other client, which timestamp is older client.run("upload Hello0/1.2.1@frodo/stable --all") self.assertNotIn("conanfile", client2.user_io.out) self.assertIn("Package is up to date.", client2.user_io.out) self.assertIn("Uploading conanmanifest.txt", client.user_io.out)
class ProfileRequiresTest(unittest.TestCase): def setUp(self): self.client = TestClient() def _export(self, var_conanfile): self.client.save({CONANFILE: var_conanfile}, clean_first=True) self.client.run("export lasote/stable") def test_profile_requires(self): self._export(build_require_parent) self._export(build_require) self._export(build_require2) self._export(my_lib_parent) self._export(my_lib) self._export(my_lib2) reuse = """ [requires] MyLib/0.1@lasote/stable MyLib2/0.1@lasote/stable [generators] cmake gcc """ self.client.save({"profile.txt": profile, "conanfile.txt": reuse}, clean_first=True) self.client.run("install --profile ./profile.txt --build missing")
def copy_test(self): client = TestClient() client.save({CONANFILE: conanfile}) client.run("export . lasote/stable") client.run("install Hello0/0.1@lasote/stable --build=missing") error = client.run("copy hello0/0.1@lasote/stable otheruser/testing", ignore_error=True) self._check(error, client)
def patch_config_test(self): client = TestClient() conanfile = """from conans import ConanFile, CMake from conans.tools import save, load import os class AConan(ConanFile): settings = "os", "compiler", "build_type", "arch" def build(self): cmake = CMake(self) save("file1.cmake", "FOLDER " + self.package_folder) save("sub/file1.cmake", "FOLDER " + self.package_folder) cmake.patch_config_paths() def package(self): self.copy("*") self.output.info("RESULT: " + load(os.path.join(self.package_folder, "file1.cmake"))) self.output.info("RESULT2: " + load(os.path.join(self.package_folder, "sub/file1.cmake"))) """ client.save({"conanfile.py": conanfile}) client.run("create . Pkg/0.1@user/channel") self.assertIn("Pkg/0.1@user/channel: RESULT: FOLDER ${CONAN_PKG_ROOT}", client.out) self.assertIn("Pkg/0.1@user/channel: RESULT2: FOLDER ${CONAN_PKG_ROOT}", client.out) client.run("install .") error = client.run("build .", ignore_error=True) self.assertTrue(error) self.assertIn("ConanException: cmake.patch_config_paths() can't work without package name", client.out)
def download_reference_with_packages_test(self): server = TestServer() servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "pkg" version = "0.1" settings = "os" """ client.save({"conanfile.py": conanfile}) client.run("create . lasote/stable") ref = ConanFileReference.loads("pkg/0.1@lasote/stable") self.assertTrue(os.path.exists(client.paths.conanfile(ref))) package_folder = os.path.join(client.paths.conan(ref), "package", os.listdir(client.paths.packages(ref))[0]) client.run("upload pkg/0.1@lasote/stable --all") client.run("remove pkg/0.1@lasote/stable -f") self.assertFalse(os.path.exists(client.paths.export(ref))) client.run("download pkg/0.1@lasote/stable") # Check not 'No remote binary packages found' warning self.assertNotIn("WARN: No remote binary packages found in remote", client.out) # Check at conanfile.py is downloaded self.assertTrue(os.path.exists(client.paths.conanfile(ref))) # Check package folder created self.assertTrue(os.path.exists(package_folder))
def options_test(self): conanfile = """from conans import ConanFile class package(ConanFile): name = "first" version = "0.0.0" options = {"coverage": [True, False]} default_options = "coverage=False" def build(self): self.output.info("Coverage: %s" % self.options.coverage) """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("export . lasote/stable") consumer = """from conans import ConanFile class package(ConanFile): name = "second" version = "0.0.0" default_options = "first:coverage=True" build_requires = "first/0.0.0@lasote/stable" """ client.save({"conanfile.py": consumer}) client.run("install . --build=missing -o Pkg:someoption=3") self.assertIn("first/0.0.0@lasote/stable: Coverage: True", client.user_io.out)
def not_reupload_test(self): """ Check that if the package has not been modified, it is not uploaded again """ servers = {} test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"}) servers["default"] = test_server client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) files = cpp_hello_conan_files("Hello0", "1.2.1", build=False) client.save(files) client.run("export frodo/stable") client.run("install Hello0/1.2.1@frodo/stable --build=missing") client.run("upload Hello0/1.2.1@frodo/stable -r default --all") self.assertIn("Uploading conan_package.tgz", client.user_io.out) client.run("remove Hello0/1.2.1@frodo/stable -f") client.run("search") self.assertNotIn("Hello0/1.2.1@frodo/stable", client.user_io.out) client.run("install Hello0/1.2.1@frodo/stable") self.assertIn("Downloading conan_package.tgz", client.user_io.out) client.run("upload Hello0/1.2.1@frodo/stable -r default --all") self.assertIn("Uploaded conan recipe", client.user_io.out) self.assertNotIn("Uploading conan_package.tgz", client.user_io.out) self.assertIn("Package is up to date", client.user_io.out)
def download_reference_without_packages_test(self): server = TestServer() servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "pkg" version = "0.1" """ client.save({"conanfile.py": conanfile}) client.run("export . lasote/stable") ref = ConanFileReference.loads("pkg/0.1@lasote/stable") self.assertTrue(os.path.exists(client.paths.conanfile(ref))) client.run("upload pkg/0.1@lasote/stable") client.run("remove pkg/0.1@lasote/stable -f") self.assertFalse(os.path.exists(client.paths.export(ref))) client.run("download pkg/0.1@lasote/stable") # Check 'No remote binary packages found' warning self.assertTrue("WARN: No remote binary packages found in remote", client.out) # Check at least conanfile.py is downloaded self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
def generate_json_info_test(self): conanfile_py = """from conans import ConanFile class HelloConan(ConanFile): exports_sources = "*.h" def package(self): self.copy("*.h", dst="include") def package_info(self): self.env_info.MY_ENV_VAR = "foo" self.user_info.my_var = "my_value" """ client = TestClient() client.save({"conanfile.py": conanfile_py, "header.h": ""}) client.run("create . Hello/0.1@lasote/testing") client.run("install Hello/0.1@lasote/testing -g json") conan_json = os.path.join(client.current_folder, "conanbuildinfo.json") with open(conan_json) as f: data = json.load(f) self.assertEquals(data["deps_env_info"]["MY_ENV_VAR"], "foo") self.assertEquals(data["deps_user_info"]["Hello"]["my_var"], "my_value") hello_data = data["dependencies"][0] self.assertTrue(os.path.exists(hello_data["rootpath"])) include_path = hello_data["include_paths"][0] self.assertTrue(os.path.isabs(include_path)) self.assertTrue(os.path.exists(include_path))
def test_disable_linter(self): client = TestClient() client.save({CONANFILE: conanfile}) client.run("config set general.recipe_linter=False") client.run("export lasote/stable") self.assertNotIn("ERROR: Py3 incompatibility", client.user_io.out) self.assertNotIn("WARN: Linter", client.user_io.out)
def download_with_sources_test(self): server = TestServer() servers = {"default": server, "other": TestServer()} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")], "other": [("lasote", "mypass")]}) conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "pkg" version = "0.1" exports_sources = "*" """ client.save({"conanfile.py": conanfile, "file.h": "myfile.h", "otherfile.cpp": "C++code"}) client.run("export . lasote/stable") ref = ConanFileReference.loads("pkg/0.1@lasote/stable") self.assertTrue(os.path.exists(client.paths.conanfile(ref))) client.run("upload pkg/0.1@lasote/stable") client.run("remove pkg/0.1@lasote/stable -f") self.assertFalse(os.path.exists(client.paths.export(ref))) client.run("download pkg/0.1@lasote/stable") self.assertIn("Downloading conan_sources.tgz", client.out) source = client.client_cache.export_sources(ref) self.assertEqual("myfile.h", load(os.path.join(source, "file.h"))) self.assertEqual("C++code", load(os.path.join(source, "otherfile.cpp")))
def test_profile_override(self, conanfile): client = TestClient() client.save({CONANFILE: tool_conanfile2}, clean_first=True) client.run("export . lasote/stable") client.save({CONANFILE: conanfile, "profile.txt": profile, "profile2.txt": profile.replace("0.3", "[>0.2]")}, clean_first=True) client.run("export . lasote/stable") client.run("install MyLib/0.1@lasote/stable --profile ./profile.txt --build missing") self.assertNotIn("Tool/0.1", client.user_io.out) self.assertNotIn("Tool/0.2", client.user_io.out) self.assertIn("Tool/0.3@lasote/stable: Generating the package", client.user_io.out) self.assertIn("ToolPath: MyToolPath", client.user_io.out) client.run("install MyLib/0.1@lasote/stable") self.assertNotIn("Tool", client.user_io.out) self.assertIn("MyLib/0.1@lasote/stable: Already installed!", client.user_io.out) client.run("install MyLib/0.1@lasote/stable --profile ./profile2.txt --build") self.assertNotIn("Tool/0.1", client.user_io.out) self.assertNotIn("Tool/0.2", client.user_io.out) self.assertIn("Tool/0.3@lasote/stable: Generating the package", client.user_io.out) self.assertIn("ToolPath: MyToolPath", client.user_io.out)
def test_run_environment(self): client = TestClient() files = cpp_hello_conan_files("Hello0", "0.1") files[CONANFILE] = files[CONANFILE].replace('self.copy(pattern="*.so", dst="lib", keep_path=False)', '''self.copy(pattern="*.so", dst="lib", keep_path=False) self.copy(pattern="*say_hello*", dst="bin", keep_path=False)''') client.save(files) client.run("export . lasote/stable") reuse = ''' from conans import ConanFile, RunEnvironment, tools class HelloConan(ConanFile): name = "Reuse" version = "0.1" build_policy = "missing" requires = "Hello0/0.1@lasote/stable" def build(self): run_env = RunEnvironment(self) with tools.environment_append(run_env.vars): self.run("say_hello") ''' client.save({"conanfile.py": reuse}, clean_first=True) client.run("install . --build missing") client.run("build .")
def basic_test(self): client = TestClient() zlib = ''' from conans import ConanFile class ConanLib(ConanFile): name = "zlib" version = "0.1" options = {"shared": [True, False]} default_options= "shared=False" ''' client.save({"conanfile.py": zlib}) client.run("export lasote/testing") project = """[requires] zlib/0.1@lasote/testing """ client.save({"conanfile.txt": project}, clean_first=True) client.run("install -o zlib:shared=True --build=missing") self.assertIn("zlib/0.1@lasote/testing:2a623e3082a38f90cd2c3d12081161412de331b0", client.user_io.out) conaninfo = load(os.path.join(client.current_folder, CONANINFO)) self.assertIn("zlib:shared=True", conaninfo) # Options not cached anymore client.run("install --build=missing") self.assertIn("zlib/0.1@lasote/testing:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", client.user_io.out) conaninfo = load(os.path.join(client.current_folder, CONANINFO)) self.assertNotIn("zlib:shared=True", conaninfo)
def test_patch_new_delete(self): conanfile = base_conanfile + ''' def build(self): from conans.tools import load, save save("oldfile", "legacy code") assert(os.path.exists("oldfile")) patch_content = """--- /dev/null +++ b/newfile @@ -0,0 +0,3 @@ +New file! +New file! +New file! --- a/oldfile +++ b/dev/null @@ -0,1 +0,0 @@ -legacy code """ patch(patch_string=patch_content) self.output.info("NEW FILE=%s" % load("newfile")) self.output.info("OLD FILE=%s" % os.path.exists("oldfile")) ''' client = TestClient() client.save({"conanfile.py": conanfile}) client.run("create . user/testing") self.assertIn("test/1.9.10@user/testing: NEW FILE=New file!\nNew file!\nNew file!\n", client.out) self.assertIn("test/1.9.10@user/testing: OLD FILE=False", client.out)
def no_signature_test(self): auth = AuthorizationHeaderSpy() retur = ReturnHandlerPlugin() server = TestServer(plugins=[auth, retur]) servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({"conanfile.py": conanfile}) client.run("export . lasote/stable") # Upload will fail, as conan_server is expecting a signed URL errors = client.run("upload Hello/0.1@lasote/stable", ignore_error=True) self.assertTrue(errors) expected_calls = [('get_conan_manifest_url', None), ('check_credentials', None), ('authenticate', 'Basic'), ('get_conanfile_snapshot', 'Bearer'), ('get_conanfile_upload_urls', 'Bearer'), ('put', 'Bearer')] self.assertEqual(len(expected_calls), len(auth.auths)) for i, (method, auth_type) in enumerate(expected_calls): real_call = auth.auths[i] self.assertEqual(method, real_call[0]) if auth_type: self.assertIn(auth_type, real_call[1]) # The Bearer of the last two calls must be identical self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
class JsonOutputTest(unittest.TestCase): def setUp(self): self.servers = {"default": TestServer()} self.client = TestClient(servers=self.servers) def test_simple_fields(self): # Result of a create self.client.save({"conanfile.py": GenConanfile("CC", "1.0")}, clean_first=True) self.client.run("create . private_user/channel --json=myfile.json") my_json = json.loads(self.client.load("myfile.json")) self.assertFalse(my_json["error"]) tmp = ConanFileReference.loads(my_json["installed"][0]["recipe"]["id"]) self.assertEqual(str(tmp), "CC/1.0@private_user/channel") if self.client.cache.config.revisions_enabled: self.assertIsNotNone(tmp.revision) self.assertFalse(my_json["installed"][0]["recipe"]["dependency"]) self.assertTrue(my_json["installed"][0]["recipe"]["exported"]) self.assertFalse(my_json["installed"][0]["recipe"]["downloaded"]) self.assertIsNone(my_json["installed"][0]["recipe"]["remote"]) self.assertTrue(my_json["installed"][0]["packages"][0]["built"]) self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"]) # Result of an install retrieving only the recipe self.client.run("upload CC/1.0@private_user/channel -c") self.client.run("remove '*' -f") self.client.run( "install CC/1.0@private_user/channel --json=myfile.json --build missing " ) my_json = json.loads(self.client.load("myfile.json")) the_time_str = my_json["installed"][0]["recipe"]["time"] self.assertIn("T", the_time_str) # Weak validation of the ISO 8601 self.assertFalse(my_json["error"]) self.assertEqual(my_json["installed"][0]["recipe"]["id"], "CC/1.0@private_user/channel") self.assertTrue(my_json["installed"][0]["recipe"]["dependency"]) self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"]) self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"]) self.assertTrue(my_json["installed"][0]["packages"][0]["built"]) self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"]) # Upload the binary too self.client.run("upload CC/1.0@private_user/channel --all -c") self.client.run("remove '*' -f") self.client.run( "install CC/1.0@private_user/channel --json=myfile.json") my_json = json.loads(self.client.load("myfile.json")) self.assertFalse(my_json["error"]) self.assertEqual(my_json["installed"][0]["recipe"]["id"], "CC/1.0@private_user/channel") self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"]) self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"]) self.assertFalse(my_json["installed"][0]["packages"][0]["built"]) self.assertTrue(my_json["installed"][0]["packages"][0]["downloaded"]) self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"]) # Force build self.client.run("remove '*' -f") self.client.run( "install CC/1.0@private_user/channel --json=myfile.json --build") my_json = json.loads(self.client.load("myfile.json")) self.assertFalse(my_json["error"]) self.assertEqual(my_json["installed"][0]["recipe"]["id"], "CC/1.0@private_user/channel") self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"]) self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"]) self.assertTrue(my_json["installed"][0]["packages"][0]["built"]) self.assertFalse(my_json["installed"][0]["packages"][0]["downloaded"]) self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"]) def test_errors(self): # Missing recipe self.client.run( "install CC/1.0@private_user/channel --json=myfile.json", assert_error=True) my_json = json.loads(self.client.load("myfile.json")) self.assertTrue(my_json["error"]) self.assertEqual(len(my_json["installed"]), 1) self.assertFalse(my_json["installed"][0]["recipe"]["downloaded"]) self.assertEqual( my_json["installed"][0]["recipe"]["error"], { 'type': 'missing', 'remote': None, 'description': "Unable to find 'CC/1.0@private_user/channel' in remotes" }) # Missing binary package self.client.save({"conanfile.py": GenConanfile("CC", "1.0")}, clean_first=True) self.client.run("create . private_user/channel --json=myfile.json ") self.client.run("upload CC/1.0@private_user/channel -c") self.client.run("remove '*' -f") self.client.run( "install CC/1.0@private_user/channel --json=myfile.json", assert_error=True) my_json = json.loads(self.client.load("myfile.json")) self.assertTrue(my_json["error"]) self.assertEqual(len(my_json["installed"]), 1) self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"]) self.assertFalse(my_json["installed"][0]["recipe"]["error"]) self.assertEqual(len(my_json["installed"][0]["packages"]), 1) self.assertFalse(my_json["installed"][0]["packages"][0]["downloaded"]) self.assertEqual( my_json["installed"][0]["packages"][0]["error"]["type"], "missing") self.assertIsNone( my_json["installed"][0]["packages"][0]["error"]["remote"]) self.assertIn( "Can't find a 'CC/1.0@private_user/channel' package", my_json["installed"][0]["packages"][0]["error"]["description"]) # Error building conanfile = str(GenConanfile("CC", "1.0")) + """ def build(self): raise Exception("Build error!") """ self.client.save({"conanfile.py": conanfile}, clean_first=True) self.client.run("create . private_user/channel --json=myfile.json ", assert_error=True) my_json = json.loads(self.client.load("myfile.json")) self.assertTrue(my_json["error"]) self.assertEqual( my_json["installed"][0]["packages"][0]["error"]["type"], "building") self.assertIsNone( my_json["installed"][0]["packages"][0]["error"]["remote"]) self.assertIn( "CC/1.0@private_user/channel: Error in build() method, line 6", my_json["installed"][0]["packages"][0]["error"]["description"]) def test_json_generation(self): self.client.save( { "conanfile.py": GenConanfile("CC", "1.0").with_option( "static", [True, False]).with_default_option( "static", True) }, clean_first=True) self.client.run("create . private_user/channel --json=myfile.json ") self.client.run('upload "*" -c --all') conanfile = str(GenConanfile("BB", "1.0")) + """ def configure(self): self.options["CC"].static = False def build_requirements(self): self.build_requires("CC/1.0@private_user/channel") """ self.client.save({"conanfile.py": conanfile}, clean_first=True) self.client.run("create . private_user/channel --build missing") self.client.run('upload "*" -c --all') self.client.save( { "conanfile.py": GenConanfile("AA", "1.0").with_require("BB/1.0@private_user/channel") }, clean_first=True) self.client.run("create . private_user/channel") self.client.run('upload "*" -c --all') save( os.path.join(self.client.cache.profiles_path, "mybr"), """ include(default) [build_requires] AA*: CC/1.0@private_user/channel """) self.client.save( { "conanfile.py": GenConanfile("PROJECT", "1.0").with_require("AA/1.0@private_user/channel") }, clean_first=True) self.client.run( "install . --profile mybr --json=myfile.json --build AA --build BB" ) my_json = self.client.load("myfile.json") my_json = json.loads(my_json) self.assertTrue(my_json["installed"][0]["recipe"]["dependency"]) self.assertTrue(my_json["installed"][1]["recipe"]["dependency"]) self.assertTrue(my_json["installed"][2]["recipe"]["dependency"]) # Installed the build require CC with two options self.assertEqual(len(my_json["installed"][2]["packages"]), 2) tmp = ConanFileReference.loads(my_json["installed"][2]["recipe"]["id"]) if self.client.cache.config.revisions_enabled: self.assertIsNotNone(tmp.revision) self.assertEqual(str(tmp), "CC/1.0@private_user/channel") self.assertFalse(my_json["installed"][2]["recipe"]["downloaded"]) self.assertFalse(my_json["installed"][2]["packages"][0]["downloaded"]) self.assertFalse(my_json["installed"][2]["packages"][1]["downloaded"]) def test_json_create_multiconfig(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Lib(ConanFile): def package_info(self): self.cpp_info.release.libs = ["hello"] self.cpp_info.debug.libs = ["hello_d"] self.cpp_info.debug.libdirs = ["lib-debug"] """) self.client.save({'conanfile.py': conanfile}) self.client.run( "create . name/version@user/channel --json=myfile.json") my_json = self.client.load("myfile.json") my_json = json.loads(my_json) # Nodes with cpp_info cpp_info = my_json["installed"][0]["packages"][0]["cpp_info"] cpp_info_debug = cpp_info["configs"]["debug"] cpp_info_release = cpp_info["configs"]["release"] # Each node should have its own information self.assertFalse("libs" in cpp_info) self.assertEqual(cpp_info_debug["libs"], ["hello_d"]) self.assertEqual(cpp_info_release["libs"], ["hello"]) self.assertEqual(cpp_info_debug["libdirs"], ["lib-debug"]) self.assertEqual(cpp_info_release["libdirs"], [DEFAULT_LIB]) # FIXME: There are _empty_ nodes self.assertEqual(cpp_info_debug["builddirs"], [""]) self.assertEqual(cpp_info_release["builddirs"], [""]) # FIXME: Default information is duplicated in all the nodes dupe_nodes = [ "rootpath", "includedirs", "resdirs", "bindirs", "builddirs", "filter_empty" ] for dupe in dupe_nodes: self.assertEqual(cpp_info[dupe], cpp_info_debug[dupe]) self.assertEqual(cpp_info[dupe], cpp_info_release[dupe])
def reuse_test(self): self._export_upload("hello0/0.1@lasote/stable") self._export_upload("hello1/0.1@lasote/stable", 1, [0]) self._export_upload("hello2/0.1@lasote/stable", 2, [0]) self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2]) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) ref = ConanFileReference.loads("hello4/0.2@lasote/stable") files3 = hello_conan_files(ref=ref, number=4, deps=[3], lang='go') client.save(files3) client.run("install . --build missing") client.run("build .") with environment_append({ "PATH": ['$GOPATH/bin'], 'GOPATH': client.current_folder }): with client.chdir("src"): client.run_command('go install hello4_main') if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' with client.chdir("bin"): client.run_command(command) self.assertEqual( ['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'], str(client.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload hello3/0.1@lasote/stable --all") self.assertEqual(str(client.out).count("Uploading package"), 1) client.run("upload hello1/0.1@lasote/stable --all") self.assertEqual(str(client.out).count("Uploading package"), 1) client.run("upload hello2/0.1@lasote/stable --all") self.assertEqual(str(client.out).count("Uploading package"), 1) client.run("upload hello0/0.1@lasote/stable --all") self.assertEqual(str(client.out).count("Uploading package"), 1) # client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) ref = ConanFileReference.loads("hello4/0.2@lasote/stable") files3 = hello_conan_files(ref=ref, number=4, deps=[3], lang='go') client2.save(files3) client2.run("install . --build missing") with environment_append({ "PATH": ['$GOPATH/bin'], 'GOPATH': client2.current_folder }): with client2.chdir("src"): client2.run_command('go install hello4_main') if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' with client2.chdir("bin"): client2.run_command(command) self.assertEqual( ['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'], str(client2.out).splitlines()[-6:])
def reuse_test(self): client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files[CONANFILE] = files[CONANFILE].replace("build", "build2") client.save(files) client.run("export . lasote/stable") client.run("install %s --build missing" % str(ref)) self.assertTrue( os.path.exists(client.cache.package_layout(ref).builds())) self.assertTrue( os.path.exists(client.cache.package_layout(ref).packages())) # Upload client.run("upload %s --all" % str(ref)) # Now from other "computer" install the uploaded conans with same options (nothing) other_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_client.run("install %s --build missing" % str(ref)) self.assertFalse( os.path.exists(other_client.cache.package_layout(ref).builds())) self.assertTrue( os.path.exists(other_client.cache.package_layout(ref).packages())) # Now from other "computer" install the uploaded conans with same options (nothing) other_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_client.run("install %s --build" % str(ref)) self.assertTrue( os.path.exists(other_client.cache.package_layout(ref).builds())) self.assertTrue( os.path.exists(other_client.cache.package_layout(ref).packages())) # Use an invalid pattern and check that its not builded from source other_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_client.run("install %s --build HelloInvalid" % str(ref)) self.assertIn("No package matching 'HelloInvalid' pattern", other_client.out) self.assertFalse( os.path.exists(other_client.cache.package_layout(ref).builds())) # self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).packages())) # Use another valid pattern and check that its not builded from source other_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_client.run("install %s --build HelloInvalid -b Hello" % str(ref)) self.assertIn("No package matching 'HelloInvalid' pattern", other_client.out) # self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).builds())) # self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).packages())) # Now even if the package is in local store, check that's rebuilded other_client.run("install %s -b Hello*" % str(ref)) self.assertIn("Copying sources to build folder", other_client.out) other_client.run("install %s" % str(ref)) self.assertNotIn("Copying sources to build folder", other_client.out)
def install_transitive_pattern_test(self): # Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks client = TestClient() client.save({ "conanfile.py": """from conans import ConanFile class Pkg(ConanFile): options = {"shared": [True, False, "header"]} default_options = "shared=False" def package_info(self): self.output.info("PKG OPTION: %s" % self.options.shared) """ }) client.run("create . Pkg/0.1@user/testing -o shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) client.save({ "conanfile.py": """from conans import ConanFile class Pkg(ConanFile): requires = "Pkg/0.1@user/testing" options = {"shared": [True, False, "header"]} default_options = "shared=False" def package_info(self): self.output.info("PKG2 OPTION: %s" % self.options.shared) """ }) client.run("create . Pkg2/0.1@user/testing -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) client.run("install Pkg2/0.1@user/testing -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) # Priority of non-scoped options client.run( "create . Pkg2/0.1@user/testing -o shared=header -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o shared=header -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of exact named option client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of exact named option reverse client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header --build=missing" ) self.assertIn("Pkg/0.1@user/testing: Calling build()", client.out) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) # Prevalence of alphabetical pattern client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of alphabetical pattern, opposite order client.run( "create . Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence and override of alphabetical pattern client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
class Base(unittest.TestCase): conanfile = textwrap.dedent(""" from conans import ConanFile from conan.tools.cmake import CMake, CMakeToolchain class App(ConanFile): settings = "os", "arch", "compiler", "build_type" requires = "hello/0.1" generators = "CMakeDeps" options = {"shared": [True, False], "fPIC": [True, False]} default_options = {"shared": False, "fPIC": True} def generate(self): tc = CMakeToolchain(self) tc.variables["MYVAR"] = "MYVAR_VALUE" tc.variables["MYVAR2"] = "MYVAR_VALUE2" tc.variables.debug["MYVAR_CONFIG"] = "MYVAR_DEBUG" tc.variables.release["MYVAR_CONFIG"] = "MYVAR_RELEASE" tc.variables.debug["MYVAR2_CONFIG"] = "MYVAR2_DEBUG" tc.variables.release["MYVAR2_CONFIG"] = "MYVAR2_RELEASE" tc.preprocessor_definitions["MYDEFINE"] = "MYDEF_VALUE" tc.preprocessor_definitions["MYDEFINEINT"] = 42 tc.preprocessor_definitions.debug["MYDEFINE_CONFIG"] = "MYDEF_DEBUG" tc.preprocessor_definitions.release["MYDEFINE_CONFIG"] = "MYDEF_RELEASE" tc.preprocessor_definitions.debug["MYDEFINEINT_CONFIG"] = 421 tc.preprocessor_definitions.release["MYDEFINEINT_CONFIG"] = 422 tc.generate() def build(self): cmake = CMake(self) cmake.configure() cmake.build() """) lib_h = gen_function_h(name="app") lib_cpp = gen_function_cpp(name="app", msg="App", includes=["hello"], calls=["hello"], preprocessor=["MYVAR", "MYVAR_CONFIG", "MYDEFINE", "MYDEFINE_CONFIG", "MYDEFINEINT", "MYDEFINEINT_CONFIG"]) main = gen_function_cpp(name="main", includes=["app"], calls=["app"]) cmakelist = textwrap.dedent(""" cmake_minimum_required(VERSION 3.15) project(App C CXX) if(NOT CMAKE_TOOLCHAIN_FILE) message(FATAL ">> Not using toolchain") endif() message(">> CMAKE_GENERATOR_PLATFORM: ${CMAKE_GENERATOR_PLATFORM}") message(">> CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}") message(">> CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}") message(">> CMAKE_CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}") message(">> CMAKE_CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}") message(">> CMAKE_C_FLAGS: ${CMAKE_C_FLAGS}") message(">> CMAKE_C_FLAGS_DEBUG: ${CMAKE_C_FLAGS_DEBUG}") message(">> CMAKE_C_FLAGS_RELEASE: ${CMAKE_C_FLAGS_RELEASE}") message(">> CMAKE_SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}") message(">> CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}") message(">> CMAKE_CXX_STANDARD: ${CMAKE_CXX_STANDARD}") message(">> CMAKE_CXX_EXTENSIONS: ${CMAKE_CXX_EXTENSIONS}") message(">> CMAKE_POSITION_INDEPENDENT_CODE: ${CMAKE_POSITION_INDEPENDENT_CODE}") message(">> CMAKE_SKIP_RPATH: ${CMAKE_SKIP_RPATH}") message(">> CMAKE_INSTALL_NAME_DIR: ${CMAKE_INSTALL_NAME_DIR}") message(">> CMAKE_MODULE_PATH: ${CMAKE_MODULE_PATH}") message(">> CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}") message(">> BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}") get_directory_property(_COMPILE_DEFS DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS) message(">> COMPILE_DEFINITIONS: ${_COMPILE_DEFS}") find_package(hello REQUIRED) add_library(app_lib app_lib.cpp) target_link_libraries(app_lib PRIVATE hello::hello) target_compile_definitions(app_lib PRIVATE MYVAR="${MYVAR}") target_compile_definitions(app_lib PRIVATE MYVAR_CONFIG="${MYVAR_CONFIG}") add_executable(app app.cpp) target_link_libraries(app PRIVATE app_lib) """) def setUp(self): self.client = TestClient() conanfile = textwrap.dedent(""" from conans import ConanFile from conans.tools import save import os class Pkg(ConanFile): settings = "build_type" def package(self): save(os.path.join(self.package_folder, "include/hello.h"), '''#include <iostream> void hello(){std::cout<< "Hello: %s" <<std::endl;}''' % self.settings.build_type) """) self.client.save({"conanfile.py": conanfile}) self.client.run("create . hello/0.1@ -s build_type=Debug") self.client.run("create . hello/0.1@ -s build_type=Release") # Prepare the actual consumer package self.client.save({"conanfile.py": self.conanfile, "CMakeLists.txt": self.cmakelist, "app.cpp": self.main, "app_lib.cpp": self.lib_cpp, "app.h": self.lib_h}) def _run_build(self, settings=None, options=None): # Build the profile according to the settings provided settings = settings or {} settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) options = " ".join("-o %s=%s" % (k, v) for k, v in options.items()) if options else "" # Run the configure corresponding to this test case build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/") with self.client.chdir(build_directory): self.client.run("install .. %s %s" % (settings, options)) install_out = self.client.out self.client.run("build ..") return install_out def _modify_code(self): lib_cpp = gen_function_cpp(name="app", msg="AppImproved", includes=["hello"], calls=["hello"], preprocessor=["MYVAR", "MYVAR_CONFIG", "MYDEFINE", "MYDEFINE_CONFIG", "MYDEFINEINT", "MYDEFINEINT_CONFIG"]) self.client.save({"app_lib.cpp": lib_cpp}) content = self.client.load("CMakeLists.txt") content = content.replace(">>", "++>>") self.client.save({"CMakeLists.txt": content}) def _incremental_build(self, build_type=None): build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/") with self.client.chdir(build_directory): config = "--config %s" % build_type if build_type else "" self.client.run_command("cmake --build . %s" % config) def _run_app(self, build_type, bin_folder=False, msg="App", dyld_path=None): if dyld_path: build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/") command_str = 'DYLD_LIBRARY_PATH="%s" build/app' % build_directory else: command_str = "build/%s/app.exe" % build_type if bin_folder else "build/app" if platform.system() == "Windows": command_str = command_str.replace("/", "\\") self.client.run_command(command_str) self.assertIn("Hello: %s" % build_type, self.client.out) self.assertIn("%s: %s!" % (msg, build_type), self.client.out) self.assertIn("MYVAR: MYVAR_VALUE", self.client.out) self.assertIn("MYVAR_CONFIG: MYVAR_%s" % build_type.upper(), self.client.out) self.assertIn("MYDEFINE: MYDEF_VALUE", self.client.out) self.assertIn("MYDEFINE_CONFIG: MYDEF_%s" % build_type.upper(), self.client.out) self.assertIn("MYDEFINEINT: 42", self.client.out) self.assertIn("MYDEFINEINT_CONFIG: {}".format(421 if build_type == "Debug" else 422), self.client.out)
def test_dependents_new_buildenv(): client = TestClient() boost = textwrap.dedent(""" from conans import ConanFile class Boost(ConanFile): def package_info(self): self.buildenv_info.define_path("PATH", "myboostpath") """) other = textwrap.dedent(""" from conans import ConanFile class Other(ConanFile): requires = "boost/1.0" def package_info(self): self.buildenv_info.append_path("PATH", "myotherpath") self.buildenv_info.prepend_path("PATH", "myotherprepend") """) consumer = textwrap.dedent(""" from conans import ConanFile from conan.tools.env import VirtualBuildEnv import os class Lib(ConanFile): build_requires = {} def generate(self): build_env = VirtualBuildEnv(self).environment() with build_env.apply(): self.output.info("LIB PATH %s" % os.getenv("PATH")) """) client.save({ "boost/conanfile.py": boost, "other/conanfile.py": other, "consumer/conanfile.py": consumer.format('"boost/1.0", "other/1.0"'), "profile_define": "[buildenv]\nPATH=(path)profilepath", "profile_append": "[buildenv]\nPATH+=(path)profilepath", "profile_prepend": "[buildenv]\nPATH=+(path)profilepath" }) client.run("create boost boost/1.0@") client.run("create other other/1.0@") client.run("install consumer") result = os.pathsep.join(["myotherprepend", "myboostpath", "myotherpath"]) assert "LIB PATH {}".format(result) in client.out # Now test if we declare in different order, still topological order should be respected client.save( {"consumer/conanfile.py": consumer.format('"other/1.0", "boost/1.0"')}) client.run("install consumer") assert "LIB PATH {}".format(result) in client.out client.run("install consumer -pr=profile_define") assert "LIB PATH profilepath" in client.out client.run("install consumer -pr=profile_append") result = os.pathsep.join( ["myotherprepend", "myboostpath", "myotherpath", "profilepath"]) assert "LIB PATH {}".format(result) in client.out client.run("install consumer -pr=profile_prepend") result = os.pathsep.join( ["profilepath", "myotherprepend", "myboostpath", "myotherpath"]) assert "LIB PATH {}".format(result) in client.out
class InstallTest(unittest.TestCase): def setUp(self): self.client = TestClient() self.settings = ("-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 " "-s arch=x86 -s compiler.runtime=MD") def install_package_folder_test(self): # Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks client = TestClient() client.save({"conanfile.py": """from conans import ConanFile import os class Pkg(ConanFile): def package_info(self): self.dummy_doesnt_exist_not_break self.output.info("Hello") self.env_info.PATH = os.path.join(self.package_folder, "bin") """}) client.run("install .") self.assertNotIn("Hello", client.out) self.assertIn("PROJECT: Generated conaninfo.txt", client.out) def _create(self, number, version, deps=None, export=True, no_config=False): files = cpp_hello_conan_files(number, version, deps, build=False, config=not no_config) self.client.save(files, clean_first=True) if export: self.client.run("export lasote/stable") def install_error_never_test(self): self._create("Hello0", "0.1", export=False) error = self.client.run("install --build never --build missing", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) error = self.client.run("install --build never --build Hello", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) error = self.client.run("install --build never --build outdated", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) def install_combined_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("install %s --build=missing" % (self.settings)) self.client.run("install %s --build=missing --build Hello1" % (self.settings)) self.assertIn("Hello0/0.1@lasote/stable: Already installed!", self.client.user_io.out) self.assertIn("Hello1/0.1@lasote/stable: WARN: Forced build from source", self.client.user_io.out) def install_transitive_cache_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"]) self.client.run("install Hello2/0.1@lasote/stable %s --build=missing" % (self.settings)) self.assertIn("Hello0/0.1@lasote/stable: Generating the package", self.client.user_io.out) self.assertIn("Hello1/0.1@lasote/stable: Generating the package", self.client.user_io.out) self.assertIn("Hello2/0.1@lasote/stable: Generating the package", self.client.user_io.out) def partials_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("install %s --build=missing" % self.settings) self.client.run("install %s --build=Bye" % self.settings) self.assertIn("No package matching 'Bye' pattern", self.client.user_io.out) for package in ["Hello0", "Hello1"]: self.client.run("install %s --build=%s" % (self.settings, package)) self.assertNotIn("No package matching", self.client.user_io.out) def reuse_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26", "44671ecdd9c606eb7166f2197ab50be8d36a3c3b"), (1, "8b964e421a5b7e48b7bc19b94782672be126be8b", "3eeab577a3134fa3afdcd82881751789ec48e08f")]: self.client.run("install -o language=%d %s --build missing" % (lang, self.settings)) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("arch=x86\n" "compiler=Visual Studio\n" "compiler.runtime=MD\n" "compiler.version=12\n" "os=Windows", conan_info.settings.dumps()) self.assertEqual("language=%s\nstatic=True" % lang, conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, id0)) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(lang, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), id1) hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(lang, hello1_conan_info.options.language) def upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run("install -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s" " --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=1\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def inverse_upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run("install -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s " "--build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=0\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual("language=0\nstatic=True", hello0_conan_info.options.dumps()) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "3eeab577a3134fa3afdcd82881751789ec48e08f") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual("language=1\nstatic=True", hello1_conan_info.options.dumps()) def upper_option_txt_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) files = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"]) files.pop(CONANFILE) files[CONANFILE_TXT] = """[requires] Hello1/0.1@lasote/stable [options] Hello0:language=1 Hello1:language=0 """ self.client.save(files, clean_first=True) self.client.run("install %s --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def change_option_txt_test(self): self._create("Hello0", "0.1") client = TestClient(base_folder=self.client.base_folder) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=1 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=1", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b", conan_info.full_requires.dumps()) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=0 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) # For conan install options are not cached anymore self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) # it is necessary to clean the cached conaninfo client.save(files, clean_first=True) client.run("install %s --build missing" % self.settings) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26", conan_info.full_requires.dumps()) def cross_platform_msg_test(self): bad_os = "Linux" if platform.system() != "Linux" else "Macos" message = "Cross-platform from '%s' to '%s'" % (detected_os(), bad_os) self._create("Hello0", "0.1") self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os, ignore_error=True) self.assertIn(message, self.client.user_io.out) def install_cwd_test(self): conanfile = """from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "0.1" settings = "os" """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("export lasote/stable") client.save({"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}, clean_first=True) client.run("install . --build=missing -s os=Windows --install-folder=win_dir") client.run("install . --build=missing -s os=Macos --install-folder=os_dir") conaninfo = load(os.path.join(client.current_folder, "win_dir/conaninfo.txt")) self.assertIn("os=Windows", conaninfo) self.assertNotIn("os=Macos", conaninfo) conaninfo = load(os.path.join(client.current_folder, "os_dir/conaninfo.txt")) self.assertNotIn("os=Windows", conaninfo) self.assertIn("os=Macos", conaninfo) def install_reference_not_conanbuildinfo_test(self): conanfile = """from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "0.1" settings = "os" """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("create conan/stable") client.save({}, clean_first=True) client.run("install Hello/0.1@conan/stable") self.assertFalse(os.path.exists(os.path.join(client.current_folder, "conanbuildinfo.txt")))
class MultiRemoteTest(unittest.TestCase): def setUp(self): self.servers = OrderedDict() self.users = {} for i in range(3): test_server = TestServer() self.servers["remote%d" % i] = test_server self.users["remote%d" % i] = [("lasote", "mypass")] self.client = TestClient(servers=self.servers, users=self.users) def predefine_remote_test(self): files = cpp_hello_conan_files("Hello0", "0.1", build=False) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("upload Hello0/0.1@lasote/stable -r=remote0") self.client.run("upload Hello0/0.1@lasote/stable -r=remote1") self.client.run("upload Hello0/0.1@lasote/stable -r=remote2") self.client.run('remove "*" -f') self.client.run("remote add_ref Hello0/0.1@lasote/stable remote1") self.client.run("install Hello0/0.1@lasote/stable --build=missing") self.assertIn( "Hello0/0.1@lasote/stable: Retrieving from predefined remote 'remote1'", self.client.out) self.client.run("remote list_ref") self.assertIn(": remote1", self.client.out) def upload_test(self): ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1", build=False) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("upload %s" % str(ref)) self.client.run("info %s" % str(ref)) self.assertIn("remote0=http://", self.client.out) # The remote, once fixed does not change self.client.run("upload %s -r=remote1" % str(ref)) self.client.run("info %s" % str(ref)) self.assertIn("remote0=http://", self.client.out) # Now install it in other machine from remote 0 client2 = TestClient(servers=self.servers, users=self.users) client2.run("install %s --build=missing" % str(ref)) client2.run("info %s" % str(ref)) self.assertIn("remote0=http://", client2.out) # Now install it in other machine from remote 1 servers = self.servers.copy() servers.pop("remote0") client3 = TestClient(servers=servers, users=self.users) client3.run("install %s --build=missing" % str(ref)) client3.run("info %s" % str(ref)) self.assertIn("remote1=http://", client3.out) def fail_when_not_notfound_test(self): """ If a remote fails with a 404 it has to keep looking in the next remote, but if it fails by any other reason it has to stop """ servers = OrderedDict() servers["s0"] = TestServer() servers["s1"] = TestServer() servers["s2"] = TestServer() client = TestClient(servers=servers, users=self.users) files = cpp_hello_conan_files("MyLib", "0.1", build=False) client.save(files) client.run("create . lasote/testing") client.run("user lasote -p mypass -r s1") client.run("upload MyLib* -r s1 -c") servers[ "s1"].fake_url = "http://asdlhaljksdhlajkshdljakhsd.com" # Do not exist client2 = TestClient(servers=servers, users=self.users) err = client2.run("install MyLib/0.1@conan/testing --build=missing", assert_error=True) self.assertTrue(err) self.assertIn("MyLib/0.1@conan/testing: Trying with 's0'...", client2.out) self.assertIn("MyLib/0.1@conan/testing: Trying with 's1'...", client2.out) self.assertIn( "Unable to connect to s1=http://asdlhaljksdhlajkshdljakhsd.com", client2.out) # s2 is not even tried self.assertNotIn("MyLib/0.1@conan/testing: Trying with 's2'...", client2.out) def install_from_remotes_test(self): for i in range(3): ref = ConanFileReference.loads("Hello%d/0.1@lasote/stable" % i) files = cpp_hello_conan_files("Hello%d" % i, "0.1", build=False) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("upload %s -r=remote%d" % (str(ref), i)) self.client.run("info %s" % str(ref)) self.assertIn("remote%d=http://" % i, self.client.out) # Now install it in other machine from remote 0 client2 = TestClient(servers=self.servers, users=self.users) files = cpp_hello_conan_files("HelloX", "0.1", deps=[ "Hello0/0.1@lasote/stable", "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable" ]) files["conanfile.py"] = files["conanfile.py"].replace( "def build(", "def build2(") client2.save(files) client2.run("install . --build=missing") self.assertIn("Hello0/0.1@lasote/stable from 'remote0'", client2.out) self.assertIn("Hello1/0.1@lasote/stable from 'remote1'", client2.out) self.assertIn("Hello2/0.1@lasote/stable from 'remote2'", client2.out) client2.run("info .") self.assertIn("Remote: remote0=http://", client2.out) self.assertIn("Remote: remote1=http://", client2.out) self.assertIn("Remote: remote2=http://", client2.out) @unittest.skipIf( TestClient().cache.config.revisions_enabled, "This test is not valid for revisions, where we keep iterating the remotes " "for searching a package for the same recipe revision") def package_binary_remote_test(self): # https://github.com/conan-io/conan/issues/3882 conanfile = """from conans import ConanFile class ConanFileToolsTest(ConanFile): pass """ # Upload recipe + package to remote1 and remote2 reference = "Hello/0.1@lasote/stable" self.client.save({"conanfile.py": conanfile}) self.client.run("create . %s" % reference) self.client.run("upload %s -r=remote0 --all" % reference) self.client.run("upload %s -r=remote2 --all" % reference) ref = ConanFileReference.loads(reference) # Remove only binary from remote1 and everything in local self.client.run("remove -f %s -p -r remote0" % reference) self.client.run('remove "*" -f') self.servers.pop("remote1") # Now install it from a client, it won't find the binary in remote2 self.client.run("install %s" % reference, assert_error=True) self.assertIn("Can't find a 'Hello/0.1@lasote/stable' package", self.client.out) self.assertNotIn("remote2", self.client.out) self.client.run("install %s -r remote2" % reference) self.assertIn( "Package installed 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", self.client.out) self.assertIn("Hello/0.1@lasote/stable from 'remote0' - Cache", self.client.out) metadata = self.client.cache.package_layout(ref).load_metadata() self.assertEqual(metadata.recipe.remote, "remote0") self.assertEqual( metadata.packages["5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9"]. remote, "remote2") client2 = TestClient(servers=self.servers, users=self.users) time.sleep(1) # Make sure timestamps increase client2.save({"conanfile.py": conanfile + " # Comment"}) client2.run("create . %s" % reference) client2.run("upload %s -r=remote2 --all" % reference) # Install from client, it should update the package from remote2 self.client.run("install %s --update" % reference) self.assertNotIn( "Hello/0.1@lasote/stable: WARN: Can't update, no package in remote", self.client.out) self.assertIn( "Hello/0.1@lasote/stable:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 - Update", self.client.out) self.assertIn("Downloading conan_package.tgz", self.client.out)
def package_info_components_complete_test(self): dep = textwrap.dedent(""" import os from conans import ConanFile class Dep(ConanFile): exports_sources = "*" def package(self): self.copy("*") def package_info(self): self.cpp_info.name = "Galaxy" self.cpp_info.components["Starlight"].includedirs = [os.path.join("galaxy", "starlight")] self.cpp_info.components["Starlight"].libs = ["libstarlight"] self.cpp_info.components["Planet"].includedirs = [os.path.join("galaxy", "planet")] self.cpp_info.components["Planet"].libs = ["libplanet"] self.cpp_info.components["Planet"].requires = ["Starlight"] self.cpp_info.components["Launcher"].system_libs = ["ground"] self.cpp_info.components["ISS"].includedirs = [os.path.join("galaxy", "iss")] self.cpp_info.components["ISS"].libs = ["libiss"] self.cpp_info.components["ISS"].libdirs = ["iss_libs"] self.cpp_info.components["ISS"].system_libs = ["solar", "magnetism"] self.cpp_info.components["ISS"].requires = ["Starlight", "Launcher"] """) consumer = textwrap.dedent(""" from conans import ConanFile class Consumer(ConanFile): requires = "dep/1.0@us/ch" def build(self): # Global values self.output.info("GLOBAL Include paths: %s" % list(self.deps_cpp_info.include_paths)) self.output.info("GLOBAL Library paths: %s" % list(self.deps_cpp_info.lib_paths)) self.output.info("GLOBAL Binary paths: %s" % list(self.deps_cpp_info.bin_paths)) self.output.info("GLOBAL Libs: %s" % list(self.deps_cpp_info.libs)) self.output.info("GLOBAL System libs: %s" % list(self.deps_cpp_info.system_libs)) # Deps values for dep_key, dep_value in self.deps_cpp_info.dependencies: self.output.info("DEPS name: %s" % dep_value.get_name('txt')) self.output.info("DEPS Include paths: %s" % list(dep_value.include_paths)) self.output.info("DEPS Library paths: %s" % list(dep_value.lib_paths)) self.output.info("DEPS Binary paths: %s" % list(dep_value.bin_paths)) self.output.info("DEPS Libs: %s" % list(dep_value.libs)) self.output.info("DEPS System libs: %s" % list(dep_value.system_libs)) # Components values for dep_key, dep_value in self.deps_cpp_info.dependencies: for comp_name, comp_value in dep_value.components.items(): self.output.info("COMP %s Include paths: %s" % (comp_name, list(comp_value.include_paths))) self.output.info("COMP %s Library paths: %s" % (comp_name, list(comp_value.lib_paths))) self.output.info("COMP %s Binary paths: %s" % (comp_name, list(comp_value.bin_paths))) self.output.info("COMP %s Libs: %s" % (comp_name, list(comp_value.libs))) self.output.info("COMP %s Requires: %s" % (comp_name, list(comp_value.requires))) self.output.info("COMP %s System libs: %s" % (comp_name, list(comp_value.system_libs))) """) client = TestClient() client.save({ "conanfile_dep.py": dep, "conanfile_consumer.py": consumer, "galaxy/starlight/starlight.h": "", "lib/libstarlight": "", "galaxy/planet/planet.h": "", "lib/libplanet": "", "galaxy/iss/iss.h": "", "iss_libs/libiss": "", "bin/exelauncher": "" }) dep_ref = ConanFileReference("dep", "1.0", "us", "ch") dep_pref = PackageReference(dep_ref, NO_SETTINGS_PACKAGE_ID) client.run("create conanfile_dep.py dep/1.0@us/ch") client.run("create conanfile_consumer.py consumer/1.0@us/ch") package_folder = client.cache.package_layout(dep_ref).package(dep_pref) expected_comp_starlight_include_paths = [ os.path.join(package_folder, "galaxy", "starlight") ] expected_comp_planet_include_paths = [ os.path.join(package_folder, "galaxy", "planet") ] expected_comp_launcher_include_paths = [] expected_comp_iss_include_paths = [ os.path.join(package_folder, "galaxy", "iss") ] expected_comp_starlight_library_paths = [ os.path.join(package_folder, "lib") ] expected_comp_launcher_library_paths = [ os.path.join(package_folder, "lib") ] expected_comp_planet_library_paths = [ os.path.join(package_folder, "lib") ] expected_comp_iss_library_paths = [ os.path.join(package_folder, "iss_libs") ] expected_comp_starlight_binary_paths = [ os.path.join(package_folder, "bin") ] expected_comp_launcher_binary_paths = [ os.path.join(package_folder, "bin") ] expected_comp_planet_binary_paths = [ os.path.join(package_folder, "bin") ] expected_comp_iss_binary_paths = [os.path.join(package_folder, "bin")] expected_global_include_paths = expected_comp_planet_include_paths + \ expected_comp_iss_include_paths + expected_comp_starlight_include_paths expected_global_library_paths = expected_comp_starlight_library_paths + \ expected_comp_iss_library_paths expected_global_binary_paths = expected_comp_starlight_binary_paths self.assertIn( "GLOBAL Include paths: %s" % expected_global_include_paths, client.out) self.assertIn( "GLOBAL Library paths: %s" % expected_global_library_paths, client.out) self.assertIn("GLOBAL Binary paths: %s" % expected_global_binary_paths, client.out) self.assertIn("GLOBAL Libs: ['libplanet', 'libiss', 'libstarlight']", client.out) self.assertIn("GLOBAL System libs: ['solar', 'magnetism', 'ground']", client.out) self.assertIn("DEPS name: Galaxy", client.out) self.assertIn("DEPS Include paths: %s" % expected_global_include_paths, client.out) self.assertIn("DEPS Library paths: %s" % expected_global_library_paths, client.out) self.assertIn("DEPS Binary paths: %s" % expected_global_binary_paths, client.out) self.assertIn("DEPS Libs: ['libplanet', 'libiss', 'libstarlight']", client.out) self.assertIn("DEPS System libs: ['solar', 'magnetism', 'ground']", client.out) self.assertIn( "COMP Starlight Include paths: %s" % list(expected_comp_starlight_include_paths), client.out) self.assertIn( "COMP Planet Include paths: %s" % list(expected_comp_planet_include_paths, ), client.out) self.assertIn( "COMP Launcher Include paths: %s" % list(expected_comp_launcher_include_paths), client.out) self.assertIn( "COMP ISS Include paths: %s" % list(expected_comp_iss_include_paths), client.out) self.assertIn( "COMP Starlight Library paths: %s" % list(expected_comp_starlight_library_paths), client.out) self.assertIn( "COMP Planet Library paths: %s" % list(expected_comp_planet_library_paths), client.out) self.assertIn( "COMP Launcher Library paths: %s" % list(expected_comp_launcher_library_paths), client.out) self.assertIn( "COMP ISS Library paths: %s" % list(expected_comp_iss_library_paths), client.out) self.assertIn( "COMP Starlight Binary paths: %s" % list(expected_comp_iss_binary_paths), client.out) self.assertIn( "COMP Planet Binary paths: %s" % list(expected_comp_planet_binary_paths), client.out) self.assertIn( "COMP Launcher Binary paths: %s" % list(expected_comp_launcher_binary_paths), client.out) self.assertIn( "COMP ISS Binary paths: %s" % list(expected_comp_iss_binary_paths), client.out) self.assertIn("COMP Starlight Libs: ['libstarlight']", client.out) self.assertIn("COMP Planet Libs: ['libplanet']", client.out) self.assertIn("COMP Launcher Libs: []", client.out) self.assertIn("COMP ISS Libs: ['libiss']", client.out) self.assertIn("COMP Starlight System libs: []", client.out) self.assertIn("COMP Planet System libs: []", client.out) self.assertIn("COMP Launcher System libs: ['ground']", client.out) self.assertIn("COMP ISS System libs: ['solar', 'magnetism']", client.out) self.assertIn("COMP Starlight Requires: []", client.out) self.assertIn("COMP Launcher Requires: []", client.out) self.assertIn("COMP Planet Requires: ['Starlight']", client.out) self.assertIn("COMP ISS Requires: ['Starlight', 'Launcher']", client.out)
class InstallTest(unittest.TestCase): def setUp(self): self.client = TestClient() self.settings = ( "-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 " "-s arch=x86 -s compiler.runtime=MD") def install_transitive_pattern_test(self): # Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks client = TestClient() client.save({ "conanfile.py": """from conans import ConanFile class Pkg(ConanFile): options = {"shared": [True, False, "header"]} default_options = "shared=False" def package_info(self): self.output.info("PKG OPTION: %s" % self.options.shared) """ }) client.run("create . Pkg/0.1@user/testing -o shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) client.save({ "conanfile.py": """from conans import ConanFile class Pkg(ConanFile): requires = "Pkg/0.1@user/testing" options = {"shared": [True, False, "header"]} default_options = "shared=False" def package_info(self): self.output.info("PKG2 OPTION: %s" % self.options.shared) """ }) client.run("create . Pkg2/0.1@user/testing -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) client.run("install Pkg2/0.1@user/testing -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) # Priority of non-scoped options client.run( "create . Pkg2/0.1@user/testing -o shared=header -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o shared=header -o *:shared=True") self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of exact named option client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of exact named option reverse client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header --build=missing" ) self.assertIn("Pkg/0.1@user/testing: Calling build()", client.out) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out) # Prevalence of alphabetical pattern client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence of alphabetical pattern, opposite order client.run( "create . Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) # Prevalence and override of alphabetical pattern client.run( "create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) client.run( "install Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header" ) self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out) self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out) def install_package_folder_test(self): # Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks client = TestClient() client.save({ "conanfile.py": """from conans import ConanFile import os class Pkg(ConanFile): def package_info(self): self.dummy_doesnt_exist_not_break self.output.info("Hello") self.env_info.PATH = os.path.join(self.package_folder, "bin") """ }) client.run("install .") self.assertNotIn("Hello", client.out) self.assertIn("PROJECT: Generated conaninfo.txt", client.out) def _create(self, number, version, deps=None, export=True, no_config=False, settings=None): files = cpp_hello_conan_files(number, version, deps, build=False, config=not no_config, settings=settings) self.client.save(files, clean_first=True) if export: self.client.run("export . lasote/stable") def install_error_never_test(self): self._create("Hello0", "0.1", export=False) error = self.client.run("install . --build never --build missing", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) error = self.client.run( "install conanfile.py --build never --build Hello", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) error = self.client.run( "install ./conanfile.py --build never --build outdated", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: --build=never not compatible with other options", self.client.user_io.out) def install_combined_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("install . %s --build=missing" % (self.settings)) self.client.run("install . %s --build=missing --build Hello1" % (self.settings)) self.assertIn("Hello0/0.1@lasote/stable: Already installed!", self.client.user_io.out) self.assertIn( "Hello1/0.1@lasote/stable: WARN: Forced build from source", self.client.user_io.out) def install_transitive_cache_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"]) self.client.run("install Hello2/0.1@lasote/stable %s --build=missing" % (self.settings)) self.assertIn("Hello0/0.1@lasote/stable: Generating the package", self.client.user_io.out) self.assertIn("Hello1/0.1@lasote/stable: Generating the package", self.client.user_io.out) self.assertIn("Hello2/0.1@lasote/stable: Generating the package", self.client.user_io.out) def partials_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("install . %s --build=missing" % self.settings) self.client.run("install ./ %s --build=Bye" % self.settings) self.assertIn("No package matching 'Bye' pattern", self.client.user_io.out) for package in ["Hello0", "Hello1"]: self.client.run("install . %s --build=%s" % (self.settings, package)) self.assertNotIn("No package matching", self.client.user_io.out) def reuse_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26", "44671ecdd9c606eb7166f2197ab50be8d36a3c3b"), (1, "8b964e421a5b7e48b7bc19b94782672be126be8b", "3eeab577a3134fa3afdcd82881751789ec48e08f")]: self.client.run("install . -o language=%d %s --build missing" % (lang, self.settings)) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual( "arch=x86\n" "compiler=Visual Studio\n" "compiler.runtime=MD\n" "compiler.version=12\n" "os=Windows", conan_info.settings.dumps()) self.assertEqual("language=%s\nstatic=True" % lang, conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference( conan_ref, id0)) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(lang, hello0_conan_info.options.language) package_ref1 = PackageReference( ConanFileReference.loads("Hello1/0.1@lasote/stable"), id1) hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(lang, hello1_conan_info.options.language) def upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run( "install conanfile.py -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s" " --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=1\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package( PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference( ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def inverse_upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run( "install . -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s " "--build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=0\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package( PackageReference(conan_ref, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual("language=0\nstatic=True", hello0_conan_info.options.dumps()) package_ref1 = PackageReference( ConanFileReference.loads("Hello1/0.1@lasote/stable"), "3eeab577a3134fa3afdcd82881751789ec48e08f") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual("language=1\nstatic=True", hello1_conan_info.options.dumps()) def upper_option_txt_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) files = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"]) files.pop(CONANFILE) files[CONANFILE_TXT] = """[requires] Hello1/0.1@lasote/stable [options] Hello0:language=1 Hello1:language=0 """ self.client.save(files, clean_first=True) self.client.run("install . %s --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package( PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference( ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def change_option_txt_test(self): self._create("Hello0", "0.1") client = TestClient(base_folder=self.client.base_folder) files = { CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=1 """ } client.save(files) client.run("install conanfile.txt %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=1", conan_info.full_options.dumps()) self.assertIn( "Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b", conan_info.full_requires.dumps()) files = { CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=0 """ } client.save(files) client.run("install . %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) # For conan install options are not cached anymore self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) # it is necessary to clean the cached conaninfo client.save(files, clean_first=True) client.run("install ./conanfile.txt %s --build missing" % self.settings) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) self.assertIn( "Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26", conan_info.full_requires.dumps()) def cross_platform_msg_test(self): # Explicit with os_build and os_arch settings message = "Cross-build from 'Linux:x86_64' to 'Windows:x86_64'" self._create( "Hello0", "0.1", settings='"os_build", "os", "arch_build", "arch", "compiler"') self.client.run( "install Hello0/0.1@lasote/stable -s os_build=Linux -s os=Windows", ignore_error=True) self.assertIn(message, self.client.user_io.out) # Implicit detection when not available (retrocompatibility) bad_os = "Linux" if platform.system() != "Linux" else "Macos" message = "Cross-build from '%s:x86_64' to '%s:x86_64'" % ( detected_os(), bad_os) self._create("Hello0", "0.1") self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os, ignore_error=True) self.assertIn(message, self.client.user_io.out) def install_cwd_test(self): conanfile = """from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "0.1" settings = "os" """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("export . lasote/stable") client.save({"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}, clean_first=True) client.run( "install . --build=missing -s os=Windows -s os_build=Windows --install-folder=win_dir" ) self.assertIn("Hello/0.1@lasote/stable from local cache", client.out) # Test "from local cache" output message client.run( "install . --build=missing -s os=Macos -s os_build=Macos --install-folder=os_dir" ) conaninfo = load( os.path.join(client.current_folder, "win_dir/conaninfo.txt")) self.assertIn("os=Windows", conaninfo) self.assertNotIn("os=Macos", conaninfo) conaninfo = load( os.path.join(client.current_folder, "os_dir/conaninfo.txt")) self.assertNotIn("os=Windows", conaninfo) self.assertIn("os=Macos", conaninfo) def install_reference_not_conanbuildinfo_test(self): conanfile = """from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "0.1" settings = "os" """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("create . conan/stable") client.save({}, clean_first=True) client.run("install Hello/0.1@conan/stable") self.assertFalse( os.path.exists( os.path.join(client.current_folder, "conanbuildinfo.txt"))) def install_with_profile_test(self): # Test for https://github.com/conan-io/conan/pull/2043 conanfile = """from conans import ConanFile class TestConan(ConanFile): settings = "os" def requirements(self): self.output.info("PKGOS=%s" % self.settings.os) """ client = TestClient() client.save({"conanfile.py": conanfile}) client.run("profile new myprofile") client.run("profile update settings.os=Linux myprofile") client.run("install . -pr=myprofile --build") self.assertIn("PKGOS=Linux", client.out) mkdir(os.path.join(client.current_folder, "myprofile")) client.run("install . -pr=myprofile") client.run("profile new myotherprofile") client.run("profile update settings.os=FreeBSD myotherprofile") client.run("install . -pr=myotherprofile") self.assertIn("PKGOS=FreeBSD", client.out) client.save({"myotherprofile": "Some garbage without sense [garbage]"}) client.run("install . -pr=myotherprofile") self.assertIn("PKGOS=FreeBSD", client.out) error = client.run("install . -pr=./myotherprofile", ignore_error=True) self.assertTrue(error) self.assertIn("Error parsing the profile", client.out) def install_with_path_errors_test(self): client = TestClient() # Install without path param not allowed error = client.run("install", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: Exiting with code: 2", client.out) # Path with wrong conanfile.txt path error = client.run( "install not_real_dir/conanfile.txt --install-folder subdir", ignore_error=True) self.assertTrue(error) self.assertIn("Conanfile not found", client.out) # Path with wrong conanfile.py path error = client.run( "install not_real_dir/conanfile.py --install-folder build", ignore_error=True) self.assertTrue(error) self.assertIn("Conanfile not found", client.out) def install_broken_reference_test(self): client = TestClient(servers={"default": TestServer()}, users={"default": [("lasote", "mypass")]}) conanfile = """from conans import ConanFile class Pkg(ConanFile): pass """ client.save({"conanfile.py": conanfile}) client.run("export . Hello/0.1@lasote/stable") client.run("remote add_ref Hello/0.1@lasote/stable default") conan_reference = ConanFileReference.loads("Hello/0.1@lasote/stable") rmdir(os.path.join(client.client_cache.conan(conan_reference))) error = client.run("install Hello/0.1@lasote/stable", ignore_error=True) self.assertTrue(error) self.assertIn( "ERROR: Hello/0.1@lasote/stable was not found in remote 'default'", client.out) # If it was associated, it has to be desasociated client.run("remote remove_ref Hello/0.1@lasote/stable") error = client.run("install Hello/0.1@lasote/stable", ignore_error=True) self.assertTrue(error) self.assertIn( "ERROR: Unable to find 'Hello/0.1@lasote/stable' in remotes", client.out) def install_argument_order_test(self): # https://github.com/conan-io/conan/issues/2520 conanfile_boost = """from conans import ConanFile class BoostConan(ConanFile): name = "boost" version = "0.1" options = {"shared": [True, False]} default_options = "shared=True" """ conanfile = """from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "0.1" requires = "boost/0.1@conan/stable" """ client = TestClient() client.save({ "conanfile.py": conanfile, "conanfile_boost.py": conanfile_boost }) client.run("create conanfile_boost.py conan/stable") client.run("install . -o boost:shared=True --build=missing") output_0 = "%s" % client.out client.run("install . -o boost:shared=True --build missing") output_1 = "%s" % client.out client.run("install -o boost:shared=True . --build missing") output_2 = "%s" % client.out client.run("install -o boost:shared=True --build missing .") output_3 = "%s" % client.out self.assertNotIn("ERROR", output_3) self.assertEqual(output_0, output_1) self.assertEqual(output_1, output_2) self.assertEqual(output_2, output_3) client.run( "install -o boost:shared=True --build boost . --build missing") output_4 = "%s" % client.out client.run( "install -o boost:shared=True --build missing --build boost .") output_5 = "%s" % client.out self.assertEqual(output_4, output_5)
def package_requires_in_components_requires_test(self): client = TestClient() client.save({ "conanfile1.py": GenConanfile("dep1", "0.1"), "conanfile2.py": GenConanfile("dep2", "0.1") }) client.run("create conanfile1.py") client.run("create conanfile2.py") conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": []}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep1' not used in " "components requires", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep1::dep1"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep2' not used in components " "requires", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep1::dep1"]}, "kkk": {"requires": ["kk"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep2' not used in components " "requires", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": []}, "kkk": {"requires": ["kk"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep1' not used in components " "requires", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]}, "kkk": {"requires": ["dep3::dep3"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep1' not used in components " "requires", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]}, "kkk": {"requires": ["dep3::dep3"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep3' declared in components " "requires but not defined as a recipe requirement", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py", assert_error=True) self.assertIn( "consumer/0.1 package_info(): Package require 'dep2' declared in components " "requires but not defined as a recipe requirement", client.out) conanfile = GenConanfile("consumer", "0.1") \ .with_requirement("dep1/0.1") \ .with_requirement("dep2/0.1") \ .with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]}, "kkk": {"requires": ["dep1::dep1"]}}}, env_info={}) client.save({"conanfile.py": conanfile}) client.run("create conanfile.py") # Correct usage
def test_trace_actions(self): client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) trace_file = os.path.join(temp_folder(), "conan_trace.log") with tools.environment_append({"CONAN_TRACE_FILE": trace_file}): # UPLOAD A PACKAGE ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True, build=False) client.save(files) client.run("user lasote -p mypass -r default") client.run("export . lasote/stable") client.run("install %s --build missing" % str(ref)) client.run("upload %s --all" % str(ref)) traces = load(trace_file) self.assertNotIn("mypass", traces) self.assertIn('"password": "******"', traces) self.assertIn('"Authorization": "**********"', traces) self.assertIn('"X-Client-Anonymous-Id": "**********"', traces) actions = traces.splitlines() without_rest_api = [it for it in actions if "REST_API_CALL" not in it] self.assertTrue(len(without_rest_api) == 11) for trace in actions: doc = json.loads(trace) self.assertIn("_action", doc) # Valid jsons self.assertEqual(json.loads(without_rest_api[0])["_action"], "COMMAND") self.assertEqual( json.loads(without_rest_api[0])["name"], "authenticate") self.assertEqual(json.loads(without_rest_api[2])["_action"], "COMMAND") self.assertEqual(json.loads(without_rest_api[2])["name"], "export") self.assertEqual(json.loads(without_rest_api[3])["_action"], "COMMAND") self.assertEqual( json.loads(without_rest_api[3])["name"], "install_reference") self.assertEqual( json.loads(without_rest_api[4])["_action"], "GOT_RECIPE_FROM_LOCAL_CACHE") self.assertEqual( json.loads(without_rest_api[4])["_id"], "Hello0/0.1@lasote/stable") self.assertEqual( json.loads(without_rest_api[5])["_action"], "PACKAGE_BUILT_FROM_SOURCES") self.assertEqual(json.loads(without_rest_api[6])["_action"], "COMMAND") self.assertEqual(json.loads(without_rest_api[6])["name"], "upload") self.assertEqual(json.loads(without_rest_api[7])["_action"], "ZIP") self.assertEqual( json.loads(without_rest_api[8])["_action"], "UPLOADED_RECIPE") self.assertEqual(json.loads(without_rest_api[9])["_action"], "ZIP") self.assertEqual( json.loads(without_rest_api[10])["_action"], "UPLOADED_PACKAGE") num_put = len( [it for it in actions if "REST_API_CALL" in it and "PUT" in it]) self.assertEqual(num_put, 6) # 3 files the recipe 3 files the package num_post = len( [it for it in actions if "REST_API_CALL" in it and "POST" in it]) if "/v2/" in traces: self.assertEqual(num_post, 0) else: self.assertEqual(num_post, 2) # 2 get urls num_get = len( [it for it in actions if "REST_API_CALL" in it and "GET" in it]) self.assertEqual(num_get, 10) # Check masked signature for action in actions: doc = json.loads(action) if doc.get("url") and "signature" in doc.get("url"): self.assertIn("signature=*****", doc.get("url"))
def git_helper_in_recipe_test(self): client = TestClient() git_repo = temp_folder() save(os.path.join(git_repo, "file.h"), "contents") with client.chdir(git_repo): client.run_command("git init .") client.run_command('git config user.email "*****@*****.**"') client.run_command('git config user.name "Your Name"') client.run_command("git checkout -b dev") client.run_command("git add .") client.run_command('git commit -m "comm"') conanfile = """ import os from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" exports_sources = "other" def source(self): git = tools.Git() git.clone("%s", "dev") def build(self): assert(os.path.exists("file.h")) """ % git_repo.replace("\\", "/") client.save({"conanfile.py": conanfile, "other": "hello"}) client.run("create . user/channel") # Now clone in a subfolder with later checkout conanfile = """ import os from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" exports_sources = "other" def source(self): tools.mkdir("src") git = tools.Git("./src") git.clone("%s") git.checkout("dev") def build(self): assert(os.path.exists(os.path.join("src", "file.h"))) """ % git_repo.replace("\\", "/") client.save({"conanfile.py": conanfile, "other": "hello"}) client.run("create . user/channel") # Base dir, with exports without subfolder and not specifying checkout fails conanfile = """ import os from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" exports_sources = "other" def source(self): git = tools.Git() git.clone("%s") def build(self): assert(os.path.exists("file.h")) """ % git_repo.replace("\\", "/") client.save({"conanfile.py": conanfile, "other": "hello"}) client.run("create . user/channel", assert_error=True) self.assertIn("specify a branch to checkout", client.out)
def autotools_real_install_dirs_test(self): body = r"""#include "hello.h" #include <iostream> using namespace std; void hello() { cout << "Hola Mundo!"; } """ header = """ #pragma once void hello(); """ main = """ #include "hello.h" int main() { hello(); return 0; } """ conanfile = """ from conans import ConanFile, AutoToolsBuildEnvironment, tools class TestConan(ConanFile): name = "test" version = "1.0" settings = "os", "compiler", "arch", "build_type" exports_sources = "*" def build(self): makefile_am = ''' bin_PROGRAMS = main lib_LIBRARIES = libhello.a libhello_a_SOURCES = hello.cpp main_SOURCES = main.cpp main_LDADD = libhello.a ''' configure_ac = ''' AC_INIT([main], [1.0], [[email protected]]) AM_INIT_AUTOMAKE([-Wall -Werror foreign]) AC_PROG_CXX AC_PROG_RANLIB AM_PROG_AR AC_CONFIG_FILES([Makefile]) AC_OUTPUT ''' tools.save("Makefile.am", makefile_am) tools.save("configure.ac", configure_ac) self.run("aclocal") self.run("autoconf") self.run("automake --add-missing --foreign") autotools = AutoToolsBuildEnvironment(self) autotools.configure() autotools.make() autotools.install() def package_id(self): # easier to have same package_id for the test self.info.header_only() """ client = TestClient() client.save({ "conanfile.py": conanfile, "main.cpp": main, "hello.h": header, "hello.cpp": body }) client.run("create . danimtb/testing") pkg_path = client.client_cache.package( PackageReference.loads("test/1.0@danimtb/testing:%s" % NO_SETTINGS_PACKAGE_ID)) [ self.assertIn(folder, os.listdir(pkg_path)) for folder in ["lib", "bin"] ] new_conanfile = conanfile.replace( "autotools.configure()", "autotools.configure(args=['--bindir=${prefix}/superbindir', '--libdir=${prefix}/superlibdir'])" ) client.save({"conanfile.py": new_conanfile}) client.run("create . danimtb/testing") [ self.assertIn(folder, os.listdir(pkg_path)) for folder in ["superlibdir", "superbindir"] ] [ self.assertNotIn(folder, os.listdir(pkg_path)) for folder in ["lib", "bin"] ]
class SettingsCppStdScopedPackageTests(unittest.TestCase): # Validation of scoped settings is delayed until graph computation, a conanfile can # declare a different set of settings, so we should wait until then to validate it. default_profile = textwrap.dedent(""" [settings] os=Linux arch=x86 compiler=gcc compiler.version=7 compiler.libcxx=libstdc++11 """) def run(self, *args, **kwargs): default_profile_path = os.path.join(temp_folder(), "default.profile") save(default_profile_path, self.default_profile) with environment_append( {"CONAN_DEFAULT_PROFILE_PATH": default_profile_path}): unittest.TestCase.run(self, *args, **kwargs) def setUp(self): self.t = TestClient(cache_folder=temp_folder()) settings = ["os", "compiler", "build_type", "arch"] if self.recipe_cppstd: settings += ["cppstd"] conanfile = textwrap.dedent(""" from conans import ConanFile class Lib(ConanFile): settings = "{}" """.format('", "'.join(settings))) self.t.save({"conanfile.py": conanfile}) def test_value_invalid(self): self.t.run( "create . hh/0.1@user/channel -shh:compiler=apple-clang " "-shh:compiler.cppstd=144", assert_error=True) self.assertIn( "Invalid setting '144' is not a valid 'settings.compiler.cppstd' value", self.t.out) def test_value_different_with_scoped_setting(self): self.t.run( "create . hh/0.1@user/channel" " -s hh:cppstd=11" " -s hh:compiler=gcc" " -s hh:compiler.cppstd=14", assert_error=True) self.assertIn( "ERROR: Error in resulting settings for package 'hh': Do not use settings" " 'compiler.cppstd' together with 'cppstd'", self.t.out) def test_value_different_with_general_setting(self): deprecation_number = 1 if self.recipe_cppstd else 0 with catch_deprecation_warning(self, n=deprecation_number): self.t.run( "create . hh/0.1@user/channel" " -s cppstd=17" " -s hh:compiler=gcc" " -s hh:compiler.cppstd=14", assert_error=True) self.assertIn( "ERROR: Error in resulting settings for package 'hh': Do not use settings" " 'compiler.cppstd' together with 'cppstd'", self.t.out) def test_conanfile_without_compiler(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Lib(ConanFile): settings = "os", "arch" """) t = TestClient(cache_folder=temp_folder()) t.save({'conanfile.py': conanfile}) with catch_deprecation_warning(self): # No mismatch, because settings for this conanfile does not include `compiler` t.run( "create . hh/0.1@user/channel" " -s cppstd=17" " -s hh:compiler=gcc" " -s hh:compiler.cppstd=14", assert_error=True) self.assertIn( "ERROR: Error in resulting settings for package 'hh': Do not use settings" " 'compiler.cppstd' together with 'cppstd'", t.out) def test_conanfile_without_compiler_but_cppstd(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Lib(ConanFile): settings = "os", "arch", "cppstd" def configure(self): self.output.info(">>> cppstd: {}".format(self.settings.cppstd)) """) t = TestClient(cache_folder=temp_folder()) t.save({'conanfile.py': conanfile}, clean_first=True) with catch_deprecation_warning(self): # No mismatch, because settings for this conanfile does not include `compiler` t.run( "create . hh/0.1@user/channel" " -s cppstd=17" " -s hh:compiler=gcc" " -s hh:compiler.cppstd=14", assert_error=True) self.assertIn( "ERROR: Error in resulting settings for package 'hh': Do not use settings" " 'compiler.cppstd' together with 'cppstd'", t.out)
def package_info_components_test(self): dep = textwrap.dedent(""" import os from conans import ConanFile class Dep(ConanFile): def package_info(self): self.cpp_info.components["dep1"].libs.append("libdep1") self.cpp_info.components["dep1"].defines.append("definedep1") self.cpp_info.components["dep2"].libs.append("libdep2") os.mkdir(os.path.join(self.package_folder, "include")) os.mkdir(os.path.join(self.package_folder, "includedep2")) self.cpp_info.components["dep2"].includedirs.append("includedep2") """) intermediate = textwrap.dedent(""" import os from conans import ConanFile class Intermediate(ConanFile): requires = "dep/1.0@us/ch" def package_info(self): self.cpp_info.components["int1"].requires = ["dep::dep"] # To avoid exception self.cpp_info.components["int1"].libs.append("libint1") self.cpp_info.components["int1"].defines.append("defint1") os.mkdir(os.path.join(self.package_folder, "include")) os.mkdir(os.path.join(self.package_folder, "includeint1")) self.cpp_info.components["int1"].includedirs.append("includeint1") self.cpp_info.components["int2"].libs.append("libint2") self.cpp_info.components["int2"].defines.append("defint2") os.mkdir(os.path.join(self.package_folder, "includeint2")) self.cpp_info.components["int2"].includedirs.append("includeint2") """) consumer = textwrap.dedent(""" import os from conans import ConanFile class Consumer(ConanFile): requires = "intermediate/1.0@us/ch" def build(self): self.output.info("deps_cpp_info.libs: %s" % list(self.deps_cpp_info.libs)) self.output.info("deps_cpp_info.defines: %s" % list(self.deps_cpp_info.defines)) self.output.info("deps_cpp_info.include_paths: %s" % [os.path.basename(value) for value in self.deps_cpp_info.include_paths]) for dep_key, dep_value in self.deps_cpp_info.dependencies: self.output.info("%s.libs: %s" % (dep_key, list(dep_value.libs))) self.output.info("%s.defines: %s" % (dep_key, list(dep_value.defines))) self.output.info("%s.include_paths: %s" % (dep_key, [os.path.basename(value) for value in dep_value.include_paths])) """) client = TestClient() client.save({ "conanfile_dep.py": dep, "conanfile_intermediate.py": intermediate, "conanfile_consumer.py": consumer }) client.run("export conanfile_dep.py dep/1.0@us/ch") client.run("export conanfile_intermediate.py intermediate/1.0@us/ch") client.run( "create conanfile_consumer.py consumer/1.0@us/ch --build missing") self.assertIn( "deps_cpp_info.libs: ['libint1', 'libint2', 'libdep1', 'libdep2']", client.out) self.assertIn( "deps_cpp_info.defines: ['definedep1', 'defint1', 'defint2']", client.out) self.assertIn( "deps_cpp_info.include_paths: ['include', 'includeint1', 'includeint2', " "'include', 'includedep2']", client.out) self.assertIn("intermediate.libs: ['libint1', 'libint2']", client.out) self.assertIn("intermediate.defines: ['defint1', 'defint2']", client.out) self.assertIn( "intermediate.include_paths: ['include', 'includeint1', 'includeint2']", client.out) self.assertIn("dep.libs: ['libdep1', 'libdep2']", client.out) self.assertIn("dep.defines: ['definedep1']", client.out) self.assertIn("dep.include_paths: ['include', 'includedep2']", client.out)
def test_toolchain_posix(self, target, build_type): client = TestClient(path_with_spaces=False) settings = { "build_type": build_type, } options = { "fPIC": "True", } if target == "exe": conanfile_options = 'options = {"fPIC": [True, False]}' conanfile_default_options = 'default_options = {"fPIC": True}' else: conanfile_options = 'options = {"shared": [True, False], "fPIC": [True, False]}' conanfile_default_options = 'default_options = {"shared": False, "fPIC": True}' if target == "shared": options["shared"] = True settings_str = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v) options_str = " ".join("-o %s=%s" % (k, v) for k, v in options.items()) if options else "" conanfile = textwrap.dedent(""" from conans import ConanFile, MakeToolchain class App(ConanFile): settings = "os", "arch", "compiler", "build_type" {options} {default_options} def toolchain(self): tc = MakeToolchain(self) tc.variables["TEST_VAR"] = "TestVarValue" tc.preprocessor_definitions["TEST_DEFINITION"] = "TestPpdValue" tc.write_toolchain_files() def build(self): self.run("make -C ..") """).format(options=conanfile_options, default_options=conanfile_default_options) hello_h = textwrap.dedent(""" #pragma once #define HELLO_MSG "{0}" #ifdef WIN32 #define APP_LIB_EXPORT __declspec(dllexport) #else #define APP_LIB_EXPORT #endif APP_LIB_EXPORT void hello(); """.format(build_type)) hello_cpp = textwrap.dedent(""" #include <iostream> #include "hello.h" void hello() { std::cout << "Hello World " << HELLO_MSG << "!" << std::endl; #ifdef NDEBUG std::cout << "App: Release!" << std::endl; #else std::cout << "App: Debug!" << std::endl; #endif std::cout << "TEST_DEFINITION: " << TEST_DEFINITION << "\\n"; } """) # only used for the executable test case main = textwrap.dedent(""" #include "hello.h" int main() { hello(); } """) makefile = textwrap.dedent(""" include conan_toolchain.mak #------------------------------------------------- # Make variables for a sample App #------------------------------------------------- OUT_DIR ?= out SRC_DIR ?= src INCLUDE_DIR ?= include PROJECT_NAME = hello EXE_FILENAME = $(PROJECT_NAME).bin STATIC_LIB_FILENAME = lib$(PROJECT_NAME).a SHARED_LIB_FILENAME = lib$(PROJECT_NAME).so SRCS += $(wildcard $(SRC_DIR)/*.cpp) OBJS += $(patsubst $(SRC_DIR)/%.cpp,$(OUT_DIR)/%.o,$(SRCS)) CPPFLAGS += $(addprefix -I,$(INCLUDE_DIR)) #------------------------------------------------- # Append CONAN_ variables to standards #------------------------------------------------- $(call CONAN_TC_SETUP) # The above function should append CONAN_TC flags to standard flags $(info >> CFLAGS: $(CFLAGS)) $(info >> CXXFLAGS: $(CXXFLAGS)) $(info >> CPPFLAGS: $(CPPFLAGS)) $(info >> LDFLAGS: $(LDFLAGS)) $(info >> LDLIBS: $(LDLIBS)) $(info >> TEST_VAR: $(TEST_VAR)) #------------------------------------------------- # Make Rules #------------------------------------------------- .PHONY : exe static shared exe : $(OBJS) $(CXX) $(OBJS) $(LDFLAGS) $(LDLIBS) -o $(OUT_DIR)/$(EXE_FILENAME) static : $(OBJS) $(AR) $(ARFLAGS) $(OUT_DIR)/$(STATIC_LIB_FILENAME) $(OBJS) shared : $(OBJS) $(CXX) -shared $(OBJS) $(LDFLAGS) $(LDLIBS) -o $(OUT_DIR)/$(SHARED_LIB_FILENAME) $(OUT_DIR)/%.o : $(SRC_DIR)/%.cpp $(OUT_DIR) $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@ $(OUT_DIR): -mkdir $@ """) files_to_save = { "conanfile.py": conanfile, "Makefile": makefile, "src/hello.cpp": hello_cpp, "include/hello.h": hello_h } if target == "exe": files_to_save["src/main.cpp"] = main client.save(files_to_save, clean_first=True) client.run("install . hello/0.1@ %s %s" % (settings_str, options_str)) if target == "exe": client.run_command("make exe") client.run_command("./out/hello.bin") self.assertIn("Hello World {}!".format(build_type), client.out) elif target == "shared": client.run_command("make shared") client.run_command("nm -C out/libhello.so | grep 'hello()'") self.assertIn("hello()", client.out) elif target == "static": client.run_command("make static") client.run_command("nm -C out/libhello.a | grep 'hello()'") self.assertIn("hello()", client.out)
def build_vs_project_test(self): conan_build_vs = """ from conans import ConanFile, MSBuild class HelloConan(ConanFile): name = "Hello" version = "1.2.1" exports = "*" settings = "os", "build_type", "arch", "compiler", "cppstd" def build(self): msbuild = MSBuild(self) msbuild.build("MyProject.sln", verbosity="normal") def package(self): self.copy(pattern="*.exe") """ client = TestClient() # Test cpp standard stuff files = get_vs_project_files(std="cpp17_2015") files[CONANFILE] = conan_build_vs client.save(files) with catch_deprecation_warning(self): client.run( 'create . Hello/1.2.1@lasote/stable -s cppstd=11 -s ' 'compiler="Visual Studio" -s compiler.version=14', assert_error=True) with catch_deprecation_warning(self): client.run('create . Hello/1.2.1@lasote/stable -s cppstd=17 ' '-s compiler="Visual Studio" -s compiler.version=14') self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out) files = get_vs_project_files() files[CONANFILE] = conan_build_vs # Try to not update the project client.cache._config = None # Invalidate cached config replace_in_file(client.cache.conan_conf_path, "[general]", "[general]\nskip_vs_projects_upgrade = True", output=client.out) client.save(files, clean_first=True) client.run("create . Hello/1.2.1@lasote/stable --build") self.assertNotIn("devenv", client.user_io.out) self.assertIn("Skipped sln project upgrade", client.out) # Try with x86_64 client.save(files) client.run("export . lasote/stable") client.run("install Hello/1.2.1@lasote/stable --build -s arch=x86_64") self.assertIn("Release|x64", client.user_io.out) self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out) # Try with x86 client.save(files, clean_first=True) client.run("export . lasote/stable") client.run("install Hello/1.2.1@lasote/stable --build -s arch=x86") self.assertIn("Release|x86", client.user_io.out) self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out) # Try with x86 debug client.save(files, clean_first=True) client.run("export . lasote/stable") client.run( "install Hello/1.2.1@lasote/stable --build -s arch=x86 -s build_type=Debug" ) self.assertIn("Debug|x86", client.user_io.out) self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out) # Try with a custom property file name files[CONANFILE] = conan_build_vs.replace( 'msbuild.build("MyProject.sln", verbosity="normal")', 'msbuild.build("MyProject.sln", verbosity="normal", property_file_name="mp.props")' ) client.save(files, clean_first=True) client.run( "create . Hello/1.2.1@lasote/stable --build -s arch=x86 -s build_type=Debug" ) self.assertIn("Debug|x86", client.user_io.out) self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out) full_ref = "Hello/1.2.1@lasote/stable:b786e9ece960c3a76378ca4d5b0d0e922f4cedc1" pref = PackageReference.loads(full_ref) build_folder = client.cache.package_layout(pref.ref).build(pref) self.assertTrue(os.path.exists(os.path.join(build_folder, "mp.props")))
def conanfile_txt_test(self): client = TestClient() client.save({"conanfile.txt": ""}) client.run("install .") client.run("install . --lockfile=conan.lock") self.assertIn("Using lockfile", client.out)
def test_settings_options(self, build_type, shared, use_repo_file): # We need two clients sharing the same Conan cache base_folder = tempfile.mkdtemp(suffix='conans', dir=CONAN_TEST_FOLDER) # Editable project client_editable = HeaderOnlyLibTestClient(use_repo_file=use_repo_file, base_folder=base_folder) if use_repo_file: client_editable.run( "editable add . MyLib/0.1@user/editable -l=mylayout") else: client_editable.run("editable add . MyLib/0.1@user/editable") # Consumer project client = TestClient(base_folder=base_folder) conanfile_txt = """ import os from conans import ConanFile, CMake class TestConan(ConanFile): name = "pkg" version = "0.0" requires = "MyLib/0.1@user/editable" settings = "os", "compiler", "build_type", "arch" generators = "cmake" exports_sources = "src/*" def build(self): cmake = CMake(self) cmake.configure(source_folder="src") cmake.build() os.chdir("bin") self.run(".%shello" % os.sep) """ cmakelists = """ cmake_minimum_required(VERSION 2.8.12) project(MyHello CXX) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() add_executable(hello main.cpp) """ main_cpp = """ #include "hello.hpp" int main() { hello(); } """ client.save({ "conanfile.py": conanfile_txt, "src/CMakeLists.txt": cmakelists, "src/main.cpp": main_cpp }) # Build consumer project client.run("create . pkg/0.0@user/testing " "-s build_type={} -o MyLib:shared={}".format( build_type, str(shared))) self.assertIn( " MyLib/0.1@user/editable from user folder - Editable", client.out) self.assertIn("Hello {}!".format(build_type), client.out) self.assertIn(" - options.shared: {}".format(shared), client.out)
def test_cpp_info_link_objects(): client = TestClient() obj_ext = "obj" if platform.system() == "Windows" else "o" cpp_info = { "objects": [os.path.join("lib", "myobject.{}".format(obj_ext))] } object_cpp = gen_function_cpp(name="myobject") object_h = gen_function_h(name="myobject") cmakelists = textwrap.dedent(""" cmake_minimum_required(VERSION 3.15) project(MyObject) file(GLOB HEADERS *.h) add_library(myobject OBJECT myobject.cpp) if( WIN32 ) set(OBJ_PATH "myobject.dir/Release/myobject${CMAKE_C_OUTPUT_EXTENSION}") else() set(OBJ_PATH "CMakeFiles/myobject.dir/myobject.cpp${CMAKE_C_OUTPUT_EXTENSION}") endif() install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${OBJ_PATH} DESTINATION ${CMAKE_INSTALL_PREFIX}/lib RENAME myobject${CMAKE_C_OUTPUT_EXTENSION}) install(FILES ${HEADERS} DESTINATION ${CMAKE_INSTALL_PREFIX}/include) """) test_package_cpp = gen_function_cpp(name="main", includes=["myobject"], calls=["myobject"]) test_package_cmakelists = textwrap.dedent(""" cmake_minimum_required(VERSION 3.15) project(example) find_package(myobject REQUIRED) add_executable(example example.cpp) target_link_libraries(example myobject::myobject) """) client.save({ "CMakeLists.txt": cmakelists, "conanfile.py": GenConanfile("myobject", "1.0").with_package_info( cpp_info=cpp_info, env_info={}).with_exports_sources( "*").with_cmake_build().with_package("cmake = CMake(self)", "cmake.install()"), "myobject.cpp": object_cpp, "myobject.h": object_h, "test_package/conanfile.py": GenConanfile().with_cmake_build().with_import("import os").with_test( 'path = "{}".format(self.settings.build_type) ' 'if self.settings.os == "Windows" else "."').with_test( 'self.run("{}{}example".format(path, os.sep))'), "test_package/example.cpp": test_package_cpp, "test_package/CMakeLists.txt": test_package_cmakelists }) client.run("create . -s build_type=Release") assert "myobject: Release!" in client.out
def test_version_ranges_revisions_update(self): # https://github.com/conan-io/conan/issues/7333 client = TestClient(default_server_user=True) client.save({"conanfile.py": GenConanfile()}) client.run("create . PkgA/0.1@") self.assertIn( "PkgA/0.1: Exported revision: f3367e0e7d170aa12abccb175fee5f97", client.out) client.run("upload * --all --confirm") client.run("search PkgA/0.1@ --revisions -r=default") self.assertIn("f3367e0e7d170aa12abccb175fee5f97", client.out) client2 = TestClient(servers=client.servers, users=client.users) client2.save({"conanfile.py": GenConanfile("PkgA")}) client2.run("create . PkgA/0.2@") client2.run("upload * --all --confirm") client2.save({ "conanfile.py": GenConanfile("PkgA", "0.2").with_build_msg("Building") }) time.sleep(1) client2.run("create . ") self.assertIn( "PkgA/0.2: Exported revision: 5e8148093372278be4e8d8e831d8bdb6", client2.out) client2.run("upload * --all --confirm") client2.run("search PkgA/0.2@ --revisions -r=default") self.assertIn("5e8148093372278be4e8d8e831d8bdb6", client2.out) self.assertIn("8ec297bab84c88218d1db36ffea97d0e", client2.out) client.save({ "conanfile.py": GenConanfile("PkgB", "0.1").with_require("PkgA/[>=0.1]") }) client.run( "lock create conanfile.py --update --lockfile-out=conan.lock") self.assertIn( "PkgA/0.2: Downloaded recipe revision 5e8148093372278be4e8d8e831d8bdb6", client.out) lockfile = client.load("conan.lock") self.assertIn("5e8148093372278be4e8d8e831d8bdb6", lockfile) # Put again the old revision locally client.run("remove * -f") client.save({"conanfile.py": GenConanfile()}) client.run("create . PkgA/0.1@") self.assertIn( "PkgA/0.1: Exported revision: f3367e0e7d170aa12abccb175fee5f97", client.out) client.save({ "conanfile.py": GenConanfile("PkgB", "0.1").with_require("PkgA/[>=0.1]") }) client.run("install . --lockfile=conan.lock") self.assertIn( "PkgA/0.2: Downloaded recipe revision 5e8148093372278be4e8d8e831d8bdb6", client.out)
class RemoteTest(unittest.TestCase): def setUp(self): self.servers = OrderedDict() self.users = {} for i in range(3): test_server = TestServer() self.servers["remote%d" % i] = test_server self.users["remote%d" % i] = [("lasote", "mypass")] self.client = TestClient(servers=self.servers, users=self.users) def test_removed_references(self): conanfile = """ from conans import ConanFile class HelloConan(ConanFile): pass """ self.client.save({"conanfile.py": conanfile}) self.client.run("create . lib/1.0@lasote/channel") self.client.run('upload "*" -c -r remote1') self.client.run('upload "*" -c -r remote2') self.client.run('remote list_ref') ref = "lib/1.0@lasote/channel" pref = "%s:%s" % (ref, NO_SETTINGS_PACKAGE_ID) self.assertIn("%s: remote1" % ref, self.client.out) # Remove from remote2, the reference should be kept there self.client.run('remove "lib/1.0@lasote/channel" -f -r remote2') self.client.run('remote list_ref') self.assertIn("%s: remote1" % ref, self.client.out) # Upload again to remote2 and remove from remote1, the ref shouldn't be removed self.client.run('upload "*" -c -r remote2') self.client.run('remove "lib/1.0@lasote/channel" -f -r remote1') self.client.run('remote list_ref') self.assertIn("%s: remote1" % ref, self.client.out) # Test the packages references now self.client.run('upload "*" -c -r remote1 --all') self.client.run('upload "*" -c -r remote2 --all') self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertIn("%s: remote1" % pref, self.client.out) # Remove from remote2, the reference should be kept there self.client.run('remove "lib/1.0@lasote/channel" ' '-p %s -f -r remote2' % NO_SETTINGS_PACKAGE_ID) self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertIn("%s: remote1" % pref, self.client.out) # Upload again to remote2 and remove from remote1, the ref shouldn't be removed self.client.run('upload "*" -c -r remote2 --all') self.client.run('remove "lib/1.0@lasote/channel" ' '-p %s -f -r remote1' % NO_SETTINGS_PACKAGE_ID) self.client.run('remote list_ref') self.assertIn("%s: remote1" % ref, self.client.out) self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertIn("%s: remote1" % pref, self.client.out) # Remove package locally self.client.run('upload "*" -c -r remote1 --all') self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertIn("%s: remote1" % pref, self.client.out) self.client.run('remove "lib/1.0@lasote/channel" ' '-p %s -f' % NO_SETTINGS_PACKAGE_ID) self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertNotIn("%s: remote1" % pref, self.client.out) # If I remove all in local, I also remove packages self.client.run("create . lib/1.0@lasote/channel") self.client.run('upload "*" -c -r remote1') self.client.run('remove "lib/1.0@lasote/channel" -f') self.client.run('remote list_pref lib/1.0@lasote/channel') self.assertEqual("", self.client.out) def list_raw_test(self): self.client.run("remote list --raw") output = re.sub(r"http:\/\/fake.+\.com", "http://fake.com", str(self.client.out)) self.assertIn("remote0 http://fake.com True", output) self.assertIn("remote1 http://fake.com True", output) self.assertIn("remote2 http://fake.com True", output) def basic_test(self): self.client.run("remote list") self.assertIn("remote0: http://", self.client.out) self.assertIn("remote1: http://", self.client.out) self.assertIn("remote2: http://", self.client.out) self.client.run("remote add origin https://myurl") self.client.run("remote list") lines = str(self.client.out).splitlines() self.assertIn("origin: https://myurl", lines[3]) self.client.run("remote update origin https://2myurl") self.client.run("remote list") self.assertIn("origin: https://2myurl", self.client.out) self.client.run("remote update remote0 https://remote0url") self.client.run("remote list") output = str(self.client.out) self.assertIn("remote0: https://remote0url", output.splitlines()[0]) self.client.run("remote remove remote0") self.client.run("remote list") output = str(self.client.out) self.assertIn("remote1: http://", output.splitlines()[0]) def remove_remote_test(self): self.client.run("remote list") self.assertIn("remote0: http://", self.client.out) self.assertIn("remote1: http://", self.client.out) self.assertIn("remote2: http://", self.client.out) self.client.run("remote add_ref Hello/0.1@user/testing remote2") self.client.run("remote add_ref Hello2/0.1@user/testing remote1") self.client.run("remote remove remote1") self.client.run("remote list") self.assertNotIn("remote1", self.client.out) self.assertIn("remote0", self.client.out) self.assertIn("remote2", self.client.out) self.client.run("remote list_ref") self.assertNotIn("Hello2/0.1@user/testing", self.client.out) self.assertIn("Hello/0.1@user/testing", self.client.out) registry = load(self.client.cache.registry_path) self.assertNotIn("Hello2/0.1@user/testing", registry) ref = ConanFileReference.loads("Hello/0.1@user/testing") metadata = self.client.cache.package_layout(ref).load_metadata() self.assertEqual(metadata.recipe.remote, "remote2") self.client.run("remote remove remote2") self.client.run("remote list") self.assertNotIn("remote1", self.client.out) self.assertIn("remote0", self.client.out) self.assertNotIn("remote2", self.client.out) self.client.run("remote list_ref") self.assertNotIn("Hello2/0.1@user/testing", self.client.out) self.assertNotIn("Hello/0.1@user/testing", self.client.out) registry = load(self.client.cache.registry_path) self.assertNotIn("Hello2/0.1@user/testing", registry) self.assertNotIn("Hello/0.1@user/testing", registry) def clean_remote_test(self): self.client.run("remote add_ref Hello/0.1@user/testing remote0") self.client.run("remote clean") self.client.run("remote list") self.assertEqual("", self.client.out) self.client.run("remote list_ref") self.assertEqual("", self.client.out) def clean_remote_no_user_test(self): self.client.run("remote add_ref Hello/0.1 remote0") self.client.run("remote clean") self.client.run("remote list") self.assertEqual("", self.client.out) self.client.run("remote list_ref") self.assertEqual("", self.client.out) def remove_remote_no_user_test(self): self.client.run("remote add_ref Hello/0.1 remote0") self.client.run("remote remove remote0") self.client.run("remote list") self.assertNotIn("remote0", self.client.out) self.client.run("remote list_ref") self.assertEqual("", self.client.out) def add_force_test(self): client = TestClient() client.run("remote add r1 https://r1") client.run("remote add r2 https://r2") client.run("remote add r3 https://r3") client.run("remote add_ref Hello/0.1@user/testing r2") client.run("remote add_ref Hello2/0.1@user/testing r1") client.run("remote add r4 https://r4 -f") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r1: https://r1", lines[0]) self.assertIn("r2: https://r2", lines[1]) self.assertIn("r3: https://r3", lines[2]) self.assertIn("r4: https://r4", lines[3]) client.run("remote add r2 https://newr2 -f") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r1: https://r1", lines[0]) self.assertIn("r3: https://r3", lines[1]) self.assertIn("r4: https://r4", lines[2]) self.assertIn("r2: https://newr2", lines[3]) client.run("remote add newr1 https://r1 -f") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r3: https://r3", lines[0]) self.assertIn("r4: https://r4", lines[1]) self.assertIn("r2: https://newr2", lines[2]) self.assertIn("newr1: https://r1", lines[3]) client.run("remote list_ref") self.assertIn("Hello2/0.1@user/testing: newr1", client.out) self.assertIn("Hello/0.1@user/testing: r2", client.out) client.run("remote add newr1 https://newr1 -f -i") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("newr1: https://newr1", lines[0]) self.assertIn("r3: https://r3", lines[1]) self.assertIn("r4: https://r4", lines[2]) self.assertIn("r2: https://newr2", lines[3]) def rename_test(self): client = TestClient() client.run("remote add r1 https://r1") client.run("remote add r2 https://r2") client.run("remote add r3 https://r3") client.run("remote add_ref Hello/0.1@user/testing r2") client.run("remote rename r2 mynewr2") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r1: https://r1", lines[0]) self.assertIn("mynewr2: https://r2", lines[1]) self.assertIn("r3: https://r3", lines[2]) client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: mynewr2", client.out) # Rename to an existing one client.run("remote rename r2 r1", assert_error=True) self.assertIn("Remote 'r1' already exists", client.out) def insert_test(self): self.client.run("remote add origin https://myurl --insert") self.client.run("remote list") first_line = str(self.client.out).splitlines()[0] self.assertIn("origin: https://myurl", first_line) self.client.run("remote add origin2 https://myurl2 --insert=0") self.client.run("remote list") lines = str(self.client.out).splitlines() self.assertIn("origin2: https://myurl2", lines[0]) self.assertIn("origin: https://myurl", lines[1]) self.client.run("remote add origin3 https://myurl3 --insert=1") self.client.run("remote list") lines = str(self.client.out).splitlines() self.assertIn("origin2: https://myurl2", lines[0]) self.assertIn("origin3: https://myurl3", lines[1]) self.assertIn("origin: https://myurl", lines[2]) def update_test_insert(self): client = TestClient() client.run("remote add r1 https://r1") client.run("remote add r2 https://r2") client.run("remote add r3 https://r3") client.run("remote update r2 https://r2new --insert") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r2: https://r2new", lines[0]) self.assertIn("r1: https://r1", lines[1]) self.assertIn("r3: https://r3", lines[2]) client.run("remote update r2 https://r2new2 --insert 2") client.run("remote list") lines = str(client.out).splitlines() self.assertIn("r1: https://r1", lines[0]) self.assertIn("r3: https://r3", lines[1]) self.assertIn("r2: https://r2new2", lines[2]) def test_update_insert_same_url(self): # https://github.com/conan-io/conan/issues/5107 client = TestClient() client.run("remote add r1 https://r1") client.run("remote add r2 https://r2") client.run("remote add r3 https://r3") client.run("remote update r2 https://r2 --insert=0") client.run("remote list") self.assertLess(str(client.out).find("r2"), str(client.out).find("r1")) self.assertLess(str(client.out).find("r1"), str(client.out).find("r3")) def verify_ssl_test(self): client = TestClient() client.run("remote add my-remote http://someurl TRUE") client.run("remote add my-remote2 http://someurl2 yes") client.run("remote add my-remote3 http://someurl3 FALse") client.run("remote add my-remote4 http://someurl4 No") registry = load(client.cache.registry_path) data = json.loads(registry) self.assertEqual(data["remotes"][0]["name"], "my-remote") self.assertEqual(data["remotes"][0]["url"], "http://someurl") self.assertEqual(data["remotes"][0]["verify_ssl"], True) self.assertEqual(data["remotes"][1]["name"], "my-remote2") self.assertEqual(data["remotes"][1]["url"], "http://someurl2") self.assertEqual(data["remotes"][1]["verify_ssl"], True) self.assertEqual(data["remotes"][2]["name"], "my-remote3") self.assertEqual(data["remotes"][2]["url"], "http://someurl3") self.assertEqual(data["remotes"][2]["verify_ssl"], False) self.assertEqual(data["remotes"][3]["name"], "my-remote4") self.assertEqual(data["remotes"][3]["url"], "http://someurl4") self.assertEqual(data["remotes"][3]["verify_ssl"], False) def remote_disable_test(self): client = TestClient() client.run("remote add my-remote0 http://someurl0") client.run("remote add my-remote1 http://someurl1") client.run("remote add my-remote2 http://someurl2") client.run("remote add my-remote3 http://someurl3") client.run("remote disable my-remote0") client.run("remote disable my-remote3") registry = load(client.cache.registry_path) data = json.loads(registry) self.assertEqual(data["remotes"][0]["name"], "my-remote0") self.assertEqual(data["remotes"][0]["url"], "http://someurl0") self.assertEqual(data["remotes"][0]["disabled"], True) self.assertEqual(data["remotes"][3]["name"], "my-remote3") self.assertEqual(data["remotes"][3]["url"], "http://someurl3") self.assertEqual(data["remotes"][3]["disabled"], True) client.run("remote disable *") registry = load(client.cache.registry_path) data = json.loads(registry) for remote in data["remotes"]: self.assertEqual(remote["disabled"], True) client.run("remote enable *") registry = load(client.cache.registry_path) data = json.loads(registry) for remote in data["remotes"]: self.assertNotIn("disabled", remote) def verify_ssl_error_test(self): client = TestClient() client.run( "remote add my-remote http://someurl some_invalid_option=foo", assert_error=True) self.assertIn( "ERROR: Unrecognized boolean value 'some_invalid_option=foo'", client.out) data = json.loads(load(client.cache.registry_path)) self.assertEqual(data["remotes"], []) def errors_test(self): self.client.run("remote update origin url", assert_error=True) self.assertIn("ERROR: Remote 'origin' not found in remotes", self.client.out) self.client.run("remote remove origin", assert_error=True) self.assertIn("ERROR: No remote 'origin' defined in remotes", self.client.out) def duplicated_error_tests(self): """ check remote name and URL are not duplicated """ self.client.run("remote add remote1 http://otherurl", assert_error=True) self.assertIn( "ERROR: Remote 'remote1' already exists in remotes (use update to modify)", self.client.out) self.client.run("remote list") url = str(self.client.out).split()[1] self.client.run("remote add newname %s" % url, assert_error=True) self.assertIn("Remote 'remote0' already exists with same URL", self.client.out) self.client.run("remote update remote1 %s" % url, assert_error=True) self.assertIn("Remote 'remote0' already exists with same URL", self.client.out) def basic_refs_test(self): self.client.run("remote add_ref Hello/0.1@user/testing remote0") self.client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: remote0", self.client.out) self.client.run("remote add_ref Hello1/0.1@user/testing remote1") self.client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: remote0", self.client.out) self.assertIn("Hello1/0.1@user/testing: remote1", self.client.out) self.client.run("remote remove_ref Hello1/0.1@user/testing") self.client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: remote0", self.client.out) self.assertNotIn("Hello1/0.1@user/testing", self.client.out) self.client.run("remote add_ref Hello1/0.1@user/testing remote1") self.client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: remote0", self.client.out) self.assertIn("Hello1/0.1@user/testing: remote1", self.client.out) self.client.run("remote update_ref Hello1/0.1@user/testing remote2") self.client.run("remote list_ref") self.assertIn("Hello/0.1@user/testing: remote0", self.client.out) self.assertIn("Hello1/0.1@user/testing: remote2", self.client.out) def package_refs_test(self): self.client.run("remote add_pref Hello/0.1@user/testing:555 remote0") self.client.run("remote list_pref Hello/0.1@user/testing") self.assertIn("Hello/0.1@user/testing:555: remote0", self.client.out) self.client.run("remote add_pref Hello1/0.1@user/testing:555 remote1") self.client.run("remote list_pref Hello1/0.1@user/testing") self.assertIn("Hello1/0.1@user/testing:555: remote1", self.client.out) self.client.run("remote remove_pref Hello1/0.1@user/testing:555") self.client.run("remote list_pref Hello1/0.1@user/testing") self.assertNotIn("Hello1/0.1@user/testing:555", self.client.out) self.client.run("remote add_pref Hello1/0.1@user/testing:555 remote0") self.client.run("remote add_pref Hello1/0.1@user/testing:666 remote1") self.client.run("remote list_pref Hello1/0.1@user/testing") self.assertIn("Hello1/0.1@user/testing:555: remote0", self.client.out) self.assertIn("Hello1/0.1@user/testing:666: remote1", self.client.out) self.client.run( "remote update_pref Hello1/0.1@user/testing:555 remote2") self.client.run("remote list_pref Hello1/0.1@user/testing") self.assertIn("Hello1/0.1@user/testing:555: remote2", self.client.out) self.assertIn("Hello1/0.1@user/testing:666: remote1", self.client.out) def missing_subarguments_test(self): self.client.run("remote", assert_error=True) self.assertIn("ERROR: Exiting with code: 2", self.client.out) def test_invalid_url(self): self.client.run("remote add foobar foobar.com") self.assertIn( "WARN: The URL 'foobar.com' is invalid. It must contain scheme and hostname.", self.client.out) self.client.run("remote list") self.assertIn("foobar.com", self.client.out) self.client.run("remote update foobar pepe.org") self.assertIn( "WARN: The URL 'pepe.org' is invalid. It must contain scheme and hostname.", self.client.out) self.client.run("remote list") self.assertIn("pepe.org", self.client.out) def test_metadata_editable_packages(self): """ Check that 'conan remote' commands work with editable packages """ self.client.save({ "conanfile.py": """from conans import ConanFile class Conan(ConanFile): pass""" }) self.client.run("create . pkg/1.1@lasote/stable") self.client.run( "upload pkg/1.1@lasote/stable --all -c --remote remote1") self.client.run("remove -f pkg/1.1@lasote/stable") self.client.run("install pkg/1.1@lasote/stable") self.assertIn("pkg/1.1@lasote/stable: Package installed", self.client.out) self.client.run("remote list_ref") self.assertIn("pkg/1.1@lasote/stable: remote1", self.client.out) self.client.run("editable add . pkg/1.1@lasote/stable") # Check add --force, update and rename self.client.run("remote add remote2 %s --force" % self.servers["remote1"].fake_url) self.client.run("remote update remote2 %sfake" % self.servers["remote1"].fake_url) self.client.run("remote rename remote2 remote-fake") self.client.run("editable remove pkg/1.1@lasote/stable") # Check associated remote has changed name self.client.run("remote list_ref") self.assertIn("pkg/1.1@lasote/stable: remote-fake", self.client.out) # Check remove self.client.run("editable add . pkg/1.1@lasote/stable") self.client.run("remote remove remote-fake") self.client.run("remote list") self.assertIn("remote0: %s" % self.servers["remote0"].fake_url, self.client.out) self.assertNotIn("remote-fake", self.client.out) # Check clean self.client.run("editable remove pkg/1.1@lasote/stable") self.client.run("remove -f pkg/1.1@lasote/stable") self.client.run("remote add remote1 %s" % self.servers["remote1"].fake_url) self.client.run("install pkg/1.1@lasote/stable") self.client.run("editable add . pkg/1.1@lasote/stable") self.client.run("remote clean") self.client.run("remote list") self.assertNotIn("remote1", self.client.out) self.assertNotIn("remote0", self.client.out)
def missing_lock_error_test(self): client = TestClient() client.save({"conanfile.py": GenConanfile("PkgA", "0.1")}) client.run("install . --lockfile=conan.lock", assert_error=True) self.assertIn("ERROR: Missing lockfile in", client.out)
def test_conan_test(self): conanfile = ''' from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): settings = "os", "compiler", "build_type", "arch" requires = "Hello0/0.1@lasote/stable" generators = "cmake" def build(self): cmake = CMake(self) self.run('cmake "%s" %s' % (self.source_folder, cmake.command_line)) self.run("cmake --build . %s" % cmake.build_config) def test(self): # equal to ./bin/greet, but portable windows self.run(os.sep.join([".","bin", "greet"])) ''' client = TestClient() files = cpp_hello_conan_files("Hello0", "0.1") print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)' files[CONANFILE] = files[CONANFILE].replace( "def build(self):", 'def build(self):\n %s' % print_build) # Add build_type setting files[CONANFILE] = files[CONANFILE].replace(', "arch"', ', "arch", "build_type"') cmakelist = """set(CMAKE_CXX_COMPILER_WORKS 1) set(CMAKE_CXX_ABI_COMPILED 1) project(MyHello CXX) cmake_minimum_required(VERSION 2.8) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() ADD_EXECUTABLE(greet main.cpp) TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS}) """ files["test_package/CMakeLists.txt"] = cmakelist files["test_package/conanfile.py"] = conanfile files["test_package/main.cpp"] = files["main.cpp"] client.save(files) client.run("create . lasote/stable -tf=None") time.sleep( 1 ) # Try to avoid windows errors in CI (Cannot change permissions) client.run( "test test_package Hello0/0.1@lasote/stable -s build_type=Release") self.assertIn('Hello Hello0', client.out) self.assertNotIn("WARN: conanbuildinfo.txt file not found", client.out) self.assertNotIn("WARN: conanenv.txt file not found", client.out) self.assertIn('Hello Hello0', client.out) client.run( "test test_package Hello0/0.1@lasote/stable -s Hello0:build_type=Debug " "-o Hello0:language=1 --build missing") self.assertIn('Hola Hello0', client.out) self.assertIn('BUILD_TYPE=>Debug', client.out)
def test_system_libs(): conanfile = textwrap.dedent(""" from conans import ConanFile from conans.tools import save import os class Test(ConanFile): name = "Test" version = "0.1" settings = "build_type" def package(self): save(os.path.join(self.package_folder, "lib/lib1.lib"), "") save(os.path.join(self.package_folder, "lib/liblib1.a"), "") def package_info(self): self.cpp_info.libs = ["lib1"] if self.settings.build_type == "Debug": self.cpp_info.system_libs.append("sys1d") else: self.cpp_info.system_libs.append("sys1") """) client = TestClient() client.save({"conanfile.py": conanfile}) client.run("create . -s build_type=Release") client.run("create . -s build_type=Debug") conanfile = textwrap.dedent(""" [requires] Test/0.1 [generators] CMakeDeps """) cmakelists = textwrap.dedent(""" cmake_minimum_required(VERSION 3.15) project(consumer NONE) set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR}) set(CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR}) find_package(Test) message("System libs release: ${Test_SYSTEM_LIBS_RELEASE}") message("Libraries to Link release: ${Test_LIBS_RELEASE}") message("System libs debug: ${Test_SYSTEM_LIBS_DEBUG}") message("Libraries to Link debug: ${Test_LIBS_DEBUG}") get_target_property(tmp Test::Test INTERFACE_LINK_LIBRARIES) message("Target libs: ${tmp}") """) for build_type in ["Release", "Debug"]: client.save({ "conanfile.txt": conanfile, "CMakeLists.txt": cmakelists }, clean_first=True) client.run("install conanfile.txt -s build_type=%s" % build_type) client.run_command('cmake . -DCMAKE_BUILD_TYPE={0}'.format(build_type)) library_name = "sys1d" if build_type == "Debug" else "sys1" # FIXME: Note it is CONAN_LIB::Test_lib1_RELEASE, not "lib1" as cmake_find_package if build_type == "Release": assert "System libs release: %s" % library_name in client.out assert "Libraries to Link release: lib1" in client.out target_libs = "$<$<CONFIG:Release>:CONAN_LIB::Test_lib1_RELEASE;sys1;" else: assert "System libs debug: %s" % library_name in client.out assert "Libraries to Link debug: lib1" in client.out target_libs = "$<$<CONFIG:Debug>:CONAN_LIB::Test_lib1_DEBUG;sys1d;" assert "Target libs: %s" % target_libs in client.out
def test_python_requires_with_alias(self, use_alias, use_alias_of_alias): assert use_alias if use_alias_of_alias else True version_str = "latest2" if use_alias_of_alias else "latest" if use_alias else "1.0" client = TestClient() # Create python_requires client.save({ CONANFILE: """ from conans import ConanFile class PythonRequires0(ConanFile): def build(self): super(PythonRequires0, self).build() self.output.info(">>> PythonRequires0::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("export . python_requires0/1.0@jgsogo/test") client.run("alias python_requires0/latest@jgsogo/test " "python_requires0/1.0@jgsogo/test") client.run("alias python_requires0/latest2@jgsogo/test " "python_requires0/latest@jgsogo/test") # Create python requires, that require the previous one client.save({ CONANFILE: """ from conans import ConanFile, python_requires base = python_requires("python_requires0/{v}@jgsogo/test") class PythonRequires1(base.PythonRequires0): def build(self): super(PythonRequires1, self).build() self.output.info(">>> PythonRequires1::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("export . python_requires1/1.0@jgsogo/test") client.run( "alias python_requires1/latest@jgsogo/test python_requires1/1.0@jgsogo/test" ) client.run( "alias python_requires1/latest2@jgsogo/test python_requires1/latest@jgsogo/test" ) # Create python requires client.save({ CONANFILE: """ from conans import ConanFile, python_requires class PythonRequires11(ConanFile): def build(self): super(PythonRequires11, self).build() self.output.info(">>> PythonRequires11::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("export . python_requires11/1.0@jgsogo/test") client.run( "alias python_requires11/latest@jgsogo/test python_requires11/1.0@jgsogo/test" ) client.run("alias python_requires11/latest2@jgsogo/test " "python_requires11/latest@jgsogo/test") # Create python requires, that require the previous one client.save({ CONANFILE: """ from conans import ConanFile, python_requires base = python_requires("python_requires0/{v}@jgsogo/test") class PythonRequires22(base.PythonRequires0): def build(self): super(PythonRequires22, self).build() self.output.info(">>> PythonRequires22::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("export . python_requires22/1.0@jgsogo/test") client.run( "alias python_requires22/latest@jgsogo/test python_requires22/1.0@jgsogo/test" ) client.run( "alias python_requires22/latest2@jgsogo/test python_requires22/latest@jgsogo/test" ) # Another python_requires, that requires the previous python requires client.save({ CONANFILE: """ from conans import ConanFile, python_requires base_class = python_requires("python_requires1/{v}@jgsogo/test") base_class2 = python_requires("python_requires11/{v}@jgsogo/test") class PythonRequires2(base_class.PythonRequires1, base_class2.PythonRequires11): def build(self): super(PythonRequires2, self).build() self.output.info(">>> PythonRequires2::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("export . python_requires2/1.0@jgsogo/test") client.run( "alias python_requires2/latest@jgsogo/test python_requires2/1.0@jgsogo/test" ) client.run( "alias python_requires2/latest2@jgsogo/test python_requires2/latest@jgsogo/test" ) # My project, will consume the latest python requires client.save({ CONANFILE: """ from conans import ConanFile, python_requires base_class = python_requires("python_requires2/{v}@jgsogo/test") base_class2 = python_requires("python_requires22/{v}@jgsogo/test") class Project(base_class.PythonRequires2, base_class2.PythonRequires22): def build(self): super(Project, self).build() self.output.info(">>> Project::build (v={{}})".format(self.version)) """.format(v=version_str) }) client.run("create . project/1.0@jgsogo/test --build=missing") # Check that everything is being built self.assertIn( "project/1.0@jgsogo/test: >>> PythonRequires11::build (v=1.0)", client.out) self.assertIn( "project/1.0@jgsogo/test: >>> PythonRequires0::build (v=1.0)", client.out) self.assertIn( "project/1.0@jgsogo/test: >>> PythonRequires22::build (v=1.0)", client.out) self.assertIn( "project/1.0@jgsogo/test: >>> PythonRequires1::build (v=1.0)", client.out) self.assertIn( "project/1.0@jgsogo/test: >>> PythonRequires2::build (v=1.0)", client.out) self.assertIn("project/1.0@jgsogo/test: >>> Project::build (v=1.0)", client.out) # Check that all the graph is printed properly # - requirements self.assertIn(" project/1.0@jgsogo/test from local cache - Cache", client.out) # - python requires self.assertIn(" python_requires11/1.0@jgsogo/test", client.out) self.assertIn(" python_requires0/1.0@jgsogo/test", client.out) self.assertIn(" python_requires22/1.0@jgsogo/test", client.out) self.assertIn(" python_requires1/1.0@jgsogo/test", client.out) self.assertIn(" python_requires2/1.0@jgsogo/test", client.out) # - packages self.assertIn( " project/1.0@jgsogo/test:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 - Build", client.out) # - no mention to alias self.assertNotIn("alias", client.out) self.assertNotIn("alias2", client.out)
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 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 conan_scopes_test(self): client = TestClient() conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" def build(self): if self.scope.dev: self.output.warn("DEP DEV") if self.scope.other: self.output.warn("DEP OTHER") ''' files = {} files["conanfile.py"] = conanfile client.save(files) client.run("export lasote/stable") conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): requires = "Hello/0.1@lasote/stable" def config(self): self.output.info(self.scope) if self.scope.dev: self.output.warn("CONFIG_CONSUMER DEV") if self.scope.other: self.output.warn("CONFIG_CONSUMER OTHER") def build(self): if self.scope.dev: self.output.warn("BUILD_CONSUMER DEV") if self.scope.other: self.output.warn("BUILD_CONSUMER OTHER") ''' files["conanfile.py"] = conanfile client.save(files, clean_first=True) client.run("install --build") self.assertNotIn("WARN: DEP DEV", client.user_io.out) self.assertNotIn("WARN: DEP OTHER", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out) client.run("install --build -sc other=True") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("[scope] dev=True other=True", "".join(conaninfo.splitlines())) self.assertIn("dev=True, other=True", client.user_io.out) self.assertNotIn("WARN: DEP DEV", client.user_io.out) self.assertNotIn("WARN: DEP OTHER", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out) client.run("install --build -sc Hello:dev=True") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("[scope] dev=True Hello:dev=True", "".join(conaninfo.splitlines())) self.assertIn("WARN: DEP DEV", client.user_io.out) self.assertNotIn("WARN: DEP OTHER", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out) client.run("install --build -sc Hello:other=True") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("[scope] dev=True Hello:other=True", "".join(conaninfo.splitlines())) self.assertNotIn("WARN: DEP DEV", client.user_io.out) self.assertIn("WARN: DEP OTHER", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out) client.run("install --build -sc Hello:other=False") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("[scope] dev=True Hello:other=False", "".join(conaninfo.splitlines())) self.assertNotIn("WARN: DEP DEV", client.user_io.out) self.assertNotIn("WARN: DEP OTHER", client.user_io.out) self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out) client.run("build") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("[scope] dev=True Hello:other=False", "".join(conaninfo.splitlines())) self.assertNotIn("WARN: DEP DEV", client.user_io.out) self.assertNotIn("WARN: DEP OTHER", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out) self.assertIn("WARN: BUILD_CONSUMER DEV", client.user_io.out) self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)