def complete_build_flow_test(self):
"""In local user folder"""
client = TestClient()
command = os.sep.join([".", "bin", "say_hello"])
for pure_c in (False, True):
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,
pure_c=pure_c)
client.save(files, clean_first=True)
client.run(install)
time.sleep(
1) # necessary so the conaninfo.txt is flushed to disc
client.run('build')
client.runner(command, cwd=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 _build(self, cmd, static, pure_c, use_cmake, lang):
client = TestClient()
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0",
"0.1",
dll_export=dll_export,
pure_c=pure_c,
use_cmake=use_cmake)
client.save(files)
client.run(cmd)
client.run('build')
ld_path = ("LD_LIBRARY_PATH=$(pwd)" if not static
and not platform.system() == "Windows" else "")
command = os.sep.join([".", "bin", "say_hello"])
client.runner("%s %s" % (ld_path, command), cwd=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 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 header_only_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py,
"hello.h": hello})
client.run("export lasote/testing")
client.save({"conanfile.txt": conanfile,
"CMakeLists.txt": cmake,
"main.cpp": main}, clean_first=True)
client.run('install -g cmake')
client.runner("cmake .", cwd=client.current_folder)
self.assertNotIn("WARN: Unknown compiler '", client.user_io.out)
self.assertNotIn("', skipping the version check...", client.user_io.out)
self.assertIn("Configuring done", client.user_io.out)
self.assertIn("Generating done", client.user_io.out)
self.assertIn("Build files have been written", client.user_io.out)
client.save({"conanfile.txt": conanfile,
"CMakeLists.txt": cmake.replace("conanbuildinfo.cmake",
"conanbuildinfo_multi.cmake"),
"main.cpp": main}, clean_first=True)
if platform.system() == "Windows":
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'
client.run('install %s -s build_type=Debug -g cmake_multi' % debug_install)
client.run('install %s -s build_type=Release -g cmake_multi' % release_install)
client.runner("cmake .", cwd=client.current_folder)
self.assertNotIn("WARN: Unknown compiler '", client.user_io.out)
self.assertNotIn("', skipping the version check...", client.user_io.out)
self.assertIn("Configuring done", client.user_io.out)
self.assertIn("Generating done", client.user_io.out)
self.assertIn("Build files have been written", client.user_io.out)
def transitive_targets_flags_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py})
client.run("export lasote/testing")
client.save({"conanfile.py": chatconanfile_py}, clean_first=True)
client.run("export lasote/testing")
cmake_targets = cmake.replace(
"conan_basic_setup()", "conan_basic_setup(TARGETS)\n"
"get_target_property(HELLO_FLAGS CONAN_PKG::Hello"
" INTERFACE_COMPILE_OPTIONS)\n"
"get_target_property(CHAT_FLAGS CONAN_PKG::Chat"
" INTERFACE_COMPILE_OPTIONS)\n")
client.save(
{
"conanfile.txt": conanfile.replace("Hello", "Chat"),
"CMakeLists.txt": cmake_targets
},
clean_first=True)
client.run('install -g cmake')
client.runner("cmake .", cwd=client.current_folder)
cmake_cxx_flags = self._get_line(client.user_io.out, "CMAKE_CXX_FLAGS")
self.assertNotIn("My", cmake_cxx_flags)
self.assertIn(
"CONAN_CXX_FLAGS=MyFlag1 MyFlag2 MyChatFlag1 MyChatFlag2",
client.user_io.out)
self.assertIn(
"HELLO_CXX_FLAGS=MyFlag1 MyFlag2;"
"$<$<CONFIG:Release>:;>;$<$<CONFIG:Debug>:;>", client.user_io.out)
self.assertIn(
"CHAT_CXX_FLAGS=MyChatFlag1 MyChatFlag2;"
"$<$<CONFIG:Release>:;>;$<$<CONFIG:Debug>:;>", client.user_io.out)
class BasicBuildTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
self.command = os.sep.join([".", "bin", "say_hello"])
def _build(self, cmd, static, pure_c, use_cmake, lang):
dll_export = self.client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export,
pure_c=pure_c, use_cmake=use_cmake)
self.client.save(files, clean_first=True)
self.client.run(cmd)
time.sleep(1) # necessary so the conaninfo.txt is flushed to disc
self.client.run('build')
ld_path = ("LD_LIBRARY_PATH=$(pwd)"
if not static and not platform.system() == "Windows" else "")
self.client.runner("%s %s" % (ld_path, self.command), cwd=self.client.current_folder)
msg = "Hello" if lang == 0 else "Hola"
self.assertIn("%s Hello0" % msg, self.client.user_io.out)
conan_info_path = os.path.join(self.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 build_cmake_test(self):
for pure_c in (False, True):
for cmd, 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)]:
self._build(cmd, static, pure_c, use_cmake=True, lang=lang)
def build_default_test(self):
"build default (gcc in nix, VS in win)"
for pure_c in (False, True):
for cmd, 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)]:
self._build(cmd, static, pure_c, use_cmake=False, lang=lang)
def build_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"
for pure_c in (False, True):
for cmd, 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)]:
self._build(cmd, static, pure_c, use_cmake=False, lang=lang)
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):
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, 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, files.keys())
# Now from other "computer" install the uploaded conans with same options (nothing)
other_conan = TestClient(servers=self.servers, users=[("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, files.keys())
reuse_conan = TestClient(servers=self.servers, users=[("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', reuse_conan.current_folder)
reuse_conan.runner(command, os.path.join(reuse_conan.current_folder, 'bin'))
self.assertIn("Hello, Go!", reuse_conan.user_io.out)
def reuse_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
client = TestClient()
client.save(files)
client.run("export lasote/stable")
configs = [] # ("gcc", "4.8")]
# Place to add different compilers
if platform.system() == "Windows2":
configs.append(("Visual Studio", "12"))
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.run("install %s --build missing" % str(conan_reference))
# Check compilation ok
package_ids = client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), len(configs))
for package_id in package_ids:
package_ref = PackageReference(conan_reference, package_id)
self._assert_library_exists(package_ref, client.paths)
# Reuse them
conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
files3 = cpp_hello_conan_files("Hello1", "0.1",
["Hello0/0.1@lasote/stable"])
client.current_folder = temp_folder()
client.save(files3)
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.run('install')
client.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, client.current_folder)
self.assertIn("Hello Hello1", client.user_io.out)
self.assertIn("Hello Hello0", client.user_io.out)
new_conanfile = files3[CONANFILE].replace('"language": 0',
'"language": 1')
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.save({CONANFILE: new_conanfile})
client.run('install')
client.run('build')
time.sleep(1)
client.runner(command, client.current_folder)
self.assertIn("Hola Hello1", client.user_io.out)
self.assertIn("Hola Hello0", client.user_io.out)
class PythonDiamondTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def _export_upload(self, name, version=None, deps=None):
files = py_hello_conan_files(name, version, deps)
self.client.save(files, clean_first=True)
self.client.run("export lasote/stable")
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"])
files3 = py_hello_conan_files("Hello4", "0.1",
["Hello3/0.1@lasote/stable"])
self.client.save(files3, clean_first=True)
self.client.run("install .")
self.assertIn("Hello1/0.1@lasote/stable: Build stuff Hello0",
self.client.user_io.out)
self.assertIn("Hello2/0.1@lasote/stable: Build stuff Hello0",
self.client.user_io.out)
self.assertIn(
" ".join([
"Hello3/0.1@lasote/stable: Build stuff Hello1",
"Hello3/0.1@lasote/stable: Build stuff Hello0",
"Hello3/0.1@lasote/stable: Build stuff Hello2",
"Hello3/0.1@lasote/stable: Build stuff Hello0"
]), " ".join(str(self.client.user_io.out).splitlines()))
self.assertNotIn("Project: Build stuff Hello3",
self.client.user_io.out)
self.client.run("build")
self.assertIn("Project: Build stuff Hello3", self.client.user_io.out)
if platform.system() == "Windows":
command = "activate && python main.py"
else:
command = 'bash -c "source activate.sh && python main.py"'
self.client.runner(command, cwd=self.client.current_folder)
self.assertEqual([
'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
'Hello Hello2', 'Hello Hello0'
],
str(self.client.user_io.out).splitlines()[-6:])
def reuse_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1")
client = TestClient()
client.save(files)
client.run("export lasote/stable")
configs = [] # ("gcc", "4.8")]
# Place to add different compilers
if platform.system() == "Windows2":
configs.append(("Visual Studio", "12"))
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.run("install %s --build missing" % str(conan_reference))
# Check compilation ok
package_ids = client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), len(configs))
for package_id in package_ids:
package_ref = PackageReference(conan_reference, package_id)
self._assert_library_exists(package_ref, client.paths)
# Reuse them
conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
files3 = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
client.current_folder = temp_folder()
client.save(files3)
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.run('install')
client.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertIn("Hello Hello1", client.user_io.out)
self.assertIn("Hello Hello0", client.user_io.out)
new_conanfile = files3[CONANFILE].replace('"language": 0', '"language": 1')
for compiler, compiler_version in configs:
client.default_settings(compiler, compiler_version)
client.save({CONANFILE: new_conanfile})
client.run('install')
client.run('build')
time.sleep(1)
client.runner(command, cwd=client.current_folder)
self.assertIn("Hola Hello1", client.user_io.out)
self.assertIn("Hola Hello0", client.user_io.out)
def uploaded_chain_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
files2 = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], static=True)
client.save(files2)
client.run("install . --build missing")
client.run("build .")
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertEqual(['Hello Hello2', 'Hello Hello1', 'Hello Hello0'],
str(client.user_io.out).splitlines()[-3:])
def uploaded_chain_test(self):
self._export_upload("Hello0", "0.1")
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
files2 = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], static=True)
client.save(files2)
client.run("install . --build missing")
client.run("build .")
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, client.current_folder)
self.assertEqual(['Hello Hello2', 'Hello Hello1', 'Hello Hello0'],
str(client.user_io.out).splitlines()[-3:])
def flags_test(self):
client = TestClient()
client.save({"conanfile.py": conanfile_py})
client.run("export lasote/testing")
client.save({
"conanfile.txt": conanfile,
"CMakeLists.txt": cmake
},
clean_first=True)
client.run('install -g cmake')
client.runner("cmake .", cwd=client.current_folder)
cmake_cxx_flags = self._get_line(client.user_io.out, "CMAKE_CXX_FLAGS")
self.assertTrue(cmake_cxx_flags.endswith("MyFlag1 MyFlag2"))
self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2", client.user_io.out)
def reuse_test(self):
self._export_upload("hello0/0.1@lasote/stable")
self._export_upload("hello1/0.1@lasote/stable", 1, [0])
self._export_upload("hello2/0.1@lasote/stable", 2, [0])
self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2])
client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client.save(files3)
os.chdir(client.current_folder)
client.run("install --build missing")
client.run("build")
command = os.sep.join([".", "bin", "say_hello"])
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client.current_folder), ]):
client.runner('go install hello4_main', os.path.join(client.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client.runner(command, os.path.join(client.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
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"), 1)
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)
client.run("upload hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
#
client2 = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client2.save(files3)
client2.run("install --build missing")
command = os.sep.join([".", "bin", "say_hello"])
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client2.current_folder), ]):
client2.runner('go install hello4_main', os.path.join(client2.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client2.runner(command, os.path.join(client2.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self):
self._export_upload("hello0/0.1@lasote/stable")
self._export_upload("hello1/0.1@lasote/stable", 1, [0])
self._export_upload("hello2/0.1@lasote/stable", 2, [0])
self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2])
client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client.save(files3)
os.chdir(client.current_folder)
client.run("install --build missing")
client.run("build")
command = "say_hello" if platform.system() == "Windows" else "./say_hello"
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client.current_folder), ]):
client.runner('go install hello4_main', os.path.join(client.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client.runner(command, os.path.join(client.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
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"), 1)
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)
client.run("upload hello0/0.1@lasote/stable --all")
self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
#
client2 = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio
conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable")
files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go')
client2.save(files3)
client2.run("install --build missing")
command = "say_hello" if platform.system() == "Windows" else "./say_hello"
with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
var_to_add=[('GOPATH', client2.current_folder), ]):
client2.runner('go install hello4_main', os.path.join(client2.current_folder, 'src'))
if platform.system() == "Windows":
command = "hello4_main"
else:
command = './hello4_main'
client2.runner(command, os.path.join(client2.current_folder, 'bin'))
self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'],
str(client2.user_io.out).splitlines()[-6:])
class PythonDiamondTest(unittest.TestCase):
def setUp(self):
self.client = TestClient()
def _export_upload(self, name, version=None, deps=None):
files = py_hello_conan_files(name, version, deps)
self.client.save(files, clean_first=True)
self.client.run("export lasote/stable")
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"])
files3 = py_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"])
self.client.save(files3, clean_first=True)
self.client.run("install .")
self.assertIn("Hello1/0.1@lasote/stable: Build stuff Hello0", self.client.user_io.out)
self.assertIn("Hello2/0.1@lasote/stable: Build stuff Hello0", self.client.user_io.out)
self.assertIn(
" ".join(
[
"Hello3/0.1@lasote/stable: Build stuff Hello1",
"Hello3/0.1@lasote/stable: Build stuff Hello0",
"Hello3/0.1@lasote/stable: Build stuff Hello2",
"Hello3/0.1@lasote/stable: Build stuff Hello0",
]
),
" ".join(str(self.client.user_io.out).splitlines()),
)
if platform.system() == "Windows":
command = "activate && python main.py"
else:
command = 'bash -c "source activate.sh && python main.py"'
self.client.runner(command, cwd=self.client.current_folder)
self.assertEqual(
["Hello Hello4", "Hello Hello3", "Hello Hello1", "Hello Hello0", "Hello Hello2", "Hello Hello0"],
str(self.client.user_io.out).splitlines()[-6:],
)
def _build(self, cmd, static, pure_c, use_cmake, lang):
client = TestClient()
dll_export = client.default_compiler_visual_studio and not static
files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export, pure_c=pure_c, use_cmake=use_cmake)
client.save(files)
client.run(cmd)
client.run("build")
ld_path = "LD_LIBRARY_PATH=$(pwd)" if not static and not platform.system() == "Windows" else ""
command = os.sep.join([".", "bin", "say_hello"])
client.runner("%s %s" % (ld_path, command), cwd=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 cmake_multi_test(self):
client = TestClient()
requires = ""
includes = ""
other_calls = ""
for name in ["Hello0", "Hello1", "Hello2"]:
client.save(
{
"conanfile.py":
conanfile.format(name=name, requires=requires),
"CMakeLists.txt":
cmake.format(name=name),
"main.cpp":
main.format(name=name),
"hello.cpp":
hello_cpp.format(
name=name, includes=includes, other_calls=other_calls),
"hello%s.h" % name:
hello_h.format(name=name)
},
clean_first=True)
requires = "%s/0.1@memsharded/testing" % name
includes = '#include "hello%s.h"' % name
other_calls = "hello%s();" % name
if name != "Hello2":
client.run("export memsharded/testing")
client.run('install . --build missing')
client.run("build")
cmd = os.sep.join([".", "bin", "say_hello"])
client.runner(cmd, cwd=client.current_folder)
self.assertIn(
"Hello Release Hello2 Hello Release Hello1 Hello Release Hello0",
" ".join(str(client.user_io.out).splitlines()))
client.runner(cmd + "_d", cwd=client.current_folder)
self.assertIn(
"Hello Debug Hello2 Hello Debug Hello1 Hello Debug Hello0",
" ".join(str(client.user_io.out).splitlines()))
def collect_libs_test(self):
conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
files = cpp_hello_conan_files("Hello0", "0.1", collect_libs=True)
client = TestClient()
client.save(files)
client.run("export lasote/stable")
client.run("install %s --build missing" % str(conan_reference))
# Check compilation ok
package_ids = client.paths.conan_packages(conan_reference)
self.assertEquals(len(package_ids), 1)
# Reuse them
conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
files3 = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"],
collect_libs=True)
# reusing the binary already in cache
client.save(files3, clean_first=True)
client.run('install')
client.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertIn("Hello Hello1", client.user_io.out)
self.assertIn("Hello Hello0", client.user_io.out)
# rebuilding the binary in cache
client.run('remove "*" -p -f')
client.run('install --build')
client.run('build')
command = os.sep.join([".", "bin", "say_hello"])
client.runner(command, cwd=client.current_folder)
self.assertIn("Hello Hello1", client.user_io.out)
self.assertIn("Hello Hello0", client.user_io.out)
def complete_build_flow_test(self):
"""In local user folder"""
files = cpp_hello_conan_files("Hello0", "0.1")
client = TestClient()
client.save(files)
command = "say_hello" if platform.system() == "Windows" else "./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)]:
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 _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):
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=[("lasote", "mypass")]) # Mocked userio
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
local_install = """ def imports(self):
self.copy("*.dll", "", "bin")
self.copy("*.dylib", "", "lib")
"""
copy_dlls_conanfile = files3[CONANFILE] + local_install
files3[CONANFILE] = copy_dlls_conanfile
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 = "say_hello" if platform.system() == "Windows" else "./say_hello"
client.runner(command, 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=[("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
copy_dlls_conanfile = files2[CONANFILE] + local_install
files2[CONANFILE] = copy_dlls_conanfile
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, 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)
copy_dlls_conanfile = files3[CONANFILE] + local_install
files3[CONANFILE] = copy_dlls_conanfile
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, client2.current_folder)
self.assertEqual(['Hola Hello3', 'Hola Hello1',
'Hola Hello0', 'Hola Hello2', 'Hola #'],
str(client2.user_io.out).splitlines()[-5:])
def _diamond_test(self, install="install", use_cmake=True, cmake_targets=False):
self._export_upload("Hello0", "0.1", use_cmake=use_cmake, cmake_targets=cmake_targets)
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
self._export_upload("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
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, cmake_targets=cmake_targets)
# 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)
if use_cmake:
if cmake_targets:
self.assertIn("Conan: Using cmake targets configuration", client.user_io.out)
self.assertNotIn("Conan: Using cmake global configuration", client.user_io.out)
else:
self.assertIn("Conan: Using cmake global configuration", client.user_io.out)
self.assertNotIn("Conan: Using cmake targets configuration", client.user_io.out)
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, cmake_targets=cmake_targets)
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, cmake_targets=cmake_targets)
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, cmake_targets=cmake_targets)
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 _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 _diamond_test(self, install="install", use_cmake=True, cmake_targets=False):
self._export_upload("Hello0", "0.1", use_cmake=use_cmake, cmake_targets=cmake_targets)
self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
self._export_upload("Hello3", "0.1", ["Hello1/0.1@lasote/stable",
"Hello2/0.1@lasote/stable"], use_cmake=use_cmake,
cmake_targets=cmake_targets)
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}, path_with_spaces=use_cmake)
files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake, cmake_targets=cmake_targets)
# 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)
if use_cmake:
if cmake_targets:
self.assertIn("Conan: Using cmake targets configuration", client.user_io.out)
self.assertNotIn("Conan: Using cmake global configuration", client.user_io.out)
else:
self.assertIn("Conan: Using cmake global configuration", client.user_io.out)
self.assertNotIn("Conan: Using cmake targets configuration", client.user_io.out)
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, cmake_targets=cmake_targets)
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")]}, path_with_spaces=use_cmake)
files3 = cpp_hello_conan_files("Hello4", "0.1", ["Hello3/0.1@lasote/stable"],
use_cmake=use_cmake, cmake_targets=cmake_targets)
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, cmake_targets=cmake_targets)
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):
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 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:])
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")]}) # Mocked userio
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)
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=[("lasote", "mypass")]) # Mocked userio
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, 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, 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=[("lasote", "mypass")]) # Mocked userio
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, 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, 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):
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")]}) # Mocked userio
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)
