def setUp(self): self.tmp_folder = temp_folder() self.cache = ClientCache(self.tmp_folder, TestBufferConanOutput())
class VCVarsStoreTest(unittest.TestCase): output = TestBufferConanOutput() def test_81(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '8.1' command = tools.vcvars_command(settings, output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) self.assertIn('store', command) self.assertIn('8.1', command) def test_10(self): sdk_version = tools.find_windows_10_sdk() if not sdk_version: return settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '10.0' command = tools.vcvars_command(settings, output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) self.assertIn('store', command) self.assertIn(sdk_version, command) def test_10_custom_winsdk(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '10.0' sdk_version = '10.0.18362.0' command = tools.vcvars_command(settings, winsdk_version=sdk_version, output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) self.assertIn('store', command) self.assertIn(sdk_version, command) def test_invalid(self): fake_settings_yml = """ os: WindowsStore: version: ["666"] arch: [x86] compiler: Visual Studio: runtime: [MD, MT, MTd, MDd] version: ["8", "9", "10", "11", "12", "14", "15"] build_type: [None, Debug, Release] """ settings = Settings.loads(fake_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '666' with self.assertRaises(ConanException): tools.vcvars_command(settings, output=self.output)
def test_detect_default_profile(self, _): output = TestBufferConanOutput() with tools.environment_append({"CC": "gcc"}): detect_defaults_settings(output, profile_path="~/.conan/profiles/default") self.assertIn("conan profile update settings.compiler.libcxx=libstdc++11 default", output)
def test_get_filename_download(self): # Create a tar file to be downloaded from server with tools.chdir(tools.mkdir_tmp()): import tarfile tar_file = tarfile.open("sample.tar.gz", "w:gz") mkdir("test_folder") tar_file.add(os.path.abspath("test_folder"), "test_folder") tar_file.close() file_path = os.path.abspath("sample.tar.gz") assert (os.path.exists(file_path)) # Instance stoppable thread server and add endpoints thread = StoppableThreadBottle() @thread.server.get("/this_is_not_the_file_name") def get_file(): return static_file(os.path.basename(file_path), root=os.path.dirname(file_path)) @thread.server.get("/") def get_file2(): self.assertEqual(request.query["file"], "1") return static_file(os.path.basename(file_path), root=os.path.dirname(file_path)) @thread.server.get("/error_url") def error_url(): from bottle import response response.status = 500 return 'This always fail' thread.run_server() out = TestBufferConanOutput() # Test: File name cannot be deduced from '?file=1' with self.assertRaises(ConanException) as error: tools.get("http://localhost:%s/?file=1" % thread.port, output=out) self.assertIn( "Cannot deduce file name from the url: 'http://localhost:{}/?file=1'." " Use 'filename' parameter.".format(thread.port), str(error.exception)) # Test: Works with filename parameter instead of '?file=1' with tools.chdir(tools.mkdir_tmp()): tools.get("http://localhost:%s/?file=1" % thread.port, filename="sample.tar.gz", requester=requests, output=out, retry=0, retry_wait=0) self.assertTrue(os.path.exists("test_folder")) # Test: Use a different endpoint but still not the filename one with tools.chdir(tools.mkdir_tmp()): from zipfile import BadZipfile with self.assertRaises(BadZipfile): tools.get("http://localhost:%s/this_is_not_the_file_name" % thread.port, requester=requests, output=out, retry=0, retry_wait=0) tools.get("http://localhost:%s/this_is_not_the_file_name" % thread.port, filename="sample.tar.gz", requester=requests, output=out, retry=0, retry_wait=0) self.assertTrue(os.path.exists("test_folder")) thread.stop() with six.assertRaisesRegex(self, ConanException, "Error"): tools.get("http://localhost:%s/error_url" % thread.port, filename="fake_sample.tar.gz", requester=requests, output=out, verify=False, retry=2, retry_wait=0) # Not found error self.assertEqual(str(out).count("Waiting 0 seconds to retry..."), 2)
class ToolsTest(unittest.TestCase): output = TestBufferConanOutput() def test_replace_paths(self): folder = temp_folder() path = os.path.join(folder, "file") replace_with = "MYPATH" expected = 'Some other contentsMYPATH"finally all text' out = TestBufferConanOutput() save(path, 'Some other contentsc:\\Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/Path/to/file.txt", replace_with, windows_paths=True, output=out) self.assertEqual(load(path), expected) self.assertTrue(ret) save(path, 'Some other contentsC:/Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/PATH/to/FILE.txt", replace_with, windows_paths=True, output=out) self.assertEqual(load(path), expected) self.assertTrue(ret) save(path, 'Some other contentsD:/Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/PATH/to/FILE.txt", replace_with, strict=False, windows_paths=True, output=out) self.assertEqual( load(path), 'Some other contentsD:/Path\\TO\\file.txt"finally all text') self.assertFalse(ret) # Multiple matches s = 'Some other contentsD:/Path\\TO\\file.txt"finally all textd:\\PATH\\to\\file.TXTMoretext' save(path, s) ret = tools.replace_path_in_file(path, "D:/PATH/to/FILE.txt", replace_with, strict=False, windows_paths=True, output=out) self.assertEqual( load(path), 'Some other contentsMYPATH"finally all textMYPATHMoretext') self.assertTrue(ret) # Automatic windows_paths save(path, s) ret = tools.replace_path_in_file(path, "D:/PATH/to/FILE.txt", replace_with, strict=False, output=out) if platform.system() == "Windows": self.assertEqual( load(path), 'Some other contentsMYPATH"finally all textMYPATHMoretext') self.assertTrue(ret) else: self.assertFalse(ret) def test_load_save(self): folder = temp_folder() path = os.path.join(folder, "file") save(path, u"äüïöñç") content = load(path) self.assertEqual(content, u"äüïöñç") def test_md5(self): result = md5(u"äüïöñç") self.assertEqual("dfcc3d74aa447280a7ecfdb98da55174", result) def test_cpu_count(self): output = ConanOutput(sys.stdout) cpus = tools.cpu_count(output=output) self.assertIsInstance(cpus, int) self.assertGreaterEqual(cpus, 1) with tools.environment_append({"CONAN_CPU_COUNT": "34"}): self.assertEqual(tools.cpu_count(output=output), 34) with tools.environment_append({"CONAN_CPU_COUNT": "null"}): with six.assertRaisesRegex(self, ConanException, "Invalid CONAN_CPU_COUNT value"): tools.cpu_count(output=output) @patch("conans.client.tools.oss.CpuProperties.get_cpu_period") @patch("conans.client.tools.oss.CpuProperties.get_cpu_quota") def test_cpu_count_in_container(self, get_cpu_quota_mock, get_cpu_period_mock): get_cpu_quota_mock.return_value = 12000 get_cpu_period_mock.return_value = 1000 output = ConanOutput(sys.stdout) cpus = tools.cpu_count(output=output) self.assertEqual(12, cpus) def test_get_env_unit(self): """ Unit tests tools.get_env """ # Test default self.assertIsNone(tools.get_env("NOT_DEFINED", environment={}), None) # Test defined default self.assertEqual( tools.get_env("NOT_DEFINED_KEY", default="random_default", environment={}), "random_default") # Test return defined string self.assertEqual( tools.get_env("FROM_STR", default="", environment={"FROM_STR": "test_string_value"}), "test_string_value") # Test boolean conversion self.assertEqual( tools.get_env("BOOL_FROM_STR", default=False, environment={"BOOL_FROM_STR": "1"}), True) self.assertEqual( tools.get_env("BOOL_FROM_STR", default=True, environment={"BOOL_FROM_STR": "0"}), False) self.assertEqual( tools.get_env("BOOL_FROM_STR", default=False, environment={"BOOL_FROM_STR": "True"}), True) self.assertEqual( tools.get_env("BOOL_FROM_STR", default=True, environment={"BOOL_FROM_STR": ""}), False) # Test int conversion self.assertEqual( tools.get_env("TO_INT", default=2, environment={"TO_INT": "1"}), 1) # Test float conversion self.assertEqual( tools.get_env("TO_FLOAT", default=2.0, environment={"TO_FLOAT": "1"}), 1.0), # Test list conversion self.assertEqual( tools.get_env("TO_LIST", default=[], environment={"TO_LIST": "1,2,3"}), ["1", "2", "3"]) self.assertEqual( tools.get_env("TO_LIST_NOT_TRIMMED", default=[], environment={"TO_LIST_NOT_TRIMMED": " 1 , 2 , 3 "}), ["1", "2", "3"]) def test_get_env_in_conanfile(self): """ Test get_env is available and working in conanfile """ client = TestClient() conanfile = """from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" def build(self): run_tests = tools.get_env("CONAN_RUN_TESTS", default=False) print("test_get_env_in_conafile CONAN_RUN_TESTS=%r" % run_tests) assert(run_tests == True) """ client.save({"conanfile.py": conanfile}) with tools.environment_append({"CONAN_RUN_TESTS": "1"}): client.run("install .") client.run("build .") def test_global_tools_overrided(self): client = TestClient() conanfile = """ from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" def build(self): assert(tools._global_requester != None) assert(tools._global_output != None) """ client.save({"conanfile.py": conanfile}) client.run("install .") client.run("build .") # Not test the real commmand get_command if it's setting the module global vars tmp = temp_folder() conf = get_default_client_conf().replace( "\n[proxies]", "\n[proxies]\nhttp = http://myproxy.com") os.mkdir(os.path.join(tmp, ".conan")) save(os.path.join(tmp, ".conan", CONAN_CONF), conf) with tools.environment_append({"CONAN_USER_HOME": tmp}): conan_api, _, _ = ConanAPIV1.factory() conan_api.remote_list() global_output, global_requester = get_global_instances() self.assertEqual(global_requester.proxies, {"http": "http://myproxy.com"}) self.assertIsNotNone(global_output.warn) def test_environment_nested(self): with tools.environment_append({"A": "1", "Z": "40"}): with tools.environment_append({"A": "1", "B": "2"}): with tools.environment_append({"A": "2", "B": "2"}): self.assertEqual(os.getenv("A"), "2") self.assertEqual(os.getenv("B"), "2") self.assertEqual(os.getenv("Z"), "40") self.assertEqual(os.getenv("A", None), "1") self.assertEqual(os.getenv("B", None), "2") self.assertEqual(os.getenv("A", None), "1") self.assertEqual(os.getenv("Z", None), "40") self.assertEqual(os.getenv("A", None), None) self.assertEqual(os.getenv("B", None), None) self.assertEqual(os.getenv("Z", None), None) @pytest.mark.skipif(platform.system() != "Windows", reason="Requires vswhere") def test_vswhere_description_strip(self): myoutput = """ [ { "instanceId": "17609d7c", "installDate": "2018-06-11T02:15:04Z", "installationName": "VisualStudio/15.7.3+27703.2026", "installationPath": "", "installationVersion": "15.7.27703.2026", "productId": "Microsoft.VisualStudio.Product.Enterprise", "productPath": "", "isPrerelease": false, "displayName": "Visual Studio Enterprise 2017", "description": "生産性向上と、さまざまな規模のチーム間の調整のための Microsoft DevOps ソリューション", "channelId": "VisualStudio.15.Release", "channelUri": "https://aka.ms/vs/15/release/channel", "enginePath": "", "releaseNotes": "https://go.microsoft.com/fwlink/?LinkId=660692#15.7.3", "thirdPartyNotices": "https://go.microsoft.com/fwlink/?LinkId=660708", "updateDate": "2018-06-11T02:15:04.7009868Z", "catalog": { "buildBranch": "d15.7", "buildVersion": "15.7.27703.2026", "id": "VisualStudio/15.7.3+27703.2026", "localBuild": "build-lab", "manifestName": "VisualStudio", "manifestType": "installer", "productDisplayVersion": "15.7.3", "productLine": "Dev15", "productLineVersion": "2017", "productMilestone": "RTW", "productMilestoneIsPreRelease": "False", "productName": "Visual Studio", "productPatchVersion": "3", "productPreReleaseMilestoneSuffix": "1.0", "productRelease": "RTW", "productSemanticVersion": "15.7.3+27703.2026", "requiredEngineVersion": "1.16.1187.57215" }, "properties": { "campaignId": "", "canceled": "0", "channelManifestId": "VisualStudio.15.Release/15.7.3+27703.2026", "nickname": "", "setupEngineFilePath": "" } }, { "instanceId": "VisualStudio.12.0", "installationPath": "", "installationVersion": "12.0" } ] """ if six.PY3: # In python3 the output from subprocess.check_output are bytes, not str myoutput = myoutput.encode() myrunner = mock_open() myrunner.check_output = lambda x: myoutput with patch('conans.client.tools.win.subprocess', myrunner): json = vswhere() self.assertNotIn("descripton", json) @pytest.mark.skipif(platform.system() != "Windows", reason="Requires Windows") def test_run_in_bash(self): class MockConanfile(object): def __init__(self): self.output = namedtuple("output", "info")( lambda x: None) # @UnusedVariable self.env = {"PATH": "/path/to/somewhere"} class MyRun(object): def __call__(self, command, output, log_filepath=None, cwd=None, subprocess=False): # @UnusedVariable self.command = command self._conan_runner = MyRun() conanfile = MockConanfile() with patch.object(OSInfo, "bash_path", return_value='bash'): tools.run_in_windows_bash(conanfile, "a_command.bat", subsystem="cygwin") self.assertIn("bash", conanfile._conan_runner.command) self.assertIn("--login -c", conanfile._conan_runner.command) self.assertIn("^&^& a_command.bat ^", conanfile._conan_runner.command) with tools.environment_append( {"CONAN_BASH_PATH": "path\\to\\mybash.exe"}): tools.run_in_windows_bash(conanfile, "a_command.bat", subsystem="cygwin") self.assertIn('path\\to\\mybash.exe --login -c', conanfile._conan_runner.command) with tools.environment_append( {"CONAN_BASH_PATH": "path with spaces\\to\\mybash.exe"}): tools.run_in_windows_bash(conanfile, "a_command.bat", subsystem="cygwin", with_login=False) self.assertIn('"path with spaces\\to\\mybash.exe" -c', conanfile._conan_runner.command) # try to append more env vars conanfile = MockConanfile() with patch.object(OSInfo, "bash_path", return_value='bash'): tools.run_in_windows_bash(conanfile, "a_command.bat", subsystem="cygwin", env={ "PATH": "/other/path", "MYVAR": "34" }) self.assertIn( '^&^& PATH=\\^"/other/path:/path/to/somewhere:$PATH\\^" ' '^&^& MYVAR=34 ^&^& a_command.bat ^', conanfile._conan_runner.command) def test_download_retries_errors(self): out = TestBufferConanOutput() # Retry arguments override defaults with six.assertRaisesRegex(self, ConanException, "Error downloading"): tools.download("http://fakeurl3.es/nonexists", os.path.join(temp_folder(), "file.txt"), out=out, requester=requests, retry=2, retry_wait=1) self.assertEqual(str(out).count("Waiting 1 seconds to retry..."), 2) # Not found error with six.assertRaisesRegex( self, ConanException, "Not found: http://google.es/FILE_NOT_FOUND"): tools.download("http://google.es/FILE_NOT_FOUND", os.path.join(temp_folder(), "README.txt"), out=out, requester=requests, retry=2, retry_wait=0) @pytest.mark.slow def test_download_retries(self): http_server = StoppableThreadBottle() with tools.chdir(tools.mkdir_tmp()): with open("manual.html", "w") as fmanual: fmanual.write("this is some content") manual_file = os.path.abspath("manual.html") from bottle import auth_basic @http_server.server.get("/manual.html") def get_manual(): return static_file(os.path.basename(manual_file), os.path.dirname(manual_file)) def check_auth(user, password): # Check user/password here return user == "user" and password == "passwd" @http_server.server.get('/basic-auth/<user>/<password>') @auth_basic(check_auth) def get_manual_auth(user, password): return static_file(os.path.basename(manual_file), os.path.dirname(manual_file)) http_server.run_server() out = TestBufferConanOutput() dest = os.path.join(temp_folder(), "manual.html") tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=3, retry_wait=0, requester=requests) self.assertTrue(os.path.exists(dest)) content = load(dest) # overwrite = False with self.assertRaises(ConanException): tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=2, retry_wait=0, overwrite=False, requester=requests) # overwrite = True tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=2, retry_wait=0, overwrite=True, requester=requests) self.assertTrue(os.path.exists(dest)) content_new = load(dest) self.assertEqual(content, content_new) # Not authorized with self.assertRaises(ConanException): tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) # Authorized tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, auth=("user", "passwd"), overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) # Authorized using headers tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) http_server.stop() @pytest.mark.slow @patch("conans.tools._global_config") def test_download_unathorized(self, mock_config): http_server = StoppableThreadBottle() mock_config.return_value = ConfigMock() @http_server.server.get('/forbidden') def get_forbidden(): return HTTPError(403, "Access denied.") http_server.run_server() out = TestBufferConanOutput() dest = os.path.join(temp_folder(), "manual.html") # Not authorized with six.assertRaisesRegex(self, AuthenticationException, "403"): tools.download("http://localhost:%s/forbidden" % http_server.port, dest, requester=requests, out=out) http_server.stop() @parameterized.expand([ ["Linux", "x86", None, "x86-linux-gnu"], ["Linux", "x86_64", None, "x86_64-linux-gnu"], ["Linux", "armv6", None, "arm-linux-gnueabi"], ["Linux", "sparc", None, "sparc-linux-gnu"], ["Linux", "sparcv9", None, "sparc64-linux-gnu"], ["Linux", "mips", None, "mips-linux-gnu"], ["Linux", "mips64", None, "mips64-linux-gnu"], ["Linux", "ppc32", None, "powerpc-linux-gnu"], ["Linux", "ppc64", None, "powerpc64-linux-gnu"], ["Linux", "ppc64le", None, "powerpc64le-linux-gnu"], ["Linux", "armv5te", None, "arm-linux-gnueabi"], ["Linux", "arm_whatever", None, "arm-linux-gnueabi"], ["Linux", "armv7hf", None, "arm-linux-gnueabihf"], ["Linux", "armv6", None, "arm-linux-gnueabi"], ["Linux", "armv7", None, "arm-linux-gnueabi"], ["Linux", "armv8_32", None, "aarch64-linux-gnu_ilp32"], ["Linux", "armv5el", None, "arm-linux-gnueabi"], ["Linux", "armv5hf", None, "arm-linux-gnueabihf"], ["Linux", "s390", None, "s390-ibm-linux-gnu"], ["Linux", "s390x", None, "s390x-ibm-linux-gnu"], ["Android", "x86", None, "i686-linux-android"], ["Android", "x86_64", None, "x86_64-linux-android"], ["Android", "armv6", None, "arm-linux-androideabi"], ["Android", "armv7", None, "arm-linux-androideabi"], ["Android", "armv7hf", None, "arm-linux-androideabi"], ["Android", "armv8", None, "aarch64-linux-android"], ["Windows", "x86", "Visual Studio", "i686-windows-msvc"], ["Windows", "x86", "gcc", "i686-w64-mingw32"], ["Windows", "x86_64", "gcc", "x86_64-w64-mingw32"], ["Darwin", "x86_64", None, "x86_64-apple-darwin"], ["Macos", "x86", None, "i686-apple-darwin"], ["iOS", "armv7", None, "arm-apple-ios"], ["iOS", "x86", None, "i686-apple-ios"], ["iOS", "x86_64", None, "x86_64-apple-ios"], ["watchOS", "armv7k", None, "arm-apple-watchos"], ["watchOS", "armv8_32", None, "aarch64-apple-watchos"], ["watchOS", "x86", None, "i686-apple-watchos"], ["watchOS", "x86_64", None, "x86_64-apple-watchos"], ["tvOS", "armv8", None, "aarch64-apple-tvos"], ["tvOS", "armv8.3", None, "aarch64-apple-tvos"], ["tvOS", "x86", None, "i686-apple-tvos"], ["tvOS", "x86_64", None, "x86_64-apple-tvos"], ["Emscripten", "asm.js", None, "asmjs-local-emscripten"], ["Emscripten", "wasm", None, "wasm32-local-emscripten"], ["AIX", "ppc32", None, "rs6000-ibm-aix"], ["AIX", "ppc64", None, "powerpc-ibm-aix"], ["Neutrino", "armv7", None, "arm-nto-qnx"], ["Neutrino", "armv8", None, "aarch64-nto-qnx"], ["Neutrino", "sh4le", None, "sh4-nto-qnx"], ["Neutrino", "ppc32be", None, "powerpcbe-nto-qnx"], ["Linux", "e2k-v2", None, "e2k-unknown-linux-gnu"], ["Linux", "e2k-v3", None, "e2k-unknown-linux-gnu"], ["Linux", "e2k-v4", None, "e2k-unknown-linux-gnu"], ["Linux", "e2k-v5", None, "e2k-unknown-linux-gnu"], ["Linux", "e2k-v6", None, "e2k-unknown-linux-gnu"], ["Linux", "e2k-v7", None, "e2k-unknown-linux-gnu"], ]) def test_get_gnu_triplet(self, os, arch, compiler, expected_triplet): triplet = tools.get_gnu_triplet(os, arch, compiler) self.assertEqual( triplet, expected_triplet, "triplet did not match for ('%s', '%s', '%s')" % (os, arch, compiler)) def test_get_gnu_triplet_on_windows_without_compiler(self): with self.assertRaises(ConanException): tools.get_gnu_triplet("Windows", "x86") def test_detect_windows_subsystem(self): # Don't raise test result = OSInfo.detect_windows_subsystem() if not OSInfo.bash_path() or platform.system() != "Windows": self.assertEqual(None, result) else: self.assertEqual(str, type(result)) @pytest.mark.slow @pytest.mark.local_bottle def test_get_filename_download(self): # Create a tar file to be downloaded from server with tools.chdir(tools.mkdir_tmp()): import tarfile tar_file = tarfile.open("sample.tar.gz", "w:gz") mkdir("test_folder") tar_file.add(os.path.abspath("test_folder"), "test_folder") tar_file.close() file_path = os.path.abspath("sample.tar.gz") assert (os.path.exists(file_path)) # Instance stoppable thread server and add endpoints thread = StoppableThreadBottle() @thread.server.get("/this_is_not_the_file_name") def get_file(): return static_file(os.path.basename(file_path), root=os.path.dirname(file_path)) @thread.server.get("/") def get_file2(): self.assertEqual(request.query["file"], "1") return static_file(os.path.basename(file_path), root=os.path.dirname(file_path)) @thread.server.get("/error_url") def error_url(): from bottle import response response.status = 500 return 'This always fail' thread.run_server() out = TestBufferConanOutput() # Test: File name cannot be deduced from '?file=1' with self.assertRaises(ConanException) as error: tools.get("http://localhost:%s/?file=1" % thread.port, output=out) self.assertIn( "Cannot deduce file name from the url: 'http://localhost:{}/?file=1'." " Use 'filename' parameter.".format(thread.port), str(error.exception)) # Test: Works with filename parameter instead of '?file=1' with tools.chdir(tools.mkdir_tmp()): tools.get("http://localhost:%s/?file=1" % thread.port, filename="sample.tar.gz", requester=requests, output=out, retry=0, retry_wait=0) self.assertTrue(os.path.exists("test_folder")) # Test: Use a different endpoint but still not the filename one with tools.chdir(tools.mkdir_tmp()): from zipfile import BadZipfile with self.assertRaises(BadZipfile): tools.get("http://localhost:%s/this_is_not_the_file_name" % thread.port, requester=requests, output=out, retry=0, retry_wait=0) tools.get("http://localhost:%s/this_is_not_the_file_name" % thread.port, filename="sample.tar.gz", requester=requests, output=out, retry=0, retry_wait=0) self.assertTrue(os.path.exists("test_folder")) thread.stop() with six.assertRaisesRegex(self, ConanException, "Error"): tools.get("http://localhost:%s/error_url" % thread.port, filename="fake_sample.tar.gz", requester=requests, output=out, verify=False, retry=2, retry_wait=0) # Not found error self.assertEqual(str(out).count("Waiting 0 seconds to retry..."), 2) def test_get_unzip_strip_root(self): """Test that the strip_root mechanism from the underlying unzip is called if I call the tools.get by checking that the exception of an invalid zip to flat is raised""" zip_folder = temp_folder() def mock_download(*args, **kwargs): tmp_folder = temp_folder() with chdir(tmp_folder): ori_files_dir = os.path.join(tmp_folder, "subfolder-1.2.3") file1 = os.path.join(ori_files_dir, "file1") file2 = os.path.join(ori_files_dir, "folder", "file2") # !!! This file is not under the root "subfolder-1.2.3" file3 = os.path.join("file3") save(file1, "") save(file2, "") save(file3, "") zip_file = os.path.join(zip_folder, "file.zip") zipdir(tmp_folder, zip_file) with six.assertRaisesRegex( self, ConanException, "The zip file contains more than 1 " "folder in the root"): with patch('conans.client.tools.net.download', new=mock_download): with chdir(zip_folder): tools.get("file.zip", strip_root=True) @pytest.mark.slow @pytest.mark.local_bottle def test_get_gunzip(self): # Create a tar file to be downloaded from server tmp = temp_folder() filepath = os.path.join(tmp, "test.txt.gz") import gzip with gzip.open(filepath, "wb") as f: f.write(b"hello world zipped!") thread = StoppableThreadBottle() @thread.server.get("/test.txt.gz") def get_file(): return static_file(os.path.basename(filepath), root=os.path.dirname(filepath), mimetype="application/octet-stream") thread.run_server() out = TestBufferConanOutput() with tools.chdir(tools.mkdir_tmp()): tools.get("http://*****:*****@patch("conans.client.tools.net.unzip") def test_get_mirror(self, _): """ tools.get must supports a list of URLs. However, only one must be downloaded. """ class MockRequester(object): def __init__(self): self.count = 0 self.fail_first = False self.fail_all = False def get(self, *args, **kwargs): self.count += 1 resp = Response() resp._content = b'{"results": []}' resp.headers = {"Content-Type": "application/json"} resp.status_code = 200 if (self.fail_first and self.count == 1) or self.fail_all: resp.status_code = 408 return resp file = "test.txt.gz" out = TestBufferConanOutput() urls = [ "http://localhost:{}/{}".format(8000 + i, file) for i in range(3) ] # Only the first file must be downloaded with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(1, requester.count) # Fail the first, download only the second with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() requester.fail_first = True tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(2, requester.count) self.assertIn( "WARN: Could not download from the URL {}: Error 408 downloading file {}." " Trying another mirror.".format(urls[0], urls[0]), out) # Fail all downloads with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() requester.fail_all = True with self.assertRaises(ConanException) as error: tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(3, requester.count) self.assertIn("All downloads from (3) URLs have failed.", str(error.exception)) def test_check_output_runner(self): import tempfile original_temp = tempfile.gettempdir() patched_temp = os.path.join(original_temp, "dir with spaces") payload = "hello world" with patch("tempfile.mktemp") as mktemp: mktemp.return_value = patched_temp output = check_output_runner(["echo", payload], stderr=subprocess.STDOUT) self.assertIn(payload, str(output)) def test_unix_to_dos_conanfile(self): client = TestClient() conanfile = """ import os from conans import ConanFile, tools class HelloConan(ConanFile): name = "Hello" version = "0.1" exports_sources = "file.txt" def build(self): assert("\\r\\n" in tools.load("file.txt")) tools.dos2unix("file.txt") assert("\\r\\n" not in tools.load("file.txt")) tools.unix2dos("file.txt") assert("\\r\\n" in tools.load("file.txt")) """ client.save({"conanfile.py": conanfile, "file.txt": "hello\r\n"}) client.run("create . user/channel")
def test_variables_setup(self): conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) # Add some cpp_info for dependencies ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables") cpp_info = CppInfo(ref.name, "dummy_root_folder1") cpp_info.defines = ["MYDEFINE1"] cpp_info.cflags.append("-Flag1=23") cpp_info.version = "1.3" cpp_info.description = "My cool description" conanfile.deps_cpp_info.add(ref.name, cpp_info) ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables") cpp_info = CppInfo(ref.name, "dummy_root_folder2") cpp_info.defines = ["MYDEFINE2"] cpp_info.version = "2.3" cpp_info.exelinkflags = ["-exelinkflag"] cpp_info.sharedlinkflags = ["-sharedlinkflag"] cpp_info.cxxflags = ["-cxxflag"] cpp_info.public_deps = ["MyPkg"] conanfile.deps_cpp_info.add(ref.name, cpp_info) # Add env_info env_info = EnvInfo() env_info.VAR1 = "env_info-value1" env_info.PATH.append("path-extended") conanfile.deps_env_info.update(env_info, "env_info_pkg") # Add user_info user_info = UserInfo() user_info.VAR1 = "user_info-value1" conanfile.deps_user_info["user_info_pkg"] = user_info # Add user_info_build conanfile.user_info_build = DepsUserInfo() user_info = UserInfo() user_info.VAR1 = "user_info_build-value1" conanfile.user_info_build["user_info_build_pkg"] = user_info generator = JsonGenerator(conanfile) json_out = generator.content parsed = json.loads(json_out) # Check dependencies dependencies = parsed["dependencies"] self.assertEqual(len(dependencies), 2) my_pkg = dependencies[0] self.assertEqual(my_pkg["name"], "MyPkg") self.assertEqual(my_pkg["description"], "My cool description") self.assertEqual(my_pkg["defines"], ["MYDEFINE1"]) # Check env_info env_info = parsed["deps_env_info"] self.assertListEqual(sorted(env_info.keys()), sorted(["VAR1", "PATH"])) self.assertEqual(env_info["VAR1"], "env_info-value1") self.assertListEqual(env_info["PATH"], ["path-extended"]) # Check user_info user_info = parsed["deps_user_info"] self.assertListEqual(list(user_info.keys()), ["user_info_pkg"]) self.assertListEqual(list(user_info["user_info_pkg"].keys()), ["VAR1"]) self.assertEqual(user_info["user_info_pkg"]["VAR1"], "user_info-value1") # Check user_info_build user_info_build = parsed["user_info_build"] self.assertListEqual(list(user_info_build.keys()), ["user_info_build_pkg"]) self.assertListEqual( list(user_info_build["user_info_build_pkg"].keys()), ["VAR1"]) self.assertEqual(user_info_build["user_info_build_pkg"]["VAR1"], "user_info_build-value1")
def test_install_profile_settings(self): files = cpp_hello_conan_files("Hello0", "0.1", build=False) # Create a profile and use it profile_settings = OrderedDict([("compiler", "Visual Studio"), ("compiler.version", "12"), ("compiler.runtime", "MD"), ("arch", "x86")]) create_profile(self.client.cache.profiles_path, "vs_12_86", settings=profile_settings, package_settings={}) self.client.cache.default_profile # Creates default tools.replace_in_file(self.client.cache.default_profile_path, "compiler.libcxx", "#compiler.libcxx", strict=False, output=TestBufferConanOutput()) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("install . --build missing -pr vs_12_86") info = self.client.load("conaninfo.txt") for setting, value in profile_settings.items(): self.assertIn("%s=%s" % (setting, value), info) # Try to override some settings in install command self.client.run( "install . --build missing -pr vs_12_86 -s compiler.version=14") info = self.client.load("conaninfo.txt") for setting, value in profile_settings.items(): if setting != "compiler.version": self.assertIn("%s=%s" % (setting, value), info) else: self.assertIn("compiler.version=14", info) # Use package settings in profile tmp_settings = OrderedDict() tmp_settings["compiler"] = "gcc" tmp_settings["compiler.libcxx"] = "libstdc++11" tmp_settings["compiler.version"] = "4.8" package_settings = {"Hello0": tmp_settings} create_profile(self.client.cache.profiles_path, "vs_12_86_Hello0_gcc", settings=profile_settings, package_settings=package_settings) # Try to override some settings in install command self.client.run( "install . --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14" ) info = self.client.load("conaninfo.txt") self.assertIn("compiler=gcc", info) self.assertIn("compiler.libcxx=libstdc++11", info) # If other package is specified compiler is not modified package_settings = {"NoExistsRecipe": tmp_settings} create_profile(self.client.cache.profiles_path, "vs_12_86_Hello0_gcc", settings=profile_settings, package_settings=package_settings) # Try to override some settings in install command self.client.run( "install . --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14" ) info = self.client.load("conaninfo.txt") self.assertIn("compiler=Visual Studio", info) self.assertNotIn("compiler.libcxx", info) # Mix command line package settings with profile package_settings = {"Hello0": tmp_settings} create_profile(self.client.cache.profiles_path, "vs_12_86_Hello0_gcc", settings=profile_settings, package_settings=package_settings) # Try to override some settings in install command self.client.run( "install . --build missing -pr vs_12_86_Hello0_gcc" " -s compiler.version=14 -s Hello0:compiler.libcxx=libstdc++") info = self.client.load("conaninfo.txt") self.assertIn("compiler=gcc", info) self.assertNotIn("compiler.libcxx=libstdc++11", info) self.assertIn("compiler.libcxx=libstdc++", info)
def test_copy(self): output = TestBufferConanOutput() userio = MockedBooleanUserIO(True, out=output) paths = ClientCache(temp_folder(), output) # Create some packages to copy ref = ConanFileReference.loads("Hello/0.1@lasote/testing") self._create_conanfile(ref, paths) self._create_package(ref, "0101001", paths) self._create_package(ref, "2222222", paths) # Copy all to destination package_copy(ref, "lasote/stable", ["0101001", "2222222"], paths, user_io=userio, force=False) new_ref = ConanFileReference.loads("Hello/0.1@lasote/stable") self._assert_conanfile_exists(new_ref, paths) self._assert_package_exists(new_ref, "0101001", paths) self._assert_package_exists(new_ref, "2222222", paths) self.assertIn( "Copied Hello/0.1@lasote/testing to Hello/0.1@lasote/stable", output) self.assertIn("Copied 0101001 to Hello/0.1@lasote/stable", output) self.assertIn("Copied 2222222 to Hello/0.1@lasote/stable", output) # Copy again, without force and answering yes output._stream.truncate(0) # Reset output package_copy(ref, "lasote/stable", ["0101001", "2222222"], paths, user_io=userio, force=False) self.assertIn( "Copied Hello/0.1@lasote/testing to Hello/0.1@lasote/stable", output) self.assertIn("Copied 0101001 to Hello/0.1@lasote/stable", output) self.assertIn("Copied 2222222 to Hello/0.1@lasote/stable", output) self.assertIn("'Hello/0.1@lasote/stable' already exist. Override?", output) self.assertIn("Package '2222222' already exist. Override?", output) self.assertIn("Package '0101001' already exist. Override?", output) # Now alter the origin and copy again to same destination and confirm the copy self._create_conanfile(ref, paths, "new content") self._create_package(ref, "0101001", paths, "new lib content") self._create_package(ref, "2222222", paths, "new lib content") output._stream.truncate(0) # Reset output package_copy(ref, "lasote/stable", ["0101001", "2222222"], paths, user_io=userio, force=False) conanfile_content = load(paths.package_layout(new_ref).conanfile()) self.assertEqual(conanfile_content, "new content") pref = PackageReference(new_ref, "0101001") package_content = load( os.path.join( paths.package_layout(new_ref).package(pref), "package.lib")) self.assertEqual(package_content, "new lib content") # Now we are going to answer always NO to override output._stream.truncate(0) # Reset output userio = MockedBooleanUserIO(False, out=output) self._create_conanfile(ref, paths, "content22") self._create_package(ref, "0101001", paths, "newlib22") self._create_package(ref, "2222222", paths, "newlib22") package_copy(ref, "lasote/stable", ["0101001", "2222222"], paths, user_io=userio, force=False) conanfile_content = load(paths.package_layout(new_ref).conanfile()) self.assertEqual(conanfile_content, "new content") # Not content22 pref = PackageReference(new_ref, "0101001") package_content = load( os.path.join( paths.package_layout(new_ref).package(pref), "package.lib")) self.assertEqual(package_content, "new lib content") # Not newlib22 # If conanfile is not override it exist self.assertNotIn("Package '2222222' already exist. Override?", output) self.assertNotIn("Package '0101001' already exist. Override?", output) self.assertNotIn("Copied 0101001 to Hello/0.1@lasote/stable", output) self.assertNotIn("Copied 2222222 to Hello/0.1@lasote/stable", output) # Now override output._stream.truncate(0) # Reset output package_copy(ref, "lasote/stable", ["0101001", "2222222"], paths, user_io=userio, force=True) self.assertIn("Copied 0101001 to Hello/0.1@lasote/stable", output) self.assertIn("Copied 2222222 to Hello/0.1@lasote/stable", output) # Now copy just one package to another user/channel output._stream.truncate(0) # Reset output package_copy(ref, "pepe/mychannel", ["0101001"], paths, user_io=userio, force=True) self.assertIn("Copied 0101001 to Hello/0.1@pepe/mychannel", output) self.assertNotIn("Copied 2222222 to Hello/0.1@pepe/mychannel", output) new_ref = ConanFileReference.loads("Hello/0.1@pepe/mychannel") self._assert_package_exists(new_ref, "0101001", paths) self._assert_package_doesnt_exists(new_ref, "2222222", paths)
def test_variables_setup(self): conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables") cpp_info = CppInfo(ref.name, "dummy_root_folder1") cpp_info.defines = ["MYDEFINE1"] cpp_info.cflags.append("-Flag1=23") cpp_info.version = "1.3" cpp_info.description = "My cool description" cpp_info.libs = ["MyLib1"] conanfile.deps_cpp_info.add(ref.name, cpp_info) ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables") cpp_info = CppInfo(ref.name, "dummy_root_folder2") cpp_info.libs = ["MyLib2"] cpp_info.defines = ["MYDEFINE2"] cpp_info.version = "2.3" cpp_info.exelinkflags = ["-exelinkflag"] cpp_info.sharedlinkflags = ["-sharedlinkflag"] cpp_info.cxxflags = ["-cxxflag"] cpp_info.public_deps = ["MyPkg"] cpp_info.libdirs.extend(["Path\\with\\slashes", "regular/path/to/dir"]) cpp_info.includedirs.extend( ["other\\Path\\with\\slashes", "other/regular/path/to/dir"]) cpp_info.filter_empty = False conanfile.deps_cpp_info.add(ref.name, cpp_info) generator = BoostBuildGenerator(conanfile) self.assertEqual( generator.content, """lib MyLib1 : : # requirements <name>MyLib1 : # default-build : # usage-requirements <define>MYDEFINE1 <cflags>-Flag1=23 ; lib MyLib2 : : # requirements <name>MyLib2 <search>dummy_root_folder2/lib <search>dummy_root_folder2/Path/with/slashes <search>dummy_root_folder2/regular/path/to/dir : # default-build : # usage-requirements <define>MYDEFINE2 <include>dummy_root_folder2/include <include>dummy_root_folder2/other/Path/with/slashes <include>dummy_root_folder2/other/regular/path/to/dir <cxxflags>-cxxflag <ldflags>-sharedlinkflag ; alias conan-deps : MyLib1 MyLib2 ; """)
def setUp(self): self.target = tempfile.mktemp() self.out = TestBufferConanOutput()
class VCVarsArchTest(unittest.TestCase): output = TestBufferConanOutput() def assert_vcvars_command(self, settings, expected, output=None, **kwargs): output = output or self.output command = tools.vcvars_command(settings, output=output, **kwargs) command = command.replace('"', '').replace("'", "") self.assertTrue(command.endswith('vcvarsall.bat %s' % expected), msg="'{}' doesn't ends with 'vcvarsall.bat {}'".format( command, expected)) def test_arch(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' self.assert_vcvars_command(settings, "x86") with environment_append({"PreferredToolArchitecture": "x64"}): self.assert_vcvars_command(settings, "amd64_x86") settings.arch = 'x86_64' self.assert_vcvars_command(settings, "amd64") settings.arch = 'armv7' self.assert_vcvars_command(settings, "amd64_arm") settings.arch = 'armv8' self.assert_vcvars_command(settings, "amd64_arm64") settings.arch = 'mips' with self.assertRaises(ConanException): tools.vcvars_command(settings, output=self.output) settings.arch_build = 'x86_64' settings.arch = 'x86' self.assert_vcvars_command(settings, "amd64_x86") def test_arch_override(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'mips64' self.assert_vcvars_command(settings, "x86", arch='x86') self.assert_vcvars_command(settings, "amd64", arch='x86_64') self.assert_vcvars_command(settings, "amd64_arm", arch='armv7') self.assert_vcvars_command(settings, "amd64_arm64", arch='armv8') with self.assertRaises(ConanException): tools.vcvars_command(settings, arch='mips', output=self.output) def test_vcvars_ver_override(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '15' settings.arch = 'x86_64' command = tools.vcvars_command(settings, vcvars_ver='14.14', output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('-vcvars_ver=14.14', command) settings.compiler.version = '14' command = tools.vcvars_command(settings, vcvars_ver='14.14', output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('-vcvars_ver=14.14', command) def test_winsdk_version_override(self): settings = Settings.loads(get_default_settings_yml()) settings.compiler = 'Visual Studio' settings.compiler.version = '15' settings.arch = 'x86_64' command = tools.vcvars_command(settings, winsdk_version='8.1', output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('8.1', command) settings.compiler.version = '14' command = tools.vcvars_command(settings, winsdk_version='8.1', output=self.output) self.assertIn('vcvarsall.bat', command) self.assertIn('8.1', command) def test_windows_ce(self): settings = Settings.loads(get_default_settings_yml()) settings.os = 'WindowsCE' settings.compiler = 'Visual Studio' settings.compiler.version = '15' settings.arch = 'armv4i' self.assert_vcvars_command(settings, "x86")
def setUp(self): self.f = tempfile.mktemp() save(self.f, "some contents") self.out = TestBufferConanOutput()
def setUp(self): self.output = TestBufferConanOutput() cache_folder = temp_folder() cache = ClientCache(cache_folder, self.output) self.cache = cache
def test_detect_abs_file_profile(self, _): output = TestBufferConanOutput() with tools.environment_append({"CC": "gcc"}): detect_defaults_settings(output, profile_path="/foo/bar/quz/custom-profile") self.assertIn("conan profile update settings.compiler.libcxx=libstdc++11 " "custom-profile", output)
def log_test(self): conanfile = ''' from conans import ConanFile class ConanFileToolsTest(ConanFile): def build(self): self.run("cmake --version") ''' # A runner logging everything output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=True, generate_run_log_file=True, log_run_to_output=True, output=output) self._install_and_build(conanfile, runner=runner) self.assertIn("--Running---", output) self.assertIn("> cmake --version", output) self.assertIn("cmake version", output) self.assertIn("Logging command output to file ", output) # A runner logging everything output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=True, generate_run_log_file=False, log_run_to_output=True, output=output) self._install_and_build(conanfile, runner=runner) self.assertIn("--Running---", output) self.assertIn("> cmake --version", output) self.assertIn("cmake version", output) self.assertNotIn("Logging command output to file ", output) output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=False, generate_run_log_file=True, log_run_to_output=True, output=output) self._install_and_build(conanfile, runner=runner) self.assertNotIn("--Running---", output) self.assertNotIn("> cmake --version", output) self.assertIn("cmake version", output) self.assertIn("Logging command output to file ", output) output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=False, generate_run_log_file=False, log_run_to_output=True, output=output) self._install_and_build(conanfile, runner=runner) self.assertNotIn("--Running---", output) self.assertNotIn("> cmake --version", output) self.assertIn("cmake version", output) self.assertNotIn("Logging command output to file ", output) output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=False, generate_run_log_file=False, log_run_to_output=False, output=output) self._install_and_build(conanfile, runner=runner) self.assertNotIn("--Running---", output) self.assertNotIn("> cmake --version", output) self.assertNotIn("cmake version", output) self.assertNotIn("Logging command output to file ", output) output = TestBufferConanOutput() runner = ConanRunner(print_commands_to_output=False, generate_run_log_file=True, log_run_to_output=False, output=output) self._install_and_build(conanfile, runner=runner) self.assertNotIn("--Running---", output) self.assertNotIn("> cmake --version", output) self.assertNotIn("cmake version", output) self.assertIn("Logging command output to file ", output)
def cache(self): # Returns a temporary cache object intended for inspecting it return ClientCache(self.cache_folder, TestBufferConanOutput())
def test_detect_clang_gcc_toolchain(self, _): output = TestBufferConanOutput() with tools.environment_append( {"CC": "clang-9 --gcc-toolchain=/usr/lib/gcc/x86_64-linux-gnu/9"}): detect_defaults_settings(output, profile_path="./MyProfile") self.assertIn("CC and CXX: clang-9 --gcc-toolchain", output)
def setUp(self): d = tempfile.mkdtemp() self.target = os.path.join(d, "target") self.out = TestBufferConanOutput()
def setUp(self): self.out = TestBufferConanOutput()
def test_variables_setup(self): tmp_folder1 = temp_folder() tmp_folder2 = temp_folder() save(os.path.join(tmp_folder1, "include1", "file.h"), "") save(os.path.join(tmp_folder2, "include2", "file.h"), "") save(os.path.join(tmp_folder1, "lib1", "file.a"), "") save(os.path.join(tmp_folder2, "lib2", "file.a"), "") save(os.path.join(tmp_folder1, "bin1", "file.bin"), "") save(os.path.join(tmp_folder2, "bin2", "file.bin"), "") save(os.path.join(tmp_folder1, "SystemFrameworks", "file.bin"), "") conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) ref = ConanFileReference.loads("MyPkg1/0.1@lasote/stables") cpp_info = CppInfo(ref.name, tmp_folder1) cpp_info.defines = ["MYDEFINE1"] cpp_info.includedirs = ['include1'] cpp_info.libdirs = ['lib1'] cpp_info.libs = ['libfoo'] cpp_info.bindirs = ['bin1'] cpp_info.version = "0.1" cpp_info.cflags = ['-fgimple'] cpp_info.cxxflags = ['-fdollars-in-identifiers'] cpp_info.sharedlinkflags = ['-framework Cocoa'] cpp_info.exelinkflags = ['-framework QuartzCore'] cpp_info.frameworks = ['AudioUnit'] cpp_info.frameworkdirs = ['SystemFrameworks'] cpp_info.system_libs = ["system_lib1"] conanfile.deps_cpp_info.add(ref.name, cpp_info) ref = ConanFileReference.loads("MyPkg2/3.2.3@lasote/stables") cpp_info = CppInfo(ref.name, tmp_folder2) cpp_info.defines = ["MYDEFINE2"] cpp_info.includedirs = ['include2'] cpp_info.libdirs = ['lib2'] cpp_info.libs = ['libbar'] cpp_info.bindirs = ['bin2'] cpp_info.version = "3.2.3" cpp_info.cflags = ['-fno-asm'] cpp_info.cxxflags = ['-pthread'] cpp_info.sharedlinkflags = ['-framework AudioFoundation'] cpp_info.exelinkflags = ['-framework VideoToolbox'] cpp_info.system_libs = ["system_lib2"] conanfile.deps_cpp_info.add(ref.name, cpp_info) generator = MakeGenerator(conanfile) content = generator.content content_template = """ CONAN_ROOT_MYPKG1 ?= \\ {conan_root_mypkg1} CONAN_SYSROOT_MYPKG1 ?= \\ CONAN_INCLUDE_DIRS_MYPKG1 += \\ {conan_include_dirs_mypkg1} CONAN_LIB_DIRS_MYPKG1 += \\ {conan_lib_dirs_mypkg1} CONAN_BIN_DIRS_MYPKG1 += \\ {conan_bin_dirs_mypkg1} CONAN_BUILD_DIRS_MYPKG1 += \\ {conan_build_dirs_mypkg1} CONAN_RES_DIRS_MYPKG1 += \\ CONAN_LIBS_MYPKG1 += \\ libfoo CONAN_SYSTEM_LIBS_MYPKG1 += \\ system_lib1 CONAN_DEFINES_MYPKG1 += \\ MYDEFINE1 CONAN_CFLAGS_MYPKG1 += \\ -fgimple CONAN_CXXFLAGS_MYPKG1 += \\ -fdollars-in-identifiers CONAN_SHAREDLINKFLAGS_MYPKG1 += \\ -framework Cocoa CONAN_EXELINKFLAGS_MYPKG1 += \\ -framework QuartzCore CONAN_FRAMEWORKS_MYPKG1 += \\ AudioUnit CONAN_FRAMEWORK_PATHS_MYPKG1 += \\ {conan_framework_dirs_mypkg1} CONAN_ROOT_MYPKG2 ?= \\ {conan_root_mypkg2} CONAN_SYSROOT_MYPKG2 ?= \\ CONAN_INCLUDE_DIRS_MYPKG2 += \\ {conan_include_dirs_mypkg2} CONAN_LIB_DIRS_MYPKG2 += \\ {conan_lib_dirs_mypkg2} CONAN_BIN_DIRS_MYPKG2 += \\ {conan_bin_dirs_mypkg2} CONAN_BUILD_DIRS_MYPKG2 += \\ {conan_build_dirs_mypkg2} CONAN_RES_DIRS_MYPKG2 += \\ CONAN_LIBS_MYPKG2 += \\ libbar CONAN_SYSTEM_LIBS_MYPKG2 += \\ system_lib2 CONAN_DEFINES_MYPKG2 += \\ MYDEFINE2 CONAN_CFLAGS_MYPKG2 += \\ -fno-asm CONAN_CXXFLAGS_MYPKG2 += \\ -pthread CONAN_SHAREDLINKFLAGS_MYPKG2 += \\ -framework AudioFoundation CONAN_EXELINKFLAGS_MYPKG2 += \\ -framework VideoToolbox CONAN_FRAMEWORKS_MYPKG2 += \\ CONAN_FRAMEWORK_PATHS_MYPKG2 += \\ CONAN_ROOTPATH += \\ $(CONAN_ROOTPATH_MYPKG1) \\ $(CONAN_ROOTPATH_MYPKG2) CONAN_SYSROOT += \\ $(CONAN_SYSROOT_MYPKG1) \\ $(CONAN_SYSROOT_MYPKG2) CONAN_INCLUDE_DIRS += \\ $(CONAN_INCLUDE_DIRS_MYPKG1) \\ $(CONAN_INCLUDE_DIRS_MYPKG2) CONAN_LIB_DIRS += \\ $(CONAN_LIB_DIRS_MYPKG1) \\ $(CONAN_LIB_DIRS_MYPKG2) CONAN_BIN_DIRS += \\ $(CONAN_BIN_DIRS_MYPKG1) \\ $(CONAN_BIN_DIRS_MYPKG2) CONAN_BUILD_DIRS += \\ $(CONAN_BUILD_DIRS_MYPKG1) \\ $(CONAN_BUILD_DIRS_MYPKG2) CONAN_RES_DIRS += \\ $(CONAN_RES_DIRS_MYPKG1) \\ $(CONAN_RES_DIRS_MYPKG2) CONAN_LIBS += \\ $(CONAN_LIBS_MYPKG1) \\ $(CONAN_LIBS_MYPKG2) CONAN_DEFINES += \\ $(CONAN_DEFINES_MYPKG1) \\ $(CONAN_DEFINES_MYPKG2) CONAN_CFLAGS += \\ $(CONAN_CFLAGS_MYPKG1) \\ $(CONAN_CFLAGS_MYPKG2) CONAN_CXXFLAGS += \\ $(CONAN_CXXFLAGS_MYPKG1) \\ $(CONAN_CXXFLAGS_MYPKG2) CONAN_SHAREDLINKFLAGS += \\ $(CONAN_SHAREDLINKFLAGS_MYPKG1) \\ $(CONAN_SHAREDLINKFLAGS_MYPKG2) CONAN_EXELINKFLAGS += \\ $(CONAN_EXELINKFLAGS_MYPKG1) \\ $(CONAN_EXELINKFLAGS_MYPKG2) CONAN_FRAMEWORKS += \\ $(CONAN_FRAMEWORKS_MYPKG1) \\ $(CONAN_FRAMEWORKS_MYPKG2) CONAN_FRAMEWORK_PATHS += \\ $(CONAN_FRAMEWORK_PATHS_MYPKG1) \\ $(CONAN_FRAMEWORK_PATHS_MYPKG2) """ root1 = tmp_folder1.replace('\\', '/') root2 = tmp_folder2.replace('\\', '/') inc1 = os.path.join(tmp_folder1, 'include1').replace('\\', '/') inc2 = os.path.join(tmp_folder2, 'include2').replace('\\', '/') lib1 = os.path.join(tmp_folder1, 'lib1').replace('\\', '/') lib2 = os.path.join(tmp_folder2, 'lib2').replace('\\', '/') bin1 = os.path.join(tmp_folder1, 'bin1').replace('\\', '/') bin2 = os.path.join(tmp_folder2, 'bin2').replace('\\', '/') expected_content = content_template.format( conan_root_mypkg1=root1, conan_include_dirs_mypkg1=inc1, conan_lib_dirs_mypkg1=lib1, conan_bin_dirs_mypkg1=bin1, conan_build_dirs_mypkg1=root1 + "/", conan_root_mypkg2=root2, conan_include_dirs_mypkg2=inc2, conan_lib_dirs_mypkg2=lib2, conan_bin_dirs_mypkg2=bin2, conan_build_dirs_mypkg2=root2 + "/", conan_framework_dirs_mypkg1=root1 + "/SystemFrameworks") self.maxDiff = None self.assertIn(expected_content, content)
def test_download_retries(self): http_server = StoppableThreadBottle() with tools.chdir(tools.mkdir_tmp()): with open("manual.html", "w") as fmanual: fmanual.write("this is some content") manual_file = os.path.abspath("manual.html") from bottle import auth_basic @http_server.server.get("/manual.html") def get_manual(): return static_file(os.path.basename(manual_file), os.path.dirname(manual_file)) def check_auth(user, password): # Check user/password here return user == "user" and password == "passwd" @http_server.server.get('/basic-auth/<user>/<password>') @auth_basic(check_auth) def get_manual_auth(user, password): return static_file(os.path.basename(manual_file), os.path.dirname(manual_file)) http_server.run_server() out = TestBufferConanOutput() dest = os.path.join(temp_folder(), "manual.html") tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=3, retry_wait=0, requester=requests) self.assertTrue(os.path.exists(dest)) content = load(dest) # overwrite = False with self.assertRaises(ConanException): tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=2, retry_wait=0, overwrite=False, requester=requests) # overwrite = True tools.download("http://localhost:%s/manual.html" % http_server.port, dest, out=out, retry=2, retry_wait=0, overwrite=True, requester=requests) self.assertTrue(os.path.exists(dest)) content_new = load(dest) self.assertEqual(content, content_new) # Not authorized with self.assertRaises(ConanException): tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) # Authorized tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, auth=("user", "passwd"), overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) # Authorized using headers tools.download("http://localhost:%s/basic-auth/user/passwd" % http_server.port, dest, headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True, requester=requests, out=out, retry=0, retry_wait=0) http_server.stop()
def test_complete(self): """ basic installation of a new conans """ client = TestClient() files = cpp_hello_source_files() ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable") reg_folder = client.cache.package_layout(ref).export() client.save(files, path=reg_folder) client.save( { CONANFILE: myconan1, "infos/%s" % CONANINFO: "//empty", "include/no_copy/lib0.h": "NO copy", "include/math/lib1.h": "copy", "include/math/lib2.h": "copy", "include/physics/lib.hpp": "copy", "my_lib/debug/libd.a": "copy", "my_data/readme.txt": "copy", "my_data/readme.md": "NO copy", "contrib/math/math.h": "copy", "contrib/physics/gravity.h": "copy", "contrib/contrib.h": "copy", "include/opencv/opencv.hpp": "copy", "include/opencv2/opencv2.hpp": "copy", "modules/simu/src/simu.cpp": "NO copy", "modules/simu/include/opencv2/simu/simu.hpp": "copy", "modules/3D/doc/readme.md": "NO copy", "modules/3D/include/opencv2/3D/3D.hpp": "copy", "modules/dev/src/dev.cpp": "NO copy", "modules/dev/include/opencv2/dev/dev.hpp": "copy", "modules/opencv_mod.hpp": "copy" }, path=reg_folder) conanfile_path = os.path.join(reg_folder, CONANFILE) pref = PackageReference(ref, "myfakeid") build_folder = client.cache.package_layout(pref.ref).build(pref) package_folder = client.cache.package_layout(pref.ref).package(pref) install_folder = os.path.join(build_folder, "infos") shutil.copytree(reg_folder, build_folder) loader = ConanFileLoader(None, TestBufferConanOutput(), ConanPythonRequire(None, None)) conanfile = loader.load_consumer(conanfile_path, create_profile()) run_package_method(conanfile, None, build_folder, build_folder, package_folder, install_folder, Mock(), conanfile_path, ref, copy_info=True) # test build folder self.assertTrue(os.path.exists(build_folder)) self.assertTrue(os.path.exists(os.path.join(package_folder, CONANINFO))) # test pack folder self.assertTrue(os.path.exists(package_folder)) def exist(rel_path): return os.path.exists(os.path.join(package_folder, rel_path)) # Expected files self.assertTrue(exist("include/lib1.h")) self.assertTrue(exist("include/lib2.h")) self.assertTrue(exist("include/physics/lib.hpp")) self.assertTrue(exist("include/contrib/math/math.h")) self.assertTrue(exist("include/contrib/physics/gravity.h")) self.assertTrue(exist("include/contrib/contrib.h")) self.assertTrue(exist("include/opencv/opencv.hpp")) self.assertTrue(exist("include/opencv2/opencv2.hpp")) self.assertTrue(exist("include/opencv2/simu/simu.hpp")) self.assertTrue(exist("include/opencv2/3D/3D.hpp")) self.assertTrue(exist("include/opencv2/dev/dev.hpp")) self.assertTrue(exist("lib/my_lib/libd.a")) self.assertTrue(exist("res/shares/readme.txt")) # Not expected files self.assertFalse(exist("include/opencv2/opencv_mod.hpp")) self.assertFalse(exist("include/opencv2/simu.hpp")) self.assertFalse(exist("include/opencv2/3D.hpp")) self.assertFalse(exist("include/opencv2/dev.hpp")) self.assertFalse(exist("include/modules/simu/src/simu.cpp")) self.assertFalse(exist("include/modules/3D/doc/readme.md")) self.assertFalse(exist("include/modules/dev/src/dev.cpp")) self.assertFalse(exist("include/opencv2/opencv_mod.hpp")) self.assertFalse(exist("include/include/no_copy/lib0.h")) self.assertFalse(exist("res/my_data/readme.md"))
def test_get_mirror(self, _): """ tools.get must supports a list of URLs. However, only one must be downloaded. """ class MockRequester(object): def __init__(self): self.count = 0 self.fail_first = False self.fail_all = False def get(self, *args, **kwargs): self.count += 1 resp = Response() resp._content = b'{"results": []}' resp.headers = {"Content-Type": "application/json"} resp.status_code = 200 if (self.fail_first and self.count == 1) or self.fail_all: resp.status_code = 408 return resp file = "test.txt.gz" out = TestBufferConanOutput() urls = [ "http://localhost:{}/{}".format(8000 + i, file) for i in range(3) ] # Only the first file must be downloaded with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(1, requester.count) # Fail the first, download only the second with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() requester.fail_first = True tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(2, requester.count) self.assertIn( "WARN: Could not download from the URL {}: Error 408 downloading file {}." " Trying another mirror.".format(urls[0], urls[0]), out) # Fail all downloads with tools.chdir(tools.mkdir_tmp()): requester = MockRequester() requester.fail_all = True with self.assertRaises(ConanException) as error: tools.get(urls, requester=requester, output=out, retry=0, retry_wait=0) self.assertEqual(3, requester.count) self.assertIn("All downloads from (3) URLs have failed.", str(error.exception))
def load_conan_txt_test(self): file_content = '''[requires] OpenCV/2.4.10@phil/stable OpenCV2/2.4.10@phil/stable [build_requires] MyPkg/1.0.0@phil/stable [generators] one two [imports] OpenCV/bin, * -> ./bin # I need this binaries OpenCV/lib, * -> ./lib [options] OpenCV:use_python=True OpenCV:other_option=False OpenCV2:use_python2=1 OpenCV2:other_option=Cosa ''' tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "file.txt") save(file_path, file_content) loader = ConanFileLoader(None, TestBufferConanOutput(), None) ret = loader.load_conanfile_txt(file_path, test_profile()) options1 = OptionsValues.loads("""OpenCV:use_python=True OpenCV:other_option=False OpenCV2:use_python2=1 OpenCV2:other_option=Cosa""") requirements = Requirements() requirements.add("OpenCV/2.4.10@phil/stable") requirements.add("OpenCV2/2.4.10@phil/stable") build_requirements = ["MyPkg/1.0.0@phil/stable"] self.assertEqual(ret.requires, requirements) self.assertEqual(ret.build_requires, build_requirements) self.assertEqual(ret.generators, ["one", "two"]) self.assertEqual(ret.options.values.dumps(), options1.dumps()) ret.copy = Mock() ret.imports() self.assertTrue(ret.copy.call_args_list, [('*', './bin', 'OpenCV/bin'), ('*', './lib', 'OpenCV/lib')]) # Now something that fails file_content = '''[requires] OpenCV/2.4.104phil/stable ''' tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "file.txt") save(file_path, file_content) loader = ConanFileLoader(None, TestBufferConanOutput(), None) with six.assertRaisesRegex(self, ConanException, "The reference has too many '/'"): loader.load_conanfile_txt(file_path, test_profile()) file_content = '''[requires] OpenCV/2.4.10@phil/stable111111111111111111111111111111111111111111111111111111111111111 [imports] OpenCV/bin/* - ./bin ''' tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "file.txt") save(file_path, file_content) loader = ConanFileLoader(None, TestBufferConanOutput(), None) with six.assertRaisesRegex(self, ConanException, "is too long. Valid names must contain"): loader.load_conanfile_txt(file_path, test_profile())
def test_replace_paths(self): folder = temp_folder() path = os.path.join(folder, "file") replace_with = "MYPATH" expected = 'Some other contentsMYPATH"finally all text' out = TestBufferConanOutput() save(path, 'Some other contentsc:\\Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/Path/to/file.txt", replace_with, windows_paths=True, output=out) self.assertEqual(load(path), expected) self.assertTrue(ret) save(path, 'Some other contentsC:/Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/PATH/to/FILE.txt", replace_with, windows_paths=True, output=out) self.assertEqual(load(path), expected) self.assertTrue(ret) save(path, 'Some other contentsD:/Path\\TO\\file.txt"finally all text') ret = tools.replace_path_in_file(path, "C:/PATH/to/FILE.txt", replace_with, strict=False, windows_paths=True, output=out) self.assertEqual( load(path), 'Some other contentsD:/Path\\TO\\file.txt"finally all text') self.assertFalse(ret) # Multiple matches s = 'Some other contentsD:/Path\\TO\\file.txt"finally all textd:\\PATH\\to\\file.TXTMoretext' save(path, s) ret = tools.replace_path_in_file(path, "D:/PATH/to/FILE.txt", replace_with, strict=False, windows_paths=True, output=out) self.assertEqual( load(path), 'Some other contentsMYPATH"finally all textMYPATHMoretext') self.assertTrue(ret) # Automatic windows_paths save(path, s) ret = tools.replace_path_in_file(path, "D:/PATH/to/FILE.txt", replace_with, strict=False, output=out) if platform.system() == "Windows": self.assertEqual( load(path), 'Some other contentsMYPATH"finally all textMYPATHMoretext') self.assertTrue(ret) else: self.assertFalse(ret)
def aux_cmake_test_setup_test(self): conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) generator = CMakeGenerator(conanfile) aux_cmake_test_setup = generator.content # extract the conan_basic_setup macro macro = self._extract_macro("conan_basic_setup", aux_cmake_test_setup) self.assertEqual( """macro(conan_basic_setup) set(options TARGETS NO_OUTPUT_DIRS SKIP_RPATH KEEP_RPATHS SKIP_STD SKIP_FPIC) cmake_parse_arguments(ARGUMENTS "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN} ) if(CONAN_EXPORTED) conan_message(STATUS "Conan: called by CMake conan helper") endif() if(CONAN_IN_LOCAL_CACHE) conan_message(STATUS "Conan: called inside local cache") endif() if(NOT ARGUMENTS_NO_OUTPUT_DIRS) conan_message(STATUS "Conan: Adjusting output directories") conan_output_dirs_setup() endif() if(NOT ARGUMENTS_TARGETS) conan_message(STATUS "Conan: Using cmake global configuration") conan_global_flags() else() conan_message(STATUS "Conan: Using cmake targets configuration") conan_define_targets() endif() if(ARGUMENTS_SKIP_RPATH) # Change by "DEPRECATION" or "SEND_ERROR" when we are ready conan_message(WARNING "Conan: SKIP_RPATH is deprecated, it has been renamed to KEEP_RPATHS") endif() if(NOT ARGUMENTS_SKIP_RPATH AND NOT ARGUMENTS_KEEP_RPATHS) # Parameter has renamed, but we keep the compatibility with old SKIP_RPATH conan_set_rpath() endif() if(NOT ARGUMENTS_SKIP_STD) conan_set_std() endif() if(NOT ARGUMENTS_SKIP_FPIC) conan_set_fpic() endif() conan_check_compiler() conan_set_libcxx() conan_set_vs_runtime() conan_set_find_paths() conan_include_build_modules() conan_set_find_library_paths() endmacro()""", macro) # extract the conan_set_find_paths macro macro = self._extract_macro("conan_set_find_paths", aux_cmake_test_setup) self.assertEqual( """macro(conan_set_find_paths) # CMAKE_MODULE_PATH does not have Debug/Release config, but there are variables # CONAN_CMAKE_MODULE_PATH_DEBUG to be used by the consumer # CMake can find findXXX.cmake files in the root of packages set(CMAKE_MODULE_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_MODULE_PATH}) # Make find_package() to work set(CMAKE_PREFIX_PATH ${CONAN_CMAKE_MODULE_PATH} ${CMAKE_PREFIX_PATH}) # Set the find root path (cross build) set(CMAKE_FIND_ROOT_PATH ${CONAN_CMAKE_FIND_ROOT_PATH} ${CMAKE_FIND_ROOT_PATH}) if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM) set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_PROGRAM}) endif() if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY) set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_LIBRARY}) endif() if(CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE) set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ${CONAN_CMAKE_FIND_ROOT_PATH_MODE_INCLUDE}) endif() endmacro()""", macro)
def valid_xml_test(self, use_toolset): tempdir = temp_folder() with chdir(tempdir): settings = Settings.loads(get_default_settings_yml()) settings.os = "Windows" settings.compiler = "Visual Studio" settings.compiler.version = "11" settings.compiler.runtime = "MD" if use_toolset: settings.compiler.toolset = "v110" conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) ref = ConanFileReference.loads("MyPkg/0.1@user/testing") cpp_info = CppInfo(ref.name, "dummy_root_folder1") conanfile.deps_cpp_info.add(ref.name, cpp_info) ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing") cpp_info = CppInfo(ref.name, "dummy_root_folder2") conanfile.deps_cpp_info.add(ref.name, cpp_info) settings.arch = "x86" settings.build_type = "Debug" conanfile.settings = settings generator = VisualStudioMultiGenerator(conanfile) generator.output_path = "" content = generator.content self.assertEqual(2, len(content)) self.assertIn('conanbuildinfo_multi.props', content.keys()) self.assertIn('conanbuildinfo_debug_win32_v110.props', content.keys()) content_multi = content['conanbuildinfo_multi.props'] self.assertIn( "<Import Condition=\"'$(Configuration)' == 'Debug' " "And '$(Platform)' == 'Win32' " "And '$(PlatformToolset)' == 'v110'\" " "Project=\"conanbuildinfo_debug_win32_v110.props\"/>", content_multi) with open('conanbuildinfo_multi.props', 'w') as f: f.write(content_multi) settings.arch = "x86_64" settings.build_type = "Release" settings.compiler.version = "15" settings.compiler.toolset = "v141" conanfile.settings = settings generator = VisualStudioMultiGenerator(conanfile) generator.output_path = "" content = generator.content self.assertEqual(2, len(content)) self.assertIn('conanbuildinfo_multi.props', content.keys()) self.assertIn('conanbuildinfo_release_x64_v141.props', content.keys()) content_multi = content['conanbuildinfo_multi.props'] self.assertIn( "<Import Condition=\"'$(Configuration)' == 'Debug' " "And '$(Platform)' == 'Win32' " "And '$(PlatformToolset)' == 'v110'\" " "Project=\"conanbuildinfo_debug_win32_v110.props\"/>", content_multi) self.assertIn( "<Import Condition=\"'$(Configuration)' == 'Release' " "And '$(Platform)' == 'x64' " "And '$(PlatformToolset)' == 'v141'\" " "Project=\"conanbuildinfo_release_x64_v141.props\"/>", content_multi) os.unlink('conanbuildinfo_multi.props')
def setUp(self): folder = temp_folder() self.cache = ClientCache(folder, output=TestBufferConanOutput()) mkdir(self.cache.store)