def test_txt(self):
base = '''[requires]
lib/0.1@user/channel
'''
extension = '''[requires]
lib/0.1@user/channel
otherlib/0.2@user/channel
[options]
otherlib:otherlib_option = 1
'''
files = {"conanfile.txt": base,
"conanfile_dev.txt": extension}
client = TestClient(self.base_folder)
client.save(files)
client.run("install --build")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("lib/0.1@user/channel", conaninfo)
self.assertNotIn("otherlib/0.2@user/channel", conaninfo)
self.assertNotIn("otherlib:otherlib_option=1", conaninfo)
client.run("install --build --file=conanfile_dev.txt")
conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
self.assertIn("lib/0.1@user/channel", conaninfo)
self.assertIn("otherlib/0.2@user/channel", conaninfo)
self.assertIn("otherlib:otherlib_option=1", conaninfo)
class InstallUpdateTest(unittest.TestCase):
def setUp(self):
test_server = TestServer()
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
def reuse_test(self):
files = cpp_hello_conan_files("Hello0", "1.0", build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
client2.run("install Hello0/1.0@lasote/stable")
files["helloHello0.h"] = "//EMPTY!"
self.client.save(files, clean_first=True)
sleep(1)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2.run("install Hello0/1.0@lasote/stable --update")
ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
package_ids = client2.paths.conan_packages(ref)
package_path = client2.paths.package(PackageReference(ref, package_ids[0]))
header = load(os.path.join(package_path, "include/helloHello0.h"))
self.assertEqual(header, "//EMPTY!")
def setUp(self):
client = TestClient()
base = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
'''
files = {"conanfile.py": base}
client.save(files)
client.run("export user/channel")
base = '''
from conans import ConanFile
class ConanOtherLib(ConanFile):
name = "otherlib"
version = "0.2"
options = {"otherlib_option": [1, 2, 3]}
default_options="otherlib_option=3"
'''
files = {"conanfile.py": base}
client.save(files)
client.run("export user/channel")
self.base_folder = client.base_folder
def upload_test(self):
test_server = TestServer([], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
files = {"conanfile.py": base}
client.save(files)
client.run("export lasote/channel")
client.run("install lib/0.1@lasote/channel --build")
client.run("upload lib/0.1@lasote/channel --all")
client.run("remove lib/0.1@lasote/channel -f")
client.run("search")
self.assertIn("There are no packages", client.user_io.out)
for download in ("", "--all"):
client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client2.run("install lib/0.1@lasote/channel %s" % download)
reference = ConanFileReference.loads("lib/0.1@lasote/channel")
export_folder = client2.client_cache.export(reference)
export_files = os.listdir(export_folder)
self.assertNotIn('conan_export.tgz', export_files)
package_ref = PackageReference.loads("lib/0.1@lasote/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client2.client_cache.package(package_ref, short_paths=None)
if platform.system() == "Windows":
original_folder = client2.client_cache.package(package_ref)
link = load(os.path.join(original_folder, ".conan_link"))
self.assertEqual(link, package_folder)
files = os.listdir(package_folder)
self.assertIn("myfile.txt", files)
self.assertIn("myfile2.txt", files)
self.assertNotIn("conan_package.tgz", files)
def test_export_the_same_code(self):
file_list = self._create_packages_and_builds()
# Export the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path2 = conan2.paths.export(self.conan_ref)
digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('conanfile.py exported as %s in %s'
% (self.conan_ref, reg_path2), conan2.user_io.out)
self.assertTrue(os.path.exists(reg_path2))
for name in files2.keys():
self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08',
'conanfile.py': '4df4b5266ad6d5d55cbdd0a8b12c9d1a',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest2.file_sums)
for f in file_list:
self.assertTrue(os.path.exists(f))
def test_export_a_new_version(self):
self._create_packages_and_builds()
# Export an update of the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path3 = conan2.paths.export(self.conan_ref)
digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn('A new conanfile.py version was exported', conan2.user_io.out)
# self.assertIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('conanfile.py exported as %s in %s'
% (self.conan_ref, reg_path3), conan2.user_io.out)
self.assertTrue(os.path.exists(reg_path3))
for name in files2.keys():
self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08',
'conanfile.py': '5a2c6e2d6b39638b7d8560786d7935a3',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest3.file_sums)
def 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 complete_build_flow_test(self):
"""In local user folder"""
client = TestClient()
command = os.sep.join([".", "bin", "say_hello"])
for install, lang, static in [("install", 0, True),
("install -o language=1", 1, True),
("install -o language=1 -o static=False", 1, False),
("install -o static=False", 0, False)]:
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export)
client.save(files)
client.run(install)
time.sleep(1) # necessary so the conaninfo.txt is flushed to disc
client.run('build')
client.runner(command, client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, client.user_io.out)
conan_info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(conan_info_path))
self.assertTrue(conan_info.full_options.language == lang)
if static:
self.assertTrue(conan_info.full_options.static)
else:
self.assertFalse(conan_info.full_options.static)
def 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)
class InstallUpdateTest(unittest.TestCase):
def setUp(self):
test_server = TestServer([("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
def reuse_test(self):
files = cpp_hello_conan_files("Hello0", "1.0")
# To avoid building
files[CONANFILE] = files[CONANFILE].replace("build(", "build2(")
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
client2.run("install Hello0/1.0@lasote/stable")
files["helloHello0.h"] = "//EMPTY!"
self.client.save(files, clean_first=True)
sleep(1)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload Hello0/1.0@lasote/stable --all")
client2.run("install Hello0/1.0@lasote/stable --update")
ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
package_ids = client2.paths.conan_packages(ref)
package_path = client2.paths.package(PackageReference(ref, package_ids[0]))
header = load(os.path.join(package_path, "include/helloHello0.h"))
self.assertEqual(header, "//EMPTY!")
def test_export_the_same_code(self):
file_list = self._create_packages_and_builds()
# Export the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path2 = conan2.paths.export(self.conan_ref)
digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path2))
for name in files2.keys():
self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': 'f21a98d974e9294b0d709070042c6e78',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest2.file_sums)
for f in file_list:
self.assertTrue(os.path.exists(f))
def 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 scopes_test_package_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
def build(self):
self.output.info("Scope: %s" % self.scope)
"""
test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
client.save({"conanfile.py": conanfile,
"test/conanfile.py": test_conanfile})
client.run("test_package --scope Hello:dev=True --build=missing")
self.assertIn("Hello/0.1@lasote/stable: Scope: dev=True", client.user_io.out)
def test_export_a_new_version(self):
self._create_packages_and_builds()
# Export an update of the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path3 = conan2.paths.export(self.conan_ref)
digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn('A new conanfile.py version was exported', conan2.user_io.out)
self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path3))
for name in files2.keys():
self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': 'c5889ea6485599c7a0cae02b54270b35',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest3.file_sums)
def change_option_txt_test(self):
self._create("Hello0", "0.1")
client = TestClient(base_folder=self.client.base_folder)
files = {CONANFILE_TXT: """[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=1
"""}
client.save(files)
client.run("install %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=1", conan_info.full_options.dumps())
self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b",
conan_info.full_requires.dumps())
files = {CONANFILE_TXT: """[requires]
Hello0/0.1@lasote/stable
[options]
Hello0:language=0
"""}
client.save(files)
client.run("install %s --build missing" % self.settings)
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.load_file(info_path)
self.assertEqual("", conan_info.options.dumps())
self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
conan_info.full_requires.dumps())
def check_multi_server_test(self):
# Check what happen if we have 2 servers and one is outdated
# The expected behavior: If we specify the remote with (-r), the commmand will fail
# if the client fot that remote is outdated. If we are just looking for a package (not with -r)
# the client will look for the package on each remote.
# Client deprecated for "the_last_server" but OK for "normal_server"
self.servers = OrderedDict({"the_last_server": self._get_server(10, 4),
"normal_server": self._get_server(4, 2)})
# First upload a package ok with an ok client
tmp_client = TestClient(servers=self.servers,
users=[("lasote", "mypass")], client_version=4)
files = cpp_hello_conan_files("Hello0", "0.1")
tmp_client.save(files)
tmp_client.run("export lasote/stable")
errors = tmp_client.run("upload Hello0/0.1@lasote/stable -r normal_server --all")
errors |= tmp_client.run("upload Hello0/0.1@lasote/stable -r the_last_server --all")
self.assertFalse(errors)
# Now with a conflictive client...try to look in servers
self.client = TestClient(servers=self.servers,
users=[("lasote", "mypass")], client_version=2)
errors = self.client.run("search something -r the_last_server", ignore_error=True)
self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
self.assertTrue(errors) # Errors
errors = self.client.run("install Hello0/0.1@lasote/stable --build missing", ignore_error=True)
self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
self.assertFalse(errors) # No Errors! because it finds the package in the second remote
def _test_with_conanfile(self, test_conanfile):
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)'
files[CONANFILE] = files[CONANFILE].replace("def build(self):",
'def build(self):\n %s' % print_build)
# Add build_type setting
files[CONANFILE] = files[CONANFILE].replace(', "arch"',
', "arch", "build_type"')
cmakelist = """PROJECT(MyHello)
cmake_minimum_required(VERSION 2.8)
include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()
ADD_EXECUTABLE(greet main.cpp)
TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS})
"""
files["test_package/CMakeLists.txt"] = cmakelist
files["test_package/conanfile.py"] = test_conanfile
files["test_package/main.cpp"] = files["main.cpp"]
client.save(files)
client.run("export lasote/stable")
error = client.run("test -s build_type=Release")
self.assertFalse(error)
self.assertNotIn("Project: WARN: conanbuildinfo.txt file not found", client.user_io.out)
self.assertNotIn("Project: WARN: conanenv.txt file not found", client.user_io.out)
self.assertIn('Hello Hello0', client.user_io.out)
error = client.run("test -s Hello0:build_type=Debug -o Hello0:language=1")
self.assertFalse(error)
self.assertIn('Hola Hello0', client.user_io.out)
self.assertIn('BUILD_TYPE=>Debug', client.user_io.out)
def 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 ..')
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def build_policies_update_test(self):
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
conanfile = """
from conans import ConanFile
class MyPackage(ConanFile):
name = "test"
version = "1.9"
build_policy = 'always'
def source(self):
self.output.info("Getting sources")
def build(self):
self.output.info("Building sources")
def package(self):
self.output.info("Packaging this test package")
"""
files = {CONANFILE: conanfile}
client.save(files, clean_first=True)
client.run("export lasote/stable")
client.run("install test/1.9@lasote/stable")
self.assertIn("Getting sources", client.user_io.out)
self.assertIn("Building sources", client.user_io.out)
self.assertIn("Packaging this test package", client.user_io.out)
self.assertIn("Building package from source as defined by build_policy='always'",
client.user_io.out)
client.run("upload test/1.9@lasote/stable")
def package_errors_test(self):
client = TestClient()
client.run("package whatever@user/channel", ignore_error=True)
self.assertIn("Wrong package recipe", client.user_io.out)
client.run("package whatever/1.0@user/channel", ignore_error=True)
self.assertIn("ERROR: Package recipe 'whatever/1.0@user/channel' does not exist",
client.user_io.out)
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
name = "MyLib"
version = "0.1"
"""
client.save({CONANFILE: conanfile_template})
client.run("export lasote/stable")
client.run("package MyLib/0.1@lasote/stable", ignore_error=True)
self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally",
client.user_io.out)
builds_dir = client.paths.builds(ConanFileReference.loads("MyLib/0.1@lasote/stable"))
os.makedirs(builds_dir)
client.run("package MyLib/0.1@lasote/stable", ignore_error=True)
self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally",
client.user_io.out)
client.run("package MyLib/0.1@lasote/stable 1234", ignore_error=True)
self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package binary '1234' folder doesn't exist",
client.user_io.out)
def local_package_build_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
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install .. -g env -g txt")
client.run("source ..")
client.run("build ..")
client.current_folder = temp_folder()
client.run('package "%s/build"' % origin_folder)
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def upload_reuse_test(self):
server = TestServer()
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
client.run("export lasote/stable")
client.save({CONANFILE: reuse}, clean_first=True)
client.run("export lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
client.run("upload conantool/1.0@lasote/stable --all")
client.run("remove * -f")
client.run("search")
self.assertNotIn("lasote/stable", client.user_io.out)
client.run("export lasote/stable")
client.run("install Consumer/0.1@lasote/stable --build")
lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
if line.startswith("Consumer/0.1@lasote/stable: Hello")]
self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
lines)
# Try again, just in case
client.run("upload conantool/1.0@lasote/stable --all")
client.run("remove * -f -r=default")
client.run("upload conantool/1.0@lasote/stable --all")
def test_path(self):
base_folder = temp_folder()
source_folder = os.path.join(base_folder, "source")
current_folder = os.path.join(base_folder, "current")
client = TestClient(current_folder=current_folder)
files = cpp_hello_conan_files("Hello0", "0.1")
conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
conanfile = files.pop("conanfile.py")
client.save(files, path=source_folder)
conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"')
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
reg_path = client.paths.export(conan_ref)
manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
client.user_io.out)
self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in ['conanfile.py', 'conanmanifest.txt', 'source/main.cpp',
'source/executable', 'source/hello.cpp', 'source/CMakeLists.txt',
'source/helloHello0.h']:
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {'source/hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'source/main.cpp': '0479f3c223c9a656a718f3148e044124',
'source/CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': 'c0bb94a3da6eb978cb94f5faff037ed3',
'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, manif.file_sums)
def test_rel_path(self):
base_folder = temp_folder()
source_folder = os.path.join(base_folder, "source")
current_folder = os.path.join(base_folder, "current")
os.makedirs(current_folder)
client = TestClient(current_folder=current_folder)
files = cpp_hello_conan_files("Hello0", "0.1")
conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
client.save(files, path=source_folder)
client.run("export lasote/stable --path=../source")
reg_path = client.paths.export(conan_ref)
manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
client.user_io.out)
self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in list(files.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': '5632cf850a7161388ab24f42b9bdb3fd',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, manif.file_sums)
def global_test(self):
client = TestClient()
files = {'conanfile.py': base_conanfile.replace("%GLOBAL%",
"self.global_system_requirements=True")}
client.save(files)
client.run("export user/testing")
client.run("install Test/0.1@user/testing --build missing")
self.assertIn("*+Running system requirements+*", client.user_io.out)
conan_ref = ConanFileReference.loads("Test/0.1@user/testing")
package_ref = PackageReference(conan_ref, "a527106fd9f2e3738a55b02087c20c0a63afce9d")
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
load_file = load(client.paths.system_reqs(conan_ref))
self.assertIn("Installed my stuff", load_file)
# Run again
client.run("install Test/0.1@user/testing --build missing")
self.assertNotIn("*+Running system requirements+*", client.user_io.out)
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
load_file = load(client.paths.system_reqs(conan_ref))
self.assertIn("Installed my stuff", load_file)
# Run with different option
client.run("install Test/0.1@user/testing -o myopt=False --build missing")
self.assertNotIn("*+Running system requirements+*", client.user_io.out)
package_ref2 = PackageReference(conan_ref, "54c9626b48cefa3b819e64316b49d3b1e1a78c26")
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2)))
load_file = load(client.paths.system_reqs(conan_ref))
self.assertIn("Installed my stuff", load_file)
# remove packages
client.run("remove Test* -f -p")
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2)))
self.assertFalse(os.path.exists(client.paths.system_reqs(conan_ref)))
def test_no_remotes(self):
client = TestClient()
files = cpp_hello_conan_files("Hello0", "0.1")
client.save(files)
client.run("export lasote/stable")
client.run("upload Hello0/0.1@lasote/stable", ignore_error=True)
self.assertIn("ERROR: No default remote defined", client.user_io.out)
def test_clean(self):
test_server = TestServer()
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
base = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
'''
files = {"conanfile.py": base}
client.save(files)
client.run("export lasote/stable")
client.run("upload lib/0.1@lasote/stable")
client.run("user")
self.assertIn("Current 'default' user: lasote", client.user_io.out)
client.run("user --clean")
client.run("user")
self.assertNotIn("lasote", client.user_io.out)
self.assertEqual("Current 'default' user: None (anonymous)\n", client.user_io.out)
client.run("upload lib/0.1@lasote/stable")
client.run("user")
self.assertIn("Current 'default' user: lasote", client.user_io.out)
def large_project_test(self):
client = TestClient()
num = 250
deep = True # True for N ... -> 3 -> 2 -> 1 -> 0, False for N -> 0, 3-> 0, 2->0, 1->0
for i in range(num):
if i == 0:
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
else:
if not deep:
files = cpp_hello_conan_files("Hello%d" % i, "0.1",
["Hello0/0.1@lasote/stable"], build=False)
else:
files = cpp_hello_conan_files("Hello%d" % i, "0.1",
["Hello%s/0.1@lasote/stable" % (i-1)],
build=False)
client.save(files, clean_first=True)
client.run("export lasote/stable")
# Now lets depend on it
if deep:
files = cpp_hello_conan_files("HelloFinal", "0.1",
["Hello%s/0.1@lasote/stable" % (num - 1)], build=False)
else:
files = cpp_hello_conan_files("HelloFinal", "0.1",
["Hello%s/0.1@lasote/stable" % (i) for i in range(num)],
build=False)
client.save(files, clean_first=True)
t1 = time.time()
client.run("install --build")
print("Final time with build %s" % (time.time() - t1))
t1 = time.time()
client.run("install")
print("Final time %s" % (time.time() - t1))
def no_signature_test(self):
auth = AuthorizationHeaderSpy()
retur = ReturnHandlerPlugin()
server = TestServer(plugins=[auth, retur])
server.app
servers = {"default": server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
errors = client.run("upload Hello/0.1@lasote/stable")
self.assertFalse(errors)
expected_calls = [('get_conan_digest_url', None),
('check_credentials', None),
('authenticate', 'Basic'),
('get_conanfile_snapshot', 'Bearer'),
('get_conanfile_upload_urls', 'Bearer'),
('put', 'Bearer')]
self.assertEqual(len(expected_calls), len(auth.auths))
for i, (method, auth_type) in enumerate(expected_calls):
real_call = auth.auths[i]
self.assertEqual(method, real_call[0])
if auth_type:
self.assertIn(auth_type, real_call[1])
# The Bearer of the last two calls must be identical
self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
class ConfigureEnvironmentTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def build_with_profile_test(self):
self._create_profile("scopes_env", {},
{}, # undefined scope do not apply to my packages
{"CXX": "/path/tomy/g++_build", "CC": "/path/tomy/gcc_build"})
self.client.save({CONANFILE: conanfile_dep})
self.client.run("export lasote/testing")
self.client.save({CONANFILE: conanfile_scope_env}, clean_first=True)
self.client.run("install --build=missing")
self.client.run("build -pr scopes_env")
self.assertRegexpMatches(str(self.client.user_io.out), "PATH=['\"]?/path/to/my/folder")
self._assert_env_variable_printed("CC", "/path/tomy/gcc_build")
self._assert_env_variable_printed("CXX", "/path/tomy/g++_build")
def _assert_env_variable_printed(self, name, value):
if platform.system() == "Windows":
self.assertIn("%s=%s" % (name, value), self.client.user_io.out)
elif platform.system() == "Darwin":
self.assertIn('%s="%s"' % (name, value), self.client.user_io.out)
else:
self.assertIn("%s='%s'" % (name, value), self.client.user_io.out)
def _create_profile(self, name, settings, scopes=None, env=None):
profile = Profile()
profile.settings = settings or {}
if scopes:
profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])
profile.env = env or {}
save(self.client.client_cache.profile_path(name), profile.dumps())
class MultiRemoteTest(unittest.TestCase):
def setUp(self):
self.servers = OrderedDict()
self.users = {}
for i in range(3):
test_server = TestServer(
[("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers["remote%d" % i] = test_server
self.users["remote%d" % i] = [("lasote", "mypass")]
self.client = TestClient(servers=self.servers, users=self.users)
def upload_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
files["conanfile.py"] = files["conanfile.py"].replace(
"def build(", "def build2(")
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("upload %s" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# The remote, once fixed does not change
self.client.run("upload %s -r=remote1" % str(conan_reference))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", self.client.user_io.out)
# Now install it in other machine from remote 0
client2 = TestClient(servers=self.servers, users=self.users)
client2.run("install %s --build=missing" % str(conan_reference))
client2.run("info %s" % str(conan_reference))
self.assertIn("remote0=http://", client2.user_io.out)
# Now install it in other machine from remote 1
servers = self.servers.copy()
servers.pop("remote0")
client3 = TestClient(servers=servers, users=self.users)
client3.run("install %s --build=missing" % str(conan_reference))
client3.run("info %s" % str(conan_reference))
self.assertIn("remote1=http://", client3.user_io.out)
def install_from_remotes_test(self):
for i in range(3):
conan_reference = ConanFileReference.loads(
"Hello%d/0.1@lasote/stable" % i)
files = cpp_hello_conan_files("Hello%d" % i, "0.1")
files["conanfile.py"] = files["conanfile.py"].replace(
"def build(", "def build2(")
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("upload %s -r=remote%d" %
(str(conan_reference), i))
self.client.run("info %s" % str(conan_reference))
self.assertIn("remote%d=http://" % i, self.client.user_io.out)
# Now install it in other machine from remote 0
client2 = TestClient(servers=self.servers, users=self.users)
conan_reference = ConanFileReference.loads("HelloX/0.1@lasote/stable")
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.user_io.out)
self.assertIn("Hello1/0.1@lasote/stable from remote1",
client2.user_io.out)
self.assertIn("Hello2/0.1@lasote/stable from remote2",
client2.user_io.out)
client2.run("info")
self.assertIn("Remote: remote0=http://", client2.user_io.out)
self.assertIn("Remote: remote1=http://", client2.user_io.out)
self.assertIn("Remote: remote2=http://", client2.user_io.out)
class SearchTest(unittest.TestCase):
def setUp(self):
self.servers = {"local": TestServer()}
self.client = TestClient(servers=self.servers)
# No conans created
self.client.run("search")
output = self.client.user_io.out
self.assertIn('There are no packages', output)
# Conans with and without packages created
self.root_folder1 = 'Hello/1.4.10/fenix/testing'
root_folder2 = 'helloTest/1.4.10/fenix/stable'
root_folder3 = 'Bye/0.14/fenix/testing'
root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
root_folder5 = 'MissFile/1.0.2/fenix/stable'
root_folder11 = 'Hello/1.4.11/fenix/testing'
root_folder12 = 'Hello/1.4.12/fenix/testing'
self.client.save({"Empty/1.10/fake/test/reg/fake.txt": "//",
"%s/%s/WindowsPackageSHA/%s" % (self.root_folder1,
PACKAGES_FOLDER,
CONANINFO): conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder11,
PACKAGES_FOLDER,
CONANINFO): conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder12,
PACKAGES_FOLDER,
CONANINFO): conan_vars1,
"%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1,
PACKAGES_FOLDER,
CONANINFO): conan_vars1b,
"%s/%s/LinuxPackageSHA/%s" % (self.root_folder1,
PACKAGES_FOLDER,
CONANINFO): conan_vars1c,
"%s/%s/a44f541cd44w57/%s" % (root_folder2,
PACKAGES_FOLDER,
CONANINFO): conan_vars2,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3,
PACKAGES_FOLDER,
CONANINFO): conan_vars3,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4,
PACKAGES_FOLDER,
CONANINFO): conan_vars4,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5,
PACKAGES_FOLDER,
"hello.txt"): "Hello"},
self.client.paths.store)
# Fake some manifests to be able to calculate recipe hash
fake_manifest = FileTreeManifest(1212, {})
self.client.save({os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
},
self.client.paths.store)
def recipe_search_test(self):
self.client.run("search Hello*")
self.assertEquals("Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
self.client.run("search Hello* --case-sensitive")
self.assertEquals("Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n",
self.client.user_io.out)
self.client.run("search *fenix* --case-sensitive")
self.assertEquals("Existing package recipes:\n\n"
"Bye/0.14@fenix/testing\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"MissFile/1.0.2@fenix/stable\n"
"NodeInfo/1.0.2@fenix/stable\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
def recipe_pattern_search_test(self):
self.client.run("search Hello*")
self.assertEquals("Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
self.client.run("search Hello* --case-sensitive")
self.assertEquals("Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n", self.client.user_io.out)
self.client.run("search *fenix* --case-sensitive")
self.assertEquals("Existing package recipes:\n\n"
"Bye/0.14@fenix/testing\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"MissFile/1.0.2@fenix/stable\n"
"NodeInfo/1.0.2@fenix/stable\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
def package_search_with_invalid_reference_test(self):
self.client.run("search Hello -q 'a=1'", ignore_error=True)
self.assertIn("-q parameter only allowed with a valid recipe", str(self.client.user_io.out))
def package_search_with_empty_query_test(self):
self.client.run("search Hello/1.4.10/fenix/testing")
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
def package_search_nonescaped_characters_test(self):
self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"')
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"')
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
# Now search with a remote
os.rmdir(self.servers["local"].paths.store)
shutil.copytree(self.client.paths.store, self.servers["local"].paths.store)
self.client.run("remove Hello* -f")
self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local')
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local')
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
def package_search_with_invalid_query_test(self):
self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'", ignore_error=True)
self.assertIn("Invalid package query: invalid", self.client.user_io.out)
def package_search_properties_filter_test(self):
# All packages without filter
self.client.run("search Hello/1.4.10/fenix/testing -q ''")
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows')
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"')
self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"')
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"')
self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"')
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"')
# One package will be outdated from recipe and another don't
self.assertEquals("""Existing packages for recipe Hello/1.4.10@fenix/testing:
Package_ID: LinuxPackageSHA
[options]
use_Qt: False
[settings]
arch: x86
compiler: gcc
compiler.libcxx: libstdc++11
compiler.version: 4.5
os: Linux
[requires]
Hello2/0.1@lasote/stable:11111
HelloInfo1/0.45@fenix/testing:33333
OpenSSL/2.10@lasote/testing:2222
outdated from recipe: False
Package_ID: PlatformIndependantSHA
[options]
use_Qt: True
[settings]
arch: x86
compiler: gcc
compiler.libcxx: libstdc++
compiler.version: 4.3
outdated from recipe: True
""", self.client.user_io.out)
self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=False')
self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
"matching the query 'use_OpenGL=False'", self.client.user_io.out)
self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=True')
self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out)
self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"')
self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out)
self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"')
self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
"matching the query 'use_OpenGL=True AND arch=x86'", self.client.user_io.out)
def search_with_no_local_test(self):
client = TestClient()
client.run("search nonexist/1.0@lasote/stable")
self.assertIn("There are no packages", self.client.user_io.out)
def cmake_multi_test(self):
if platform.system() == "Windows":
generator = "Visual Studio 14 Win64"
debug_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MDd'
release_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MD'
elif platform.system() == "Darwin":
generator = "Xcode"
debug_install = ''
release_install = ''
else:
return
client = TestClient()
def prepare_files(files, number):
# Change language according to build_type, to check
orig = "lang = '-DCONAN_LANGUAGE=%s' % self.options.language"
replace = "lang = '-DCONAN_LANGUAGE=%s' % (0 if self.settings.build_type=='Debug' else 1)"
conanfile = files["conanfile.py"]
# The test files, surprisingly, dont use build_type
conanfile = conanfile.replace(orig, replace).replace(
'"arch"', '"arch", "build_type"')
# Header of the package will contain a different DEFINE, to make sure that it includes
# the correct one
conanfile = conanfile.replace(
"def build(self):\n", """def build(self):
with open("helloHello{0}.h", "a") as f:
f.write('#define HELLO{0}BUILD "%s"' % self.settings.build_type)
""".format(number))
conanfile = conanfile.replace(
"def package_info(self):\n", """def package_info(self):
self.cpp_info.defines = ['HELLO{}DEFINE="%s"' % self.settings.build_type]
""".format(number))
files["conanfile.py"] = conanfile
client.save(files, clean_first=True)
client.run("export lasote/testing")
files = cpp_hello_conan_files("Hello0", "0.1")
prepare_files(files, 0)
files = cpp_hello_conan_files("Hello1",
"0.1",
deps=["Hello0/0.1@lasote/testing"])
prepare_files(files, 1)
# better in one test instead of two, because install time is amortized
for cmake_file in (
cmake,
cmake_targets,
):
client.save(
{
"conanfile.txt": conanfile,
"CMakeLists.txt": cmake_file,
"main.cpp": main
},
clean_first=True)
client.run('install -s build_type=Debug %s --build=missing' %
debug_install)
client.run('install -s build_type=Release %s --build=missing' %
release_install)
output = StringIO()
runner = TestRunner(output)
runner('cmake . -G "%s"' % generator, cwd=client.current_folder)
self.assertNotIn("WARN: Unknown compiler '", output.getvalue())
self.assertNotIn("', skipping the version check...",
output.getvalue())
runner('cmake --build . --config Debug', cwd=client.current_folder)
hello_comand = os.sep.join([".", "Debug", "say_hello"])
runner(hello_comand, cwd=client.current_folder)
outstr = output.getvalue()
self.assertIn("Hello0:Debug Hello1:Debug", outstr)
self.assertIn("Hello Hello1", outstr)
self.assertIn("Hello Hello0", outstr)
runner('cmake --build . --config Release',
cwd=client.current_folder)
hello_comand = os.sep.join([".", "Release", "say_hello"])
runner(hello_comand, cwd=client.current_folder)
outstr = output.getvalue()
self.assertIn("Hello0:Release Hello1:Release", outstr)
self.assertIn("Hola Hello1", outstr)
self.assertIn("Hola Hello0", outstr)
if cmake_file == cmake_targets:
self.assertIn("Conan: Using cmake targets configuration",
outstr)
else:
self.assertIn("Conan: Using cmake global configuration",
outstr)
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"
},
path=reg_folder)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
digest_path = client.client_cache.digestfile_package(package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
client.run("upload %s" % str(conan_ref))
client.run("upload %s -p %s" %
(str(conan_ref), package_ref.package_id))
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
installer = ConanProxy(client2.paths, client2.user_io,
client2.remote_manager, "default")
installer.get_recipe(conan_ref)
installer.get_package(package_ref,
force_build=False,
short_paths=False)
# Check that the output is done in order
lines = [
line.strip() for line in str(client2.user_io.out).splitlines()
if line.startswith("Downloading")
]
self.assertEqual(lines, [
"Downloading conanmanifest.txt", "Downloading conanfile.py",
"Downloading conan_export.tgz", "Downloading conanmanifest.txt",
"Downloading conaninfo.txt", "Downloading conan_package.tgz"
])
reg_path = client2.paths.export(
ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# Test the file in the downloaded conans
files = [
'CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h',
CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h',
'my_data/readme.txt'
]
for _file in files:
self.assertTrue(os.path.exists(os.path.join(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "include", "lib1.h")))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "lib", "my_lib/libd.a")))
self.assertTrue(
os.path.exists(
os.path.join(pack_folder, "res", "shares/readme.txt")))
class UploadTest(unittest.TestCase):
def setUp(self):
servers = {}
# All can write (for avoid authentication until we mock user_io)
self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = self.test_server
conan_digest = FileTreeManifest('123123123', {})
self.client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save({CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"}, path=reg_folder)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode |
stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def try_upload_bad_recipe_test(self):
files = hello_conan_files("Hello0", "1.2.1")
self.client.save(files)
self.client.run("export frodo/stable")
ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable")
os.unlink(os.path.join(self.client.client_cache.export(ref), CONAN_MANIFEST))
with self.assertRaisesRegexp(Exception, "Command failed"):
self.client.run("upload %s" % str(ref))
self.assertIn("Cannot upload corrupted recipe", self.client.user_io.out)
def upload_same_package_dont_compress_test(self):
# Create a manifest for the faked package
pack_path = self.client.paths.package(self.package_ref)
digest_path = self.client.client_cache.digestfile_package(self.package_ref)
expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertIn("Compressing exported files", self.client.user_io.out)
self.assertIn("Compressing package", str(self.client.user_io.out))
self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
self.assertNotIn("Compressing exported files", self.client.user_io.out)
self.assertNotIn("Compressing package", str(self.client.user_io.out))
self.assertIn("Package is up to date", str(self.client.user_io.out))
def upload_with_no_valid_settings_test(self):
'''Check if upload is still working even if the specified setting is not valid.
If this test fails, will fail in Linux/OSx'''
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
settings = {"os": ["Windows"]}
"""
files = {CONANFILE: conanfile}
self.client.save(files)
self.client.run("export lasote/stable")
self.assertIn("WARN: Conanfile doesn't have a 'license'", self.client.user_io.out)
self.client.run("upload Hello/1.2@lasote/stable", ignore_error=False)
self.assertIn("Uploading conan_export.tgz", self.client.user_io.out)
def simple_test(self):
""" basic installation of a new conans
"""
# Try to upload an package without upload conans first
self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)),
ignore_error=True)
self.assertIn("There are no remote conanfiles like %s" % str(self.conan_ref),
self.client.user_io.out)
# Upload conans
self.client.run('upload %s' % str(self.conan_ref))
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
# Upload package
self.client.run('upload %s -p %s'
% (str(self.conan_ref), str(self.package_ref.package_id)))
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
# Test the file in the downloaded conans
files = ['CMakeLists.txt',
'my_lib/debug/libd.a',
'hello.cpp',
'hello0.h',
CONANFILE,
CONAN_MANIFEST,
'main.cpp',
'include/math/lib1.h',
'my_data/readme.txt',
'my_bin/executable']
self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, CONANFILE)))
self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME)))
tmp = temp_folder()
untargz(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME), tmp)
for f in files:
if f not in (CONANFILE, CONAN_MANIFEST):
self.assertTrue(os.path.exists(os.path.join(tmp, f)))
else:
self.assertFalse(os.path.exists(os.path.join(tmp, f)))
folder = uncompress_packaged_files(self.test_server.paths, self.package_ref)
self.assertTrue(os.path.exists(os.path.join(folder,
"include",
"lib1.h")))
self.assertTrue(os.path.exists(os.path.join(folder,
"lib",
"my_lib/libd.a")))
self.assertTrue(os.path.exists(os.path.join(folder,
"res",
"shares/readme.txt")))
if platform.system() != "Windows":
self.assertEqual(os.stat(os.path.join(folder,
"bin",
"my_bin/executable")).st_mode &
stat.S_IRWXU, stat.S_IRWXU)
def upload_all_test(self):
'''Upload conans and package together'''
# Try to upload all conans and packages
self.client.run('upload %s --all' % str(self.conan_ref))
lines = [line.strip() for line in str(self.client.user_io.out).splitlines()
if line.startswith("Uploading")]
self.assertEqual(lines, ["Uploading Hello/1.2.1@frodo/stable",
"Uploading conanmanifest.txt",
"Uploading conanfile.py",
"Uploading conan_export.tgz",
"Uploading package 1/1: myfakeid",
"Uploading conanmanifest.txt",
"Uploading conaninfo.txt",
"Uploading conan_package.tgz",
])
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
def force_test(self):
'''Tries to upload a conans exported after than remote version.'''
# Upload all conans and packages
self.client.run('upload %s --all' % str(self.conan_ref))
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
# Fake datetime from exported date and upload again
digest_path = os.path.join(self.client.paths.export(self.conan_ref), CONAN_MANIFEST)
old_digest = self.client.paths.load_manifest(self.conan_ref)
fake_digest = FileTreeManifest(2, old_digest.file_sums)
save(digest_path, str(fake_digest))
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("Remote conans is newer than local conans", self.client.user_io.out)
self.client.run('upload %s --force' % str(self.conan_ref))
self.assertIn("Uploading %s" % str(self.conan_ref),
self.client.user_io.out)
def reuse_test(self):
conan_reference = ConanFileReference.loads(
"stringutil/0.1@lasote/stable")
files = {
'conanfile.py': stringutil_conanfile,
'reverse.go': reverse,
'reverse_test.go': reverse_test,
'reverse.txt': reverse,
'hello/helloreverse.txt': reverse
}
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install %s --build missing" % str(conan_reference))
# Check compilation ok
package_ids = self.client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), 1)
package_ref = PackageReference(conan_reference, package_ids[0])
self._assert_package_exists(package_ref, self.client.paths,
list(files.keys()))
# Upload conans
self.client.run("upload %s" % str(conan_reference))
# Check that conans exists on server
server_paths = self.servers["default"].paths
conan_path = server_paths.export(conan_reference)
self.assertTrue(os.path.exists(conan_path))
# Upload package
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
# Check library on server
self._assert_package_exists_in_server(package_ref, server_paths,
list(files.keys()))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build missing" % str(conan_reference))
# Build should be empty
build_path = other_conan.paths.build(package_ref)
self.assertFalse(os.path.exists(build_path))
# Lib should exist
self._assert_package_exists(package_ref, other_conan.paths,
list(files.keys()))
reuse_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files = {'conanfile.py': reuse_conanfile, 'src/hello/main.go': main}
reuse_conan.save(files)
reuse_conan.run("install --build missing")
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[
('GOPATH', reuse_conan.current_folder),
]):
if platform.system() == "Windows":
command = "hello"
else:
command = './hello'
reuse_conan.runner('go install hello',
cwd=reuse_conan.current_folder)
reuse_conan.runner(command,
cwd=os.path.join(reuse_conan.current_folder,
'bin'))
self.assertIn("Hello, Go!", reuse_conan.user_io.out)
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello00", "0.2", msg="#")
self._export_upload("Hello1",
"0.1",
deps=[("Hello0/0.1@lasote/stable", "private")],
static=False)
self._export_upload("Hello2",
"0.1",
deps=[("Hello00/0.2@lasote/stable", "private")],
static=False)
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs and dylib
client.save(files3)
client.run('install --build missing')
client.run('build')
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
build_info_cmake = load(info_path)
# Ensure it does not depend on Hello0 to build, as private in dlls
self.assertNotIn("Hello0", repr(build_info_cmake))
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'
],
str(client.user_io.out).splitlines()[-5:])
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(info_path))
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
# Try to upload and reuse the binaries
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files2 = cpp_hello_conan_files(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs
client2.save(files2)
client2.run("install . --build missing")
self.assertNotIn("Package installed in Hello0/0.1",
client2.user_io.out)
self.assertNotIn("Building", client2.user_io.out)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'
],
str(client2.user_io.out).splitlines()[-5:])
files3 = cpp_hello_conan_files(
"Hello3",
"0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
language=1)
client2.save(files3)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
'Hola #'
],
str(client2.user_io.out).splitlines()[-5:])
# Issue 79, fixing private deps from current project
files3 = cpp_hello_conan_files(
"Hello3",
"0.2", [
"Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable",
("Hello0/0.1@lasote/stable", "private"),
("Hello00/0.2@lasote/stable", "private")
],
language=1)
client2.save(files3, clean_first=True)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
'Hola #', 'Hola Hello0', 'Hola #'
],
str(client2.user_io.out).splitlines()[-7:])
class ProfileTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def bad_syntax_test(self):
self.client.save({CONANFILE: conanfile_scope_env})
self.client.run("export lasote/stable")
profile = '''
[settings
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self.assertIn("Error reading 'clang' profile", self.client.user_io.out)
self.assertIn("Bad syntax", self.client.user_io.out)
profile = '''
[settings]
[invented]
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self.assertIn("Unrecognized field 'invented'", self.client.user_io.out)
self.assertIn("Error reading 'clang' profile", self.client.user_io.out)
profile = '''
[settings]
as
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self.assertIn("Error reading 'clang' profile: Invalid setting line 'as'", self.client.user_io.out)
profile = '''
[env]
as
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self.assertIn("Error reading 'clang' profile: Invalid env line 'as'", self.client.user_io.out)
profile = '''
[scopes]
as
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self.assertIn("Error reading 'clang' profile: Bad scope as", self.client.user_io.out)
profile = '''
[settings]
os = a value
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
# stripped "a value"
self.assertIn("'a value' is not a valid 'settings.os'", self.client.user_io.out)
profile = '''
[env]
ENV_VAR = a value
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
self._assert_env_variable_printed("ENV_VAR", "a value")
profile = '''
# Line with comments is not a problem
[env]
# Not even here
ENV_VAR = a value
'''
save(self.client.client_cache.profile_path("clang"), profile)
self.client.run("install Hello0/0.1@lasote/stable --build -pr clang", ignore_error=True)
self._assert_env_variable_printed("ENV_VAR", "a value")
def build_with_profile_test(self):
self._create_profile("scopes_env", settings={},
scopes={}, # undefined scope do not apply to my packages
env=[("CXX", "/path/tomy/g++_build"), ("CC", "/path/tomy/gcc_build")])
self.client.save({CONANFILE: conanfile_scope_env})
self.client.run("build -pr scopes_env")
self._assert_env_variable_printed("CC", "/path/tomy/gcc_build")
self._assert_env_variable_printed("CXX", "/path/tomy/g++_build")
def install_profile_env_test(self):
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
files["conanfile.py"] = conanfile_scope_env
self._create_profile("envs", settings={}, env=[("A_VAR", "A_VALUE")],
package_env={"Hello0": [("OTHER_VAR", 2)]})
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr envs")
self._assert_env_variable_printed("A_VAR", "A_VALUE")
self._assert_env_variable_printed("OTHER_VAR", "2")
# Override with package var
self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE")
self._assert_env_variable_printed("A_VAR", "OTHER_VALUE")
self._assert_env_variable_printed("OTHER_VAR", "2")
# Override package var with package var
self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE -e Hello0:OTHER_VAR=3")
self._assert_env_variable_printed("A_VAR", "OTHER_VALUE")
self._assert_env_variable_printed("OTHER_VAR", "3")
def install_profile_settings_test(self):
files = cpp_hello_conan_files("Hello0", "0.1", build=False)
files["conanfile.py"] = files["conanfile.py"].replace("generators =", "generators = \"txt\",")
# Create a profile and use it
profile_settings = {"compiler": "Visual Studio",
"compiler.version": "12",
"compiler.runtime": "MD",
"arch": "x86"}
self._create_profile("vs_12_86", settings=profile_settings, package_settings={})
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install --build missing -pr vs_12_86")
info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
for setting, value in profile_settings.items():
self.assertIn("%s=%s" % (setting, value), info)
# Try to override some settings in install command
self.client.run("install --build missing -pr vs_12_86 -s compiler.version=14")
info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
for setting, value in profile_settings.items():
if setting != "compiler.version":
self.assertIn("%s=%s" % (setting, value), info)
else:
self.assertIn("compiler.version=14", info)
# Use package settings in profile
tmp_settings = OrderedDict()
tmp_settings["compiler"] = "gcc"
tmp_settings["compiler.libcxx"] = "libstdc++11"
tmp_settings["compiler.version"] = "4.8"
package_settings = {"Hello0": tmp_settings}
self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
package_settings=package_settings)
# Try to override some settings in install command
self.client.run("install --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14")
info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
self.assertIn("compiler=gcc", info)
self.assertIn("compiler.libcxx=libstdc++11", info)
# If other package is specified compiler is not modified
package_settings = {"NoExistsRecipe": tmp_settings}
self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
package_settings=package_settings)
# Try to override some settings in install command
self.client.run("install --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14")
info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
self.assertIn("compiler=Visual Studio", info)
self.assertNotIn("compiler.libcxx", info)
# Mix command line package settings with profile
package_settings = {"Hello0": tmp_settings}
self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
package_settings=package_settings)
# Try to override some settings in install command
self.client.run("install --build missing -pr vs_12_86_Hello0_gcc"
" -s compiler.version=14 -s Hello0:compiler.libcxx=libstdc++")
info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
self.assertIn("compiler=gcc", info)
self.assertNotIn("compiler.libcxx=libstdc++11", info)
self.assertIn("compiler.libcxx=libstdc++", info)
def scopes_env_test(self):
# Create a profile and use it
self._create_profile("scopes_env", settings={},
scopes={"Hello0:myscope": "1",
"ALL:otherscope": "2",
"undefined": "3"}, # undefined scope do not apply to my packages
env=[("CXX", "/path/tomy/g++"), ("CC", "/path/tomy/gcc")])
self.client.save({CONANFILE: conanfile_scope_env})
self.client.run("export lasote/stable")
self.client.run("install Hello0/0.1@lasote/stable --build missing -pr scopes_env")
self.assertIn("Scope myscope: 1", self.client.user_io.out)
self.assertIn("Scope otherscope: 2", self.client.user_io.out)
self.assertIn("Scope undefined: None", self.client.user_io.out)
self._assert_env_variable_printed("CC", "/path/tomy/gcc")
self._assert_env_variable_printed("CXX", "/path/tomy/g++")
# The env variable shouldn't persist after install command
self.assertFalse(os.environ.get("CC", None) == "/path/tomy/gcc")
self.assertFalse(os.environ.get("CXX", None) == "/path/tomy/g++")
def test_package_test(self):
test_conanfile = '''from conans.model.conan_file import ConanFile
from conans import CMake
import os
class DefaultNameConan(ConanFile):
name = "DefaultName"
version = "0.1"
settings = "os", "compiler", "arch", "build_type"
requires = "Hello0/0.1@lasote/stable"
def build(self):
# Print environment vars
# self.run('cmake %s %s' % (self.conanfile_directory, cmake.command_line))
if self.settings.os == "Windows":
self.run('echo "My var is %ONE_VAR%"')
else:
self.run('echo "My var is $ONE_VAR"')
def test(self):
pass
'''
files = {}
files["conanfile.py"] = conanfile_scope_env
files["test_package/conanfile.py"] = test_conanfile
# Create a profile and use it
self._create_profile("scopes_env", settings={},
scopes={},
env=[("ONE_VAR", "ONE_VALUE")])
self.client.save(files)
self.client.run("test_package --profile scopes_env")
self._assert_env_variable_printed("ONE_VAR", "ONE_VALUE")
self.assertIn("My var is ONE_VALUE", str(self.client.user_io.out))
# Try now with package environment vars
self._create_profile("scopes_env2", settings={},
scopes={},
package_env={"DefaultName": [("ONE_VAR", "IN_TEST_PACKAGE")],
"Hello0": [("ONE_VAR", "PACKAGE VALUE")]})
self.client.run("test_package --profile scopes_env2")
self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE")
self.assertIn("My var is IN_TEST_PACKAGE", str(self.client.user_io.out))
# Try now overriding some variables with command line
self.client.run("test_package --profile scopes_env2 -e DefaultName:ONE_VAR=InTestPackageOverride "
"-e Hello0:ONE_VAR=PackageValueOverride ")
self._assert_env_variable_printed("ONE_VAR", "PackageValueOverride")
self.assertIn("My var is InTestPackageOverride", str(self.client.user_io.out))
# A global setting in command line won't override a scoped package variable
self.client.run("test_package --profile scopes_env2 -e ONE_VAR=AnotherValue")
self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE")
def _assert_env_variable_printed(self, name, value):
if platform.system() == "Windows":
self.assertIn("%s=%s" % (name, value), self.client.user_io.out)
elif platform.system() == "Darwin":
self.assertIn('%s="%s"' % (name, value), self.client.user_io.out)
else:
self.assertIn("%s='%s'" % (name, value), self.client.user_io.out)
def _create_profile(self, name, settings, scopes=None, package_settings=None,
env=None, package_env=None):
package_env = package_env or {}
profile = Profile()
profile._settings = settings or {}
if scopes:
profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])
if package_settings:
profile._package_settings = package_settings
for package_name, envs in package_env.items():
for var_name, value in envs:
profile._package_env[package_name][var_name] = value
for var_name, value in env or {}:
profile._env[var_name] = value
save(self.client.client_cache.profile_path(name), profile.dumps())
def package_test(self):
"""Use 'conan package' command to repackage a generated package (without build it)"""
client = TestClient(users={"default": [("lasote", "mypass")]})
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
name = "MyLib"
version = "0.1"
exports = '*'
def package(self):
self.copy(pattern="*.h", dst="include", keep_path=False)
#self.copy(pattern="*.a", dst="lib", keep_path=False)
"""
files = {
"lib/file1.a": "foo",
"include/file.h": "foo",
CONANFILE: conanfile_template
}
client.save(files)
client.run("export lasote/stable")
# Build and package conan file
conan_reference = ConanFileReference.loads("MyLib/0.1@lasote/stable")
client.run("install %s --build missing" % str(conan_reference))
package_id = "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9"
package_path = client.paths.package(
PackageReference(conan_reference, package_id))
# Verify the headers are there but lib doesn't
self.assertTrue(
os.path.exists(os.path.join(package_path, "include", "file.h")))
self.assertFalse(
os.path.exists(os.path.join(package_path, "lib", "file1.a")))
# Fix conanfile and re-package
client.save({CONANFILE: conanfile_template.replace("#", "")})
client.run("export lasote/stable")
# Build and package conan file
client.run("package %s %s" % (conan_reference, package_id))
self.assertIn(
"MyLib/0.1@lasote/stable: "
"Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
client.user_io.out)
self.assertTrue(
os.path.exists(os.path.join(package_path, "include", "file.h")))
self.assertTrue(
os.path.exists(os.path.join(package_path, "lib", "file1.a")))
# Fix again conanfile and re-package with AL
client.save(
{CONANFILE: conanfile_template.replace("self.copy", "pass #")})
client.run("export lasote/stable")
# Build and package conan file
client.run("package %s" % str(conan_reference))
self.assertIn(
"MyLib/0.1@lasote/stable: "
"Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
client.user_io.out)
self.assertFalse(
os.path.exists(os.path.join(package_path, "include", "file.h")))
self.assertFalse(
os.path.exists(os.path.join(package_path, "lib", "file1.a")))
def conan_test_test(self):
'''Checks --build in test command'''
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
self._create(client, "Hello0", "0.0")
self._create(client, "Hello1", "1.1", ["Hello0/0.0@lasote/stable"])
# Now test out Hello2
self._create(client,
"Hello2",
"2.2", ["Hello1/1.1@lasote/stable"],
export=True)
hello2conanfile = load(os.path.join(client.current_folder, CONANFILE))
client.save({CONANFILE: hello2conanfile})
test_conanfile = '''
from conans.model.conan_file import ConanFile
class DefaultNameConan(ConanFile):
settings = "os", "compiler", "arch"
requires = "Hello2/2.2@lasote/stable"
generators = "cmake"
def test(self):
pass
'''
client.save({"test/%s" % CONANFILE: test_conanfile})
# Should recognize the hello package
# Will Fail because Hello0/0.0 and Hello1/1.1 has not built packages
# and by default no packages are built
error = client.run("test", ignore_error=True)
self.assertTrue(error)
self.assertIn('Try to build from sources with "--build Hello0"',
client.user_io.out)
# We generate the package for Hello0/0.0
client.run("install Hello0/0.0@lasote/stable --build Hello0")
# Still missing Hello1/1.1
error = client.run("test", ignore_error=True)
self.assertTrue(error)
self.assertIn('Try to build from sources with "--build Hello1"',
client.user_io.out)
# We generate the package for Hello1/1.1
client.run("install Hello1/1.1@lasote/stable --build Hello1")
# Now Hello2 should be built and not fail
client.run("test")
self.assertNotIn("Can't find a 'Hello2/2.2@lasote/stable' package",
client.user_io.out)
self.assertIn(
'Hello2/2.2@lasote/stable: WARN: Forced build from source',
client.user_io.out)
# Now package is generated but should be built again
client.run("test")
self.assertIn(
'Hello2/2.2@lasote/stable: WARN: Forced build from source',
client.user_io.out)
class SettingsTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def settings_as_a_str_test(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.client.run("install -s os=Linux --build missing")
# Now read the conaninfo and verify that settings applied is only os and value is windows
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Linux")
def settings_as_a_list_conanfile_test(self):
"""Declare settings as a list"""
# Now with conanfile as a list
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os", "arch"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.assertEquals(conan_info.settings.fields, ["arch", "os"])
def settings_as_a_dict_conanfile_test(self):
"""Declare settings as a dict"""
# Now with conanfile as a dict
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": ["Windows"], "arch": ["x86_64"]}
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=Windows --build missing")
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.os, "Windows")
self.assertEquals(conan_info.settings.fields, ["arch", "os"])
def invalid_settings_test(self):
'''Test wrong values and wrong constraints'''
# MISSING VALUE FOR A SETTING
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os", "build_type"
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing", ignore_error=True)
self.assertIn(undefined_value("settings.build_type"),
str(self.client.user_io.out))
def invalid_settings_test2(self):
# MISSING A DEFAULT VALUE BECAUSE ITS RESTRICTED TO OTHER, SO ITS REQUIRED
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": ["Windows", "Linux", "Macos"], "compiler": ["Visual Studio"]}
"""
self.client.save({CONANFILE: content})
self.client.run(
"install -s compiler=gcc -s compiler.version=4.8 --build missing",
ignore_error=True)
self.assertIn(
bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]),
str(self.client.user_io.out))
def invalid_settings_test3(self):
# dict without options
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {"os": None, "compiler": ["Visual Studio"]}
"""
self.client.save({CONANFILE: content})
self.client.run(
"install -s compiler=gcc -s compiler.version=4.8 --build missing",
ignore_error=True)
self.assertIn(
bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]),
str(self.client.user_io.out))
# Test wrong settings in conanfile
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = invalid
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing", ignore_error=True)
self.assertIn("invalid' is not defined", str(self.client.user_io.out))
# Test wrong values in conanfile
def invalid_settings_test4(self):
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = "os"
"""
self.client.save({CONANFILE: content})
self.client.run("install -s os=ChromeOS --build missing",
ignore_error=True)
self.assertIn(
bad_value_msg("settings.os", "ChromeOS",
['Android', 'Linux', 'Macos', 'Windows']),
str(self.client.user_io.out))
# Now add new settings to config and try again
config = load(self.client.paths.settings_path)
config = config.replace("Windows,", "Windows, ChromeOS,")
save(self.client.paths.settings_path, config)
self.client.run("install -s os=ChromeOS --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
# Settings is None
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = None
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
# Settings is {}
content = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
settings = {}
"""
self.client.save({CONANFILE: content})
self.client.run("install --build missing")
self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
conan_info = ConanInfo.loads(
load(os.path.join(self.client.current_folder, CONANINFO)))
self.assertEquals(conan_info.settings.dumps(), "")
class SameUserChannelTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
conanfile = """
from conans import ConanFile
class SayConan(ConanFile):
name = "Say"
version = "0.1"
build_policy = "missing"
def build(self):
self.output.info("Building %s")
"""
for channel in ("lasote/stable", "other/testing"):
self.client.save({"conanfile.py": conanfile % channel})
self.client.run("export %s" % channel)
self.conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
build_policy = "missing"
def requirements(self):
self.requires("Say/0.1@%s/%s" % (self.user, self.channel))
def build(self):
self.output.info("Building %s/%s" % (self.user, self.channel) )
"""
self.test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
self.client.save({
"conanfile.py": self.conanfile,
"test/conanfile.py": self.test_conanfile
})
def test_testpackage(self):
self.client.run("test_package")
self.assertIn("Say/0.1@lasote/stable: Building lasote/stable",
self.client.user_io.out)
self.assertIn("Hello/0.1@lasote/stable: Building lasote/stable",
self.client.user_io.out)
self.assertNotIn("other/testing", self.client.user_io.out)
self.client.save({
"conanfile.py":
self.conanfile,
"test/conanfile.py":
self.test_conanfile.replace("lasote/stable", "other/testing")
})
self.client.run("test_package")
self.assertIn("Say/0.1@other/testing: Building other/testing",
self.client.user_io.out)
self.assertIn("Hello/0.1@other/testing: Building other/testing",
self.client.user_io.out)
self.assertNotIn("lasote/stable", self.client.user_io.out)
def test_local_commands(self):
error = self.client.run("install", ignore_error=True)
self.assertEqual(error, True)
self.assertIn(
"ERROR: Conanfile: CONAN_USERNAME environment variable not defined, "
"but self.user is used in conanfile", self.client.user_io.out)
os.environ["CONAN_USERNAME"] = "******"
error = self.client.run("install", ignore_error=True)
self.assertEqual(error, True)
self.assertIn(
"ERROR: Conanfile: CONAN_CHANNEL environment variable not defined, "
"but self.channel is used in conanfile", self.client.user_io.out)
os.environ["CONAN_CHANNEL"] = "stable"
self.client.run("install")
self.assertIn("Say/0.1@lasote/stable: Building lasote/stable",
self.client.user_io.out)
self.assertNotIn("other/testing", self.client.user_io.out)
os.environ["CONAN_USERNAME"] = "******"
os.environ["CONAN_CHANNEL"] = "testing"
self.client.run("install")
self.assertIn("Say/0.1@other/testing: Building other/testing",
self.client.user_io.out)
self.assertNotIn("lasote/stable", self.client.user_io.out)
del os.environ["CONAN_USERNAME"]
del os.environ["CONAN_CHANNEL"]
class SynchronizeTest(unittest.TestCase):
def setUp(self):
test_server = TestServer(
[("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def upload_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
files["to_be_deleted.txt"] = "delete me"
files["to_be_deleted2.txt"] = "delete me2"
remote_paths = self.client.servers["default"].paths
server_conan_path = remote_paths.export(conan_reference)
self.client.save(files)
self.client.run("export lasote/stable")
# Upload conan file
self.client.run("upload %s" % str(conan_reference))
# Verify the files are there
self.assertTrue(
os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
tmp = temp_folder()
untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")),
"delete me")
self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")),
"delete me2")
# Now delete local files export and upload and check that they are not in server
os.remove(os.path.join(self.client.current_folder,
"to_be_deleted.txt"))
self.client.run("export lasote/stable")
self.client.run("upload %s" % str(conan_reference))
self.assertTrue(
os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
tmp = temp_folder()
untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
self.assertFalse(os.path.exists(os.path.join(tmp,
"to_be_deleted.txt")))
self.assertTrue(os.path.exists(os.path.join(tmp,
"to_be_deleted2.txt")))
# Now modify a file, and delete other, and put a new one.
files["to_be_deleted2.txt"] = "modified content"
files["new_file.lib"] = "new file"
del files["to_be_deleted.txt"]
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("upload %s" % str(conan_reference))
# Verify all is correct
self.assertTrue(
os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
tmp = temp_folder()
untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")),
"modified content")
self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file")
self.assertFalse(os.path.exists(os.path.join(tmp,
"to_be_deleted.txt")))
##########################
# Now try with the package
##########################
self.client.run("install %s --build missing" % str(conan_reference))
# Upload package
package_ids = self.client.paths.conan_packages(conan_reference)
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
# Check that conans exists on server
package_reference = PackageReference(conan_reference,
str(package_ids[0]))
package_server_path = remote_paths.package(package_reference)
self.assertTrue(os.path.exists(package_server_path))
# Add a new file to package (artificially), upload again and check
new_file_source_path = os.path.join(
self.client.paths.package(package_reference), "newlib.lib")
save(new_file_source_path, "newlib")
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
folder = uncompress_packaged_files(remote_paths, package_reference)
remote_file_path = os.path.join(folder, "newlib.lib")
self.assertTrue(os.path.exists(remote_file_path))
# Now modify the file and check again
save(new_file_source_path, "othercontent")
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
folder = uncompress_packaged_files(remote_paths, package_reference)
remote_file_path = os.path.join(folder, "newlib.lib")
self.assertTrue(os.path.exists(remote_file_path))
self.assertTrue(load(remote_file_path), "othercontent")
# Now delete the file and check again
os.remove(new_file_source_path)
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
folder = uncompress_packaged_files(remote_paths, package_reference)
remote_file_path = os.path.join(folder, "newlib.lib")
self.assertFalse(os.path.exists(remote_file_path))
self.assertNotEquals(remote_file_path, new_file_source_path)
class PrivateDepsTest(unittest.TestCase):
def setUp(self):
test_server = TestServer(
[("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def _export_upload(self,
name=0,
version=None,
deps=None,
msg=None,
static=True):
dll_export = self.client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files(name,
version,
deps,
msg=msg,
static=static,
private_includes=True,
dll_export=dll_export)
conan_ref = ConanFileReference(name, version, "lasote", "stable")
self.client.save(files, clean_first=True)
self.client.run("export lasote/stable")
self.client.run("upload %s" % str(conan_ref))
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello00", "0.2", msg="#")
self._export_upload("Hello1",
"0.1",
deps=[("Hello0/0.1@lasote/stable", "private")],
static=False)
self._export_upload("Hello2",
"0.1",
deps=[("Hello00/0.2@lasote/stable", "private")],
static=False)
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs and dylib
client.save(files3)
client.run('install --build missing')
client.run('build')
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
build_info_cmake = load(info_path)
# Ensure it does not depend on Hello0 to build, as private in dlls
self.assertNotIn("Hello0", repr(build_info_cmake))
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'
],
str(client.user_io.out).splitlines()[-5:])
# assert Hello3 only depends on Hello2, and Hello1
info_path = os.path.join(client.current_folder, CONANINFO)
conan_info = ConanInfo.loads(load(info_path))
self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
# Try to upload and reuse the binaries
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files2 = cpp_hello_conan_files(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
# WE need to copy the DLLs
client2.save(files2)
client2.run("install . --build missing")
self.assertNotIn("Package installed in Hello0/0.1",
client2.user_io.out)
self.assertNotIn("Building", client2.user_io.out)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
'Hello #'
],
str(client2.user_io.out).splitlines()[-5:])
files3 = cpp_hello_conan_files(
"Hello3",
"0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
language=1)
client2.save(files3)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
'Hola #'
],
str(client2.user_io.out).splitlines()[-5:])
# Issue 79, fixing private deps from current project
files3 = cpp_hello_conan_files(
"Hello3",
"0.2", [
"Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable",
("Hello0/0.1@lasote/stable", "private"),
("Hello00/0.2@lasote/stable", "private")
],
language=1)
client2.save(files3, clean_first=True)
client2.run('install -o language=1 --build missing')
client2.run('build')
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello00.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
'Hola #', 'Hola Hello0', 'Hola #'
],
str(client2.user_io.out).splitlines()[-7:])
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 _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 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())
self.assertIn("Hello0:language=1", 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 warn_bad_os_test(self):
bad_os = "Linux" if platform.system() != "Linux" else "Macos"
message = "You are building this package with settings.os='%s" % 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)
self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % detected_os(),
ignore_error=True)
self.assertNotIn("You are building this package with settings.os", self.client.user_io.out)
def reuse_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install %s --build missing" % str(conan_reference))
self.assertIn(
"Hello0/0.1@lasote/stable package(): Copied 1 '.h' files: helloHello0.h",
self.client.user_io.out)
# Check compilation ok
package_ids = self.client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), 1)
package_ref = PackageReference(conan_reference, package_ids[0])
self._assert_library_exists(package_ref, self.client.paths)
# Upload conans
self.client.run("upload %s" % str(conan_reference))
# Check that conans exists on server
server_paths = self.servers["default"].paths
conan_path = server_paths.export(conan_reference)
self.assertTrue(os.path.exists(conan_path))
# Upload package
self.client.run("upload %s -p %s" %
(str(conan_reference), str(package_ids[0])))
# Check library on server
self._assert_library_exists_in_server(package_ref, server_paths)
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build missing" % str(conan_reference))
# Build should be empty
build_path = other_conan.paths.build(package_ref)
self.assertFalse(os.path.exists(build_path))
# Lib should exist
self._assert_library_exists(package_ref, other_conan.paths)
# Now install it but with other options
other_conan.run('install %s -o language=1 --build missing' %
(str(conan_reference)))
# Should have two packages
package_ids = other_conan.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), 2)
for package_id in package_ids:
ref = PackageReference(conan_reference, package_id)
self._assert_library_exists(ref, other_conan.paths)
client3 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
files3 = cpp_hello_conan_files("Hello1", "0.1",
["Hello0/0.1@lasote/stable"])
client3.save(files3)
client3.run('install')
client3.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client3.runner(command, cwd=client3.current_folder)
self.assertIn("Hello Hello1", client3.user_io.out)
self.assertIn("Hello Hello0", client3.user_io.out)
client3.run('install -o language=1 --build missing')
time.sleep(1)
client3.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client3.runner(command, cwd=client3.current_folder)
self.assertIn("Hola Hello1", client3.user_io.out)
self.assertIn("Hola Hello0", client3.user_io.out)
class ExportTest(unittest.TestCase):
def setUp(self):
self.conan = TestClient()
self.files = cpp_hello_conan_files("Hello0", "0.1")
self.conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
self.conan.save(self.files)
self.conan.run("export lasote/stable")
def test_basic(self):
""" simple registration of a new conans
"""
reg_path = self.conan.paths.export(self.conan_ref)
manif = FileTreeManifest.loads(load(self.conan.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path))
for name in list(self.files.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': '9e26c9274ae837c03764d1418c063ebb',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, manif.file_sums)
def test_case_sensitive(self):
self.files = cpp_hello_conan_files("hello0", "0.1")
self.conan_ref = ConanFileReference("hello0", "0.1", "lasote", "stable")
self.conan.save(self.files)
error = self.conan.run("export lasote/stable", ignore_error=True)
self.assertTrue(error)
self.assertIn("ERROR: Cannot export package with same name but different case",
self.conan.user_io.out)
def test_export_filter(self):
content = """
from conans import ConanFile
class OpenSSLConan(ConanFile):
name = "openssl"
version = "2.0.1"
"""
save(os.path.join(self.conan.current_folder, CONANFILE), content)
self.conan.run("export lasote/stable")
reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
self.assertEqual(sorted(os.listdir(reg_path)),
[EXPORT_SOURCES_DIR, CONANFILE, CONAN_MANIFEST])
content = """
from conans import ConanFile
class OpenSSLConan(ConanFile):
name = "openssl"
version = "2.0.1"
exports = ('*.txt', '*.h')
"""
save(os.path.join(self.conan.current_folder, CONANFILE), content)
self.conan.run("export lasote/stable")
reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
self.assertEqual(sorted(os.listdir(reg_path)),
[EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST,
'helloHello0.h'])
# Now exports being a list instead a tuple
content = """
from conans import ConanFile
class OpenSSLConan(ConanFile):
name = "openssl"
version = "2.0.1"
exports = ['*.txt', '*.h']
"""
save(os.path.join(self.conan.current_folder, CONANFILE), content)
self.conan.run("export lasote/stable")
reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
self.assertEqual(sorted(os.listdir(reg_path)),
[EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST,
'helloHello0.h'])
def test_export_the_same_code(self):
file_list = self._create_packages_and_builds()
# Export the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path2 = conan2.paths.export(self.conan_ref)
digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path2))
for name in list(files2.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': '9e26c9274ae837c03764d1418c063ebb',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest2.file_sums)
for f in file_list:
self.assertTrue(os.path.exists(f))
def test_export_a_new_version(self):
self._create_packages_and_builds()
# Export an update of the same conans
conan2 = TestClient(self.conan.base_folder)
files2 = cpp_hello_conan_files("Hello0", "0.1")
files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
conan2.save(files2)
conan2.run("export lasote/stable")
reg_path3 = conan2.paths.export(self.conan_ref)
digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))
self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
self.conan.user_io.out)
self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out)
self.assertTrue(os.path.exists(reg_path3))
for name in list(files2.keys()):
self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))
expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
'main.cpp': '0479f3c223c9a656a718f3148e044124',
'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
'conanfile.py': 'b6ac37b87cf6cfd63991d355b48db40e',
'executable': '68b329da9893e34099c7d8ad5cb9c940',
'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
self.assertEqual(expected_sums, digest3.file_sums)
# for f in file_list:
# self.assertFalse(os.path.exists(f))
def _create_packages_and_builds(self):
reg_builds = self.conan.paths.builds(self.conan_ref)
reg_packs = self.conan.paths.packages(self.conan_ref)
folders = [os.path.join(reg_builds, '342525g4f52f35f'),
os.path.join(reg_builds, 'ew9o8asdf908asdf80'),
os.path.join(reg_packs, '342525g4f52f35f'),
os.path.join(reg_packs, 'ew9o8asdf908asdf80')]
file_list = []
for f in folders:
for name, content in {'file1.h': 'asddfasdf', 'file1.dll': 'asddfasdf'}.items():
file_path = os.path.join(f, name)
save(file_path, content)
file_list.append(file_path)
return file_list
class InstallSelectedPackagesTest(unittest.TestCase):
def setUp(self):
test_server = TestServer()
self.servers = {"default": test_server}
self.client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
self.package_ids = self._upload_some_packages(self.client)
self.new_client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def install_all_test(self):
# Should retrieve the three packages
self.new_client.run("install Hello0/0.1@lasote/stable --all")
p1 = os.path.join(self.new_client.paths.packages(self.ref))
packages = os.listdir(p1)
self.assertEquals(len(packages), 3)
def install_some_reference_test(self):
# Should retrieve the specified packages
self.new_client.run("install Hello0/0.1@lasote/stable -p %s" %
self.package_ids[0])
packages = os.listdir(self.new_client.paths.packages(self.ref))
self.assertEquals(len(packages), 1)
self.assertEquals(packages[0], self.package_ids[0])
self.new_client.run("install Hello0/0.1@lasote/stable -p %s -p %s" %
(self.package_ids[0], self.package_ids[1]))
packages = os.listdir(self.new_client.paths.packages(self.ref))
self.assertEquals(len(packages), 2)
def download_recipe_twice_test(self):
expected_conanfile_contents = self.files[CONANFILE]
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_conanfile = load(
os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
self.assertEquals(expected_conanfile_contents, got_conanfile)
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_conanfile = load(
os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
self.assertEquals(expected_conanfile_contents, got_conanfile)
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_conanfile = load(
os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
self.assertEquals(expected_conanfile_contents, got_conanfile)
def download_packages_twice_test(self):
expected_header_contents = self.files["helloHello0.h"]
package_folder = self.new_client.paths.package(
PackageReference(self.ref, self.package_ids[0]))
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_header = load(
os.path.join(package_folder, "include", "helloHello0.h"))
self.assertEquals(expected_header_contents, got_header)
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_header = load(
os.path.join(package_folder, "include", "helloHello0.h"))
self.assertEquals(expected_header_contents, got_header)
self.new_client.run("install Hello0/0.1@lasote/stable --all")
got_header = load(
os.path.join(package_folder, "include", "helloHello0.h"))
self.assertEquals(expected_header_contents, got_header)
def install_all_but_no_packages_test(self):
# Remove all from remote
self.new_client.run("remove Hello* -f -r default")
# Try to install all
self.new_client.run("install Hello0/0.1@lasote/stable --all",
ignore_error=True)
self.assertIn("'Hello0/0.1@lasote/stable' not found in remote",
self.new_client.user_io.out)
# Upload only the recipe
self.new_client.save(self.files)
self.new_client.run("export lasote/stable")
self.new_client.run("upload Hello0/0.1@lasote/stable --all")
# And try to download all
self.new_client.run("install Hello0/0.1@lasote/stable --all")
self.assertIn("No remote binary packages found in remote",
self.new_client.user_io.out)
def _upload_some_packages(self, client):
self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
self.files = cpp_hello_conan_files("Hello0", "0.1")
# No build.
self.files[CONANFILE] = self.files[CONANFILE].replace(
"def build(self):", "def build(self):\n return\n")
client.save(self.files)
client.run("export lasote/stable")
client.run(
"install Hello0/0.1@lasote/stable -s os=Windows --build missing")
client.run(
"install Hello0/0.1@lasote/stable -s os=Linux --build missing")
client.run(
"install Hello0/0.1@lasote/stable -s os=Linux -s compiler=gcc -s "
"compiler.version=4.6 -s compiler.libcxx=libstdc++ --build missing"
)
client.run("upload Hello0/0.1@lasote/stable --all")
return os.listdir(self.client.paths.packages(self.ref))
class ImportsTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
self.client.save({"conanfile.py": conanfile})
self.client.run("export lasote/stable")
def imports_global_path_test(self):
""" Ensure that when importing files in a global path, outside the package build,
they are not deleted
"""
dst_global_folder = temp_folder().replace("\\", "/")
conanfile2 = '''
from conans import ConanFile
class ConanLib(ConanFile):
name = "Say"
version = "0.1"
requires = "Hello/0.1@lasote/stable"
def imports(self):
self.copy("file*.txt", dst="%s")
''' % dst_global_folder
self.client.save({"conanfile.py": conanfile2}, clean_first=True)
self.client.run("export lasote/stable")
self.client.current_folder = temp_folder()
self.client.run("install Say/0.1@lasote/stable --build=missing")
for filename, content in [("file1.txt", "Hello"),
("file2.txt", "World")]:
filecontent = load(os.path.join(dst_global_folder, filename))
self.assertTrue(content, filecontent)
def imports_env_var_test(self):
conanfile2 = '''
from conans import ConanFile
import os
class ConanLib(ConanFile):
requires = "Hello/0.1@lasote/stable"
def imports(self):
self.copy("file*.txt", dst=os.environ["MY_IMPORT_PATH"])
'''
for folder in ("folder1", "folder2"):
self.client.save({"conanfile.py": conanfile2}, clean_first=True)
self.client.run("install -e MY_IMPORT_PATH=%s" % folder)
self.assertEqual(
"Hello",
load(
os.path.join(self.client.current_folder, folder,
"file1.txt")))
def imports_error_test(self):
self.client.save({"conanfile.txt": test1}, clean_first=True)
self.client.run("install --no-imports")
self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
error = self.client.run("imports", ignore_error=True)
self.assertTrue(error)
self.assertIn("conanbuildinfo.txt file not found",
self.client.user_io.out)
def install_manifest_test(self):
self.client.save({"conanfile.txt": test1}, clean_first=True)
self.client.run("install -g txt")
self.assertIn("imports(): Copied 2 '.txt' files",
self.client.user_io.out)
self.assertIn("file1.txt", os.listdir(self.client.current_folder))
self.assertIn("file2.txt", os.listdir(self.client.current_folder))
self._check_manifest()
def undo_install_manifest_test(self):
self.client.save({"conanfile.txt": test1}, clean_first=True)
self.client.run("install -g txt")
self.client.run("imports --undo")
self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
self.assertNotIn(IMPORTS_MANIFESTS,
os.listdir(self.client.current_folder))
self.assertIn("Removed 2 imported files", self.client.user_io.out)
self.assertIn("Removed imports manifest file", self.client.user_io.out)
def _check_manifest(self):
manifest_content = load(
os.path.join(self.client.current_folder, IMPORTS_MANIFESTS))
manifest = FileTreeManifest.loads(manifest_content)
self.assertEqual(
manifest.file_sums, {
os.path.join(self.client.current_folder, "file1.txt"):
"8b1a9953c4611296a827abf8c47804d7",
os.path.join(self.client.current_folder, "file2.txt"):
"f5a7924e621e84c9280a9a27e1bcb7f6"
})
def imports_test(self):
self.client.save({"conanfile.txt": test1}, clean_first=True)
self.client.run("install --no-imports -g txt")
self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
self.client.run("imports")
self.assertIn("imports(): Copied 2 '.txt' files",
self.client.user_io.out)
self.assertIn("file1.txt", os.listdir(self.client.current_folder))
self.assertIn("file2.txt", os.listdir(self.client.current_folder))
self._check_manifest()
def imports_filename_test(self):
self.client.save(
{
"conanfile.txt": test1,
"conanfile.py": test2,
"conanfile2.py": test3
},
clean_first=True)
self.client.run("install --no-imports -g txt")
self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
self.client.run("imports -f=conanfile2.py")
self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
self.assertIn("file2.txt", os.listdir(self.client.current_folder))
os.unlink(os.path.join(self.client.current_folder, "file2.txt"))
self.client.run("imports")
self.assertIn("file1.txt", os.listdir(self.client.current_folder))
self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
os.unlink(os.path.join(self.client.current_folder, "file1.txt"))
self.client.run("imports -f conanfile.txt")
self.assertIn("file1.txt", os.listdir(self.client.current_folder))
self.assertIn("file2.txt", os.listdir(self.client.current_folder))
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"
},
path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
loader = ConanFileLoader(None, Settings(), OptionsValues.loads(""))
conanfile = loader.load_conan(conanfile_path, None)
create_package(conanfile, build_folder, package_folder,
TestBufferConanOutput())
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder,
CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
def _diamond_test(self, install="install", use_cmake=True):
def wait_until_removed(folder):
latest_exception = None
for _ in range(50): # Max 5 seconds
time.sleep(0.1)
try:
shutil.rmtree(folder)
break
except Exception as e:
latest_exception = e
else:
raise Exception("Could remove folder %s: %s" %
(folder, latest_exception))
self._export_upload("Hello0", "0.1", use_cmake=use_cmake)
self._export_upload("Hello1",
"0.1", ["Hello0/0.1@lasote/stable"],
use_cmake=use_cmake)
self._export_upload("Hello2",
"0.1", ["Hello0/0.1@lasote/stable"],
use_cmake=use_cmake)
self._export_upload(
"Hello3",
"0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
use_cmake=use_cmake)
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake)
# Add some stuff to base project conanfile to test further the individual
# flags in build_info (txt, cmake) files
content = files3[CONANFILE]
content = content.replace("generators =", 'generators = "txt",')
content = content.replace(
"def build(self):", "def build(self):\n"
" self.output.info('INCLUDE %s' "
"% self.deps_cpp_info['Hello0'].include_paths)")
files3[CONANFILE] = content
client.save(files3)
client.run("%s . --build missing" % install)
client.run("build .")
self._check_individual_deps(client)
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1,
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
wait_until_removed(client.current_folder)
client.save(files3)
client.run("%s . --build missing" % install)
client.run("build .")
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client.user_io.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload Hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
client2.save(files3)
client2.run("%s . --build missing" % install)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1,
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
wait_until_removed(client2.current_folder)
client2.save(files3)
client2.run("%s . --build missing" % install)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
def test_update_settings(self):
file_content = '''
from conans import ConanFile
class ConanFileToolsTest(ConanFile):
name = "test"
version = "1.9"
settings = "os", "compiler", "arch"
def source(self):
self.output.warn("Sourcing...")
def build(self):
self.output.warn("Building...")
'''
prev_settings = """
os: [Windows, Linux, Macos, Android]
arch: [x86, x86_64, armv6, armv7, armv7hf, armv8]
compiler:
gcc:
version: ["4.4", "4.5", "4.6", "4.7", "4.8", "4.9", "5.1", "5.2", "5.3"]
libcxx: [libstdc++, libstdc++11]
Visual Studio:
runtime: [None, MD, MT, MTd, MDd]
version: ["8", "9", "10", "11", "12", "14"]
clang:
version: ["3.3", "3.4", "3.5", "3.6", "3.7", "3.8"]
libcxx: [libstdc++, libstdc++11, libc++]
apple-clang:
version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.1", "7.2", "7.3"]
libcxx: [libstdc++, libc++]
"""
files = {"conanfile.py": file_content}
client = TestClient()
save(client.paths.settings_path, prev_settings)
conf = load(client.paths.conan_conf_path)
conf = conf.replace("build_type=Release", "")
self.assertNotIn("build_type", conf)
save(client.paths.conan_conf_path, conf)
self.assertNotIn("build_type",
client.paths.conan_config.settings_defaults.dumps())
client.save(files)
client.run("export lasote/testing")
self.assertNotIn("build_type", load(client.paths.settings_path))
self.assertNotIn("build_type", load(client.paths.conan_conf_path))
self.assertNotIn("build_type",
client.paths.conan_config.settings_defaults.dumps())
client.run(
"install test/1.9@lasote/testing --build -s compiler=gcc "
"-s compiler.version=4.9 -s os=Windows -s compiler.libcxx=libstdc++"
)
self.assertIn("390146894f59dda18c902ee25e649ef590140732",
client.user_io.out)
# Now the new one
files = {
"conanfile.py": file_content.replace('"arch"',
'"arch", "build_type"')
}
client = TestClient()
client.save(files)
client.run("export lasote/testing")
self.assertIn("build_type", load(client.paths.settings_path))
client.run(
"install test/1.9@lasote/testing --build -s compiler=gcc "
"-s compiler.version=4.9 -s os=Windows -s build_type=None -s compiler.libcxx=libstdc++"
)
self.assertIn("390146894f59dda18c902ee25e649ef590140732",
client.user_io.out)
class DiamondTest(unittest.TestCase):
def setUp(self):
test_server = TestServer(
[("*/*@*/*", "*")], # read permissions
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def _export_upload(self, name, version=None, deps=None):
files = cpp_hello_conan_files(name, version, deps, need_patch=True)
conan_ref = ConanFileReference(name, version, "lasote", "stable")
self.conan.save(files, clean_first=True)
self.conan.run("export lasote/stable")
self.conan.run("upload %s" % str(conan_ref))
def _check_individual_deps(self, client):
self.assertIn("INCLUDE [", client.user_io.out)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable",
client.user_io.out)
build_file = os.path.join(client.current_folder, BUILD_INFO)
content = load(build_file)
cmakebuildinfo = load(
os.path.join(client.current_folder, BUILD_INFO_CMAKE))
self.assertIn(
"set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0",
cmakebuildinfo)
self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)",
cmakebuildinfo)
deps_cpp_info = DepsCppInfo.loads(content)
self.assertEqual(len(deps_cpp_info.include_paths), 4)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
content = load(build_file)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep),
content)
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"])
self._export_upload(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4", "0.1",
["Hello3/0.1@lasote/stable"])
# Add some stuff to base project conanfile to test further the individual
# flags in build_info (txt, cmake) files
content = files3[CONANFILE]
content = content.replace("generators =", 'generators = "txt",')
content = content.replace(
"def build(self):", "def build(self):\n"
" self.output.info('INCLUDE %s' "
"% self.deps_cpp_info['Hello0'].include_paths)")
files3[CONANFILE] = content
client.save(files3)
client.run("install . --build missing")
client.run("build .")
self._check_individual_deps(client)
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1)
client.save(files3, clean_first=True)
client.run("install . --build missing")
client.run("build .")
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client.user_io.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload Hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4", "0.1",
["Hello3/0.1@lasote/stable"])
client2.save(files3)
client2.run("install . --build missing")
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1)
client2.save(files3, clean_first=True)
client2.run("install . --build missing")
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
class SearchTest(unittest.TestCase):
def setUp(self):
self.servers = {
"local":
TestServer(server_capabilities=[]),
"search_able":
TestServer(server_capabilities=[COMPLEX_SEARCH_CAPABILITY])
}
self.client = TestClient(servers=self.servers)
# No conans created
self.client.run("search")
output = self.client.user_io.out
self.assertIn('There are no packages', output)
# Conans with and without packages created
self.root_folder1 = 'Hello/1.4.10/fenix/testing'
root_folder2 = 'helloTest/1.4.10/fenix/stable'
root_folder3 = 'Bye/0.14/fenix/testing'
root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
root_folder5 = 'MissFile/1.0.2/fenix/stable'
root_folder11 = 'Hello/1.4.11/fenix/testing'
root_folder12 = 'Hello/1.4.12/fenix/testing'
self.client.save(
{
"Empty/1.10/fake/test/reg/fake.txt":
"//",
"%s/%s/WindowsPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder11, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder12, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1b,
"%s/%s/LinuxPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1c,
"%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO):
conan_vars2,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO):
conan_vars3,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO):
conan_vars4,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"):
"Hello"
}, self.client.paths.store)
# Fake some manifests to be able to calculate recipe hash
fake_manifest = FileTreeManifest(1212, {})
self.client.save(
{
os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
}, self.client.paths.store)
def recipe_search_test(self):
self.client.run("search Hello*")
self.assertEquals(
"Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
self.client.run("search Hello* --case-sensitive")
self.assertEquals(
"Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n", self.client.user_io.out)
self.client.run("search *fenix* --case-sensitive")
self.assertEquals(
"Existing package recipes:\n\n"
"Bye/0.14@fenix/testing\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"MissFile/1.0.2@fenix/stable\n"
"NodeInfo/1.0.2@fenix/stable\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
def recipe_pattern_search_test(self):
self.client.run("search Hello*")
self.assertEquals(
"Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
self.client.run("search Hello* --case-sensitive")
self.assertEquals(
"Existing package recipes:\n\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n", self.client.user_io.out)
self.client.run("search *fenix* --case-sensitive")
self.assertEquals(
"Existing package recipes:\n\n"
"Bye/0.14@fenix/testing\n"
"Hello/1.4.10@fenix/testing\n"
"Hello/1.4.11@fenix/testing\n"
"Hello/1.4.12@fenix/testing\n"
"MissFile/1.0.2@fenix/stable\n"
"NodeInfo/1.0.2@fenix/stable\n"
"helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)
def package_search_with_invalid_reference_test(self):
self.client.run("search Hello -q 'a=1'", ignore_error=True)
self.assertIn("-q parameter only allowed with a valid recipe",
str(self.client.user_io.out))
def package_search_with_empty_query_test(self):
self.client.run("search Hello/1.4.10/fenix/testing")
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
def package_search_nonescaped_characters_test(self):
self.client.run(
'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"'
)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.client.run(
'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"'
)
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
# Now search with a remote
os.rmdir(self.servers["local"].paths.store)
shutil.copytree(self.client.paths.store,
self.servers["local"].paths.store)
self.client.run("remove Hello* -f")
self.client.run(
'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local'
)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.client.run(
'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local'
)
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
def _assert_pkg_q(self, query, packages_found, remote):
command = 'search Hello/1.4.10@fenix/testing -q \'%s\'' % query
if remote:
command += " -r %s" % remote
self.client.run(command)
for pack_name in [
"LinuxPackageSHA", "PlatformIndependantSHA",
"WindowsPackageSHA"
]:
self.assertEquals(pack_name in self.client.user_io.out, pack_name
in packages_found, "%s fail" % pack_name)
def package_search_complex_queries_test(self):
def test_cases(remote=None):
if remote: # Simulate upload to remote
os.rmdir(self.servers[remote].paths.store)
shutil.copytree(self.client.paths.store,
self.servers[remote].paths.store)
q = ''
self._assert_pkg_q(q, [
"LinuxPackageSHA", "PlatformIndependantSHA",
"WindowsPackageSHA"
], remote)
q = 'compiler="gcc"'
self._assert_pkg_q(q,
["LinuxPackageSHA", "PlatformIndependantSHA"],
remote)
q = 'compiler=' # No packages found with empty value
self._assert_pkg_q(q, [], remote)
q = 'compiler="gcc" OR compiler.libcxx=libstdc++11'
# Should find Visual because of the OR, visual doesn't care about libcxx
self._assert_pkg_q(q, [
"LinuxPackageSHA", "PlatformIndependantSHA",
"WindowsPackageSHA"
], remote)
q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR compiler.version=4.5'
self._assert_pkg_q(q, ["LinuxPackageSHA"], remote)
q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR '\
'(compiler.version=4.5 OR compiler.version=8.1)'
self._assert_pkg_q(q, ["LinuxPackageSHA", "WindowsPackageSHA"],
remote)
q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\
'(compiler.version=4.5 OR compiler.version=8.1)'
self._assert_pkg_q(q, [
"LinuxPackageSHA", "PlatformIndependantSHA",
"WindowsPackageSHA"
], remote)
q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\
'(compiler.version=4.3 OR compiler.version=8.1)'
self._assert_pkg_q(q,
["PlatformIndependantSHA", "WindowsPackageSHA"],
remote)
q = '(os="Linux" OR os=Windows)'
self._assert_pkg_q(q, [
"PlatformIndependantSHA", "LinuxPackageSHA",
"WindowsPackageSHA"
], remote)
q = '(os="Linux" OR os=Windows) AND use_Qt=True'
self._assert_pkg_q(q,
["PlatformIndependantSHA", "WindowsPackageSHA"],
remote)
q = '(os="Linux" OR os=Windows) AND use_Qt=True AND nonexistant_option=3'
self._assert_pkg_q(q,
["PlatformIndependantSHA", "WindowsPackageSHA"],
remote)
q = '(os="Linux" OR os=Windows) AND use_Qt=True OR nonexistant_option=3'
self._assert_pkg_q(q, [
"PlatformIndependantSHA", "WindowsPackageSHA",
"LinuxPackageSHA"
], remote)
# test in local
test_cases()
# test in remote
test_cases(remote="local")
# test in remote with search capabilities
test_cases(remote="search_able")
def package_search_with_invalid_query_test(self):
self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'",
ignore_error=True)
self.assertIn("Invalid package query: invalid",
self.client.user_io.out)
self.client.run("search Hello/1.4.10/fenix/testing -q 'os= 3'",
ignore_error=True)
self.assertIn("Invalid package query: os= 3", self.client.user_io.out)
self.client.run("search Hello/1.4.10/fenix/testing -q 'os=3 FAKE '",
ignore_error=True)
self.assertIn("Invalid package query: os=3 FAKE ",
self.client.user_io.out)
self.client.run(
"search Hello/1.4.10/fenix/testing -q 'os=3 os.compiler=4'",
ignore_error=True)
self.assertIn("Invalid package query: os=3 os.compiler=4",
self.client.user_io.out)
self.client.run(
"search Hello/1.4.10/fenix/testing -q 'not os=3 AND os.compiler=4'",
ignore_error=True)
self.assertIn(
"Invalid package query: not os=3 AND os.compiler=4. 'not' operator is not allowed",
self.client.user_io.out)
self.client.run(
"search Hello/1.4.10/fenix/testing -q 'os=3 AND !os.compiler=4'",
ignore_error=True)
self.assertIn(
"Invalid package query: os=3 AND !os.compiler=4. '!' character is not allowed",
self.client.user_io.out)
def package_search_properties_filter_test(self):
# All packages without filter
self.client.run("search Hello/1.4.10/fenix/testing -q ''")
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows')
self.assertIn("WindowsPackageSHA", self.client.user_io.out)
self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run(
'search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"'
)
self.assertIn(
"There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'",
self.client.user_io.out)
self.client.run(
'search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"'
)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run(
'search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"')
self.assertIn(
"There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'",
self.client.user_io.out)
self.client.run(
'search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"'
)
self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
self.assertIn("LinuxPackageSHA", self.client.user_io.out)
self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"')
# One package will be outdated from recipe and another don't
self.assertEquals(
"""Existing packages for recipe Hello/1.4.10@fenix/testing:
Package_ID: LinuxPackageSHA
[options]
use_Qt: False
[settings]
arch: x86
compiler: gcc
compiler.libcxx: libstdc++11
compiler.version: 4.5
os: Linux
[requires]
Hello2/0.1@lasote/stable:11111
HelloInfo1/0.45@fenix/testing:33333
OpenSSL/2.10@lasote/testing:2222
outdated from recipe: False
Package_ID: PlatformIndependantSHA
[options]
use_Qt: True
[settings]
arch: x86
compiler: gcc
compiler.libcxx: libstdc++
compiler.version: 4.3
outdated from recipe: True
""", self.client.user_io.out)
self.client.run(
'search helloTest/1.4.10@fenix/stable -q use_OpenGL=False')
self.assertIn(
"There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
"matching the query 'use_OpenGL=False'", self.client.user_io.out)
self.client.run(
'search helloTest/1.4.10@fenix/stable -q use_OpenGL=True')
self.assertIn(
"Existing packages for recipe helloTest/1.4.10@fenix/stable",
self.client.user_io.out)
self.client.run(
'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"'
)
self.assertIn(
"Existing packages for recipe helloTest/1.4.10@fenix/stable",
self.client.user_io.out)
self.client.run(
'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"'
)
self.assertIn(
"There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
"matching the query 'use_OpenGL=True AND arch=x86'",
self.client.user_io.out)
def search_with_no_local_test(self):
client = TestClient()
client.run("search nonexist/1.0@lasote/stable")
self.assertIn("There are no packages", self.client.user_io.out)
class FlatRequirementsTest(unittest.TestCase):
def setUp(self):
self.conan_reference = ConanFileReference.loads(
"Hello0/0.1@lasote/stable")
self.files = cpp_hello_conan_files("Hello0", "0.1", build=False)
self.conan = TestClient()
self.conan.save(self.files)
self.conan.run("export lasote/stable")
def consumer_with_flat_requirement_test(self):
# We want to reuse exported Hello0/0.1@lasote/stable
tmp_dir = temp_folder()
req_file = '''[requires]
Hello0/0.1@lasote/stable # My req comment
[generators]
gcc # I need this generator for..
cmake
visual_studio
xcode
'''
save(os.path.join(tmp_dir, CONANFILE_TXT), req_file)
self.conan.current_folder = tmp_dir
# Install requirements
self.conan.run('install --build missing')
self.assertEqual(
sorted([
CONANFILE_TXT, BUILD_INFO_GCC, BUILD_INFO_CMAKE,
BUILD_INFO_VISUAL_STUDIO, BUILD_INFO_XCODE, CONANINFO
]), sorted(os.listdir(tmp_dir)))
cmake = load(os.path.join(tmp_dir, BUILD_INFO_CMAKE))
gcc = load(os.path.join(tmp_dir, BUILD_INFO_GCC))
self.assertIn("CONAN_INCLUDE_DIRS", cmake)
self.assertIn("CONAN_LIB_DIRS", cmake)
self.assertIn("CONAN_LIBS", cmake)
self.assertIn("CONAN_INCLUDE_DIRS", cmake)
self.assertIn("CONAN_LIB_DIRS", cmake)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", cmake)
self.assertIn("-L", gcc)
self.assertIn("-l", gcc)
self.assertIn("-I", gcc)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", gcc)
# CHECK VISUAL STUDIO GENERATOR
from xml.dom import minidom
xmldoc = minidom.parse(os.path.join(tmp_dir, BUILD_INFO_VISUAL_STUDIO))
definition_group = xmldoc.getElementsByTagName(
'ItemDefinitionGroup')[0]
compiler = definition_group.getElementsByTagName("ClCompile")[0]
include_dirs = compiler.getElementsByTagName(
"AdditionalIncludeDirectories")[0].firstChild.data
definitions = compiler.getElementsByTagName(
"PreprocessorDefinitions")[0].firstChild.data
linker = definition_group.getElementsByTagName("Link")[0]
lib_dirs = linker.getElementsByTagName(
"AdditionalLibraryDirectories")[0].firstChild.data
libs = linker.getElementsByTagName(
"AdditionalDependencies")[0].firstChild.data
package_id = os.listdir(self.conan.paths.packages(
self.conan_reference))[0]
package_ref = PackageReference(self.conan_reference, package_id)
package_paths = self.conan.paths.package(package_ref).replace(
"\\", "/")
expected_lib_dirs = os.path.join(package_paths,
"lib").replace("\\", "/")
expected_include_dirs = os.path.join(package_paths,
"include").replace("\\", "/")
self.assertIn(expected_lib_dirs, lib_dirs)
self.assertEquals("helloHello0.lib;%(AdditionalDependencies)", libs)
self.assertEquals("%(PreprocessorDefinitions)", definitions)
self.assertIn(expected_include_dirs, include_dirs)
# CHECK XCODE GENERATOR
xcode = load(os.path.join(tmp_dir, BUILD_INFO_XCODE))
self.assertIn(
'LIBRARY_SEARCH_PATHS = $(inherited) "%s"' % expected_lib_dirs,
xcode)
self.assertIn(
'HEADER_SEARCH_PATHS = $(inherited) "%s"' % expected_include_dirs,
xcode)
self.assertIn("GCC_PREPROCESSOR_DEFINITIONS = $(inherited)", xcode)
self.assertIn("OTHER_CFLAGS = $(inherited)", xcode)
self.assertIn("OTHER_CPLUSPLUSFLAGS = $(inherited)", xcode)
def reuse_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"])
self._export_upload(
"Hello3", "0.1",
["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4", "0.1",
["Hello3/0.1@lasote/stable"])
# Add some stuff to base project conanfile to test further the individual
# flags in build_info (txt, cmake) files
content = files3[CONANFILE]
content = content.replace("generators =", 'generators = "txt",')
content = content.replace(
"def build(self):", "def build(self):\n"
" self.output.info('INCLUDE %s' "
"% self.deps_cpp_info['Hello0'].include_paths)")
files3[CONANFILE] = content
client.save(files3)
client.run("install . --build missing")
client.run("build .")
self._check_individual_deps(client)
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1)
client.save(files3, clean_first=True)
client.run("install . --build missing")
client.run("build .")
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client.user_io.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload Hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4", "0.1",
["Hello3/0.1@lasote/stable"])
client2.save(files3)
client2.run("install . --build missing")
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1)
client2.save(files3, clean_first=True)
client2.run("install . --build missing")
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
def local_test(self):
client = TestClient()
# No conans created
client.run("search")
output = client.user_io.out
self.assertIn('There are no packages', output)
# Conans with and without packages created
root_folder1 = 'Hello/1.4.10/fenix/testing'
root_folder2 = 'helloTest/1.4.10/fenix/stable'
root_folder3 = 'Bye/0.14/fenix/testing'
root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
root_folder5 = 'MissFile/1.0.2/fenix/stable'
client.save(
{
"Empty/1.10/fake/test/reg/fake.txt":
"//",
"%s/%s/d91960d4c06b38/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO):
conan_vars2,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO):
conan_vars3,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO):
conan_vars4,
"%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"):
"Hello"
}, client.paths.store)
client.run("search -v")
self.assertEqual(
"""Existing packages info:
Bye/0.14@fenix/testing
Package_ID: e4f7vdwcv4w55d
[options]
HAVE_TESTS=True
USE_CONFIG=False
[settings]
os=Darwin
[requirements]
Empty/1.10@fake/test
There are no packages
Hello/1.4.10@fenix/testing
Package_ID: d91960d4c06b38
[options]
use_Qt=True
[settings]
arch=x64
os=Windows
version=8.1
[requirements]
MissFile/1.0.2@fenix/stable
There are no packages
NodeInfo/1.0.2@fenix/stable
Package_ID: e4f7vdwcv4w55d
[options]
language=1
[settings]
arch=x86_64
compiler=gcc
os=Windows
[requirements]
helloTest/1.4.10@fenix/stable
Package_ID: a44f541cd44w57
[options]
use_OpenGL=True
[settings]
arch=x64
os=Ubuntu
version=15.04
[requirements]
""", client.user_io.out)
client.run("search")
self.assertEqual(
"""Existing packages info:
Bye/0.14@fenix/testing
Package_ID: e4f7vdwcv4w55d
(Darwin)
Empty/1.10@fake/test
There are no packages
Hello/1.4.10@fenix/testing
Package_ID: d91960d4c06b38
(x64, Windows, 8.1)
MissFile/1.0.2@fenix/stable
There are no packages
NodeInfo/1.0.2@fenix/stable
Package_ID: e4f7vdwcv4w55d
(x86_64, gcc, Windows)
helloTest/1.4.10@fenix/stable
Package_ID: a44f541cd44w57
(x64, Ubuntu, 15.04)
""", client.user_io.out)
client.run("search Bye/* -v")
self.assertEqual(
"""Existing packages info:
Bye/0.14@fenix/testing
Package_ID: e4f7vdwcv4w55d
[options]
HAVE_TESTS=True
USE_CONFIG=False
[settings]
os=Darwin
[requirements]
""", client.user_io.out)
# bad pattern
client.run("search OpenCV/*")
self.assertIn("There are no packages matching the OpenCV/* pattern",
client.user_io.out)
# pattern case-sensitive
client.run("search hello* --case-sensitive -v")
self.assertIn("helloTest/1.4.10@fenix/stable", client.user_io.out)
self.assertNotIn("Empty/1.10@fake/test", client.user_io.out)
self.assertNotIn("Hello/1.4.10@fenix/testing", client.user_io.out)
self.assertNotIn("NodeInfo/1.0.2@fenix/stable", client.user_io.out)
# Package search
client.run("search -p e4*")
self.assertIn(
'''Bye/0.14@fenix/testing
Package_ID: e4f7vdwcv4w55d
(Darwin)
NodeInfo/1.0.2@fenix/stable
Package_ID: e4f7vdwcv4w55d
(x86_64, gcc, Windows)''', client.user_io.out)
client.run("search -p d9")
self.assertIn(
'''Hello/1.4.10@fenix/testing
Package_ID: d91960d4c06b38
(x64, Windows, 8.1)''', client.user_io.out)
client.run("search Bye/0.14@fenix/testing -p e4*")
self.assertNotIn('''NodeInfo/1.0.2@fenix/stable''', client.user_io.out)
class DiamondTest(unittest.TestCase):
def setUp(self):
test_server = TestServer(
[], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
self.servers = {"default": test_server}
self.conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
def _export_upload(self, name, version=None, deps=None, use_cmake=True):
files = cpp_hello_conan_files(name,
version,
deps,
need_patch=True,
use_cmake=use_cmake)
conan_ref = ConanFileReference(name, version, "lasote", "stable")
self.conan.save(files, clean_first=True)
self.conan.run("export lasote/stable")
self.conan.run("upload %s" % str(conan_ref))
def _check_individual_deps(self, client):
self.assertIn("INCLUDE [", client.user_io.out)
self.assertIn(".conan/data/Hello0/0.1/lasote/stable",
client.user_io.out)
build_file = os.path.join(client.current_folder, BUILD_INFO)
content = load(build_file)
cmakebuildinfo = load(
os.path.join(client.current_folder, BUILD_INFO_CMAKE))
self.assertIn(
"set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0",
cmakebuildinfo)
self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)",
cmakebuildinfo)
deps_cpp_info = DepsCppInfo.loads(content)
self.assertEqual(len(deps_cpp_info.include_paths), 4)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
content = load(build_file)
for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep),
content)
def diamond_cmake_test(self):
self._diamond_test(use_cmake=True)
def diamond_default_test(self):
self._diamond_test(use_cmake=False)
def diamond_mingw_test(self):
if platform.system() != "Windows":
return
not_env = os.system("g++ --version > nul")
if not_env != 0:
logger.error("This platform does not support G++ command")
return
install = "install -s compiler=gcc -s compiler.libcxx=libstdc++ -s compiler.version=4.9"
self._diamond_test(install=install, use_cmake=False)
def _diamond_test(self, install="install", use_cmake=True):
def wait_until_removed(folder):
latest_exception = None
for _ in range(50): # Max 5 seconds
time.sleep(0.1)
try:
shutil.rmtree(folder)
break
except Exception as e:
latest_exception = e
else:
raise Exception("Could remove folder %s: %s" %
(folder, latest_exception))
self._export_upload("Hello0", "0.1", use_cmake=use_cmake)
self._export_upload("Hello1",
"0.1", ["Hello0/0.1@lasote/stable"],
use_cmake=use_cmake)
self._export_upload("Hello2",
"0.1", ["Hello0/0.1@lasote/stable"],
use_cmake=use_cmake)
self._export_upload(
"Hello3",
"0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
use_cmake=use_cmake)
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake)
# Add some stuff to base project conanfile to test further the individual
# flags in build_info (txt, cmake) files
content = files3[CONANFILE]
content = content.replace("generators =", 'generators = "txt",')
content = content.replace(
"def build(self):", "def build(self):\n"
" self.output.info('INCLUDE %s' "
"% self.deps_cpp_info['Hello0'].include_paths)")
files3[CONANFILE] = content
client.save(files3)
client.run("%s . --build missing" % install)
client.run("build .")
self._check_individual_deps(client)
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1,
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
wait_until_removed(client.current_folder)
client.save(files3)
client.run("%s . --build missing" % install)
client.run("build .")
client.runner(command, cwd=client.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client.user_io.out).splitlines()[-6:])
# Try to upload and reuse the binaries
client.run("upload Hello3/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello1/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello2/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client.run("upload Hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
client2 = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
client2.save(files3)
client2.run("%s . --build missing" % install)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
files3 = cpp_hello_conan_files("Hello4",
"0.1", ["Hello3/0.1@lasote/stable"],
language=1,
use_cmake=use_cmake)
files3[CONANFILE] = files3[CONANFILE].replace("generators =",
'generators = "txt",')
wait_until_removed(client2.current_folder)
client2.save(files3)
client2.run("%s . --build missing" % install)
client2.run("build .")
self.assertNotIn("libhello0.a", client2.user_io.out)
self.assertNotIn("libhello1.a", client2.user_io.out)
self.assertNotIn("libhello2.a", client2.user_io.out)
self.assertNotIn("libhello3.a", client2.user_io.out)
client2.runner(command, cwd=client2.current_folder)
self.assertEqual([
'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
'Hola Hello2', 'Hola Hello0'
],
str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self):
client = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
conan_reference = 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(conan_reference))
self.assertTrue(os.path.exists(client.paths.builds(conan_reference)))
self.assertTrue(os.path.exists(client.paths.packages(conan_reference)))
# Upload
client.run("upload %s --all" % str(conan_reference))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build missing" % str(conan_reference))
self.assertFalse(
os.path.exists(other_conan.paths.builds(conan_reference)))
self.assertTrue(
os.path.exists(other_conan.paths.packages(conan_reference)))
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build" % str(conan_reference))
self.assertTrue(
os.path.exists(other_conan.paths.builds(conan_reference)))
self.assertTrue(
os.path.exists(other_conan.paths.packages(conan_reference)))
# Use an invalid pattern and check that its not builded from source
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build HelloInvalid" %
str(conan_reference))
self.assertFalse(
os.path.exists(other_conan.paths.builds(conan_reference)))
self.assertTrue(
os.path.exists(other_conan.paths.packages(conan_reference)))
# Use another valid pattern and check that its not builded from source
other_conan = TestClient(servers=self.servers,
users={"default": [("lasote", "mypass")]})
other_conan.run("install %s --build HelloInvalid -b Hello" %
str(conan_reference))
self.assertTrue(
os.path.exists(other_conan.paths.builds(conan_reference)))
self.assertTrue(
os.path.exists(other_conan.paths.packages(conan_reference)))
# Now even if the package is in local store, check that's rebuilded
other_conan.run("install %s -b Hello*" % str(conan_reference))
self.assertIn("Copying sources to build folder",
other_conan.user_io.out)
other_conan.run("install %s" % str(conan_reference))
self.assertNotIn("Copying sources to build folder",
other_conan.user_io.out)
class MyBuildInfo(unittest.TestCase):
def setUp(self):
test_server = TestServer(users={"lasote": "lasote"})
test_server2 = TestServer(users={"lasote": "lasote"})
self.servers = {"default": test_server, "alternative": test_server2}
self.client = TestClient(servers=self.servers,
users={
"default": [("lasote", "lasote")],
"alternative": [("lasote", "lasote")]
})
def test_only_download(self):
files = cpp_hello_conan_files("Hello", "1.0", build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("upload '*' -c --all")
trace_file = os.path.join(temp_folder(), "conan_trace.log")
self.client.run("remove '*' -f")
with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
self.client.run("install Hello/1.0@lasote/stable --build")
data = get_build_info(trace_file).serialize()
self.assertEquals(len(data["modules"]), 1)
self.assertEquals(data["modules"][0]["id"], "DownloadOnly")
self.assertEquals(len(data["modules"][0]["artifacts"]), 0)
self.assertEquals(len(data["modules"][0]["dependencies"]), 3)
def test_json(self):
# Upload to server Hello1 => Hello0 and Hello2 => Hello0
files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False)
self.client.save(files)
self.client.run("export lasote/stable")
files = cpp_hello_conan_files("Hello1",
"1.0",
deps=["Hello0/1.0@lasote/stable"],
build=False)
self.client.save(files)
self.client.run("export lasote/stable")
files = cpp_hello_conan_files("Hello2",
"1.0",
deps=["Hello0/1.0@lasote/stable"],
build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello1/1.0@lasote/stable --build missing")
self.client.run("install Hello2/1.0@lasote/stable --build missing")
self.client.run("upload '*' -c --all")
# Remove all from local cache
self.client.run("remove '*' -f")
# Now activate logs and install both Hello1 and Hello2
trace_file = os.path.join(temp_folder(), "conan_trace.log")
with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
self.client.run("install Hello0/1.0@lasote/stable")
self.client.run("upload '*' -c --all")
data = get_build_info(trace_file).serialize()
# Only uploaded 2 modules, the Hello0 recipe and the Hello0 package
# without dependencies
self.assertEquals(len(data["modules"]), 2)
self.assertEquals(len(data["modules"][0]["dependencies"]), 0)
self.assertEquals(len(data["modules"][0]["dependencies"]), 0)
self.assertEquals(len(data["modules"][0]["artifacts"]), 3)
# Now upload the rest of them
self.client.run("install Hello1/1.0@lasote/stable --build missing")
self.client.run("install Hello2/1.0@lasote/stable --build missing")
self.client.run("upload '*' -c --all")
data = get_build_info(trace_file).serialize()
self.assertEquals(len(data["modules"]), 6)
for mod_name in [
"Hello1/1.0@lasote/stable", "Hello2/1.0@lasote/stable"
]:
module = _get_module(data, mod_name)
self.assertEquals(3, len(module["dependencies"]))
self.assertEquals(3, len(module["artifacts"]))
for dep in module["dependencies"]:
self.assertTrue(
dep["id"].startswith("Hello0/1.0@lasote/stable"))
def test_invalid_tracer(self):
trace_file = os.path.join(temp_folder(), "conan_trace.log")
save(trace_file, "invalid contents")
with self.assertRaisesRegexp(Exception, "INVALID TRACE FILE!"):
get_build_info(trace_file).serialize()
def test_cross_remotes(self):
# Upload to alternative server Hello0 but Hello1 to the default
files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False)
self.client.save(files)
self.client.run("export lasote/stable")
files = cpp_hello_conan_files("Hello1",
"1.0",
deps=["Hello0/1.0@lasote/stable"],
build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("export lasote/stable")
self.client.run("install Hello1/1.0@lasote/stable --build missing")
self.client.run("upload 'Hello0*' -c --all -r alternative")
self.client.run("upload 'Hello1*' -c --all -r default")
trace_file = os.path.join(temp_folder(), "conan_trace.log")
with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
# Will retrieve the Hello0 deps from the alternative
self.client.run("install Hello1/1.0@lasote/stable --build")
# Upload to the default, not matching the Hello0 remote
self.client.run("upload 'Hello1*' -c --all -r default")
data = get_build_info(trace_file).serialize()
self.assertEquals(len(data["modules"]), 2)
module = _get_module(data, "Hello1/1.0@lasote/stable")
self.assertEquals(0, len(module["dependencies"]))
def trace_command_test(self):
from conans.build_info.command import run
trace_file = os.path.join(temp_folder(), "conan_trace.log")
# Generate some traces
with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
files = cpp_hello_conan_files("Hello0",
"1.0",
deps=[],
build=False)
self.client.save(files)
self.client.run("export lasote/stable")
self.client.run("install Hello0/1.0@lasote/stable --build")
self.client.run("upload '*' --all -c")
# Get json from file
output = os.path.join(temp_folder(), "build_info.json")
sys.argv = ['conan_build_info', trace_file, '--output', output]
run()
the_json = json.loads(load(output))
self.assertTrue(the_json["modules"][0]["id"],
"Hello0/1.0@lasote/stable")
# Now get from stdout
sys.argv = ['conan_build_info', trace_file]
run()
try: # in IDEs or with --nocapture it will fail
stdout_value = sys.stdout.getvalue()
except AttributeError:
pass
else:
the_json = json.loads(stdout_value)
self.assertTrue(the_json["modules"][0]["id"],
"Hello0/1.0@lasote/stable")
