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 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_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)
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 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 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 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 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:])
