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_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_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)
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())
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 test_conanfile_not_found(self): """If package is OpenSSL is not openssl""" test_server = TestServer() self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]}) files = cpp_hello_conan_files("Hello0", "0.1") self.client.save(files) self.client.run("export lasote/stable") self.assertRaises(Exception, self.client.run, "install hello0/0.1@lasote/stable") self.client.run("install Hello0/0.1@lasote/stable --build missing") self.client.run("upload Hello0/0.1@lasote/stable") # Now with requirements.txt (bug in server) self.client = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]}) self.client.save({"conanfile.txt": "[requires]\nHello0/0.1@lasote/stable\n[generators]\ntxt"}) self.client.run("install --build missing ") build_info = load(os.path.join(self.client.current_folder, "conanbuildinfo.txt")) self.assertIn("helloHello0", build_info) self.client = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]}) self.client.save({"conanfile.txt": "[requires]\nhello0/0.1@lasote/stable\n[generators]\ntxt"}) self.assertRaises(Exception, self.client.run, "install")
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_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 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 test_command_user(self): """ Test that the user can be shown and changed, and it is reflected in the user cache localdb """ client = TestClient() client.run('user', ignore_error=True) self.assertIn("ERROR: No default remote defined", client.user_io.out)
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 list_test(self): client = TestClient() create_profile(client.client_cache.profiles_path, "profile1") create_profile(client.client_cache.profiles_path, "profile2") create_profile(client.client_cache.profiles_path, "profile3") client.run("profile list") self.assertEqual(set(["profile1", "profile2", "profile3"]), set(str(client.user_io.out).splitlines()))
class InfoTest(unittest.TestCase): def _create(self, number, version, deps=None, export=True): files = cpp_hello_conan_files(number, version, deps) # To avoid building files = {CONANFILE: files[CONANFILE].replace("build(", "build2(")} self.client.save(files, clean_first=True) if export: self.client.run("export lasote/stable") expected_output = textwrap.dedent( """\ WARN: Conanfile doesn't have 'url'. It is recommended to add your repo URL as attribute WARN: Conanfile doesn't have a 'license'. It is recommended to add the package license as attribute""") self.assertIn(expected_output, self.client.user_io.out) files[CONANFILE] = files[CONANFILE].replace('version = "0.1"', 'version = "0.1"\n' ' url= "myurl"\n' ' license = "MIT"') self.client.save(files) if export: self.client.run("export lasote/stable") self.assertNotIn("WARN: Conanfile doesn't have 'url'", self.client.user_io.out) def reuse_test(self): self.client = TestClient() self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("info") expected_output = textwrap.dedent( """\ Hello2/0.1@PROJECT URL: myurl License: MIT Requires: Hello1/0.1@lasote/stable Hello0/0.1@lasote/stable Remote: None URL: myurl License: MIT Updates: You have the latest version (None) Required by: Hello1/0.1@lasote/stable Hello1/0.1@lasote/stable Remote: None URL: myurl License: MIT Updates: You have the latest version (None) Required by: Hello2/0.1@PROJECT Requires: Hello0/0.1@lasote/stable""") self.assertIn(expected_output, self.client.user_io.out)
def local_source_test(self): conanfile = """ from conans import ConanFile from conans.util.files import save class ConanLib(ConanFile): def source(self): self.output.info("Running source!") err save("file1.txt", "Hello World") """ # First, failing source() client = TestClient() client.save({CONANFILE: conanfile}) client.run("source .", ignore_error=True) self.assertIn("PROJECT: Running source!", client.user_io.out) self.assertIn("ERROR: PROJECT: Error in source() method, line 9", client.user_io.out) # Fix the error and repeat client.save({CONANFILE: conanfile.replace("err", "")}) client.run("source .") self.assertIn("PROJECT: Configuring sources in", client.user_io.out) self.assertIn("PROJECT: WARN: Your previous source command failed", client.user_io.out) self.assertIn("PROJECT: Running source!", client.user_io.out) self.assertEqual("Hello World", load(os.path.join(client.current_folder, "file1.txt")))
def 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 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 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 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 check_versions_test(self): # Client deprecated self.servers = {"default": self._get_server(10, 5)} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, client_version=4) errors = self.client.run("search something -r default", 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) # Not Errors # Client outdated self.servers = {"default": self._get_server(10, 4)} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, client_version=4) errors = self.client.run("search something -r default", ignore_error=False) self.assertIn(" A new conan version (v10) is available in current remote. Please, " "upgrade conan client to avoid deprecation.", self.client.user_io.out) self.assertFalse(errors) # Not Errors # Client ok self.servers = {"default": self._get_server(10, 4)} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, client_version=10) errors = self.client.run("search something -r default", ignore_error=False) self.assertNotIn("conan client", self.client.user_io.out) self.assertFalse(errors) # Not Errors # Server outdated self.servers = {"default": self._get_server(1, 1)} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, client_version=10, min_server_compatible_version=1) errors = self.client.run("search something -r default", ignore_error=True) self.assertNotIn("The conan remote version is outdated (v1). Please, contact" " with your system administrator and upgrade the remote to" " avoid deprecation", self.client.user_io.out) self.assertFalse(errors) # No Errors # Server deprecated self.servers = {"default": self._get_server(1, 1)} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, client_version=10, min_server_compatible_version=2) errors = self.client.run("search something -r default", ignore_error=True) self.assertIn("Your conan's client is incompatible with this remote." " The server is deprecated. " "(v1). Please, contact with your system administrator and" " upgrade the server.", self.client.user_io.out) self.assertTrue(errors) # Errors
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 new_without_test(self): """ Test that the user can be shown and changed, and it is reflected in the user cache localdb """ client = TestClient() client.run('new MyPackage/1.3@myuser/testing') root = client.current_folder self.assertTrue(os.path.exists(os.path.join(root, "conanfile.py"))) self.assertFalse(os.path.exists(os.path.join(root, "test_package/conanfile.py"))) self.assertFalse(os.path.exists(os.path.join(root, "test_package/CMakeLists.txt"))) self.assertFalse(os.path.exists(os.path.join(root, "test_package/example.cpp")))
def duplicate_requires_test(self): client = TestClient() conanfile = ''' [requires] foo/0.1@user/testing foo/0.2@user/testing ''' files = {"conanfile.txt": conanfile} client.save(files) error = client.run("install . --build", ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: Duplicated requirement", client.user_io.out)
def _export_upload(self, name, version=None, deps=None): conan = TestClient(servers=self.servers, users=[("lasote", "mypass")]) files = cpp_hello_conan_files(name, version, deps, static=self.static) conan_ref = ConanFileReference(name, version, "lasote", "stable") conan.save(files, clean_first=True) conan.run("export lasote/stable") conan.run("install '%s' -o static=False -o language=0 --build missing" % str(conan_ref)) conan.run("upload %s --all" % str(conan_ref)) rmdir(conan.current_folder) shutil.rmtree(conan.paths.store, ignore_errors=True)
def copy_error_test(self): client = TestClient() conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" exports = "*" def package(self): self.copy2("*.h", dst="include", src=["include","platform"]) ''' files = {"conanfile.py": conanfile, "test.txt": "Hello world"} client.save(files) client.run("export lasote/stable") client.run("install Hello/0.1@lasote/stable --build", ignore_error=True) self.assertIn( "Hello/0.1@lasote/stable: Error in package() method, line 9", client.user_io.out) self.assertIn( 'self.copy2("*.h", dst="include", src=["include","platform"]', client.user_io.out) self.assertIn("'HelloConan' object has no attribute 'copy2'", client.user_io.out)
def test_complex_deps_propagation_override(self): client = TestClient() # Try injecting some package level ENV in the install, but without priority self._export(client, "A", [], {}, { "VAR1": "900", "VAR2": "23", "VAR3": "-23" }) self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"}) self._export(client, "C", ["B"], {"VAR3": "bestvalue"}, {"VAR1": "700"}) client.save({"conanfile.py": reuse}) client.run("install . --build missing -e LIB_B:VAR3=override") self.assertIn("Building LIB_A, VAR1:None", client.user_io.out) self.assertIn("Building LIB_A, VAR2:None", client.user_io.out) self.assertIn("Building LIB_A, VAR3:None", client.user_io.out) self.assertIn("Building LIB_B, VAR1:900", client.user_io.out) self.assertIn("Building LIB_B, VAR2:23", client.user_io.out) self.assertIn("Building LIB_B, VAR3:override", client.user_io.out) self.assertIn("Building LIB_C, VAR1:800", client.user_io.out) self.assertIn("Building LIB_C, VAR2:24", client.user_io.out) self.assertIn("Building LIB_C, VAR3:-23", client.user_io.out) client.run("build") self.assertInSep("VAR1=>700:800:900", client.user_io.out) self.assertInSep("VAR2=>24:23*", client.user_io.out) self.assertInSep("VAR3=>bestvalue*", client.user_io.out)
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 local_system_requirements_test(self): client = TestClient() files = {'conanfile.py': base_conanfile.replace("%GLOBAL%", "")} client.save(files) client.run("install .") self.assertIn("*+Running system requirements+*", client.user_io.out) files = { 'conanfile.py': base_conanfile.replace("%GLOBAL%", "self.run('fake command!')") } client.save(files) with self.assertRaisesRegexp(Exception, "Command failed"): client.run("install .")
def new_without_test(self): """ Test that the user can be shown and changed, and it is reflected in the user cache localdb """ client = TestClient() client.run('new MyPackage/1.3@myuser/testing') root = client.current_folder self.assertTrue(os.path.exists(os.path.join(root, "conanfile.py"))) self.assertFalse( os.path.exists(os.path.join(root, "test_package/conanfile.py"))) self.assertFalse( os.path.exists(os.path.join(root, "test_package/CMakeLists.txt"))) self.assertFalse( os.path.exists(os.path.join(root, "test_package/example.cpp")))
def setUp(self): test_server = TestServer() self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self.new_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1", build=False) self.client.save(files) self.client.run("export lasote/stable") self.client.run("install Hello0/0.1@lasote/stable --build missing") self.client.run("upload Hello0/0.1@lasote/stable --all")
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") 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) 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 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 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)
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.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 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': 'c90fe9d800e1f48c8ea0999e8e5929d8', 'source/executable': '68b329da9893e34099c7d8ad5cb9c940', 'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'} self.assertEqual(expected_sums, manif.file_sums)
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_override_simple2(self): client = TestClient() # Try injecting some package level ENV in the install self._export(client, "A", [], {"VAR3": "-23"}, { "VAR1": "900", "VAR2": "23" }) self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"}) self._export(client, "C", ["B"], {}, {"VAR1": "700"}) client.save({"conanfile.py": reuse}) client.run("install . --build missing -e VAR3=override") self.assertIn("Building LIB_A, VAR1:None", client.user_io.out) self.assertIn("Building LIB_A, VAR2:None", client.user_io.out) self.assertIn("Building LIB_A, VAR3:override", client.user_io.out) self.assertIn("Building LIB_B, VAR1:900", client.user_io.out) self.assertIn("Building LIB_B, VAR2:23", client.user_io.out) self.assertIn("Building LIB_B, VAR3:override", client.user_io.out) self.assertIn("Building LIB_C, VAR1:800", client.user_io.out) self.assertIn("Building LIB_C, VAR2:24", client.user_io.out) self.assertIn("Building LIB_C, VAR3:override", client.user_io.out) client.run("build") self.assertInSep("VAR1=>700:800:900", client.user_io.out) self.assertInSep("VAR2=>24:23*", client.user_io.out) self.assertInSep("VAR3=>override*", client.user_io.out)
def test_error_patch(self): file_content = base_conanfile + ''' def build(self): patch_content = "some corrupted patch" patch(patch_string=patch_content, output=self.output) ''' client = TestClient() client.save({"conanfile.py": file_content}) error = client.run("build", ignore_error=True) self.assertTrue(error) self.assertIn("patch: error: no patch data found!", client.user_io.out) self.assertIn("ERROR: Failed to parse patch: string", client.user_io.out)
def basic_test(self): client = TestClient() base = ''' from conans import ConanFile from conans.util.files import load, save import os class ConanLib(ConanFile): name = "lib" version = "0.1" short_paths = True def source(self): extra_path = "1/" * 108 os.makedirs(extra_path) myfile = os.path.join(extra_path, "myfile.txt") # print("File length ", len(myfile)) save(myfile, "Hello extra path length") def build(self): extra_path = "1/" * 108 myfile = os.path.join(extra_path, "myfile2.txt") # print("File length ", len(myfile)) save(myfile, "Hello2 extra path length") def package(self): self.copy("*.txt", keep_path=False) ''' files = {"conanfile.py": base} client.save(files) client.run("export user/channel") client.run("install lib/0.1@user/channel --build") package_ref = PackageReference.loads("lib/0.1@user/channel:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") package_folder = client.client_cache.package(package_ref) file1 = load(os.path.join(package_folder, "myfile.txt")) self.assertEqual("Hello extra path length", file1) file2 = load(os.path.join(package_folder, "myfile2.txt")) self.assertEqual("Hello2 extra path length", file2) if platform.system() == "Windows": conan_ref = ConanFileReference.loads("lib/0.1@user/channel") source_folder = client.client_cache.source(conan_ref) link_source = load(os.path.join(source_folder, ".conan_link")) self.assertTrue(os.path.exists(link_source)) build_folder = client.client_cache.build(package_ref) link_build = load(os.path.join(build_folder, ".conan_link")) self.assertTrue(os.path.exists(link_build)) client.run("remove lib* -f") self.assertFalse(os.path.exists(link_source)) self.assertFalse(os.path.exists(link_build))
def diamond_build_order_test(self): self.client = TestClient() self._create("LibA", "0.1") self._create("Dev1", "0.1") self._create("LibE", "0.1", deps_dev=["Dev1/0.1@lasote/stable"]) self._create("LibF", "0.1") self._create("LibG", "0.1") self._create("Dev2", "0.1", deps=["LibG/0.1@lasote/stable"]) self._create("LibB", "0.1", ["LibA/0.1@lasote/stable", "LibE/0.1@lasote/stable"]) self._create("LibC", "0.1", ["LibA/0.1@lasote/stable", "LibF/0.1@lasote/stable"], deps_dev=["Dev2/0.1@lasote/stable"]) self._create("LibD", "0.1", ["LibB/0.1@lasote/stable", "LibC/0.1@lasote/stable"], export=False) self.client.run("info -bo=LibA/0.1@lasote/stable") self.assertIn("[LibA/0.1@lasote/stable], " "[LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=LibB/0.1@lasote/stable") self.assertIn("[LibB/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=LibE/0.1@lasote/stable") self.assertIn("[LibE/0.1@lasote/stable], [LibB/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=LibF/0.1@lasote/stable") self.assertIn("[LibF/0.1@lasote/stable], [LibC/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=Dev1/0.1@lasote/stable") self.assertEqual("\n", self.client.user_io.out) self.client.run("info --scope=LibE:dev=True -bo=Dev1/0.1@lasote/stable") self.assertIn("[Dev1/0.1@lasote/stable], [LibE/0.1@lasote/stable], " "[LibB/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=LibG/0.1@lasote/stable") self.assertEqual("\n", self.client.user_io.out) self.client.run("info --scope=LibC:dev=True -bo=LibG/0.1@lasote/stable") self.assertIn("[LibG/0.1@lasote/stable], [Dev2/0.1@lasote/stable], " "[LibC/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info --build_order=ALL") self.assertIn("[LibA/0.1@lasote/stable, LibE/0.1@lasote/stable, LibF/0.1@lasote/stable], " "[LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info --build_order=ALL --scope=ALL:dev=True") self.assertIn("[Dev1/0.1@lasote/stable, LibG/0.1@lasote/stable], " "[Dev2/0.1@lasote/stable, LibA/0.1@lasote/stable, LibE/0.1@lasote/stable, " "LibF/0.1@lasote/stable], [LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]", self.client.user_io.out)
def failure_test(self): base = ''' from conans import ConanFile from conans.util.files import load, save import os class ConanLib(ConanFile): name = "lib" version = "0.1" short_paths = True exports = "*" generators = "cmake" def build(self): self.output.info("%s/%s" % (self.conanfile_directory, self.name)) # print os.listdir(self.conanfile_directory) path = os.path.join(self.conanfile_directory, self.name) # print "PATH EXISTS ", os.path.exists(path) # print os.listdir(path) path = os.path.join(path, "myfile.txt") # print "PATH EXISTS ", os.path.exists(path) def package(self): self.copy("*.txt", keep_path=False) ''' client = TestClient() files = {"conanfile.py": base, "lib/myfile.txt": "Hello world!"} client.save(files) client.run("export user/channel") client.run("install lib/0.1@user/channel --build") # print client.paths.store package_ref = PackageReference.loads( "lib/0.1@user/channel:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") package_folder = client.client_cache.package(package_ref, short_paths=None) file1 = load(os.path.join(package_folder, "myfile.txt")) self.assertEqual("Hello world!", file1) client.run("install lib/0.1@user/channel --build") package_ref = PackageReference.loads( "lib/0.1@user/channel:" "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9") package_folder = client.client_cache.package(package_ref, short_paths=None) file1 = load(os.path.join(package_folder, "myfile.txt")) self.assertEqual("Hello world!", file1)
def shared_folder_test(self): hello_files = cpp_hello_conan_files("Hello") client = TestClient() client.save(hello_files) client.run("export lasote/stable") path = os.path.join(client.storage_folder, "Hello/0.1/lasote/stable") self.assertTrue(os.path.exists(path)) client.run("export lasote2/stable") path = os.path.join(client.storage_folder, "Hello/0.1/lasote2/stable") self.assertTrue(os.path.exists(path)) client.run("remove Hello/0.1@lasote/stable -f") path = os.path.join(client.storage_folder, "Hello/0.1/lasote") self.assertFalse(os.path.exists(path)) path = os.path.join(client.storage_folder, "Hello/0.1") self.assertTrue(os.path.exists(path))
def test_copy_command(self): client = TestClient(users=[("lasote", "mypass")]) self._export_some_packages(client) # Copy all packages new_reference = ConanFileReference.loads("Hello0/0.1@pepe/testing") client.run("copy Hello0/0.1@lasote/stable pepe/testing --all --force") p1 = client.paths.packages(new_reference) packages = os.listdir(p1) self.assertEquals(len(packages), 3) # Copy just one rmdir(p1) client.run("copy Hello0/0.1@lasote/stable pepe/testing -p %s --force" % packages[0]) packages = os.listdir(p1) self.assertEquals(len(packages), 1)
def uploaded_chain_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files2 = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], static=True) client.save(files2) client.run("install . --build missing") client.run("build .") command = os.sep.join([".", "bin", "say_hello"]) client.runner(command, cwd=client.current_folder) self.assertEqual(['Hello Hello2', 'Hello Hello1', 'Hello Hello0'], str(client.user_io.out).splitlines()[-3:])
def setUp(self): self.client = TestClient() # 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 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' self.client.save( { "Empty/1.10/fake/test/reg/fake.txt": "//", "%s/%s/WindowsPackageSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1, "%s/%s/PlatformIndependantSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO): conan_vars1b, "%s/%s/LinuxPackageSHA/%s" % (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(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 _export_upload(self, name, version=None, deps=None): conan = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]}) dll_export = conan.default_compiler_visual_studio files = cpp_hello_conan_files(name, version, deps, static=False, dll_export=dll_export) conan_ref = ConanFileReference(name, version, "lasote", "stable") conan.save(files, clean_first=True) conan.run("export lasote/stable") conan.run("install '%s' --build missing" % str(conan_ref)) conan.run("upload %s --all" % str(conan_ref)) rmdir(conan.current_folder) shutil.rmtree(conan.paths.store, ignore_errors=True)
class BasicBuildTest(unittest.TestCase): def setUp(self): self.client = TestClient() self.command = os.sep.join([".", "bin", "say_hello"]) def _build(self, cmd, static, pure_c, use_cmake, lang): dll_export = self.client.default_compiler_visual_studio and not static files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export, pure_c=pure_c, use_cmake=use_cmake) self.client.save(files, clean_first=True) self.client.run(cmd) time.sleep(1) # necessary so the conaninfo.txt is flushed to disc self.client.run('build') ld_path = ("LD_LIBRARY_PATH=$(pwd)" if not static and not platform.system() == "Windows" else "") self.client.runner("%s %s" % (ld_path, self.command), cwd=self.client.current_folder) msg = "Hello" if lang == 0 else "Hola" self.assertIn("%s Hello0" % msg, self.client.user_io.out) conan_info_path = os.path.join(self.client.current_folder, CONANINFO) conan_info = ConanInfo.loads(load(conan_info_path)) self.assertTrue(conan_info.full_options.language == lang) if static: self.assertTrue(conan_info.full_options.static) else: self.assertFalse(conan_info.full_options.static) def build_cmake_test(self): for pure_c in (False, True): for cmd, 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)]: self._build(cmd, static, pure_c, use_cmake=True, lang=lang) def build_default_test(self): "build default (gcc in nix, VS in win)" for pure_c in (False, True): for cmd, 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)]: self._build(cmd, static, pure_c, use_cmake=False, lang=lang) def build_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" for pure_c in (False, True): for cmd, 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)]: self._build(cmd, static, pure_c, use_cmake=False, lang=lang)
def reuse_test(self): self.client = TestClient() self._create("Hello0", "0.1") self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"]) self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False) self.client.run("info") expected_output = textwrap.dedent( """\ Hello2/0.1@PROJECT URL: myurl License: MIT Requires: Hello1/0.1@lasote/stable Hello0/0.1@lasote/stable Remote: None URL: myurl License: MIT Updates: You have the latest version (None) Required by: Hello1/0.1@lasote/stable Hello1/0.1@lasote/stable Remote: None URL: myurl License: MIT Updates: You have the latest version (None) Required by: Hello2/0.1@PROJECT Requires: Hello0/0.1@lasote/stable""") self.assertIn(expected_output, self.client.user_io.out)
def _export_upload(self, name, version=None, deps=None): conan = TestClient(servers=self.servers, users=[("lasote", "mypass")]) dll_export = conan.default_compiler_visual_studio files = cpp_hello_conan_files(name, version, deps, static=False, dll_export=dll_export) conan_ref = ConanFileReference(name, version, "lasote", "stable") conan.save(files, clean_first=True) conan.run("export lasote/stable") conan.run("install '%s' --build missing" % str(conan_ref)) conan.run("upload %s --all" % str(conan_ref)) rmdir(conan.current_folder) shutil.rmtree(conan.paths.store, ignore_errors=True)
def duplicate_requires_py_test(self): client = TestClient() conanfile = ''' from conans import ConanFile class HelloConan(ConanFile): name = "Hello" version = "0.1" requires = "foo/0.1@user/testing", "foo/0.2@user/testing" ''' files = {"conanfile.py": conanfile} client.save(files) error = client.run("install . --build", ignore_error=True) self.assertTrue(error) self.assertIn("Error while initializing requirements. Duplicated requirement", client.user_io.out)
def _install_and_build(self, conanfile_text, runner=None): client = TestClient(runner=runner) files = {"conanfile.py": conanfile_text} test_folder = os.path.join(client.current_folder, "test_folder") self.assertFalse(os.path.exists(test_folder)) client.save(files) client.run("install") client.run("build") return client
def _export(self, name=0, version=None, deps=None): client = TestClient(servers=self.servers, users={"default": [("lu", "mypass")]}) self.clients[name] = client # Not necessary to actually build binaries files = cpp_hello_conan_files(name, version, deps, build=False) client.save(files, clean_first=True) client.run("export lu/st") client.run("upload %s/%s@lu/st" % (name, version))
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=[("lasote", "mypass")]) # Export and upload the conanfile self.conan_reference = ConanFileReference.loads( "hello0/0.1@lasote/stable") self.files = hello_conan_files(conan_reference=self.conan_reference, lang='go') self.conan.save(self.files, clean_first=True) self.conan.run("export lasote/stable") self.conan.run("upload %s" % str(self.conan_reference))
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 _get_client(self, requester=None): servers = {} # All can write (for avoid authentication until we mock user_io) self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"}) servers["default"] = self.test_server return TestClient(servers=servers, users={"default": [("lasote", "mypass")]}, requester_class=requester)
class PythonDiamondTest(unittest.TestCase): def setUp(self): self.client = TestClient() def _export_upload(self, name, version=None, deps=None): files = py_hello_conan_files(name, version, deps) self.client.save(files, clean_first=True) self.client.run("export lasote/stable") 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"]) files3 = py_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"]) self.client.save(files3, clean_first=True) self.client.run("install .") self.assertIn("Hello1/0.1@lasote/stable: Build stuff Hello0", self.client.user_io.out) self.assertIn("Hello2/0.1@lasote/stable: Build stuff Hello0", self.client.user_io.out) self.assertIn( " ".join([ "Hello3/0.1@lasote/stable: Build stuff Hello1", "Hello3/0.1@lasote/stable: Build stuff Hello0", "Hello3/0.1@lasote/stable: Build stuff Hello2", "Hello3/0.1@lasote/stable: Build stuff Hello0" ]), " ".join(str(self.client.user_io.out).splitlines())) if platform.system() == "Windows": command = "activate && python main.py" else: command = 'bash -c "source activate.sh && python main.py"' self.client.runner(command, cwd=self.client.current_folder) self.assertEqual([ 'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2', 'Hello Hello0' ], str(self.client.user_io.out).splitlines()[-6:])
def install_same_test(self): client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") error = client.run("install hello0/0.1@lasote/stable --build=missing", ignore_error=True) self._check(error, client)
def source_test(self): client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") error = client.run("source hello0/0.1@lasote/stable", ignore_error=True) self._check(error, client)
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 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])