def build(tester, 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 "") if platform.system() == "Darwin": ld_path += ' DYLD_LIBRARY_PATH="%s"' % os.path.join( client.current_folder, 'lib') 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" tester.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)) tester.assertTrue(conan_info.full_options.language == lang) if static: tester.assertTrue(conan_info.full_options.static) else: tester.assertFalse(conan_info.full_options.static)
def targets_own_flags_test(self): client = TestClient() client.save({ "conanfile.py": conanfile_py.replace( 'version = "0.1"', 'version = "0.1"\n' ' settings = "compiler"') }) 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)") client.save( { "conanfile.txt": conanfile, "CMakeLists.txt": cmake_targets }, clean_first=True) client.run('install -g cmake') client.runner("cmake . -DCONAN_CXX_FLAGS=CmdCXXFlag", 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("CmdCXXFlag", cmake_cxx_flags) self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2 CmdCXXFlag", client.user_io.out) self.assertIn( "HELLO_CXX_FLAGS=MyFlag1;MyFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.user_io.out)
def targets_flags_test(self): client = TestClient() client.save({"conanfile.py": conanfile_py}) 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(HELLO_DEFINES CONAN_PKG::Hello" " INTERFACE_COMPILE_DEFINITIONS)") client.save( { "conanfile.txt": conanfile, "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.out, "CMAKE_CXX_FLAGS") self.assertNotIn("My", cmake_cxx_flags) self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2", client.out) self.assertIn( "HELLO_CXX_FLAGS=-load;C:\some\path;MyFlag1;MyFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;" "$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out) self.assertIn( 'HELLO_DEFINES=MY_DEF=My" \string;MY_DEF2=My${} other \string;', client.out)
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:RelWithDebInfo>:;>;$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.user_io.out) self.assertIn( "CHAT_CXX_FLAGS=MyChatFlag1;MyChatFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", 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" "get_target_property(HELLO_DEFINES CONAN_PKG::Hello" " INTERFACE_COMPILE_DEFINITIONS)") client.save({"conanfile.txt": conanfile.replace("Hello", "Chat"), "CMakeLists.txt": cmake_targets}, clean_first=True) client.run('install . -g cmake') 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=-load;C:\some\path;MyFlag1;MyFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;" "$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out) self.assertIn("CHAT_CXX_FLAGS=MyChatFlag1;MyChatFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;" "$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out) self.assertIn('HELLO_DEFINES=MY_DEF=My" \string;MY_DEF2=My${} other \string;', client.out)
def transitive_targets_flags_test(self): client = TestClient() client.save({"conanfile.py": conanfile_py}) client.run("export . lasote/testing") client.save({"conanfile.py": chatconanfile_py}, clean_first=True) client.run("export . lasote/testing") cmake_targets = cmake.replace("conan_basic_setup()", "conan_basic_setup(TARGETS)\n" "get_target_property(HELLO_FLAGS CONAN_PKG::Hello" " INTERFACE_COMPILE_OPTIONS)\n" "get_target_property(CHAT_FLAGS CONAN_PKG::Chat" " INTERFACE_COMPILE_OPTIONS)\n" "get_target_property(HELLO_DEFINES CONAN_PKG::Hello" " INTERFACE_COMPILE_DEFINITIONS)") client.save({"conanfile.txt": conanfile.replace("Hello", "Chat"), "CMakeLists.txt": cmake_targets}, clean_first=True) client.run('install . -g cmake') generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else "" client.runner("cmake . %s" % generator, 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=-load;C:\some\path;MyFlag1;MyFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;" "$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out) self.assertIn("CHAT_CXX_FLAGS=MyChatFlag1;MyChatFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;" "$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", client.out) self.assertIn('HELLO_DEFINES=MY_DEF=My" \string;MY_DEF2=My${} other \string;', client.out)
def 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} files_without_conanfile = set(files.keys()) - set(["conanfile.py"]) 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_without_conanfile) # 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_without_conanfile) # 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, files_without_conanfile) 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 test_base(self): # meson > py 3.4 if sys.version_info[0] < 3 or sys.version_info[1] < 5: return client = TestClient(path_with_spaces=False) self._export(client, "LIB_C", []) self._export(client, "LIB_B", ["LIB_C"]) self._export(client, "LIB_B2", []) self._export(client, "LIB_A", ["LIB_B", "LIB_B2"]) consumer = """ from conans import ConanFile, Meson class ConanFileToolsTest(ConanFile): generators = "pkg_config" requires = "LIB_A/0.1@conan/stable" settings = "os", "compiler", "build_type" def build(self): meson = Meson(self) meson.configure() meson.build() """ meson_build = """ project('conan_hello', 'c') liba = dependency('LIB_A', version : '>=0') executable('demo', 'main.c', dependencies: [liba]) """ main_c = """ #include "helloLIB_A.h" int main(){ helloLIB_A(); } """ client.save({CONANFILE: consumer, "meson.build": meson_build, "main.c": main_c}, clean_first=True) mkdir(os.path.join(client.current_folder, "build")) client.current_folder = os.path.join(client.current_folder, "build") client.run("install .. --build") if six.PY2: # Meson only available return client.run("build .. --source-folder ..") if platform.system() == "Windows": command = "demo" else: command = './demo' client.runner(command, cwd=os.path.join(client.current_folder)) self.assertEqual(['Hello LIB_A', 'Hello LIB_B', 'Hello LIB_C', 'Hello LIB_B2'], str(client.user_io.out).splitlines()[-4:])
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 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)
class PremakeGeneratorTest(unittest.TestCase): def setUp(self): self.client = TestClient() conanfile = textwrap.dedent(""" [generators] premake """) premake = textwrap.dedent(""" include("conanbuildinfo.premake.lua") workspace("example") conan_basic_setup() project("example") kind "ConsoleApp" language "C++" targetdir = "bin/%{cfg.buildcfg}" filter "configurations:Debug" defines { "DEBUG" } symbols "On" filter "configurations:Release" defines { "NDEBUG" } optimize "On" """) self.client.save({ "conanfile.txt": conanfile, "premake5.lua": premake }, clean_first=True) def test_generate_basic_setup_release(self): self.client.run( "install . -s build_type=Release -s arch=x86_64 --build missing") with chdir(self.client.current_folder): self.client.runner("premake5 vs2017") sln_content = load( os.path.join(self.client.current_folder, "example.sln")) self.assertIn("Release|x64", sln_content) self.assertNotIn("Debug|Win32", sln_content) self.assertNotIn("Debug|x64", sln_content) def test_generate_basic_setup_debug_32bit(self): self.client.run( "install . -s build_type=Debug -s arch=x86 --build missing") with chdir(self.client.current_folder): self.client.runner("premake5 vs2017") sln_content = load( os.path.join(self.client.current_folder, "example.sln")) self.assertIn("Debug|Win32", sln_content) self.assertNotIn("Release|Win32", sln_content) self.assertNotIn("Release|x64", sln_content)
def test_basic(self): if conan_version < "1.3.0": # Avoid 0.30.0 return if platform.system() != "Windows" or pyver < "3.6": return client = TestClient() client.runner( "git clone https://github.com/memsharded/conan-scons-template .", cwd=client.current_folder) client.run("create . user/testing") self.assertIn("Hello World Release!", client.out) client.run("create . user/testing -s build_type=Debug") self.assertIn("Hello World Debug!", client.out)
def cmake_multi_test(self): if platform.system() not in ["Windows", "Darwin"]: return client = TestClient() client.save(multi_config_files("Hello0", test=False), clean_first=True) client.run("export . lasote/testing") client.run("install Hello0/0.1@lasote/testing --build=missing") client.save(package_files("Hello1", ["Hello0"]), clean_first=True) client.run("export . lasote/testing") 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 = '' # 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) client.runner('cmake . -G "%s"' % generator, cwd=client.current_folder) self.assertNotIn("WARN: Unknown compiler '", client.user_io.out) self.assertNotIn("', skipping the version check...", client.user_io.out) client.runner('cmake --build . --config Debug', cwd=client.current_folder) hello_comand = os.sep.join([".", "Debug", "say_hello"]) client.runner(hello_comand, cwd=client.current_folder) self.assertIn("Hello0:Debug Hello1:Debug", client.user_io.out) self.assertIn("Hello0Def:Debug Hello1Def:Debug", client.user_io.out) self.assertIn("Hello Debug Hello1", client.user_io.out) self.assertIn("Hello Debug Hello0", client.user_io.out) client.runner('cmake --build . --config Release', cwd=client.current_folder) hello_comand = os.sep.join([".", "Release", "say_hello"]) client.runner(hello_comand, cwd=client.current_folder) self.assertIn("Hello0:Release Hello1:Release", client.user_io.out) self.assertIn("Hello0Def:Release Hello1Def:Release", client.user_io.out) self.assertIn("Hello Release Hello1", client.user_io.out) self.assertIn("Hello Release Hello0", client.user_io.out) if cmake_file == cmake_targets: self.assertIn("Conan: Using cmake targets configuration", client.user_io.out) else: self.assertIn("Conan: Using cmake global configuration", client.user_io.out)
class SCMFolderObsoleteTest(unittest.TestCase): conanfile = textwrap.dedent("""\ from conans import ConanFile, tools class Pkg(ConanFile): scm = {"type": "git", "url": "auto", "revision": "auto"} def build(self): content = tools.load("file.txt") self.output.info(">>>> I'm {}/{}@{}/{}".format(self.name, self.version, self.user, self.channel)) self.output.info(">>>> content: {} ".format(content)) """) def setUp(self): self.reference = "pkg/v1@user/channel" self.t = TestClient(path_with_spaces=False) # Create pkg/v1 url, _ = create_local_git_repo(files={ 'conanfile.py': self.conanfile, 'file.txt': self.reference }, folder=self.t.current_folder) self.t.runner('git remote add origin {}'.format(url), cwd=self.t.current_folder) self.t.run("create . {}".format(self.reference)) self.assertIn(">>>> I'm {}".format(self.reference), self.t.out) self.assertIn(">>>> content: {}".format(self.reference), self.t.out) # Change something in the local folder self.new_content = "Updated in the local folder!" self.t.save({'file.txt': self.new_content}) def test_create_workflow(self): """ Use the 'create' command, local changes are reflected in the cache """ self.t.run("create . {}".format(self.reference)) self.assertIn(">>>> I'm {}".format(self.reference), self.t.out) self.assertIn(">>>> content: {}".format(self.new_content), self.t.out) def test_install_workflow(self): """ Using the install command, it won't be taken into account """ t2 = TestClient(base_folder=self.t.base_folder) t2.save({'conanfile.txt': "[requires]\n{}".format(self.reference)}) ref = ConanFileReference.loads(self.reference) t2.run("install . --build={}".format(ref.name)) self.assertNotIn(self.new_content, t2.out) self.assertIn(">>>> I'm {}".format(self.reference), self.t.out) self.assertIn(">>>> content: {}".format(self.reference), self.t.out)
def cmake_multi_find_test(self): if platform.system() not in ["Windows", "Linux"]: return client = TestClient() conanfile = """from conans import ConanFile, CMake class HelloConan(ConanFile): name = "Hello" version = "0.1" settings = "build_type" exports = '*' def package(self): self.copy(pattern="*", src="%s" % self.settings.build_type) """ client.save({"conanfile.py": conanfile, "Debug/FindHello.cmake": 'message(STATUS "FIND HELLO DEBUG!")', "Release/FindHello.cmake": 'message(STATUS "FIND HELLO RELEASE!")'}) client.run("export . lasote/testing") cmake = """set(CMAKE_CXX_COMPILER_WORKS 1) project(MyHello CXX) cmake_minimum_required(VERSION 2.8) include(conanbuildinfo_multi.cmake) conan_basic_setup() find_package(Hello) """ conanfile = """from conans import ConanFile, CMake class HelloConan(ConanFile): requires = "Hello/0.1@lasote/testing" settings = "build_type" generators = "cmake_multi" """ client.save({"conanfile.py": conanfile, "CMakeLists.txt": cmake}, clean_first=True) client.run("install . --build=missing ") client.run("install . -s build_type=Debug --build=missing ") with tools.remove_from_path("sh"): generator = "MinGW Makefiles" if platform.system() == "Windows" else "Unix Makefiles" client.runner('cmake . -G "%s" -DCMAKE_BUILD_TYPE=Debug' % generator, cwd=client.current_folder) self.assertIn("FIND HELLO DEBUG!", client.user_io.out) self.assertNotIn("FIND HELLO RELEASE!", client.user_io.out) client.init_dynamic_vars() # to reset output client.runner('cmake . -G "%s" -DCMAKE_BUILD_TYPE=Release' % generator, cwd=client.current_folder) self.assertIn("FIND HELLO RELEASE!", client.user_io.out) self.assertNotIn("FIND HELLO DEBUG!", client.user_io.out)
def cmake_multi_find_test(self): if platform.system() not in ["Windows", "Linux"]: return client = TestClient() conanfile = """from conans import ConanFile, CMake class HelloConan(ConanFile): name = "Hello" version = "0.1" settings = "build_type" exports = '*' def package(self): self.copy(pattern="*", src="%s" % self.settings.build_type) """ client.save({"conanfile.py": conanfile, "Debug/FindHello.cmake": 'message(STATUS "FIND HELLO DEBUG!")', "Release/FindHello.cmake": 'message(STATUS "FIND HELLO RELEASE!")'}) client.run("export . lasote/testing") cmake = """set(CMAKE_CXX_COMPILER_WORKS 1) project(MyHello CXX) cmake_minimum_required(VERSION 2.8) include(conanbuildinfo_multi.cmake) conan_basic_setup() find_package(Hello) """ conanfile = """from conans import ConanFile, CMake class HelloConan(ConanFile): requires = "Hello/0.1@lasote/testing" settings = "build_type" generators = "cmake_multi" """ client.save({"conanfile.py": conanfile, "CMakeLists.txt": cmake}, clean_first=True) client.run("install . --build=missing ") client.run("install . -s build_type=Debug --build=missing ") with clean_sh_from_path(): generator = "MinGW Makefiles" if platform.system() == "Windows" else "Unix Makefiles" client.runner('cmake . -G "%s" -DCMAKE_BUILD_TYPE=Debug' % generator, cwd=client.current_folder) self.assertIn("FIND HELLO DEBUG!", client.user_io.out) self.assertNotIn("FIND HELLO RELEASE!", client.user_io.out) client.init_dynamic_vars() # to reset output client.runner('cmake . -G "%s" -DCMAKE_BUILD_TYPE=Release' % generator, cwd=client.current_folder) self.assertIn("FIND HELLO RELEASE!", client.user_io.out) self.assertNotIn("FIND HELLO DEBUG!", 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 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 test_conanfile_removed(self): # https://github.com/conan-io/conan/issues/4013 conanfile = """from conans import ConanFile class ScmtestConan(ConanFile): scm = { "type": "git", "url": "auto", "revision": "auto" } """ client = TestClient() client.save({"conanfile.py": conanfile}) client.runner("git init .", cwd=client.current_folder) client.run("source .") self.assertEqual(sorted(["conanfile.py", '.git']), sorted(os.listdir(client.current_folder)))
def transitive_flags_test(self): client = TestClient() client.save({"conanfile.py": conanfile_py}) client.run("export . lasote/testing") client.save({"conanfile.py": chatconanfile_py}, clean_first=True) client.run("export . lasote/testing") client.save({"conanfile.txt": conanfile.replace("Hello", "Chat"), "CMakeLists.txt": cmake}, clean_first=True) client.run('install . -g cmake') generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else "" client.runner("cmake . %s" % generator, 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 MyChatFlag1 MyChatFlag2")) self.assertIn("CONAN_CXX_FLAGS=MyFlag1 MyFlag2 MyChatFlag1 MyChatFlag2", client.user_io.out)
def flags_test(self): client = TestClient() client.save({"conanfile.py": conanfile_py}) client.run("export . lasote/testing") client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmake}, clean_first=True) client.run('install . -g cmake') 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.out) self.assertIn("CMAKE_C_FLAGS= -load C:\some\path", client.out) self.assertIn("CONAN_C_FLAGS=-load C:\some\path ", client.out) self.assertIn('CONAN_DEFINES_HELLO=-DMY_DEF=My" \string;-DMY_DEF2=My${} other \string', client.out)
def reuse_test(self): self._export_upload("hello0/0.1@lasote/stable") self._export_upload("hello1/0.1@lasote/stable", 1, [0]) self._export_upload("hello2/0.1@lasote/stable", 2, [0]) self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2]) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) 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) 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', cwd=os.path.join(client.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client.runner(command, cwd=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={"default": [("lasote", "mypass")]}) 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', cwd=os.path.join(client2.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client2.runner(command, cwd=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={"default": [("lasote", "mypass")]}) 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) client.run("install --build missing") client.run("build .") with CustomEnvPath(paths_to_add=['$GOPATH/bin'], var_to_add=[('GOPATH', client.current_folder), ]): client.runner('go install hello4_main', cwd=os.path.join(client.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client.runner(command, cwd=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={"default": [("lasote", "mypass")]}) 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', cwd=os.path.join(client2.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client2.runner(command, cwd=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 targets_flags_test(self): client = TestClient() client.save({"conanfile.py": conanfile_py}) 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)") client.save({"conanfile.txt": conanfile, "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", client.user_io.out) self.assertIn("HELLO_CXX_FLAGS=MyFlag1;MyFlag2;" "$<$<CONFIG:Release>:;>;$<$<CONFIG:RelWithDebInfo>:;>;$<$<CONFIG:MinSizeRel>:;>;$<$<CONFIG:Debug>:;>", 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 cmake_multi_test(self): client = TestClient() deps = None for name in ["Hello0", "Hello1", "Hello2"]: files = multi_config_files(name, test=False, deps=deps) client.save(files, clean_first=True) deps = [name] if name != "Hello2": client.run("export lasote/stable") 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 cmake_multi_test(self): client = TestClient() deps = None for name in ["Hello0", "Hello1", "Hello2"]: files = multi_config_files(name, test=False, deps=deps) client.save(files, clean_first=True) deps = [name] if name != "Hello2": client.run("export . lasote/stable") 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 setUp(self): # Create a sample SVN repository conanfile = textwrap.dedent(""" from conans import ConanFile, tools class Lib(ConanFile): scm = {"type": "svn", "url": "auto", "revision": "auto"} """) files = { 'trunk/level0.txt': "level0", 'trunk/level1/level1.txt': "level1", 'trunk/level1/conanfile.py': "invalid content", 'tags/sentinel': "" } self.project_url, rev = self.create_project(files=files) self.project_url = self.project_url.replace(" ", "%20") # Modify the recipe file and commit in trunk t = TestClient() t.runner('svn co "{url}/trunk" "{path}"'.format(url=self.project_url, path=t.current_folder)) t.save({"level1/conanfile.py": conanfile}) t.runner('svn commit -m "created the conanfile"', cwd=t.current_folder) # Create a tag for 'release 1.0' t.runner('svn copy {url}/trunk {url}/tags/release-1.0' ' -m "Release 1.0"'.format(url=self.project_url), cwd=t.current_folder)
def test_skip_flag(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 --build') client.runner("cmake .", cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.user_io.out) self.assertIn("Build files have been written", client.user_io.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmake.replace("TARGETS SKIP_RPATH", "SKIP_RPATH")}, clean_first=True) client.run('install -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.user_io.out) self.assertIn("Build files have been written", client.user_io.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmake.replace("SKIP_RPATH", "")}, clean_first=True) client.run('install -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertIn("Conan: Adjusting default RPATHs Conan policies", client.user_io.out) self.assertIn("Build files have been written", client.user_io.out)
def test_skip_flag(self): for way_to_skip in ("SKIP_RPATH", "KEEP_RPATHS"): client = TestClient() client.save({"conanfile.py": conanfile_py}) client.run("export . lasote/testing") client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmake % way_to_skip}, clean_first=True) client.run('install . -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) if way_to_skip == "SKIP_RPATH": self.assertIn("Conan: SKIP_RPATH is deprecated, it has been renamed to KEEP_RPATHS", client.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": (cmake % way_to_skip).replace("TARGETS", "")}, clean_first=True) client.run('install . -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": (cmake % "").replace("FATAL_ERROR", "INFO")}, clean_first=True) if platform.system() == "Darwin": client.run('install . -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) self.assertIn("RPath was skipped", client.out)
def reuse_test(self): self._export_upload("Hello0", "0.1") self._export_upload("Hello1", "0.1", deps=[("Hello0/0.1@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"]) client.save(files3) client.run('install . --build missing') client.run('build .') # assert Hello3 only depends on Hello2, and Hello1 build_info_cmake = load(os.path.join(client.current_folder, BUILD_INFO_CMAKE)) # 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'], str(client.user_io.out).splitlines()[-3:]) conan_info = ConanInfo.loads(load(os.path.join(client.current_folder, CONANINFO))) 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) client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) client2.save(files3) client2.run("install .") 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("libhello1.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'], str(client2.user_io.out).splitlines()[-3:]) # Issue 79, fixing private deps from current project files3 = cpp_hello_conan_files("Hello3", "0.2", ["Hello1/0.1@lasote/stable", ("Hello0/0.1@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("libhello1.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 Hello0'], str(client2.user_io.out).splitlines()[-4:])
def test_skip_flag(self): for way_to_skip in ("SKIP_RPATH", "KEEP_RPATHS"): client = TestClient() client.save({"conanfile.py": conanfile_py}) client.run("export . lasote/testing") client.save({"conanfile.txt": conanfile, "CMakeLists.txt": cmake % way_to_skip}, clean_first=True) client.run('install . -g cmake --build') generator = '-G "Visual Studio 15 Win64"' if platform.system() == "Windows" else "" client.runner("cmake . %s" % generator, cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) if way_to_skip == "SKIP_RPATH": self.assertIn("Conan: SKIP_RPATH is deprecated, it has been renamed to KEEP_RPATHS", client.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": (cmake % way_to_skip).replace("TARGETS", "")}, clean_first=True) client.run('install . -g cmake --build') client.runner("cmake . %s" % generator, cwd=client.current_folder) self.assertNotIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) client.save({"conanfile.txt": conanfile, "CMakeLists.txt": (cmake % "").replace("FATAL_ERROR", "INFO")}, clean_first=True) if platform.system() == "Darwin": client.run('install . -g cmake --build') client.runner("cmake .", cwd=client.current_folder) self.assertIn("Conan: Adjusting default RPATHs Conan policies", client.out) self.assertIn("Build files have been written", client.out) self.assertIn("RPath was skipped", client.out)
def conditional_parameter_expansion_test(self): # https://github.com/conan-io/conan/issues/3911 client = TestClient() client.save({"conanfile.txt": ""}) client.run("profile new default --detect") client.run("profile update env.PREPEND_VAR=[1,2,three] default") client.run("install . -g virtualenv") activate = load(os.path.join(client.current_folder, "activate.sh")) self.assertIn( "PREPEND_VAR=\"1\":\"2\":\"three\"${PREPEND_VAR+:$PREPEND_VAR}", activate) client.runner("%s -c 'source \"%s/activate.sh\" && env'" % (OSInfo.bash_path(), client.current_folder)) # Check no trailing path separator ":" self.assertNotIn("PREPEND_VAR=1:2:three:", client.out) self.assertIn("PREPEND_VAR=1:2:three", client.out) # Check correct value # Check old value is preserved client.runner( "%s -c 'export PREPEND_VAR=kk && source \"%s/activate.sh\" && env'" % (OSInfo.bash_path(), client.current_folder)) self.assertIn("PREPEND_VAR=1:2:three:kk", client.out)
class CMakeMultiSyntaxTest(unittest.TestCase): def setUp(self): self.client = TestClient() cmakelists = textwrap.dedent(""" cmake_minimum_required(VERSION 3.12) include(${CMAKE_BINARY_DIR}/conanbuildinfo_multi.cmake) conan_basic_setup(NO_OUTPUT_DIRS) """) self.client.save({ "conanfile.txt": "[generators]\ncmake_multi\ncmake", "CMakeLists.txt": cmakelists }) self.client.run("install .") self.client.run("install . -s build_type=Debug") def conan_basic_setup_interface_test(self): """ Check conan_basic_setup() interface is the same one for cmake and cmake_multi generators """ conanbuildinfo = load( os.path.join(self.client.current_folder, "conanbuildinfo.cmake")) conanbuildinfo_multi = load( os.path.join(self.client.current_folder, "conanbuildinfo_multi.cmake")) expected = "set(options TARGETS NO_OUTPUT_DIRS SKIP_RPATH KEEP_RPATHS SKIP_STD SKIP_FPIC)" self.assertIn(expected, conanbuildinfo) self.assertIn(expected, conanbuildinfo_multi) def conan_basic_setup_output_dirs_warning_test(self): """ Check warning when suing NO_OUTPUT_DIRS """ with chdir(self.client.current_folder): self.client.runner("cmake .") self.assertTrue("CMake Warning at conanbuildinfo_multi.cmake", self.client.out) self.assertTrue( "Conan: NO_OUTPUT_DIRS has no effect with cmake_multi generator", self.client.out)
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 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 test_delegated_python_code(self): client = TestClient() code_file = """ from conans.tools import Git from conans import ConanFile def get_commit(repo_path): git = Git(repo_path) return git.get_commit() class MyLib(ConanFile): pass """ client.save({"conanfile.py": code_file}) client.run("export . tool/0.1@user/testing") conanfile = """import os from conans import ConanFile, python_requires from conans.tools import load tool = python_requires("tool/0.1@user/testing") class MyLib(ConanFile): scm = {'type': 'git', 'url': '%s', 'revision': tool.get_commit(os.path.dirname(__file__))} def build(self): self.output.info("File: {}".format(load("file.txt"))) """ % client.current_folder.replace("\\", "/") client.save({"conanfile.py": conanfile, "file.txt": "hello!"}) path, commit = create_local_git_repo(folder=client.current_folder) client.runner('git remote add origin "%s"' % path.replace("\\", "/"), cwd=path) client.run("export . pkg/0.1@user/channel") ref = ConanFileReference.loads("pkg/0.1@user/channel") exported_conanfile = client.cache.package_layout(ref).conanfile() content = load(exported_conanfile) self.assertIn(commit, content)
class RemoveCredentials(unittest.TestCase): conanfile = textwrap.dedent("""\ from conans import ConanFile class Lib(ConanFile): scm = {"type": "git", "url": "auto"} """) def setUp(self): self.ref = ConanFileReference.loads("lib/1.0@lasote/testing") self.path, _ = create_local_git_repo({"conanfile.py": self.conanfile}) self.client = TestClient() self.client.current_folder = self.path self.client.runner("git remote add origin https://url.to.be.sustituted", cwd=self.path) def test_https(self): expected_url = 'https://myrepo.com.git' origin_url = 'https://*****:*****@myrepo.com.git' self.client.runner("git remote set-url origin {}".format(origin_url), cwd=self.path) self.client.run("export . {}".format(self.ref)) self.assertIn("Repo origin deduced by 'auto': {}".format(expected_url), self.client.out)
def test(self, install=None, use_cmake=True, cmake_targets=False): install = install or "install ." if not use_cmake and platform.system() == "SunOS": return # If is using sun-cc the gcc generator doesn't work 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.test_obj.assertIn("Conan: Using cmake targets configuration", client.user_io.out) self.test_obj.assertNotIn("Conan: Using cmake global configuration", client.user_io.out) else: self.test_obj.assertIn("Conan: Using cmake global configuration", client.user_io.out) self.test_obj.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.test_obj.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.test_obj.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.test_obj.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello1/0.1@lasote/stable --all") self.test_obj.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello2/0.1@lasote/stable --all") self.test_obj.assertEqual(str(client.user_io.out).count("Uploading package"), 2) client.run("upload Hello0/0.1@lasote/stable --all") self.test_obj.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.test_obj.assertNotIn("libhello0.a", client2.user_io.out) self.test_obj.assertNotIn("libhello1.a", client2.user_io.out) self.test_obj.assertNotIn("libhello2.a", client2.user_io.out) self.test_obj.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.test_obj.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.test_obj.assertNotIn("libhello0.a", client2.user_io.out) self.test_obj.assertNotIn("libhello1.a", client2.user_io.out) self.test_obj.assertNotIn("libhello2.a", client2.user_io.out) self.test_obj.assertNotIn("libhello3.a", client2.user_io.out) client2.runner(command, cwd=client2.current_folder) self.test_obj.assertEqual(['Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2', 'Hola Hello0'], str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self, complete_urls): test_server = TestServer(complete_urls=complete_urls) self.servers = {"default": test_server} 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", 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' file: 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)) self.assertIn("Compressing recipe", str(self.client.user_io.out)) # Not needed to tgz again self.client.run("upload %s" % str(conan_reference)) self.assertNotIn("Compressing exported", str(self.client.user_io.out)) # 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]))) self.assertIn("Compressing package", str(self.client.user_io.out)) # Not needed to tgz again self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) self.assertNotIn("Compressing package", str(self.client.user_io.out)) # If we install the package again will be removed and re tgz self.client.run("install %s --build missing" % str(conan_reference)) # Upload package self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) self.assertNotIn("Compressing package", str(self.client.user_io.out)) # 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")]}) 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 ConfigInstallTest(unittest.TestCase): def setUp(self): self.client = TestClient() registry_path = self.client.client_cache.registry save(registry_path, """my-repo-2 https://myrepo2.com True conan-center https://conan-center.com MyPkg/0.1@user/channel my-repo-2 Other/1.2@user/channel conan-center """) save(os.path.join(self.client.client_cache.profiles_path, "default"), "#default profile empty") save(os.path.join(self.client.client_cache.profiles_path, "linux"), "#empty linux profile") self.old_env = dict(os.environ) def tearDown(self): os.environ.clear() os.environ.update(self.old_env) def _create_profile_folder(self, folder=None): folder = folder or temp_folder(path_with_spaces=False) save_files(folder, {"settings.yml": settings_yml, "remotes.txt": remotes, "profiles/linux": linux_profile, "profiles/windows": win_profile, "config/conan.conf": conan_conf, "pylintrc": "#Custom pylint", "python/myfuncs.py": myfuncpy, "python/__init__.py": ""}) return folder def _create_zip(self, zippath=None): folder = self._create_profile_folder() zippath = zippath or os.path.join(folder, "myconfig.zip") zipdir(folder, zippath) return zippath def _check(self, install_path): settings_path = self.client.client_cache.settings_path self.assertEqual(load(settings_path).splitlines(), settings_yml.splitlines()) registry_path = self.client.client_cache.registry registry = RemoteRegistry(registry_path, TestBufferConanOutput()) self.assertEqual(registry.remotes, [Remote("myrepo1", "https://myrepourl.net", False), Remote("my-repo-2", "https://myrepo2.com", True), ]) self.assertEqual(registry.refs, {"MyPkg/0.1@user/channel": "my-repo-2"}) self.assertEqual(sorted(os.listdir(self.client.client_cache.profiles_path)), sorted(["default", "linux", "windows"])) self.assertEqual(load(os.path.join(self.client.client_cache.profiles_path, "linux")).splitlines(), linux_profile.splitlines()) self.assertEqual(load(os.path.join(self.client.client_cache.profiles_path, "windows")).splitlines(), win_profile.splitlines()) conan_conf = ConanClientConfigParser(self.client.client_cache.conan_conf_path) self.assertEqual(conan_conf.get_item("log.run_to_output"), "False") self.assertEqual(conan_conf.get_item("log.run_to_file"), "False") self.assertEqual(conan_conf.get_item("log.level"), "10") self.assertEqual(conan_conf.get_item("general.compression_level"), "6") self.assertEqual(conan_conf.get_item("general.sysrequires_sudo"), "True") self.assertEqual(conan_conf.get_item("general.cpu_count"), "1") self.assertEqual(conan_conf.get_item("general.config_install"), install_path) self.assertEqual(conan_conf.get_item("proxies.no_proxy"), "mylocalhost") self.assertEqual(conan_conf.get_item("proxies.https"), "None") self.assertEqual(conan_conf.get_item("proxies.http"), "http://*****:*****@10.10.1.10:3128/") self.assertEqual("#Custom pylint", load(os.path.join(self.client.client_cache.conan_folder, "pylintrc"))) self.assertEqual("", load(os.path.join(self.client.client_cache.conan_folder, "python", "__init__.py"))) def reuse_python_test(self): zippath = self._create_zip() self.client.run('config install "%s"' % zippath) conanfile = """from conans import ConanFile from myfuncs import mycooladd a = mycooladd(1, 2) assert a == 3 class Pkg(ConanFile): def build(self): self.output.info("A is %s" % a) """ self.client.save({"conanfile.py": conanfile}) self.client.run("create . Pkg/0.1@user/testing") self.assertIn("A is 3", self.client.out) def install_file_test(self): """ should install from a file in current dir """ zippath = self._create_zip() self.client.run('config install "%s"' % zippath) self._check(zippath) self.assertTrue(os.path.exists(zippath)) def test_without_profile_folder(self): shutil.rmtree(self.client.client_cache.profiles_path) zippath = self._create_zip() self.client.run('config install "%s"' % zippath) self.assertEqual(sorted(os.listdir(self.client.client_cache.profiles_path)), sorted(["linux", "windows"])) self.assertEqual(load(os.path.join(self.client.client_cache.profiles_path, "linux")).splitlines(), linux_profile.splitlines()) def install_url_test(self): """ should install from a URL """ def my_download(obj, url, filename, **kwargs): # @UnusedVariable self._create_zip(filename) with patch.object(Downloader, 'download', new=my_download): self.client.run("config install http://myfakeurl.com/myconf.zip") self._check("http://myfakeurl.com/myconf.zip") # repeat the process to check self.client.run("config install http://myfakeurl.com/myconf.zip") self._check("http://myfakeurl.com/myconf.zip") def failed_install_repo_test(self): """ should install from a git repo """ error = self.client.run('config install notexistingrepo.git', ignore_error=True) self.assertTrue(error) self.assertIn("ERROR: config install error. Can't clone repo", self.client.out) def install_repo_test(self): """ should install from a git repo """ folder = self._create_profile_folder() with tools.chdir(folder): self.client.runner('git init .') self.client.runner('git add .') self.client.runner('git config user.name myname') self.client.runner('git config user.email [email protected]') self.client.runner('git commit -m "mymsg"') self.client.run('config install "%s/.git"' % folder) self._check("%s/.git" % folder) def reinstall_test(self): """ should use configured URL in conan.conf """ zippath = self._create_zip() self.client.run('config set general.config_install="%s"' % zippath) self.client.run("config install") self._check(zippath) def reinstall_error_test(self): """ should use configured URL in conan.conf """ error = self.client.run("config install", ignore_error=True) self.assertTrue(error) self.assertIn("Called config install without arguments", self.client.out) def removed_credentials_from_url_unit_test(self): """ Unit tests to remove credentials in netloc from url when using basic auth # https://github.com/conan-io/conan/issues/2324 """ url_without_credentials = r"https://server.com/resource.zip" url_with_credentials = r"https://*****:*****@server.com/resource.zip" url_hidden_password = r"https://*****:*****@server.com/resource.zip" # Check url is the same when not using credentials self.assertEqual(_hide_password(url_without_credentials), url_without_credentials) # Check password is hidden using url with credentials self.assertEqual(_hide_password(url_with_credentials), url_hidden_password) # Check that it works with other protocols ftp ftp_with_credentials = r"ftp://*****:*****@server.com/resurce.zip" ftp_hidden_password = r"ftp://*****:*****@server.com/resurce.zip" self.assertEqual(_hide_password(ftp_with_credentials), ftp_hidden_password) # Check function also works for file paths *unix/windows unix_file_path = r"/tmp/test" self.assertEqual(_hide_password(unix_file_path), unix_file_path) windows_file_path = r"c:\windows\test" self.assertEqual(_hide_password(windows_file_path), windows_file_path) # Check works with empty string self.assertEqual(_hide_password(''), '') def remove_credentials_config_installer_test(self): """ Functional test to check credentials are not displayed in output but are still present in conan configuration # https://github.com/conan-io/conan/issues/2324 """ fake_url_with_credentials = "http://*****:*****@myfakeurl.com/myconf.zip" fake_url_hidden_password = "******" def my_download(obj, url, filename, **kwargs): # @UnusedVariable self.assertEqual(url, fake_url_with_credentials) self._create_zip(filename) with patch.object(Downloader, 'download', new=my_download): self.client.run("config install %s" % (fake_url_with_credentials,)) # Check credentials are not displayed in output self.assertNotIn(fake_url_with_credentials, self.client.out) self.assertIn(fake_url_hidden_password, self.client.out) # Check credentials still stored in configuration self._check(fake_url_with_credentials) def ssl_verify_test(self): fake_url = "https://fakeurl.com/myconf.zip" def download_verify_false(obj, url, filename, **kwargs): # @UnusedVariable self.assertFalse(obj.verify) self._create_zip(filename) def download_verify_true(obj, url, filename, **kwargs): # @UnusedVariable self.assertTrue(obj.verify) self._create_zip(filename) with patch.object(Downloader, 'download', new=download_verify_false): self.client.run("config install %s --verify-ssl=False" % fake_url) with patch.object(Downloader, 'download', new=download_verify_true): self.client.run("config install %s --verify-ssl=True" % fake_url)
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:])