def test_txt(self): base = '''[requires] lib/0.1@user/channel ''' extension = '''[requires] lib/0.1@user/channel otherlib/0.2@user/channel [options] otherlib:otherlib_option = 1 ''' files = {"conanfile.txt": base, "conanfile_dev.txt": extension} client = TestClient(self.base_folder) client.save(files) client.run("install --build") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("lib/0.1@user/channel", conaninfo) self.assertNotIn("otherlib/0.2@user/channel", conaninfo) self.assertNotIn("otherlib:otherlib_option=1", conaninfo) client.run("install --build --file=conanfile_dev.txt") conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt")) self.assertIn("lib/0.1@user/channel", conaninfo) self.assertIn("otherlib/0.2@user/channel", conaninfo) self.assertIn("otherlib:otherlib_option=1", conaninfo)
class InstallUpdateTest(unittest.TestCase): def setUp(self): test_server = TestServer() self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def reuse_test(self): files = cpp_hello_conan_files("Hello0", "1.0", 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 Hello0/1.0@lasote/stable --all") client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) client2.run("install Hello0/1.0@lasote/stable") files["helloHello0.h"] = "//EMPTY!" self.client.save(files, clean_first=True) sleep(1) self.client.run("export lasote/stable") self.client.run("install Hello0/1.0@lasote/stable --build") self.client.run("upload Hello0/1.0@lasote/stable --all") client2.run("install Hello0/1.0@lasote/stable --update") ref = ConanFileReference.loads("Hello0/1.0@lasote/stable") package_ids = client2.paths.conan_packages(ref) package_path = client2.paths.package(PackageReference(ref, package_ids[0])) header = load(os.path.join(package_path, "include/helloHello0.h")) self.assertEqual(header, "//EMPTY!")
def setUp(self): client = TestClient() base = ''' from conans import ConanFile class ConanLib(ConanFile): name = "lib" version = "0.1" ''' files = {"conanfile.py": base} client.save(files) client.run("export user/channel") base = ''' from conans import ConanFile class ConanOtherLib(ConanFile): name = "otherlib" version = "0.2" options = {"otherlib_option": [1, 2, 3]} default_options="otherlib_option=3" ''' files = {"conanfile.py": base} client.save(files) client.run("export user/channel") self.base_folder = client.base_folder
def upload_test(self): test_server = TestServer([], # write permissions users={"lasote": "mypass"}) # exported users and passwords servers = {"default": test_server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) files = {"conanfile.py": base} client.save(files) client.run("export lasote/channel") client.run("install lib/0.1@lasote/channel --build") client.run("upload lib/0.1@lasote/channel --all") client.run("remove lib/0.1@lasote/channel -f") client.run("search") self.assertIn("There are no packages", client.user_io.out) for download in ("", "--all"): client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client2.run("install lib/0.1@lasote/channel %s" % download) reference = ConanFileReference.loads("lib/0.1@lasote/channel") export_folder = client2.client_cache.export(reference) export_files = os.listdir(export_folder) self.assertNotIn('conan_export.tgz', export_files) package_ref = PackageReference.loads("lib/0.1@lasote/channel:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") package_folder = client2.client_cache.package(package_ref, short_paths=None) if platform.system() == "Windows": original_folder = client2.client_cache.package(package_ref) link = load(os.path.join(original_folder, ".conan_link")) self.assertEqual(link, package_folder) files = os.listdir(package_folder) self.assertIn("myfile.txt", files) self.assertIn("myfile2.txt", files) self.assertNotIn("conan_package.tgz", files)
def test_export_the_same_code(self): file_list = self._create_packages_and_builds() # Export the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") conan2.save(files2) conan2.run("export lasote/stable") reg_path2 = conan2.paths.export(self.conan_ref) digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertNotIn('A new Conan version was exported', conan2.user_io.out) self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out) self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out) self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out) self.assertIn('conanfile.py exported as %s in %s' % (self.conan_ref, reg_path2), conan2.user_io.out) self.assertTrue(os.path.exists(reg_path2)) for name in files2.keys(): self.assertTrue(os.path.exists(os.path.join(reg_path2, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08', 'conanfile.py': '4df4b5266ad6d5d55cbdd0a8b12c9d1a', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest2.file_sums) for f in file_list: self.assertTrue(os.path.exists(f))
def test_export_a_new_version(self): self._create_packages_and_builds() # Export an update of the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE] conan2.save(files2) conan2.run("export lasote/stable") reg_path3 = conan2.paths.export(self.conan_ref) digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertIn('A new conanfile.py version was exported', conan2.user_io.out) # self.assertIn('All the previous packs were cleaned', conan2.user_io.out) self.assertIn('conanfile.py exported as %s in %s' % (self.conan_ref, reg_path3), conan2.user_io.out) self.assertTrue(os.path.exists(reg_path3)) for name in files2.keys(): self.assertTrue(os.path.exists(os.path.join(reg_path3, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08', 'conanfile.py': '5a2c6e2d6b39638b7d8560786d7935a3', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest3.file_sums)
def copy_test(self): client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") client.run("install Hello0/0.1@lasote/stable --build=missing") error = client.run("copy hello0/0.1@lasote/stable otheruser/testing", ignore_error=True) self._check(error, client)
def complete_build_flow_test(self): """In local user folder""" client = TestClient() command = os.sep.join([".", "bin", "say_hello"]) for install, lang, static in [("install", 0, True), ("install -o language=1", 1, True), ("install -o language=1 -o static=False", 1, False), ("install -o static=False", 0, False)]: dll_export = client.default_compiler_visual_studio and not static files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export) client.save(files) client.run(install) time.sleep(1) # necessary so the conaninfo.txt is flushed to disc client.run('build') client.runner(command, client.current_folder) msg = "Hello" if lang == 0 else "Hola" self.assertIn("%s Hello0" % msg, client.user_io.out) conan_info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.loads(load(conan_info_path)) self.assertTrue(conan_info.full_options.language == lang) if static: self.assertTrue(conan_info.full_options.static) else: self.assertFalse(conan_info.full_options.static)
def basic_source_test(self): conanfile = """ from conans import ConanFile class ConanLib(ConanFile): name = "Hello" version = "0.1" def source(self): self.output.info("Running source!") """ client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") client.run("source Hello/0.1@lasote/stable") self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # The second call shouldn't have effect client.run("source Hello/0.1@lasote/stable") self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertNotIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # Forced should have effect client.run("source Hello/0.1@lasote/stable --force") self.assertIn("WARN: Forced removal of source folder", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
class InstallUpdateTest(unittest.TestCase): def setUp(self): test_server = TestServer([("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def reuse_test(self): files = cpp_hello_conan_files("Hello0", "1.0") # To avoid building files[CONANFILE] = files[CONANFILE].replace("build(", "build2(") self.client.save(files) self.client.run("export lasote/stable") self.client.run("install Hello0/1.0@lasote/stable --build") self.client.run("upload Hello0/1.0@lasote/stable --all") client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) client2.run("install Hello0/1.0@lasote/stable") files["helloHello0.h"] = "//EMPTY!" self.client.save(files, clean_first=True) sleep(1) self.client.run("export lasote/stable") self.client.run("install Hello0/1.0@lasote/stable --build") self.client.run("upload Hello0/1.0@lasote/stable --all") client2.run("install Hello0/1.0@lasote/stable --update") ref = ConanFileReference.loads("Hello0/1.0@lasote/stable") package_ids = client2.paths.conan_packages(ref) package_path = client2.paths.package(PackageReference(ref, package_ids[0])) header = load(os.path.join(package_path, "include/helloHello0.h")) self.assertEqual(header, "//EMPTY!")
def test_export_the_same_code(self): file_list = self._create_packages_and_builds() # Export the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") conan2.save(files2) conan2.run("export lasote/stable") reg_path2 = conan2.paths.export(self.conan_ref) digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertNotIn('A new Conan version was exported', conan2.user_io.out) self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out) self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out) self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out) self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path2)) for name in files2.keys(): self.assertTrue(os.path.exists(os.path.join(reg_path2, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': 'f21a98d974e9294b0d709070042c6e78', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest2.file_sums) for f in file_list: self.assertTrue(os.path.exists(f))
def fail_test_package_test(self): client = TestClient() conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" exports = "*" def package(self): self.copy("*") """ test_conanfile = """ from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): requires = "Hello/0.1@lasote/stable" def test(self): self.conanfile_directory """ client.save({"conanfile.py": conanfile, "FindXXX.cmake": "Hello FindCmake", "test/conanfile.py": test_conanfile}) client.run("test_package") ref = PackageReference.loads("Hello/0.1@lasote/stable:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") self.assertEqual("Hello FindCmake", load(os.path.join(client.paths.package(ref), "FindXXX.cmake"))) client.save({"FindXXX.cmake": "Bye FindCmake"}) client.run("test_package") self.assertEqual("Bye FindCmake", load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
def scopes_test_package_test(self): client = TestClient() conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" def build(self): self.output.info("Scope: %s" % self.scope) """ test_conanfile = """ from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): requires = "Hello/0.1@lasote/stable" def test(self): self.conanfile_directory """ client.save({"conanfile.py": conanfile, "test/conanfile.py": test_conanfile}) client.run("test_package --scope Hello:dev=True --build=missing") self.assertIn("Hello/0.1@lasote/stable: Scope: dev=True", client.user_io.out)
def test_export_a_new_version(self): self._create_packages_and_builds() # Export an update of the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE] conan2.save(files2) conan2.run("export lasote/stable") reg_path3 = conan2.paths.export(self.conan_ref) digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertIn('A new conanfile.py version was exported', conan2.user_io.out) self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path3)) for name in files2.keys(): self.assertTrue(os.path.exists(os.path.join(reg_path3, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': 'c5889ea6485599c7a0cae02b54270b35', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest3.file_sums)
def change_option_txt_test(self): self._create("Hello0", "0.1") client = TestClient(base_folder=self.client.base_folder) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=1 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=1", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b", conan_info.full_requires.dumps()) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=0 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26", conan_info.full_requires.dumps())
def check_multi_server_test(self): # Check what happen if we have 2 servers and one is outdated # The expected behavior: If we specify the remote with (-r), the commmand will fail # if the client fot that remote is outdated. If we are just looking for a package (not with -r) # the client will look for the package on each remote. # Client deprecated for "the_last_server" but OK for "normal_server" self.servers = OrderedDict({"the_last_server": self._get_server(10, 4), "normal_server": self._get_server(4, 2)}) # First upload a package ok with an ok client tmp_client = TestClient(servers=self.servers, users=[("lasote", "mypass")], client_version=4) files = cpp_hello_conan_files("Hello0", "0.1") tmp_client.save(files) tmp_client.run("export lasote/stable") errors = tmp_client.run("upload Hello0/0.1@lasote/stable -r normal_server --all") errors |= tmp_client.run("upload Hello0/0.1@lasote/stable -r the_last_server --all") self.assertFalse(errors) # Now with a conflictive client...try to look in servers self.client = TestClient(servers=self.servers, users=[("lasote", "mypass")], client_version=2) errors = self.client.run("search something -r the_last_server", ignore_error=True) self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out) self.assertTrue(errors) # Errors errors = self.client.run("install Hello0/0.1@lasote/stable --build missing", ignore_error=True) self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out) self.assertFalse(errors) # No Errors! because it finds the package in the second remote
def _test_with_conanfile(self, test_conanfile): client = TestClient() files = cpp_hello_conan_files("Hello0", "0.1") print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)' files[CONANFILE] = files[CONANFILE].replace("def build(self):", 'def build(self):\n %s' % print_build) # Add build_type setting files[CONANFILE] = files[CONANFILE].replace(', "arch"', ', "arch", "build_type"') cmakelist = """PROJECT(MyHello) cmake_minimum_required(VERSION 2.8) include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() ADD_EXECUTABLE(greet main.cpp) TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS}) """ files["test_package/CMakeLists.txt"] = cmakelist files["test_package/conanfile.py"] = test_conanfile files["test_package/main.cpp"] = files["main.cpp"] client.save(files) client.run("export lasote/stable") error = client.run("test -s build_type=Release") self.assertFalse(error) self.assertNotIn("Project: WARN: conanbuildinfo.txt file not found", client.user_io.out) self.assertNotIn("Project: WARN: conanenv.txt file not found", client.user_io.out) self.assertIn('Hello Hello0', client.user_io.out) error = client.run("test -s Hello0:build_type=Debug -o Hello0:language=1") self.assertFalse(error) self.assertIn('Hola Hello0', client.user_io.out) self.assertIn('BUILD_TYPE=>Debug', client.user_io.out)
def local_flow_test(self): """Use 'conan package' to process locally the package method""" client = TestClient() conanfile_template = """ from conans import ConanFile class MyConan(ConanFile): def package(self): self.copy(pattern="*.h", dst="include", src="include") """ files = {"include/file.h": "foo", CONANFILE: conanfile_template} client.save(files) origin_folder = client.current_folder client.run("install -g env -g txt") client.run("source") client.run("build") client.run("package .", ignore_error=True) self.assertIn("ERROR: Cannot 'conan package' to the build folder", client.user_io.out) package_folder = os.path.join(origin_folder, "package") mkdir(package_folder) client.current_folder = package_folder client.run('package ..') content = load(os.path.join(client.current_folder, "include/file.h")) self.assertEqual(content, "foo")
def build_policies_update_test(self): client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) conanfile = """ from conans import ConanFile class MyPackage(ConanFile): name = "test" version = "1.9" build_policy = 'always' def source(self): self.output.info("Getting sources") def build(self): self.output.info("Building sources") def package(self): self.output.info("Packaging this test package") """ files = {CONANFILE: conanfile} client.save(files, clean_first=True) client.run("export lasote/stable") client.run("install test/1.9@lasote/stable") self.assertIn("Getting sources", client.user_io.out) self.assertIn("Building sources", client.user_io.out) self.assertIn("Packaging this test package", client.user_io.out) self.assertIn("Building package from source as defined by build_policy='always'", client.user_io.out) client.run("upload test/1.9@lasote/stable")
def package_errors_test(self): client = TestClient() client.run("package whatever@user/channel", ignore_error=True) self.assertIn("Wrong package recipe", client.user_io.out) client.run("package whatever/1.0@user/channel", ignore_error=True) self.assertIn("ERROR: Package recipe 'whatever/1.0@user/channel' does not exist", client.user_io.out) conanfile_template = """ from conans import ConanFile class MyConan(ConanFile): name = "MyLib" version = "0.1" """ client.save({CONANFILE: conanfile_template}) client.run("export lasote/stable") client.run("package MyLib/0.1@lasote/stable", ignore_error=True) self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally", client.user_io.out) builds_dir = client.paths.builds(ConanFileReference.loads("MyLib/0.1@lasote/stable")) os.makedirs(builds_dir) client.run("package MyLib/0.1@lasote/stable", ignore_error=True) self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally", client.user_io.out) client.run("package MyLib/0.1@lasote/stable 1234", ignore_error=True) self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package binary '1234' folder doesn't exist", client.user_io.out)
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 upload_reuse_test(self): server = TestServer() servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test}) client.run("export lasote/stable") client.save({CONANFILE: reuse}, clean_first=True) client.run("export lasote/stable") client.run("install Consumer/0.1@lasote/stable --build") lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines() if line.startswith("Consumer/0.1@lasote/stable: Hello")] self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'], lines) client.run("upload conantool/1.0@lasote/stable --all") client.run("remove * -f") client.run("search") self.assertNotIn("lasote/stable", client.user_io.out) client.run("export lasote/stable") client.run("install Consumer/0.1@lasote/stable --build") lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines() if line.startswith("Consumer/0.1@lasote/stable: Hello")] self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'], lines) # Try again, just in case client.run("upload conantool/1.0@lasote/stable --all") client.run("remove * -f -r=default") client.run("upload conantool/1.0@lasote/stable --all")
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': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': 'c0bb94a3da6eb978cb94f5faff037ed3', 'source/executable': '68b329da9893e34099c7d8ad5cb9c940', 'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
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': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': '5632cf850a7161388ab24f42b9bdb3fd', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
def global_test(self): client = TestClient() files = {'conanfile.py': base_conanfile.replace("%GLOBAL%", "self.global_system_requirements=True")} client.save(files) client.run("export user/testing") client.run("install Test/0.1@user/testing --build missing") self.assertIn("*+Running system requirements+*", client.user_io.out) conan_ref = ConanFileReference.loads("Test/0.1@user/testing") package_ref = PackageReference(conan_ref, "a527106fd9f2e3738a55b02087c20c0a63afce9d") self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref))) load_file = load(client.paths.system_reqs(conan_ref)) self.assertIn("Installed my stuff", load_file) # Run again client.run("install Test/0.1@user/testing --build missing") self.assertNotIn("*+Running system requirements+*", client.user_io.out) self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref))) load_file = load(client.paths.system_reqs(conan_ref)) self.assertIn("Installed my stuff", load_file) # Run with different option client.run("install Test/0.1@user/testing -o myopt=False --build missing") self.assertNotIn("*+Running system requirements+*", client.user_io.out) package_ref2 = PackageReference(conan_ref, "54c9626b48cefa3b819e64316b49d3b1e1a78c26") self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref))) self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2))) load_file = load(client.paths.system_reqs(conan_ref)) self.assertIn("Installed my stuff", load_file) # remove packages client.run("remove Test* -f -p") self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref))) self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2))) self.assertFalse(os.path.exists(client.paths.system_reqs(conan_ref)))
def test_no_remotes(self): client = TestClient() files = cpp_hello_conan_files("Hello0", "0.1") client.save(files) client.run("export lasote/stable") client.run("upload Hello0/0.1@lasote/stable", ignore_error=True) self.assertIn("ERROR: No default remote defined", client.user_io.out)
def test_clean(self): test_server = TestServer() servers = {"default": test_server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) base = ''' from conans import ConanFile class ConanLib(ConanFile): name = "lib" version = "0.1" ''' files = {"conanfile.py": base} client.save(files) client.run("export lasote/stable") client.run("upload lib/0.1@lasote/stable") client.run("user") self.assertIn("Current 'default' user: lasote", client.user_io.out) client.run("user --clean") client.run("user") self.assertNotIn("lasote", client.user_io.out) self.assertEqual("Current 'default' user: None (anonymous)\n", client.user_io.out) client.run("upload lib/0.1@lasote/stable") client.run("user") self.assertIn("Current 'default' user: lasote", client.user_io.out)
def large_project_test(self): client = TestClient() num = 250 deep = True # True for N ... -> 3 -> 2 -> 1 -> 0, False for N -> 0, 3-> 0, 2->0, 1->0 for i in range(num): if i == 0: files = cpp_hello_conan_files("Hello0", "0.1", build=False) else: if not deep: files = cpp_hello_conan_files("Hello%d" % i, "0.1", ["Hello0/0.1@lasote/stable"], build=False) else: files = cpp_hello_conan_files("Hello%d" % i, "0.1", ["Hello%s/0.1@lasote/stable" % (i-1)], build=False) client.save(files, clean_first=True) client.run("export lasote/stable") # Now lets depend on it if deep: files = cpp_hello_conan_files("HelloFinal", "0.1", ["Hello%s/0.1@lasote/stable" % (num - 1)], build=False) else: files = cpp_hello_conan_files("HelloFinal", "0.1", ["Hello%s/0.1@lasote/stable" % (i) for i in range(num)], build=False) client.save(files, clean_first=True) t1 = time.time() client.run("install --build") print("Final time with build %s" % (time.time() - t1)) t1 = time.time() client.run("install") print("Final time %s" % (time.time() - t1))
def no_signature_test(self): auth = AuthorizationHeaderSpy() retur = ReturnHandlerPlugin() server = TestServer(plugins=[auth, retur]) server.app servers = {"default": server} client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) client.save({"conanfile.py": conanfile}) client.run("export lasote/stable") errors = client.run("upload Hello/0.1@lasote/stable") self.assertFalse(errors) expected_calls = [('get_conan_digest_url', None), ('check_credentials', None), ('authenticate', 'Basic'), ('get_conanfile_snapshot', 'Bearer'), ('get_conanfile_upload_urls', 'Bearer'), ('put', 'Bearer')] self.assertEqual(len(expected_calls), len(auth.auths)) for i, (method, auth_type) in enumerate(expected_calls): real_call = auth.auths[i] self.assertEqual(method, real_call[0]) if auth_type: self.assertIn(auth_type, real_call[1]) # The Bearer of the last two calls must be identical self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
class ConfigureEnvironmentTest(unittest.TestCase): def setUp(self): self.client = TestClient() def build_with_profile_test(self): self._create_profile("scopes_env", {}, {}, # undefined scope do not apply to my packages {"CXX": "/path/tomy/g++_build", "CC": "/path/tomy/gcc_build"}) self.client.save({CONANFILE: conanfile_dep}) self.client.run("export lasote/testing") self.client.save({CONANFILE: conanfile_scope_env}, clean_first=True) self.client.run("install --build=missing") self.client.run("build -pr scopes_env") self.assertRegexpMatches(str(self.client.user_io.out), "PATH=['\"]?/path/to/my/folder") self._assert_env_variable_printed("CC", "/path/tomy/gcc_build") self._assert_env_variable_printed("CXX", "/path/tomy/g++_build") def _assert_env_variable_printed(self, name, value): if platform.system() == "Windows": self.assertIn("%s=%s" % (name, value), self.client.user_io.out) elif platform.system() == "Darwin": self.assertIn('%s="%s"' % (name, value), self.client.user_io.out) else: self.assertIn("%s='%s'" % (name, value), self.client.user_io.out) def _create_profile(self, name, settings, scopes=None, env=None): profile = Profile() profile.settings = settings or {} if scopes: profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()]) profile.env = env or {} save(self.client.client_cache.profile_path(name), profile.dumps())
class MultiRemoteTest(unittest.TestCase): def setUp(self): self.servers = OrderedDict() self.users = {} for i in range(3): test_server = TestServer( [("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers["remote%d" % i] = test_server self.users["remote%d" % i] = [("lasote", "mypass")] self.client = TestClient(servers=self.servers, users=self.users) def upload_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files["conanfile.py"] = files["conanfile.py"].replace( "def build(", "def build2(") self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) self.client.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", self.client.user_io.out) # The remote, once fixed does not change self.client.run("upload %s -r=remote1" % str(conan_reference)) self.client.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", self.client.user_io.out) # Now install it in other machine from remote 0 client2 = TestClient(servers=self.servers, users=self.users) client2.run("install %s --build=missing" % str(conan_reference)) client2.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", client2.user_io.out) # Now install it in other machine from remote 1 servers = self.servers.copy() servers.pop("remote0") client3 = TestClient(servers=servers, users=self.users) client3.run("install %s --build=missing" % str(conan_reference)) client3.run("info %s" % str(conan_reference)) self.assertIn("remote1=http://", client3.user_io.out) def install_from_remotes_test(self): for i in range(3): conan_reference = ConanFileReference.loads( "Hello%d/0.1@lasote/stable" % i) files = cpp_hello_conan_files("Hello%d" % i, "0.1") files["conanfile.py"] = files["conanfile.py"].replace( "def build(", "def build2(") self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload %s -r=remote%d" % (str(conan_reference), i)) self.client.run("info %s" % str(conan_reference)) self.assertIn("remote%d=http://" % i, self.client.user_io.out) # Now install it in other machine from remote 0 client2 = TestClient(servers=self.servers, users=self.users) conan_reference = ConanFileReference.loads("HelloX/0.1@lasote/stable") files = cpp_hello_conan_files("HelloX", "0.1", deps=[ "Hello0/0.1@lasote/stable", "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable" ]) files["conanfile.py"] = files["conanfile.py"].replace( "def build(", "def build2(") client2.save(files) client2.run("install --build=missing") self.assertIn("Hello0/0.1@lasote/stable from remote0", client2.user_io.out) self.assertIn("Hello1/0.1@lasote/stable from remote1", client2.user_io.out) self.assertIn("Hello2/0.1@lasote/stable from remote2", client2.user_io.out) client2.run("info") self.assertIn("Remote: remote0=http://", client2.user_io.out) self.assertIn("Remote: remote1=http://", client2.user_io.out) self.assertIn("Remote: remote2=http://", client2.user_io.out)
class SearchTest(unittest.TestCase): def setUp(self): self.servers = {"local": TestServer()} self.client = TestClient(servers=self.servers) # No conans created self.client.run("search") output = self.client.user_io.out self.assertIn('There are no packages', output) # Conans with and without packages created self.root_folder1 = 'Hello/1.4.10/fenix/testing' root_folder2 = 'helloTest/1.4.10/fenix/stable' root_folder3 = 'Bye/0.14/fenix/testing' root_folder4 = 'NodeInfo/1.0.2/fenix/stable' root_folder5 = 'MissFile/1.0.2/fenix/stable' root_folder11 = 'Hello/1.4.11/fenix/testing' root_folder12 = 'Hello/1.4.12/fenix/testing' self.client.save({"Empty/1.10/fake/test/reg/fake.txt": "//", "%s/%s/WindowsPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/WindowsPackageSHA/%s" % (root_folder11, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/WindowsPackageSHA/%s" % (root_folder12, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1b, "%s/%s/LinuxPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1c, "%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO): conan_vars2, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO): conan_vars3, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO): conan_vars4, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"): "Hello"}, self.client.paths.store) # Fake some manifests to be able to calculate recipe hash fake_manifest = FileTreeManifest(1212, {}) self.client.save({os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), }, self.client.paths.store) def recipe_search_test(self): self.client.run("search Hello*") self.assertEquals("Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) self.client.run("search Hello* --case-sensitive") self.assertEquals("Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n", self.client.user_io.out) self.client.run("search *fenix* --case-sensitive") self.assertEquals("Existing package recipes:\n\n" "Bye/0.14@fenix/testing\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "MissFile/1.0.2@fenix/stable\n" "NodeInfo/1.0.2@fenix/stable\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) def recipe_pattern_search_test(self): self.client.run("search Hello*") self.assertEquals("Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) self.client.run("search Hello* --case-sensitive") self.assertEquals("Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n", self.client.user_io.out) self.client.run("search *fenix* --case-sensitive") self.assertEquals("Existing package recipes:\n\n" "Bye/0.14@fenix/testing\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "MissFile/1.0.2@fenix/stable\n" "NodeInfo/1.0.2@fenix/stable\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) def package_search_with_invalid_reference_test(self): self.client.run("search Hello -q 'a=1'", ignore_error=True) self.assertIn("-q parameter only allowed with a valid recipe", str(self.client.user_io.out)) def package_search_with_empty_query_test(self): self.client.run("search Hello/1.4.10/fenix/testing") self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) def package_search_nonescaped_characters_test(self): self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"') self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"') self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) # Now search with a remote os.rmdir(self.servers["local"].paths.store) shutil.copytree(self.client.paths.store, self.servers["local"].paths.store) self.client.run("remove Hello* -f") self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local') self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local') self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) def package_search_with_invalid_query_test(self): self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'", ignore_error=True) self.assertIn("Invalid package query: invalid", self.client.user_io.out) def package_search_properties_filter_test(self): # All packages without filter self.client.run("search Hello/1.4.10/fenix/testing -q ''") self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows') self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"') self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"') self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"') self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"') self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"') # One package will be outdated from recipe and another don't self.assertEquals("""Existing packages for recipe Hello/1.4.10@fenix/testing: Package_ID: LinuxPackageSHA [options] use_Qt: False [settings] arch: x86 compiler: gcc compiler.libcxx: libstdc++11 compiler.version: 4.5 os: Linux [requires] Hello2/0.1@lasote/stable:11111 HelloInfo1/0.45@fenix/testing:33333 OpenSSL/2.10@lasote/testing:2222 outdated from recipe: False Package_ID: PlatformIndependantSHA [options] use_Qt: True [settings] arch: x86 compiler: gcc compiler.libcxx: libstdc++ compiler.version: 4.3 outdated from recipe: True """, self.client.user_io.out) self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=False') self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' " "matching the query 'use_OpenGL=False'", self.client.user_io.out) self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=True') self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out) self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"') self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out) self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"') self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' " "matching the query 'use_OpenGL=True AND arch=x86'", self.client.user_io.out) def search_with_no_local_test(self): client = TestClient() client.run("search nonexist/1.0@lasote/stable") self.assertIn("There are no packages", self.client.user_io.out)
def cmake_multi_test(self): if platform.system() == "Windows": generator = "Visual Studio 14 Win64" debug_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MDd' release_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MD' elif platform.system() == "Darwin": generator = "Xcode" debug_install = '' release_install = '' else: return client = TestClient() def prepare_files(files, number): # Change language according to build_type, to check orig = "lang = '-DCONAN_LANGUAGE=%s' % self.options.language" replace = "lang = '-DCONAN_LANGUAGE=%s' % (0 if self.settings.build_type=='Debug' else 1)" conanfile = files["conanfile.py"] # The test files, surprisingly, dont use build_type conanfile = conanfile.replace(orig, replace).replace( '"arch"', '"arch", "build_type"') # Header of the package will contain a different DEFINE, to make sure that it includes # the correct one conanfile = conanfile.replace( "def build(self):\n", """def build(self): with open("helloHello{0}.h", "a") as f: f.write('#define HELLO{0}BUILD "%s"' % self.settings.build_type) """.format(number)) conanfile = conanfile.replace( "def package_info(self):\n", """def package_info(self): self.cpp_info.defines = ['HELLO{}DEFINE="%s"' % self.settings.build_type] """.format(number)) files["conanfile.py"] = conanfile client.save(files, clean_first=True) client.run("export lasote/testing") files = cpp_hello_conan_files("Hello0", "0.1") prepare_files(files, 0) files = cpp_hello_conan_files("Hello1", "0.1", deps=["Hello0/0.1@lasote/testing"]) prepare_files(files, 1) # better in one test instead of two, because install time is amortized for cmake_file in ( cmake, cmake_targets, ): client.save( { "conanfile.txt": conanfile, "CMakeLists.txt": cmake_file, "main.cpp": main }, clean_first=True) client.run('install -s build_type=Debug %s --build=missing' % debug_install) client.run('install -s build_type=Release %s --build=missing' % release_install) output = StringIO() runner = TestRunner(output) runner('cmake . -G "%s"' % generator, cwd=client.current_folder) self.assertNotIn("WARN: Unknown compiler '", output.getvalue()) self.assertNotIn("', skipping the version check...", output.getvalue()) runner('cmake --build . --config Debug', cwd=client.current_folder) hello_comand = os.sep.join([".", "Debug", "say_hello"]) runner(hello_comand, cwd=client.current_folder) outstr = output.getvalue() self.assertIn("Hello0:Debug Hello1:Debug", outstr) self.assertIn("Hello Hello1", outstr) self.assertIn("Hello Hello0", outstr) runner('cmake --build . --config Release', cwd=client.current_folder) hello_comand = os.sep.join([".", "Release", "say_hello"]) runner(hello_comand, cwd=client.current_folder) outstr = output.getvalue() self.assertIn("Hello0:Release Hello1:Release", outstr) self.assertIn("Hola Hello1", outstr) self.assertIn("Hola Hello0", outstr) if cmake_file == cmake_targets: self.assertIn("Conan: Using cmake targets configuration", outstr) else: self.assertIn("Conan: Using cmake global configuration", outstr)
def complete_test(self): """ basic installation of a new conans """ servers = {} # All can write (for avoid authentication until we mock user_io) test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")]) servers["default"] = test_server conan_digest = FileTreeManifest(123123123, {}) client = TestClient(servers=servers) client.init_dynamic_vars() conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable") reg_folder = client.paths.export(conan_ref) files = hello_source_files() client.save(files, path=reg_folder) client.save( { CONANFILE: myconan1, CONAN_MANIFEST: str(conan_digest), "include/math/lib1.h": "//copy", "my_lib/debug/libd.a": "//copy", "my_data/readme.txt": "//copy" }, path=reg_folder) package_ref = PackageReference(conan_ref, "fakeid") package_folder = client.paths.package(package_ref) save(os.path.join(package_folder, CONANINFO), "info") save(os.path.join(package_folder, CONAN_MANIFEST), "manifest") save(os.path.join(package_folder, "include", "lib1.h"), "//header") save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib") save(os.path.join(package_folder, "res", "shares", "readme.txt"), "//res") digest_path = client.client_cache.digestfile_package(package_ref) expected_manifest = FileTreeManifest.create( os.path.dirname(digest_path)) save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest)) client.run("upload %s" % str(conan_ref)) client.run("upload %s -p %s" % (str(conan_ref), package_ref.package_id)) client2 = TestClient(servers=servers) client2.init_dynamic_vars() installer = ConanProxy(client2.paths, client2.user_io, client2.remote_manager, "default") installer.get_recipe(conan_ref) installer.get_package(package_ref, force_build=False, short_paths=False) # Check that the output is done in order lines = [ line.strip() for line in str(client2.user_io.out).splitlines() if line.startswith("Downloading") ] self.assertEqual(lines, [ "Downloading conanmanifest.txt", "Downloading conanfile.py", "Downloading conan_export.tgz", "Downloading conanmanifest.txt", "Downloading conaninfo.txt", "Downloading conan_package.tgz" ]) reg_path = client2.paths.export( ConanFileReference.loads("Hello/1.2.1/frodo/stable")) pack_folder = client2.paths.package(package_ref) # Test the file in the downloaded conans files = [ 'CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt' ] for _file in files: self.assertTrue(os.path.exists(os.path.join(reg_path, _file))) self.assertTrue(os.path.exists(pack_folder)) # Test the file in the downloaded package self.assertTrue(os.path.exists(pack_folder)) self.assertTrue( os.path.exists(os.path.join(pack_folder, "include", "lib1.h"))) self.assertTrue( os.path.exists(os.path.join(pack_folder, "lib", "my_lib/libd.a"))) self.assertTrue( os.path.exists( os.path.join(pack_folder, "res", "shares/readme.txt")))
class UploadTest(unittest.TestCase): def setUp(self): servers = {} # All can write (for avoid authentication until we mock user_io) self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"}) servers["default"] = self.test_server conan_digest = FileTreeManifest('123123123', {}) self.client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]}) self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable") reg_folder = self.client.paths.export(self.conan_ref) self.client.run('upload %s' % str(self.conan_ref), ignore_error=True) self.assertIn("There is no local conanfile exported as %s" % str(self.conan_ref), self.client.user_io.out) files = hello_source_files() self.client.save(files, path=reg_folder) self.client.save({CONANFILE: myconan1, CONAN_MANIFEST: str(conan_digest), "include/math/lib1.h": "//copy", "my_lib/debug/libd.a": "//copy", "my_data/readme.txt": "//copy", "my_bin/executable": "//copy"}, path=reg_folder) self.package_ref = PackageReference(self.conan_ref, "myfakeid") self.server_pack_folder = self.test_server.paths.package(self.package_ref) package_folder = self.client.paths.package(self.package_ref) save(os.path.join(package_folder, "include", "lib1.h"), "//header") save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib") save(os.path.join(package_folder, "res", "shares", "readme.txt"), "//res") save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin") save(os.path.join(package_folder, CONANINFO), "info") save(os.path.join(package_folder, CONAN_MANIFEST), "manifest") os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"), os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode | stat.S_IRWXU) digest_path = self.client.client_cache.digestfile_package(self.package_ref) expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path)) save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest)) self.server_reg_folder = self.test_server.paths.export(self.conan_ref) self.assertFalse(os.path.exists(self.server_reg_folder)) self.assertFalse(os.path.exists(self.server_pack_folder)) def try_upload_bad_recipe_test(self): files = hello_conan_files("Hello0", "1.2.1") self.client.save(files) self.client.run("export frodo/stable") ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable") os.unlink(os.path.join(self.client.client_cache.export(ref), CONAN_MANIFEST)) with self.assertRaisesRegexp(Exception, "Command failed"): self.client.run("upload %s" % str(ref)) self.assertIn("Cannot upload corrupted recipe", self.client.user_io.out) def upload_same_package_dont_compress_test(self): # Create a manifest for the faked package pack_path = self.client.paths.package(self.package_ref) digest_path = self.client.client_cache.digestfile_package(self.package_ref) expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path)) save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest)) self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False) self.assertIn("Compressing exported files", self.client.user_io.out) self.assertIn("Compressing package", str(self.client.user_io.out)) self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False) self.assertNotIn("Compressing exported files", self.client.user_io.out) self.assertNotIn("Compressing package", str(self.client.user_io.out)) self.assertIn("Package is up to date", str(self.client.user_io.out)) def upload_with_no_valid_settings_test(self): '''Check if upload is still working even if the specified setting is not valid. If this test fails, will fail in Linux/OSx''' conanfile = """ from conans import ConanFile class TestConan(ConanFile): name = "Hello" version = "1.2" settings = {"os": ["Windows"]} """ files = {CONANFILE: conanfile} self.client.save(files) self.client.run("export lasote/stable") self.assertIn("WARN: Conanfile doesn't have a 'license'", self.client.user_io.out) self.client.run("upload Hello/1.2@lasote/stable", ignore_error=False) self.assertIn("Uploading conan_export.tgz", self.client.user_io.out) def simple_test(self): """ basic installation of a new conans """ # Try to upload an package without upload conans first self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)), ignore_error=True) self.assertIn("There are no remote conanfiles like %s" % str(self.conan_ref), self.client.user_io.out) # Upload conans self.client.run('upload %s' % str(self.conan_ref)) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertFalse(os.path.exists(self.server_pack_folder)) # Upload package self.client.run('upload %s -p %s' % (str(self.conan_ref), str(self.package_ref.package_id))) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Test the file in the downloaded conans files = ['CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt', 'my_bin/executable'] self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, CONANFILE))) self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME), tmp) for f in files: if f not in (CONANFILE, CONAN_MANIFEST): self.assertTrue(os.path.exists(os.path.join(tmp, f))) else: self.assertFalse(os.path.exists(os.path.join(tmp, f))) folder = uncompress_packaged_files(self.test_server.paths, self.package_ref) self.assertTrue(os.path.exists(os.path.join(folder, "include", "lib1.h"))) self.assertTrue(os.path.exists(os.path.join(folder, "lib", "my_lib/libd.a"))) self.assertTrue(os.path.exists(os.path.join(folder, "res", "shares/readme.txt"))) if platform.system() != "Windows": self.assertEqual(os.stat(os.path.join(folder, "bin", "my_bin/executable")).st_mode & stat.S_IRWXU, stat.S_IRWXU) def upload_all_test(self): '''Upload conans and package together''' # Try to upload all conans and packages self.client.run('upload %s --all' % str(self.conan_ref)) lines = [line.strip() for line in str(self.client.user_io.out).splitlines() if line.startswith("Uploading")] self.assertEqual(lines, ["Uploading Hello/1.2.1@frodo/stable", "Uploading conanmanifest.txt", "Uploading conanfile.py", "Uploading conan_export.tgz", "Uploading package 1/1: myfakeid", "Uploading conanmanifest.txt", "Uploading conaninfo.txt", "Uploading conan_package.tgz", ]) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) def force_test(self): '''Tries to upload a conans exported after than remote version.''' # Upload all conans and packages self.client.run('upload %s --all' % str(self.conan_ref)) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Fake datetime from exported date and upload again digest_path = os.path.join(self.client.paths.export(self.conan_ref), CONAN_MANIFEST) old_digest = self.client.paths.load_manifest(self.conan_ref) fake_digest = FileTreeManifest(2, old_digest.file_sums) save(digest_path, str(fake_digest)) self.client.run('upload %s' % str(self.conan_ref), ignore_error=True) self.assertIn("Remote conans is newer than local conans", self.client.user_io.out) self.client.run('upload %s --force' % str(self.conan_ref)) self.assertIn("Uploading %s" % str(self.conan_ref), self.client.user_io.out)
def reuse_test(self): conan_reference = ConanFileReference.loads( "stringutil/0.1@lasote/stable") files = { 'conanfile.py': stringutil_conanfile, 'reverse.go': reverse, 'reverse_test.go': reverse_test, 'reverse.txt': reverse, 'hello/helloreverse.txt': reverse } self.client.save(files) self.client.run("export lasote/stable") self.client.run("install %s --build missing" % str(conan_reference)) # Check compilation ok package_ids = self.client.paths.conan_packages(conan_reference) self.assertEquals(len(package_ids), 1) package_ref = PackageReference(conan_reference, package_ids[0]) self._assert_package_exists(package_ref, self.client.paths, list(files.keys())) # Upload conans self.client.run("upload %s" % str(conan_reference)) # Check that conans exists on server server_paths = self.servers["default"].paths conan_path = server_paths.export(conan_reference) self.assertTrue(os.path.exists(conan_path)) # Upload package self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check library on server self._assert_package_exists_in_server(package_ref, server_paths, list(files.keys())) # Now from other "computer" install the uploaded conans with same options (nothing) other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build missing" % str(conan_reference)) # Build should be empty build_path = other_conan.paths.build(package_ref) self.assertFalse(os.path.exists(build_path)) # Lib should exist self._assert_package_exists(package_ref, other_conan.paths, list(files.keys())) reuse_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files = {'conanfile.py': reuse_conanfile, 'src/hello/main.go': main} reuse_conan.save(files) reuse_conan.run("install --build missing") with CustomEnvPath(paths_to_add=['$GOPATH/bin'], var_to_add=[ ('GOPATH', reuse_conan.current_folder), ]): if platform.system() == "Windows": command = "hello" else: command = './hello' reuse_conan.runner('go install hello', cwd=reuse_conan.current_folder) reuse_conan.runner(command, cwd=os.path.join(reuse_conan.current_folder, 'bin')) self.assertIn("Hello, Go!", reuse_conan.user_io.out)
def reuse_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello00", "0.2", msg="#") self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@lasote/stable", "private")], static=False) self._export_upload("Hello2", "0.1", deps=[("Hello00/0.2@lasote/stable", "private")], static=False) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) # WE need to copy the DLLs and dylib client.save(files3) client.run('install --build missing') client.run('build') # assert Hello3 only depends on Hello2, and Hello1 info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE) build_info_cmake = load(info_path) # Ensure it does not depend on Hello0 to build, as private in dlls self.assertNotIn("Hello0", repr(build_info_cmake)) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello #' ], str(client.user_io.out).splitlines()[-5:]) # assert Hello3 only depends on Hello2, and Hello1 info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.loads(load(info_path)) self.assertEqual("language=0\nstatic=True", conan_info.options.dumps()) # Try to upload and reuse the binaries client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files2 = cpp_hello_conan_files( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) # WE need to copy the DLLs client2.save(files2) client2.run("install . --build missing") self.assertNotIn("Package installed in Hello0/0.1", client2.user_io.out) self.assertNotIn("Building", client2.user_io.out) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello #' ], str(client2.user_io.out).splitlines()[-5:]) files3 = cpp_hello_conan_files( "Hello3", "0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"], language=1) client2.save(files3) client2.run('install -o language=1 --build missing') client2.run('build') self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola #' ], str(client2.user_io.out).splitlines()[-5:]) # Issue 79, fixing private deps from current project files3 = cpp_hello_conan_files( "Hello3", "0.2", [ "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable", ("Hello0/0.1@lasote/stable", "private"), ("Hello00/0.2@lasote/stable", "private") ], language=1) client2.save(files3, clean_first=True) client2.run('install -o language=1 --build missing') client2.run('build') self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola #', 'Hola Hello0', 'Hola #' ], str(client2.user_io.out).splitlines()[-7:])
class ProfileTest(unittest.TestCase): def setUp(self): self.client = TestClient() def bad_syntax_test(self): self.client.save({CONANFILE: conanfile_scope_env}) self.client.run("export lasote/stable") profile = ''' [settings ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self.assertIn("Error reading 'clang' profile", self.client.user_io.out) self.assertIn("Bad syntax", self.client.user_io.out) profile = ''' [settings] [invented] ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self.assertIn("Unrecognized field 'invented'", self.client.user_io.out) self.assertIn("Error reading 'clang' profile", self.client.user_io.out) profile = ''' [settings] as ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self.assertIn("Error reading 'clang' profile: Invalid setting line 'as'", self.client.user_io.out) profile = ''' [env] as ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self.assertIn("Error reading 'clang' profile: Invalid env line 'as'", self.client.user_io.out) profile = ''' [scopes] as ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self.assertIn("Error reading 'clang' profile: Bad scope as", self.client.user_io.out) profile = ''' [settings] os = a value ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) # stripped "a value" self.assertIn("'a value' is not a valid 'settings.os'", self.client.user_io.out) profile = ''' [env] ENV_VAR = a value ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True) self._assert_env_variable_printed("ENV_VAR", "a value") profile = ''' # Line with comments is not a problem [env] # Not even here ENV_VAR = a value ''' save(self.client.client_cache.profile_path("clang"), profile) self.client.run("install Hello0/0.1@lasote/stable --build -pr clang", ignore_error=True) self._assert_env_variable_printed("ENV_VAR", "a value") def build_with_profile_test(self): self._create_profile("scopes_env", settings={}, scopes={}, # undefined scope do not apply to my packages env=[("CXX", "/path/tomy/g++_build"), ("CC", "/path/tomy/gcc_build")]) self.client.save({CONANFILE: conanfile_scope_env}) self.client.run("build -pr scopes_env") self._assert_env_variable_printed("CC", "/path/tomy/gcc_build") self._assert_env_variable_printed("CXX", "/path/tomy/g++_build") def install_profile_env_test(self): files = cpp_hello_conan_files("Hello0", "0.1", build=False) files["conanfile.py"] = conanfile_scope_env self._create_profile("envs", settings={}, env=[("A_VAR", "A_VALUE")], package_env={"Hello0": [("OTHER_VAR", 2)]}) self.client.save(files) self.client.run("export lasote/stable") self.client.run("install Hello0/0.1@lasote/stable --build missing -pr envs") self._assert_env_variable_printed("A_VAR", "A_VALUE") self._assert_env_variable_printed("OTHER_VAR", "2") # Override with package var self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE") self._assert_env_variable_printed("A_VAR", "OTHER_VALUE") self._assert_env_variable_printed("OTHER_VAR", "2") # Override package var with package var self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE -e Hello0:OTHER_VAR=3") self._assert_env_variable_printed("A_VAR", "OTHER_VALUE") self._assert_env_variable_printed("OTHER_VAR", "3") def install_profile_settings_test(self): files = cpp_hello_conan_files("Hello0", "0.1", build=False) files["conanfile.py"] = files["conanfile.py"].replace("generators =", "generators = \"txt\",") # Create a profile and use it profile_settings = {"compiler": "Visual Studio", "compiler.version": "12", "compiler.runtime": "MD", "arch": "x86"} self._create_profile("vs_12_86", settings=profile_settings, package_settings={}) self.client.save(files) self.client.run("export lasote/stable") self.client.run("install --build missing -pr vs_12_86") info = load(os.path.join(self.client.current_folder, "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 = load(os.path.join(self.client.current_folder, "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} self._create_profile("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 = load(os.path.join(self.client.current_folder, "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} self._create_profile("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 = load(os.path.join(self.client.current_folder, "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} self._create_profile("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 = load(os.path.join(self.client.current_folder, "conaninfo.txt")) self.assertIn("compiler=gcc", info) self.assertNotIn("compiler.libcxx=libstdc++11", info) self.assertIn("compiler.libcxx=libstdc++", info) def scopes_env_test(self): # Create a profile and use it self._create_profile("scopes_env", settings={}, scopes={"Hello0:myscope": "1", "ALL:otherscope": "2", "undefined": "3"}, # undefined scope do not apply to my packages env=[("CXX", "/path/tomy/g++"), ("CC", "/path/tomy/gcc")]) self.client.save({CONANFILE: conanfile_scope_env}) self.client.run("export lasote/stable") self.client.run("install Hello0/0.1@lasote/stable --build missing -pr scopes_env") self.assertIn("Scope myscope: 1", self.client.user_io.out) self.assertIn("Scope otherscope: 2", self.client.user_io.out) self.assertIn("Scope undefined: None", self.client.user_io.out) self._assert_env_variable_printed("CC", "/path/tomy/gcc") self._assert_env_variable_printed("CXX", "/path/tomy/g++") # The env variable shouldn't persist after install command self.assertFalse(os.environ.get("CC", None) == "/path/tomy/gcc") self.assertFalse(os.environ.get("CXX", None) == "/path/tomy/g++") def test_package_test(self): test_conanfile = '''from conans.model.conan_file import ConanFile from conans import CMake import os class DefaultNameConan(ConanFile): name = "DefaultName" version = "0.1" settings = "os", "compiler", "arch", "build_type" requires = "Hello0/0.1@lasote/stable" def build(self): # Print environment vars # self.run('cmake %s %s' % (self.conanfile_directory, cmake.command_line)) if self.settings.os == "Windows": self.run('echo "My var is %ONE_VAR%"') else: self.run('echo "My var is $ONE_VAR"') def test(self): pass ''' files = {} files["conanfile.py"] = conanfile_scope_env files["test_package/conanfile.py"] = test_conanfile # Create a profile and use it self._create_profile("scopes_env", settings={}, scopes={}, env=[("ONE_VAR", "ONE_VALUE")]) self.client.save(files) self.client.run("test_package --profile scopes_env") self._assert_env_variable_printed("ONE_VAR", "ONE_VALUE") self.assertIn("My var is ONE_VALUE", str(self.client.user_io.out)) # Try now with package environment vars self._create_profile("scopes_env2", settings={}, scopes={}, package_env={"DefaultName": [("ONE_VAR", "IN_TEST_PACKAGE")], "Hello0": [("ONE_VAR", "PACKAGE VALUE")]}) self.client.run("test_package --profile scopes_env2") self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE") self.assertIn("My var is IN_TEST_PACKAGE", str(self.client.user_io.out)) # Try now overriding some variables with command line self.client.run("test_package --profile scopes_env2 -e DefaultName:ONE_VAR=InTestPackageOverride " "-e Hello0:ONE_VAR=PackageValueOverride ") self._assert_env_variable_printed("ONE_VAR", "PackageValueOverride") self.assertIn("My var is InTestPackageOverride", str(self.client.user_io.out)) # A global setting in command line won't override a scoped package variable self.client.run("test_package --profile scopes_env2 -e ONE_VAR=AnotherValue") self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE") def _assert_env_variable_printed(self, name, value): if platform.system() == "Windows": self.assertIn("%s=%s" % (name, value), self.client.user_io.out) elif platform.system() == "Darwin": self.assertIn('%s="%s"' % (name, value), self.client.user_io.out) else: self.assertIn("%s='%s'" % (name, value), self.client.user_io.out) def _create_profile(self, name, settings, scopes=None, package_settings=None, env=None, package_env=None): package_env = package_env or {} profile = Profile() profile._settings = settings or {} if scopes: profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()]) if package_settings: profile._package_settings = package_settings for package_name, envs in package_env.items(): for var_name, value in envs: profile._package_env[package_name][var_name] = value for var_name, value in env or {}: profile._env[var_name] = value save(self.client.client_cache.profile_path(name), profile.dumps())
def package_test(self): """Use 'conan package' command to repackage a generated package (without build it)""" client = TestClient(users={"default": [("lasote", "mypass")]}) conanfile_template = """ from conans import ConanFile class MyConan(ConanFile): name = "MyLib" version = "0.1" exports = '*' def package(self): self.copy(pattern="*.h", dst="include", keep_path=False) #self.copy(pattern="*.a", dst="lib", keep_path=False) """ files = { "lib/file1.a": "foo", "include/file.h": "foo", CONANFILE: conanfile_template } client.save(files) client.run("export lasote/stable") # Build and package conan file conan_reference = ConanFileReference.loads("MyLib/0.1@lasote/stable") client.run("install %s --build missing" % str(conan_reference)) package_id = "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9" package_path = client.paths.package( PackageReference(conan_reference, package_id)) # Verify the headers are there but lib doesn't self.assertTrue( os.path.exists(os.path.join(package_path, "include", "file.h"))) self.assertFalse( os.path.exists(os.path.join(package_path, "lib", "file1.a"))) # Fix conanfile and re-package client.save({CONANFILE: conanfile_template.replace("#", "")}) client.run("export lasote/stable") # Build and package conan file client.run("package %s %s" % (conan_reference, package_id)) self.assertIn( "MyLib/0.1@lasote/stable: " "Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", client.user_io.out) self.assertTrue( os.path.exists(os.path.join(package_path, "include", "file.h"))) self.assertTrue( os.path.exists(os.path.join(package_path, "lib", "file1.a"))) # Fix again conanfile and re-package with AL client.save( {CONANFILE: conanfile_template.replace("self.copy", "pass #")}) client.run("export lasote/stable") # Build and package conan file client.run("package %s" % str(conan_reference)) self.assertIn( "MyLib/0.1@lasote/stable: " "Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", client.user_io.out) self.assertFalse( os.path.exists(os.path.join(package_path, "include", "file.h"))) self.assertFalse( os.path.exists(os.path.join(package_path, "lib", "file1.a")))
def conan_test_test(self): '''Checks --build in test command''' client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self._create(client, "Hello0", "0.0") self._create(client, "Hello1", "1.1", ["Hello0/0.0@lasote/stable"]) # Now test out Hello2 self._create(client, "Hello2", "2.2", ["Hello1/1.1@lasote/stable"], export=True) hello2conanfile = load(os.path.join(client.current_folder, CONANFILE)) client.save({CONANFILE: hello2conanfile}) test_conanfile = ''' from conans.model.conan_file import ConanFile class DefaultNameConan(ConanFile): settings = "os", "compiler", "arch" requires = "Hello2/2.2@lasote/stable" generators = "cmake" def test(self): pass ''' client.save({"test/%s" % CONANFILE: test_conanfile}) # Should recognize the hello package # Will Fail because Hello0/0.0 and Hello1/1.1 has not built packages # and by default no packages are built error = client.run("test", ignore_error=True) self.assertTrue(error) self.assertIn('Try to build from sources with "--build Hello0"', client.user_io.out) # We generate the package for Hello0/0.0 client.run("install Hello0/0.0@lasote/stable --build Hello0") # Still missing Hello1/1.1 error = client.run("test", ignore_error=True) self.assertTrue(error) self.assertIn('Try to build from sources with "--build Hello1"', client.user_io.out) # We generate the package for Hello1/1.1 client.run("install Hello1/1.1@lasote/stable --build Hello1") # Now Hello2 should be built and not fail client.run("test") self.assertNotIn("Can't find a 'Hello2/2.2@lasote/stable' package", client.user_io.out) self.assertIn( 'Hello2/2.2@lasote/stable: WARN: Forced build from source', client.user_io.out) # Now package is generated but should be built again client.run("test") self.assertIn( 'Hello2/2.2@lasote/stable: WARN: Forced build from source', client.user_io.out)
class SettingsTest(unittest.TestCase): def setUp(self): self.client = TestClient() def settings_as_a_str_test(self): content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = "os" """ self.client.save({CONANFILE: content}) self.client.run("install -s os=Windows --build missing") # Now read the conaninfo and verify that settings applied is only os and value is windows conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.os, "Windows") self.client.run("install -s os=Linux --build missing") # Now read the conaninfo and verify that settings applied is only os and value is windows conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.os, "Linux") def settings_as_a_list_conanfile_test(self): """Declare settings as a list""" # Now with conanfile as a list content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = "os", "arch" """ self.client.save({CONANFILE: content}) self.client.run("install -s os=Windows --build missing") conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.os, "Windows") self.assertEquals(conan_info.settings.fields, ["arch", "os"]) def settings_as_a_dict_conanfile_test(self): """Declare settings as a dict""" # Now with conanfile as a dict content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = {"os": ["Windows"], "arch": ["x86_64"]} """ self.client.save({CONANFILE: content}) self.client.run("install -s os=Windows --build missing") conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.os, "Windows") self.assertEquals(conan_info.settings.fields, ["arch", "os"]) def invalid_settings_test(self): '''Test wrong values and wrong constraints''' # MISSING VALUE FOR A SETTING content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = "os", "build_type" """ self.client.save({CONANFILE: content}) self.client.run("install --build missing", ignore_error=True) self.assertIn(undefined_value("settings.build_type"), str(self.client.user_io.out)) def invalid_settings_test2(self): # MISSING A DEFAULT VALUE BECAUSE ITS RESTRICTED TO OTHER, SO ITS REQUIRED content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = {"os": ["Windows", "Linux", "Macos"], "compiler": ["Visual Studio"]} """ self.client.save({CONANFILE: content}) self.client.run( "install -s compiler=gcc -s compiler.version=4.8 --build missing", ignore_error=True) self.assertIn( bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]), str(self.client.user_io.out)) def invalid_settings_test3(self): # dict without options content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = {"os": None, "compiler": ["Visual Studio"]} """ self.client.save({CONANFILE: content}) self.client.run( "install -s compiler=gcc -s compiler.version=4.8 --build missing", ignore_error=True) self.assertIn( bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]), str(self.client.user_io.out)) # Test wrong settings in conanfile content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = invalid """ self.client.save({CONANFILE: content}) self.client.run("install --build missing", ignore_error=True) self.assertIn("invalid' is not defined", str(self.client.user_io.out)) # Test wrong values in conanfile def invalid_settings_test4(self): content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = "os" """ self.client.save({CONANFILE: content}) self.client.run("install -s os=ChromeOS --build missing", ignore_error=True) self.assertIn( bad_value_msg("settings.os", "ChromeOS", ['Android', 'Linux', 'Macos', 'Windows']), str(self.client.user_io.out)) # Now add new settings to config and try again config = load(self.client.paths.settings_path) config = config.replace("Windows,", "Windows, ChromeOS,") save(self.client.paths.settings_path, config) self.client.run("install -s os=ChromeOS --build missing") self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out)) # Settings is None content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = None """ self.client.save({CONANFILE: content}) self.client.run("install --build missing") self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out)) conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.dumps(), "") # Settings is {} content = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" settings = {} """ self.client.save({CONANFILE: content}) self.client.run("install --build missing") self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out)) conan_info = ConanInfo.loads( load(os.path.join(self.client.current_folder, CONANINFO))) self.assertEquals(conan_info.settings.dumps(), "")
class SameUserChannelTest(unittest.TestCase): def setUp(self): self.client = TestClient() conanfile = """ from conans import ConanFile class SayConan(ConanFile): name = "Say" version = "0.1" build_policy = "missing" def build(self): self.output.info("Building %s") """ for channel in ("lasote/stable", "other/testing"): self.client.save({"conanfile.py": conanfile % channel}) self.client.run("export %s" % channel) self.conanfile = """ from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" build_policy = "missing" def requirements(self): self.requires("Say/0.1@%s/%s" % (self.user, self.channel)) def build(self): self.output.info("Building %s/%s" % (self.user, self.channel) ) """ self.test_conanfile = """ from conans import ConanFile, CMake import os class HelloReuseConan(ConanFile): requires = "Hello/0.1@lasote/stable" def test(self): self.conanfile_directory """ self.client.save({ "conanfile.py": self.conanfile, "test/conanfile.py": self.test_conanfile }) def test_testpackage(self): self.client.run("test_package") self.assertIn("Say/0.1@lasote/stable: Building lasote/stable", self.client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Building lasote/stable", self.client.user_io.out) self.assertNotIn("other/testing", self.client.user_io.out) self.client.save({ "conanfile.py": self.conanfile, "test/conanfile.py": self.test_conanfile.replace("lasote/stable", "other/testing") }) self.client.run("test_package") self.assertIn("Say/0.1@other/testing: Building other/testing", self.client.user_io.out) self.assertIn("Hello/0.1@other/testing: Building other/testing", self.client.user_io.out) self.assertNotIn("lasote/stable", self.client.user_io.out) def test_local_commands(self): error = self.client.run("install", ignore_error=True) self.assertEqual(error, True) self.assertIn( "ERROR: Conanfile: CONAN_USERNAME environment variable not defined, " "but self.user is used in conanfile", self.client.user_io.out) os.environ["CONAN_USERNAME"] = "******" error = self.client.run("install", ignore_error=True) self.assertEqual(error, True) self.assertIn( "ERROR: Conanfile: CONAN_CHANNEL environment variable not defined, " "but self.channel is used in conanfile", self.client.user_io.out) os.environ["CONAN_CHANNEL"] = "stable" self.client.run("install") self.assertIn("Say/0.1@lasote/stable: Building lasote/stable", self.client.user_io.out) self.assertNotIn("other/testing", self.client.user_io.out) os.environ["CONAN_USERNAME"] = "******" os.environ["CONAN_CHANNEL"] = "testing" self.client.run("install") self.assertIn("Say/0.1@other/testing: Building other/testing", self.client.user_io.out) self.assertNotIn("lasote/stable", self.client.user_io.out) del os.environ["CONAN_USERNAME"] del os.environ["CONAN_CHANNEL"]
class SynchronizeTest(unittest.TestCase): def setUp(self): test_server = TestServer( [("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def upload_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files["to_be_deleted.txt"] = "delete me" files["to_be_deleted2.txt"] = "delete me2" remote_paths = self.client.servers["default"].paths server_conan_path = remote_paths.export(conan_reference) self.client.save(files) self.client.run("export lasote/stable") # Upload conan file self.client.run("upload %s" % str(conan_reference)) # Verify the files are there self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")), "delete me") self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "delete me2") # Now delete local files export and upload and check that they are not in server os.remove(os.path.join(self.client.current_folder, "to_be_deleted.txt")) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) self.assertTrue(os.path.exists(os.path.join(tmp, "to_be_deleted2.txt"))) # Now modify a file, and delete other, and put a new one. files["to_be_deleted2.txt"] = "modified content" files["new_file.lib"] = "new file" del files["to_be_deleted.txt"] self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) # Verify all is correct self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "modified content") self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file") self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) ########################## # Now try with the package ########################## self.client.run("install %s --build missing" % str(conan_reference)) # Upload package package_ids = self.client.paths.conan_packages(conan_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check that conans exists on server package_reference = PackageReference(conan_reference, str(package_ids[0])) package_server_path = remote_paths.package(package_reference) self.assertTrue(os.path.exists(package_server_path)) # Add a new file to package (artificially), upload again and check new_file_source_path = os.path.join( self.client.paths.package(package_reference), "newlib.lib") save(new_file_source_path, "newlib") self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) # Now modify the file and check again save(new_file_source_path, "othercontent") self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) self.assertTrue(load(remote_file_path), "othercontent") # Now delete the file and check again os.remove(new_file_source_path) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertFalse(os.path.exists(remote_file_path)) self.assertNotEquals(remote_file_path, new_file_source_path)
class PrivateDepsTest(unittest.TestCase): def setUp(self): test_server = TestServer( [("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def _export_upload(self, name=0, version=None, deps=None, msg=None, static=True): dll_export = self.client.default_compiler_visual_studio and not static files = cpp_hello_conan_files(name, version, deps, msg=msg, static=static, private_includes=True, dll_export=dll_export) conan_ref = ConanFileReference(name, version, "lasote", "stable") self.client.save(files, clean_first=True) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_ref)) def reuse_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello00", "0.2", msg="#") self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@lasote/stable", "private")], static=False) self._export_upload("Hello2", "0.1", deps=[("Hello00/0.2@lasote/stable", "private")], static=False) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) # WE need to copy the DLLs and dylib client.save(files3) client.run('install --build missing') client.run('build') # assert Hello3 only depends on Hello2, and Hello1 info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE) build_info_cmake = load(info_path) # Ensure it does not depend on Hello0 to build, as private in dlls self.assertNotIn("Hello0", repr(build_info_cmake)) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello #' ], str(client.user_io.out).splitlines()[-5:]) # assert Hello3 only depends on Hello2, and Hello1 info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.loads(load(info_path)) self.assertEqual("language=0\nstatic=True", conan_info.options.dumps()) # Try to upload and reuse the binaries client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files2 = cpp_hello_conan_files( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) # WE need to copy the DLLs client2.save(files2) client2.run("install . --build missing") self.assertNotIn("Package installed in Hello0/0.1", client2.user_io.out) self.assertNotIn("Building", client2.user_io.out) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello #' ], str(client2.user_io.out).splitlines()[-5:]) files3 = cpp_hello_conan_files( "Hello3", "0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"], language=1) client2.save(files3) client2.run('install -o language=1 --build missing') client2.run('build') self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola #' ], str(client2.user_io.out).splitlines()[-5:]) # Issue 79, fixing private deps from current project files3 = cpp_hello_conan_files( "Hello3", "0.2", [ "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable", ("Hello0/0.1@lasote/stable", "private"), ("Hello00/0.2@lasote/stable", "private") ], language=1) client2.save(files3, clean_first=True) client2.run('install -o language=1 --build missing') client2.run('build') self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello00.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola #', 'Hola Hello0', 'Hola #' ], str(client2.user_io.out).splitlines()[-7:])
class InstallTest(unittest.TestCase): def setUp(self): self.client = TestClient() self.settings = ("-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 " "-s arch=x86 -s compiler.runtime=MD") def _create(self, number, version, deps=None, export=True, no_config=False): files = cpp_hello_conan_files(number, version, deps, build=False, config=not no_config) self.client.save(files, clean_first=True) if export: self.client.run("export lasote/stable") def reuse_test(self): self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26", "44671ecdd9c606eb7166f2197ab50be8d36a3c3b"), (1, "8b964e421a5b7e48b7bc19b94782672be126be8b", "3eeab577a3134fa3afdcd82881751789ec48e08f")]: self.client.run("install -o language=%d %s --build missing" % (lang, self.settings)) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("arch=x86\n" "compiler=Visual Studio\n" "compiler.runtime=MD\n" "compiler.version=12\n" "os=Windows", conan_info.settings.dumps()) self.assertEqual("language=%s\nstatic=True" % lang, conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, id0)) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(lang, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), id1) hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(lang, hello1_conan_info.options.language) def upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run("install -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s" " --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=1\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def inverse_upper_option_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True) self.client.run("install -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s " "--build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("language=0\nstatic=True", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual("language=0\nstatic=True", hello0_conan_info.options.dumps()) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "3eeab577a3134fa3afdcd82881751789ec48e08f") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual("language=1\nstatic=True", hello1_conan_info.options.dumps()) def upper_option_txt_test(self): self._create("Hello0", "0.1", no_config=True) self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True) files = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"]) files.pop(CONANFILE) files[CONANFILE_TXT] = """[requires] Hello1/0.1@lasote/stable [options] Hello0:language=1 Hello1:language=0 """ self.client.save(files, clean_first=True) self.client.run("install %s --build missing" % self.settings) info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") hello0 = self.client.paths.package(PackageReference(conan_ref, "8b964e421a5b7e48b7bc19b94782672be126be8b")) hello0_info = os.path.join(hello0, CONANINFO) hello0_conan_info = ConanInfo.load_file(hello0_info) self.assertEqual(1, hello0_conan_info.options.language) package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"), "44671ecdd9c606eb7166f2197ab50be8d36a3c3b") hello1 = self.client.paths.package(package_ref1) hello1_info = os.path.join(hello1, CONANINFO) hello1_conan_info = ConanInfo.load_file(hello1_info) self.assertEqual(0, hello1_conan_info.options.language) def change_option_txt_test(self): self._create("Hello0", "0.1") client = TestClient(base_folder=self.client.base_folder) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=1 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=1", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b", conan_info.full_requires.dumps()) files = {CONANFILE_TXT: """[requires] Hello0/0.1@lasote/stable [options] Hello0:language=0 """} client.save(files) client.run("install %s --build missing" % self.settings) info_path = os.path.join(client.current_folder, CONANINFO) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=1", conan_info.full_options.dumps()) # it is necessary to clean the cached conaninfo client.save(files, clean_first=True) client.run("install %s --build missing" % self.settings) conan_info = ConanInfo.load_file(info_path) self.assertEqual("", conan_info.options.dumps()) self.assertIn("Hello0:language=0", conan_info.full_options.dumps()) self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26", conan_info.full_requires.dumps()) def warn_bad_os_test(self): bad_os = "Linux" if platform.system() != "Linux" else "Macos" message = "You are building this package with settings.os='%s" % bad_os self._create("Hello0", "0.1") self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os, ignore_error=True) self.assertIn(message, self.client.user_io.out) self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % detected_os(), ignore_error=True) self.assertNotIn("You are building this package with settings.os", self.client.user_io.out)
def reuse_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True) self.client.save(files) self.client.run("export lasote/stable") self.client.run("install %s --build missing" % str(conan_reference)) self.assertIn( "Hello0/0.1@lasote/stable package(): Copied 1 '.h' files: helloHello0.h", self.client.user_io.out) # Check compilation ok package_ids = self.client.paths.conan_packages(conan_reference) self.assertEquals(len(package_ids), 1) package_ref = PackageReference(conan_reference, package_ids[0]) self._assert_library_exists(package_ref, self.client.paths) # Upload conans self.client.run("upload %s" % str(conan_reference)) # Check that conans exists on server server_paths = self.servers["default"].paths conan_path = server_paths.export(conan_reference) self.assertTrue(os.path.exists(conan_path)) # Upload package self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check library on server self._assert_library_exists_in_server(package_ref, server_paths) # Now from other "computer" install the uploaded conans with same options (nothing) other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build missing" % str(conan_reference)) # Build should be empty build_path = other_conan.paths.build(package_ref) self.assertFalse(os.path.exists(build_path)) # Lib should exist self._assert_library_exists(package_ref, other_conan.paths) # Now install it but with other options other_conan.run('install %s -o language=1 --build missing' % (str(conan_reference))) # Should have two packages package_ids = other_conan.paths.conan_packages(conan_reference) self.assertEquals(len(package_ids), 2) for package_id in package_ids: ref = PackageReference(conan_reference, package_id) self._assert_library_exists(ref, other_conan.paths) client3 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable") files3 = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) client3.save(files3) client3.run('install') client3.run('build') command = os.sep.join([".", "bin", "say_hello"]) client3.runner(command, cwd=client3.current_folder) self.assertIn("Hello Hello1", client3.user_io.out) self.assertIn("Hello Hello0", client3.user_io.out) client3.run('install -o language=1 --build missing') time.sleep(1) client3.run('build') command = os.sep.join([".", "bin", "say_hello"]) client3.runner(command, cwd=client3.current_folder) self.assertIn("Hola Hello1", client3.user_io.out) self.assertIn("Hola Hello0", client3.user_io.out)
class ExportTest(unittest.TestCase): def setUp(self): self.conan = TestClient() self.files = cpp_hello_conan_files("Hello0", "0.1") self.conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable") self.conan.save(self.files) self.conan.run("export lasote/stable") def test_basic(self): """ simple registration of a new conans """ reg_path = self.conan.paths.export(self.conan_ref) manif = FileTreeManifest.loads(load(self.conan.paths.digestfile_conanfile(self.conan_ref))) self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path)) for name in list(self.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': '9e26c9274ae837c03764d1418c063ebb', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums) def test_case_sensitive(self): self.files = cpp_hello_conan_files("hello0", "0.1") self.conan_ref = ConanFileReference("hello0", "0.1", "lasote", "stable") self.conan.save(self.files) error = self.conan.run("export lasote/stable", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: Cannot export package with same name but different case", self.conan.user_io.out) def test_export_filter(self): content = """ from conans import ConanFile class OpenSSLConan(ConanFile): name = "openssl" version = "2.0.1" """ save(os.path.join(self.conan.current_folder, CONANFILE), content) self.conan.run("export lasote/stable") reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable')) self.assertEqual(sorted(os.listdir(reg_path)), [EXPORT_SOURCES_DIR, CONANFILE, CONAN_MANIFEST]) content = """ from conans import ConanFile class OpenSSLConan(ConanFile): name = "openssl" version = "2.0.1" exports = ('*.txt', '*.h') """ save(os.path.join(self.conan.current_folder, CONANFILE), content) self.conan.run("export lasote/stable") reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable')) self.assertEqual(sorted(os.listdir(reg_path)), [EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST, 'helloHello0.h']) # Now exports being a list instead a tuple content = """ from conans import ConanFile class OpenSSLConan(ConanFile): name = "openssl" version = "2.0.1" exports = ['*.txt', '*.h'] """ save(os.path.join(self.conan.current_folder, CONANFILE), content) self.conan.run("export lasote/stable") reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable')) self.assertEqual(sorted(os.listdir(reg_path)), [EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST, 'helloHello0.h']) def test_export_the_same_code(self): file_list = self._create_packages_and_builds() # Export the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") conan2.save(files2) conan2.run("export lasote/stable") reg_path2 = conan2.paths.export(self.conan_ref) digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertNotIn('A new Conan version was exported', conan2.user_io.out) self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out) self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out) self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out) self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path2)) for name in list(files2.keys()): self.assertTrue(os.path.exists(os.path.join(reg_path2, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': '9e26c9274ae837c03764d1418c063ebb', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest2.file_sums) for f in file_list: self.assertTrue(os.path.exists(f)) def test_export_a_new_version(self): self._create_packages_and_builds() # Export an update of the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE] conan2.save(files2) conan2.run("export lasote/stable") reg_path3 = conan2.paths.export(self.conan_ref) digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path3)) for name in list(files2.keys()): self.assertTrue(os.path.exists(os.path.join(reg_path3, name))) expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': 'b6ac37b87cf6cfd63991d355b48db40e', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, digest3.file_sums) # for f in file_list: # self.assertFalse(os.path.exists(f)) def _create_packages_and_builds(self): reg_builds = self.conan.paths.builds(self.conan_ref) reg_packs = self.conan.paths.packages(self.conan_ref) folders = [os.path.join(reg_builds, '342525g4f52f35f'), os.path.join(reg_builds, 'ew9o8asdf908asdf80'), os.path.join(reg_packs, '342525g4f52f35f'), os.path.join(reg_packs, 'ew9o8asdf908asdf80')] file_list = [] for f in folders: for name, content in {'file1.h': 'asddfasdf', 'file1.dll': 'asddfasdf'}.items(): file_path = os.path.join(f, name) save(file_path, content) file_list.append(file_path) return file_list
class InstallSelectedPackagesTest(unittest.TestCase): def setUp(self): test_server = TestServer() self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self.package_ids = self._upload_some_packages(self.client) self.new_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def install_all_test(self): # Should retrieve the three packages self.new_client.run("install Hello0/0.1@lasote/stable --all") p1 = os.path.join(self.new_client.paths.packages(self.ref)) packages = os.listdir(p1) self.assertEquals(len(packages), 3) def install_some_reference_test(self): # Should retrieve the specified packages self.new_client.run("install Hello0/0.1@lasote/stable -p %s" % self.package_ids[0]) packages = os.listdir(self.new_client.paths.packages(self.ref)) self.assertEquals(len(packages), 1) self.assertEquals(packages[0], self.package_ids[0]) self.new_client.run("install Hello0/0.1@lasote/stable -p %s -p %s" % (self.package_ids[0], self.package_ids[1])) packages = os.listdir(self.new_client.paths.packages(self.ref)) self.assertEquals(len(packages), 2) def download_recipe_twice_test(self): expected_conanfile_contents = self.files[CONANFILE] self.new_client.run("install Hello0/0.1@lasote/stable --all") got_conanfile = load( os.path.join(self.new_client.paths.export(self.ref), CONANFILE)) self.assertEquals(expected_conanfile_contents, got_conanfile) self.new_client.run("install Hello0/0.1@lasote/stable --all") got_conanfile = load( os.path.join(self.new_client.paths.export(self.ref), CONANFILE)) self.assertEquals(expected_conanfile_contents, got_conanfile) self.new_client.run("install Hello0/0.1@lasote/stable --all") got_conanfile = load( os.path.join(self.new_client.paths.export(self.ref), CONANFILE)) self.assertEquals(expected_conanfile_contents, got_conanfile) def download_packages_twice_test(self): expected_header_contents = self.files["helloHello0.h"] package_folder = self.new_client.paths.package( PackageReference(self.ref, self.package_ids[0])) self.new_client.run("install Hello0/0.1@lasote/stable --all") got_header = load( os.path.join(package_folder, "include", "helloHello0.h")) self.assertEquals(expected_header_contents, got_header) self.new_client.run("install Hello0/0.1@lasote/stable --all") got_header = load( os.path.join(package_folder, "include", "helloHello0.h")) self.assertEquals(expected_header_contents, got_header) self.new_client.run("install Hello0/0.1@lasote/stable --all") got_header = load( os.path.join(package_folder, "include", "helloHello0.h")) self.assertEquals(expected_header_contents, got_header) def install_all_but_no_packages_test(self): # Remove all from remote self.new_client.run("remove Hello* -f -r default") # Try to install all self.new_client.run("install Hello0/0.1@lasote/stable --all", ignore_error=True) self.assertIn("'Hello0/0.1@lasote/stable' not found in remote", self.new_client.user_io.out) # Upload only the recipe self.new_client.save(self.files) self.new_client.run("export lasote/stable") self.new_client.run("upload Hello0/0.1@lasote/stable --all") # And try to download all self.new_client.run("install Hello0/0.1@lasote/stable --all") self.assertIn("No remote binary packages found in remote", self.new_client.user_io.out) def _upload_some_packages(self, client): self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") self.files = cpp_hello_conan_files("Hello0", "0.1") # No build. self.files[CONANFILE] = self.files[CONANFILE].replace( "def build(self):", "def build(self):\n return\n") client.save(self.files) client.run("export lasote/stable") client.run( "install Hello0/0.1@lasote/stable -s os=Windows --build missing") client.run( "install Hello0/0.1@lasote/stable -s os=Linux --build missing") client.run( "install Hello0/0.1@lasote/stable -s os=Linux -s compiler=gcc -s " "compiler.version=4.6 -s compiler.libcxx=libstdc++ --build missing" ) client.run("upload Hello0/0.1@lasote/stable --all") return os.listdir(self.client.paths.packages(self.ref))
class ImportsTest(unittest.TestCase): def setUp(self): self.client = TestClient() self.client.save({"conanfile.py": conanfile}) self.client.run("export lasote/stable") def imports_global_path_test(self): """ Ensure that when importing files in a global path, outside the package build, they are not deleted """ dst_global_folder = temp_folder().replace("\\", "/") conanfile2 = ''' from conans import ConanFile class ConanLib(ConanFile): name = "Say" version = "0.1" requires = "Hello/0.1@lasote/stable" def imports(self): self.copy("file*.txt", dst="%s") ''' % dst_global_folder self.client.save({"conanfile.py": conanfile2}, clean_first=True) self.client.run("export lasote/stable") self.client.current_folder = temp_folder() self.client.run("install Say/0.1@lasote/stable --build=missing") for filename, content in [("file1.txt", "Hello"), ("file2.txt", "World")]: filecontent = load(os.path.join(dst_global_folder, filename)) self.assertTrue(content, filecontent) def imports_env_var_test(self): conanfile2 = ''' from conans import ConanFile import os class ConanLib(ConanFile): requires = "Hello/0.1@lasote/stable" def imports(self): self.copy("file*.txt", dst=os.environ["MY_IMPORT_PATH"]) ''' for folder in ("folder1", "folder2"): self.client.save({"conanfile.py": conanfile2}, clean_first=True) self.client.run("install -e MY_IMPORT_PATH=%s" % folder) self.assertEqual( "Hello", load( os.path.join(self.client.current_folder, folder, "file1.txt"))) def imports_error_test(self): self.client.save({"conanfile.txt": test1}, clean_first=True) self.client.run("install --no-imports") self.assertNotIn("file1.txt", os.listdir(self.client.current_folder)) self.assertNotIn("file2.txt", os.listdir(self.client.current_folder)) error = self.client.run("imports", ignore_error=True) self.assertTrue(error) self.assertIn("conanbuildinfo.txt file not found", self.client.user_io.out) def install_manifest_test(self): self.client.save({"conanfile.txt": test1}, clean_first=True) self.client.run("install -g txt") self.assertIn("imports(): Copied 2 '.txt' files", self.client.user_io.out) self.assertIn("file1.txt", os.listdir(self.client.current_folder)) self.assertIn("file2.txt", os.listdir(self.client.current_folder)) self._check_manifest() def undo_install_manifest_test(self): self.client.save({"conanfile.txt": test1}, clean_first=True) self.client.run("install -g txt") self.client.run("imports --undo") self.assertNotIn("file1.txt", os.listdir(self.client.current_folder)) self.assertNotIn("file2.txt", os.listdir(self.client.current_folder)) self.assertNotIn(IMPORTS_MANIFESTS, os.listdir(self.client.current_folder)) self.assertIn("Removed 2 imported files", self.client.user_io.out) self.assertIn("Removed imports manifest file", self.client.user_io.out) def _check_manifest(self): manifest_content = load( os.path.join(self.client.current_folder, IMPORTS_MANIFESTS)) manifest = FileTreeManifest.loads(manifest_content) self.assertEqual( manifest.file_sums, { os.path.join(self.client.current_folder, "file1.txt"): "8b1a9953c4611296a827abf8c47804d7", os.path.join(self.client.current_folder, "file2.txt"): "f5a7924e621e84c9280a9a27e1bcb7f6" }) def imports_test(self): self.client.save({"conanfile.txt": test1}, clean_first=True) self.client.run("install --no-imports -g txt") self.assertNotIn("file1.txt", os.listdir(self.client.current_folder)) self.assertNotIn("file2.txt", os.listdir(self.client.current_folder)) self.client.run("imports") self.assertIn("imports(): Copied 2 '.txt' files", self.client.user_io.out) self.assertIn("file1.txt", os.listdir(self.client.current_folder)) self.assertIn("file2.txt", os.listdir(self.client.current_folder)) self._check_manifest() def imports_filename_test(self): self.client.save( { "conanfile.txt": test1, "conanfile.py": test2, "conanfile2.py": test3 }, clean_first=True) self.client.run("install --no-imports -g txt") self.assertNotIn("file1.txt", os.listdir(self.client.current_folder)) self.assertNotIn("file2.txt", os.listdir(self.client.current_folder)) self.client.run("imports -f=conanfile2.py") self.assertNotIn("file1.txt", os.listdir(self.client.current_folder)) self.assertIn("file2.txt", os.listdir(self.client.current_folder)) os.unlink(os.path.join(self.client.current_folder, "file2.txt")) self.client.run("imports") self.assertIn("file1.txt", os.listdir(self.client.current_folder)) self.assertNotIn("file2.txt", os.listdir(self.client.current_folder)) os.unlink(os.path.join(self.client.current_folder, "file1.txt")) self.client.run("imports -f conanfile.txt") self.assertIn("file1.txt", os.listdir(self.client.current_folder)) self.assertIn("file2.txt", os.listdir(self.client.current_folder))
def complete_test(self): """ basic installation of a new conans """ client = TestClient() client.init_dynamic_vars() files = hello_source_files() conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable") reg_folder = client.paths.export(conan_ref) client.save(files, path=reg_folder) client.save( { CONANFILE: myconan1, 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) package_ref = PackageReference(conan_ref, "myfakeid") build_folder = client.paths.build(package_ref) package_folder = client.paths.package(package_ref) shutil.copytree(reg_folder, build_folder) loader = ConanFileLoader(None, Settings(), OptionsValues.loads("")) conanfile = loader.load_conan(conanfile_path, None) create_package(conanfile, build_folder, package_folder, TestBufferConanOutput()) # 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 _diamond_test(self, install="install", use_cmake=True): def wait_until_removed(folder): latest_exception = None for _ in range(50): # Max 5 seconds time.sleep(0.1) try: shutil.rmtree(folder) break except Exception as e: latest_exception = e else: raise Exception("Could remove folder %s: %s" % (folder, latest_exception)) self._export_upload("Hello0", "0.1", use_cmake=use_cmake) self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake) self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake) self._export_upload( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"], use_cmake=use_cmake) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], use_cmake=use_cmake) # Add some stuff to base project conanfile to test further the individual # flags in build_info (txt, cmake) files content = files3[CONANFILE] content = content.replace("generators =", 'generators = "txt",') content = content.replace( "def build(self):", "def build(self):\n" " self.output.info('INCLUDE %s' " "% self.deps_cpp_info['Hello0'].include_paths)") files3[CONANFILE] = content client.save(files3) client.run("%s . --build missing" % install) client.run("build .") self._check_individual_deps(client) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1, use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') wait_until_removed(client.current_folder) client.save(files3) client.run("%s . --build missing" % install) client.run("build .") client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client.user_io.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload Hello3/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello0/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') client2.save(files3) client2.run("%s . --build missing" % install) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client2.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1, use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') wait_until_removed(client2.current_folder) client2.save(files3) client2.run("%s . --build missing" % install) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client2.user_io.out).splitlines()[-6:])
def test_update_settings(self): file_content = ''' from conans import ConanFile class ConanFileToolsTest(ConanFile): name = "test" version = "1.9" settings = "os", "compiler", "arch" def source(self): self.output.warn("Sourcing...") def build(self): self.output.warn("Building...") ''' prev_settings = """ os: [Windows, Linux, Macos, Android] arch: [x86, x86_64, armv6, armv7, armv7hf, armv8] compiler: gcc: version: ["4.4", "4.5", "4.6", "4.7", "4.8", "4.9", "5.1", "5.2", "5.3"] libcxx: [libstdc++, libstdc++11] Visual Studio: runtime: [None, MD, MT, MTd, MDd] version: ["8", "9", "10", "11", "12", "14"] clang: version: ["3.3", "3.4", "3.5", "3.6", "3.7", "3.8"] libcxx: [libstdc++, libstdc++11, libc++] apple-clang: version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.1", "7.2", "7.3"] libcxx: [libstdc++, libc++] """ files = {"conanfile.py": file_content} client = TestClient() save(client.paths.settings_path, prev_settings) conf = load(client.paths.conan_conf_path) conf = conf.replace("build_type=Release", "") self.assertNotIn("build_type", conf) save(client.paths.conan_conf_path, conf) self.assertNotIn("build_type", client.paths.conan_config.settings_defaults.dumps()) client.save(files) client.run("export lasote/testing") self.assertNotIn("build_type", load(client.paths.settings_path)) self.assertNotIn("build_type", load(client.paths.conan_conf_path)) self.assertNotIn("build_type", client.paths.conan_config.settings_defaults.dumps()) client.run( "install test/1.9@lasote/testing --build -s compiler=gcc " "-s compiler.version=4.9 -s os=Windows -s compiler.libcxx=libstdc++" ) self.assertIn("390146894f59dda18c902ee25e649ef590140732", client.user_io.out) # Now the new one files = { "conanfile.py": file_content.replace('"arch"', '"arch", "build_type"') } client = TestClient() client.save(files) client.run("export lasote/testing") self.assertIn("build_type", load(client.paths.settings_path)) client.run( "install test/1.9@lasote/testing --build -s compiler=gcc " "-s compiler.version=4.9 -s os=Windows -s build_type=None -s compiler.libcxx=libstdc++" ) self.assertIn("390146894f59dda18c902ee25e649ef590140732", client.user_io.out)
class DiamondTest(unittest.TestCase): def setUp(self): test_server = TestServer( [("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def _export_upload(self, name, version=None, deps=None): files = cpp_hello_conan_files(name, version, deps, need_patch=True) conan_ref = ConanFileReference(name, version, "lasote", "stable") self.conan.save(files, clean_first=True) self.conan.run("export lasote/stable") self.conan.run("upload %s" % str(conan_ref)) def _check_individual_deps(self, client): self.assertIn("INCLUDE [", client.user_io.out) self.assertIn(".conan/data/Hello0/0.1/lasote/stable", client.user_io.out) build_file = os.path.join(client.current_folder, BUILD_INFO) content = load(build_file) cmakebuildinfo = load( os.path.join(client.current_folder, BUILD_INFO_CMAKE)) self.assertIn( "set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0", cmakebuildinfo) self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)", cmakebuildinfo) deps_cpp_info = DepsCppInfo.loads(content) self.assertEqual(len(deps_cpp_info.include_paths), 4) for dep in ("Hello3", "Hello2", "Hello1", "Hello0"): self.assertEqual(len(deps_cpp_info[dep].include_paths), 1) self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1) self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep]) build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE) content = load(build_file) for dep in ("Hello3", "Hello2", "Hello1", "Hello0"): self.assertEqual(len(deps_cpp_info[dep].include_paths), 1) self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content) self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep), content) def reuse_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"]) self._export_upload( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"]) # Add some stuff to base project conanfile to test further the individual # flags in build_info (txt, cmake) files content = files3[CONANFILE] content = content.replace("generators =", 'generators = "txt",') content = content.replace( "def build(self):", "def build(self):\n" " self.output.info('INCLUDE %s' " "% self.deps_cpp_info['Hello0'].include_paths)") files3[CONANFILE] = content client.save(files3) client.run("install . --build missing") client.run("build .") self._check_individual_deps(client) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1) client.save(files3, clean_first=True) client.run("install . --build missing") client.run("build .") client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client.user_io.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload Hello3/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello0/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"]) client2.save(files3) client2.run("install . --build missing") client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client2.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1) client2.save(files3, clean_first=True) client2.run("install . --build missing") client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client2.user_io.out).splitlines()[-6:])
class SearchTest(unittest.TestCase): def setUp(self): self.servers = { "local": TestServer(server_capabilities=[]), "search_able": TestServer(server_capabilities=[COMPLEX_SEARCH_CAPABILITY]) } self.client = TestClient(servers=self.servers) # No conans created self.client.run("search") output = self.client.user_io.out self.assertIn('There are no packages', output) # Conans with and without packages created self.root_folder1 = 'Hello/1.4.10/fenix/testing' root_folder2 = 'helloTest/1.4.10/fenix/stable' root_folder3 = 'Bye/0.14/fenix/testing' root_folder4 = 'NodeInfo/1.0.2/fenix/stable' root_folder5 = 'MissFile/1.0.2/fenix/stable' root_folder11 = 'Hello/1.4.11/fenix/testing' root_folder12 = 'Hello/1.4.12/fenix/testing' self.client.save( { "Empty/1.10/fake/test/reg/fake.txt": "//", "%s/%s/WindowsPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/WindowsPackageSHA/%s" % (root_folder11, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/WindowsPackageSHA/%s" % (root_folder12, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1b, "%s/%s/LinuxPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1c, "%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO): conan_vars2, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO): conan_vars3, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO): conan_vars4, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"): "Hello" }, self.client.paths.store) # Fake some manifests to be able to calculate recipe hash fake_manifest = FileTreeManifest(1212, {}) self.client.save( { os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest), }, self.client.paths.store) def recipe_search_test(self): self.client.run("search Hello*") self.assertEquals( "Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) self.client.run("search Hello* --case-sensitive") self.assertEquals( "Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n", self.client.user_io.out) self.client.run("search *fenix* --case-sensitive") self.assertEquals( "Existing package recipes:\n\n" "Bye/0.14@fenix/testing\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "MissFile/1.0.2@fenix/stable\n" "NodeInfo/1.0.2@fenix/stable\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) def recipe_pattern_search_test(self): self.client.run("search Hello*") self.assertEquals( "Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) self.client.run("search Hello* --case-sensitive") self.assertEquals( "Existing package recipes:\n\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n", self.client.user_io.out) self.client.run("search *fenix* --case-sensitive") self.assertEquals( "Existing package recipes:\n\n" "Bye/0.14@fenix/testing\n" "Hello/1.4.10@fenix/testing\n" "Hello/1.4.11@fenix/testing\n" "Hello/1.4.12@fenix/testing\n" "MissFile/1.0.2@fenix/stable\n" "NodeInfo/1.0.2@fenix/stable\n" "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out) def package_search_with_invalid_reference_test(self): self.client.run("search Hello -q 'a=1'", ignore_error=True) self.assertIn("-q parameter only allowed with a valid recipe", str(self.client.user_io.out)) def package_search_with_empty_query_test(self): self.client.run("search Hello/1.4.10/fenix/testing") self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) def package_search_nonescaped_characters_test(self): self.client.run( 'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"' ) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.client.run( 'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"' ) self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) # Now search with a remote os.rmdir(self.servers["local"].paths.store) shutil.copytree(self.client.paths.store, self.servers["local"].paths.store) self.client.run("remove Hello* -f") self.client.run( 'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local' ) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.client.run( 'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local' ) self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) def _assert_pkg_q(self, query, packages_found, remote): command = 'search Hello/1.4.10@fenix/testing -q \'%s\'' % query if remote: command += " -r %s" % remote self.client.run(command) for pack_name in [ "LinuxPackageSHA", "PlatformIndependantSHA", "WindowsPackageSHA" ]: self.assertEquals(pack_name in self.client.user_io.out, pack_name in packages_found, "%s fail" % pack_name) def package_search_complex_queries_test(self): def test_cases(remote=None): if remote: # Simulate upload to remote os.rmdir(self.servers[remote].paths.store) shutil.copytree(self.client.paths.store, self.servers[remote].paths.store) q = '' self._assert_pkg_q(q, [ "LinuxPackageSHA", "PlatformIndependantSHA", "WindowsPackageSHA" ], remote) q = 'compiler="gcc"' self._assert_pkg_q(q, ["LinuxPackageSHA", "PlatformIndependantSHA"], remote) q = 'compiler=' # No packages found with empty value self._assert_pkg_q(q, [], remote) q = 'compiler="gcc" OR compiler.libcxx=libstdc++11' # Should find Visual because of the OR, visual doesn't care about libcxx self._assert_pkg_q(q, [ "LinuxPackageSHA", "PlatformIndependantSHA", "WindowsPackageSHA" ], remote) q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR compiler.version=4.5' self._assert_pkg_q(q, ["LinuxPackageSHA"], remote) q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR '\ '(compiler.version=4.5 OR compiler.version=8.1)' self._assert_pkg_q(q, ["LinuxPackageSHA", "WindowsPackageSHA"], remote) q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\ '(compiler.version=4.5 OR compiler.version=8.1)' self._assert_pkg_q(q, [ "LinuxPackageSHA", "PlatformIndependantSHA", "WindowsPackageSHA" ], remote) q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\ '(compiler.version=4.3 OR compiler.version=8.1)' self._assert_pkg_q(q, ["PlatformIndependantSHA", "WindowsPackageSHA"], remote) q = '(os="Linux" OR os=Windows)' self._assert_pkg_q(q, [ "PlatformIndependantSHA", "LinuxPackageSHA", "WindowsPackageSHA" ], remote) q = '(os="Linux" OR os=Windows) AND use_Qt=True' self._assert_pkg_q(q, ["PlatformIndependantSHA", "WindowsPackageSHA"], remote) q = '(os="Linux" OR os=Windows) AND use_Qt=True AND nonexistant_option=3' self._assert_pkg_q(q, ["PlatformIndependantSHA", "WindowsPackageSHA"], remote) q = '(os="Linux" OR os=Windows) AND use_Qt=True OR nonexistant_option=3' self._assert_pkg_q(q, [ "PlatformIndependantSHA", "WindowsPackageSHA", "LinuxPackageSHA" ], remote) # test in local test_cases() # test in remote test_cases(remote="local") # test in remote with search capabilities test_cases(remote="search_able") def package_search_with_invalid_query_test(self): self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'", ignore_error=True) self.assertIn("Invalid package query: invalid", self.client.user_io.out) self.client.run("search Hello/1.4.10/fenix/testing -q 'os= 3'", ignore_error=True) self.assertIn("Invalid package query: os= 3", self.client.user_io.out) self.client.run("search Hello/1.4.10/fenix/testing -q 'os=3 FAKE '", ignore_error=True) self.assertIn("Invalid package query: os=3 FAKE ", self.client.user_io.out) self.client.run( "search Hello/1.4.10/fenix/testing -q 'os=3 os.compiler=4'", ignore_error=True) self.assertIn("Invalid package query: os=3 os.compiler=4", self.client.user_io.out) self.client.run( "search Hello/1.4.10/fenix/testing -q 'not os=3 AND os.compiler=4'", ignore_error=True) self.assertIn( "Invalid package query: not os=3 AND os.compiler=4. 'not' operator is not allowed", self.client.user_io.out) self.client.run( "search Hello/1.4.10/fenix/testing -q 'os=3 AND !os.compiler=4'", ignore_error=True) self.assertIn( "Invalid package query: os=3 AND !os.compiler=4. '!' character is not allowed", self.client.user_io.out) def package_search_properties_filter_test(self): # All packages without filter self.client.run("search Hello/1.4.10/fenix/testing -q ''") self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows') self.assertIn("WindowsPackageSHA", self.client.user_io.out) self.assertIn("PlatformIndependantSHA", self.client.user_io.out) self.assertNotIn("LinuxPackageSHA", self.client.user_io.out) self.client.run( 'search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"' ) self.assertIn( "There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'", self.client.user_io.out) self.client.run( 'search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"' ) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run( 'search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"') self.assertIn( "There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'", self.client.user_io.out) self.client.run( 'search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"' ) self.assertNotIn("WindowsPackageSHA", self.client.user_io.out) self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out) self.assertIn("LinuxPackageSHA", self.client.user_io.out) self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"') # One package will be outdated from recipe and another don't self.assertEquals( """Existing packages for recipe Hello/1.4.10@fenix/testing: Package_ID: LinuxPackageSHA [options] use_Qt: False [settings] arch: x86 compiler: gcc compiler.libcxx: libstdc++11 compiler.version: 4.5 os: Linux [requires] Hello2/0.1@lasote/stable:11111 HelloInfo1/0.45@fenix/testing:33333 OpenSSL/2.10@lasote/testing:2222 outdated from recipe: False Package_ID: PlatformIndependantSHA [options] use_Qt: True [settings] arch: x86 compiler: gcc compiler.libcxx: libstdc++ compiler.version: 4.3 outdated from recipe: True """, self.client.user_io.out) self.client.run( 'search helloTest/1.4.10@fenix/stable -q use_OpenGL=False') self.assertIn( "There are no packages for reference 'helloTest/1.4.10@fenix/stable' " "matching the query 'use_OpenGL=False'", self.client.user_io.out) self.client.run( 'search helloTest/1.4.10@fenix/stable -q use_OpenGL=True') self.assertIn( "Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out) self.client.run( 'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"' ) self.assertIn( "Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out) self.client.run( 'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"' ) self.assertIn( "There are no packages for reference 'helloTest/1.4.10@fenix/stable' " "matching the query 'use_OpenGL=True AND arch=x86'", self.client.user_io.out) def search_with_no_local_test(self): client = TestClient() client.run("search nonexist/1.0@lasote/stable") self.assertIn("There are no packages", self.client.user_io.out)
class FlatRequirementsTest(unittest.TestCase): def setUp(self): self.conan_reference = ConanFileReference.loads( "Hello0/0.1@lasote/stable") self.files = cpp_hello_conan_files("Hello0", "0.1", build=False) self.conan = TestClient() self.conan.save(self.files) self.conan.run("export lasote/stable") def consumer_with_flat_requirement_test(self): # We want to reuse exported Hello0/0.1@lasote/stable tmp_dir = temp_folder() req_file = '''[requires] Hello0/0.1@lasote/stable # My req comment [generators] gcc # I need this generator for.. cmake visual_studio xcode ''' save(os.path.join(tmp_dir, CONANFILE_TXT), req_file) self.conan.current_folder = tmp_dir # Install requirements self.conan.run('install --build missing') self.assertEqual( sorted([ CONANFILE_TXT, BUILD_INFO_GCC, BUILD_INFO_CMAKE, BUILD_INFO_VISUAL_STUDIO, BUILD_INFO_XCODE, CONANINFO ]), sorted(os.listdir(tmp_dir))) cmake = load(os.path.join(tmp_dir, BUILD_INFO_CMAKE)) gcc = load(os.path.join(tmp_dir, BUILD_INFO_GCC)) self.assertIn("CONAN_INCLUDE_DIRS", cmake) self.assertIn("CONAN_LIB_DIRS", cmake) self.assertIn("CONAN_LIBS", cmake) self.assertIn("CONAN_INCLUDE_DIRS", cmake) self.assertIn("CONAN_LIB_DIRS", cmake) self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", cmake) self.assertIn("-L", gcc) self.assertIn("-l", gcc) self.assertIn("-I", gcc) self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", gcc) # CHECK VISUAL STUDIO GENERATOR from xml.dom import minidom xmldoc = minidom.parse(os.path.join(tmp_dir, BUILD_INFO_VISUAL_STUDIO)) definition_group = xmldoc.getElementsByTagName( 'ItemDefinitionGroup')[0] compiler = definition_group.getElementsByTagName("ClCompile")[0] include_dirs = compiler.getElementsByTagName( "AdditionalIncludeDirectories")[0].firstChild.data definitions = compiler.getElementsByTagName( "PreprocessorDefinitions")[0].firstChild.data linker = definition_group.getElementsByTagName("Link")[0] lib_dirs = linker.getElementsByTagName( "AdditionalLibraryDirectories")[0].firstChild.data libs = linker.getElementsByTagName( "AdditionalDependencies")[0].firstChild.data package_id = os.listdir(self.conan.paths.packages( self.conan_reference))[0] package_ref = PackageReference(self.conan_reference, package_id) package_paths = self.conan.paths.package(package_ref).replace( "\\", "/") expected_lib_dirs = os.path.join(package_paths, "lib").replace("\\", "/") expected_include_dirs = os.path.join(package_paths, "include").replace("\\", "/") self.assertIn(expected_lib_dirs, lib_dirs) self.assertEquals("helloHello0.lib;%(AdditionalDependencies)", libs) self.assertEquals("%(PreprocessorDefinitions)", definitions) self.assertIn(expected_include_dirs, include_dirs) # CHECK XCODE GENERATOR xcode = load(os.path.join(tmp_dir, BUILD_INFO_XCODE)) self.assertIn( 'LIBRARY_SEARCH_PATHS = $(inherited) "%s"' % expected_lib_dirs, xcode) self.assertIn( 'HEADER_SEARCH_PATHS = $(inherited) "%s"' % expected_include_dirs, xcode) self.assertIn("GCC_PREPROCESSOR_DEFINITIONS = $(inherited)", xcode) self.assertIn("OTHER_CFLAGS = $(inherited)", xcode) self.assertIn("OTHER_CPLUSPLUSFLAGS = $(inherited)", xcode)
def reuse_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"]) self._export_upload( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"]) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"]) # Add some stuff to base project conanfile to test further the individual # flags in build_info (txt, cmake) files content = files3[CONANFILE] content = content.replace("generators =", 'generators = "txt",') content = content.replace( "def build(self):", "def build(self):\n" " self.output.info('INCLUDE %s' " "% self.deps_cpp_info['Hello0'].include_paths)") files3[CONANFILE] = content client.save(files3) client.run("install . --build missing") client.run("build .") self._check_individual_deps(client) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1) client.save(files3, clean_first=True) client.run("install . --build missing") client.run("build .") client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client.user_io.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload Hello3/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello0/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"]) client2.save(files3) client2.run("install . --build missing") client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client2.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1) client2.save(files3, clean_first=True) client2.run("install . --build missing") client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client2.user_io.out).splitlines()[-6:])
def local_test(self): client = TestClient() # No conans created client.run("search") output = client.user_io.out self.assertIn('There are no packages', output) # Conans with and without packages created root_folder1 = 'Hello/1.4.10/fenix/testing' root_folder2 = 'helloTest/1.4.10/fenix/stable' root_folder3 = 'Bye/0.14/fenix/testing' root_folder4 = 'NodeInfo/1.0.2/fenix/stable' root_folder5 = 'MissFile/1.0.2/fenix/stable' client.save( { "Empty/1.10/fake/test/reg/fake.txt": "//", "%s/%s/d91960d4c06b38/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO): conan_vars2, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO): conan_vars3, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO): conan_vars4, "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"): "Hello" }, client.paths.store) client.run("search -v") self.assertEqual( """Existing packages info: Bye/0.14@fenix/testing Package_ID: e4f7vdwcv4w55d [options] HAVE_TESTS=True USE_CONFIG=False [settings] os=Darwin [requirements] Empty/1.10@fake/test There are no packages Hello/1.4.10@fenix/testing Package_ID: d91960d4c06b38 [options] use_Qt=True [settings] arch=x64 os=Windows version=8.1 [requirements] MissFile/1.0.2@fenix/stable There are no packages NodeInfo/1.0.2@fenix/stable Package_ID: e4f7vdwcv4w55d [options] language=1 [settings] arch=x86_64 compiler=gcc os=Windows [requirements] helloTest/1.4.10@fenix/stable Package_ID: a44f541cd44w57 [options] use_OpenGL=True [settings] arch=x64 os=Ubuntu version=15.04 [requirements] """, client.user_io.out) client.run("search") self.assertEqual( """Existing packages info: Bye/0.14@fenix/testing Package_ID: e4f7vdwcv4w55d (Darwin) Empty/1.10@fake/test There are no packages Hello/1.4.10@fenix/testing Package_ID: d91960d4c06b38 (x64, Windows, 8.1) MissFile/1.0.2@fenix/stable There are no packages NodeInfo/1.0.2@fenix/stable Package_ID: e4f7vdwcv4w55d (x86_64, gcc, Windows) helloTest/1.4.10@fenix/stable Package_ID: a44f541cd44w57 (x64, Ubuntu, 15.04) """, client.user_io.out) client.run("search Bye/* -v") self.assertEqual( """Existing packages info: Bye/0.14@fenix/testing Package_ID: e4f7vdwcv4w55d [options] HAVE_TESTS=True USE_CONFIG=False [settings] os=Darwin [requirements] """, client.user_io.out) # bad pattern client.run("search OpenCV/*") self.assertIn("There are no packages matching the OpenCV/* pattern", client.user_io.out) # pattern case-sensitive client.run("search hello* --case-sensitive -v") self.assertIn("helloTest/1.4.10@fenix/stable", client.user_io.out) self.assertNotIn("Empty/1.10@fake/test", client.user_io.out) self.assertNotIn("Hello/1.4.10@fenix/testing", client.user_io.out) self.assertNotIn("NodeInfo/1.0.2@fenix/stable", client.user_io.out) # Package search client.run("search -p e4*") self.assertIn( '''Bye/0.14@fenix/testing Package_ID: e4f7vdwcv4w55d (Darwin) NodeInfo/1.0.2@fenix/stable Package_ID: e4f7vdwcv4w55d (x86_64, gcc, Windows)''', client.user_io.out) client.run("search -p d9") self.assertIn( '''Hello/1.4.10@fenix/testing Package_ID: d91960d4c06b38 (x64, Windows, 8.1)''', client.user_io.out) client.run("search Bye/0.14@fenix/testing -p e4*") self.assertNotIn('''NodeInfo/1.0.2@fenix/stable''', client.user_io.out)
class DiamondTest(unittest.TestCase): def setUp(self): test_server = TestServer( [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) def _export_upload(self, name, version=None, deps=None, use_cmake=True): files = cpp_hello_conan_files(name, version, deps, need_patch=True, use_cmake=use_cmake) conan_ref = ConanFileReference(name, version, "lasote", "stable") self.conan.save(files, clean_first=True) self.conan.run("export lasote/stable") self.conan.run("upload %s" % str(conan_ref)) def _check_individual_deps(self, client): self.assertIn("INCLUDE [", client.user_io.out) self.assertIn(".conan/data/Hello0/0.1/lasote/stable", client.user_io.out) build_file = os.path.join(client.current_folder, BUILD_INFO) content = load(build_file) cmakebuildinfo = load( os.path.join(client.current_folder, BUILD_INFO_CMAKE)) self.assertIn( "set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0", cmakebuildinfo) self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)", cmakebuildinfo) deps_cpp_info = DepsCppInfo.loads(content) self.assertEqual(len(deps_cpp_info.include_paths), 4) for dep in ("Hello3", "Hello2", "Hello1", "Hello0"): self.assertEqual(len(deps_cpp_info[dep].include_paths), 1) self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1) self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep]) build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE) content = load(build_file) for dep in ("Hello3", "Hello2", "Hello1", "Hello0"): self.assertEqual(len(deps_cpp_info[dep].include_paths), 1) self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content) self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep), content) def diamond_cmake_test(self): self._diamond_test(use_cmake=True) def diamond_default_test(self): self._diamond_test(use_cmake=False) def diamond_mingw_test(self): if platform.system() != "Windows": return not_env = os.system("g++ --version > nul") if not_env != 0: logger.error("This platform does not support G++ command") return install = "install -s compiler=gcc -s compiler.libcxx=libstdc++ -s compiler.version=4.9" self._diamond_test(install=install, use_cmake=False) def _diamond_test(self, install="install", use_cmake=True): def wait_until_removed(folder): latest_exception = None for _ in range(50): # Max 5 seconds time.sleep(0.1) try: shutil.rmtree(folder) break except Exception as e: latest_exception = e else: raise Exception("Could remove folder %s: %s" % (folder, latest_exception)) self._export_upload("Hello0", "0.1", use_cmake=use_cmake) self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake) self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake) self._export_upload( "Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"], use_cmake=use_cmake) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], use_cmake=use_cmake) # Add some stuff to base project conanfile to test further the individual # flags in build_info (txt, cmake) files content = files3[CONANFILE] content = content.replace("generators =", 'generators = "txt",') content = content.replace( "def build(self):", "def build(self):\n" " self.output.info('INCLUDE %s' " "% self.deps_cpp_info['Hello0'].include_paths)") files3[CONANFILE] = content client.save(files3) client.run("%s . --build missing" % install) client.run("build .") self._check_individual_deps(client) command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1, use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') wait_until_removed(client.current_folder) client.save(files3) client.run("%s . --build missing" % install) client.run("build .") client.runner(command, cwd=client.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client.user_io.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload Hello3/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello0/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') client2.save(files3) client2.run("%s . --build missing" % install) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(client2.user_io.out).splitlines()[-6:]) files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"], language=1, use_cmake=use_cmake) files3[CONANFILE] = files3[CONANFILE].replace("generators =", 'generators = "txt",') wait_until_removed(client2.current_folder) client2.save(files3) client2.run("%s . --build missing" % install) client2.run("build .") self.assertNotIn("libhello0.a", client2.user_io.out) self.assertNotIn("libhello1.a", client2.user_io.out) self.assertNotIn("libhello2.a", client2.user_io.out) self.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.assertEqual([ 'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0' ], str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self): client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files[CONANFILE] = files[CONANFILE].replace("build", "build2") client.save(files) client.run("export lasote/stable") client.run("install %s --build missing" % str(conan_reference)) self.assertTrue(os.path.exists(client.paths.builds(conan_reference))) self.assertTrue(os.path.exists(client.paths.packages(conan_reference))) # Upload client.run("upload %s --all" % str(conan_reference)) # Now from other "computer" install the uploaded conans with same options (nothing) other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build missing" % str(conan_reference)) self.assertFalse( os.path.exists(other_conan.paths.builds(conan_reference))) self.assertTrue( os.path.exists(other_conan.paths.packages(conan_reference))) # Now from other "computer" install the uploaded conans with same options (nothing) other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build" % str(conan_reference)) self.assertTrue( os.path.exists(other_conan.paths.builds(conan_reference))) self.assertTrue( os.path.exists(other_conan.paths.packages(conan_reference))) # Use an invalid pattern and check that its not builded from source other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build HelloInvalid" % str(conan_reference)) self.assertFalse( os.path.exists(other_conan.paths.builds(conan_reference))) self.assertTrue( os.path.exists(other_conan.paths.packages(conan_reference))) # Use another valid pattern and check that its not builded from source other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build HelloInvalid -b Hello" % str(conan_reference)) self.assertTrue( os.path.exists(other_conan.paths.builds(conan_reference))) self.assertTrue( os.path.exists(other_conan.paths.packages(conan_reference))) # Now even if the package is in local store, check that's rebuilded other_conan.run("install %s -b Hello*" % str(conan_reference)) self.assertIn("Copying sources to build folder", other_conan.user_io.out) other_conan.run("install %s" % str(conan_reference)) self.assertNotIn("Copying sources to build folder", other_conan.user_io.out)
class MyBuildInfo(unittest.TestCase): def setUp(self): test_server = TestServer(users={"lasote": "lasote"}) test_server2 = TestServer(users={"lasote": "lasote"}) self.servers = {"default": test_server, "alternative": test_server2} self.client = TestClient(servers=self.servers, users={ "default": [("lasote", "lasote")], "alternative": [("lasote", "lasote")] }) def test_only_download(self): files = cpp_hello_conan_files("Hello", "1.0", build=False) self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload '*' -c --all") trace_file = os.path.join(temp_folder(), "conan_trace.log") self.client.run("remove '*' -f") with tools.environment_append({"CONAN_TRACE_FILE": trace_file}): self.client.run("install Hello/1.0@lasote/stable --build") data = get_build_info(trace_file).serialize() self.assertEquals(len(data["modules"]), 1) self.assertEquals(data["modules"][0]["id"], "DownloadOnly") self.assertEquals(len(data["modules"][0]["artifacts"]), 0) self.assertEquals(len(data["modules"][0]["dependencies"]), 3) def test_json(self): # Upload to server Hello1 => Hello0 and Hello2 => Hello0 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") files = cpp_hello_conan_files("Hello2", "1.0", deps=["Hello0/1.0@lasote/stable"], build=False) self.client.save(files) self.client.run("export lasote/stable") self.client.run("install Hello1/1.0@lasote/stable --build missing") self.client.run("install Hello2/1.0@lasote/stable --build missing") self.client.run("upload '*' -c --all") # Remove all from local cache self.client.run("remove '*' -f") # Now activate logs and install both Hello1 and Hello2 trace_file = os.path.join(temp_folder(), "conan_trace.log") with tools.environment_append({"CONAN_TRACE_FILE": trace_file}): self.client.run("install Hello0/1.0@lasote/stable") self.client.run("upload '*' -c --all") data = get_build_info(trace_file).serialize() # Only uploaded 2 modules, the Hello0 recipe and the Hello0 package # without dependencies self.assertEquals(len(data["modules"]), 2) self.assertEquals(len(data["modules"][0]["dependencies"]), 0) self.assertEquals(len(data["modules"][0]["dependencies"]), 0) self.assertEquals(len(data["modules"][0]["artifacts"]), 3) # Now upload the rest of them self.client.run("install Hello1/1.0@lasote/stable --build missing") self.client.run("install Hello2/1.0@lasote/stable --build missing") self.client.run("upload '*' -c --all") data = get_build_info(trace_file).serialize() self.assertEquals(len(data["modules"]), 6) for mod_name in [ "Hello1/1.0@lasote/stable", "Hello2/1.0@lasote/stable" ]: module = _get_module(data, mod_name) self.assertEquals(3, len(module["dependencies"])) self.assertEquals(3, len(module["artifacts"])) for dep in module["dependencies"]: self.assertTrue( dep["id"].startswith("Hello0/1.0@lasote/stable")) def test_invalid_tracer(self): trace_file = os.path.join(temp_folder(), "conan_trace.log") save(trace_file, "invalid contents") with self.assertRaisesRegexp(Exception, "INVALID TRACE FILE!"): get_build_info(trace_file).serialize() 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 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")