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()
