def __init__(self, base_folder=None, current_folder=None, servers=None, users=None, client_version=CLIENT_VERSION, min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION): """ storage_folder: Local storage path current_folder: Current execution folder servers: dict of {remote_name: TestServer} logins is a list of (user, password) for auto input in order if required==> [("lasote", "mypass"), ("other", "otherpass")] """ self.users = users or {"default": [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]} self.servers = servers or {} self.client_version = Version(str(client_version)) self.min_server_compatible_version = Version(str(min_server_compatible_version)) self.base_folder = base_folder or temp_folder() # Define storage_folder, if not, it will be read from conf file & pointed to real user home self.storage_folder = os.path.join(self.base_folder, ".conan", "data") self.paths = ConanPaths(self.base_folder, self.storage_folder, TestBufferConanOutput()) self.default_settings(get_env("CONAN_COMPILER", "gcc"), get_env("CONAN_COMPILER_VERSION", "4.8")) self.init_dynamic_vars() save(self.paths.registry, "") registry = RemoteRegistry(self.paths.registry, TestBufferConanOutput()) for name, server in self.servers.items(): registry.add(name, server.fake_url) logger.debug("Client storage = %s" % self.storage_folder) self.current_folder = current_folder or temp_folder()
def testMd5Name(self): files = { "one_file.txt": { "contents": b"The contents", "mode": 0o777 }, "Two_file.txt": { "contents": b"Two contents", "mode": 0o777 } } new_files = compress_files(files, PACKAGE_TGZ_NAME, excluded=[]) folder = temp_folder() file_path = os.path.join(folder, PACKAGE_TGZ_NAME) save(file_path, new_files[PACKAGE_TGZ_NAME]) md5_a = md5sum(file_path) time.sleep(1) # Timestamps change new_files = compress_files(files, PACKAGE_TGZ_NAME, excluded=[]) folder = temp_folder() file_path = os.path.join(folder, PACKAGE_TGZ_NAME) save(file_path, new_files[PACKAGE_TGZ_NAME]) md5_b = md5sum(file_path) self.assertEquals(md5_a, md5_b)
def test_md5_compress(self): folder = temp_folder() save(os.path.join(folder, "one_file.txt"), b"The contents") save(os.path.join(folder, "Two_file.txt"), b"Two contents") files = { "one_file.txt": os.path.join(folder, "one_file.txt"), "Two_file.txt": os.path.join(folder, "Two_file.txt"), } compress_files(files, {}, PACKAGE_TGZ_NAME, dest_dir=folder) file_path = os.path.join(folder, PACKAGE_TGZ_NAME) md5_a = md5sum(file_path) self.assertEqual(md5_a, "df220cfbc0652e8992a89a77666c03b5") time.sleep(1) # Timestamps change folder = temp_folder() compress_files(files, {}, PACKAGE_TGZ_NAME, dest_dir=folder) file_path = os.path.join(folder, PACKAGE_TGZ_NAME) md5_b = md5sum(file_path) self.assertEquals(md5_a, md5_b)
def __init__( self, base_folder=None, current_folder=None, servers=None, users=None, client_version=CLIENT_VERSION, min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION, ): """ storage_folder: Local storage path current_folder: Current execution folder servers: dict of {remote_name: TestServer} logins is a list of (user, password) for auto input in order if required==> [("lasote", "mypass"), ("other", "otherpass")] """ if users is None: users = [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)] self.users = users self.servers = servers or {} self.client_version = Version(client_version) self.min_server_compatible_version = Version(min_server_compatible_version) self.base_folder = base_folder or temp_folder() # Define storage_folder, if not, it will be readed from conf file and pointed to real user home self.storage_folder = os.path.join(self.base_folder, ".conan", "data") # First initialization for set paths (some test copies data before first real initialization) self.init_dynamic_vars() self.default_settings(get_env("CONAN_COMPILER", "gcc"), get_env("CONAN_COMPILER_VERSION", "4.8")) logger.debug("Client storage = %s" % self.storage_folder) self.current_folder = current_folder or temp_folder()
def trace_command_test(self): from conans.build_info.command import run trace_file = os.path.join(temp_folder(), "conan_trace.log") # Generate some traces with tools.environment_append({"CONAN_TRACE_FILE": trace_file}): files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("install Hello0/1.0@lasote/stable --build") self.client.run("upload '*' --all -c") # Get json from file output = os.path.join(temp_folder(), "build_info.json") sys.argv = ['conan_build_info', trace_file, '--output', output] run() the_json = json.loads(load(output)) self.assertTrue(the_json["modules"][0]["id"], "Hello0/1.0@lasote/stable") # Now get from stdout sys.argv = ['conan_build_info', trace_file] run() try: # in IDEs or with --nocapture it will fail stdout_value = sys.stdout.getvalue() except AttributeError: pass else: the_json = json.loads(stdout_value) self.assertTrue(the_json["modules"][0]["id"], "Hello0/1.0@lasote/stable")
def __init__(self, base_folder=None, current_folder=None, servers=None, users=None, client_version=CLIENT_VERSION, min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION, requester_class=None, runner=None, path_with_spaces=True): """ storage_folder: Local storage path current_folder: Current execution folder servers: dict of {remote_name: TestServer} logins is a list of (user, password) for auto input in order if required==> [("lasote", "mypass"), ("other", "otherpass")] """ self.all_output = "" # For debugging purpose, append all the run outputs self.users = users or {"default": [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]} self.client_version = Version(str(client_version)) self.min_server_compatible_version = Version(str(min_server_compatible_version)) self.base_folder = base_folder or temp_folder(path_with_spaces) # Define storage_folder, if not, it will be read from conf file & pointed to real user home self.storage_folder = os.path.join(self.base_folder, ".conan", "data") self.client_cache = ClientCache(self.base_folder, self.storage_folder, TestBufferConanOutput()) self.search_manager = DiskSearchManager(self.client_cache) self.requester_class = requester_class self.conan_runner = runner self.update_servers(servers) self.init_dynamic_vars() logger.debug("Client storage = %s" % self.storage_folder) self.current_folder = current_folder or temp_folder(path_with_spaces)
def basic_test(self): folder1 = temp_folder() sub1 = os.path.join(folder1, "subdir1") sub2 = os.path.join(folder1, "subdir2") save(os.path.join(sub1, "file1.txt"), "Hello1") save(os.path.join(sub1, "file2.c"), "Hello2") save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub") save(os.path.join(sub1, "sub1/file2.c"), "Hello2 sub") save(os.path.join(sub2, "file1.txt"), "2 Hello1") save(os.path.join(sub2, "file2.c"), "2 Hello2") folder2 = temp_folder() copier = FileCopier(folder1, folder2) copier("*.txt", "texts") self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt"))) self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt"))) self.assertEqual("2 Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt"))) self.assertEqual(['file1.txt'], os.listdir(os.path.join(folder2, "texts/subdir2"))) folder2 = temp_folder() copier = FileCopier(folder1, folder2) copier("*.txt", "texts", "subdir1") self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt"))) self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt"))) self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
def basic_with_linked_dir_test(self): if platform.system() == "Linux" or platform.system() == "Darwin": folder1 = temp_folder() sub1 = os.path.join(folder1, "subdir1") sub2 = os.path.join(folder1, "subdir2") os.makedirs(sub1) os.symlink("subdir1", sub2) save(os.path.join(sub1, "file1.txt"), "Hello1") save(os.path.join(sub1, "file2.c"), "Hello2") save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub") folder2 = temp_folder() copier = FileCopier(folder1, folder2) copier("*.txt", "texts") self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt"))) self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt"))) self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt"))) self.assertEqual(['file1.txt', 'sub1'].sort(), os.listdir(os.path.join(folder2, "texts/subdir2")).sort()) folder2 = temp_folder() copier = FileCopier(folder1, folder2) copier("*.txt", "texts", "subdir1") self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt"))) self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt"))) self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
def valid_xml_test(self): conanfile = ConanFile(None, None, Settings({}), None) ref = ConanFileReference.loads("MyPkg/0.1@user/testing") folder1 = temp_folder() folder1 = folder1.replace("\\", "/") os.makedirs(os.path.join(folder1, "include")) os.makedirs(os.path.join(folder1, "lib")) cpp_info = CppInfo(folder1) conanfile.deps_cpp_info.update(cpp_info, ref.name) ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing") folder2 = temp_folder() folder2 = folder2.replace("\\", "/") os.makedirs(os.path.join(folder2, "include")) os.makedirs(os.path.join(folder2, "lib")) cpp_info = CppInfo(folder2) conanfile.deps_cpp_info.update(cpp_info, ref.name) generator = VisualStudioLegacyGenerator(conanfile) content = generator.content xml.etree.ElementTree.fromstring(content) self.assertIn('AdditionalIncludeDirectories=""%s/include";"%s/include";"' % (folder1, folder2), content) self.assertIn('AdditionalLibraryDirectories=""%s/lib";"%s/lib";"' % (folder1, folder2), content)
def setUp(self): self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing") self.package_reference = PackageReference(self.conan_reference, "123123123") self.remote_client = MockRemoteClient() self.output = TestBufferConanOutput() self.client_cache = ClientCache(temp_folder(), temp_folder(), self.output) self.manager = RemoteManager(self.client_cache, self.remote_client, self.output)
def setUp(self): self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing") self.package_reference = PackageReference(self.conan_reference, "123123123") self.remote_client = MockRemoteClient() self.output = TestBufferConanOutput() self.paths = ConanPaths(temp_folder(), temp_folder(), self.output) self.remotes = [("default", "url1"), ("other", "url2"), ("last", "url3")] self.manager = RemoteManager(self.paths, self.remote_client, self.output)
def download_retries_test(self): out = TestBufferConanOutput() set_global_instances(out, requests) # Connection error with self.assertRaisesRegexp(ConanException, "HTTPConnectionPool"): tools.download("http://fakeurl3.es/nonexists", os.path.join(temp_folder(), "file.txt"), out=out, retry=3, retry_wait=0) # Not found error self.assertEquals(str(out).count("Waiting 0 seconds to retry..."), 2) with self.assertRaisesRegexp(NotFoundException, "Not found: "): tools.download("https://github.com/conan-io/conan/blob/develop/FILE_NOT_FOUND.txt", os.path.join(temp_folder(), "README.txt"), out=out, retry=3, retry_wait=0) # And OK dest = os.path.join(temp_folder(), "manual.html") tools.download("http://www.zlib.net/manual.html", dest, out=out, retry=3, retry_wait=0) self.assertTrue(os.path.exists(dest)) content = load(dest) # overwrite = False with self.assertRaises(ConanException): tools.download("http://www.zlib.net/manual.html", dest, out=out, retry=3, retry_wait=0, overwrite=False) # overwrite = True tools.download("http://www.zlib.net/manual.html", dest, out=out, retry=3, retry_wait=0, overwrite=True) self.assertTrue(os.path.exists(dest)) content_new = load(dest) self.assertEqual(content, content_new) # Not authorized with self.assertRaises(ConanException): tools.download("https://httpbin.org/basic-auth/user/passwd", dest, overwrite=True) # Authorized tools.download("https://httpbin.org/basic-auth/user/passwd", dest, auth=("user", "passwd"), overwrite=True) # Authorized using headers tools.download("https://httpbin.org/basic-auth/user/passwd", dest, headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True)
def local_package_build_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 build_folder = os.path.join(client.current_folder, "build") mkdir(build_folder) client.current_folder = build_folder client.run("install .. -g env -g txt") client.run("source ..") client.run("build ..") client.current_folder = temp_folder() client.run('package "%s/build"' % origin_folder) content = load(os.path.join(client.current_folder, "include/file.h")) self.assertEqual(content, "foo")
def test_replace_in_file(self): file_content = ''' from conans import ConanFile from conans.tools import download, unzip, replace_in_file import os class ConanFileToolsTest(ConanFile): name = "test" version = "1.9.10" settings = [] def source(self): pass def build(self): replace_in_file("otherfile.txt", "ONE TWO THREE", "FOUR FIVE SIX") ''' tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "conanfile.py") other_file = os.path.join(tmp_dir, "otherfile.txt") save(file_path, file_content) save(other_file, "ONE TWO THREE") loader = ConanFileLoader(None, None, Settings(), OptionsValues.loads("")) ret = loader.load_conan(file_path) curdir = os.path.abspath(os.curdir) os.chdir(tmp_dir) try: ret.build() finally: os.chdir(curdir) content = load(other_file) self.assertEquals(content, "FOUR FIVE SIX")
def test_paths(self): """Unit test of path_exists""" tmp_dir = temp_folder() new_path = os.path.join(tmp_dir, "CapsDir") mkdir(new_path) self.assertTrue(path_exists(new_path, tmp_dir)) self.assertFalse(path_exists(os.path.join(tmp_dir, "capsdir"), tmp_dir))
def test_basic(self): """ check that we do not generate anymore tgz with .c_src. also, they are not present any more in the cache layout, even if they come from a .c_src tgz server file """ test_server = TestServer() servers = {"default": test_server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({"conanfile.py": """from conans import ConanFile class MyPkg(ConanFile): name= "Pkg" version = "0.1" exports_sources = "*.txt" """, "myfile.txt": "Hello world"}) client.run("export . lasote/testing") client.run("upload Pkg/0.1@lasote/testing") client.run("remove * -f") client.run("search") self.assertIn("There are no packages", client.user_io.out) conan_reference = ConanFileReference.loads("Pkg/0.1@lasote/testing") path = test_server.paths.export(conan_reference) sources_tgz = os.path.join(path, "conan_sources.tgz") self.assertTrue(os.path.exists(sources_tgz)) folder = temp_folder() with open(sources_tgz, 'rb') as file_handler: tar_extract(file_handler, folder) self.assertEqual(os.listdir(folder), ["myfile.txt"]) # Now install again client.run("install Pkg/0.1@lasote/testing --build=missing") export = client.client_cache.export(conan_reference) self.assertNotIn(EXPORT_SOURCES_DIR_OLD, os.listdir(export)) export_sources = client.client_cache.export_sources(conan_reference) self.assertEqual(os.listdir(export_sources), ["myfile.txt"])
def test_values(self): config = ConanServerConfigParser(self.file_path, environment=self.environ) self.assertEquals(config.jwt_secret, "mysecret") self.assertEquals(config.jwt_expire_time, timedelta(minutes=121)) self.assertEquals(config.disk_storage_path, self.storage_path) self.assertTrue(config.ssl_enabled) self.assertEquals(config.port, 9220) self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.read_permissions, [("*/*@*/*", "*"), ("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.users, {"lasote": "defaultpass", "pepe": "pepepass"}) # Now check with environments tmp_storage = temp_folder() self.environ["CONAN_STORAGE_PATH"] = tmp_storage self.environ["CONAN_JWT_SECRET"] = "newkey" self.environ["CONAN_JWT_EXPIRE_MINUTES"] = "123" self.environ["CONAN_SSL_ENABLED"] = "False" self.environ["CONAN_SERVER_PORT"] = "1233" self.environ["CONAN_SERVER_USERS"] = "lasote:lasotepass,pepe2:pepepass2" config = ConanServerConfigParser(self.file_path, environment=self.environ) self.assertEquals(config.jwt_secret, "newkey") self.assertEquals(config.jwt_expire_time, timedelta(minutes=123)) self.assertEquals(config.disk_storage_path, os.path.expanduser(tmp_storage)) self.assertFalse(config.ssl_enabled) self.assertEquals(config.port, 1233) self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.read_permissions, [("*/*@*/*", "*"), ("openssl/2.0.1@lasote/testing", "pepe")]) self.assertEquals(config.users, {"lasote": "lasotepass", "pepe2": "pepepass2"})
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 _upload_recipe(self, conan_reference, base_files=None, retry=1, retry_wait=0): files = hello_source_files(3, [1, 12]) if base_files: files.update(base_files) content = """ from conans import ConanFile class MyConan(ConanFile): name = "%s" version = "%s" settings = arch, compiler, os """ % (conan_reference.name, conan_reference.version) files[CONANFILE] = content files_md5s = {filename: md5(content) for filename, content in files.items()} conan_digest = FileTreeManifest(123123123, files_md5s) files[CONAN_MANIFEST] = str(conan_digest) tmp_dir = temp_folder() abs_paths = {} for filename, content in files.items(): abs_path = os.path.join(tmp_dir, filename) save(abs_path, content) abs_paths[filename] = abs_path self.api.upload_recipe(conan_reference, abs_paths, retry, retry_wait, False)
def setUp(self): folder = temp_folder() paths = SimplePaths(folder) search_adapter = DiskSearchAdapter() self.search_manager = DiskSearchManager(paths, search_adapter) os.chdir(paths.store) self.paths = paths
def _save_files(self, file_content): tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "conanfile.py") text_file = os.path.join(tmp_dir, "text.txt") save(file_path, file_content) save(text_file, "ONE TWO THREE") return tmp_dir, file_path, text_file
def test_cross_remotes(self): # Upload to alternative server Hello0 but Hello1 to the default files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False) self.client.save(files) self.client.run("export . lasote/stable") files = cpp_hello_conan_files("Hello1", "1.0", deps=["Hello0/1.0@lasote/stable"], build=False) self.client.save(files) self.client.run("export . lasote/stable") self.client.run("export . lasote/stable") self.client.run("install Hello1/1.0@lasote/stable --build missing") self.client.run("upload 'Hello0*' -c --all -r alternative") self.client.run("upload 'Hello1*' -c --all -r default") trace_file = os.path.join(temp_folder(), "conan_trace.log") with tools.environment_append({"CONAN_TRACE_FILE": trace_file}): # Will retrieve the Hello0 deps from the alternative self.client.run("install Hello1/1.0@lasote/stable --build") # Upload to the default, not matching the Hello0 remote self.client.run("upload 'Hello1*' -c --all -r default") data = get_build_info(trace_file).serialize() self.assertEquals(len(data["modules"]), 2) module = _get_module(data, "Hello1/1.0@lasote/stable") self.assertEquals(0, len(module["dependencies"]))
def unzip_output_test(self): tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "example.txt") save(file_path, "Hello world!") zip_path = os.path.join(tmp_dir, 'example.zip') zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) for root, _, files in os.walk(tmp_dir): for f in files: zipf.write(os.path.join(root, f), f) zipf.close() output_dir = os.path.join(tmp_dir, "output_dir") new_out = StringIO() old_out = sys.stdout try: sys.stdout = new_out tools.unzip(zip_path, output_dir) finally: sys.stdout = old_out output = new_out.getvalue() self.assertRegexpMatches(output, "Unzipping [\d]+ bytes, this can take a while") content = load(os.path.join(output_dir, "example.txt")) self.assertEqual(content, "Hello world!")
def env_vars_test_inheritance(self): tmp_dir = temp_folder() p1 = '''[env]\nVAR=1''' p2 = '''include(p1)\n[env]\nVAR=2''' save(os.path.join(tmp_dir, "p1"), p1) new_profile, _ = _load_profile(p2, tmp_dir, tmp_dir) self.assertEquals(new_profile.env_values.data[None]["VAR"], "2")
def setUp(self): self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing") self.package_reference = PackageReference(self.conan_reference, "123123123") self.tmp_dir = temp_folder() read_perms = [("*/*@*/*", "*")] write_perms = [] authorizer = BasicAuthorizer(read_perms, write_perms) self.fake_url = "http://url" updown_auth_manager = JWTUpDownAuthManager("secret", timedelta(seconds=200)) adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager) self.paths = SimplePaths(self.tmp_dir) self.file_manager = FileManager(self.paths, adapter) search_adapter = DiskSearchAdapter() self.search_manager = DiskSearchManager(self.paths, search_adapter) self.service = ConanService(authorizer, self.file_manager, "lasote") self.search_service = SearchService(authorizer, self.search_manager, "lasote") files = hello_source_files("test") save_files(self.paths.export(self.conan_reference), files) self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference)) conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST) save(conan_digest_path, str(self.conan_digest)) files = hello_source_files("package") save_files(self.paths.package(self.package_reference), files)
def unzip_output_test(self): tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "example.txt") save(file_path, "Hello world!") zip_path = os.path.join(tmp_dir, 'example.zip') zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) for root, _, files in os.walk(tmp_dir): for f in files: zipf.write(os.path.join(root, f), f) zipf.close() output_dir = os.path.join(tmp_dir, "output_dir") new_out = StringIO() old_out = sys.stdout try: import requests import conans conans.tools.set_global_instances(ConanOutput(new_out), requests) tools.unzip(zip_path, output_dir) finally: conans.tools.set_global_instances(ConanOutput(old_out), requests) output = new_out.getvalue() self.assertRegexpMatches(output, "Unzipping [\d]+B") content = load(os.path.join(output_dir, "example.txt")) self.assertEqual(content, "Hello world!")
def test_basic(self): current_folder = temp_folder() source_folder = os.path.join(current_folder, "source") 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': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': '5632cf850a7161388ab24f42b9bdb3fd', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
def short_paths_unzip_output_test(self): if platform.system() != "Windows": return tmp_dir = temp_folder() file_path = os.path.join(tmp_dir, "src/"*40, "example.txt") save(file_path, "Hello world!") zip_path = os.path.join(tmp_dir, 'example.zip') zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) for root, _, files in os.walk(tmp_dir): for f in files: zipf.write(os.path.join(root, f), os.path.join("src/"*20, f)) zipf.close() output_dir = os.path.join(tmp_dir, "dst/"*40, "output_dir") new_out = StringIO() old_out = sys.stdout try: import conans conans.tools.set_global_instances(ConanOutput(new_out), None) tools.unzip(zip_path, output_dir) finally: conans.tools.set_global_instances(ConanOutput(old_out), None) output = new_out.getvalue() self.assertIn("ERROR: Error extract src/src", output)
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 test_tree_manifest(self): tmp_dir = temp_folder() files = {"one.ext": "aalakjshdlkjahsdlkjahsdljkhsadljkhasljkdhlkjashd", "path/to/two.txt": "asdas13123", "two.txt": "asdasdasdasdasdasd", "folder/damn.pyc": "binarythings", "folder/damn.pyo": "binarythings2", "pythonfile.pyc": "binarythings3"} for filename, content in files.items(): save(os.path.join(tmp_dir, filename), content) manifest = FileTreeManifest.create(tmp_dir) save(os.path.join(tmp_dir, "THEMANIFEST.txt"), str(manifest)) readed_manifest = FileTreeManifest.loads(load(os.path.join(tmp_dir, "THEMANIFEST.txt"))) self.assertEqual(readed_manifest.time, manifest.time) self.assertEqual(readed_manifest, manifest) # Not included the pycs or pyo self.assertEquals(set(manifest.file_sums.keys()), set(["one.ext", "path/to/two.txt", "two.txt"])) for filepath, md5readed in manifest.file_sums.items(): content = files[filepath] self.assertEquals(md5(content), md5readed)
def test_install_multiple_configs(self): folder = temp_folder() save_files(folder, { "subf/file.txt": "hello", "subf2/file2.txt": "bye" }) self.client.run('config install "%s" -sf=subf' % folder) content = load(os.path.join(self.client.cache_folder, "file.txt")) file2 = os.path.join(self.client.cache_folder, "file2.txt") self.assertEqual(content, "hello") self.assertFalse(os.path.exists(file2)) self.client.run('config install "%s" -sf=subf2' % folder) content = load(file2) self.assertEqual(content, "bye") save_files(folder, { "subf/file.txt": "HELLO!!", "subf2/file2.txt": "BYE!!" }) self.client.run('config install') content = load(os.path.join(self.client.cache_folder, "file.txt")) self.assertEqual(content, "HELLO!!") content = load(file2) self.assertEqual(content, "BYE!!")
def profile_dir_test(self): tmp = temp_folder() txt = ''' [env] PYTHONPATH=$PROFILE_DIR/my_python_tools ''' def assert_path(profile): pythonpath = profile.env_values.env_dicts("")[0]["PYTHONPATH"] self.assertEqual( pythonpath, os.path.join(tmp, "my_python_tools").replace('\\', '/')) abs_profile_path = os.path.join(tmp, "Myprofile.txt") save(abs_profile_path, txt) profile, _ = read_profile(abs_profile_path, None, None) assert_path(profile) profile, _ = read_profile("./Myprofile.txt", tmp, None) assert_path(profile) profile, _ = read_profile("Myprofile.txt", None, tmp) assert_path(profile)
def _upload_package(self, package_reference, base_files=None): files = { "conanfile.py": GenConanfile("3").with_requires("1", "12").with_exports("*"), "hello.cpp": "hello" } if base_files: files.update(base_files) tmp_dir = temp_folder() abs_paths = {} for filename, content in files.items(): abs_path = os.path.join(tmp_dir, filename) save(abs_path, str(content)) abs_paths[filename] = abs_path self.api.upload_package(package_reference, abs_paths, None, retry=1, retry_wait=0)
def test_dirty_download(self): # https://github.com/conan-io/conan/issues/8578 client = TestClient(default_server_user=True) cache_folder = temp_folder() client.run('config set storage.download_cache="%s"' % cache_folder) client.save({ "conanfile.py": GenConanfile().with_package_file("file.txt", "content") }) client.run("create . pkg/0.1@") client.run("upload * --all -c") client.run("remove * -f") client.run("install pkg/0.1@") for f in os.listdir(cache_folder): # damage the file path = os.path.join(cache_folder, f) if os.path.isfile(path): save(path, "broken!") set_dirty(path) client.run("remove * -f") client.run("install pkg/0.1@") assert "pkg/0.1: Downloaded package" in client.out
def test_define_prefix(self): if platform.system() == "Windows": return tmp_dir = temp_folder() filename = os.path.join(tmp_dir, 'libastral.pc') with open(filename, 'w') as f: f.write(libastral_pc) with environment_append({'PKG_CONFIG_PATH': tmp_dir}): pkg_config = PkgConfig("libastral", variables={'prefix': '/home/conan'}) self.assertEquals(frozenset(pkg_config.cflags), frozenset(['-D_USE_LIBASTRAL', '-I/home/conan/include/libastral'])) self.assertEquals(frozenset(pkg_config.cflags_only_I), frozenset(['-I/home/conan/include/libastral'])) self.assertEquals(frozenset(pkg_config.cflags_only_other), frozenset(['-D_USE_LIBASTRAL'])) self.assertEquals(frozenset(pkg_config.libs), frozenset(['-L/home/conan/lib/libastral', '-lastral', '-Wl,--whole-archive'])) self.assertEquals(frozenset(pkg_config.libs_only_L), frozenset(['-L/home/conan/lib/libastral'])) self.assertEquals(frozenset(pkg_config.libs_only_l), frozenset(['-lastral', ])) self.assertEquals(frozenset(pkg_config.libs_only_other), frozenset(['-Wl,--whole-archive'])) self.assertEquals(pkg_config.variables['prefix'], '/home/conan') os.unlink(filename)
def test_env_files_sh(env, prevenv): display = textwrap.dedent("""\ echo MyVar=$MyVar!! echo MyVar1=$MyVar1!! echo MyVar2=$MyVar2!! echo MyVar3=$MyVar3!! echo MyVar4=$MyVar4!! echo MyVar5=$MyVar5!! echo MyVar6=$MyVar6!! echo MyPath1=$MyPath1!! echo MyPath2=$MyPath2!! echo MyPath3=$MyPath3!! echo MyPath4=$MyPath4!! """) with chdir(temp_folder()): env = env.vars(ConanFileMock()) env.save_sh("test.sh") save("display.sh", display) os.chmod("display.sh", 0o777) # We include the "set -e" to test it is robust against errors cmd = 'set -e && . ./test.sh && ./display.sh && . ./deactivate_test.sh && ./display.sh' check_env_files_output(cmd, prevenv)
def test_build_info_old_lockfile_version(self, mock_cache, user_home_mock): base_folder = temp_folder(True) cache_folder = os.path.join(base_folder, ".conan") client = TestClient(cache_folder=cache_folder) client.save({"conan.lock": '{"version": "0.2"}'}) mock_cache.return_value = client.cache user_home_mock.return_value = cache_folder sys.argv = ["conan_build_info", "--v2", "start", "MyBuildName", "42"] run() sys.argv = ["conan_build_info", "--v2", "create", os.path.join(client.current_folder, "buildinfo.json"), "--lockfile", os.path.join(client.current_folder, "conan.lock")] old_stderr = sys.stderr try: result = StringIO() sys.stderr = result run() result = result.getvalue() self.assertIn("This lockfile was created with an incompatible version of Conan", result) finally: sys.stderr = old_stderr
def test_env_files_ps1(env, prevenv): prevenv.update(dict(os.environ.copy())) display = textwrap.dedent("""\ echo "MyVar=$env:MyVar!!" echo "MyVar1=$env:MyVar1!!" echo "MyVar2=$env:MyVar2!!" echo "MyVar3=$env:MyVar3!!" echo "MyVar4=$env:MyVar4!!" echo "MyVar5=$env:MyVar5!!" echo "MyVar6=$env:MyVar6!!" echo "MyPath1=$env:MyPath1!!" echo "MyPath2=$env:MyPath2!!" echo "MyPath3=$env:MyPath3!!" echo "MyPath4=$env:MyPath4!!" """) with chdir(temp_folder()): env = env.vars(ConanFileMock()) env.save_ps1("test.ps1") save("display.ps1", display) cmd = "powershell.exe .\\test.ps1 ; .\\display.ps1 ; .\\deactivate_test.ps1 ; .\\display.ps1" check_env_files_output(cmd, prevenv)
def test_basic(self): folder = temp_folder() file_path = os.path.join(folder, "myfile.txt") self.cached_downloader.download("testurl", file_path) self.assertEqual(self.file_downloader.calls["testurl"], 1) self.assertEqual("testurl", load(file_path)) # Try again, the count will be the same self.cached_downloader.download("testurl", file_path) self.assertEqual(self.file_downloader.calls["testurl"], 1) # Try direct content content = self.cached_downloader.download("testurl") self.assertEqual(content.decode("utf-8"), "testurl") self.assertEqual(self.file_downloader.calls["testurl"], 1) # Try another file file_path = os.path.join(folder, "myfile2.txt") self.cached_downloader.download("testurl2", file_path) self.assertEqual(self.file_downloader.calls["testurl2"], 1) self.assertEqual("testurl2", load(file_path)) self.cached_downloader.download("testurl2", file_path) self.assertEqual(self.file_downloader.calls["testurl"], 1) self.assertEqual(self.file_downloader.calls["testurl2"], 1)
def test_deleted_source_folder(self): path, _ = create_local_git_repo({"myfile": "contents"}, branch="my_release") curdir = self.client.current_folder.replace("\\", "/") conanfile = base_git.format(url=_quoted("auto"), revision="auto") self.client.save({ "conanfile.py": conanfile, "myfile.txt": "My file is copied" }) create_local_git_repo(folder=self.client.current_folder) self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/")) self.client.run("export . user/channel") new_curdir = temp_folder() self.client.current_folder = new_curdir # delete old source, so it will try to checkout the remote because of the missing local dir rmdir(curdir) self.client.run("install lib/0.1@user/channel --build", assert_error=True) self.assertIn( "Getting sources from url: '%s'" % path.replace("\\", "/"), self.client.out)
def test_migration_editables_to_conanfile_name(self): # Create the old editable_packages.json file (and user workspace) tmp_folder = temp_folder() conanfile1 = os.path.join(tmp_folder, 'dir1', 'conanfile.py') conanfile2 = os.path.join(tmp_folder, 'dir2', 'conanfile.py') save(conanfile1, "anything") save(conanfile2, "anything") save(os.path.join(tmp_folder, EDITABLE_PACKAGES_FILE), json.dumps({"name/version": {"path": os.path.dirname(conanfile1), "layout": None}, "other/version@user/testing": {"path": os.path.dirname(conanfile2), "layout": "anyfile"}})) cache = TestClient(cache_folder=tmp_folder).cache migrate_editables_use_conanfile_name(cache) # Now we have same info and full paths with open(os.path.join(tmp_folder, EDITABLE_PACKAGES_FILE)) as f: data = json.load(f) self.assertEqual(data["name/version"]["path"], conanfile1) self.assertEqual(data["name/version"]["layout"], None) self.assertEqual(data["other/version@user/testing"]["path"], conanfile2) self.assertEqual(data["other/version@user/testing"]["layout"], "anyfile")
def test_deleted_source_folder(self): path, _ = create_local_git_repo({"myfile": "contents"}, branch="my_release") conanfile = base_git.format(url=_quoted("auto"), revision="auto") self.client.save({"conanfile.py": conanfile, "myfile.txt": "My file is copied"}) self.client.init_git_repo() self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/")) self.client.run_command('git push origin master') self.client.run("export . user/channel") # delete old source, but it doesn't matter because the sources are in the cache rmdir(self.client.current_folder) new_curdir = temp_folder() self.client.current_folder = new_curdir self.client.run("install lib/0.1@user/channel --build") self.assertNotIn("Getting sources from url: '%s'" % path.replace("\\", "/"), self.client.out) # If the remove the source folder, then it is fetched from the "remote" doing an install self.client.run("remove lib/0.1@user/channel -f -s") self.client.run("install lib/0.1@user/channel --build") self.assertIn("SCM: Getting sources from url: '%s'" % path.replace("\\", "/"), self.client.out)
def paths_cmake_multi_user_vars_test(self): settings_mock = namedtuple("Settings", "build_type, os, os_build, constraint") conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(settings_mock("Release", None, None, lambda x: x), EnvValues()) ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables") tmp_folder = temp_folder() save(os.path.join(tmp_folder, "lib", "mylib.lib"), "") save(os.path.join(tmp_folder, "include", "myheader.h"), "") cpp_info = CppInfo(tmp_folder) cpp_info.release.libs = ["hello"] cpp_info.debug.libs = ["hello_D"] conanfile.deps_cpp_info.update(cpp_info, ref.name) generator = CMakeMultiGenerator(conanfile) release = generator.content["conanbuildinfo_release.cmake"] release = release.replace(tmp_folder.replace("\\", "/"), "root_folder") cmake_lines = release.splitlines() self.assertIn( 'set(CONAN_INCLUDE_DIRS_MYPKG_RELEASE "root_folder/include")', cmake_lines) self.assertIn('set(CONAN_LIB_DIRS_MYPKG_RELEASE "root_folder/lib")', cmake_lines)
def local_package_build_test(self, default_folder): client = TestClient() conanfile_template = """ from conans import ConanFile class MyConan(ConanFile): def package(self): self.copy(pattern="*.h", dst="include", src="include") self.copy(pattern="*.lib") """ client.save({"include/file.h": "foo", "build/lib/mypkg.lib": "mylib", CONANFILE: conanfile_template}) recipe_folder = client.current_folder client.current_folder = os.path.join(client.current_folder, "build") client.run("install ..") if default_folder: package_folder = os.path.join(client.current_folder, "package") client.run('package .. --build-folder=.') self.assertEqual(sorted(os.listdir(package_folder)), sorted(["include", "lib", "conaninfo.txt", "conanmanifest.txt"])) else: package_folder = temp_folder() client.current_folder = package_folder build_folder = os.path.join(recipe_folder, "build") client.run('package "{0}" --build_folder="{2}"' ' --package_folder="{1}"'.format(recipe_folder, package_folder, build_folder)) self.assertEqual(sorted(os.listdir(package_folder)), sorted(["include", "lib", "conaninfo.txt", "conanmanifest.txt"])) content = load(os.path.join(package_folder, "include/file.h")) self.assertEqual(content, "foo") self.assertEqual(os.listdir(os.path.join(package_folder, "include")), ["file.h"]) self.assertEqual(os.listdir(os.path.join(package_folder, "lib")), ["mypkg.lib"])
def validate_additional_dependencies(libname, additional_dep): tempdir = temp_folder() with chdir(tempdir): conanfile = ConanFile(TestBufferConanOutput(), None) conanfile.initialize(Settings({}), EnvValues()) ref = ConanFileReference.loads("MyPkg/0.1@user/testing") cpp_info = CppInfo(ref.name, "dummy_root_folder1") cpp_info.libs = [libname] conanfile.deps_cpp_info.add(ref.name, cpp_info) settings = Settings.loads(get_default_settings_yml()) settings.os = "Windows" settings.arch = "x86_64" settings.build_type = "Release" settings.compiler = "Visual Studio" settings.compiler.version = "15" settings.compiler.runtime = "MD" settings.compiler.toolset = "v141" conanfile.settings = settings generator = VisualStudioMultiGenerator(conanfile) generator.output_path = "" content = generator.content self.assertIn('conanbuildinfo_release_x64_v141.props', content.keys()) content_release = content[ 'conanbuildinfo_release_x64_v141.props'] self.assertIn( "<ConanLibraries>%s;</ConanLibraries>" % additional_dep, content_release) self.assertIn( "<AdditionalDependencies>" "$(ConanLibraries)%(AdditionalDependencies)" "</AdditionalDependencies>", content_release)
def test_bazeldeps_get_lib_file_path_by_basename(): conanfile = ConanFile(Mock(), None) cpp_info = CppInfo("mypkg", "dummy_root_folder1") cpp_info.defines = ["DUMMY_DEFINE=\"string/value\""] cpp_info.system_libs = ["system_lib1"] cpp_info.libs = ["liblib1.a"] conanfile_dep = ConanFile(Mock(), None) conanfile_dep.cpp_info = cpp_info conanfile_dep._conan_node = Mock() conanfile_dep._conan_node.ref = ConanFileReference.loads( "OriginalDepName/1.0") package_folder = temp_folder() save(os.path.join(package_folder, "lib", "liblib1.a"), "") conanfile_dep.folders.set_base_package(package_folder) # FIXME: This will run infinite loop if conanfile.dependencies.host.topological_sort. # Move to integration test with mock.patch('conans.ConanFile.dependencies', new_callable=mock.PropertyMock) as mock_deps: req = Requirement(ConanFileReference.loads("OriginalDepName/1.0")) mock_deps.return_value = ConanFileDependencies( {req: ConanFileInterface(conanfile_dep)}) bazeldeps = BazelDeps(conanfile) for dependency in bazeldeps._conanfile.dependencies.host.values(): dependency_content = bazeldeps._get_dependency_buildfile_content( dependency) assert 'cc_library(\n name = "OriginalDepName",' in dependency_content assert """defines = ["DUMMY_DEFINE=\\\\\\"string/value\\\\\\""]""" in dependency_content if platform.system() == "Windows": assert 'linkopts = ["/DEFAULTLIB:system_lib1"]' in dependency_content else: assert 'linkopts = ["-lsystem_lib1"],' in dependency_content assert 'deps = [\n \n ":liblib1.a_precompiled",' in dependency_content
def test_msbuild_and_intel_cc_props(mode, expected_toolset): test_folder = temp_folder() settings = Settings({ "build_type": ["Release"], "compiler": { "intel-cc": { "version": ["2021.3"], "mode": [mode] }, "msvc": { "version": ["193"], "cppstd": ["20"] } }, "os": ["Windows"], "arch": ["x86_64"] }) conanfile = ConanFile(Mock(), None) conanfile.folders.set_base_generators(test_folder) conanfile.folders.set_base_install(test_folder) conanfile.conf = Conf() conanfile.conf["tools.intel:installation_path"] = "my/intel/oneapi/path" conanfile.conf["tools.microsoft.msbuild:installation_path"] = "." conanfile.settings = "os", "compiler", "build_type", "arch" conanfile.initialize(settings, EnvValues()) conanfile.settings.build_type = "Release" conanfile.settings.compiler = "intel-cc" conanfile.settings.compiler.version = "2021.3" conanfile.settings.compiler.mode = mode conanfile.settings.os = "Windows" conanfile.settings.arch = "x86_64" msbuild = MSBuildToolchain(conanfile) props_file = os.path.join(test_folder, 'conantoolchain_release_x64.props') msbuild.generate() assert '<PlatformToolset>%s</PlatformToolset>' % expected_toolset in load( props_file)
def test_pc(self): tmp_dir = temp_folder() filename = os.path.join(tmp_dir, 'libastral.pc') with open(filename, 'w') as f: f.write(libastral_pc) with environment_append({'PKG_CONFIG_PATH': tmp_dir}): pkg_config = PkgConfig("libastral") self.assertEqual( frozenset(pkg_config.cflags), frozenset( ['-D_USE_LIBASTRAL', '-I/usr/local/include/libastral'])) self.assertEqual(frozenset(pkg_config.cflags_only_I), frozenset(['-I/usr/local/include/libastral'])) self.assertEqual(frozenset(pkg_config.cflags_only_other), frozenset(['-D_USE_LIBASTRAL'])) self.assertEqual( frozenset(pkg_config.libs), frozenset([ '-L/usr/local/lib/libastral', '-lastral', '-Wl,--whole-archive' ])) self.assertEqual(frozenset(pkg_config.libs_only_L), frozenset(['-L/usr/local/lib/libastral'])) self.assertEqual(frozenset(pkg_config.libs_only_l), frozenset([ '-lastral', ])) self.assertEqual(frozenset(pkg_config.libs_only_other), frozenset(['-Wl,--whole-archive'])) self.assertEqual(pkg_config.variables['prefix'], '/usr/local') self.assertEqual(frozenset(pkg_config.version), frozenset(['6.6.6'])) os.unlink(filename)
def create_local_svn_checkout(files, repo_url, rel_project_path=None, commit_msg='default commit message', delete_checkout=True, folder=None): tmp_dir = folder or temp_folder() try: rel_project_path = rel_project_path or str(uuid.uuid4()) # Do not use SVN class as it is what we will be testing subprocess.check_output('svn co "{url}" "{path}"'.format(url=repo_url, path=tmp_dir), shell=True) tmp_project_dir = os.path.join(tmp_dir, rel_project_path) mkdir(tmp_project_dir) save_files(tmp_project_dir, files) with chdir(tmp_project_dir): subprocess.check_output("svn add .", shell=True) subprocess.check_output('svn commit -m "{}"'.format(commit_msg), shell=True) if SVN.get_version() >= SVN.API_CHANGE_VERSION: rev = subprocess.check_output("svn info --show-item revision", shell=True).decode().strip() else: import xml.etree.ElementTree as ET output = subprocess.check_output("svn info --xml", shell=True).decode().strip() root = ET.fromstring(output) rev = root.findall("./entry")[0].get("revision") project_url = repo_url + "/" + quote( rel_project_path.replace("\\", "/")) return project_url, rev finally: if delete_checkout: shutil.rmtree(tmp_dir, ignore_errors=False, onerror=try_remove_readonly)
def test_basic(self): """ check that we do not generate anymore tgz with .c_src. also, they are not present any more in the cache layout, even if they come from a .c_src tgz server file """ test_server = TestServer() servers = {"default": test_server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({ "conanfile.py": """from conans import ConanFile class MyPkg(ConanFile): name= "Pkg" version = "0.1" exports_sources = "*.txt" """, "myfile.txt": "Hello world" }) client.run("export lasote/testing") client.run("upload Pkg/0.1@lasote/testing") client.run("remove * -f") client.run("search") self.assertIn("There are no packages", client.user_io.out) conan_reference = ConanFileReference.loads("Pkg/0.1@lasote/testing") path = test_server.paths.export(conan_reference) sources_tgz = os.path.join(path, "conan_sources.tgz") self.assertTrue(os.path.exists(sources_tgz)) folder = temp_folder() with open(sources_tgz, 'rb') as file_handler: tar_extract(file_handler, folder) self.assertEqual(os.listdir(folder), ["myfile.txt"]) # Now install again client.run("install Pkg/0.1@lasote/testing --build=missing") export = client.client_cache.export(conan_reference) self.assertNotIn(EXPORT_SOURCES_DIR_OLD, os.listdir(export)) export_sources = client.client_cache.export_sources(conan_reference) self.assertEqual(os.listdir(export_sources), ["myfile.txt"])
def config_patch_deps_test(self): conan_file = ConanFileMock() conan_file.name = "MyPkg" conan_file.settings = Settings() conan_file.source_folder = os.path.join(self.tempdir, "src") conan_file.build_folder = os.path.join(self.tempdir, "build") conan_file.package_folder = os.path.join(self.tempdir, "pkg") conan_file.deps_cpp_info = DepsCppInfo() ref = ConanFileReference.loads("MyPkg1/0.1@user/channel") cpp_info = CppInfo(self.tempdir2) conan_file.deps_cpp_info.update(cpp_info, ref.name) self.tempdir = temp_folder(path_with_spaces=False) self.assertEqual(list(conan_file.deps_cpp_info.deps), ['MyPkg1']) self.assertEqual(conan_file.deps_cpp_info['MyPkg1'].rootpath, self.tempdir2) msg = "FOLDER: " + self.tempdir2 for folder in (conan_file.build_folder, conan_file.package_folder): save(os.path.join(folder, "file1.cmake"), "Nothing") save(os.path.join(folder, "file2"), msg) save(os.path.join(folder, "file3.txt"), msg) save(os.path.join(folder, "file3.cmake"), msg) save(os.path.join(folder, "sub", "file3.cmake"), msg) cmake = CMake(conan_file, generator="Unix Makefiles") cmake.patch_config_paths() for folder in (conan_file.build_folder, conan_file.package_folder): self.assertEqual("Nothing", load(os.path.join(folder, "file1.cmake"))) self.assertEqual(msg, load(os.path.join(folder, "file2"))) self.assertEqual(msg, load(os.path.join(folder, "file3.txt"))) self.assertEqual("FOLDER: ${CONAN_MYPKG1_ROOT}", load(os.path.join(folder, "file3.cmake"))) self.assertEqual("FOLDER: ${CONAN_MYPKG1_ROOT}", load(os.path.join(folder, "sub", "file3.cmake")))
def setUp(self): self.server_folder = temp_folder() test_server = TestServer([("*/*@*/*", "*")], # read permissions [], # write permissions users={"fenix": "mypass"}, base_path=self.server_folder) # exported users and passwords self.server = test_server servers = {"default": test_server} client = TestClient(servers=servers, users={"default":[("fenix", "mypass")]}) # Conans with and without packages created self.root_folder = {"H1": 'Hello/1.4.10/fenix/testing', "H2": 'Hello/2.4.11/fenix/testing', "B": 'Bye/0.14/fenix/testing', "O": 'Other/1.2/fenix/testing'} files = {} for key, folder in self.root_folder.items(): files["%s/%s/conanfile.py" % (folder, EXPORT_FOLDER)] = "" files["%s/%s/conanmanifest.txt" % (folder, EXPORT_FOLDER)] = "" files["%s/%s/conans.txt" % (folder, SRC_FOLDER)] = "" for pack_id in (1, 2): pack_id = "%s_%s" % (pack_id, key) files["%s/%s/%s/conans.txt" % (folder, BUILD_FOLDER, pack_id)] = "" files["%s/%s/%s/conans.txt" % (folder, PACKAGES_FOLDER, pack_id)] = "" client.save(files, client.paths.store) self.client = client for folder in self.root_folder.values(): client.run("upload %s --all" % folder.replace("/fenix", "@fenix")) self.assert_folders({"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]}, {"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]}, {"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]}, {"H1": True, "H2": True, "B": True, "O": True})
def _create_and_load(myfunc, value, subdir_name, add_subdir_init): subdir_content = textwrap.dedent(""" def get_value(): return {value} def {myfunc}(): return "{myfunc}" """) side_content = textwrap.dedent(""" def get_side_value(): return {value} def side_{myfunc}(): return "{myfunc}" """) conanfile = textwrap.dedent(""" import pickle from {subdir}.api import get_value, {myfunc} from file import get_side_value, side_{myfunc} from fractions import Fraction def conanfile_func(): return get_value(), {myfunc}(), get_side_value(), side_{myfunc}(), str(Fraction(1,1)) """) expected_return = (value, myfunc, value, myfunc, "1") tmp = temp_folder() with chdir(tmp): save("conanfile.py", conanfile.format(value=value, myfunc=myfunc, subdir=subdir_name)) save("file.py", side_content.format(value=value, myfunc=myfunc)) save("{}/api.py".format(subdir_name), subdir_content.format(value=value, myfunc=myfunc)) if add_subdir_init: save("__init__.py", "") save("{}/__init__.py".format(subdir_name), "") loaded, module_id = _parse_conanfile(os.path.join(tmp, "conanfile.py")) return loaded, module_id, expected_return
def insert_test(self): tmp_folder = temp_folder() f = os.path.join(tmp_folder, "remotes.json") save( f, """ { "remotes": [ { "url": "https://server.conan.io", "verify_ssl": true, "name": "conan.io" } ] } """) output = TestBufferConanOutput() cache = ClientCache(tmp_folder, output) registry = RemoteRegistry(cache, output) registry.add("repo1", "url1", True, insert=0) self.assertEqual(list(registry.load_remotes().values()), [ Remote("repo1", "url1", True, False), Remote("conan.io", "https://server.conan.io", True, False) ]) registry.add("repo2", "url2", True, insert=1) self.assertEqual(list(registry.load_remotes().values()), [ Remote("repo1", "url1", True, False), Remote("repo2", "url2", True, False), Remote("conan.io", "https://server.conan.io", True, False) ]) registry.add("repo3", "url3", True, insert=5) self.assertEqual(list(registry.load_remotes().values()), [ Remote("repo1", "url1", True, False), Remote("repo2", "url2", True, False), Remote("conan.io", "https://server.conan.io", True, False), Remote("repo3", "url3", True, False) ])
def test_remote_none(self): """ RemoteRegistry should be able to deal when the URL is None """ f = os.path.join(temp_folder(), "add_none_test") Remotes().save(f) cache = ClientCache(os.path.dirname(f), TestBufferConanOutput()) registry = cache.registry registry.add("foobar", None) self.assertEqual( list(registry.load_remotes().values()), [("conan-center", "https://conan.bintray.com", True, False), ("foobar", None, True, False)]) self.assertIn( "WARN: The URL is empty. It must contain scheme and hostname.", cache._output) registry.remove("foobar") registry.update("conan-center", None) self.assertEqual(list(registry.load_remotes().values()), [("conan-center", None, True, False)]) self.assertIn( "WARN: The URL is empty. It must contain scheme and hostname.", cache._output)
def test_concurrent_locks(self): folder = temp_folder() def download(index): if index % 2: content = self.cached_downloader.download("slow_testurl") content = content.decode("utf-8") else: file_path = os.path.join(folder, "myfile%s.txt" % index) self.cached_downloader.download("slow_testurl", file_path) content = load(file_path) self.assertEqual(content, "slow_testurl") self.assertEqual(self.file_downloader.calls["slow_testurl"], 1) ps = [] for i in range(8): thread = Thread(target=download, args=(i, )) thread.start() ps.append(thread) for p in ps: p.join() self.assertEqual(self.file_downloader.calls["slow_testurl"], 1)
def test_rpaths_libs(self): if platform.system() == "Windows": return pc_content = """prefix=/my_prefix/path libdir=/my_absoulte_path/fake/mylib/lib libdir3=${prefix}/lib2 includedir=/my_absoulte_path/fake/mylib/include Name: MyLib Description: Conan package: MyLib Version: 0.1 Libs: -L${libdir} -L${libdir3} -Wl,-rpath="${libdir}" -Wl,-rpath="${libdir3}" Cflags: -I${includedir}""" tmp_dir = temp_folder() filename = os.path.join(tmp_dir, 'MyLib.pc') with open(filename, 'w') as f: f.write(pc_content) with environment_append({'PKG_CONFIG_PATH': tmp_dir}): expected = ("-L/my_absoulte_path/fake/mylib/lib " "-L/my_prefix/path/lib2 " "-Wl,-rpath=/my_absoulte_path/fake/mylib/lib " "-Wl,-rpath=/my_prefix/path/lib2") pkg_config = PkgConfig("MyLib") self.assertIn(expected, " ".join(lib for lib in pkg_config.libs))
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(base_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 test_profile_load_dump(): # Empty profile tmp = temp_folder() profile = Profile() dumps = profile.dumps() new_profile, _ = get_profile(tmp, dumps) assert new_profile.settings == profile.settings # Settings profile = Profile() profile.settings["arch"] = "x86_64" profile.settings["compiler"] = "Visual Studio" profile.settings["compiler.version"] = "12" profile.env_values.add("CXX", "path/to/my/compiler/g++") profile.env_values.add("CC", "path/to/my/compiler/gcc") profile.build_requires["*"] = ["android_toolchain/1.2.8@lasote/testing"] profile.build_requires["zlib/*"] = ["cmake/1.0.2@lasote/stable", "autotools/1.0.3@lasote/stable"] dump = profile.dumps() new_profile, _ = get_profile(tmp, dump) assert new_profile.settings == profile.settings assert new_profile.settings["arch"] == "x86_64" assert new_profile.settings["compiler.version"] == "12" assert new_profile.settings["compiler"] == "Visual Studio" assert new_profile.env_values.env_dicts("") == ({'CXX': 'path/to/my/compiler/g++', 'CC': 'path/to/my/compiler/gcc'}, {}) assert new_profile.build_requires["zlib/*"] == \ [ConanFileReference.loads("cmake/1.0.2@lasote/stable"), ConanFileReference.loads("autotools/1.0.3@lasote/stable")] assert new_profile.build_requires["*"] == \ [ConanFileReference.loads("android_toolchain/1.2.8@lasote/testing")]
def test_combined(self): base_folder = temp_folder() source_folder = os.path.join(base_folder, "source") conanfile_folder = os.path.join(base_folder, "conan") 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") conanfile = files.pop("conanfile.py") client.save(files, path=source_folder) conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"') client.save({"conanfile.py": conanfile}, path=conanfile_folder) client.run("export lasote/stable --path=../conan") 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': '40c9a26a156aecb0304fded35c1db93b', 'conanfile.py': '41c0a463c6f20084671502154f5b33f4', 'source/executable': '68b329da9893e34099c7d8ad5cb9c940', 'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)