def remove_specific_builds_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("export user/channel")
client.save({"conanfile.txt": consumer}, clean_first=True)
client.run('install -s build_type=Debug')
client.run('install -s build_type=Release')
ref = ConanFileReference.loads("Pkg/0.1@user/channel")
def _check_builds():
builds = client.client_cache.conan_builds(ref)
self.assertEqual(1, len(builds))
packages = client.client_cache.conan_packages(ref)
self.assertEqual(2, len(packages))
self.assertNotIn(builds[0], packages)
return builds[0], packages
build, packages = _check_builds()
client.run("remove Pkg/0.1@user/channel -b %s -f" % packages[0])
_check_builds()
client.run("remove Pkg/0.1@user/channel -b %s -f" % build)
builds = client.client_cache.conan_builds(ref)
self.assertEqual(0, len(builds))
packages = client.client_cache.conan_packages(ref)
self.assertEqual(2, len(packages))
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_build_mode_requires(self):
client = TestClient()
self._create(client)
client.save({CONANFILE: lib_conanfile,
"profile.txt": profile}, clean_first=True)
error = client.run("install --profile ./profile.txt", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: Missing prebuilt package for 'PythonTool/0.1@lasote/stable'",
client.user_io.out)
error = client.run("install --profile ./profile.txt --build=PythonTool",
ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: Missing prebuilt package for 'Tool/0.1@lasote/stable'",
client.user_io.out)
client.run("install --profile ./profile.txt --build=*Tool")
self.assertIn("Installed build requires: [Tool/0.1@lasote/stable, "
"PythonTool/0.1@lasote/stable]", client.user_io.out)
self.assertIn("Tool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out)
self.assertIn("PythonTool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out)
# now remove packages, ensure --build=missing also creates them
client.run('remove "*" -p -f')
client.run("install --profile ./profile.txt --build=missing")
self.assertIn("Installed build requires: [Tool/0.1@lasote/stable, "
"PythonTool/0.1@lasote/stable]", client.user_io.out)
self.assertIn("Tool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out)
self.assertIn("PythonTool/0.1@lasote/stable: Generated conaninfo.txt", client.user_io.out)
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)
def local_flow_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo",
CONANFILE: conanfile_template}
client.save(files)
origin_folder = client.current_folder
client.run("install -g env -g txt")
client.run("source")
client.run("build")
client.run("package .", ignore_error=True)
self.assertIn("ERROR: Cannot 'conan package' to the build folder", client.user_io.out)
package_folder = os.path.join(origin_folder, "package")
mkdir(package_folder)
client.current_folder = package_folder
client.run('package .. --build_folder=..')
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def test_path(self):
base_folder = temp_folder()
source_folder = os.path.join(base_folder, "source")
current_folder = os.path.join(base_folder, "current")
client = TestClient(current_folder=current_folder)
files = cpp_hello_conan_files("Hello0", "0.1")
conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
conanfile = files.pop("conanfile.py")
client.save(files, path=source_folder)
conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"')
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
reg_path = client.paths.export(conan_ref)
manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
client.user_io.out)
self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in ['conanfile.py', 'conanmanifest.txt', 'source/main.cpp',
'source/executable', 'source/hello.cpp', 'source/CMakeLists.txt',
'source/helloHello0.h']:
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {'source/hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'source/main.cpp': '0479f3c223c9a656a718f3148e044124',
'source/CMakeLists.txt': '52546396c42f16be3daf72ecf7ab7143',
'conanfile.py': '3ac566eb5b2e4df4417003f0e606e237',
'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, manif.file_sums)
def value_parse_test(self):
# https://github.com/conan-io/conan/issues/2816
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "test"
version = "0.1"
settings = "os", "compiler", "arch", "build_type"
exports_sources = "header.h"
def package_id(self):
self.info.settings.compiler.version = "kk=kk"
def package(self):
self.copy("header.h", dst="include", keep_path=True)
"""
server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")], users={"lasote": "mypass"})
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": conanfile,
"header.h": "header content"})
client.run("create . danimtb/testing")
client.run("search test/0.1@danimtb/testing")
self.assertIn("compiler.version: kk=kk", client.out)
client.run("upload test/0.1@danimtb/testing --all")
client.run("remove test/0.1@danimtb/testing --force")
client.run("install test/0.1@danimtb/testing")
client.run("search test/0.1@danimtb/testing")
self.assertIn("compiler.version: kk=kk", client.out)
def remove_option_setting_test(self):
# https://github.com/conan-io/conan/issues/2826
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
settings = "os"
options = {"opt": [True, False]}
default_options = "opt=False"
def package_id(self):
self.output.info("OPTION OPT=%s" % self.info.options.opt)
del self.info.settings.os
del self.info.options.opt
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("create . Pkg/0.1@user/testing -s os=Windows")
self.assertIn("Pkg/0.1@user/testing: OPTION OPT=False", client.out)
self.assertIn("Pkg/0.1@user/testing: Package "
"'5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' created",
client.out)
client.run("create . Pkg/0.1@user/testing -s os=Linux -o Pkg:opt=True")
self.assertIn("Pkg/0.1@user/testing: OPTION OPT=True", client.out)
self.assertIn("Pkg/0.1@user/testing: Package "
"'5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' created",
client.out)
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 basic_source_test(self):
conanfile = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "Hello"
version = "0.1"
def source(self):
self.output.info("Running source!")
'''
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("export lasote/stable")
client.run("source Hello/0.1@lasote/stable")
self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
# The second call shouldn't have effect
client.run("source Hello/0.1@lasote/stable")
self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
self.assertNotIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
# Forced should have effect
client.run("source Hello/0.1@lasote/stable --force")
self.assertIn("WARN: Forced removal of source folder", client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
def local_source_test(self):
conanfile = '''
from conans import ConanFile
from conans.util.files import save
class ConanLib(ConanFile):
def source(self):
self.output.info("Running source!")
err
save("file1.txt", "Hello World")
'''
# First, failing source()
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("source .", ignore_error=True)
self.assertIn("PROJECT: Running source!", client.user_io.out)
self.assertIn("ERROR: PROJECT: Error in source() method, line 9", client.user_io.out)
# Fix the error and repeat
client.save({CONANFILE: conanfile.replace("err", "")})
client.run("source .")
self.assertIn("PROJECT: Configuring sources in", client.user_io.out)
self.assertIn("PROJECT: WARN: Your previous source command failed", client.user_io.out)
self.assertIn("PROJECT: Running source!", client.user_io.out)
self.assertEqual("Hello World", load(os.path.join(client.current_folder, "file1.txt")))
def fail_test_package_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports = "*"
def package(self):
self.copy("*")
"""
test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
client.save({"conanfile.py": conanfile,
"FindXXX.cmake": "Hello FindCmake",
"test/conanfile.py": test_conanfile})
client.run("test_package")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertEqual("Hello FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
client.save({"FindXXX.cmake": "Bye FindCmake"})
client.run("test_package")
self.assertEqual("Bye FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
def transitive_same_name_test(self):
# https://github.com/conan-io/conan/issues/1366
client = TestClient()
conanfile = '''
from conans import ConanFile
class HelloConan(ConanFile):
name = "HelloBar"
version = "0.1"
'''
test_package = '''
from conans import ConanFile
class HelloTestConan(ConanFile):
requires = "HelloBar/0.1@lasote/testing"
def test(self):
pass
'''
client.save({"conanfile.py": conanfile, "test_package/conanfile.py": test_package})
client.run("test_package")
self.assertIn("HelloBar/0.1@lasote/testing: WARN: Forced build from source",
client.user_io.out)
client.save({"conanfile.py": conanfile.replace("HelloBar", "Hello") +
" requires='HelloBar/0.1@lasote/testing'",
"test_package/conanfile.py": test_package.replace("HelloBar", "Hello")})
client.run("test_package")
self.assertNotIn("HelloBar/0.1@lasote/testing: WARN: Forced build from source",
client.user_io.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 upload_newer_recipe_test(self):
servers = {}
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = test_server
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
client.save(files)
client.run("export frodo/stable")
client.run("install Hello0/1.2.1@frodo/stable --build=missing")
client.run("upload Hello0/1.2.1@frodo/stable --all")
client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client2.save(files)
client2.run("export frodo/stable")
ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable")
manifest = client2.client_cache.load_manifest(ref)
manifest.time += 10
save(client2.client_cache.digestfile_conanfile(ref), str(manifest))
client2.run("install Hello0/1.2.1@frodo/stable --build=missing")
client2.run("upload Hello0/1.2.1@frodo/stable --all")
self.assertNotIn("conanfile", client2.user_io.out)
self.assertIn("Package is up to date.", client2.user_io.out)
self.assertIn("Uploading conanmanifest.txt", client2.user_io.out)
# Now try again with the other client, which timestamp is older
client.run("upload Hello0/1.2.1@frodo/stable --all")
self.assertNotIn("conanfile", client2.user_io.out)
self.assertIn("Package is up to date.", client2.user_io.out)
self.assertIn("Uploading conanmanifest.txt", client.user_io.out)
class ProfileRequiresTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def _export(self, var_conanfile):
self.client.save({CONANFILE: var_conanfile}, clean_first=True)
self.client.run("export lasote/stable")
def test_profile_requires(self):
self._export(build_require_parent)
self._export(build_require)
self._export(build_require2)
self._export(my_lib_parent)
self._export(my_lib)
self._export(my_lib2)
reuse = """
[requires]
MyLib/0.1@lasote/stable
MyLib2/0.1@lasote/stable
[generators]
cmake
gcc
"""
self.client.save({"profile.txt": profile, "conanfile.txt": reuse}, clean_first=True)
self.client.run("install --profile ./profile.txt --build missing")
def copy_test(self):
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("export . lasote/stable")
client.run("install Hello0/0.1@lasote/stable --build=missing")
error = client.run("copy hello0/0.1@lasote/stable otheruser/testing", ignore_error=True)
self._check(error, client)
def patch_config_test(self):
client = TestClient()
conanfile = """from conans import ConanFile, CMake
from conans.tools import save, load
import os
class AConan(ConanFile):
settings = "os", "compiler", "build_type", "arch"
def build(self):
cmake = CMake(self)
save("file1.cmake", "FOLDER " + self.package_folder)
save("sub/file1.cmake", "FOLDER " + self.package_folder)
cmake.patch_config_paths()
def package(self):
self.copy("*")
self.output.info("RESULT: " + load(os.path.join(self.package_folder, "file1.cmake")))
self.output.info("RESULT2: " + load(os.path.join(self.package_folder, "sub/file1.cmake")))
"""
client.save({"conanfile.py": conanfile})
client.run("create . Pkg/0.1@user/channel")
self.assertIn("Pkg/0.1@user/channel: RESULT: FOLDER ${CONAN_PKG_ROOT}", client.out)
self.assertIn("Pkg/0.1@user/channel: RESULT2: FOLDER ${CONAN_PKG_ROOT}", client.out)
client.run("install .")
error = client.run("build .", ignore_error=True)
self.assertTrue(error)
self.assertIn("ConanException: cmake.patch_config_paths() can't work without package name",
client.out)
def download_reference_with_packages_test(self):
server = TestServer()
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "pkg"
version = "0.1"
settings = "os"
"""
client.save({"conanfile.py": conanfile})
client.run("create . lasote/stable")
ref = ConanFileReference.loads("pkg/0.1@lasote/stable")
self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
package_folder = os.path.join(client.paths.conan(ref), "package", os.listdir(client.paths.packages(ref))[0])
client.run("upload pkg/0.1@lasote/stable --all")
client.run("remove pkg/0.1@lasote/stable -f")
self.assertFalse(os.path.exists(client.paths.export(ref)))
client.run("download pkg/0.1@lasote/stable")
# Check not 'No remote binary packages found' warning
self.assertNotIn("WARN: No remote binary packages found in remote", client.out)
# Check at conanfile.py is downloaded
self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
# Check package folder created
self.assertTrue(os.path.exists(package_folder))
def options_test(self):
conanfile = """from conans import ConanFile
class package(ConanFile):
name = "first"
version = "0.0.0"
options = {"coverage": [True, False]}
default_options = "coverage=False"
def build(self):
self.output.info("Coverage: %s" % self.options.coverage)
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("export . lasote/stable")
consumer = """from conans import ConanFile
class package(ConanFile):
name = "second"
version = "0.0.0"
default_options = "first:coverage=True"
build_requires = "first/0.0.0@lasote/stable"
"""
client.save({"conanfile.py": consumer})
client.run("install . --build=missing -o Pkg:someoption=3")
self.assertIn("first/0.0.0@lasote/stable: Coverage: True", client.user_io.out)
def not_reupload_test(self):
""" Check that if the package has not been modified, it is not uploaded
again
"""
servers = {}
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = test_server
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
client.save(files)
client.run("export frodo/stable")
client.run("install Hello0/1.2.1@frodo/stable --build=missing")
client.run("upload Hello0/1.2.1@frodo/stable -r default --all")
self.assertIn("Uploading conan_package.tgz", client.user_io.out)
client.run("remove Hello0/1.2.1@frodo/stable -f")
client.run("search")
self.assertNotIn("Hello0/1.2.1@frodo/stable", client.user_io.out)
client.run("install Hello0/1.2.1@frodo/stable")
self.assertIn("Downloading conan_package.tgz", client.user_io.out)
client.run("upload Hello0/1.2.1@frodo/stable -r default --all")
self.assertIn("Uploaded conan recipe", client.user_io.out)
self.assertNotIn("Uploading conan_package.tgz", client.user_io.out)
self.assertIn("Package is up to date", client.user_io.out)
def download_reference_without_packages_test(self):
server = TestServer()
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "pkg"
version = "0.1"
"""
client.save({"conanfile.py": conanfile})
client.run("export . lasote/stable")
ref = ConanFileReference.loads("pkg/0.1@lasote/stable")
self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
client.run("upload pkg/0.1@lasote/stable")
client.run("remove pkg/0.1@lasote/stable -f")
self.assertFalse(os.path.exists(client.paths.export(ref)))
client.run("download pkg/0.1@lasote/stable")
# Check 'No remote binary packages found' warning
self.assertTrue("WARN: No remote binary packages found in remote", client.out)
# Check at least conanfile.py is downloaded
self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
def generate_json_info_test(self):
conanfile_py = """from conans import ConanFile
class HelloConan(ConanFile):
exports_sources = "*.h"
def package(self):
self.copy("*.h", dst="include")
def package_info(self):
self.env_info.MY_ENV_VAR = "foo"
self.user_info.my_var = "my_value"
"""
client = TestClient()
client.save({"conanfile.py": conanfile_py,
"header.h": ""})
client.run("create . Hello/0.1@lasote/testing")
client.run("install Hello/0.1@lasote/testing -g json")
conan_json = os.path.join(client.current_folder, "conanbuildinfo.json")
with open(conan_json) as f:
data = json.load(f)
self.assertEquals(data["deps_env_info"]["MY_ENV_VAR"], "foo")
self.assertEquals(data["deps_user_info"]["Hello"]["my_var"], "my_value")
hello_data = data["dependencies"][0]
self.assertTrue(os.path.exists(hello_data["rootpath"]))
include_path = hello_data["include_paths"][0]
self.assertTrue(os.path.isabs(include_path))
self.assertTrue(os.path.exists(include_path))
def test_disable_linter(self):
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("config set general.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 download_with_sources_test(self):
server = TestServer()
servers = {"default": server,
"other": TestServer()}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")],
"other": [("lasote", "mypass")]})
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
name = "pkg"
version = "0.1"
exports_sources = "*"
"""
client.save({"conanfile.py": conanfile,
"file.h": "myfile.h",
"otherfile.cpp": "C++code"})
client.run("export . lasote/stable")
ref = ConanFileReference.loads("pkg/0.1@lasote/stable")
self.assertTrue(os.path.exists(client.paths.conanfile(ref)))
client.run("upload pkg/0.1@lasote/stable")
client.run("remove pkg/0.1@lasote/stable -f")
self.assertFalse(os.path.exists(client.paths.export(ref)))
client.run("download pkg/0.1@lasote/stable")
self.assertIn("Downloading conan_sources.tgz", client.out)
source = client.client_cache.export_sources(ref)
self.assertEqual("myfile.h", load(os.path.join(source, "file.h")))
self.assertEqual("C++code", load(os.path.join(source, "otherfile.cpp")))
def test_profile_override(self, conanfile):
client = TestClient()
client.save({CONANFILE: tool_conanfile2}, clean_first=True)
client.run("export . lasote/stable")
client.save({CONANFILE: conanfile,
"profile.txt": profile,
"profile2.txt": profile.replace("0.3", "[>0.2]")}, clean_first=True)
client.run("export . lasote/stable")
client.run("install MyLib/0.1@lasote/stable --profile ./profile.txt --build missing")
self.assertNotIn("Tool/0.1", client.user_io.out)
self.assertNotIn("Tool/0.2", client.user_io.out)
self.assertIn("Tool/0.3@lasote/stable: Generating the package", client.user_io.out)
self.assertIn("ToolPath: MyToolPath", client.user_io.out)
client.run("install MyLib/0.1@lasote/stable")
self.assertNotIn("Tool", client.user_io.out)
self.assertIn("MyLib/0.1@lasote/stable: Already installed!", client.user_io.out)
client.run("install MyLib/0.1@lasote/stable --profile ./profile2.txt --build")
self.assertNotIn("Tool/0.1", client.user_io.out)
self.assertNotIn("Tool/0.2", client.user_io.out)
self.assertIn("Tool/0.3@lasote/stable: Generating the package", client.user_io.out)
self.assertIn("ToolPath: MyToolPath", client.user_io.out)
def test_run_environment(self):
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
files[CONANFILE] = files[CONANFILE].replace('self.copy(pattern="*.so", dst="lib", keep_path=False)',
'''self.copy(pattern="*.so", dst="lib", keep_path=False)
self.copy(pattern="*say_hello*", dst="bin", keep_path=False)''')
client.save(files)
client.run("export . lasote/stable")
reuse = '''
from conans import ConanFile, RunEnvironment, tools
class HelloConan(ConanFile):
name = "Reuse"
version = "0.1"
build_policy = "missing"
requires = "Hello0/0.1@lasote/stable"
def build(self):
run_env = RunEnvironment(self)
with tools.environment_append(run_env.vars):
self.run("say_hello")
'''
client.save({"conanfile.py": reuse}, clean_first=True)
client.run("install . --build missing")
client.run("build .")
def basic_test(self):
client = TestClient()
zlib = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "zlib"
version = "0.1"
options = {"shared": [True, False]}
default_options= "shared=False"
'''
client.save({"conanfile.py": zlib})
client.run("export lasote/testing")
project = """[requires]
zlib/0.1@lasote/testing
"""
client.save({"conanfile.txt": project}, clean_first=True)
client.run("install -o zlib:shared=True --build=missing")
self.assertIn("zlib/0.1@lasote/testing:2a623e3082a38f90cd2c3d12081161412de331b0",
client.user_io.out)
conaninfo = load(os.path.join(client.current_folder, CONANINFO))
self.assertIn("zlib:shared=True", conaninfo)
# Options not cached anymore
client.run("install --build=missing")
self.assertIn("zlib/0.1@lasote/testing:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
client.user_io.out)
conaninfo = load(os.path.join(client.current_folder, CONANINFO))
self.assertNotIn("zlib:shared=True", conaninfo)
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 no_signature_test(self):
auth = AuthorizationHeaderSpy()
retur = ReturnHandlerPlugin()
server = TestServer(plugins=[auth, retur])
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": conanfile})
client.run("export . lasote/stable")
# Upload will fail, as conan_server is expecting a signed URL
errors = client.run("upload Hello/0.1@lasote/stable", ignore_error=True)
self.assertTrue(errors)
expected_calls = [('get_conan_manifest_url', None),
('check_credentials', None),
('authenticate', 'Basic'),
('get_conanfile_snapshot', 'Bearer'),
('get_conanfile_upload_urls', 'Bearer'),
('put', 'Bearer')]
self.assertEqual(len(expected_calls), len(auth.auths))
for i, (method, auth_type) in enumerate(expected_calls):
real_call = auth.auths[i]
self.assertEqual(method, real_call[0])
if auth_type:
self.assertIn(auth_type, real_call[1])
# The Bearer of the last two calls must be identical
self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
class JsonOutputTest(unittest.TestCase):
def setUp(self):
self.servers = {"default": TestServer()}
self.client = TestClient(servers=self.servers)
def test_simple_fields(self):
# Result of a create
self.client.save({"conanfile.py": GenConanfile("CC", "1.0")},
clean_first=True)
self.client.run("create . private_user/channel --json=myfile.json")
my_json = json.loads(self.client.load("myfile.json"))
self.assertFalse(my_json["error"])
tmp = ConanFileReference.loads(my_json["installed"][0]["recipe"]["id"])
self.assertEqual(str(tmp), "CC/1.0@private_user/channel")
if self.client.cache.config.revisions_enabled:
self.assertIsNotNone(tmp.revision)
self.assertFalse(my_json["installed"][0]["recipe"]["dependency"])
self.assertTrue(my_json["installed"][0]["recipe"]["exported"])
self.assertFalse(my_json["installed"][0]["recipe"]["downloaded"])
self.assertIsNone(my_json["installed"][0]["recipe"]["remote"])
self.assertTrue(my_json["installed"][0]["packages"][0]["built"])
self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"])
# Result of an install retrieving only the recipe
self.client.run("upload CC/1.0@private_user/channel -c")
self.client.run("remove '*' -f")
self.client.run(
"install CC/1.0@private_user/channel --json=myfile.json --build missing "
)
my_json = json.loads(self.client.load("myfile.json"))
the_time_str = my_json["installed"][0]["recipe"]["time"]
self.assertIn("T", the_time_str) # Weak validation of the ISO 8601
self.assertFalse(my_json["error"])
self.assertEqual(my_json["installed"][0]["recipe"]["id"],
"CC/1.0@private_user/channel")
self.assertTrue(my_json["installed"][0]["recipe"]["dependency"])
self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"])
self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"])
self.assertTrue(my_json["installed"][0]["packages"][0]["built"])
self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"])
# Upload the binary too
self.client.run("upload CC/1.0@private_user/channel --all -c")
self.client.run("remove '*' -f")
self.client.run(
"install CC/1.0@private_user/channel --json=myfile.json")
my_json = json.loads(self.client.load("myfile.json"))
self.assertFalse(my_json["error"])
self.assertEqual(my_json["installed"][0]["recipe"]["id"],
"CC/1.0@private_user/channel")
self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"])
self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"])
self.assertFalse(my_json["installed"][0]["packages"][0]["built"])
self.assertTrue(my_json["installed"][0]["packages"][0]["downloaded"])
self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"])
# Force build
self.client.run("remove '*' -f")
self.client.run(
"install CC/1.0@private_user/channel --json=myfile.json --build")
my_json = json.loads(self.client.load("myfile.json"))
self.assertFalse(my_json["error"])
self.assertEqual(my_json["installed"][0]["recipe"]["id"],
"CC/1.0@private_user/channel")
self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"])
self.assertIsNotNone(my_json["installed"][0]["recipe"]["remote"])
self.assertTrue(my_json["installed"][0]["packages"][0]["built"])
self.assertFalse(my_json["installed"][0]["packages"][0]["downloaded"])
self.assertTrue(my_json["installed"][0]["packages"][0]["cpp_info"])
def test_errors(self):
# Missing recipe
self.client.run(
"install CC/1.0@private_user/channel --json=myfile.json",
assert_error=True)
my_json = json.loads(self.client.load("myfile.json"))
self.assertTrue(my_json["error"])
self.assertEqual(len(my_json["installed"]), 1)
self.assertFalse(my_json["installed"][0]["recipe"]["downloaded"])
self.assertEqual(
my_json["installed"][0]["recipe"]["error"], {
'type':
'missing',
'remote':
None,
'description':
"Unable to find 'CC/1.0@private_user/channel' in remotes"
})
# Missing binary package
self.client.save({"conanfile.py": GenConanfile("CC", "1.0")},
clean_first=True)
self.client.run("create . private_user/channel --json=myfile.json ")
self.client.run("upload CC/1.0@private_user/channel -c")
self.client.run("remove '*' -f")
self.client.run(
"install CC/1.0@private_user/channel --json=myfile.json",
assert_error=True)
my_json = json.loads(self.client.load("myfile.json"))
self.assertTrue(my_json["error"])
self.assertEqual(len(my_json["installed"]), 1)
self.assertTrue(my_json["installed"][0]["recipe"]["downloaded"])
self.assertFalse(my_json["installed"][0]["recipe"]["error"])
self.assertEqual(len(my_json["installed"][0]["packages"]), 1)
self.assertFalse(my_json["installed"][0]["packages"][0]["downloaded"])
self.assertEqual(
my_json["installed"][0]["packages"][0]["error"]["type"], "missing")
self.assertIsNone(
my_json["installed"][0]["packages"][0]["error"]["remote"])
self.assertIn(
"Can't find a 'CC/1.0@private_user/channel' package",
my_json["installed"][0]["packages"][0]["error"]["description"])
# Error building
conanfile = str(GenConanfile("CC", "1.0")) + """
def build(self):
raise Exception("Build error!")
"""
self.client.save({"conanfile.py": conanfile}, clean_first=True)
self.client.run("create . private_user/channel --json=myfile.json ",
assert_error=True)
my_json = json.loads(self.client.load("myfile.json"))
self.assertTrue(my_json["error"])
self.assertEqual(
my_json["installed"][0]["packages"][0]["error"]["type"],
"building")
self.assertIsNone(
my_json["installed"][0]["packages"][0]["error"]["remote"])
self.assertIn(
"CC/1.0@private_user/channel: Error in build() method, line 6",
my_json["installed"][0]["packages"][0]["error"]["description"])
def test_json_generation(self):
self.client.save(
{
"conanfile.py":
GenConanfile("CC", "1.0").with_option(
"static", [True, False]).with_default_option(
"static", True)
},
clean_first=True)
self.client.run("create . private_user/channel --json=myfile.json ")
self.client.run('upload "*" -c --all')
conanfile = str(GenConanfile("BB", "1.0")) + """
def configure(self):
self.options["CC"].static = False
def build_requirements(self):
self.build_requires("CC/1.0@private_user/channel")
"""
self.client.save({"conanfile.py": conanfile}, clean_first=True)
self.client.run("create . private_user/channel --build missing")
self.client.run('upload "*" -c --all')
self.client.save(
{
"conanfile.py":
GenConanfile("AA",
"1.0").with_require("BB/1.0@private_user/channel")
},
clean_first=True)
self.client.run("create . private_user/channel")
self.client.run('upload "*" -c --all')
save(
os.path.join(self.client.cache.profiles_path, "mybr"), """
include(default)
[build_requires]
AA*: CC/1.0@private_user/channel
""")
self.client.save(
{
"conanfile.py":
GenConanfile("PROJECT",
"1.0").with_require("AA/1.0@private_user/channel")
},
clean_first=True)
self.client.run(
"install . --profile mybr --json=myfile.json --build AA --build BB"
)
my_json = self.client.load("myfile.json")
my_json = json.loads(my_json)
self.assertTrue(my_json["installed"][0]["recipe"]["dependency"])
self.assertTrue(my_json["installed"][1]["recipe"]["dependency"])
self.assertTrue(my_json["installed"][2]["recipe"]["dependency"])
# Installed the build require CC with two options
self.assertEqual(len(my_json["installed"][2]["packages"]), 2)
tmp = ConanFileReference.loads(my_json["installed"][2]["recipe"]["id"])
if self.client.cache.config.revisions_enabled:
self.assertIsNotNone(tmp.revision)
self.assertEqual(str(tmp), "CC/1.0@private_user/channel")
self.assertFalse(my_json["installed"][2]["recipe"]["downloaded"])
self.assertFalse(my_json["installed"][2]["packages"][0]["downloaded"])
self.assertFalse(my_json["installed"][2]["packages"][1]["downloaded"])
def test_json_create_multiconfig(self):
conanfile = textwrap.dedent("""
from conans import ConanFile
class Lib(ConanFile):
def package_info(self):
self.cpp_info.release.libs = ["hello"]
self.cpp_info.debug.libs = ["hello_d"]
self.cpp_info.debug.libdirs = ["lib-debug"]
""")
self.client.save({'conanfile.py': conanfile})
self.client.run(
"create . name/version@user/channel --json=myfile.json")
my_json = self.client.load("myfile.json")
my_json = json.loads(my_json)
# Nodes with cpp_info
cpp_info = my_json["installed"][0]["packages"][0]["cpp_info"]
cpp_info_debug = cpp_info["configs"]["debug"]
cpp_info_release = cpp_info["configs"]["release"]
# Each node should have its own information
self.assertFalse("libs" in cpp_info)
self.assertEqual(cpp_info_debug["libs"], ["hello_d"])
self.assertEqual(cpp_info_release["libs"], ["hello"])
self.assertEqual(cpp_info_debug["libdirs"], ["lib-debug"])
self.assertEqual(cpp_info_release["libdirs"], [DEFAULT_LIB])
# FIXME: There are _empty_ nodes
self.assertEqual(cpp_info_debug["builddirs"], [""])
self.assertEqual(cpp_info_release["builddirs"], [""])
# FIXME: Default information is duplicated in all the nodes
dupe_nodes = [
"rootpath", "includedirs", "resdirs", "bindirs", "builddirs",
"filter_empty"
]
for dupe in dupe_nodes:
self.assertEqual(cpp_info[dupe], cpp_info_debug[dupe])
self.assertEqual(cpp_info[dupe], cpp_info_release[dupe])
def reuse_test(self):
self._export_upload("hello0/0.1@lasote/stable")
self._export_upload("hello1/0.1@lasote/stable", 1, [0])
self._export_upload("hello2/0.1@lasote/stable", 2, [0])
self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2])
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
ref = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(ref=ref, number=4, deps=[3], lang='go')
client.save(files3)
client.run("install . --build missing")
client.run("build .")
with environment_append({
"PATH": ['$GOPATH/bin'],
'GOPATH': client.current_folder
}):
with client.chdir("src"):
client.run_command('go install hello4_main')
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
with client.chdir("bin"):
client.run_command(command)
self.assertEqual(
['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.out).count("Uploading package"), 1)
client.run("upload hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.out).count("Uploading package"), 1)
client.run("upload hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.out).count("Uploading package"), 1)
client.run("upload hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.out).count("Uploading package"), 1)
#
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
ref = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(ref=ref, number=4, deps=[3], lang='go')
client2.save(files3)
client2.run("install . --build missing")
with environment_append({
"PATH": ['$GOPATH/bin'],
'GOPATH': client2.current_folder
}):
with client2.chdir("src"):
client2.run_command('go install hello4_main')
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
with client2.chdir("bin"):
client2.run_command(command)
self.assertEqual(
['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client2.out).splitlines()[-6:])
def reuse_test(self):
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
files[CONANFILE] = files[CONANFILE].replace("build", "build2")
client.save(files)
client.run("export . lasote/stable")
client.run("install %s --build missing" % str(ref))
self.assertTrue(
os.path.exists(client.cache.package_layout(ref).builds()))
self.assertTrue(
os.path.exists(client.cache.package_layout(ref).packages()))
# Upload
client.run("upload %s --all" % str(ref))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_client.run("install %s --build missing" % str(ref))
self.assertFalse(
os.path.exists(other_client.cache.package_layout(ref).builds()))
self.assertTrue(
os.path.exists(other_client.cache.package_layout(ref).packages()))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_client.run("install %s --build" % str(ref))
self.assertTrue(
os.path.exists(other_client.cache.package_layout(ref).builds()))
self.assertTrue(
os.path.exists(other_client.cache.package_layout(ref).packages()))
# Use an invalid pattern and check that its not builded from source
other_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_client.run("install %s --build HelloInvalid" % str(ref))
self.assertIn("No package matching 'HelloInvalid' pattern",
other_client.out)
self.assertFalse(
os.path.exists(other_client.cache.package_layout(ref).builds()))
# self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).packages()))
# Use another valid pattern and check that its not builded from source
other_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_client.run("install %s --build HelloInvalid -b Hello" % str(ref))
self.assertIn("No package matching 'HelloInvalid' pattern",
other_client.out)
# self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).builds()))
# self.assertFalse(os.path.exists(other_client.cache.package_layout(ref).packages()))
# Now even if the package is in local store, check that's rebuilded
other_client.run("install %s -b Hello*" % str(ref))
self.assertIn("Copying sources to build folder", other_client.out)
other_client.run("install %s" % str(ref))
self.assertNotIn("Copying sources to build folder", other_client.out)
def install_transitive_pattern_test(self):
# Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks
client = TestClient()
client.save({
"conanfile.py":
"""from conans import ConanFile
class Pkg(ConanFile):
options = {"shared": [True, False, "header"]}
default_options = "shared=False"
def package_info(self):
self.output.info("PKG OPTION: %s" % self.options.shared)
"""
})
client.run("create . Pkg/0.1@user/testing -o shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
client.save({
"conanfile.py":
"""from conans import ConanFile
class Pkg(ConanFile):
requires = "Pkg/0.1@user/testing"
options = {"shared": [True, False, "header"]}
default_options = "shared=False"
def package_info(self):
self.output.info("PKG2 OPTION: %s" % self.options.shared)
"""
})
client.run("create . Pkg2/0.1@user/testing -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
client.run("install Pkg2/0.1@user/testing -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
# Priority of non-scoped options
client.run(
"create . Pkg2/0.1@user/testing -o shared=header -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o shared=header -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of exact named option
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of exact named option reverse
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header --build=missing"
)
self.assertIn("Pkg/0.1@user/testing: Calling build()", client.out)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
# Prevalence of alphabetical pattern
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of alphabetical pattern, opposite order
client.run(
"create . Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence and override of alphabetical pattern
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
class Base(unittest.TestCase):
conanfile = textwrap.dedent("""
from conans import ConanFile
from conan.tools.cmake import CMake, CMakeToolchain
class App(ConanFile):
settings = "os", "arch", "compiler", "build_type"
requires = "hello/0.1"
generators = "CMakeDeps"
options = {"shared": [True, False], "fPIC": [True, False]}
default_options = {"shared": False, "fPIC": True}
def generate(self):
tc = CMakeToolchain(self)
tc.variables["MYVAR"] = "MYVAR_VALUE"
tc.variables["MYVAR2"] = "MYVAR_VALUE2"
tc.variables.debug["MYVAR_CONFIG"] = "MYVAR_DEBUG"
tc.variables.release["MYVAR_CONFIG"] = "MYVAR_RELEASE"
tc.variables.debug["MYVAR2_CONFIG"] = "MYVAR2_DEBUG"
tc.variables.release["MYVAR2_CONFIG"] = "MYVAR2_RELEASE"
tc.preprocessor_definitions["MYDEFINE"] = "MYDEF_VALUE"
tc.preprocessor_definitions["MYDEFINEINT"] = 42
tc.preprocessor_definitions.debug["MYDEFINE_CONFIG"] = "MYDEF_DEBUG"
tc.preprocessor_definitions.release["MYDEFINE_CONFIG"] = "MYDEF_RELEASE"
tc.preprocessor_definitions.debug["MYDEFINEINT_CONFIG"] = 421
tc.preprocessor_definitions.release["MYDEFINEINT_CONFIG"] = 422
tc.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
""")
lib_h = gen_function_h(name="app")
lib_cpp = gen_function_cpp(name="app", msg="App", includes=["hello"], calls=["hello"],
preprocessor=["MYVAR", "MYVAR_CONFIG", "MYDEFINE", "MYDEFINE_CONFIG",
"MYDEFINEINT", "MYDEFINEINT_CONFIG"])
main = gen_function_cpp(name="main", includes=["app"], calls=["app"])
cmakelist = textwrap.dedent("""
cmake_minimum_required(VERSION 3.15)
project(App C CXX)
if(NOT CMAKE_TOOLCHAIN_FILE)
message(FATAL ">> Not using toolchain")
endif()
message(">> CMAKE_GENERATOR_PLATFORM: ${CMAKE_GENERATOR_PLATFORM}")
message(">> CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
message(">> CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
message(">> CMAKE_CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
message(">> CMAKE_CXX_FLAGS_RELEASE: ${CMAKE_CXX_FLAGS_RELEASE}")
message(">> CMAKE_C_FLAGS: ${CMAKE_C_FLAGS}")
message(">> CMAKE_C_FLAGS_DEBUG: ${CMAKE_C_FLAGS_DEBUG}")
message(">> CMAKE_C_FLAGS_RELEASE: ${CMAKE_C_FLAGS_RELEASE}")
message(">> CMAKE_SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
message(">> CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
message(">> CMAKE_CXX_STANDARD: ${CMAKE_CXX_STANDARD}")
message(">> CMAKE_CXX_EXTENSIONS: ${CMAKE_CXX_EXTENSIONS}")
message(">> CMAKE_POSITION_INDEPENDENT_CODE: ${CMAKE_POSITION_INDEPENDENT_CODE}")
message(">> CMAKE_SKIP_RPATH: ${CMAKE_SKIP_RPATH}")
message(">> CMAKE_INSTALL_NAME_DIR: ${CMAKE_INSTALL_NAME_DIR}")
message(">> CMAKE_MODULE_PATH: ${CMAKE_MODULE_PATH}")
message(">> CMAKE_PREFIX_PATH: ${CMAKE_PREFIX_PATH}")
message(">> BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}")
get_directory_property(_COMPILE_DEFS DIRECTORY ${CMAKE_SOURCE_DIR} COMPILE_DEFINITIONS)
message(">> COMPILE_DEFINITIONS: ${_COMPILE_DEFS}")
find_package(hello REQUIRED)
add_library(app_lib app_lib.cpp)
target_link_libraries(app_lib PRIVATE hello::hello)
target_compile_definitions(app_lib PRIVATE MYVAR="${MYVAR}")
target_compile_definitions(app_lib PRIVATE MYVAR_CONFIG="${MYVAR_CONFIG}")
add_executable(app app.cpp)
target_link_libraries(app PRIVATE app_lib)
""")
def setUp(self):
self.client = TestClient()
conanfile = textwrap.dedent("""
from conans import ConanFile
from conans.tools import save
import os
class Pkg(ConanFile):
settings = "build_type"
def package(self):
save(os.path.join(self.package_folder, "include/hello.h"),
'''#include <iostream>
void hello(){std::cout<< "Hello: %s" <<std::endl;}'''
% self.settings.build_type)
""")
self.client.save({"conanfile.py": conanfile})
self.client.run("create . hello/0.1@ -s build_type=Debug")
self.client.run("create . hello/0.1@ -s build_type=Release")
# Prepare the actual consumer package
self.client.save({"conanfile.py": self.conanfile,
"CMakeLists.txt": self.cmakelist,
"app.cpp": self.main,
"app_lib.cpp": self.lib_cpp,
"app.h": self.lib_h})
def _run_build(self, settings=None, options=None):
# Build the profile according to the settings provided
settings = settings or {}
settings = " ".join('-s %s="%s"' % (k, v) for k, v in settings.items() if v)
options = " ".join("-o %s=%s" % (k, v) for k, v in options.items()) if options else ""
# Run the configure corresponding to this test case
build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/")
with self.client.chdir(build_directory):
self.client.run("install .. %s %s" % (settings, options))
install_out = self.client.out
self.client.run("build ..")
return install_out
def _modify_code(self):
lib_cpp = gen_function_cpp(name="app", msg="AppImproved", includes=["hello"],
calls=["hello"], preprocessor=["MYVAR", "MYVAR_CONFIG",
"MYDEFINE", "MYDEFINE_CONFIG",
"MYDEFINEINT",
"MYDEFINEINT_CONFIG"])
self.client.save({"app_lib.cpp": lib_cpp})
content = self.client.load("CMakeLists.txt")
content = content.replace(">>", "++>>")
self.client.save({"CMakeLists.txt": content})
def _incremental_build(self, build_type=None):
build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/")
with self.client.chdir(build_directory):
config = "--config %s" % build_type if build_type else ""
self.client.run_command("cmake --build . %s" % config)
def _run_app(self, build_type, bin_folder=False, msg="App", dyld_path=None):
if dyld_path:
build_directory = os.path.join(self.client.current_folder, "build").replace("\\", "/")
command_str = 'DYLD_LIBRARY_PATH="%s" build/app' % build_directory
else:
command_str = "build/%s/app.exe" % build_type if bin_folder else "build/app"
if platform.system() == "Windows":
command_str = command_str.replace("/", "\\")
self.client.run_command(command_str)
self.assertIn("Hello: %s" % build_type, self.client.out)
self.assertIn("%s: %s!" % (msg, build_type), self.client.out)
self.assertIn("MYVAR: MYVAR_VALUE", self.client.out)
self.assertIn("MYVAR_CONFIG: MYVAR_%s" % build_type.upper(), self.client.out)
self.assertIn("MYDEFINE: MYDEF_VALUE", self.client.out)
self.assertIn("MYDEFINE_CONFIG: MYDEF_%s" % build_type.upper(), self.client.out)
self.assertIn("MYDEFINEINT: 42", self.client.out)
self.assertIn("MYDEFINEINT_CONFIG: {}".format(421 if build_type == "Debug" else 422),
self.client.out)
def test_dependents_new_buildenv():
client = TestClient()
boost = textwrap.dedent("""
from conans import ConanFile
class Boost(ConanFile):
def package_info(self):
self.buildenv_info.define_path("PATH", "myboostpath")
""")
other = textwrap.dedent("""
from conans import ConanFile
class Other(ConanFile):
requires = "boost/1.0"
def package_info(self):
self.buildenv_info.append_path("PATH", "myotherpath")
self.buildenv_info.prepend_path("PATH", "myotherprepend")
""")
consumer = textwrap.dedent("""
from conans import ConanFile
from conan.tools.env import VirtualBuildEnv
import os
class Lib(ConanFile):
build_requires = {}
def generate(self):
build_env = VirtualBuildEnv(self).environment()
with build_env.apply():
self.output.info("LIB PATH %s" % os.getenv("PATH"))
""")
client.save({
"boost/conanfile.py":
boost,
"other/conanfile.py":
other,
"consumer/conanfile.py":
consumer.format('"boost/1.0", "other/1.0"'),
"profile_define":
"[buildenv]\nPATH=(path)profilepath",
"profile_append":
"[buildenv]\nPATH+=(path)profilepath",
"profile_prepend":
"[buildenv]\nPATH=+(path)profilepath"
})
client.run("create boost boost/1.0@")
client.run("create other other/1.0@")
client.run("install consumer")
result = os.pathsep.join(["myotherprepend", "myboostpath", "myotherpath"])
assert "LIB PATH {}".format(result) in client.out
# Now test if we declare in different order, still topological order should be respected
client.save(
{"consumer/conanfile.py": consumer.format('"other/1.0", "boost/1.0"')})
client.run("install consumer")
assert "LIB PATH {}".format(result) in client.out
client.run("install consumer -pr=profile_define")
assert "LIB PATH profilepath" in client.out
client.run("install consumer -pr=profile_append")
result = os.pathsep.join(
["myotherprepend", "myboostpath", "myotherpath", "profilepath"])
assert "LIB PATH {}".format(result) in client.out
client.run("install consumer -pr=profile_prepend")
result = os.pathsep.join(
["profilepath", "myotherprepend", "myboostpath", "myotherpath"])
assert "LIB PATH {}".format(result) in client.out
class InstallTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
self.settings = ("-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 "
"-s arch=x86 -s compiler.runtime=MD")
def install_package_folder_test(self):
# Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks
client = TestClient()
client.save({"conanfile.py": """from conans import ConanFile
import os
class Pkg(ConanFile):
def package_info(self):
self.dummy_doesnt_exist_not_break
self.output.info("Hello")
self.env_info.PATH = os.path.join(self.package_folder, "bin")
"""})
client.run("install .")
self.assertNotIn("Hello", client.out)
self.assertIn("PROJECT: Generated conaninfo.txt", client.out)
def _create(self, number, version, deps=None, export=True, no_config=False):
files = cpp_hello_conan_files(number, version, deps, build=False, config=not no_config)
self.client.save(files, clean_first=True)
if export:
self.client.run("export lasote/stable")
def install_error_never_test(self):
self._create("Hello0", "0.1", export=False)
error = self.client.run("install --build never --build missing", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
error = self.client.run("install --build never --build Hello", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
error = self.client.run("install --build never --build outdated", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
def install_combined_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False)
self.client.run("install %s --build=missing" % (self.settings))
self.client.run("install %s --build=missing --build Hello1" % (self.settings))
self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
self.client.user_io.out)
self.assertIn("Hello1/0.1@lasote/stable: WARN: Forced build from source",
self.client.user_io.out)
def install_transitive_cache_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"])
self.client.run("install Hello2/0.1@lasote/stable %s --build=missing" % (self.settings))
self.assertIn("Hello0/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
self.assertIn("Hello1/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
self.assertIn("Hello2/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
def partials_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False)
self.client.run("install %s --build=missing" % self.settings)
self.client.run("install %s --build=Bye" % self.settings)
self.assertIn("No package matching 'Bye' pattern", self.client.user_io.out)
for package in ["Hello0", "Hello1"]:
self.client.run("install %s --build=%s" % (self.settings, package))
self.assertNotIn("No package matching", self.client.user_io.out)
def reuse_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False)
for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b"),
(1, "8b964e421a5b7e48b7bc19b94782672be126be8b",
"3eeab577a3134fa3afdcd82881751789ec48e08f")]:
self.client.run("install -o language=%d %s --build missing" % (lang, self.settings))
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("arch=x86\n"
"compiler=Visual Studio\n"
"compiler.runtime=MD\n"
"compiler.version=12\n"
"os=Windows",
conan_info.settings.dumps())
self.assertEqual("language=%s\nstatic=True" % lang, conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(PackageReference(conan_ref, id0))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(lang, hello0_conan_info.options.language)
package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
id1)
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(lang, hello1_conan_info.options.language)
def upper_option_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True)
self.client.run("install -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s"
" --build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("language=1\nstatic=True", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(PackageReference(conan_ref,
"8b964e421a5b7e48b7bc19b94782672be126be8b"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(1, hello0_conan_info.options.language)
package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(0, hello1_conan_info.options.language)
def inverse_upper_option_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True)
self.client.run("install -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s "
"--build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(PackageReference(conan_ref,
"2e38bbc2c3ef1425197c8e2ffa8532894c347d26"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual("language=0\nstatic=True", hello0_conan_info.options.dumps())
package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"3eeab577a3134fa3afdcd82881751789ec48e08f")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual("language=1\nstatic=True", hello1_conan_info.options.dumps())
def upper_option_txt_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)
files = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"])
files.pop(CONANFILE)
files[CONANFILE_TXT] = """[requires]
Hello1/0.1@lasote/stable
[options]
Hello0:language=1
Hello1:language=0
"""
self.client.save(files, clean_first=True)
self.client.run("install %s --build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(PackageReference(conan_ref,
"8b964e421a5b7e48b7bc19b94782672be126be8b"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(1, hello0_conan_info.options.language)
package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(0, hello1_conan_info.options.language)
def change_option_txt_test(self):
self._create("Hello0", "0.1")
client = TestClient(base_folder=self.client.base_folder)
files = {CONANFILE_TXT: """[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=1
"""}
client.save(files)
client.run("install %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=1", conan_info.full_options.dumps())
self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b",
conan_info.full_requires.dumps())
files = {CONANFILE_TXT: """[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=0
"""}
client.save(files)
client.run("install %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
# For conan install options are not cached anymore
self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
# it is necessary to clean the cached conaninfo
client.save(files, clean_first=True)
client.run("install %s --build missing" % self.settings)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
conan_info.full_requires.dumps())
def cross_platform_msg_test(self):
bad_os = "Linux" if platform.system() != "Linux" else "Macos"
message = "Cross-platform from '%s' to '%s'" % (detected_os(), bad_os)
self._create("Hello0", "0.1")
self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os, ignore_error=True)
self.assertIn(message, self.client.user_io.out)
def install_cwd_test(self):
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
client.save({"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}, clean_first=True)
client.run("install . --build=missing -s os=Windows --install-folder=win_dir")
client.run("install . --build=missing -s os=Macos --install-folder=os_dir")
conaninfo = load(os.path.join(client.current_folder, "win_dir/conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertNotIn("os=Macos", conaninfo)
conaninfo = load(os.path.join(client.current_folder, "os_dir/conaninfo.txt"))
self.assertNotIn("os=Windows", conaninfo)
self.assertIn("os=Macos", conaninfo)
def install_reference_not_conanbuildinfo_test(self):
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("create conan/stable")
client.save({}, clean_first=True)
client.run("install Hello/0.1@conan/stable")
self.assertFalse(os.path.exists(os.path.join(client.current_folder, "conanbuildinfo.txt")))
class MultiRemoteTest(unittest.TestCase):
def setUp(self):
self.servers = OrderedDict()
self.users = {}
for i in range(3):
test_server = TestServer()
self.servers["remote%d" % i] = test_server
self.users["remote%d" % i] = [("lasote", "mypass")]
self.client = TestClient(servers=self.servers, users=self.users)
def predefine_remote_test(self):
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
self.client.save(files)
self.client.run("export . lasote/stable")
self.client.run("upload Hello0/0.1@lasote/stable -r=remote0")
self.client.run("upload Hello0/0.1@lasote/stable -r=remote1")
self.client.run("upload Hello0/0.1@lasote/stable -r=remote2")
self.client.run('remove "*" -f')
self.client.run("remote add_ref Hello0/0.1@lasote/stable remote1")
self.client.run("install Hello0/0.1@lasote/stable --build=missing")
self.assertIn(
"Hello0/0.1@lasote/stable: Retrieving from predefined remote 'remote1'",
self.client.out)
self.client.run("remote list_ref")
self.assertIn(": remote1", self.client.out)
def upload_test(self):
ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
self.client.save(files)
self.client.run("export . lasote/stable")
self.client.run("upload %s" % str(ref))
self.client.run("info %s" % str(ref))
self.assertIn("remote0=http://", self.client.out)
# The remote, once fixed does not change
self.client.run("upload %s -r=remote1" % str(ref))
self.client.run("info %s" % str(ref))
self.assertIn("remote0=http://", self.client.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(ref))
client2.run("info %s" % str(ref))
self.assertIn("remote0=http://", client2.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(ref))
client3.run("info %s" % str(ref))
self.assertIn("remote1=http://", client3.out)
def fail_when_not_notfound_test(self):
"""
If a remote fails with a 404 it has to keep looking in the next remote, but if it fails by
any other reason it has to stop
"""
servers = OrderedDict()
servers["s0"] = TestServer()
servers["s1"] = TestServer()
servers["s2"] = TestServer()
client = TestClient(servers=servers, users=self.users)
files = cpp_hello_conan_files("MyLib", "0.1", build=False)
client.save(files)
client.run("create . lasote/testing")
client.run("user lasote -p mypass -r s1")
client.run("upload MyLib* -r s1 -c")
servers[
"s1"].fake_url = "http://asdlhaljksdhlajkshdljakhsd.com" # Do not exist
client2 = TestClient(servers=servers, users=self.users)
err = client2.run("install MyLib/0.1@conan/testing --build=missing",
assert_error=True)
self.assertTrue(err)
self.assertIn("MyLib/0.1@conan/testing: Trying with 's0'...",
client2.out)
self.assertIn("MyLib/0.1@conan/testing: Trying with 's1'...",
client2.out)
self.assertIn(
"Unable to connect to s1=http://asdlhaljksdhlajkshdljakhsd.com",
client2.out)
# s2 is not even tried
self.assertNotIn("MyLib/0.1@conan/testing: Trying with 's2'...",
client2.out)
def install_from_remotes_test(self):
for i in range(3):
ref = ConanFileReference.loads("Hello%d/0.1@lasote/stable" % i)
files = cpp_hello_conan_files("Hello%d" % i, "0.1", build=False)
self.client.save(files)
self.client.run("export . lasote/stable")
self.client.run("upload %s -r=remote%d" % (str(ref), i))
self.client.run("info %s" % str(ref))
self.assertIn("remote%d=http://" % i, self.client.out)
# Now install it in other machine from remote 0
client2 = TestClient(servers=self.servers, users=self.users)
files = cpp_hello_conan_files("HelloX",
"0.1",
deps=[
"Hello0/0.1@lasote/stable",
"Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"
])
files["conanfile.py"] = files["conanfile.py"].replace(
"def build(", "def build2(")
client2.save(files)
client2.run("install . --build=missing")
self.assertIn("Hello0/0.1@lasote/stable from 'remote0'", client2.out)
self.assertIn("Hello1/0.1@lasote/stable from 'remote1'", client2.out)
self.assertIn("Hello2/0.1@lasote/stable from 'remote2'", client2.out)
client2.run("info .")
self.assertIn("Remote: remote0=http://", client2.out)
self.assertIn("Remote: remote1=http://", client2.out)
self.assertIn("Remote: remote2=http://", client2.out)
@unittest.skipIf(
TestClient().cache.config.revisions_enabled,
"This test is not valid for revisions, where we keep iterating the remotes "
"for searching a package for the same recipe revision")
def package_binary_remote_test(self):
# https://github.com/conan-io/conan/issues/3882
conanfile = """from conans import ConanFile
class ConanFileToolsTest(ConanFile):
pass
"""
# Upload recipe + package to remote1 and remote2
reference = "Hello/0.1@lasote/stable"
self.client.save({"conanfile.py": conanfile})
self.client.run("create . %s" % reference)
self.client.run("upload %s -r=remote0 --all" % reference)
self.client.run("upload %s -r=remote2 --all" % reference)
ref = ConanFileReference.loads(reference)
# Remove only binary from remote1 and everything in local
self.client.run("remove -f %s -p -r remote0" % reference)
self.client.run('remove "*" -f')
self.servers.pop("remote1")
# Now install it from a client, it won't find the binary in remote2
self.client.run("install %s" % reference, assert_error=True)
self.assertIn("Can't find a 'Hello/0.1@lasote/stable' package",
self.client.out)
self.assertNotIn("remote2", self.client.out)
self.client.run("install %s -r remote2" % reference)
self.assertIn(
"Package installed 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
self.client.out)
self.assertIn("Hello/0.1@lasote/stable from 'remote0' - Cache",
self.client.out)
metadata = self.client.cache.package_layout(ref).load_metadata()
self.assertEqual(metadata.recipe.remote, "remote0")
self.assertEqual(
metadata.packages["5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9"].
remote, "remote2")
client2 = TestClient(servers=self.servers, users=self.users)
time.sleep(1) # Make sure timestamps increase
client2.save({"conanfile.py": conanfile + " # Comment"})
client2.run("create . %s" % reference)
client2.run("upload %s -r=remote2 --all" % reference)
# Install from client, it should update the package from remote2
self.client.run("install %s --update" % reference)
self.assertNotIn(
"Hello/0.1@lasote/stable: WARN: Can't update, no package in remote",
self.client.out)
self.assertIn(
"Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 - Update",
self.client.out)
self.assertIn("Downloading conan_package.tgz", self.client.out)
def package_info_components_complete_test(self):
dep = textwrap.dedent("""
import os
from conans import ConanFile
class Dep(ConanFile):
exports_sources = "*"
def package(self):
self.copy("*")
def package_info(self):
self.cpp_info.name = "Galaxy"
self.cpp_info.components["Starlight"].includedirs = [os.path.join("galaxy", "starlight")]
self.cpp_info.components["Starlight"].libs = ["libstarlight"]
self.cpp_info.components["Planet"].includedirs = [os.path.join("galaxy", "planet")]
self.cpp_info.components["Planet"].libs = ["libplanet"]
self.cpp_info.components["Planet"].requires = ["Starlight"]
self.cpp_info.components["Launcher"].system_libs = ["ground"]
self.cpp_info.components["ISS"].includedirs = [os.path.join("galaxy", "iss")]
self.cpp_info.components["ISS"].libs = ["libiss"]
self.cpp_info.components["ISS"].libdirs = ["iss_libs"]
self.cpp_info.components["ISS"].system_libs = ["solar", "magnetism"]
self.cpp_info.components["ISS"].requires = ["Starlight", "Launcher"]
""")
consumer = textwrap.dedent("""
from conans import ConanFile
class Consumer(ConanFile):
requires = "dep/1.0@us/ch"
def build(self):
# Global values
self.output.info("GLOBAL Include paths: %s" % list(self.deps_cpp_info.include_paths))
self.output.info("GLOBAL Library paths: %s" % list(self.deps_cpp_info.lib_paths))
self.output.info("GLOBAL Binary paths: %s" % list(self.deps_cpp_info.bin_paths))
self.output.info("GLOBAL Libs: %s" % list(self.deps_cpp_info.libs))
self.output.info("GLOBAL System libs: %s" % list(self.deps_cpp_info.system_libs))
# Deps values
for dep_key, dep_value in self.deps_cpp_info.dependencies:
self.output.info("DEPS name: %s" % dep_value.get_name('txt'))
self.output.info("DEPS Include paths: %s" % list(dep_value.include_paths))
self.output.info("DEPS Library paths: %s" % list(dep_value.lib_paths))
self.output.info("DEPS Binary paths: %s" % list(dep_value.bin_paths))
self.output.info("DEPS Libs: %s" % list(dep_value.libs))
self.output.info("DEPS System libs: %s" % list(dep_value.system_libs))
# Components values
for dep_key, dep_value in self.deps_cpp_info.dependencies:
for comp_name, comp_value in dep_value.components.items():
self.output.info("COMP %s Include paths: %s" % (comp_name,
list(comp_value.include_paths)))
self.output.info("COMP %s Library paths: %s" % (comp_name, list(comp_value.lib_paths)))
self.output.info("COMP %s Binary paths: %s" % (comp_name, list(comp_value.bin_paths)))
self.output.info("COMP %s Libs: %s" % (comp_name, list(comp_value.libs)))
self.output.info("COMP %s Requires: %s" % (comp_name, list(comp_value.requires)))
self.output.info("COMP %s System libs: %s" % (comp_name, list(comp_value.system_libs)))
""")
client = TestClient()
client.save({
"conanfile_dep.py": dep,
"conanfile_consumer.py": consumer,
"galaxy/starlight/starlight.h": "",
"lib/libstarlight": "",
"galaxy/planet/planet.h": "",
"lib/libplanet": "",
"galaxy/iss/iss.h": "",
"iss_libs/libiss": "",
"bin/exelauncher": ""
})
dep_ref = ConanFileReference("dep", "1.0", "us", "ch")
dep_pref = PackageReference(dep_ref, NO_SETTINGS_PACKAGE_ID)
client.run("create conanfile_dep.py dep/1.0@us/ch")
client.run("create conanfile_consumer.py consumer/1.0@us/ch")
package_folder = client.cache.package_layout(dep_ref).package(dep_pref)
expected_comp_starlight_include_paths = [
os.path.join(package_folder, "galaxy", "starlight")
]
expected_comp_planet_include_paths = [
os.path.join(package_folder, "galaxy", "planet")
]
expected_comp_launcher_include_paths = []
expected_comp_iss_include_paths = [
os.path.join(package_folder, "galaxy", "iss")
]
expected_comp_starlight_library_paths = [
os.path.join(package_folder, "lib")
]
expected_comp_launcher_library_paths = [
os.path.join(package_folder, "lib")
]
expected_comp_planet_library_paths = [
os.path.join(package_folder, "lib")
]
expected_comp_iss_library_paths = [
os.path.join(package_folder, "iss_libs")
]
expected_comp_starlight_binary_paths = [
os.path.join(package_folder, "bin")
]
expected_comp_launcher_binary_paths = [
os.path.join(package_folder, "bin")
]
expected_comp_planet_binary_paths = [
os.path.join(package_folder, "bin")
]
expected_comp_iss_binary_paths = [os.path.join(package_folder, "bin")]
expected_global_include_paths = expected_comp_planet_include_paths + \
expected_comp_iss_include_paths + expected_comp_starlight_include_paths
expected_global_library_paths = expected_comp_starlight_library_paths + \
expected_comp_iss_library_paths
expected_global_binary_paths = expected_comp_starlight_binary_paths
self.assertIn(
"GLOBAL Include paths: %s" % expected_global_include_paths,
client.out)
self.assertIn(
"GLOBAL Library paths: %s" % expected_global_library_paths,
client.out)
self.assertIn("GLOBAL Binary paths: %s" % expected_global_binary_paths,
client.out)
self.assertIn("GLOBAL Libs: ['libplanet', 'libiss', 'libstarlight']",
client.out)
self.assertIn("GLOBAL System libs: ['solar', 'magnetism', 'ground']",
client.out)
self.assertIn("DEPS name: Galaxy", client.out)
self.assertIn("DEPS Include paths: %s" % expected_global_include_paths,
client.out)
self.assertIn("DEPS Library paths: %s" % expected_global_library_paths,
client.out)
self.assertIn("DEPS Binary paths: %s" % expected_global_binary_paths,
client.out)
self.assertIn("DEPS Libs: ['libplanet', 'libiss', 'libstarlight']",
client.out)
self.assertIn("DEPS System libs: ['solar', 'magnetism', 'ground']",
client.out)
self.assertIn(
"COMP Starlight Include paths: %s" %
list(expected_comp_starlight_include_paths), client.out)
self.assertIn(
"COMP Planet Include paths: %s" %
list(expected_comp_planet_include_paths, ), client.out)
self.assertIn(
"COMP Launcher Include paths: %s" %
list(expected_comp_launcher_include_paths), client.out)
self.assertIn(
"COMP ISS Include paths: %s" %
list(expected_comp_iss_include_paths), client.out)
self.assertIn(
"COMP Starlight Library paths: %s" %
list(expected_comp_starlight_library_paths), client.out)
self.assertIn(
"COMP Planet Library paths: %s" %
list(expected_comp_planet_library_paths), client.out)
self.assertIn(
"COMP Launcher Library paths: %s" %
list(expected_comp_launcher_library_paths), client.out)
self.assertIn(
"COMP ISS Library paths: %s" %
list(expected_comp_iss_library_paths), client.out)
self.assertIn(
"COMP Starlight Binary paths: %s" %
list(expected_comp_iss_binary_paths), client.out)
self.assertIn(
"COMP Planet Binary paths: %s" %
list(expected_comp_planet_binary_paths), client.out)
self.assertIn(
"COMP Launcher Binary paths: %s" %
list(expected_comp_launcher_binary_paths), client.out)
self.assertIn(
"COMP ISS Binary paths: %s" % list(expected_comp_iss_binary_paths),
client.out)
self.assertIn("COMP Starlight Libs: ['libstarlight']", client.out)
self.assertIn("COMP Planet Libs: ['libplanet']", client.out)
self.assertIn("COMP Launcher Libs: []", client.out)
self.assertIn("COMP ISS Libs: ['libiss']", client.out)
self.assertIn("COMP Starlight System libs: []", client.out)
self.assertIn("COMP Planet System libs: []", client.out)
self.assertIn("COMP Launcher System libs: ['ground']", client.out)
self.assertIn("COMP ISS System libs: ['solar', 'magnetism']",
client.out)
self.assertIn("COMP Starlight Requires: []", client.out)
self.assertIn("COMP Launcher Requires: []", client.out)
self.assertIn("COMP Planet Requires: ['Starlight']", client.out)
self.assertIn("COMP ISS Requires: ['Starlight', 'Launcher']",
client.out)
class InstallTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
self.settings = (
"-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 "
"-s arch=x86 -s compiler.runtime=MD")
def install_transitive_pattern_test(self):
# Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks
client = TestClient()
client.save({
"conanfile.py":
"""from conans import ConanFile
class Pkg(ConanFile):
options = {"shared": [True, False, "header"]}
default_options = "shared=False"
def package_info(self):
self.output.info("PKG OPTION: %s" % self.options.shared)
"""
})
client.run("create . Pkg/0.1@user/testing -o shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
client.save({
"conanfile.py":
"""from conans import ConanFile
class Pkg(ConanFile):
requires = "Pkg/0.1@user/testing"
options = {"shared": [True, False, "header"]}
default_options = "shared=False"
def package_info(self):
self.output.info("PKG2 OPTION: %s" % self.options.shared)
"""
})
client.run("create . Pkg2/0.1@user/testing -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
client.run("install Pkg2/0.1@user/testing -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
# Priority of non-scoped options
client.run(
"create . Pkg2/0.1@user/testing -o shared=header -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o shared=header -o *:shared=True")
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of exact named option
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of exact named option reverse
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header --build=missing"
)
self.assertIn("Pkg/0.1@user/testing: Calling build()", client.out)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: True", client.out)
# Prevalence of alphabetical pattern
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg2*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence of alphabetical pattern, opposite order
client.run(
"create . Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o Pkg2*:shared=header -o *:shared=True"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: True", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
# Prevalence and override of alphabetical pattern
client.run(
"create . Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
client.run(
"install Pkg2/0.1@user/testing -o *:shared=True -o Pkg*:shared=header"
)
self.assertIn("Pkg/0.1@user/testing: PKG OPTION: header", client.out)
self.assertIn("Pkg2/0.1@user/testing: PKG2 OPTION: header", client.out)
def install_package_folder_test(self):
# Make sure a simple conan install doesn't fire package_info() so self.package_folder breaks
client = TestClient()
client.save({
"conanfile.py":
"""from conans import ConanFile
import os
class Pkg(ConanFile):
def package_info(self):
self.dummy_doesnt_exist_not_break
self.output.info("Hello")
self.env_info.PATH = os.path.join(self.package_folder, "bin")
"""
})
client.run("install .")
self.assertNotIn("Hello", client.out)
self.assertIn("PROJECT: Generated conaninfo.txt", client.out)
def _create(self,
number,
version,
deps=None,
export=True,
no_config=False,
settings=None):
files = cpp_hello_conan_files(number,
version,
deps,
build=False,
config=not no_config,
settings=settings)
self.client.save(files, clean_first=True)
if export:
self.client.run("export . lasote/stable")
def install_error_never_test(self):
self._create("Hello0", "0.1", export=False)
error = self.client.run("install . --build never --build missing",
ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
error = self.client.run(
"install conanfile.py --build never --build Hello",
ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
error = self.client.run(
"install ./conanfile.py --build never --build outdated",
ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: --build=never not compatible with other options",
self.client.user_io.out)
def install_combined_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False)
self.client.run("install . %s --build=missing" % (self.settings))
self.client.run("install . %s --build=missing --build Hello1" %
(self.settings))
self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
self.client.user_io.out)
self.assertIn(
"Hello1/0.1@lasote/stable: WARN: Forced build from source",
self.client.user_io.out)
def install_transitive_cache_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"])
self.client.run("install Hello2/0.1@lasote/stable %s --build=missing" %
(self.settings))
self.assertIn("Hello0/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
self.assertIn("Hello1/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
self.assertIn("Hello2/0.1@lasote/stable: Generating the package",
self.client.user_io.out)
def partials_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False)
self.client.run("install . %s --build=missing" % self.settings)
self.client.run("install ./ %s --build=Bye" % self.settings)
self.assertIn("No package matching 'Bye' pattern",
self.client.user_io.out)
for package in ["Hello0", "Hello1"]:
self.client.run("install . %s --build=%s" %
(self.settings, package))
self.assertNotIn("No package matching", self.client.user_io.out)
def reuse_test(self):
self._create("Hello0", "0.1")
self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False)
for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b"),
(1, "8b964e421a5b7e48b7bc19b94782672be126be8b",
"3eeab577a3134fa3afdcd82881751789ec48e08f")]:
self.client.run("install . -o language=%d %s --build missing" %
(lang, self.settings))
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual(
"arch=x86\n"
"compiler=Visual Studio\n"
"compiler.runtime=MD\n"
"compiler.version=12\n"
"os=Windows", conan_info.settings.dumps())
self.assertEqual("language=%s\nstatic=True" % lang,
conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(PackageReference(
conan_ref, id0))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(lang, hello0_conan_info.options.language)
package_ref1 = PackageReference(
ConanFileReference.loads("Hello1/0.1@lasote/stable"), id1)
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(lang, hello1_conan_info.options.language)
def upper_option_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1",
"0.1", ["Hello0/0.1@lasote/stable"],
no_config=True)
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False,
no_config=True)
self.client.run(
"install conanfile.py -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s"
" --build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("language=1\nstatic=True", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(
PackageReference(conan_ref,
"8b964e421a5b7e48b7bc19b94782672be126be8b"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(1, hello0_conan_info.options.language)
package_ref1 = PackageReference(
ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(0, hello1_conan_info.options.language)
def inverse_upper_option_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1",
"0.1", ["Hello0/0.1@lasote/stable"],
no_config=True)
self._create("Hello2",
"0.1", ["Hello1/0.1@lasote/stable"],
export=False,
no_config=True)
self.client.run(
"install . -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s "
"--build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(
PackageReference(conan_ref,
"2e38bbc2c3ef1425197c8e2ffa8532894c347d26"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual("language=0\nstatic=True",
hello0_conan_info.options.dumps())
package_ref1 = PackageReference(
ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"3eeab577a3134fa3afdcd82881751789ec48e08f")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual("language=1\nstatic=True",
hello1_conan_info.options.dumps())
def upper_option_txt_test(self):
self._create("Hello0", "0.1", no_config=True)
self._create("Hello1",
"0.1", ["Hello0/0.1@lasote/stable"],
no_config=True)
files = cpp_hello_conan_files("Hello2", "0.1",
["Hello1/0.1@lasote/stable"])
files.pop(CONANFILE)
files[CONANFILE_TXT] = """[requires]
Hello1/0.1@lasote/stable
[options]
Hello0:language=1
Hello1:language=0
"""
self.client.save(files, clean_first=True)
self.client.run("install . %s --build missing" % self.settings)
info_path = os.path.join(self.client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
hello0 = self.client.paths.package(
PackageReference(conan_ref,
"8b964e421a5b7e48b7bc19b94782672be126be8b"))
hello0_info = os.path.join(hello0, CONANINFO)
hello0_conan_info = ConanInfo.load_file(hello0_info)
self.assertEqual(1, hello0_conan_info.options.language)
package_ref1 = PackageReference(
ConanFileReference.loads("Hello1/0.1@lasote/stable"),
"44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
hello1 = self.client.paths.package(package_ref1)
hello1_info = os.path.join(hello1, CONANINFO)
hello1_conan_info = ConanInfo.load_file(hello1_info)
self.assertEqual(0, hello1_conan_info.options.language)
def change_option_txt_test(self):
self._create("Hello0", "0.1")
client = TestClient(base_folder=self.client.base_folder)
files = {
CONANFILE_TXT:
"""[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=1
"""
}
client.save(files)
client.run("install conanfile.txt %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=1", conan_info.full_options.dumps())
self.assertIn(
"Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b",
conan_info.full_requires.dumps())
files = {
CONANFILE_TXT:
"""[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=0
"""
}
client.save(files)
client.run("install . %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
# For conan install options are not cached anymore
self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
# it is necessary to clean the cached conaninfo
client.save(files, clean_first=True)
client.run("install ./conanfile.txt %s --build missing" %
self.settings)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
self.assertIn(
"Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
conan_info.full_requires.dumps())
def cross_platform_msg_test(self):
# Explicit with os_build and os_arch settings
message = "Cross-build from 'Linux:x86_64' to 'Windows:x86_64'"
self._create(
"Hello0",
"0.1",
settings='"os_build", "os", "arch_build", "arch", "compiler"')
self.client.run(
"install Hello0/0.1@lasote/stable -s os_build=Linux -s os=Windows",
ignore_error=True)
self.assertIn(message, self.client.user_io.out)
# Implicit detection when not available (retrocompatibility)
bad_os = "Linux" if platform.system() != "Linux" else "Macos"
message = "Cross-build from '%s:x86_64' to '%s:x86_64'" % (
detected_os(), bad_os)
self._create("Hello0", "0.1")
self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os,
ignore_error=True)
self.assertIn(message, self.client.user_io.out)
def install_cwd_test(self):
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("export . lasote/stable")
client.save({"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"},
clean_first=True)
client.run(
"install . --build=missing -s os=Windows -s os_build=Windows --install-folder=win_dir"
)
self.assertIn("Hello/0.1@lasote/stable from local cache",
client.out) # Test "from local cache" output message
client.run(
"install . --build=missing -s os=Macos -s os_build=Macos --install-folder=os_dir"
)
conaninfo = load(
os.path.join(client.current_folder, "win_dir/conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertNotIn("os=Macos", conaninfo)
conaninfo = load(
os.path.join(client.current_folder, "os_dir/conaninfo.txt"))
self.assertNotIn("os=Windows", conaninfo)
self.assertIn("os=Macos", conaninfo)
def install_reference_not_conanbuildinfo_test(self):
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
settings = "os"
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("create . conan/stable")
client.save({}, clean_first=True)
client.run("install Hello/0.1@conan/stable")
self.assertFalse(
os.path.exists(
os.path.join(client.current_folder, "conanbuildinfo.txt")))
def install_with_profile_test(self):
# Test for https://github.com/conan-io/conan/pull/2043
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
settings = "os"
def requirements(self):
self.output.info("PKGOS=%s" % self.settings.os)
"""
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("profile new myprofile")
client.run("profile update settings.os=Linux myprofile")
client.run("install . -pr=myprofile --build")
self.assertIn("PKGOS=Linux", client.out)
mkdir(os.path.join(client.current_folder, "myprofile"))
client.run("install . -pr=myprofile")
client.run("profile new myotherprofile")
client.run("profile update settings.os=FreeBSD myotherprofile")
client.run("install . -pr=myotherprofile")
self.assertIn("PKGOS=FreeBSD", client.out)
client.save({"myotherprofile": "Some garbage without sense [garbage]"})
client.run("install . -pr=myotherprofile")
self.assertIn("PKGOS=FreeBSD", client.out)
error = client.run("install . -pr=./myotherprofile", ignore_error=True)
self.assertTrue(error)
self.assertIn("Error parsing the profile", client.out)
def install_with_path_errors_test(self):
client = TestClient()
# Install without path param not allowed
error = client.run("install", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: Exiting with code: 2", client.out)
# Path with wrong conanfile.txt path
error = client.run(
"install not_real_dir/conanfile.txt --install-folder subdir",
ignore_error=True)
self.assertTrue(error)
self.assertIn("Conanfile not found", client.out)
# Path with wrong conanfile.py path
error = client.run(
"install not_real_dir/conanfile.py --install-folder build",
ignore_error=True)
self.assertTrue(error)
self.assertIn("Conanfile not found", client.out)
def install_broken_reference_test(self):
client = TestClient(servers={"default": TestServer()},
users={"default": [("lasote", "mypass")]})
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
pass
"""
client.save({"conanfile.py": conanfile})
client.run("export . Hello/0.1@lasote/stable")
client.run("remote add_ref Hello/0.1@lasote/stable default")
conan_reference = ConanFileReference.loads("Hello/0.1@lasote/stable")
rmdir(os.path.join(client.client_cache.conan(conan_reference)))
error = client.run("install Hello/0.1@lasote/stable",
ignore_error=True)
self.assertTrue(error)
self.assertIn(
"ERROR: Hello/0.1@lasote/stable was not found in remote 'default'",
client.out)
# If it was associated, it has to be desasociated
client.run("remote remove_ref Hello/0.1@lasote/stable")
error = client.run("install Hello/0.1@lasote/stable",
ignore_error=True)
self.assertTrue(error)
self.assertIn(
"ERROR: Unable to find 'Hello/0.1@lasote/stable' in remotes",
client.out)
def install_argument_order_test(self):
# https://github.com/conan-io/conan/issues/2520
conanfile_boost = """from conans import ConanFile
class BoostConan(ConanFile):
name = "boost"
version = "0.1"
options = {"shared": [True, False]}
default_options = "shared=True"
"""
conanfile = """from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
requires = "boost/0.1@conan/stable"
"""
client = TestClient()
client.save({
"conanfile.py": conanfile,
"conanfile_boost.py": conanfile_boost
})
client.run("create conanfile_boost.py conan/stable")
client.run("install . -o boost:shared=True --build=missing")
output_0 = "%s" % client.out
client.run("install . -o boost:shared=True --build missing")
output_1 = "%s" % client.out
client.run("install -o boost:shared=True . --build missing")
output_2 = "%s" % client.out
client.run("install -o boost:shared=True --build missing .")
output_3 = "%s" % client.out
self.assertNotIn("ERROR", output_3)
self.assertEqual(output_0, output_1)
self.assertEqual(output_1, output_2)
self.assertEqual(output_2, output_3)
client.run(
"install -o boost:shared=True --build boost . --build missing")
output_4 = "%s" % client.out
client.run(
"install -o boost:shared=True --build missing --build boost .")
output_5 = "%s" % client.out
self.assertEqual(output_4, output_5)
def package_requires_in_components_requires_test(self):
client = TestClient()
client.save({
"conanfile1.py": GenConanfile("dep1", "0.1"),
"conanfile2.py": GenConanfile("dep2", "0.1")
})
client.run("create conanfile1.py")
client.run("create conanfile2.py")
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": []}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep1' not used in "
"components requires", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep1::dep1"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep2' not used in components "
"requires", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep1::dep1"]},
"kkk": {"requires": ["kk"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep2' not used in components "
"requires", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": []},
"kkk": {"requires": ["kk"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep1' not used in components "
"requires", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]},
"kkk": {"requires": ["dep3::dep3"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep1' not used in components "
"requires", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]},
"kkk": {"requires": ["dep3::dep3"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep3' declared in components "
"requires but not defined as a recipe requirement", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py", assert_error=True)
self.assertIn(
"consumer/0.1 package_info(): Package require 'dep2' declared in components "
"requires but not defined as a recipe requirement", client.out)
conanfile = GenConanfile("consumer", "0.1") \
.with_requirement("dep1/0.1") \
.with_requirement("dep2/0.1") \
.with_package_info(cpp_info={"components": {"kk": {"requires": ["dep2::comp"]},
"kkk": {"requires": ["dep1::dep1"]}}},
env_info={})
client.save({"conanfile.py": conanfile})
client.run("create conanfile.py") # Correct usage
def test_trace_actions(self):
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
trace_file = os.path.join(temp_folder(), "conan_trace.log")
with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
# UPLOAD A PACKAGE
ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0",
"0.1",
need_patch=True,
build=False)
client.save(files)
client.run("user lasote -p mypass -r default")
client.run("export . lasote/stable")
client.run("install %s --build missing" % str(ref))
client.run("upload %s --all" % str(ref))
traces = load(trace_file)
self.assertNotIn("mypass", traces)
self.assertIn('"password": "******"', traces)
self.assertIn('"Authorization": "**********"', traces)
self.assertIn('"X-Client-Anonymous-Id": "**********"', traces)
actions = traces.splitlines()
without_rest_api = [it for it in actions if "REST_API_CALL" not in it]
self.assertTrue(len(without_rest_api) == 11)
for trace in actions:
doc = json.loads(trace)
self.assertIn("_action", doc) # Valid jsons
self.assertEqual(json.loads(without_rest_api[0])["_action"], "COMMAND")
self.assertEqual(
json.loads(without_rest_api[0])["name"], "authenticate")
self.assertEqual(json.loads(without_rest_api[2])["_action"], "COMMAND")
self.assertEqual(json.loads(without_rest_api[2])["name"], "export")
self.assertEqual(json.loads(without_rest_api[3])["_action"], "COMMAND")
self.assertEqual(
json.loads(without_rest_api[3])["name"], "install_reference")
self.assertEqual(
json.loads(without_rest_api[4])["_action"],
"GOT_RECIPE_FROM_LOCAL_CACHE")
self.assertEqual(
json.loads(without_rest_api[4])["_id"], "Hello0/0.1@lasote/stable")
self.assertEqual(
json.loads(without_rest_api[5])["_action"],
"PACKAGE_BUILT_FROM_SOURCES")
self.assertEqual(json.loads(without_rest_api[6])["_action"], "COMMAND")
self.assertEqual(json.loads(without_rest_api[6])["name"], "upload")
self.assertEqual(json.loads(without_rest_api[7])["_action"], "ZIP")
self.assertEqual(
json.loads(without_rest_api[8])["_action"], "UPLOADED_RECIPE")
self.assertEqual(json.loads(without_rest_api[9])["_action"], "ZIP")
self.assertEqual(
json.loads(without_rest_api[10])["_action"], "UPLOADED_PACKAGE")
num_put = len(
[it for it in actions if "REST_API_CALL" in it and "PUT" in it])
self.assertEqual(num_put, 6) # 3 files the recipe 3 files the package
num_post = len(
[it for it in actions if "REST_API_CALL" in it and "POST" in it])
if "/v2/" in traces:
self.assertEqual(num_post, 0)
else:
self.assertEqual(num_post, 2) # 2 get urls
num_get = len(
[it for it in actions if "REST_API_CALL" in it and "GET" in it])
self.assertEqual(num_get, 10)
# Check masked signature
for action in actions:
doc = json.loads(action)
if doc.get("url") and "signature" in doc.get("url"):
self.assertIn("signature=*****", doc.get("url"))
def git_helper_in_recipe_test(self):
client = TestClient()
git_repo = temp_folder()
save(os.path.join(git_repo, "file.h"), "contents")
with client.chdir(git_repo):
client.run_command("git init .")
client.run_command('git config user.email "*****@*****.**"')
client.run_command('git config user.name "Your Name"')
client.run_command("git checkout -b dev")
client.run_command("git add .")
client.run_command('git commit -m "comm"')
conanfile = """
import os
from conans import ConanFile, tools
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports_sources = "other"
def source(self):
git = tools.Git()
git.clone("%s", "dev")
def build(self):
assert(os.path.exists("file.h"))
""" % git_repo.replace("\\", "/")
client.save({"conanfile.py": conanfile, "other": "hello"})
client.run("create . user/channel")
# Now clone in a subfolder with later checkout
conanfile = """
import os
from conans import ConanFile, tools
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports_sources = "other"
def source(self):
tools.mkdir("src")
git = tools.Git("./src")
git.clone("%s")
git.checkout("dev")
def build(self):
assert(os.path.exists(os.path.join("src", "file.h")))
""" % git_repo.replace("\\", "/")
client.save({"conanfile.py": conanfile, "other": "hello"})
client.run("create . user/channel")
# Base dir, with exports without subfolder and not specifying checkout fails
conanfile = """
import os
from conans import ConanFile, tools
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports_sources = "other"
def source(self):
git = tools.Git()
git.clone("%s")
def build(self):
assert(os.path.exists("file.h"))
""" % git_repo.replace("\\", "/")
client.save({"conanfile.py": conanfile, "other": "hello"})
client.run("create . user/channel", assert_error=True)
self.assertIn("specify a branch to checkout", client.out)
def autotools_real_install_dirs_test(self):
body = r"""#include "hello.h"
#include <iostream>
using namespace std;
void hello()
{
cout << "Hola Mundo!";
}
"""
header = """
#pragma once
void hello();
"""
main = """
#include "hello.h"
int main()
{
hello();
return 0;
}
"""
conanfile = """
from conans import ConanFile, AutoToolsBuildEnvironment, tools
class TestConan(ConanFile):
name = "test"
version = "1.0"
settings = "os", "compiler", "arch", "build_type"
exports_sources = "*"
def build(self):
makefile_am = '''
bin_PROGRAMS = main
lib_LIBRARIES = libhello.a
libhello_a_SOURCES = hello.cpp
main_SOURCES = main.cpp
main_LDADD = libhello.a
'''
configure_ac = '''
AC_INIT([main], [1.0], [[email protected]])
AM_INIT_AUTOMAKE([-Wall -Werror foreign])
AC_PROG_CXX
AC_PROG_RANLIB
AM_PROG_AR
AC_CONFIG_FILES([Makefile])
AC_OUTPUT
'''
tools.save("Makefile.am", makefile_am)
tools.save("configure.ac", configure_ac)
self.run("aclocal")
self.run("autoconf")
self.run("automake --add-missing --foreign")
autotools = AutoToolsBuildEnvironment(self)
autotools.configure()
autotools.make()
autotools.install()
def package_id(self):
# easier to have same package_id for the test
self.info.header_only()
"""
client = TestClient()
client.save({
"conanfile.py": conanfile,
"main.cpp": main,
"hello.h": header,
"hello.cpp": body
})
client.run("create . danimtb/testing")
pkg_path = client.client_cache.package(
PackageReference.loads("test/1.0@danimtb/testing:%s" %
NO_SETTINGS_PACKAGE_ID))
[
self.assertIn(folder, os.listdir(pkg_path))
for folder in ["lib", "bin"]
]
new_conanfile = conanfile.replace(
"autotools.configure()",
"autotools.configure(args=['--bindir=${prefix}/superbindir', '--libdir=${prefix}/superlibdir'])"
)
client.save({"conanfile.py": new_conanfile})
client.run("create . danimtb/testing")
[
self.assertIn(folder, os.listdir(pkg_path))
for folder in ["superlibdir", "superbindir"]
]
[
self.assertNotIn(folder, os.listdir(pkg_path))
for folder in ["lib", "bin"]
]
class SettingsCppStdScopedPackageTests(unittest.TestCase):
# Validation of scoped settings is delayed until graph computation, a conanfile can
# declare a different set of settings, so we should wait until then to validate it.
default_profile = textwrap.dedent("""
[settings]
os=Linux
arch=x86
compiler=gcc
compiler.version=7
compiler.libcxx=libstdc++11
""")
def run(self, *args, **kwargs):
default_profile_path = os.path.join(temp_folder(), "default.profile")
save(default_profile_path, self.default_profile)
with environment_append(
{"CONAN_DEFAULT_PROFILE_PATH": default_profile_path}):
unittest.TestCase.run(self, *args, **kwargs)
def setUp(self):
self.t = TestClient(cache_folder=temp_folder())
settings = ["os", "compiler", "build_type", "arch"]
if self.recipe_cppstd:
settings += ["cppstd"]
conanfile = textwrap.dedent("""
from conans import ConanFile
class Lib(ConanFile):
settings = "{}"
""".format('", "'.join(settings)))
self.t.save({"conanfile.py": conanfile})
def test_value_invalid(self):
self.t.run(
"create . hh/0.1@user/channel -shh:compiler=apple-clang "
"-shh:compiler.cppstd=144",
assert_error=True)
self.assertIn(
"Invalid setting '144' is not a valid 'settings.compiler.cppstd' value",
self.t.out)
def test_value_different_with_scoped_setting(self):
self.t.run(
"create . hh/0.1@user/channel"
" -s hh:cppstd=11"
" -s hh:compiler=gcc"
" -s hh:compiler.cppstd=14",
assert_error=True)
self.assertIn(
"ERROR: Error in resulting settings for package 'hh': Do not use settings"
" 'compiler.cppstd' together with 'cppstd'", self.t.out)
def test_value_different_with_general_setting(self):
deprecation_number = 1 if self.recipe_cppstd else 0
with catch_deprecation_warning(self, n=deprecation_number):
self.t.run(
"create . hh/0.1@user/channel"
" -s cppstd=17"
" -s hh:compiler=gcc"
" -s hh:compiler.cppstd=14",
assert_error=True)
self.assertIn(
"ERROR: Error in resulting settings for package 'hh': Do not use settings"
" 'compiler.cppstd' together with 'cppstd'", self.t.out)
def test_conanfile_without_compiler(self):
conanfile = textwrap.dedent("""
from conans import ConanFile
class Lib(ConanFile):
settings = "os", "arch"
""")
t = TestClient(cache_folder=temp_folder())
t.save({'conanfile.py': conanfile})
with catch_deprecation_warning(self):
# No mismatch, because settings for this conanfile does not include `compiler`
t.run(
"create . hh/0.1@user/channel"
" -s cppstd=17"
" -s hh:compiler=gcc"
" -s hh:compiler.cppstd=14",
assert_error=True)
self.assertIn(
"ERROR: Error in resulting settings for package 'hh': Do not use settings"
" 'compiler.cppstd' together with 'cppstd'", t.out)
def test_conanfile_without_compiler_but_cppstd(self):
conanfile = textwrap.dedent("""
from conans import ConanFile
class Lib(ConanFile):
settings = "os", "arch", "cppstd"
def configure(self):
self.output.info(">>> cppstd: {}".format(self.settings.cppstd))
""")
t = TestClient(cache_folder=temp_folder())
t.save({'conanfile.py': conanfile}, clean_first=True)
with catch_deprecation_warning(self):
# No mismatch, because settings for this conanfile does not include `compiler`
t.run(
"create . hh/0.1@user/channel"
" -s cppstd=17"
" -s hh:compiler=gcc"
" -s hh:compiler.cppstd=14",
assert_error=True)
self.assertIn(
"ERROR: Error in resulting settings for package 'hh': Do not use settings"
" 'compiler.cppstd' together with 'cppstd'", t.out)
def package_info_components_test(self):
dep = textwrap.dedent("""
import os
from conans import ConanFile
class Dep(ConanFile):
def package_info(self):
self.cpp_info.components["dep1"].libs.append("libdep1")
self.cpp_info.components["dep1"].defines.append("definedep1")
self.cpp_info.components["dep2"].libs.append("libdep2")
os.mkdir(os.path.join(self.package_folder, "include"))
os.mkdir(os.path.join(self.package_folder, "includedep2"))
self.cpp_info.components["dep2"].includedirs.append("includedep2")
""")
intermediate = textwrap.dedent("""
import os
from conans import ConanFile
class Intermediate(ConanFile):
requires = "dep/1.0@us/ch"
def package_info(self):
self.cpp_info.components["int1"].requires = ["dep::dep"] # To avoid exception
self.cpp_info.components["int1"].libs.append("libint1")
self.cpp_info.components["int1"].defines.append("defint1")
os.mkdir(os.path.join(self.package_folder, "include"))
os.mkdir(os.path.join(self.package_folder, "includeint1"))
self.cpp_info.components["int1"].includedirs.append("includeint1")
self.cpp_info.components["int2"].libs.append("libint2")
self.cpp_info.components["int2"].defines.append("defint2")
os.mkdir(os.path.join(self.package_folder, "includeint2"))
self.cpp_info.components["int2"].includedirs.append("includeint2")
""")
consumer = textwrap.dedent("""
import os
from conans import ConanFile
class Consumer(ConanFile):
requires = "intermediate/1.0@us/ch"
def build(self):
self.output.info("deps_cpp_info.libs: %s" % list(self.deps_cpp_info.libs))
self.output.info("deps_cpp_info.defines: %s" % list(self.deps_cpp_info.defines))
self.output.info("deps_cpp_info.include_paths: %s" %
[os.path.basename(value) for value in self.deps_cpp_info.include_paths])
for dep_key, dep_value in self.deps_cpp_info.dependencies:
self.output.info("%s.libs: %s" % (dep_key, list(dep_value.libs)))
self.output.info("%s.defines: %s" % (dep_key, list(dep_value.defines)))
self.output.info("%s.include_paths: %s" % (dep_key,
[os.path.basename(value) for value in
dep_value.include_paths]))
""")
client = TestClient()
client.save({
"conanfile_dep.py": dep,
"conanfile_intermediate.py": intermediate,
"conanfile_consumer.py": consumer
})
client.run("export conanfile_dep.py dep/1.0@us/ch")
client.run("export conanfile_intermediate.py intermediate/1.0@us/ch")
client.run(
"create conanfile_consumer.py consumer/1.0@us/ch --build missing")
self.assertIn(
"deps_cpp_info.libs: ['libint1', 'libint2', 'libdep1', 'libdep2']",
client.out)
self.assertIn(
"deps_cpp_info.defines: ['definedep1', 'defint1', 'defint2']",
client.out)
self.assertIn(
"deps_cpp_info.include_paths: ['include', 'includeint1', 'includeint2', "
"'include', 'includedep2']", client.out)
self.assertIn("intermediate.libs: ['libint1', 'libint2']", client.out)
self.assertIn("intermediate.defines: ['defint1', 'defint2']",
client.out)
self.assertIn(
"intermediate.include_paths: ['include', 'includeint1', 'includeint2']",
client.out)
self.assertIn("dep.libs: ['libdep1', 'libdep2']", client.out)
self.assertIn("dep.defines: ['definedep1']", client.out)
self.assertIn("dep.include_paths: ['include', 'includedep2']",
client.out)
def test_toolchain_posix(self, target, build_type):
client = TestClient(path_with_spaces=False)
settings = {
"build_type": build_type,
}
options = {
"fPIC": "True",
}
if target == "exe":
conanfile_options = 'options = {"fPIC": [True, False]}'
conanfile_default_options = 'default_options = {"fPIC": True}'
else:
conanfile_options = 'options = {"shared": [True, False], "fPIC": [True, False]}'
conanfile_default_options = 'default_options = {"shared": False, "fPIC": True}'
if target == "shared":
options["shared"] = True
settings_str = " ".join('-s %s="%s"' % (k, v)
for k, v in settings.items() if v)
options_str = " ".join("-o %s=%s" % (k, v)
for k, v in options.items()) if options else ""
conanfile = textwrap.dedent("""
from conans import ConanFile, MakeToolchain
class App(ConanFile):
settings = "os", "arch", "compiler", "build_type"
{options}
{default_options}
def toolchain(self):
tc = MakeToolchain(self)
tc.variables["TEST_VAR"] = "TestVarValue"
tc.preprocessor_definitions["TEST_DEFINITION"] = "TestPpdValue"
tc.write_toolchain_files()
def build(self):
self.run("make -C ..")
""").format(options=conanfile_options,
default_options=conanfile_default_options)
hello_h = textwrap.dedent("""
#pragma once
#define HELLO_MSG "{0}"
#ifdef WIN32
#define APP_LIB_EXPORT __declspec(dllexport)
#else
#define APP_LIB_EXPORT
#endif
APP_LIB_EXPORT void hello();
""".format(build_type))
hello_cpp = textwrap.dedent("""
#include <iostream>
#include "hello.h"
void hello() {
std::cout << "Hello World " << HELLO_MSG << "!" << std::endl;
#ifdef NDEBUG
std::cout << "App: Release!" << std::endl;
#else
std::cout << "App: Debug!" << std::endl;
#endif
std::cout << "TEST_DEFINITION: " << TEST_DEFINITION << "\\n";
}
""")
# only used for the executable test case
main = textwrap.dedent("""
#include "hello.h"
int main() {
hello();
}
""")
makefile = textwrap.dedent("""
include conan_toolchain.mak
#-------------------------------------------------
# Make variables for a sample App
#-------------------------------------------------
OUT_DIR ?= out
SRC_DIR ?= src
INCLUDE_DIR ?= include
PROJECT_NAME = hello
EXE_FILENAME = $(PROJECT_NAME).bin
STATIC_LIB_FILENAME = lib$(PROJECT_NAME).a
SHARED_LIB_FILENAME = lib$(PROJECT_NAME).so
SRCS += $(wildcard $(SRC_DIR)/*.cpp)
OBJS += $(patsubst $(SRC_DIR)/%.cpp,$(OUT_DIR)/%.o,$(SRCS))
CPPFLAGS += $(addprefix -I,$(INCLUDE_DIR))
#-------------------------------------------------
# Append CONAN_ variables to standards
#-------------------------------------------------
$(call CONAN_TC_SETUP)
# The above function should append CONAN_TC flags to standard flags
$(info >> CFLAGS: $(CFLAGS))
$(info >> CXXFLAGS: $(CXXFLAGS))
$(info >> CPPFLAGS: $(CPPFLAGS))
$(info >> LDFLAGS: $(LDFLAGS))
$(info >> LDLIBS: $(LDLIBS))
$(info >> TEST_VAR: $(TEST_VAR))
#-------------------------------------------------
# Make Rules
#-------------------------------------------------
.PHONY : exe static shared
exe : $(OBJS)
$(CXX) $(OBJS) $(LDFLAGS) $(LDLIBS) -o $(OUT_DIR)/$(EXE_FILENAME)
static : $(OBJS)
$(AR) $(ARFLAGS) $(OUT_DIR)/$(STATIC_LIB_FILENAME) $(OBJS)
shared : $(OBJS)
$(CXX) -shared $(OBJS) $(LDFLAGS) $(LDLIBS) -o $(OUT_DIR)/$(SHARED_LIB_FILENAME)
$(OUT_DIR)/%.o : $(SRC_DIR)/%.cpp $(OUT_DIR)
$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@
$(OUT_DIR):
-mkdir $@
""")
files_to_save = {
"conanfile.py": conanfile,
"Makefile": makefile,
"src/hello.cpp": hello_cpp,
"include/hello.h": hello_h
}
if target == "exe":
files_to_save["src/main.cpp"] = main
client.save(files_to_save, clean_first=True)
client.run("install . hello/0.1@ %s %s" % (settings_str, options_str))
if target == "exe":
client.run_command("make exe")
client.run_command("./out/hello.bin")
self.assertIn("Hello World {}!".format(build_type), client.out)
elif target == "shared":
client.run_command("make shared")
client.run_command("nm -C out/libhello.so | grep 'hello()'")
self.assertIn("hello()", client.out)
elif target == "static":
client.run_command("make static")
client.run_command("nm -C out/libhello.a | grep 'hello()'")
self.assertIn("hello()", client.out)
def build_vs_project_test(self):
conan_build_vs = """
from conans import ConanFile, MSBuild
class HelloConan(ConanFile):
name = "Hello"
version = "1.2.1"
exports = "*"
settings = "os", "build_type", "arch", "compiler", "cppstd"
def build(self):
msbuild = MSBuild(self)
msbuild.build("MyProject.sln", verbosity="normal")
def package(self):
self.copy(pattern="*.exe")
"""
client = TestClient()
# Test cpp standard stuff
files = get_vs_project_files(std="cpp17_2015")
files[CONANFILE] = conan_build_vs
client.save(files)
with catch_deprecation_warning(self):
client.run(
'create . Hello/1.2.1@lasote/stable -s cppstd=11 -s '
'compiler="Visual Studio" -s compiler.version=14',
assert_error=True)
with catch_deprecation_warning(self):
client.run('create . Hello/1.2.1@lasote/stable -s cppstd=17 '
'-s compiler="Visual Studio" -s compiler.version=14')
self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out)
files = get_vs_project_files()
files[CONANFILE] = conan_build_vs
# Try to not update the project
client.cache._config = None # Invalidate cached config
replace_in_file(client.cache.conan_conf_path,
"[general]",
"[general]\nskip_vs_projects_upgrade = True",
output=client.out)
client.save(files, clean_first=True)
client.run("create . Hello/1.2.1@lasote/stable --build")
self.assertNotIn("devenv", client.user_io.out)
self.assertIn("Skipped sln project upgrade", client.out)
# Try with x86_64
client.save(files)
client.run("export . lasote/stable")
client.run("install Hello/1.2.1@lasote/stable --build -s arch=x86_64")
self.assertIn("Release|x64", client.user_io.out)
self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out)
# Try with x86
client.save(files, clean_first=True)
client.run("export . lasote/stable")
client.run("install Hello/1.2.1@lasote/stable --build -s arch=x86")
self.assertIn("Release|x86", client.user_io.out)
self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out)
# Try with x86 debug
client.save(files, clean_first=True)
client.run("export . lasote/stable")
client.run(
"install Hello/1.2.1@lasote/stable --build -s arch=x86 -s build_type=Debug"
)
self.assertIn("Debug|x86", client.user_io.out)
self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out)
# Try with a custom property file name
files[CONANFILE] = conan_build_vs.replace(
'msbuild.build("MyProject.sln", verbosity="normal")',
'msbuild.build("MyProject.sln", verbosity="normal", property_file_name="mp.props")'
)
client.save(files, clean_first=True)
client.run(
"create . Hello/1.2.1@lasote/stable --build -s arch=x86 -s build_type=Debug"
)
self.assertIn("Debug|x86", client.user_io.out)
self.assertIn("Packaged 1 '.exe' file: MyProject.exe", client.out)
full_ref = "Hello/1.2.1@lasote/stable:b786e9ece960c3a76378ca4d5b0d0e922f4cedc1"
pref = PackageReference.loads(full_ref)
build_folder = client.cache.package_layout(pref.ref).build(pref)
self.assertTrue(os.path.exists(os.path.join(build_folder, "mp.props")))
def conanfile_txt_test(self):
client = TestClient()
client.save({"conanfile.txt": ""})
client.run("install .")
client.run("install . --lockfile=conan.lock")
self.assertIn("Using lockfile", client.out)
def test_settings_options(self, build_type, shared, use_repo_file):
# We need two clients sharing the same Conan cache
base_folder = tempfile.mkdtemp(suffix='conans', dir=CONAN_TEST_FOLDER)
# Editable project
client_editable = HeaderOnlyLibTestClient(use_repo_file=use_repo_file,
base_folder=base_folder)
if use_repo_file:
client_editable.run(
"editable add . MyLib/0.1@user/editable -l=mylayout")
else:
client_editable.run("editable add . MyLib/0.1@user/editable")
# Consumer project
client = TestClient(base_folder=base_folder)
conanfile_txt = """
import os
from conans import ConanFile, CMake
class TestConan(ConanFile):
name = "pkg"
version = "0.0"
requires = "MyLib/0.1@user/editable"
settings = "os", "compiler", "build_type", "arch"
generators = "cmake"
exports_sources = "src/*"
def build(self):
cmake = CMake(self)
cmake.configure(source_folder="src")
cmake.build()
os.chdir("bin")
self.run(".%shello" % os.sep)
"""
cmakelists = """
cmake_minimum_required(VERSION 2.8.12)
project(MyHello CXX)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
add_executable(hello main.cpp)
"""
main_cpp = """
#include "hello.hpp"
int main() {
hello();
}
"""
client.save({
"conanfile.py": conanfile_txt,
"src/CMakeLists.txt": cmakelists,
"src/main.cpp": main_cpp
})
# Build consumer project
client.run("create . pkg/0.0@user/testing "
"-s build_type={} -o MyLib:shared={}".format(
build_type, str(shared)))
self.assertIn(
" MyLib/0.1@user/editable from user folder - Editable",
client.out)
self.assertIn("Hello {}!".format(build_type), client.out)
self.assertIn(" - options.shared: {}".format(shared), client.out)
def test_cpp_info_link_objects():
client = TestClient()
obj_ext = "obj" if platform.system() == "Windows" else "o"
cpp_info = {
"objects": [os.path.join("lib", "myobject.{}".format(obj_ext))]
}
object_cpp = gen_function_cpp(name="myobject")
object_h = gen_function_h(name="myobject")
cmakelists = textwrap.dedent("""
cmake_minimum_required(VERSION 3.15)
project(MyObject)
file(GLOB HEADERS *.h)
add_library(myobject OBJECT myobject.cpp)
if( WIN32 )
set(OBJ_PATH "myobject.dir/Release/myobject${CMAKE_C_OUTPUT_EXTENSION}")
else()
set(OBJ_PATH "CMakeFiles/myobject.dir/myobject.cpp${CMAKE_C_OUTPUT_EXTENSION}")
endif()
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${OBJ_PATH}
DESTINATION ${CMAKE_INSTALL_PREFIX}/lib
RENAME myobject${CMAKE_C_OUTPUT_EXTENSION})
install(FILES ${HEADERS}
DESTINATION ${CMAKE_INSTALL_PREFIX}/include)
""")
test_package_cpp = gen_function_cpp(name="main",
includes=["myobject"],
calls=["myobject"])
test_package_cmakelists = textwrap.dedent("""
cmake_minimum_required(VERSION 3.15)
project(example)
find_package(myobject REQUIRED)
add_executable(example example.cpp)
target_link_libraries(example myobject::myobject)
""")
client.save({
"CMakeLists.txt":
cmakelists,
"conanfile.py":
GenConanfile("myobject", "1.0").with_package_info(
cpp_info=cpp_info, env_info={}).with_exports_sources(
"*").with_cmake_build().with_package("cmake = CMake(self)",
"cmake.install()"),
"myobject.cpp":
object_cpp,
"myobject.h":
object_h,
"test_package/conanfile.py":
GenConanfile().with_cmake_build().with_import("import os").with_test(
'path = "{}".format(self.settings.build_type) '
'if self.settings.os == "Windows" else "."').with_test(
'self.run("{}{}example".format(path, os.sep))'),
"test_package/example.cpp":
test_package_cpp,
"test_package/CMakeLists.txt":
test_package_cmakelists
})
client.run("create . -s build_type=Release")
assert "myobject: Release!" in client.out
def test_version_ranges_revisions_update(self):
# https://github.com/conan-io/conan/issues/7333
client = TestClient(default_server_user=True)
client.save({"conanfile.py": GenConanfile()})
client.run("create . PkgA/0.1@")
self.assertIn(
"PkgA/0.1: Exported revision: f3367e0e7d170aa12abccb175fee5f97",
client.out)
client.run("upload * --all --confirm")
client.run("search PkgA/0.1@ --revisions -r=default")
self.assertIn("f3367e0e7d170aa12abccb175fee5f97", client.out)
client2 = TestClient(servers=client.servers, users=client.users)
client2.save({"conanfile.py": GenConanfile("PkgA")})
client2.run("create . PkgA/0.2@")
client2.run("upload * --all --confirm")
client2.save({
"conanfile.py":
GenConanfile("PkgA", "0.2").with_build_msg("Building")
})
time.sleep(1)
client2.run("create . ")
self.assertIn(
"PkgA/0.2: Exported revision: 5e8148093372278be4e8d8e831d8bdb6",
client2.out)
client2.run("upload * --all --confirm")
client2.run("search PkgA/0.2@ --revisions -r=default")
self.assertIn("5e8148093372278be4e8d8e831d8bdb6", client2.out)
self.assertIn("8ec297bab84c88218d1db36ffea97d0e", client2.out)
client.save({
"conanfile.py":
GenConanfile("PkgB", "0.1").with_require("PkgA/[>=0.1]")
})
client.run(
"lock create conanfile.py --update --lockfile-out=conan.lock")
self.assertIn(
"PkgA/0.2: Downloaded recipe revision 5e8148093372278be4e8d8e831d8bdb6",
client.out)
lockfile = client.load("conan.lock")
self.assertIn("5e8148093372278be4e8d8e831d8bdb6", lockfile)
# Put again the old revision locally
client.run("remove * -f")
client.save({"conanfile.py": GenConanfile()})
client.run("create . PkgA/0.1@")
self.assertIn(
"PkgA/0.1: Exported revision: f3367e0e7d170aa12abccb175fee5f97",
client.out)
client.save({
"conanfile.py":
GenConanfile("PkgB", "0.1").with_require("PkgA/[>=0.1]")
})
client.run("install . --lockfile=conan.lock")
self.assertIn(
"PkgA/0.2: Downloaded recipe revision 5e8148093372278be4e8d8e831d8bdb6",
client.out)
class RemoteTest(unittest.TestCase):
def setUp(self):
self.servers = OrderedDict()
self.users = {}
for i in range(3):
test_server = TestServer()
self.servers["remote%d" % i] = test_server
self.users["remote%d" % i] = [("lasote", "mypass")]
self.client = TestClient(servers=self.servers, users=self.users)
def test_removed_references(self):
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
pass
"""
self.client.save({"conanfile.py": conanfile})
self.client.run("create . lib/1.0@lasote/channel")
self.client.run('upload "*" -c -r remote1')
self.client.run('upload "*" -c -r remote2')
self.client.run('remote list_ref')
ref = "lib/1.0@lasote/channel"
pref = "%s:%s" % (ref, NO_SETTINGS_PACKAGE_ID)
self.assertIn("%s: remote1" % ref, self.client.out)
# Remove from remote2, the reference should be kept there
self.client.run('remove "lib/1.0@lasote/channel" -f -r remote2')
self.client.run('remote list_ref')
self.assertIn("%s: remote1" % ref, self.client.out)
# Upload again to remote2 and remove from remote1, the ref shouldn't be removed
self.client.run('upload "*" -c -r remote2')
self.client.run('remove "lib/1.0@lasote/channel" -f -r remote1')
self.client.run('remote list_ref')
self.assertIn("%s: remote1" % ref, self.client.out)
# Test the packages references now
self.client.run('upload "*" -c -r remote1 --all')
self.client.run('upload "*" -c -r remote2 --all')
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertIn("%s: remote1" % pref, self.client.out)
# Remove from remote2, the reference should be kept there
self.client.run('remove "lib/1.0@lasote/channel" '
'-p %s -f -r remote2' % NO_SETTINGS_PACKAGE_ID)
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertIn("%s: remote1" % pref, self.client.out)
# Upload again to remote2 and remove from remote1, the ref shouldn't be removed
self.client.run('upload "*" -c -r remote2 --all')
self.client.run('remove "lib/1.0@lasote/channel" '
'-p %s -f -r remote1' % NO_SETTINGS_PACKAGE_ID)
self.client.run('remote list_ref')
self.assertIn("%s: remote1" % ref, self.client.out)
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertIn("%s: remote1" % pref, self.client.out)
# Remove package locally
self.client.run('upload "*" -c -r remote1 --all')
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertIn("%s: remote1" % pref, self.client.out)
self.client.run('remove "lib/1.0@lasote/channel" '
'-p %s -f' % NO_SETTINGS_PACKAGE_ID)
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertNotIn("%s: remote1" % pref, self.client.out)
# If I remove all in local, I also remove packages
self.client.run("create . lib/1.0@lasote/channel")
self.client.run('upload "*" -c -r remote1')
self.client.run('remove "lib/1.0@lasote/channel" -f')
self.client.run('remote list_pref lib/1.0@lasote/channel')
self.assertEqual("", self.client.out)
def list_raw_test(self):
self.client.run("remote list --raw")
output = re.sub(r"http:\/\/fake.+\.com", "http://fake.com",
str(self.client.out))
self.assertIn("remote0 http://fake.com True", output)
self.assertIn("remote1 http://fake.com True", output)
self.assertIn("remote2 http://fake.com True", output)
def basic_test(self):
self.client.run("remote list")
self.assertIn("remote0: http://", self.client.out)
self.assertIn("remote1: http://", self.client.out)
self.assertIn("remote2: http://", self.client.out)
self.client.run("remote add origin https://myurl")
self.client.run("remote list")
lines = str(self.client.out).splitlines()
self.assertIn("origin: https://myurl", lines[3])
self.client.run("remote update origin https://2myurl")
self.client.run("remote list")
self.assertIn("origin: https://2myurl", self.client.out)
self.client.run("remote update remote0 https://remote0url")
self.client.run("remote list")
output = str(self.client.out)
self.assertIn("remote0: https://remote0url", output.splitlines()[0])
self.client.run("remote remove remote0")
self.client.run("remote list")
output = str(self.client.out)
self.assertIn("remote1: http://", output.splitlines()[0])
def remove_remote_test(self):
self.client.run("remote list")
self.assertIn("remote0: http://", self.client.out)
self.assertIn("remote1: http://", self.client.out)
self.assertIn("remote2: http://", self.client.out)
self.client.run("remote add_ref Hello/0.1@user/testing remote2")
self.client.run("remote add_ref Hello2/0.1@user/testing remote1")
self.client.run("remote remove remote1")
self.client.run("remote list")
self.assertNotIn("remote1", self.client.out)
self.assertIn("remote0", self.client.out)
self.assertIn("remote2", self.client.out)
self.client.run("remote list_ref")
self.assertNotIn("Hello2/0.1@user/testing", self.client.out)
self.assertIn("Hello/0.1@user/testing", self.client.out)
registry = load(self.client.cache.registry_path)
self.assertNotIn("Hello2/0.1@user/testing", registry)
ref = ConanFileReference.loads("Hello/0.1@user/testing")
metadata = self.client.cache.package_layout(ref).load_metadata()
self.assertEqual(metadata.recipe.remote, "remote2")
self.client.run("remote remove remote2")
self.client.run("remote list")
self.assertNotIn("remote1", self.client.out)
self.assertIn("remote0", self.client.out)
self.assertNotIn("remote2", self.client.out)
self.client.run("remote list_ref")
self.assertNotIn("Hello2/0.1@user/testing", self.client.out)
self.assertNotIn("Hello/0.1@user/testing", self.client.out)
registry = load(self.client.cache.registry_path)
self.assertNotIn("Hello2/0.1@user/testing", registry)
self.assertNotIn("Hello/0.1@user/testing", registry)
def clean_remote_test(self):
self.client.run("remote add_ref Hello/0.1@user/testing remote0")
self.client.run("remote clean")
self.client.run("remote list")
self.assertEqual("", self.client.out)
self.client.run("remote list_ref")
self.assertEqual("", self.client.out)
def clean_remote_no_user_test(self):
self.client.run("remote add_ref Hello/0.1 remote0")
self.client.run("remote clean")
self.client.run("remote list")
self.assertEqual("", self.client.out)
self.client.run("remote list_ref")
self.assertEqual("", self.client.out)
def remove_remote_no_user_test(self):
self.client.run("remote add_ref Hello/0.1 remote0")
self.client.run("remote remove remote0")
self.client.run("remote list")
self.assertNotIn("remote0", self.client.out)
self.client.run("remote list_ref")
self.assertEqual("", self.client.out)
def add_force_test(self):
client = TestClient()
client.run("remote add r1 https://r1")
client.run("remote add r2 https://r2")
client.run("remote add r3 https://r3")
client.run("remote add_ref Hello/0.1@user/testing r2")
client.run("remote add_ref Hello2/0.1@user/testing r1")
client.run("remote add r4 https://r4 -f")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r1: https://r1", lines[0])
self.assertIn("r2: https://r2", lines[1])
self.assertIn("r3: https://r3", lines[2])
self.assertIn("r4: https://r4", lines[3])
client.run("remote add r2 https://newr2 -f")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r1: https://r1", lines[0])
self.assertIn("r3: https://r3", lines[1])
self.assertIn("r4: https://r4", lines[2])
self.assertIn("r2: https://newr2", lines[3])
client.run("remote add newr1 https://r1 -f")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r3: https://r3", lines[0])
self.assertIn("r4: https://r4", lines[1])
self.assertIn("r2: https://newr2", lines[2])
self.assertIn("newr1: https://r1", lines[3])
client.run("remote list_ref")
self.assertIn("Hello2/0.1@user/testing: newr1", client.out)
self.assertIn("Hello/0.1@user/testing: r2", client.out)
client.run("remote add newr1 https://newr1 -f -i")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("newr1: https://newr1", lines[0])
self.assertIn("r3: https://r3", lines[1])
self.assertIn("r4: https://r4", lines[2])
self.assertIn("r2: https://newr2", lines[3])
def rename_test(self):
client = TestClient()
client.run("remote add r1 https://r1")
client.run("remote add r2 https://r2")
client.run("remote add r3 https://r3")
client.run("remote add_ref Hello/0.1@user/testing r2")
client.run("remote rename r2 mynewr2")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r1: https://r1", lines[0])
self.assertIn("mynewr2: https://r2", lines[1])
self.assertIn("r3: https://r3", lines[2])
client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: mynewr2", client.out)
# Rename to an existing one
client.run("remote rename r2 r1", assert_error=True)
self.assertIn("Remote 'r1' already exists", client.out)
def insert_test(self):
self.client.run("remote add origin https://myurl --insert")
self.client.run("remote list")
first_line = str(self.client.out).splitlines()[0]
self.assertIn("origin: https://myurl", first_line)
self.client.run("remote add origin2 https://myurl2 --insert=0")
self.client.run("remote list")
lines = str(self.client.out).splitlines()
self.assertIn("origin2: https://myurl2", lines[0])
self.assertIn("origin: https://myurl", lines[1])
self.client.run("remote add origin3 https://myurl3 --insert=1")
self.client.run("remote list")
lines = str(self.client.out).splitlines()
self.assertIn("origin2: https://myurl2", lines[0])
self.assertIn("origin3: https://myurl3", lines[1])
self.assertIn("origin: https://myurl", lines[2])
def update_test_insert(self):
client = TestClient()
client.run("remote add r1 https://r1")
client.run("remote add r2 https://r2")
client.run("remote add r3 https://r3")
client.run("remote update r2 https://r2new --insert")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r2: https://r2new", lines[0])
self.assertIn("r1: https://r1", lines[1])
self.assertIn("r3: https://r3", lines[2])
client.run("remote update r2 https://r2new2 --insert 2")
client.run("remote list")
lines = str(client.out).splitlines()
self.assertIn("r1: https://r1", lines[0])
self.assertIn("r3: https://r3", lines[1])
self.assertIn("r2: https://r2new2", lines[2])
def test_update_insert_same_url(self):
# https://github.com/conan-io/conan/issues/5107
client = TestClient()
client.run("remote add r1 https://r1")
client.run("remote add r2 https://r2")
client.run("remote add r3 https://r3")
client.run("remote update r2 https://r2 --insert=0")
client.run("remote list")
self.assertLess(str(client.out).find("r2"), str(client.out).find("r1"))
self.assertLess(str(client.out).find("r1"), str(client.out).find("r3"))
def verify_ssl_test(self):
client = TestClient()
client.run("remote add my-remote http://someurl TRUE")
client.run("remote add my-remote2 http://someurl2 yes")
client.run("remote add my-remote3 http://someurl3 FALse")
client.run("remote add my-remote4 http://someurl4 No")
registry = load(client.cache.registry_path)
data = json.loads(registry)
self.assertEqual(data["remotes"][0]["name"], "my-remote")
self.assertEqual(data["remotes"][0]["url"], "http://someurl")
self.assertEqual(data["remotes"][0]["verify_ssl"], True)
self.assertEqual(data["remotes"][1]["name"], "my-remote2")
self.assertEqual(data["remotes"][1]["url"], "http://someurl2")
self.assertEqual(data["remotes"][1]["verify_ssl"], True)
self.assertEqual(data["remotes"][2]["name"], "my-remote3")
self.assertEqual(data["remotes"][2]["url"], "http://someurl3")
self.assertEqual(data["remotes"][2]["verify_ssl"], False)
self.assertEqual(data["remotes"][3]["name"], "my-remote4")
self.assertEqual(data["remotes"][3]["url"], "http://someurl4")
self.assertEqual(data["remotes"][3]["verify_ssl"], False)
def remote_disable_test(self):
client = TestClient()
client.run("remote add my-remote0 http://someurl0")
client.run("remote add my-remote1 http://someurl1")
client.run("remote add my-remote2 http://someurl2")
client.run("remote add my-remote3 http://someurl3")
client.run("remote disable my-remote0")
client.run("remote disable my-remote3")
registry = load(client.cache.registry_path)
data = json.loads(registry)
self.assertEqual(data["remotes"][0]["name"], "my-remote0")
self.assertEqual(data["remotes"][0]["url"], "http://someurl0")
self.assertEqual(data["remotes"][0]["disabled"], True)
self.assertEqual(data["remotes"][3]["name"], "my-remote3")
self.assertEqual(data["remotes"][3]["url"], "http://someurl3")
self.assertEqual(data["remotes"][3]["disabled"], True)
client.run("remote disable *")
registry = load(client.cache.registry_path)
data = json.loads(registry)
for remote in data["remotes"]:
self.assertEqual(remote["disabled"], True)
client.run("remote enable *")
registry = load(client.cache.registry_path)
data = json.loads(registry)
for remote in data["remotes"]:
self.assertNotIn("disabled", remote)
def verify_ssl_error_test(self):
client = TestClient()
client.run(
"remote add my-remote http://someurl some_invalid_option=foo",
assert_error=True)
self.assertIn(
"ERROR: Unrecognized boolean value 'some_invalid_option=foo'",
client.out)
data = json.loads(load(client.cache.registry_path))
self.assertEqual(data["remotes"], [])
def errors_test(self):
self.client.run("remote update origin url", assert_error=True)
self.assertIn("ERROR: Remote 'origin' not found in remotes",
self.client.out)
self.client.run("remote remove origin", assert_error=True)
self.assertIn("ERROR: No remote 'origin' defined in remotes",
self.client.out)
def duplicated_error_tests(self):
""" check remote name and URL are not duplicated
"""
self.client.run("remote add remote1 http://otherurl",
assert_error=True)
self.assertIn(
"ERROR: Remote 'remote1' already exists in remotes (use update to modify)",
self.client.out)
self.client.run("remote list")
url = str(self.client.out).split()[1]
self.client.run("remote add newname %s" % url, assert_error=True)
self.assertIn("Remote 'remote0' already exists with same URL",
self.client.out)
self.client.run("remote update remote1 %s" % url, assert_error=True)
self.assertIn("Remote 'remote0' already exists with same URL",
self.client.out)
def basic_refs_test(self):
self.client.run("remote add_ref Hello/0.1@user/testing remote0")
self.client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: remote0", self.client.out)
self.client.run("remote add_ref Hello1/0.1@user/testing remote1")
self.client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: remote0", self.client.out)
self.assertIn("Hello1/0.1@user/testing: remote1", self.client.out)
self.client.run("remote remove_ref Hello1/0.1@user/testing")
self.client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: remote0", self.client.out)
self.assertNotIn("Hello1/0.1@user/testing", self.client.out)
self.client.run("remote add_ref Hello1/0.1@user/testing remote1")
self.client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: remote0", self.client.out)
self.assertIn("Hello1/0.1@user/testing: remote1", self.client.out)
self.client.run("remote update_ref Hello1/0.1@user/testing remote2")
self.client.run("remote list_ref")
self.assertIn("Hello/0.1@user/testing: remote0", self.client.out)
self.assertIn("Hello1/0.1@user/testing: remote2", self.client.out)
def package_refs_test(self):
self.client.run("remote add_pref Hello/0.1@user/testing:555 remote0")
self.client.run("remote list_pref Hello/0.1@user/testing")
self.assertIn("Hello/0.1@user/testing:555: remote0", self.client.out)
self.client.run("remote add_pref Hello1/0.1@user/testing:555 remote1")
self.client.run("remote list_pref Hello1/0.1@user/testing")
self.assertIn("Hello1/0.1@user/testing:555: remote1", self.client.out)
self.client.run("remote remove_pref Hello1/0.1@user/testing:555")
self.client.run("remote list_pref Hello1/0.1@user/testing")
self.assertNotIn("Hello1/0.1@user/testing:555", self.client.out)
self.client.run("remote add_pref Hello1/0.1@user/testing:555 remote0")
self.client.run("remote add_pref Hello1/0.1@user/testing:666 remote1")
self.client.run("remote list_pref Hello1/0.1@user/testing")
self.assertIn("Hello1/0.1@user/testing:555: remote0", self.client.out)
self.assertIn("Hello1/0.1@user/testing:666: remote1", self.client.out)
self.client.run(
"remote update_pref Hello1/0.1@user/testing:555 remote2")
self.client.run("remote list_pref Hello1/0.1@user/testing")
self.assertIn("Hello1/0.1@user/testing:555: remote2", self.client.out)
self.assertIn("Hello1/0.1@user/testing:666: remote1", self.client.out)
def missing_subarguments_test(self):
self.client.run("remote", assert_error=True)
self.assertIn("ERROR: Exiting with code: 2", self.client.out)
def test_invalid_url(self):
self.client.run("remote add foobar foobar.com")
self.assertIn(
"WARN: The URL 'foobar.com' is invalid. It must contain scheme and hostname.",
self.client.out)
self.client.run("remote list")
self.assertIn("foobar.com", self.client.out)
self.client.run("remote update foobar pepe.org")
self.assertIn(
"WARN: The URL 'pepe.org' is invalid. It must contain scheme and hostname.",
self.client.out)
self.client.run("remote list")
self.assertIn("pepe.org", self.client.out)
def test_metadata_editable_packages(self):
"""
Check that 'conan remote' commands work with editable packages
"""
self.client.save({
"conanfile.py":
"""from conans import ConanFile
class Conan(ConanFile):
pass"""
})
self.client.run("create . pkg/1.1@lasote/stable")
self.client.run(
"upload pkg/1.1@lasote/stable --all -c --remote remote1")
self.client.run("remove -f pkg/1.1@lasote/stable")
self.client.run("install pkg/1.1@lasote/stable")
self.assertIn("pkg/1.1@lasote/stable: Package installed",
self.client.out)
self.client.run("remote list_ref")
self.assertIn("pkg/1.1@lasote/stable: remote1", self.client.out)
self.client.run("editable add . pkg/1.1@lasote/stable")
# Check add --force, update and rename
self.client.run("remote add remote2 %s --force" %
self.servers["remote1"].fake_url)
self.client.run("remote update remote2 %sfake" %
self.servers["remote1"].fake_url)
self.client.run("remote rename remote2 remote-fake")
self.client.run("editable remove pkg/1.1@lasote/stable")
# Check associated remote has changed name
self.client.run("remote list_ref")
self.assertIn("pkg/1.1@lasote/stable: remote-fake", self.client.out)
# Check remove
self.client.run("editable add . pkg/1.1@lasote/stable")
self.client.run("remote remove remote-fake")
self.client.run("remote list")
self.assertIn("remote0: %s" % self.servers["remote0"].fake_url,
self.client.out)
self.assertNotIn("remote-fake", self.client.out)
# Check clean
self.client.run("editable remove pkg/1.1@lasote/stable")
self.client.run("remove -f pkg/1.1@lasote/stable")
self.client.run("remote add remote1 %s" %
self.servers["remote1"].fake_url)
self.client.run("install pkg/1.1@lasote/stable")
self.client.run("editable add . pkg/1.1@lasote/stable")
self.client.run("remote clean")
self.client.run("remote list")
self.assertNotIn("remote1", self.client.out)
self.assertNotIn("remote0", self.client.out)
def missing_lock_error_test(self):
client = TestClient()
client.save({"conanfile.py": GenConanfile("PkgA", "0.1")})
client.run("install . --lockfile=conan.lock", assert_error=True)
self.assertIn("ERROR: Missing lockfile in", client.out)
def test_conan_test(self):
conanfile = '''
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
settings = "os", "compiler", "build_type", "arch"
requires = "Hello0/0.1@lasote/stable"
generators = "cmake"
def build(self):
cmake = CMake(self)
self.run('cmake "%s" %s' % (self.source_folder, cmake.command_line))
self.run("cmake --build . %s" % cmake.build_config)
def test(self):
# equal to ./bin/greet, but portable windows
self.run(os.sep.join([".","bin", "greet"]))
'''
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)'
files[CONANFILE] = files[CONANFILE].replace(
"def build(self):", 'def build(self):\n %s' % print_build)
# Add build_type setting
files[CONANFILE] = files[CONANFILE].replace(', "arch"',
', "arch", "build_type"')
cmakelist = """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()
ADD_EXECUTABLE(greet main.cpp)
TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS})
"""
files["test_package/CMakeLists.txt"] = cmakelist
files["test_package/conanfile.py"] = conanfile
files["test_package/main.cpp"] = files["main.cpp"]
client.save(files)
client.run("create . lasote/stable -tf=None")
time.sleep(
1
) # Try to avoid windows errors in CI (Cannot change permissions)
client.run(
"test test_package Hello0/0.1@lasote/stable -s build_type=Release")
self.assertIn('Hello Hello0', client.out)
self.assertNotIn("WARN: conanbuildinfo.txt file not found", client.out)
self.assertNotIn("WARN: conanenv.txt file not found", client.out)
self.assertIn('Hello Hello0', client.out)
client.run(
"test test_package Hello0/0.1@lasote/stable -s Hello0:build_type=Debug "
"-o Hello0:language=1 --build missing")
self.assertIn('Hola Hello0', client.out)
self.assertIn('BUILD_TYPE=>Debug', client.out)
def test_system_libs():
conanfile = textwrap.dedent("""
from conans import ConanFile
from conans.tools import save
import os
class Test(ConanFile):
name = "Test"
version = "0.1"
settings = "build_type"
def package(self):
save(os.path.join(self.package_folder, "lib/lib1.lib"), "")
save(os.path.join(self.package_folder, "lib/liblib1.a"), "")
def package_info(self):
self.cpp_info.libs = ["lib1"]
if self.settings.build_type == "Debug":
self.cpp_info.system_libs.append("sys1d")
else:
self.cpp_info.system_libs.append("sys1")
""")
client = TestClient()
client.save({"conanfile.py": conanfile})
client.run("create . -s build_type=Release")
client.run("create . -s build_type=Debug")
conanfile = textwrap.dedent("""
[requires]
Test/0.1
[generators]
CMakeDeps
""")
cmakelists = textwrap.dedent("""
cmake_minimum_required(VERSION 3.15)
project(consumer NONE)
set(CMAKE_PREFIX_PATH ${CMAKE_BINARY_DIR})
set(CMAKE_MODULE_PATH ${CMAKE_BINARY_DIR})
find_package(Test)
message("System libs release: ${Test_SYSTEM_LIBS_RELEASE}")
message("Libraries to Link release: ${Test_LIBS_RELEASE}")
message("System libs debug: ${Test_SYSTEM_LIBS_DEBUG}")
message("Libraries to Link debug: ${Test_LIBS_DEBUG}")
get_target_property(tmp Test::Test INTERFACE_LINK_LIBRARIES)
message("Target libs: ${tmp}")
""")
for build_type in ["Release", "Debug"]:
client.save({
"conanfile.txt": conanfile,
"CMakeLists.txt": cmakelists
},
clean_first=True)
client.run("install conanfile.txt -s build_type=%s" % build_type)
client.run_command('cmake . -DCMAKE_BUILD_TYPE={0}'.format(build_type))
library_name = "sys1d" if build_type == "Debug" else "sys1"
# FIXME: Note it is CONAN_LIB::Test_lib1_RELEASE, not "lib1" as cmake_find_package
if build_type == "Release":
assert "System libs release: %s" % library_name in client.out
assert "Libraries to Link release: lib1" in client.out
target_libs = "$<$<CONFIG:Release>:CONAN_LIB::Test_lib1_RELEASE;sys1;"
else:
assert "System libs debug: %s" % library_name in client.out
assert "Libraries to Link debug: lib1" in client.out
target_libs = "$<$<CONFIG:Debug>:CONAN_LIB::Test_lib1_DEBUG;sys1d;"
assert "Target libs: %s" % target_libs in client.out
def test_python_requires_with_alias(self, use_alias, use_alias_of_alias):
assert use_alias if use_alias_of_alias else True
version_str = "latest2" if use_alias_of_alias else "latest" if use_alias else "1.0"
client = TestClient()
# Create python_requires
client.save({
CONANFILE:
"""
from conans import ConanFile
class PythonRequires0(ConanFile):
def build(self):
super(PythonRequires0, self).build()
self.output.info(">>> PythonRequires0::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("export . python_requires0/1.0@jgsogo/test")
client.run("alias python_requires0/latest@jgsogo/test "
"python_requires0/1.0@jgsogo/test")
client.run("alias python_requires0/latest2@jgsogo/test "
"python_requires0/latest@jgsogo/test")
# Create python requires, that require the previous one
client.save({
CONANFILE:
"""
from conans import ConanFile, python_requires
base = python_requires("python_requires0/{v}@jgsogo/test")
class PythonRequires1(base.PythonRequires0):
def build(self):
super(PythonRequires1, self).build()
self.output.info(">>> PythonRequires1::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("export . python_requires1/1.0@jgsogo/test")
client.run(
"alias python_requires1/latest@jgsogo/test python_requires1/1.0@jgsogo/test"
)
client.run(
"alias python_requires1/latest2@jgsogo/test python_requires1/latest@jgsogo/test"
)
# Create python requires
client.save({
CONANFILE:
"""
from conans import ConanFile, python_requires
class PythonRequires11(ConanFile):
def build(self):
super(PythonRequires11, self).build()
self.output.info(">>> PythonRequires11::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("export . python_requires11/1.0@jgsogo/test")
client.run(
"alias python_requires11/latest@jgsogo/test python_requires11/1.0@jgsogo/test"
)
client.run("alias python_requires11/latest2@jgsogo/test "
"python_requires11/latest@jgsogo/test")
# Create python requires, that require the previous one
client.save({
CONANFILE:
"""
from conans import ConanFile, python_requires
base = python_requires("python_requires0/{v}@jgsogo/test")
class PythonRequires22(base.PythonRequires0):
def build(self):
super(PythonRequires22, self).build()
self.output.info(">>> PythonRequires22::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("export . python_requires22/1.0@jgsogo/test")
client.run(
"alias python_requires22/latest@jgsogo/test python_requires22/1.0@jgsogo/test"
)
client.run(
"alias python_requires22/latest2@jgsogo/test python_requires22/latest@jgsogo/test"
)
# Another python_requires, that requires the previous python requires
client.save({
CONANFILE:
"""
from conans import ConanFile, python_requires
base_class = python_requires("python_requires1/{v}@jgsogo/test")
base_class2 = python_requires("python_requires11/{v}@jgsogo/test")
class PythonRequires2(base_class.PythonRequires1, base_class2.PythonRequires11):
def build(self):
super(PythonRequires2, self).build()
self.output.info(">>> PythonRequires2::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("export . python_requires2/1.0@jgsogo/test")
client.run(
"alias python_requires2/latest@jgsogo/test python_requires2/1.0@jgsogo/test"
)
client.run(
"alias python_requires2/latest2@jgsogo/test python_requires2/latest@jgsogo/test"
)
# My project, will consume the latest python requires
client.save({
CONANFILE:
"""
from conans import ConanFile, python_requires
base_class = python_requires("python_requires2/{v}@jgsogo/test")
base_class2 = python_requires("python_requires22/{v}@jgsogo/test")
class Project(base_class.PythonRequires2, base_class2.PythonRequires22):
def build(self):
super(Project, self).build()
self.output.info(">>> Project::build (v={{}})".format(self.version))
""".format(v=version_str)
})
client.run("create . project/1.0@jgsogo/test --build=missing")
# Check that everything is being built
self.assertIn(
"project/1.0@jgsogo/test: >>> PythonRequires11::build (v=1.0)",
client.out)
self.assertIn(
"project/1.0@jgsogo/test: >>> PythonRequires0::build (v=1.0)",
client.out)
self.assertIn(
"project/1.0@jgsogo/test: >>> PythonRequires22::build (v=1.0)",
client.out)
self.assertIn(
"project/1.0@jgsogo/test: >>> PythonRequires1::build (v=1.0)",
client.out)
self.assertIn(
"project/1.0@jgsogo/test: >>> PythonRequires2::build (v=1.0)",
client.out)
self.assertIn("project/1.0@jgsogo/test: >>> Project::build (v=1.0)",
client.out)
# Check that all the graph is printed properly
# - requirements
self.assertIn(" project/1.0@jgsogo/test from local cache - Cache",
client.out)
# - python requires
self.assertIn(" python_requires11/1.0@jgsogo/test", client.out)
self.assertIn(" python_requires0/1.0@jgsogo/test", client.out)
self.assertIn(" python_requires22/1.0@jgsogo/test", client.out)
self.assertIn(" python_requires1/1.0@jgsogo/test", client.out)
self.assertIn(" python_requires2/1.0@jgsogo/test", client.out)
# - packages
self.assertIn(
" project/1.0@jgsogo/test:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 - Build",
client.out)
# - no mention to alias
self.assertNotIn("alias", client.out)
self.assertNotIn("alias2", client.out)
def test_conaninfo_filtered(self):
client = TestClient()
# Try injecting some package level ENV in the install, but without priority
self._export(client, "A", [], {}, {
"VAR1": "900",
"VAR2": "23",
"VAR3": "-23"
})
self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
self._export(client, "B2", ["A"], {}, {
"VAR1": "800_2",
"VAR2": "24_2"
})
self._export(client, "C", ["B", "B2"], {"VAR3": "bestvalue"},
{"VAR1": "700"})
def load_conaninfo(lib):
# Read the LIB_A conaninfo
packages_path = client.client_cache.packages(
ConanFileReference.loads("LIB_%s/1.0@lasote/stable" % lib))
package_path = os.path.join(packages_path,
os.listdir(packages_path)[0])
info = ConanInfo.loads(load(os.path.join(package_path, CONANINFO)))
return info
# Test "A" conaninfo, should filter the FAKE_LIB
client.save({"conanfile.py": reuse})
client.run("install . --build missing -e LIB_A:VAR3=override "
"-e GLOBAL=99 -e FAKE_LIB:VAR1=-90 -e LIB_B:VAR2=222 "
"-e LIB_B2:NEWVAR=VALUE -e VAR3=[newappend]")
info = load_conaninfo("A")
self.assertEquals(info.env_values.env_dicts("LIB_A"), ({
"VAR3": "override",
"GLOBAL": "99"
}, {}))
self.assertEquals(info.env_values.env_dicts(""), ({
'GLOBAL': '99'
}, {
'VAR3': ['newappend']
}))
info = load_conaninfo("B")
self.assertEquals(info.env_values.env_dicts("LIB_A"),
({
'GLOBAL': '99',
'VAR3': "override"
}, {
'VAR2': ['23'],
'VAR1': ['900']
}))
self.assertEquals(info.env_values.env_dicts("LIB_B"), ({
'GLOBAL': '99',
"VAR2": "222"
}, {
'VAR3': ['newappend', '-23'],
'VAR1': ["900"]
}))
info = load_conaninfo("B2")
self.assertEquals(info.env_values.env_dicts("LIB_A"),
({
'GLOBAL': '99',
'VAR3': 'override'
}, {
'VAR2': ['23'],
'VAR1': ['900']
}))
self.assertEquals(info.env_values.env_dicts("LIB_B2"),
({
'GLOBAL': '99',
'NEWVAR': "VALUE"
}, {
'VAR2': ['23'],
'VAR1': ['900'],
'VAR3': ['newappend', '-23']
}))
info = load_conaninfo("C")
self.assertEquals(info.env_values.env_dicts("LIB_B2"),
({
'GLOBAL': '99',
'NEWVAR': "VALUE"
}, {
'VAR3': ['newappend', '-23'],
'VAR1': ['800', '800_2', '900'],
'VAR2': ['24', '24_2', '23']
}))
self.assertEquals(info.env_values.env_dicts("LIB_C"), ({
'GLOBAL': '99'
}, {
'VAR2': ['24', '24_2', '23'],
'VAR1': ['800', '800_2', '900'],
'VAR3': ['newappend', "-23"]
}))
# Now check the info for the project
info = ConanInfo.loads(
load(os.path.join(client.current_folder, CONANINFO)))
self.assertEquals(info.env_values.env_dicts("PROJECT"), ({
'GLOBAL': '99'
}, {
'VAR2': ['24', '24_2', '23'],
'VAR1': ['700', '800', '800_2', '900'],
'VAR3': ['newappend', 'bestvalue']
}))
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 conan_scopes_test(self):
client = TestClient()
conanfile = '''
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def build(self):
if self.scope.dev:
self.output.warn("DEP DEV")
if self.scope.other:
self.output.warn("DEP OTHER")
'''
files = {}
files["conanfile.py"] = conanfile
client.save(files)
client.run("export lasote/stable")
conanfile = '''
from conans import ConanFile
class HelloConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def config(self):
self.output.info(self.scope)
if self.scope.dev:
self.output.warn("CONFIG_CONSUMER DEV")
if self.scope.other:
self.output.warn("CONFIG_CONSUMER OTHER")
def build(self):
if self.scope.dev:
self.output.warn("BUILD_CONSUMER DEV")
if self.scope.other:
self.output.warn("BUILD_CONSUMER OTHER")
'''
files["conanfile.py"] = conanfile
client.save(files, clean_first=True)
client.run("install --build")
self.assertNotIn("WARN: DEP DEV", client.user_io.out)
self.assertNotIn("WARN: DEP OTHER", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
client.run("install --build -sc other=True")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("[scope] dev=True other=True",
"".join(conaninfo.splitlines()))
self.assertIn("dev=True, other=True", client.user_io.out)
self.assertNotIn("WARN: DEP DEV", client.user_io.out)
self.assertNotIn("WARN: DEP OTHER", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
client.run("install --build -sc Hello:dev=True")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("[scope] dev=True Hello:dev=True",
"".join(conaninfo.splitlines()))
self.assertIn("WARN: DEP DEV", client.user_io.out)
self.assertNotIn("WARN: DEP OTHER", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
client.run("install --build -sc Hello:other=True")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("[scope] dev=True Hello:other=True",
"".join(conaninfo.splitlines()))
self.assertNotIn("WARN: DEP DEV", client.user_io.out)
self.assertIn("WARN: DEP OTHER", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
client.run("install --build -sc Hello:other=False")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("[scope] dev=True Hello:other=False",
"".join(conaninfo.splitlines()))
self.assertNotIn("WARN: DEP DEV", client.user_io.out)
self.assertNotIn("WARN: DEP OTHER", client.user_io.out)
self.assertIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
client.run("build")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("[scope] dev=True Hello:other=False",
"".join(conaninfo.splitlines()))
self.assertNotIn("WARN: DEP DEV", client.user_io.out)
self.assertNotIn("WARN: DEP OTHER", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: CONFIG_CONSUMER OTHER", client.user_io.out)
self.assertIn("WARN: BUILD_CONSUMER DEV", client.user_io.out)
self.assertNotIn("WARN: BUILD_CONSUMER OTHER", client.user_io.out)
