def test_profile_test_requires(self):
client = TestClient()
self._create(client)
test_conanfile = """
import os
from conans import ConanFile, tools
class TestMyLib(ConanFile):
requires = "MyLib/0.1@lasote/stable"
def build(self):
self.run("mytool")
with tools.pythonpath(self):
import mypythontool
self.output.info(mypythontool.tool_hello_world())
def test(self):
pass
"""
client.save({CONANFILE: lib_conanfile,
"test_package/conanfile.py": test_conanfile,
"profile.txt": profile,
"profile2.txt": profile2}, clean_first=True)
client.run("test_package --profile ./profile.txt --build missing")
self.assertEqual(2, str(client.user_io.out).splitlines().count("Hello World!"))
self.assertIn("MyLib/0.1@lasote/stable: Hello world from python tool!", client.user_io.out)
self.assertIn("Project: Hello world from python tool!", client.user_io.out)
def test_command_user(self):
""" Test that the user can be shown and changed, and it is reflected in the
user cache localdb
"""
client = TestClient()
client.run('user')
self.assertIn("ERROR: No remotes defined", client.user_io.out)
def conditional_requirements_test(self):
conanfile = """from conans import ConanFile
class TestConanLib(ConanFile):
name = "Hello"
version = "0.1"
settings = "os", "build_type", "product"
"""
test_conanfile = '''
from conans import ConanFile
class TestConanLib(ConanFile):
requires = "Hello/0.1@lasote/testing"
settings = "os", "build_type", "product"
def requirements(self):
self.output.info("Conditional test requirement: %s, %s, %s"
% (self.settings.os, self.settings.build_type, self.settings.product))
def test(self):
pass
'''
client = TestClient()
settings_path = client.client_cache.settings_path
client.client_cache.settings
settings = load(settings_path)
settings += "\nproduct: [onion, potato]"
save(settings_path, settings)
client.save({"conanfile.py": conanfile,
"test_package/conanfile.py": test_conanfile})
client.run("create . lasote/testing -s os=Windows -s product=onion -s build_type=Release")
self.assertIn("PROJECT: Conditional test requirement: Windows, Release, onion",
client.user_io.out)
class InstallCWDTest(unittest.TestCase):
def setUp(self):
self.client = TestClient(users={"myremote": [("lasote", "mypass")]})
conanfile = """
import os
from conans import ConanFile, tools, CMake
class MyLib(ConanFile):
name = "MyLib"
version = "0.1"
exports = "*"
settings = "os", "compiler", "arch", "build_type"
generators = "cmake"
def build(self):
pass
"""
self.client.save({CONANFILE: conanfile})
self.client.run("export . lasote/stable")
def test_install_cwd(self):
self.client.save({CONANFILE_TXT: "[requires]MyLib/0.1@lasote/stable"}, clean_first=True)
os.mkdir(os.path.join(self.client.current_folder, "new"))
self.client.run("install . --install-folder new -g cmake")
self.assertTrue(os.path.join(self.client.current_folder, "new", "conanbuildinfo.cmake"))
def install_ref(self):
self.client.run("install MyLib/0.1@lasote/stable --build=missing")
self.assertEqual(["conanfile.py"], os.listdir(self.client.current_folder))
def package_files_test(self):
if platform.system() == "Windows":
return
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
def package(self):
self.copy("*", symlinks=True)
"""
client.save({"recipe/conanfile.py": conanfile})
file1 = os.path.join(client.current_folder, "file1.txt")
file2 = os.path.join(client.current_folder, "version1/file2.txt")
file11 = os.path.join(client.current_folder, "file1.txt.1")
latest = os.path.join(client.current_folder, "latest")
save(file1, "Hello1")
os.symlink("file1.txt", file11)
save(file2, "Hello2")
os.symlink("version1", latest)
client.run("export-pkg ./recipe Hello/0.1@lasote/stable")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self._check(client, ref, build=False)
class ProfilesEnvironmentTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def build_with_profile_test(self):
self._create_profile("scopes_env", {},
{}, # undefined scope do not apply to my packages
{"CXX": "/path/tomy/g++_build", "CC": "/path/tomy/gcc_build"})
self.client.save({CONANFILE: conanfile_dep})
self.client.run("export lasote/testing")
self.client.save({CONANFILE: conanfile_scope_env}, clean_first=True)
self.client.run("install --build=missing --pr scopes_env")
self.client.run("build")
self.assertRegexpMatches(str(self.client.user_io.out), "PATH=['\"]*/path/to/my/folder")
self._assert_env_variable_printed("CC", "/path/tomy/gcc_build")
self._assert_env_variable_printed("CXX", "/path/tomy/g++_build")
def _assert_env_variable_printed(self, name, value):
self.assertIn("%s=%s" % (name, value), self.client.user_io.out)
def _create_profile(self, name, settings, scopes=None, env=None):
env = env or {}
profile = Profile()
profile._settings = settings or {}
if scopes:
profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])
for varname, value in env.items():
profile.env_values.add(varname, value)
save(os.path.join(self.client.client_cache.profiles_path, name), profile.dumps())
def base_profile_generated_test(self):
"""we are testing that the default profile is created (when not existing, fresh install)
even when you run a create with a profile"""
client = TestClient()
client.save({CONANFILE: conanfile_scope_env,
"myprofile": "include(default)\n[settings]\nbuild_type=Debug"})
client.run("create . conan/testing --profile myprofile")
def test_rel_path(self):
base_folder = temp_folder()
source_folder = os.path.join(base_folder, "source")
current_folder = os.path.join(base_folder, "current")
os.makedirs(current_folder)
client = TestClient(current_folder=current_folder)
files = cpp_hello_conan_files("Hello0", "0.1")
conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
client.save(files, path=source_folder)
client.run("export lasote/stable --path=../source")
reg_path = client.paths.export(conan_ref)
manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
client.user_io.out)
self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in list(files.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143',
'conanfile.py': '355949fbf0b4fc32b8f1c5a338dfe1ae',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, manif.file_sums)
class ConflictDiamondTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def _export(self, name, version, deps=None, export=True):
deps = ", ".join(['"%s"' % d for d in deps or []]) or '""'
conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
name = "%s"
version = "%s"
requires = %s
""" % (name, version, deps)
files = {CONANFILE: conanfile}
self.client.save(files, clean_first=True)
if export:
self.client.run("export . lasote/stable")
def reuse_test(self):
self._export("Hello0", "0.1")
self._export("Hello0", "0.2")
self._export("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._export("Hello2", "0.1", ["Hello0/0.2@lasote/stable"])
self._export("Hello3", "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
export=False)
error = self.client.run("install . --build missing", ignore_error=True)
self.assertTrue(error)
self.assertIn("Conflict in Hello2/0.1@lasote/stable", self.client.user_io.out)
self.assertNotIn("PROJECT: Generated conaninfo.txt", self.client.user_io.out)
def test_disable_linter(self):
client = TestClient()
client.save({CONANFILE: conanfile})
with tools.environment_append({"CONAN_RECIPE_LINTER": "False"}):
client.run("export . lasote/stable")
self.assertNotIn("ERROR: Py3 incompatibility", client.user_io.out)
self.assertNotIn("WARN: Linter", client.user_io.out)
def upload_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
self.client.save(files)
self.client.run("export . lasote/stable")
self.client.run("upload %s" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# The remote, once fixed does not change
self.client.run("upload %s -r=remote1" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# Now install it in other machine from remote 0
client2 = TestClient(servers=self.servers, users=self.users)
client2.run("install %s --build=missing" % str(conan_reference))
client2.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", client2.user_io.out)
# Now install it in other machine from remote 1
servers = self.servers.copy()
servers.pop("remote0")
client3 = TestClient(servers=servers, users=self.users)
client3.run("install %s --build=missing" % str(conan_reference))
client3.run("info %s" % str(conan_reference))
self.assertIn("remote1=http://", client3.user_io.out)
def new_ci_test(self):
client = TestClient()
client.run('new MyPackage/1.3@myuser/testing -cis -ciw -cilg -cilc -cio -ciu=myurl')
root = client.current_folder
build_py = load(os.path.join(root, "build.py"))
self.assertIn('builder.add_common_builds(shared_option_name="MyPackage:shared")',
build_py)
self.assertNotIn('visual_versions=', build_py)
self.assertNotIn('gcc_versions=', build_py)
self.assertNotIn('clang_versions=', build_py)
self.assertNotIn('apple_clang_versions=', build_py)
appveyor = load(os.path.join(root, "appveyor.yml"))
self.assertIn("CONAN_UPLOAD: \"myurl\"", appveyor)
self.assertIn('CONAN_REFERENCE: "MyPackage/1.3"', appveyor)
self.assertIn('CONAN_USERNAME: "******"', appveyor)
self.assertIn('CONAN_CHANNEL: "testing"', appveyor)
self.assertIn('CONAN_VISUAL_VERSIONS: 12', appveyor)
self.assertIn('CONAN_VISUAL_VERSIONS: 14', appveyor)
self.assertIn('CONAN_VISUAL_VERSIONS: 15', appveyor)
travis = load(os.path.join(root, ".travis.yml"))
self.assertIn("- CONAN_UPLOAD: \"myurl\"", travis)
self.assertIn('- CONAN_REFERENCE: "MyPackage/1.3"', travis)
self.assertIn('- CONAN_USERNAME: "******"', travis)
self.assertIn('- CONAN_CHANNEL: "testing"', travis)
self.assertIn('env: CONAN_GCC_VERSIONS=5.4 CONAN_DOCKER_IMAGE=lasote/conangcc54',
travis)
def test_patch_new_delete(self):
conanfile = base_conanfile + '''
def build(self):
from conans.tools import load, save
save("oldfile", "legacy code")
assert(os.path.exists("oldfile"))
patch_content = """--- /dev/null
+++ b/newfile
@@ -0,0 +0,3 @@
+New file!
+New file!
+New file!
--- a/oldfile
+++ b/dev/null
@@ -0,1 +0,0 @@
-legacy code
"""
patch(patch_string=patch_content)
self.output.info("NEW FILE=%s" % load("newfile"))
self.output.info("OLD FILE=%s" % os.path.exists("oldfile"))
'''
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("create . user/testing")
self.assertIn("test/1.9.10@user/testing: NEW FILE=New file!\nNew file!\nNew file!\n",
client.out)
self.assertIn("test/1.9.10@user/testing: OLD FILE=False", client.out)
def test_package_env_test(self):
client = TestClient()
conanfile = '''
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def package_info(self):
self.env_info.PYTHONPATH.append("new/pythonpath/value")
'''
test_package = '''
import os
from conans import ConanFile
class HelloTestConan(ConanFile):
requires = "Hello/0.1@lasote/testing"
def build(self):
assert("new/pythonpath/value" in os.environ["PYTHONPATH"])
def test(self):
assert("new/pythonpath/value" in os.environ["PYTHONPATH"])
'''
client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_package})
client.run("test_package")
def scopes_test_package_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def build(self):
self.output.info("Scope: %s" % self.scope)
"""
test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
client.save({"conanfile.py": conanfile,
"test/conanfile.py": test_conanfile})
client.run("test_package --scope Hello:dev=True --build=missing")
self.assertIn("Hello/0.1@lasote/stable: Scope: dev=True", client.user_io.out)
def test_package_folder(self):
# https://github.com/conan-io/conan/issues/2350
conanfile = """from conans import ConanFile
class HelloPythonConan(ConanFile):
settings = "os"
def package(self):
self.output.info("PACKAGE NOT CALLED")
raise Exception("PACKAGE NOT CALLED")
"""
client = TestClient()
client.save({CONANFILE: conanfile,
"pkg/myfile.h": "",
"profile": "[settings]\nos=Windows"})
client.run("export-pkg . Hello/0.1@lasote/stable -pf=pkg -pr=profile")
self.assertNotIn("PACKAGE NOT CALLED", client.out)
self.assertIn("Hello/0.1@lasote/stable: Copied 1 '.h' file: myfile.h", client.out)
ref = ConanFileReference.loads("Hello/0.1@lasote/stable")
pkg_folder = client.client_cache.packages(ref)
folders = os.listdir(pkg_folder)
pkg_folder = os.path.join(pkg_folder, folders[0])
conaninfo = load(os.path.join(pkg_folder, "conaninfo.txt"))
self.assertEqual(2, conaninfo.count("os=Windows"))
manifest = load(os.path.join(pkg_folder, "conanmanifest.txt"))
self.assertIn("conaninfo.txt: f395060da1ffdeb934be8b62e4bd8a3a", manifest)
self.assertIn("myfile.h: d41d8cd98f00b204e9800998ecf8427e", manifest)
def verbose_version_test(self):
client = TestClient()
conanfile = TestConanFile("MyPkg", "0.1", requires=["MyOtherPkg/[~0.1]@user/testing"])
client.save({CONANFILE: str(conanfile)})
error = client.run("install . --build", ignore_error=True)
self.assertTrue(error)
self.assertIn("from requirement 'MyOtherPkg/[~0.1]@user/testing'", client.user_io.out)
def test_build_source_folders(self):
client = TestClient()
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
settings = "os"
def package(self):
self.copy("*.h", src="include", dst="inc")
self.copy("*.lib", src="lib", dst="lib")
"""
client.save({CONANFILE: conanfile,
"src/include/header.h": "//Windows header",
"src/include/header.txt": "",
"build/libs/what": "",
"build/lib/hello.lib": "My Lib",
"build/lib/bye.txt": ""})
client.run("export-pkg . Hello/0.1@lasote/stable -s os=Windows --build-folder=build "
"--source-folder=src")
conan_ref = ConanFileReference.loads("Hello/0.1@lasote/stable")
package_ref = PackageReference(conan_ref, "3475bd55b91ae904ac96fde0f106a136ab951a5e")
package_folder = client.client_cache.package(package_ref)
inc = os.path.join(package_folder, "inc")
self.assertEqual(os.listdir(inc), ["header.h"])
self.assertEqual(load(os.path.join(inc, "header.h")), "//Windows header")
lib = os.path.join(package_folder, "lib")
self.assertEqual(os.listdir(lib), ["hello.lib"])
self.assertEqual(load(os.path.join(lib, "hello.lib")), "My Lib")
def test_export_a_new_version(self):
self._create_packages_and_builds()
# Export an update of the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path3 = conan2.paths.export(self.conan_ref)
digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path3))
for name in list(files2.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143',
'conanfile.py': 'ad17cf00b3142728b03ac37782b9acd9',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest3.file_sums)
def test_global_tools_overrided(self):
client = TestClient()
tools._global_requester = None
tools._global_output = None
conanfile = """
from conans import ConanFile, tools
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def build(self):
assert(tools._global_requester != None)
assert(tools._global_output != None)
"""
client.save({"conanfile.py": conanfile})
client.run("build")
# Not test the real commmand get_command if it's setting the module global vars
tools._global_requester = None
tools._global_output = None
tmp = tempfile.mkdtemp()
conf = default_client_conf.replace("\n[proxies]", "\n[proxies]\nhttp = http://myproxy.com")
os.mkdir(os.path.join(tmp, ".conan"))
save(os.path.join(tmp, ".conan", CONAN_CONF), conf)
with tools.environment_append({"CONAN_USER_HOME": tmp}):
conan_api = ConanAPIV1.factory()
conan_api.remote_list()
self.assertEquals(tools._global_requester.proxies, {"http": "http://myproxy.com"})
self.assertIsNotNone(tools._global_output.warn)
def test_export_the_same_code(self):
file_list = self._create_packages_and_builds()
# Export the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path2 = conan2.paths.export(self.conan_ref)
digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path2))
for name in list(files2.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143',
'conanfile.py': '355949fbf0b4fc32b8f1c5a338dfe1ae',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest2.file_sums)
for f in file_list:
self.assertTrue(os.path.exists(f))
def _upload_with_credentials(credentials):
cli = TestClient(servers=self.servers, users={})
save(os.path.join(cli.current_folder, CONANFILE), conan_content)
cli.run("export . lasote/testing")
with tools.environment_append(credentials):
cli.run("upload %s" % str(self.conan_reference))
return cli
def test_with_no_user(self):
test_server = TestServer()
client = TestClient(servers={"default": test_server})
error = client.run('user -p test', ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: User for remote 'default' is not defined. [Remote: default]",
client.out)
def new_without_test(self):
client = TestClient()
client.run('new MyPackage/1.3@myuser/testing')
root = client.current_folder
self.assertTrue(os.path.exists(os.path.join(root, "conanfile.py")))
self.assertFalse(os.path.exists(os.path.join(root, "test_package/conanfile.py")))
self.assertFalse(os.path.exists(os.path.join(root, "test_package/CMakeLists.txt")))
self.assertFalse(os.path.exists(os.path.join(root, "test_package/example.cpp")))
def verify_ssl_error_test(self):
client = TestClient()
error = client.run("remote add my-remote http://someurl some_invalid_option=foo",
ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: Unrecognized boolean value 'some_invalid_option=foo'",
client.user_io.out)
self.assertEqual("", load(client.client_cache.registry))
def invalid_reference_error_test(self):
""" Trying to upload an invalid reference must raise an Error
"""
client = TestClient()
error = client.run("upload some_nonsense -p hash1", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: -p parameter only allowed with a valid recipe reference",
client.user_io.out)
def not_existing_error_test(self):
""" Trying to upload with pattern not matched must raise an Error
"""
client = TestClient()
error = client.run("upload some_nonsense", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: No packages found matching pattern 'some_nonsense'",
client.user_io.out)
def create_empty_property_file_test(self):
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
client.save(files)
client.run("export lasote/stable")
props_file = client.client_cache.put_headers_path
self.assertTrue(os.path.exists(props_file))
def search_with_no_registry_test(self):
# https://github.com/conan-io/conan/issues/2589
client = TestClient()
os.remove(os.path.join(client.client_cache.registry))
error = client.run("search nonexist/1.0@lasote/stable -r=myremote", ignore_error=True)
self.assertTrue(error)
self.assertIn("WARN: Remotes registry file missing, creating default one", client.out)
self.assertIn("ERROR: No remote 'myremote' defined in remotes", client.out)
def non_existing_package_error_test(self):
""" Trying to upload a non-existing package must raise an Error
"""
client = TestClient()
error = client.run("upload Pkg/0.1@user/channel -p hash1", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: There is no local conanfile exported as Pkg/0.1@user/channel",
client.user_io.out)
def test_conan_data_everywhere(self):
client = TestClient()
conanfile = """from conans import ConanFile
class Lib(ConanFile):
def _assert_data(self):
assert(self.conan_data["sources"]["all"]["url"] == "the url")
assert(self.conan_data["sources"]["all"]["other"] == "field")
self.output.info("My URL: {}".format(self.conan_data["sources"]["all"]["url"]))
def configure(self):
self._assert_data()
def config_options(self):
self._assert_data()
def source(self):
self._assert_data()
def build(self):
self._assert_data()
def package(self):
self._assert_data()
def package_info(self):
self._assert_data()
"""
client.save({"conanfile.py": conanfile,
"conandata.yml": """
sources:
all:
url: "the url"
other: "field"
"""})
ref = ConanFileReference.loads("Lib/0.1@user/testing")
client.run("create . {}".format(ref))
self.assertIn("File 'conandata.yml' found. Exporting it...", client.out)
self.assertIn("My URL:", client.out)
export_folder = client.cache.package_layout(ref).export()
self.assertTrue(os.path.exists(os.path.join(export_folder, "conandata.yml")))
# Transitive loaded?
client.save({"conanfile.txt": "[requires]\n{}".format(ref)}, clean_first=True)
client.run("install . ")
self.assertIn("My URL:", client.out)
client.run("install . --build")
self.assertIn("My URL:", client.out)
def pythonpath_env_injection_test(self):
# Save some custom python code in custom dir
external_py = '''
def external_baz():
print("External baz")
'''
external_dir = temp_folder()
save(os.path.join(external_dir, "external.py"), external_py)
conanfile = """
import os
from conans import ConanFile, tools
class ConanToolPackage(ConanFile):
name = "conantool"
version = "1.0"
exports = "*"
build_policy = "missing"
def build(self):
with tools.pythonpath(self):
import external
external.external_baz()
def package(self):
self.copy("*")
def package_info(self):
self.env_info.PYTHONPATH.append(self.package_folder)
"""
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
# We can't build the package without our PYTHONPATH
self.assertRaises(Exception, client.run, "install conantool/1.0@lasote/stable --build missing")
# But we can inject the PYTHONPATH
client.run("install conantool/1.0@lasote/stable -e PYTHONPATH=['%s']" % external_dir)
# Now we want to reuse the package and access both external stuff and mytest.py stuff
reuse = """from conans import ConanFile, tools
class ToolsTest(ConanFile):
name = "Consumer"
version = "0.1"
requires = "conantool/1.0@lasote/stable"
def build(self):
with tools.pythonpath(self):
import mytest
mytest.foo(self.output)
import external
external.external_baz()
"""
client.save({CONANFILE: reuse})
client.run("install . --build -e PYTHONPATH=['%s']" % external_dir)
client.run("build .")
info = ConanInfo.loads(load(os.path.join(client.current_folder, "conaninfo.txt")))
pythonpath = info.env_values.env_dicts(None)[1]["PYTHONPATH"]
self.assertEquals(os.path.normpath(pythonpath[0]), os.path.normpath(external_dir))
self.assertTrue(len(pythonpath), 2)
def errors_test(self):
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("install .")
# BUILD_INFO is created by default, remove it to check message
os.remove(os.path.join(client.current_folder, BUILD_INFO))
client.run("source .", ignore_error=True)
# Output in py3 is different, uses single quote
# Now it works automatically without the env generator file
self.assertIn("No module named mytest", str(client.user_io.out).replace("'", ""))
def test_local_monorepo(self):
t = TestClient(path_with_spaces=False)
t.runner("svn co {} .".format(self.url), cwd=t.current_folder)
self._run_local_test(t, t.current_folder,
os.path.join("lib1", self.path_to_conanfile))
def test_cmake_virtualenv():
client = TestClient()
client.run("new hello/0.1 -s")
client.run("create .")
cmakewrapper = textwrap.dedent(r"""
from conans import ConanFile
import os
from conans.tools import save, chdir
class Pkg(ConanFile):
def package(self):
with chdir(self.package_folder):
save("cmake.bat", "@echo off\necho MYCMAKE WRAPPER!!\ncmake.exe %*")
save("cmake.sh", 'echo MYCMAKE WRAPPER!!\ncmake "$@"')
os.chmod("cmake.sh", 0o777)
def package_info(self):
# Custom buildenv not defined by cpp_info
self.buildenv_info.prepend_path("PATH", self.package_folder)
""")
consumer = textwrap.dedent("""
from conans import ConanFile
from conan.tools.cmake import CMake
class App(ConanFile):
settings = "os", "arch", "compiler", "build_type"
exports_sources = "CMakeLists.txt", "main.cpp"
requires = "hello/0.1"
build_requires = "cmakewrapper/0.1"
generators = "CMakeDeps", "CMakeToolchain", "VirtualEnv"
apply_env = False
def build(self):
cmake = CMake(self)
if self.settings.os != "Windows":
cmake._cmake_program = "cmake.sh" # VERY DIRTY HACK
cmake.configure()
cmake.build()
""")
cmakelists = textwrap.dedent("""
cmake_minimum_required(VERSION 3.15)
project(MyApp CXX)
find_package(hello)
add_executable(app main.cpp)
target_link_libraries(app hello::hello)
""")
client.save(
{
"cmakewrapper/conanfile.py":
cmakewrapper,
"consumer/conanfile.py":
consumer,
"consumer/main.cpp":
gen_function_cpp(name="main", includes=["hello"], calls=["hello"]),
"consumer/CMakeLists.txt":
cmakelists
},
clean_first=True)
client.run("create cmakewrapper cmakewrapper/0.1@")
client.run("create consumer consumer/0.1@")
assert "MYCMAKE WRAPPER!!" in client.out
assert "consumer/0.1: Created package" in client.out
def find_package_priority_test(self):
"""A package findXXX has priority over the CMake installation one and the curdir one"""
client = TestClient()
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Zlib"
version = "0.1"
exports = "*"
def package(self):
self.copy(pattern="*", keep_path=False)
"""
files = {"conanfile.py": conanfile,
"FindZLIB.cmake": 'MESSAGE("HELLO FROM THE PACKAGE FIND PACKAGE!")'}
client.save(files)
client.run("create . user/channel")
files = {"CMakeLists.txt": """
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/../conan_paths.cmake)
find_package(ZLIB REQUIRED)
"""}
build_dir = os.path.join(client.current_folder, "build")
files["FindZLIB.cmake"] = 'MESSAGE("HELLO FROM THE INSTALL FOLDER!")'
client.save(files, clean_first=True)
os.mkdir(build_dir)
client.run("install Zlib/0.1@user/channel -g cmake_paths")
ret = client.runner("cmake .. ", cwd=build_dir)
self.assertEquals(ret, 0)
self.assertIn("HELLO FROM THE PACKAGE FIND PACKAGE!", client.out)
# Now consume the zlib package as a require with the cmake_find_package
# and the "cmake" generator. Should prioritize the one from the package.
conanfile = """from conans import ConanFile, CMake
class TestConan(ConanFile):
name = "Consumer"
version = "0.1"
exports = "*"
settings = "compiler", "arch"
generators = "cmake_find_package", "cmake"
requires = "Zlib/0.1@user/channel"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
self.copy(pattern="*", keep_path=False)
"""
files = {"conanfile.py": conanfile,
"CMakeLists.txt": """
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
find_package(ZLIB REQUIRED)
"""}
client.save(files, clean_first=True)
client.run("create . user/channel")
self.assertIn("HELLO FROM THE PACKAGE FIND PACKAGE!", client.out)
self.assertNotIn("Conan: Using autogenerated FindZlib.cmake", client.out)
def test_upload_export_pkg(self):
"""
Package metadata created when doing an export-pkg and then uploading the package works
"""
server1 = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers = OrderedDict()
servers["server1"] = server1
client = TestClient(servers=servers)
client.save({"release/kk.lib": ""})
client.run("user lasote -r server1 -p mypass")
client.run("new hello/1.0 --header")
client.run("export-pkg . user/testing -pf release")
client.run("upload hello/1.0@user/testing --all -r server1")
self.assertNotIn(
"Binary package hello/1.0@user/testing:5%s not found" %
NO_SETTINGS_PACKAGE_ID, client.out)
ref = ConanFileReference("hello", "1.0", "user", "testing")
metadata = client.cache.package_layout(ref).load_metadata()
self.assertIn(NO_SETTINGS_PACKAGE_ID, metadata.packages)
self.assertTrue(metadata.packages[NO_SETTINGS_PACKAGE_ID].revision)
def basic_source_test(self):
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("install .")
client.run("source .")
self.assertIn("Hello Baz", client.user_io.out)
self.assertNotIn("Hello Foo", client.user_io.out)
self.assertNotIn("Hello Bar", client.user_io.out)
self.assertNotIn("Hello Boom", client.user_io.out)
def upload_reuse_test(self):
server = TestServer()
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("export . lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
client.run("upload conantool/1.0@lasote/stable --all")
client.run("remove * -f")
client.run("search")
self.assertNotIn("lasote/stable", client.user_io.out)
client.run("export . lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
# Try again, just in case
client.run("upload conantool/1.0@lasote/stable --all")
client.run("remove * -f -r=default")
client.run("upload conantool/1.0@lasote/stable --all")
def transitive_flags_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py})
client.run("export . lasote/testing")
client.save({"conanfile.py": chatconanfile_py}, clean_first=True)
client.run("export . lasote/testing")
client.save({"conanfile.txt": conanfile.replace("Hello", "Chat"),
"CMakeLists.txt": cmake}, clean_first=True)
client.run('install . -g cmake')
generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else ""
client.run_command("cmake . %s" % generator)
cmake_cxx_flags = self._get_line(client.out, "CMAKE_CXX_FLAGS")
self.assertTrue(cmake_cxx_flags.endswith("MyFlag1 MyFlag2 MyChatFlag1 MyChatFlag2"))
self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2 MyChatFlag1 MyChatFlag2",
client.out)
def flags_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py})
client.run("export . lasote/testing")
client.save({"conanfile.txt": conanfile,
"CMakeLists.txt": cmake}, clean_first=True)
client.run('install . -g cmake')
generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else ""
client.run_command("cmake . %s" % generator)
cmake_cxx_flags = self._get_line(client.out, "CMAKE_CXX_FLAGS")
self.assertTrue(cmake_cxx_flags.endswith("MyFlag1 MyFlag2"))
self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2", client.out)
self.assertIn("CMAKE_C_FLAGS= -load C:\some\path", client.out)
self.assertIn("CONAN_C_FLAGS=-load C:\some\path ", client.out)
self.assertIn('CONAN_DEFINES_HELLO=-DMY_DEF=My" \string;-DMY_DEF2=My${} other \string',
client.out)
def transitive_targets_flags_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py})
client.run("export . lasote/testing")
client.save({"conanfile.py": chatconanfile_py}, clean_first=True)
client.run("export . lasote/testing")
cmake_targets = cmake.replace("conan_basic_setup()",
"conan_basic_setup(TARGETS)\n"
"get_target_property(HELLO_FLAGS CONAN_PKG::Hello"
" INTERFACE_COMPILE_OPTIONS)\n"
"get_target_property(CHAT_FLAGS CONAN_PKG::Chat"
" INTERFACE_COMPILE_OPTIONS)\n"
"get_target_property(HELLO_DEFINES CONAN_PKG::Hello"
" INTERFACE_COMPILE_DEFINITIONS)")
client.save({"conanfile.txt": conanfile.replace("Hello", "Chat"),
"CMakeLists.txt": cmake_targets},
clean_first=True)
client.run('install . -g cmake')
generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else ""
client.run_command("cmake . %s" % generator)
cmake_cxx_flags = self._get_line(client.out, "CMAKE_CXX_FLAGS")
self.assertNotIn("My", cmake_cxx_flags)
self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2 MyChatFlag1 MyChatFlag2",
client.out)
self.assertIn("HELLO_CXX_FLAGS=-load;C:\some\path;MyFlag1;MyFlag2;"
"$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;"
"$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out)
self.assertIn("CHAT_CXX_FLAGS=MyChatFlag1;MyChatFlag2;"
"$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;"
"$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out)
self.assertIn('HELLO_DEFINES=MY_DEF=My" \string;MY_DEF2=My${} other \string;', client.out)
def cmake_shared_flag_test(self):
conanfile = """
import os
from conans import ConanFile, CMake
class MyLib(ConanFile):
name = "MyLib"
version = "0.1"
options = {"shared": [True, False]}
default_options= "shared=%s"
settings = "arch", "compiler"
def build(self):
cmake = CMake(self)
if self.options.shared:
assert(cmake.definitions["BUILD_SHARED_LIBS"] == "ON")
else:
assert(cmake.definitions["BUILD_SHARED_LIBS"] == "OFF")
"""
client = TestClient()
client.save({"conanfile.py": conanfile % "True"})
client.run("build .", assert_error=True)
self.assertIn("conanbuildinfo.txt file not found", client.out)
client.run("install .")
client.run("build .")
client.save({"conanfile.py": conanfile % "False"}, clean_first=True)
client.run("install .")
client.run("build .")
def std_flag_applied_test(self):
conanfile = """
import os
from conans import ConanFile, CMake
class MyLib(ConanFile):
name = "MyLib"
version = "0.1"
settings = "arch", "compiler", "cppstd"
generators = "cmake"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
"""
client = TestClient()
client.save({"conanfile.py": conanfile,
"mylib.cpp": "auto myfunc(){return 3;}", # c++14 feature
"CMakeLists.txt": """
cmake_minimum_required(VERSION 2.8.12)
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
add_library(mylib mylib.cpp)
target_link_libraries(mylib ${CONAN_LIBS})
"""})
if platform.system() != "Windows":
with catch_deprecation_warning(self):
client.run("install . --install-folder=build -s cppstd=gnu98")
client.run("build . --build-folder=build", assert_error=True)
self.assertIn("Error in build()", client.out)
# Now specify c++14
with catch_deprecation_warning(self):
client.run("install . --install-folder=build -s cppstd=gnu14")
client.run("build . --build-folder=build")
self.assertIn("CPP STANDARD: 14 WITH EXTENSIONS ON", client.out)
libname = "libmylib.a" if platform.system() != "Windows" else "mylib.lib"
libpath = os.path.join(client.current_folder, "build", "lib", libname)
self.assertTrue(os.path.exists(libpath))
with catch_deprecation_warning(self):
client.run("install . --install-folder=build -s cppstd=14")
client.run("build . --build-folder=build")
self.assertIn("CPP STANDARD: 14 WITH EXTENSIONS OFF", client.out)
self.assertNotIn("Conan setting CXX_FLAGS flags", client.out)
libname = "libmylib.a" if platform.system() != "Windows" else "mylib.lib"
libpath = os.path.join(client.current_folder, "build", "lib", libname)
self.assertTrue(os.path.exists(libpath))
def test_upload_key_error(self):
files = {"conanfile.py": GenConanfile("Hello0", "1.2.1")}
server1 = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
server2 = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers = OrderedDict()
servers["server1"] = server1
servers["server2"] = server2
client = TestClient(servers=servers)
client.save(files)
client.run("create . user/testing")
client.run("user lasote -p mypass")
client.run("user lasote -p mypass -r server2")
client.run("upload Hello0/1.2.1@user/testing --all -r server1")
client.run("remove * --force")
client.run("install Hello0/1.2.1@user/testing -r server1")
client.run("remote remove server1")
client.run("upload Hello0/1.2.1@user/testing --all -r server2")
self.assertNotIn("ERROR: 'server1'", client.out)
def fpic_applied_test(self):
conanfile = """
import os
from conans import ConanFile, CMake
class MyLib(ConanFile):
name = "MyLib"
version = "0.1"
settings = "arch", "compiler"
options = {"fPIC": [True, False]}
default_options = "fPIC=False"
generators = "cmake"
exports_sources = "CMakeLists.txt"
def build(self):
cmake = CMake(self)
cmake.configure()
"""
cmakelists = """
cmake_minimum_required(VERSION 2.8.12)
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
"""
client = TestClient()
client.save({"conanfile.py": conanfile,
"CMakeLists.txt": cmakelists})
client.run("create . user/channel -o MyLib:fPIC=True")
self.assertIn("Conan: Adjusting fPIC flag (ON)", client.out)
client.run("create . user/channel -o MyLib:fPIC=False")
self.assertIn("Conan: Adjusting fPIC flag (OFF)", client.out)
client.save({"conanfile.py": conanfile.replace("fPIC", "fpic")}, clean_first=False)
client.run("create . user/channel -o MyLib:fpic=True")
self.assertNotIn("Conan: Adjusting fPIC flag (ON)", client.out)
# Skip fpic adjustements in basic setup
tmp = cmakelists.replace("conan_basic_setup()", "conan_basic_setup(SKIP_FPIC)")
client.save({"CMakeLists.txt": tmp, "conanfile.py": conanfile}, clean_first=True)
client.run("create . user/channel -o MyLib:fPIC=True")
self.assertNotIn("Conan: Adjusting fPIC flag", client.out)
def basic_package_test(self):
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("export . lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build", ignore_error=True)
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
def reuse_test(self):
client = TestClient()
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export . lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("install .")
self.assertNotIn("Hello Bar", client.user_io.out) # IMPORTANT!! WTF? Why this test was passing? Why I'm missing?
self.assertNotIn("Hello Foo", client.user_io.out)
client.run("build .")
self.assertNotIn("Hello Bar", client.user_io.out)
self.assertIn("Hello Foo", client.user_io.out)
client.run("export . lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
def test_remote_monorepo_chdir(self):
t = TestClient(path_with_spaces=False)
t.runner("svn co {} .".format(self.url), cwd=t.current_folder)
self._run_remote_test(t, os.path.join(t.current_folder, "lib1"),
self.path_to_conanfile)
def test_local_root_folder(self):
t = TestClient(path_with_spaces=False)
t.runner('git clone "{}" .'.format(self.url), cwd=t.current_folder)
self._run_local_test(t, t.current_folder, self.path_to_conanfile)
def test_conan_data_development_flow(self):
client = TestClient()
conanfile = textwrap.dedent("""
from conans import ConanFile
class Lib(ConanFile):
def _assert_data(self):
assert(self.conan_data["sources"]["all"]["url"] == "this url")
assert(self.conan_data["sources"]["all"]["other"] == "field")
self.output.info("My URL: {}".format(self.conan_data["sources"]["all"]["url"]))
def source(self):
self._assert_data()
def build(self):
self._assert_data()
def package(self):
self._assert_data()
""")
conandata = textwrap.dedent("""
sources:
all:
url: "this url"
other: "field"
""")
client.save({"conanfile.py": conanfile,
"conandata.yml": conandata})
client.run("source . -sf tmp/source")
self.assertIn("My URL: this url", client.out)
client.run("install . -if tmp/install")
client.run("build . -if tmp/install -bf tmp/build")
self.assertIn("My URL: this url", client.out)
client.run("package . -sf tmp/source -if tmp/install -bf tmp/build -pf tmp/package")
self.assertIn("My URL: this url", client.out)
client.run("export-pkg . name/version@ -sf tmp/source -if tmp/install -bf tmp/build")
self.assertIn("My URL: this url", client.out)
def test_remote_root_folder(self):
t = TestClient(path_with_spaces=False)
t.runner("svn co {}/lib1 .".format(self.url), cwd=t.current_folder)
self._run_remote_test(t, t.current_folder, self.path_to_conanfile)
class IOSMesonTestCase(unittest.TestCase):
_conanfile_py = textwrap.dedent("""
from conans import ConanFile, tools
from conan.tools.meson import MesonToolchain
class App(ConanFile):
settings = "os", "arch", "compiler", "build_type"
options = {"shared": [True, False], "fPIC": [True, False]}
default_options = {"shared": False, "fPIC": True}
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def toolchain(self):
tc = MesonToolchain(self)
tc.generate()
def build(self):
# this will be moved to build helper eventually
with tools.vcvars(self) if self.settings.compiler == "Visual Studio" else tools.no_op():
self.run("meson setup --cross-file conan_meson_cross.ini build .")
self.run("meson compile -C build")
""")
_meson_build = textwrap.dedent("""
project('tutorial', 'cpp')
add_global_arguments('-DSTRING_DEFINITION="' + get_option('STRING_DEFINITION') + '"',
language : 'cpp')
hello = library('hello', 'hello.cpp')
executable('demo', 'main.cpp', link_with: hello)
""")
_meson_options_txt = textwrap.dedent("""
option('STRING_DEFINITION', type : 'string', description : 'a string option')
""")
def settings(self):
return [("os", self.os), ("os.version", self.os_version),
("arch", self.arch), ("compiler", "apple-clang"),
("compiler.version", "12.0"), ("compiler.libcxx", "libc++")]
def env(self):
cc = self.xcrun.cc
cxx = self.xcrun.cxx
cflags = apple_deployment_target_flag(self.os, self.os_version)
cflags += " -isysroot " + self.xcrun.sdk_path
cflags += " -arch " + to_apple_arch(self.arch)
cxxflags = cflags
return {'CC': cc, 'CXX': cxx, 'CFLAGS': cflags, 'CXXFLAGS': cxxflags}
def profile(self):
template = textwrap.dedent("""
include(default)
[settings]
{settings}
[env]
{env}
""")
settings = '\n'.join(
["%s = %s" % (s[0], s[1]) for s in self.settings()])
env = '\n'.join(["%s = %s" % (k, v) for k, v in self.env().items()])
return template.format(settings=settings, env=env)
@parameterized.expand([('armv8', 'iOS', '10.0', 'iphoneos'),
('armv7', 'iOS', '10.0', 'iphoneos'),
('x86', 'iOS', '10.0', 'iphonesimulator'),
('x86_64', 'iOS', '10.0', 'iphonesimulator')])
def test_meson_toolchain(self, arch, os_, os_version, sdk):
self.xcrun = XCRun(None, sdk)
self.arch = arch
self.os = os_
self.os_version = os_version
hello_h = gen_function_h(name="hello")
hello_cpp = gen_function_cpp(name="hello",
preprocessor=["STRING_DEFINITION"])
app = gen_function_cpp(name="main",
includes=["hello"],
calls=["hello"])
self.t = TestClient()
self.t.save({
"conanfile.py": self._conanfile_py,
"meson.build": self._meson_build,
"meson_options.txt": self._meson_options_txt,
"hello.h": hello_h,
"hello.cpp": hello_cpp,
"main.cpp": app,
"profile_host": self.profile()
})
self.t.run(
"install . --profile:build=default --profile:host=profile_host")
self.t.run("build .")
libhello = os.path.join(self.t.current_folder, "build", "libhello.a")
self.assertTrue(os.path.isfile(libhello))
demo = os.path.join(self.t.current_folder, "build", "demo")
self.assertTrue(os.path.isfile(demo))
lipo = self.xcrun.find('lipo')
self.t.run_command('"%s" -info "%s"' % (lipo, libhello))
self.assertIn("architecture: %s" % to_apple_arch(self.arch),
self.t.out)
self.t.run_command('"%s" -info "%s"' % (lipo, demo))
self.assertIn("architecture: %s" % to_apple_arch(self.arch),
self.t.out)
def test_native_export_multi(self):
"""
bye depends on hello. Both use find_package in their CMakeLists.txt
The consumer depends on bye, using the cmake_find_package_multi generator
"""
c = TestClient()
project_folder_name = "project_targets"
assets_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"assets/cmake_find_package_multi")
c.copy_from_assets(assets_path, ["bye", "hello", project_folder_name])
# Create packages for hello and bye
for p in ("hello", "bye"):
for bt in ("Debug", "Release"):
c.run("create {} user/channel -s build_type={}".format(p, bt))
with c.chdir(project_folder_name):
# Save conanfile and example
conanfile = textwrap.dedent("""
[requires]
bye/1.0@user/channel
[generators]
cmake_find_package_multi
""")
example_cpp = textwrap.dedent("""
#include <iostream>
#include "bye.h"
int main() {
bye();
}
""")
c.save({"conanfile.txt": conanfile, "example.cpp": example_cpp})
with c.chdir("build"):
for bt in ("Debug", "Release"):
c.run(
"install .. user/channel -s build_type={}".format(bt))
# Test that we are using find_dependency with the NO_MODULE option
# to skip finding first possible FindBye somewhere
self.assertIn(
"find_dependency(hello REQUIRED NO_MODULE)",
load(os.path.join(c.current_folder, "byeConfig.cmake")))
if platform.system() == "Windows":
c.run_command('cmake .. -G "Visual Studio 15 Win64"')
c.run_command('cmake --build . --config Debug')
c.run_command('cmake --build . --config Release')
c.run_command('Debug\\example.exe')
self.assertIn("Hello World Debug!", c.out)
self.assertIn("bye World Debug!", c.out)
c.run_command('Release\\example.exe')
self.assertIn("Hello World Release!", c.out)
self.assertIn("bye World Release!", c.out)
else:
for bt in ("Debug", "Release"):
c.run_command(
'cmake .. -DCMAKE_BUILD_TYPE={}'.format(bt))
c.run_command('cmake --build .')
c.run_command('./example')
self.assertIn("Hello World {}!".format(bt), c.out)
self.assertIn("bye World {}!".format(bt), c.out)
os.remove(os.path.join(c.current_folder, "example"))
def test_checksums_metadata(self):
client = TestClient(default_server_user=True)
client.save({"conanfile.py": GenConanfile()})
client.run('create . lib/1.0@user/channel')
client.run('upload lib/1.0 -c --all -r default')
ref = ConanFileReference("lib", "1.0", "user", "channel")
metadata = client.cache.package_layout(ref).load_metadata()
package_md5 = metadata.packages[NO_SETTINGS_PACKAGE_ID].checksums[
"conan_package.tgz"]["md5"]
package_sha1 = metadata.packages[NO_SETTINGS_PACKAGE_ID].checksums[
"conan_package.tgz"]["sha1"]
recipe_md5 = metadata.recipe.checksums["conanfile.py"]["md5"]
recipe_sha1 = metadata.recipe.checksums["conanfile.py"]["sha1"]
self.assertEqual(package_md5, "25f53ac9685e07815b990e7c6f21bfd0")
self.assertEqual(package_sha1,
"be152c82859285658a06816aaaec529a159c33d3")
self.assertEqual(recipe_md5, "8eda41e0997f3eacc436fb6c621d7396")
self.assertEqual(recipe_sha1,
"b97d6b26be5bd02252a44c265755f873cf5ec70b")
client.run('remove * -f')
client.run('install lib/1.0@user/channel -r default')
metadata = client.cache.package_layout(ref).load_metadata()
self.assertEqual(
metadata.packages[NO_SETTINGS_PACKAGE_ID].
checksums["conan_package.tgz"]["md5"], package_md5)
self.assertEqual(
metadata.packages[NO_SETTINGS_PACKAGE_ID].
checksums["conan_package.tgz"]["sha1"], package_sha1)
self.assertEqual(metadata.recipe.checksums["conanfile.py"]["md5"],
recipe_md5)
self.assertEqual(metadata.recipe.checksums["conanfile.py"]["sha1"],
recipe_sha1)
def test_complete():
client = TestClient()
client.run("new myopenssl/1.0 -m=v2_cmake")
client.run("create . -o myopenssl:shared=True")
client.run("create . -o myopenssl:shared=True -s build_type=Debug")
mycmake_main = gen_function_cpp(name="main",
msg="mycmake",
includes=["myopenssl"],
calls=["myopenssl"])
mycmake_conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.cmake import CMake
class App(ConanFile):
settings = "os", "arch", "compiler", "build_type"
requires = "myopenssl/1.0"
default_options = {"myopenssl:shared": True}
generators = "CMakeDeps", "CMakeToolchain", "VirtualEnv"
exports = "*"
apply_env = False
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
src = str(self.settings.build_type) if self.settings.os == "Windows" else ""
self.copy("mycmake*", src=src, dst="bin")
def package_info(self):
self.cpp_info.bindirs = ["bin"]
""")
mycmake_cmakelists = textwrap.dedent("""
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
cmake_minimum_required(VERSION 3.15)
project(MyCmake CXX)
find_package(myopenssl REQUIRED)
add_executable(mycmake main.cpp)
target_link_libraries(mycmake PRIVATE myopenssl::myopenssl)
""")
client.save(
{
"conanfile.py": mycmake_conanfile,
"CMakeLists.txt": mycmake_cmakelists,
"main.cpp": mycmake_main
},
clean_first=True)
client.run("create . mycmake/1.0@")
mylib = textwrap.dedent(r"""
from conans import ConanFile
import os
from conan.tools.cmake import CMake
class Pkg(ConanFile):
settings = "os", "compiler", "build_type", "arch"
build_requires = "mycmake/1.0"
requires = "myopenssl/1.0"
default_options = {"myopenssl:shared": True}
exports_sources = "CMakeLists.txt", "main.cpp"
generators = "CMakeDeps", "CMakeToolchain", "VirtualEnv"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
self.run("mycmake")
self.output.info("RUNNING MYAPP")
if self.settings.os == "Windows":
self.run(os.sep.join([".", str(self.settings.build_type), "myapp"]),
env="conanrunenv")
else:
self.run(os.sep.join([".", "myapp"]), env="conanrunenv")
""")
cmakelists = textwrap.dedent("""
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
cmake_minimum_required(VERSION 3.15)
project(MyApp CXX)
find_package(myopenssl)
add_executable(myapp main.cpp)
target_link_libraries(myapp myopenssl::myopenssl)
""")
client.save(
{
"conanfile.py":
mylib,
"main.cpp":
gen_function_cpp(name="main",
msg="myapp",
includes=["myopenssl"],
calls=["myopenssl"]),
"CMakeLists.txt":
cmakelists
},
clean_first=True)
client.run(
"create . myapp/0.1@ -s:b build_type=Release -s:h build_type=Debug")
first, last = str(client.out).split("RUNNING MYAPP")
assert "mycmake: Release!" in first
assert "myopenssl/1.0: Hello World Release!" in first
assert "myapp: Debug!" in last
assert "myopenssl/1.0: Hello World Debug!" in last
def cmake_paths_integration_test(self):
"""First package with own findHello0.cmake file"""
client = TestClient()
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello0"
version = "0.1"
exports = "*"
def package(self):
self.copy(pattern="*", keep_path=False)
"""
files = {"conanfile.py": conanfile,
"FindHello0.cmake": """
SET(Hello0_FOUND 1)
MESSAGE("HELLO FROM THE Hello0 FIND PACKAGE!")
"""}
client.save(files)
client.run("create . user/channel")
# Directly using CMake as a consumer we can find it with the "cmake_paths" generator
files = {"CMakeLists.txt": """
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
cmake_minimum_required(VERSION 2.8)
find_package(Hello0 REQUIRED)
"""}
client.save(files, clean_first=True)
client.run("install Hello0/0.1@user/channel -g cmake_paths")
self.assertTrue(os.path.exists(os.path.join(client.current_folder,
"conan_paths.cmake")))
# Without the toolchain we cannot find the package
build_dir = os.path.join(client.current_folder, "build")
os.mkdir(build_dir)
ret = client.runner("cmake ..", cwd=build_dir)
shutil.rmtree(build_dir)
self.assertNotEqual(ret, 0)
# With the toolchain everything is ok
os.mkdir(build_dir)
ret = client.runner("cmake .. -DCMAKE_TOOLCHAIN_FILE=../conan_paths.cmake",
cwd=build_dir)
self.assertEqual(ret, 0)
self.assertIn("HELLO FROM THE Hello0 FIND PACKAGE!", client.out)
# Now try without toolchain but including the file
files = {"CMakeLists.txt": """
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/../conan_paths.cmake)
find_package(Hello0 REQUIRED)
"""}
client.save(files, clean_first=True)
os.mkdir(build_dir)
client.run("install Hello0/0.1@user/channel -g cmake_paths")
ret = client.runner("cmake .. ", cwd=build_dir)
self.assertEqual(ret, 0)
self.assertIn("HELLO FROM THE Hello0 FIND PACKAGE!", client.out)
def build_app_test(self, targets):
client = TestClient()
conanfile_py = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def package_info(self):
self.cpp_info.defines = [r'MY_DEF=My${} $string', r'MY_DEF2=My$ other string']
"""
client.save({"conanfile.py": conanfile_py})
client.run("create . lasote/testing")
consumer = """from conans import ConanFile, CMake
import os
class App(ConanFile):
settings = "os", "compiler", "arch", "build_type"
requires = "Hello/0.1@lasote/testing"
generators = "cmake"
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
self.run(os.sep.join([".", "bin", "myapp"]))
"""
cmake_app = """cmake_minimum_required(VERSION 2.8.12)
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup(%s)
add_executable(myapp myapp.cpp)
conan_target_link_libraries(myapp)
""" % ("TARGETS" if targets else "")
myapp = r"""#include <iostream>
#define STRINGIFY(x) #x
#define STRINGIFYMACRO(y) STRINGIFY(y)
int main(){
std::cout << "Msg1: " << STRINGIFYMACRO(MY_DEF) << "\n";
std::cout << "Msg2: " << STRINGIFYMACRO(MY_DEF2) << "\n";
}"""
client.save({"conanfile.py": consumer,
"CMakeLists.txt": cmake_app,
"myapp.cpp": myapp
}, clean_first=True)
client.run("install .")
client.run("build .")
self.assertIn("Msg1: My${} $string", client.out)
self.assertIn("Msg2: My$ other string", client.out)
def find_package_priority2_test(self):
"""A system findXXX has NOT priority over the install folder one,
the zlib package do not package findZLIB.cmake"""
client = TestClient()
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Zlib"
version = "0.1"
exports = "*"
def package(self):
self.copy(pattern="*", keep_path=False)
"""
files = {"conanfile.py": conanfile}
client.save(files)
client.run("create . user/channel")
files = {"CMakeLists.txt": """
set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/../conan_paths.cmake)
find_package(ZLIB REQUIRED)
"""}
build_dir = os.path.join(client.current_folder, "build")
files["FindZLIB.cmake"] = 'MESSAGE("HELLO FROM THE INSTALL FOLDER!")'
client.save(files, clean_first=True)
os.mkdir(build_dir)
client.run("install Zlib/0.1@user/channel -g cmake_paths")
ret = client.runner("cmake .. ", cwd=build_dir)
self.assertEquals(ret, 0)
self.assertIn("HELLO FROM THE INSTALL FOLDER!", client.out)
def test_upload_login_prompt_disabled_user_authenticated(self):
# When user is authenticated, uploads should work even when login prompt has been disabled.
client = TestClient(default_server_user=True)
client.save({"conanfile.py": GenConanfile("Hello0", "1.2.1")})
client.run("config set general.non_interactive=True")
client.run("create . user/testing")
client.run("user -c")
client.run("user user -p password")
client.run("upload Hello0/1.2.1@user/testing")
self.assertIn("Uploading conanmanifest.txt", client.out)
self.assertIn("Uploading conanfile.py", client.out)
