def test_no_upload_remote(self): self.save_conanfile(self.conanfile) mp = ConanMultiPackager(username="******", out=self.output.write) mp.add({}, {}, {}) mp.run() self.assertIn("Upload skipped, not upload remote available", self.output)
def test_existing_upload_repo_by_name(self): self.api.remote_add( "upload_repo", "https://api.bintray.com/different/conan-community/conan") self.save_conanfile(self.conanfile) with tools.environment_append({ "CONAN_PASSWORD": "******", "CONAN_UPLOAD": "https://api.bintray.com/conan/" "conan-community/conan" }): mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager) mp.add({}, {}, {}) with self.assertRaisesRegexp(ConanException, "Wrong user or password"): mp.run() self.assertNotIn( "already exist, keeping the current remote and its name", self.output) repo = self.api.get_remote_by_name("upload_repo") self.assertEquals( repo.url, "https://api.bintray.com/conan/conan-community/conan")
def test_no_credentials_only_url(self): self.save_conanfile(self.conanfile) mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload="https://uilianr.jfrog.io/artifactory/api/conan/public-conan") mp.add({}, {}, {}) mp.run() self.assertIn("Upload skipped, credentials for remote 'my_upload_remote' " "not available", self.output) self.assertNotIn("Uploading packages", self.output)
def test_no_credentials_only_url(self): self.save_conanfile(self.conanfile) mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload="https://api.bintray.com/conan/conan-community/conan") mp.add({}, {}, {}) mp.run() self.assertIn("Upload skipped, credentials for remote 'my_upload_remote' " "not available", self.output) self.assertNotIn("Uploading packages", self.output)
def test_no_credentials_only_url_skip_check(self): self.save_conanfile(self.conanfile) with tools.environment_append({"CONAN_PASSWORD": "******", "CONAN_UPLOAD_ONLY_WHEN_STABLE": "1"}): mp = ConanMultiPackager(username="******", out=self.output.write, channel="my_channel", ci_manager=self.ci_manager, upload="https://api.bintray.com/conan/conan-community/conan",) mp.add({}, {}, {}) mp.run() self.assertIn("Skipping upload, not stable channel", self.output)
def test_remove_build_if(self): self.packager.add({ "arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "6" }) self.packager.add({ "arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "6" }) self.packager.add({ "arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "7" }) self.packager.add({ "arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "7" }) self.packager.remove_build_if( lambda build: build.settings["compiler.version"] == "6") packager_expected = ConanMultiPackager("lasote", "mychannel", runner=self.runner, conan_api=self.conan_api, reference="lib/1.0", ci_manager=self.ci_manager) packager_expected.add({ "arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "7" }) packager_expected.add({ "arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "7" }) self.assertEqual([tuple(a) for a in self.packager.items], packager_expected.items)
def test_no_credentials_but_skip(self): with tools.environment_append({"CONAN_NON_INTERACTIVE": "1"}): self.save_conanfile(self.conanfile) mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload=("https://uilianr.jfrog.io/artifactory/api/conan/public-conan", True, "my_upload_remote"), skip_check_credentials=True) mp.add({}, {}, {}) with self.assertRaisesRegexp(ConanException, "Errors uploading some packages"): mp.run() self.assertIn("Uploading packages for", self.output) self.assertIn("Credentials not specified but 'skip_check_credentials' activated", self.output)
def test_no_credentials_but_skip(self): with tools.environment_append({"CONAN_NON_INTERACTIVE": "1"}): self.save_conanfile(self.conanfile) mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload=("https://api.bintray.com/conan/conan-community/conan", True, "my_upload_remote"), skip_check_credentials=True) mp.add({}, {}, {}) with self.assertRaisesRegexp(ConanException, "Conan interactive mode disabled"): mp.run() self.assertIn("Uploading packages for", self.output) self.assertIn("Credentials not specified but 'skip_check_credentials' activated", self.output)
def test_existing_upload_repo(self): self.api.remote_add("my_upload_repo", "https://api.bintray.com/conan/conan-community/conan") self.save_conanfile(self.conanfile) with tools.environment_append({"CONAN_PASSWORD": "******"}): mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload=["https://api.bintray.com/conan/conan-community/conan", False, "othername"]) mp.add({}, {}, {}) with self.assertRaisesRegexp(ConanException, "Wrong user or password"): mp.run() # The upload repo is kept because there is already an url # FIXME: Probaby we should rename if name is different (Conan 1.3) self.assertIn("Remote for URL 'https://api.bintray.com/conan/conan-community/conan' " "already exist, keeping the current remote and its name", self.output)
def test_existing_upload_repo(self): self.api.remote_add("my_upload_repo", "https://uilianr.jfrog.io/artifactory/api/conan/public-conan") self.save_conanfile(self.conanfile) with tools.environment_append({"CONAN_PASSWORD": "******"}): mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager, upload=["https://uilianr.jfrog.io/artifactory/api/conan/public-conan", False, "othername"]) mp.add({}, {}, {}) with self.assertRaises(ConanException) as context: mp.run() self.assertTrue(any("Wrong user or password" in context.exception, "blocked due to recurrent login failures" in context.exception)) # The upload repo is kept because there is already an url # FIXME: Probaby we should rename if name is different (Conan 1.3) self.assertIn("Remote for URL 'https://uilianr.jfrog.io/artifactory/api/conan/public-conan' " "already exist, keeping the current remote and its name", self.output)
def test_update_build_if(self): self.packager.add({"os": "Windows"}) self.packager.add({"os": "Linux"}) self.packager.update_build_if(lambda build: build.settings["os"] == "Windows", new_build_requires={"*": ["7zip_installer/0.1.0@conan/stable"]}) packager_expected = ConanMultiPackager("lasote", "mychannel", runner=self.runner, conan_api=self.conan_api, reference="lib/1.0", ci_manager=self.ci_manager) packager_expected.add({"os": "Windows"}, {}, {}, {"*": ["7zip_installer/0.1.0@conan/stable"]}) packager_expected.add({"os": "Linux"}) self.assertEqual([tuple(a) for a in self.packager.items], packager_expected.items)
def test_existing_upload_repo_by_name(self): self.api.remote_add("upload_repo", "https://foobar.jfrog.io/artifactory/api/conan/public-conan") self.save_conanfile(self.conanfile) with tools.environment_append({"CONAN_PASSWORD": "******", "CONAN_UPLOAD": "https://uilianr.jfrog.io/artifactory/api/conan/public-conan" }): mp = ConanMultiPackager(username="******", out=self.output.write, ci_manager=self.ci_manager) mp.add({}, {}, {}) with self.assertRaises(ConanException) as context: mp.run() self.assertTrue(any("Wrong user or password" in context.exception, "blocked due to recurrent login failures" in context.exception)) self.assertNotIn("already exist, keeping the current remote and its name", self.output) repo = self.api.get_remote_by_name("upload_repo") self.assertEquals(repo.url, "https://uilianr.jfrog.io/artifactory/api/conan/public-conan")
def build_package(self, package_section): settings = self._shared_platform['settings']['settings'] options = {} env_vars = {} build = package_section['package'] build_requires = {} local_build_type = [] if 'options' in package_section: options = package_section['options'] else: options = self._shared_options if 'env_vars' in self._shared_platform: env_vars = self._shared_platform['env_vars'] if 'build_requires' in package_section: build_requires = package_section['build_requires'] if 'os' in package_section: if platform.system() not in package_section['os']: print('The {} package is not building for the {} platform'. format(build['reference'], platform.system())) return if 'settings' in package_section and 'build_type' in package_section[ 'settings']: local_build_type = package_section['settings']['build_type'] for env_var in env_vars: os.environ[env_var] = env_vars[env_var] packager = ConanMultiPackager(**build, build_policy='outdated', login_username=self._remote_user, password=self._remote_password, upload=self._remote) for build_type in self._shared_platform['settings']['build_type']: if len(local_build_type) == 0 or build_type in local_build_type: settings['build_type'] = build_type packager.add(settings.copy(), options=options, build_requires=build_requires) packager.run()
def test_32bits_images(self): packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, use_docker=True, docker_32_images=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6-x86", self.runner.calls[0]) self.runner.reset() packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, docker_32_images=False, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertNotIn("docker pull conanio/gcc6-i386", self.runner.calls[0]) self.runner.reset() with tools.environment_append({"CONAN_DOCKER_32_IMAGES": "1"}): packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6-x86", self.runner.calls[0]) self.runner.reset() # Test the opossite packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, docker_32_images=False, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6", self.runner.calls[0])
def main(): command = "sudo apt-get -qq update && sudo apt-get -qq install -y build-essential zlib1g-dev \ pkg-config libglib2.0-dev binutils-dev libboost-all-dev autoconf libtool libssl-dev \ libpixman-1-dev libpython-dev python-pip python-capstone virtualenv" arch = os.environ["CONAN_ARCHS"] builder = ConanMultiPackager(docker_entry_script=command) current_os = detected_os() for version in AVAILABLE_VERSIONS: builder.add({ "os": current_os, "arch_build": arch, "arch": arch }, {}, {}, {}, reference="qemu_installer/%s" % version) builder.run()
def test_remotes(self): runner = MockRunner() builder = ConanMultiPackager(username="******", remotes=["url1", "url2"], runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[1], "url1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[3].args[1], "url2") self.assertEquals(self.conan_api.calls[3].kwargs["insert"], -1) runner = MockRunner() self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", remotes="myurl1", runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[1], "myurl1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) # Named remotes, with SSL flag runner = MockRunner() self.conan_api = MockConanAPI() remotes = [("u1", True, "my_cool_name1"), ("u2", False, "my_cool_name2")] builder = ConanMultiPackager(username="******", remotes=remotes, runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[0], "my_cool_name1") self.assertEquals(self.conan_api.calls[1].args[1], "u1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[1].kwargs["verify_ssl"], True) self.assertEquals(self.conan_api.calls[3].args[0], "my_cool_name2") self.assertEquals(self.conan_api.calls[3].args[1], "u2") self.assertEquals(self.conan_api.calls[3].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[3].kwargs["verify_ssl"], False)
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"build_type": "Debug"}, options={}, env_vars={}, build_requires={}) builder.add(settings={"build_type": "Release"}, options={}, env_vars={}, build_requires={}) builder.run()
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"arch": "armv7", "os.api_level": "16"}) builder.add(settings={"arch": "armv8", "os.api_level": "21"}) builder.add(settings={"arch": "x86", "os.api_level": "16"}) builder.add(settings={"arch": "x86_64", "os.api_level": "21"}) builder.run()
class SimpleTest(BaseTest): def test_missing_full_reference(self): conanfile = """from conans import ConanFile class Pkg(ConanFile): pass """ self.save_conanfile(conanfile) mp = ConanMultiPackager(username="******") with self.assertRaisesRegexp( Exception, "Specify a CONAN_REFERENCE or name and version"): mp.add_common_builds() def test_missing_username(self): conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "lib" version = "1.0" options = {"shared": [True, False]} default_options = "shared=False" """ self.save_conanfile(conanfile) with self.assertRaisesRegexp( Exception, "Instance ConanMultiPackage with 'username' " "parameter or use CONAN_USERNAME env variable"): ConanMultiPackager() @unittest.skipUnless(sys.platform.startswith("win"), "Requires Windows") def test_msvc(self): conanfile = """from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" def build(self): assert("WindowsLibPath" in os.environ) """ self.save_conanfile(conanfile) self.packager = ConanMultiPackager(username="******", channel="mychannel", visual_versions=[15], archs=["x86"], build_types=["Release"], visual_runtimes=["MD"], reference="zlib/1.2.2") self.packager.add_common_builds() self.packager.run_builds(1, 1) def test_msvc_exclude_precommand(self): conanfile = """from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" def build(self): assert("WindowsLibPath" not in os.environ) """ self.save_conanfile(conanfile) self.packager = ConanMultiPackager(username="******", channel="mychannel", visual_versions=[15], archs=["x86"], build_types=["Release"], visual_runtimes=["MD"], exclude_vcvars_precommand=True, reference="zlib/1.2.2") self.packager.add_common_builds() self.packager.run_builds(1, 1) def test_shared_option_auto_managed(self): conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "lib" version = "1.0" settings = "os", "compiler", "build_type", "arch" options = {"shared": [True, False]} """ self.save_conanfile(conanfile) self.packager = ConanMultiPackager(username="******") self.packager.add_common_builds() self.assertIn("lib:shared", self.packager.items[0].options) # Even without name and version but reference conanfile = """from conans import ConanFile class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" options = {"shared": [True, False]} """ self.save_conanfile(conanfile) self.packager = ConanMultiPackager(username="******", reference="lib2/1.0") self.packager.add_common_builds() self.assertIn("lib2:shared", self.packager.items[0].options) self.packager = ConanMultiPackager(username="******", reference="lib2/1.0") self.packager.add_common_builds(shared_option_name=False) self.assertNotIn("lib2:shared", self.packager.items[0].options) def test_exported_files(self): conanfile = """from conans import ConanFile class Pkg(ConanFile): name = "lib" version = "1.0" settings = "os" exports = "*" exports_sources = "source*" """ ci_manager = MockCIManager() self.save_conanfile(conanfile) tools.save(os.path.join(self.tmp_folder, "other_file"), "Dummy contents") tools.save(os.path.join(self.tmp_folder, "source.cpp"), "Dummy contents") self.packager = ConanMultiPackager(username="******", reference="lib/1.0", ci_manager=ci_manager) self.packager.add({}, {}, {}, {}) self.packager.run() pf = self.client_cache.export( ConanFileReference.loads("lib/1.0@lasote/testing")) found_in_export = False for exported in os.listdir(pf): if "other_file" == exported: found_in_export = True break self.assertTrue(found_in_export) pf = self.client_cache.export_sources( ConanFileReference.loads("lib/1.0@lasote/testing")) found_in_export_sources = False for exported in os.listdir(pf): if "source.cpp" == exported: found_in_export_sources = True break self.assertTrue(found_in_export_sources) def test_build_policy(self): ci_manager = MockCIManager(build_policy="outdated") conanfile = """from conans import ConanFile import os class Pkg(ConanFile): name = "lib" version = "1.2" settings = "os", "compiler", "build_type", "arch" """ self.save_conanfile(conanfile) with tools.environment_append({"CONAN_USERNAME": "******"}): self.packager = ConanMultiPackager(channel="mychannel", gcc_versions=["6"], visual_versions=["12"], archs=["x86", "x86_64"], build_types=["Release"], ci_manager=ci_manager) self.packager.add_common_builds() self.packager.run()
from cpt.packager import ConanMultiPackager builder = ConanMultiPackager(username="******") builder.add(settings={"arch": "x86"}) builder.run()
""" Only upload the package the branch name is like a tag """ return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"\d+\.\d+\.\d+") @property def reference(self): """ Read project version from CMake file to create Conan referece """ pattern = re.compile(r"project\(taocpp-operators VERSION (\d+\.\d+\.\d+) LANGUAGES CXX\)") version = None with open('CMakeLists.txt') as file: for line in file: result = pattern.match(line) if result: version = result.group(1) if not version: raise Exception("Could not find version in CMakeLists.txt") return os.getenv("CONAN_REFERENCE", "operators/{}@taocpp/stable".format(version)) if __name__ == "__main__": settings = BuilderSettings() builder = ConanMultiPackager( reference=settings.reference, username=settings.username, upload=settings.upload, upload_only_when_stable=settings.upload_only_when_stable, stable_branch_pattern=settings.stable_branch_pattern, test_folder=os.path.join(".conan", "test_package")) builder.add() builder.run()
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"os": "iOS", "os.version": "9.0"}) builder.add(settings={ "os": "watchOS", "os.version": "4.0", "arch": "armv7k" }) builder.add(settings={"os": "tvOS", "os.version": "11.0", "arch": "armv8"}) builder.run()
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"arch": "asm.js"}) builder.add(settings={"arch": "wasm"}) builder.run()
username = get_username() url = "https://api.bintray.com/conan/{}/conan".format(username) default_upload = url if os.getenv("GITHUB_REF") else False return os.getenv("CONAN_UPLOAD", default_upload) def upload_when_stable(): return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "1").lower() not in ["0", "false", "no"] if __name__ == "__main__": test_folder = os.path.join(".conan", "test_package") builder = ConanMultiPackager(reference=get_reference(), username=get_username(), upload=get_upload(), test_folder=test_folder, stable_branch_pattern=r'v?\d+\.\d+\.\d+.*', upload_only_when_stable=upload_when_stable()) if platform.system() == "Linux": builder.add(settings={ "compiler": "gcc", "compiler.version": "8", "arch": "x86_64", "build_type": "Release" }, options={}, env_vars={}, build_requires={}) builder.run()
class DockerTest(BaseTest): CONAN_SERVER_ADDRESS = "http://0.0.0.0:9300" def setUp(self): super(DockerTest, self).setUp() self.server_process = subprocess.Popen("conan_server") time.sleep(3) def tearDown(self): self.server_process.kill() super(DockerTest, self).tearDown() @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker(self): client_version = get_client_version() ci_manager = MockCIManager() unique_ref = "zlib/%s" % str(time.time()) conanfile = textwrap.dedent(""" from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USE_DOCKER": "1", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_LOGIN_USERNAME": "******", "CONAN_USERNAME": "******", "CONAN_UPLOAD": DockerTest.CONAN_SERVER_ADDRESS, "CONAN_PASSWORD": "******" }): self.packager = ConanMultiPackager(channel="mychannel", gcc_versions=["8"], archs=["x86", "x86_64"], build_types=["Release"], reference=unique_ref, ci_manager=ci_manager) self.packager.add_common_builds() self.packager.run() search_pattern = "%s*" % unique_ref ref = ConanFileReference.loads("%s@demo/mychannel" % unique_ref) # Remove from remote if Version(client_version) < Version("1.7"): results = self.api.search_recipes( search_pattern, remote="upload_repo")["results"][0]["items"] self.assertEquals(len(results), 1) packages = self.api.search_packages( ref, remote="upload_repo")["results"][0]["items"][0]["packages"] self.assertEquals(len(packages), 2) self.api.authenticate(name=CONAN_LOGIN_UPLOAD, password=CONAN_UPLOAD_PASSWORD, remote="upload_repo") self.api.remove(search_pattern, remote="upload_repo", force=True) self.assertEquals( self.api.search_recipes(search_pattern)["results"], []) else: results = self.api.search_recipes( search_pattern, remote_name="upload_repo")["results"][0]["items"] self.assertEquals(len(results), 1) if Version(client_version) >= Version("1.12.0"): ref = repr(ref) packages = self.api.search_packages( ref, remote_name="upload_repo" )["results"][0]["items"][0]["packages"] self.assertEquals(len(packages), 2) self.api.authenticate(name="demo", password="******", remote_name="upload_repo") self.api.remove(search_pattern, remote_name="upload_repo", force=True) self.assertEquals( self.api.search_recipes(search_pattern)["results"], []) # Try upload only when stable, shouldn't upload anything with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USE_DOCKER": "1", "CONAN_LOGIN_USERNAME": "******", "CONAN_USERNAME": "******", "CONAN_PASSWORD": "******", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_UPLOAD_ONLY_WHEN_STABLE": "1" }): self.packager = ConanMultiPackager( channel="mychannel", gcc_versions=["8"], archs=["x86", "x86_64"], build_types=["Release"], reference=unique_ref, upload=DockerTest.CONAN_SERVER_ADDRESS, ci_manager=ci_manager) self.packager.add_common_builds() self.packager.run() if Version(client_version) < Version("1.7"): results = self.api.search_recipes(search_pattern, remote="upload_repo")["results"] self.assertEquals(len(results), 0) self.api.remove(search_pattern, remote="upload_repo", force=True) else: results = self.api.search_recipes( search_pattern, remote_name="upload_repo")["results"] self.assertEquals(len(results), 0) self.api.remove(search_pattern, remote_name="upload_repo", force=True) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_run_options(self): conanfile = textwrap.dedent(""" from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" requires = "zlib/1.2.11" def build(self): pass """) self.save_conanfile(conanfile) # Validate by Environemnt Variable with tools.environment_append({ "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USERNAME": "******", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", "CONAN_DOCKER_RUN_OPTIONS": "--network=host, --add-host=google.com:8.8.8.8 -v{}:/tmp/cpt". format(self.root_project_folder), "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_SHELL": "/bin/bash -c" }): self.packager = ConanMultiPackager(gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], out=self.output.write) self.packager.add({}) self.packager.run() self.assertIn("--network=host --add-host=google.com:8.8.8.8 -v", self.output) self.assertIn("/bin/bash -c", self.output) self.assertIn("/home/conan/project:z", self.output) # Validate by parameter with tools.environment_append({ "CONAN_USERNAME": "******", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", }): self.packager = ConanMultiPackager( gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], docker_run_options="--network=host -v{}:/tmp/cpt --cpus=1". format(self.root_project_folder), docker_entry_script="pip install -U /tmp/cpt", docker_image_skip_update=True, docker_shell="/bin/bash -c", out=self.output.write, force_selinux=True) self.packager.add({}) self.packager.run() self.assertIn("--cpus=1 conanio/gcc8", self.output) self.assertIn("/bin/bash -c", self.output) self.assertIn("/home/conan/project:z", self.output) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_run_android(self): self.create_project() command = ( 'docker run --rm -v "{}:/home/conan/project" ', '-e CONAN_RECIPE_LINTER="False" ', '-e CONAN_PIP_PACKAGE="0" ', '-e CONAN_DOCKER_ENTRY_SCRIPT="pip install -U /tmp/cpt" ', '-e CONAN_USERNAME="******" ', '-e CONAN_DOCKER_IMAGE="conanio/android-clang8" ', '-e CONAN_CHANNEL="testing" ', '-e CONAN_DOCKER_RUN_OPTIONS="-v{}:/tmp/cpt" ', '-e CONAN_DOCKER_IMAGE_SKIP_UPDATE="TRUE" ', '-e CONAN_DOCKER_USE_SUDO="FALSE" ', '-e CONAN_ARCHS="x86_64" ', '-e CONAN_CLANG_VERSIONS="8" ', '-e CONAN_BUILD_TYPES="Release" ', '-e CONAN_LOGIN_USERNAME="******" ', '-e CONAN_REFERENCE="hello/0.1.0@bar/testing" ', '-e CPT_PROFILE="@@include(default)@@@@[settings]@@arch=x86_64@@build_type=Release@@compiler=clang@@compiler.version=8@@[options]@@@@[env]@@@@[build_requires]@@@@" ', '-e CONAN_TEMP_TEST_FOLDER="1" ', '-e CPT_UPLOAD_RETRY="3" ', '-e CPT_CONANFILE="conanfile.py" ', '-v{}:/tmp/cpt ', 'conanio/android-clang8 ', '/bin/sh -c " cd project && pip install -U /tmp/cpt && run_create_in_docker "' ) command = "".join(command).format(self.tmp_folder, self.root_project_folder, self.root_project_folder) output = subprocess.check_output(command, shell=True).decode() self.assertIn("os=Android", output) self.assertIn("compiler.version=8", output) self.assertIn("compiler=clang", output) self.assertIn("arch=x86_64", output) self.assertIn("Cross-build from 'Linux:x86_64' to 'Android:x86_64'", output) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_custom_pip_command(self): conanfile = textwrap.dedent(""" from conans import ConanFile import os class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" requires = "zlib/1.2.11" def build(self): pass """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_USERNAME": "******", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", "CONAN_DOCKER_RUN_OPTIONS": "--network=host, --add-host=google.com:8.8.8.8 -v{}:/tmp/cpt". format(self.root_project_folder), "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_SHELL": "/bin/bash -c", "CONAN_DOCKER_PIP_COMMAND": "foobar" }): self.packager = ConanMultiPackager(gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], out=self.output.write) self.packager.add({}) with self.assertRaises(Exception) as raised: self.packager.run() self.assertIn("Error updating the image", str(raised.exception)) self.assertIn("foobar install conan_package_tools", str(raised.exception)) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_base_profile(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Pkg(ConanFile): def build(self): pass """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_USE_DOCKER": "1", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_USE_SUDO": "FALSE", "CONAN_DOCKER_SHELL": "/bin/bash -c", }): self.packager = ConanMultiPackager( gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], config_url= "https://github.com/bincrafters/bincrafters-config.git", out=self.output.write) self.packager.add({}) self.packager.run(base_profile_name="linux-gcc8-amd64") self.assertIn( 'Using specified default base profile: linux-gcc8-amd64', self.output) self.assertIn('-e CPT_BASE_PROFILE_NAME="linux-gcc8-amd64"', self.output) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_base_build_profile(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Pkg(ConanFile): def build(self): pass """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_DOCKER_RUN_OPTIONS": "--network=host -v{}:/tmp/cpt".format( self.root_project_folder), "CONAN_DOCKER_ENTRY_SCRIPT": "pip install -U /tmp/cpt", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_USE_DOCKER": "1", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_USE_SUDO": "FALSE", "CONAN_DOCKER_SHELL": "/bin/bash -c", }): self.packager = ConanMultiPackager( gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], config_url= "https://github.com/bincrafters/bincrafters-config.git", out=self.output.write) self.packager.add({}) self.packager.run(base_profile_name="orangepi", base_profile_build_name="linux-gcc8-amd64") self.assertIn('Using specified default base profile: orangepi', self.output) self.assertIn('Using specified build profile: linux-gcc8-amd64', self.output) self.assertIn('-e CPT_BASE_PROFILE_NAME="orangepi"', self.output) self.assertNotIn('-e CPT_PROFILE_BUILD="linux-gcc8-amd64"', self.output) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_hidden_password(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Pkg(ConanFile): settings = "os", "compiler", "build_type", "arch" def build(self): pass """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_USERNAME": "******", "CONAN_LOGIN_USERNAME": "******", "CONAN_PASSWORD": "******", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_REFERENCE": "foo/0.0.1@bar/testing", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_USE_SUDO": "FALSE", "CONAN_DOCKER_SHELL": "/bin/bash -c", }): self.packager = ConanMultiPackager(gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], out=self.output.write) self.packager.add({}) self.packager.run() self.assertIn('-e CONAN_LOGIN_USERNAME="******"', self.output) self.assertIn('-e CONAN_PASSWORD="******"', self.output) @unittest.skipUnless(is_linux_and_have_docker(), "Requires Linux and Docker") def test_docker_underscore_user_channel(self): conanfile = textwrap.dedent(""" from conans import ConanFile class Pkg(ConanFile): def build(self): pass """) self.save_conanfile(conanfile) with tools.environment_append({ "CONAN_USERNAME": "******", "CONAN_CHANNEL": "_", "CONAN_DOCKER_IMAGE": "conanio/gcc8", "CONAN_REFERENCE": "foo/0.0.1", "CONAN_DOCKER_IMAGE_SKIP_UPDATE": "TRUE", "CONAN_FORCE_SELINUX": "TRUE", "CONAN_DOCKER_USE_SUDO": "FALSE", "CONAN_DOCKER_SHELL": "/bin/bash -c", }): self.packager = ConanMultiPackager(gcc_versions=["8"], archs=["x86_64"], build_types=["Release"], out=self.output.write) self.packager.add({}) self.packager.run() self.assertIn('-e CONAN_USERNAME="******"', self.output) self.assertIn('-e CONAN_CHANNEL="_"', self.output)
"3.8.2", "3.8.1", "3.8.0", "3.7.2", "3.7.1", "3.7.0", "3.6.3", "3.6.2", "3.6.1", "3.6.0", "3.5.2", "3.4.3", "3.3.2", "3.2.3", "3.1.3", "3.0.2", "2.8.12"] def detected_os(): if OSInfo().is_macos: return "Macos" if OSInfo().is_windows: return "Windows" return platform.system() if __name__ == "__main__": arch = os.environ["CONAN_ARCHS"] builder = ConanMultiPackager() os = detected_os() for version in available_versions: # New mode, with version field builder.add({"os" : os, "arch_build" : arch, "arch": arch}, {}, {}, {}, reference="cmake_installer/%s" % version) # Old mode, version as an option builder.add({"os" : os, "arch_build" : arch, "arch": arch}, {"cmake_installer:version": version}, {}, {}, reference="cmake_installer/1.0") builder.run()
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"os.version": "10.13"}) builder.add() builder.run()
class AppTest(unittest.TestCase): def setUp(self): self.runner = MockRunner() self.conan_api = MockConanAPI() self.ci_manager = MockCIManager() self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, reference="lib/1.0", ci_manager=self.ci_manager) if "APPVEYOR" in os.environ: del os.environ["APPVEYOR"] if "TRAVIS" in os.environ: del os.environ["TRAVIS"] def _add_build(self, number, compiler=None, version=None): self.packager.add({"os": "os%d" % number, "compiler": compiler or "compiler%d" % number, "compiler.version": version or "4.3"}, {"option%d" % number: "value%d" % number, "option%d" % number: "value%d" % number}) def test_remove_build_if(self): self.packager.add({"arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "6"}) self.packager.add({"arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "6"}) self.packager.add({"arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "7"}) self.packager.add({"arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "7"}) self.packager.remove_build_if(lambda build: build.settings["compiler.version"] == "6") packager_expected = ConanMultiPackager("lasote", "mychannel", runner=self.runner, conan_api=self.conan_api, reference="lib/1.0", ci_manager=self.ci_manager) packager_expected.add({"arch": "x86", "build_type": "Release", "compiler": "gcc", "compiler.version": "7"}) packager_expected.add({"arch": "x86", "build_type": "Debug", "compiler": "gcc", "compiler.version": "7"}) self.assertEqual([tuple(a) for a in self.packager.items], packager_expected.items) def test_update_build_if(self): self.packager.add({"os": "Windows"}) self.packager.add({"os": "Linux"}) self.packager.update_build_if(lambda build: build.settings["os"] == "Windows", new_build_requires={"*": ["7zip_installer/0.1.0@conan/stable"]}) packager_expected = ConanMultiPackager("lasote", "mychannel", runner=self.runner, conan_api=self.conan_api, reference="lib/1.0", ci_manager=self.ci_manager) packager_expected.add({"os": "Windows"}, {}, {}, {"*": ["7zip_installer/0.1.0@conan/stable"]}) packager_expected.add({"os": "Linux"}) self.assertEqual([tuple(a) for a in self.packager.items], packager_expected.items) def test_full_profile(self): self.packager.add({"os": "Windows", "compiler": "gcc"}, {"option1": "One"}, {"VAR_1": "ONE", "VAR_2": "TWO"}, {"*": ["myreference/1.0@lasote/testing"]}) self.packager.run_builds(1, 1) profile = self.conan_api.get_profile_from_call_index(1) self.assertEquals(profile.settings["os"], "Windows") self.assertEquals(profile.settings["compiler"], "gcc") self.assertEquals(profile.options.as_list(), [("option1", "One")]) self.assertEquals(profile.env_values.data[None]["VAR_1"], "ONE") self.assertEquals(profile.env_values.data[None]["VAR_2"], "TWO") self.assertEquals(profile.build_requires["*"], [ConanFileReference.loads("myreference/1.0@lasote/testing")]) def test_profile_environ(self): self.packager.add({"os": "Windows", "compiler": "gcc"}, {"option1": "One"}, {"VAR_1": "ONE", "VAR_2": "TWO"}, {"*": ["myreference/1.0@lasote/testing"]}) with tools.environment_append({"CONAN_BUILD_REQUIRES": "br1/1.0@conan/testing"}): self.packager.run_builds(1, 1) profile = self.conan_api.get_profile_from_call_index(1) self.assertEquals(profile.build_requires["*"], [ConanFileReference.loads("myreference/1.0@lasote/testing"), ConanFileReference.loads("br1/1.0@conan/testing")]) def test_pages(self): for number in range(10): self._add_build(number) # 10 pages, 1 per build self.packager.run_builds(1, 10) self.conan_api.assert_tests_for([0]) # 2 pages, 5 per build self.conan_api.reset() self.packager.run_builds(1, 2) self.conan_api.assert_tests_for([0, 2, 4, 6, 8]) self.conan_api.reset() self.packager.run_builds(2, 2) self.conan_api.assert_tests_for([1, 3, 5, 7, 9]) # 3 pages, 4 builds in page 1 and 3 in the rest of pages self.conan_api.reset() self.packager.run_builds(1, 3) self.conan_api.assert_tests_for([0, 3, 6, 9]) self.conan_api.reset() self.packager.run_builds(2, 3) self.conan_api.assert_tests_for([1, 4, 7]) self.conan_api.reset() self.packager.run_builds(3, 3) self.conan_api.assert_tests_for([2, 5, 8]) def test_deprecation_gcc(self): with self.assertRaisesRegexp(Exception, "DEPRECATED GCC MINOR VERSIONS!"): ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5.4"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) def test_32bits_images(self): packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, use_docker=True, docker_32_images=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6-x86", self.runner.calls[0]) self.runner.reset() packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, docker_32_images=False, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertNotIn("docker pull conanio/gcc6-i386", self.runner.calls[0]) self.runner.reset() with tools.environment_append({"CONAN_DOCKER_32_IMAGES": "1"}): packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6-x86", self.runner.calls[0]) self.runner.reset() # Test the opossite packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, docker_32_images=False, reference="zlib/1.2.11", ci_manager=self.ci_manager) packager.add({"arch": "x86", "compiler": "gcc", "compiler.version": "6"}) packager.run_builds(1, 1) self.assertIn("docker pull conanio/gcc6", self.runner.calls[0]) def test_docker_gcc(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self._add_build(2, "gcc", "4.3") self._add_build(3, "gcc", "4.3") self.packager.run_builds(1, 2) self.assertIn("docker pull conanio/gcc43", self.runner.calls[0]) self.assertIn('docker run ', self.runner.calls[1]) self.assertNotIn('sudo pip', self.runner.calls[1]) self.assertIn('pip install', self.runner.calls[1]) self.assertIn('os=os1', self.runner.calls[4]) self.packager.run_builds(1, 2) self.assertIn("docker pull conanio/gcc43", self.runner.calls[0]) # Next build from 4.3 is cached, not pulls are performed self.assertIn('os=os3', self.runner.calls[5]) for the_bool in ["True", "False"]: self.runner.reset() with tools.environment_append({"CONAN_DOCKER_USE_SUDO": the_bool}): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) if the_bool == "True": self.assertIn("sudo -E docker run", self.runner.calls[-1]) else: self.assertNotIn("sudo -E docker run", self.runner.calls[-1]) self.assertIn("docker run", self.runner.calls[-1]) self.runner.reset() with tools.environment_append({"CONAN_PIP_USE_SUDO": the_bool}): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) if the_bool == "True": self.assertIn("sudo -E pip", self.runner.calls[1]) else: self.assertNotIn("sudo -E pip", self.runner.calls[1]) self.assertIn("pip", self.runner.calls[1]) def test_docker_clang(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, clang_versions=["3.8", "4.0"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "clang", "3.8") self._add_build(2, "clang", "3.8") self._add_build(3, "clang", "3.8") self.packager.run_builds(1, 2) self.assertIn("docker pull conanio/clang38", self.runner.calls[0]) self.assertIn('docker run ', self.runner.calls[1]) self.assertIn('os=os1', self.runner.calls[4]) # Next build from 3.8 is cached, not pulls are performed self.assertIn('os=os3', self.runner.calls[5]) def test_docker_gcc_and_clang(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["5", "6"], clang_versions=["3.9", "4.0"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "5") self._add_build(2, "gcc", "5") self._add_build(3, "gcc", "5") self._add_build(4, "clang", "3.9") self._add_build(5, "clang", "3.9") self._add_build(6, "clang", "3.9") self.packager.run_builds(1, 2) self.assertIn("docker pull conanio/gcc5", self.runner.calls[0]) self.assertIn('docker run ', self.runner.calls[1]) self.assertIn('os=os1', self.runner.calls[4]) self.assertIn('os=os3', self.runner.calls[5]) self.packager.run_builds(2, 2) self.assertIn("docker pull conanio/clang39", self.runner.calls[16]) self.assertIn('docker run ', self.runner.calls[17]) self.assertIn('os=os4', self.runner.calls[20]) self.assertIn('os=os6', self.runner.calls[21]) def test_upload_false(self): packager = ConanMultiPackager(username="******", channel="mychannel", upload=False, reference="zlib/1.2.11", ci_manager=self.ci_manager) self.assertFalse(packager._upload_enabled()) def test_docker_env_propagated(self): # test env with tools.environment_append({"CONAN_FAKE_VAR": "32"}): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["5", "6"], clang_versions=["3.9", "4.0"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "5") self.packager.run_builds(1, 1) self.assertIn('-e CONAN_FAKE_VAR="32"', self.runner.calls[-1]) def test_docker_home_env(self): with tools.environment_append({"CONAN_DOCKER_HOME": "/some/dir"}): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["5", "6"], clang_versions=["3.9", "4.0"], use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "5") self.packager.run_builds(1, 1) self.assertIn('-e CONAN_DOCKER_HOME="/some/dir"', self.runner.calls[-1]) self.assertEquals(self.packager.docker_conan_home, "/some/dir") def test_docker_home_opt(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["5", "6"], clang_versions=["3.9", "4.0"], use_docker=True, docker_conan_home="/some/dir", reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "5") self.packager.run_builds(1, 1) self.assertEquals(self.packager.docker_conan_home, "/some/dir") def test_docker_invalid(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, use_docker=True, reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "msvc", "10") # Only clang and gcc have docker images self.assertRaises(Exception, self.packager.run_builds) def test_assign_builds_retrocompatibility(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], use_docker=True, reference="lib/1.0", ci_manager=self.ci_manager) self.packager.add_common_builds() self.packager.builds = [({"os": "Windows"}, {"option": "value"})] self.assertEquals(self.packager.items, [BuildConf(settings={'os': 'Windows'}, options={'option': 'value'}, env_vars={}, build_requires={}, reference="lib/1.0@lasote/mychannel")]) def test_only_mingw(self): mingw_configurations = [("4.9", "x86_64", "seh", "posix")] builder = ConanMultiPackager(mingw_configurations=mingw_configurations, visual_versions=[], username="******", platform_info=platform_mock_for("Windows"), reference="lib/1.0", ci_manager=self.ci_manager) builder.add_common_builds(shared_option_name="zlib:shared", pure_c=True) expected = [({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'compiler.threads': 'posix', 'compiler.version': '4.9', 'arch': 'x86_64', 'build_type': 'Release', 'compiler': 'gcc'}, {'zlib:shared': True}, {}, {'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}), ({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'arch': 'x86_64', 'compiler.threads': 'posix', 'compiler.version': '4.9', 'build_type': 'Debug', 'compiler': 'gcc'}, {'zlib:shared': True}, {}, {'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}), ({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'compiler.threads': 'posix', 'compiler.version': '4.9', 'arch': 'x86_64', 'build_type': 'Release', 'compiler': 'gcc'}, {'zlib:shared': False}, {}, {'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]}), ({'compiler.exception': 'seh', 'compiler.libcxx': "libstdc++", 'arch': 'x86_64', 'compiler.threads': 'posix', 'compiler.version': '4.9', 'build_type': 'Debug', 'compiler': 'gcc'}, {'zlib:shared': False}, {}, {'*': [ConanFileReference.loads("mingw_installer/1.0@conan/stable")]})] self.assertEquals([tuple(a) for a in builder.builds], expected) def test_named_pages(self): builder = ConanMultiPackager(username="******", reference="zlib/1.2.11", ci_manager=self.ci_manager) named_builds = defaultdict(list) builder.add_common_builds(shared_option_name="zlib:shared", pure_c=True) for settings, options, env_vars, build_requires, _ in builder.items: named_builds[settings['arch']].append([settings, options, env_vars, build_requires]) builder.named_builds = named_builds self.assertEquals(builder.builds, []) if platform.system() == "Darwin": # Not default x86 in Macos self.assertEquals(len(builder.named_builds), 1) self.assertFalse("x86" in builder.named_builds) self.assertTrue("x86_64" in builder.named_builds) else: self.assertEquals(len(builder.named_builds), 2) self.assertTrue("x86" in builder.named_builds) self.assertTrue("x86_64" in builder.named_builds) def test_remotes(self): runner = MockRunner() builder = ConanMultiPackager(username="******", remotes=["url1", "url2"], runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[1], "url1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[3].args[1], "url2") self.assertEquals(self.conan_api.calls[3].kwargs["insert"], -1) runner = MockRunner() self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", remotes="myurl1", runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[1], "myurl1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) # Named remotes, with SSL flag runner = MockRunner() self.conan_api = MockConanAPI() remotes = [("u1", True, "my_cool_name1"), ("u2", False, "my_cool_name2")] builder = ConanMultiPackager(username="******", remotes=remotes, runner=runner, conan_api=self.conan_api, reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add({}, {}, {}, {}) builder.run_builds() self.assertEquals(self.conan_api.calls[1].args[0], "my_cool_name1") self.assertEquals(self.conan_api.calls[1].args[1], "u1") self.assertEquals(self.conan_api.calls[1].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[1].kwargs["verify_ssl"], True) self.assertEquals(self.conan_api.calls[3].args[0], "my_cool_name2") self.assertEquals(self.conan_api.calls[3].args[1], "u2") self.assertEquals(self.conan_api.calls[3].kwargs["insert"], -1) self.assertEquals(self.conan_api.calls[3].kwargs["verify_ssl"], False) def test_visual_defaults(self): with tools.environment_append({"CONAN_VISUAL_VERSIONS": "10"}): builder = ConanMultiPackager(username="******", platform_info=platform_mock_for("Windows"), reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add_common_builds() for settings, _, _, _, _ in builder.items: self.assertEquals(settings["compiler"], "Visual Studio") self.assertEquals(settings["compiler.version"], "10") with tools.environment_append({"CONAN_VISUAL_VERSIONS": "10", "MINGW_CONFIGURATIONS": "4.9@x86_64@seh@posix"}): builder = ConanMultiPackager(username="******", platform_info=platform_mock_for("Windows"), reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) builder.add_common_builds() for settings, _, _, _, _ in builder.items: self.assertEquals(settings["compiler"], "gcc") self.assertEquals(settings["compiler.version"], "4.9") def select_defaults_test(self): with tools.environment_append({"CONAN_REFERENCE": "zlib/1.2.8"}): builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"), gcc_versions=["4.8", "5"], username="******", reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) self.assertEquals(builder.build_generator._clang_versions, []) with tools.environment_append({"CONAN_GCC_VERSIONS": "4.8, 5", "CONAN_REFERENCE": "zlib/1.2.8"}): builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"), username="******", reference="lib/1.0@lasote/mychannel", ci_manager=self.ci_manager) self.assertEquals(builder.build_generator._clang_versions, []) self.assertEquals(builder.build_generator._gcc_versions, ["4.8", "5"]) builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"), clang_versions=["4.8", "5"], username="******", reference="lib/1.0", ci_manager=self.ci_manager) self.assertEquals(builder.build_generator._gcc_versions, []) with tools.environment_append({"CONAN_CLANG_VERSIONS": "4.8, 5", "CONAN_APPLE_CLANG_VERSIONS": " "}): builder = ConanMultiPackager(platform_info=platform_mock_for("Linux"), username="******", reference="lib/1.0", ci_manager=self.ci_manager) self.assertEquals(builder.build_generator._gcc_versions, []) self.assertEquals(builder.build_generator._clang_versions, ["4.8", "5"]) self.assertEquals(builder.build_generator._clang_versions, ["4.8", "5"]) self.assertEquals(builder.build_generator._apple_clang_versions, []) def test_upload(self): runner = MockRunner() runner.output = "arepo: myurl" builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload="myurl", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=runner, conan_api=self.conan_api, remotes="myurl, otherurl", platform_info=platform_mock_for("Darwin"), ci_manager=self.ci_manager) builder.add_common_builds() builder.run() # Duplicated upload remote puts upload repo first (in the remotes order) self.assertEqual(self.conan_api.calls[1].args[0], 'upload_repo') self.assertEqual(self.conan_api.calls[3].args[0], 'remote1') # Now check that the upload remote order is preserved if we specify it in the remotes runner = MockRunner() self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload="myurl", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=runner, conan_api=self.conan_api, remotes="otherurl, myurl, moreurl", platform_info=platform_mock_for("Darwin"), ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEqual(self.conan_api.calls[1].args[0], 'remote0') self.assertEqual(self.conan_api.calls[3].args[0], 'upload_repo') self.assertEqual(self.conan_api.calls[5].args[0], 'remote2') runner = MockRunner() self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload="myurl", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=runner, conan_api=self.conan_api, remotes="otherurl", platform_info=platform_mock_for("Darwin"), ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEqual(self.conan_api.calls[1].args[0], 'remote0') self.assertEqual(self.conan_api.calls[3].args[0], 'upload_repo') def test_build_policy(self): builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, remotes="otherurl", platform_info=platform_mock_for("Darwin"), build_policy="outdated", ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEquals(["outdated"], self.conan_api.calls[-1].kwargs["build_modes"]) with tools.environment_append({"CONAN_BUILD_POLICY": "missing"}): self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, remotes="otherurl", platform_info=platform_mock_for("Darwin"), build_policy="missing", ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEquals(["missing"], self.conan_api.calls[-1].kwargs["build_modes"]) def test_test_folder(self): builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, remotes="otherurl", platform_info=platform_mock_for("Darwin"), test_folder="foobar", ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEquals("foobar", self.conan_api.calls[-1].kwargs["test_folder"]) with tools.environment_append({"CONAN_BUILD_POLICY": "missing"}): self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, remotes="otherurl", platform_info=platform_mock_for("Darwin"), build_policy=None, ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertEquals(None, self.conan_api.calls[-1].kwargs["test_folder"]) def test_check_credentials(self): builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload="myurl", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, platform_info=platform_mock_for("Darwin"), ci_manager=self.ci_manager) builder.add_common_builds() builder.run() # When activated, check credentials before to create the profiles self.assertEqual(self.conan_api.calls[2].name, 'authenticate') self.assertEqual(self.conan_api.calls[5].name, 'create_profile') self.conan_api = MockConanAPI() # If we skip the credentials check, the login will be performed just before the upload builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload="myurl", visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, platform_info=platform_mock_for("Darwin"), skip_check_credentials=True, ci_manager=self.ci_manager) builder.add_common_builds() builder.run() self.assertNotEqual(self.conan_api.calls[0].name, 'authenticate') # No upload, no authenticate self.conan_api = MockConanAPI() builder = ConanMultiPackager(username="******", channel="testing", reference="Hello/0.1", password="******", upload=None, visual_versions=[], gcc_versions=[], apple_clang_versions=[], runner=self.runner, conan_api=self.conan_api, platform_info=platform_mock_for("Darwin"), skip_check_credentials=True, ci_manager=self.ci_manager) builder.add_common_builds() builder.run() for action in self.conan_api.calls: self.assertNotEqual(action.name, 'authenticate') self.assertNotEqual(action.name, 'upload') def channel_detector_test(self): for branch, expected_channel in [("testing", "a_channel"), ("dummy", "a_channel"), ("stable", "stable"), ("stable/something", "stable"), ("release", "stable"), ("release/something", "stable"), ("master", "stable"), ("master/something", "a_channel")]: builder = ConanMultiPackager(username="******", channel="a_channel", reference="lib/1.0", ci_manager=MockCIManager(current_branch=branch)) self.assertEquals(builder.channel, expected_channel, "Not match for branch %s" % branch) def test_pip_conanio_image(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], use_docker=True, docker_image='conanio/gcc43', reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) self.assertNotIn("sudo -E pip", self.runner.calls[1]) self.assertIn("pip", self.runner.calls[1]) self.runner.reset() self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], docker_image='conanio/gcc43', reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) self.assertNotIn("sudo -E pip", self.runner.calls[1]) self.assertIn("pip", self.runner.calls[1]) @unittest.skipIf(sys.platform.startswith("win"), "Requires Linux") def test_pip_docker_sudo(self): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], docker_image='foobar/gcc43', reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) self.assertIn("sudo -E pip", self.runner.calls[1]) self.runner.reset() with tools.environment_append({"CONAN_PIP_USE_SUDO": "True"}): self.packager = ConanMultiPackager(username="******", channel="mychannel", runner=self.runner, conan_api=self.conan_api, gcc_versions=["4.3", "5"], docker_image='conanio/gcc43', reference="zlib/1.2.11", ci_manager=self.ci_manager) self._add_build(1, "gcc", "4.3") self.packager.run_builds(1, 2) self.assertIn("sudo -E pip", self.runner.calls[1])
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add(settings={"os": "Macos", "arch": "x86_64"}) builder.add(settings={"os": "Macos", "arch": "x86_64"}) builder.add(settings={"os": "iOS", "os.version": "9.0", "arch": "armv8.3"}) builder.add(settings={ "os": "watchOS", "os.version": "4.0", "arch": "armv7k" }) builder.add(settings={"os": "tvOS", "os.version": "11.0", "arch": "armv8"}) builder.add(settings={ "os": "Macos", "arch": "x86_64", "os.subsystem": "catalyst", }) builder.add( settings={ "os": "iOS", "os.version": "9.0", "arch": "armv8.3" }, options={"darwin-toolchain:enable_bitcode": True}, ) builder.run()
#!/usr/bin/python import platform from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager(username="******", channel="testing") builder.add(settings={"arch": "x86_64", "build_type": "Release"}, options={}, env_vars={}, build_requires={}) builder.run()
"meson:arch": arch_build, "cmake_installer:arch": arch_build, } options = { "*:shared": False, "*:fPIC": True, } build_requires = { "*": ["gcc-toolchain/6.3.0@bobrofon/stable", "meson/0.56.2"] } builder = ConanMultiPackager( username="******", channel="testing", upload="https://api.bintray.com/conan/bobrofon/sshfs-world", build_policy="missing", ) builder.add(settings=settings | {"arch": "armv6"}, options=options | {"gcc-toolchain:target": "armv6"}, build_requires=build_requires) builder.add(settings=settings | {"arch": "armv8"}, options=options | {"gcc-toolchain:target": "armv8"}, build_requires=build_requires) builder.add(settings=settings | {"arch": "x86"}, options=options | {"gcc-toolchain:target": "x86"}, build_requires=build_requires) builder.add(settings=settings | {"arch": "x86_64"}, options=options | {"gcc-toolchain:target": "x86_64"}, build_requires=build_requires) builder.run()
from cpt.packager import ConanMultiPackager if __name__ == "__main__": builder = ConanMultiPackager() builder.add() builder.run()
def get_reference(): version = get_version() username = get_username() return "uvw/{}@{}/stable".format(version, username) def get_upload(): username = get_username() url = "https://api.bintray.com/conan/{}/conan".format(username) default_upload = url if os.getenv("TRAVIS_TAG") else False return os.getenv("CONAN_UPLOAD", default_upload) def upload_when_stable(): return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "1").lower() not in ["0", "false", "no"] if __name__ == "__main__": test_folder = os.path.join(".conan", "test_package") builder = ConanMultiPackager(reference=get_reference(), username=get_username(), upload=get_upload(), test_folder=test_folder, stable_branch_pattern=r'v?\d+\.\d+\.\d+.*', upload_only_when_stable=upload_when_stable()) if platform.system() == "Linux": builder.add(settings={"compiler": "gcc", "compiler.version": "8", "arch": "x86_64", "build_type": "Release"}, options={}, env_vars={}, build_requires={}) builder.run()