def setUpClass(cls):
if not cls.server:
cls.server = TestServerLauncher(
server_capabilities=['ImCool', 'TooCool'])
cls.server.start()
filename = os.path.join(temp_folder(), "conan.conf")
save(filename, "")
config = ConanClientConfigParser(filename)
requester = ConanRequester(config, requests)
client_factory = RestApiClientFactory(TestBufferConanOutput(),
requester=requester,
config=config)
localdb = LocalDBMock()
mocked_user_io = UserIO(out=TestBufferConanOutput())
mocked_user_io.get_username = Mock(return_value="private_user")
mocked_user_io.get_password = Mock(return_value="private_pass")
cls.auth_manager = ConanApiAuthManager(client_factory,
mocked_user_io, localdb)
cls.remote = Remote("myremote",
"http://127.0.0.1:%s" % str(cls.server.port),
True, True)
cls.auth_manager._authenticate(cls.remote,
user="******",
password="******")
cls.api = client_factory.new(cls.remote, localdb.access_token,
localdb.refresh_token, {})
def test_replace_in_file_readonly(self):
tmp_dir = temp_folder()
text_file = os.path.join(tmp_dir, "text.txt")
save(text_file, "ONE TWO THREE")
os.chmod(
text_file,
os.stat(text_file).st_mode
& ~(stat.S_IWRITE | stat.S_IWGRP | stat.S_IWOTH))
mode_before_replace = os.stat(text_file).st_mode
replace_in_file(text_file,
"ONE TWO THREE",
"FOUR FIVE SIX",
output=TestBufferConanOutput())
self.assertEqual(load(text_file), "FOUR FIVE SIX")
self.assertEqual(os.stat(text_file).st_mode, mode_before_replace)
replace_path_in_file(text_file,
"FOUR FIVE SIX",
"SEVEN EIGHT NINE",
output=TestBufferConanOutput())
self.assertEqual(load(text_file), "SEVEN EIGHT NINE")
self.assertEqual(os.stat(text_file).st_mode, mode_before_replace)
def test_plain_zip(self):
tmp_folder = temp_folder()
with chdir(tmp_folder):
ori_files_dir = os.path.join(tmp_folder, "subfolder-1.2.3")
file1 = os.path.join(ori_files_dir, "file1")
file2 = os.path.join(ori_files_dir, "folder", "file2")
file3 = os.path.join(ori_files_dir, "file3")
save(file1, "")
save(file2, "")
save(file3, "")
zip_file = os.path.join(tmp_folder, "myzip.zip")
# Zip with a "folder_entry" in the zip (not only for the files)
self._zipdir(tmp_folder, zip_file, folder_entry="subfolder-1.2.3")
# ZIP unzipped regularly
extract_folder = temp_folder()
output = TestBufferConanOutput()
unzip(zip_file,
destination=extract_folder,
strip_root=False,
output=output)
self.assertNotIn("ERROR: Error extract", output)
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "subfolder-1.2.3")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "file1")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "folder",
"file2")))
self.assertTrue(
os.path.exists(
os.path.join(extract_folder, "subfolder-1.2.3", "file3")))
# Extract without the subfolder
extract_folder = temp_folder()
output = TestBufferConanOutput()
unzip(zip_file,
destination=extract_folder,
strip_root=True,
output=output)
self.assertNotIn("ERROR: Error extract", output)
self.assertFalse(
os.path.exists(os.path.join(extract_folder, "subfolder-1.2.3")))
self.assertTrue(os.path.exists(os.path.join(extract_folder, "file1")))
self.assertTrue(
os.path.exists(os.path.join(extract_folder, "folder", "file2")))
self.assertTrue(os.path.exists(os.path.join(extract_folder, "file3")))
def test_node(self):
""" nodes are different even if contain same values,
so they can be repeated if necessary in the graph (common
static libraries)
"""
ref1 = ConanFileReference.loads("Hello/0.1@user/stable")
ref2 = ConanFileReference.loads("Hello/0.1@user/stable")
conanfile1 = ConanFile(TestBufferConanOutput(), None)
conanfile2 = ConanFile(TestBufferConanOutput(), None)
n1 = Node(ref1, conanfile1, context=CONTEXT_HOST)
n2 = Node(ref2, conanfile2, context=CONTEXT_HOST)
self.assertNotEqual(n1, n2)
def build_vs_project_test(self, generator, props):
client = TestClient()
files = {}
files["conanfile.py"] = hello_conanfile_py
files["hello.h"] = hello_h
client.save(files)
client.run("create . lasote/testing")
files = get_vs_project_files()
files["MyProject/main.cpp"] = main_cpp
files["conanfile.txt"] = conanfile_txt.format(generator=generator)
props = os.path.join(client.current_folder, props)
old = '<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />'
new = old + '<Import Project="{props}" />'.format(props=props)
files["MyProject/MyProject.vcxproj"] = files[
"MyProject/MyProject.vcxproj"].replace(old, new)
client.save(files, clean_first=True)
for build_type in ["Debug", "Release"]:
arch = "x86"
runner = ConanRunner(print_commands_to_output=True,
generate_run_log_file=False,
log_run_to_output=True,
output=TestBufferConanOutput())
settings = MockSettings({
"os": "Windows",
"build_type": build_type,
"arch": arch,
"compiler": "Visual Studio",
"compiler.version": "15",
"compiler.toolset": "v141"
})
conanfile = MockConanfile(settings, runner=runner)
settings = " -s os=Windows " \
" -s build_type={build_type} " \
" -s arch={arch}" \
" -s compiler=\"Visual Studio\"" \
" -s compiler.toolset=v141" \
" -s compiler.version=15".format(build_type=build_type, arch=arch)
client.run("install . %s" % settings)
with tools.chdir(client.current_folder):
msbuild = MSBuild(conanfile)
msbuild.build(project_file="MyProject.sln",
build_type=build_type,
arch=arch)
output = TestBufferConanOutput()
runner("%s\MyProject.exe" % build_type, output)
self.assertIn("Hello %s!!!" % build_type, output)
def valid_xml_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
folder1 = temp_folder()
folder1 = folder1.replace("\\", "/")
os.makedirs(os.path.join(folder1, "include"))
os.makedirs(os.path.join(folder1, "lib"))
cpp_info = CppInfo(ref.name, folder1)
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing")
folder2 = temp_folder()
folder2 = folder2.replace("\\", "/")
os.makedirs(os.path.join(folder2, "include"))
os.makedirs(os.path.join(folder2, "lib"))
cpp_info = CppInfo(ref.name, folder2)
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = VisualStudioLegacyGenerator(conanfile)
content = generator.content
xml.etree.ElementTree.fromstring(content)
self.assertIn(
'AdditionalIncludeDirectories=""%s/include";"%s/include";"'
% (folder1, folder2), content)
self.assertIn(
'AdditionalLibraryDirectories=""%s/lib";"%s/lib";"'
% (folder1, folder2), content)
def basic_mocked_test(self):
mocked_user_io = UserIO(out=TestBufferConanOutput())
mocked_user_io.request_boolean = Mock(return_value=True)
self.client.run("remove hello/*", user_io=mocked_user_io)
self.assert_folders(local_folders={
"H1": None,
"H2": None,
"B": [1, 2],
"O": [1, 2]
},
remote_folders={
"H1": [1, 2],
"H2": [1, 2],
"B": [1, 2],
"O": [1, 2]
},
build_folders={
"H1": None,
"H2": None,
"B": [1, 2],
"O": [1, 2]
},
src_folders={
"H1": False,
"H2": False,
"B": True,
"O": True
})
folders = os.listdir(self.client.storage_folder)
six.assertCountEqual(self, ["Other", "Bye"], folders)
def test_user_space_with_local_sources(self):
output = TestBufferConanOutput()
# Need a real repo to get a working SCM object
local_sources_path = os.path.join(self.tmp_dir,
'git_repo').replace('\\', '/')
create_local_git_repo(files={'file1': "content"},
folder=local_sources_path)
git = Git(local_sources_path)
url = "https://remote.url"
git.run("remote add origin \"{}\"".format(url))
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
# Mock functions called from inside _run_scm (tests will be here)
def merge_directories(src, dst, excluded=None):
src = os.path.normpath(src)
dst = os.path.normpath(dst)
self.assertEqual(src.replace('\\', '/'), local_sources_path)
self.assertEqual(dst, self.src_folder)
with mock.patch("conans.client.source.merge_directories",
side_effect=merge_directories):
_run_local_scm(conanfile,
conanfile_folder=local_sources_path,
src_folder=self.src_folder,
output=output)
self.assertIn(
"getting sources from folder: {}".format(
local_sources_path).lower(),
str(output).lower())
def test_500_raises_internal_error(self):
out = TestBufferConanOutput()
uploader = FileUploader(MockRequester(500), out, verify=False, config=_ConfigMock())
_, f = tempfile.mkstemp()
save(f, "some contents")
with six.assertRaisesRegex(self, InternalErrorException, "tururu"):
uploader.upload("fake_url", self.f, dedup=True)
def apple_frameworks_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = "apple-clang"
settings.os = "Macos"
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
conanfile.settings = settings
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "/dummy_root_folder1")
cpp_info.filter_empty = False
cpp_info.frameworks = ['AudioUnit', 'AudioToolbox']
cpp_info.version = "1.3"
cpp_info.description = "My cool description"
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = PkgConfigGenerator(conanfile)
files = generator.content
self.assertEqual(
files["MyPkg.pc"], """prefix=/dummy_root_folder1
libdir=${prefix}/lib
includedir=${prefix}/include
Name: MyPkg
Description: My cool description
Version: 1.3
Libs: -L${libdir} -Wl,-rpath,"${libdir}" -framework AudioUnit -framework AudioToolbox -F /dummy_root_folder1/Frameworks
Cflags: -I${includedir}
""")
def test_in_cache_with_local_sources(self):
"""In cache, if we have cached scm sources in the scm_sources, it will get them"""
output = TestBufferConanOutput()
local_sources_path = self.tmp_dir.replace('\\', '/')
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
conanfile.folders.base_source = self.src_folder
# Mock functions called from inside _run_scm (tests will be here)
def merge_directories(src, dst, excluded=None):
self.assertEqual(src, local_sources_path)
self.assertEqual(dst, self.src_folder)
def clean_source_folder(folder):
self.assertEqual(folder, self.src_folder)
with mock.patch("conans.client.source.merge_directories",
side_effect=merge_directories):
with mock.patch("conans.client.source._clean_source_folder",
side_effect=clean_source_folder):
_run_cache_scm(conanfile,
scm_sources_folder=local_sources_path,
output=output)
self.assertIn("Copying previously cached scm sources", output)
def insert_test(self):
tmp_folder = temp_folder()
f = os.path.join(tmp_folder, "remotes.json")
save(f, """
{
"remotes": [
{
"url": "https://server.conan.io",
"verify_ssl": true,
"name": "conan.io"
}
]
}
""")
output = TestBufferConanOutput()
cache = ClientCache(tmp_folder, output)
registry = RemoteRegistry(cache, output)
registry.add("repo1", "url1", True, insert=0)
self.assertEqual(list(registry.load_remotes().values()), [Remote("repo1", "url1", True, False),
Remote("conan.io", "https://server.conan.io", True, False)])
registry.add("repo2", "url2", True, insert=1)
self.assertEqual(list(registry.load_remotes().values()), [Remote("repo1", "url1", True, False),
Remote("repo2", "url2", True, False),
Remote("conan.io", "https://server.conan.io", True, False)])
registry.add("repo3", "url3", True, insert=5)
self.assertEqual(list(registry.load_remotes().values()), [Remote("repo1", "url1", True, False),
Remote("repo2", "url2", True, False),
Remote("conan.io", "https://server.conan.io", True, False),
Remote("repo3", "url3", True, False)])
def test_remote_none(self):
""" RemoteRegistry should be able to deal when the URL is None
"""
f = os.path.join(temp_folder(), "add_none_test")
Remotes().save(f)
cache = ClientCache(os.path.dirname(f), TestBufferConanOutput())
registry = cache.registry
registry.add("foobar", None)
self.assertEqual(
list(registry.load_remotes().values()),
[("conancenter", "https://center.conan.io", True, False),
("conan-center", "https://conan.bintray.com", True, False),
("foobar", None, True, False)])
self.assertIn(
"WARN: The URL is empty. It must contain scheme and hostname.",
cache._output)
registry.remove("foobar")
registry.update("conan-center", None)
self.assertEqual(
list(registry.load_remotes().values()),
[("conancenter", "https://center.conan.io", True, False),
("conan-center", None, True, False)])
self.assertIn(
"WARN: The URL is empty. It must contain scheme and hostname.",
cache._output)
def validate_additional_dependencies(libname, additional_dep):
tempdir = temp_folder()
with chdir(tempdir):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.libs = [libname]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
settings = Settings.loads(get_default_settings_yml())
settings.os = "Windows"
settings.arch = "x86_64"
settings.build_type = "Release"
settings.compiler = "Visual Studio"
settings.compiler.version = "15"
settings.compiler.runtime = "MD"
settings.compiler.toolset = "v141"
conanfile.settings = settings
generator = VisualStudioMultiGenerator(conanfile)
generator.output_path = ""
content = generator.content
self.assertIn('conanbuildinfo_release_x64_v141.props', content.keys())
content_release = content['conanbuildinfo_release_x64_v141.props']
self.assertIn("<ConanLibraries>%s;</ConanLibraries>" % additional_dep,
content_release)
self.assertIn("<AdditionalDependencies>"
"$(ConanLibraries)%(AdditionalDependencies)"
"</AdditionalDependencies>", content_release)
def system_frameworks_libs_test(self):
# https://github.com/conan-io/conan/issues/7301
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
cpp_info = CppInfo("MyPkg", "/rootpath")
cpp_info.version = "0.1"
cpp_info.libs = ["mypkg"]
cpp_info.system_libs = ["pthread"]
cpp_info.frameworks = ["cocoa"]
cpp_info.frameworkdirs = ["frameworks"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add("MyPkg", DepCppInfo(cpp_info))
generator = SConsGenerator(conanfile)
content = generator.content
scons_lines = content.splitlines()
self.assertIn(' "LIBS" : [\'mypkg\', \'pthread\'],',
scons_lines)
self.assertIn(' "FRAMEWORKS" : [\'cocoa\'],', scons_lines)
if platform.system() == "Windows":
self.assertIn(
' "FRAMEWORKPATH" : [\'/rootpath\\\\frameworks\'],',
scons_lines)
else:
self.assertIn(
' "FRAMEWORKPATH" : [\'/rootpath/frameworks\'],',
scons_lines)
self.assertIn(' "MyPkg_version" : "0.1",', scons_lines)
def test_revision_auto(self, _, is_pristine):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
url = "https://remote.url"
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': url, 'revision': 'auto'}
if not is_pristine:
save(os.path.join(self.git.folder, "other"), "ccc")
scm_data, _ = _capture_scm_auto_fields(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
package_layout=None,
output=output,
ignore_dirty=False,
scm_to_conandata=False)
self.assertEqual(scm_data.url, url)
if is_pristine:
self.assertEqual(scm_data.revision, self.rev)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev), output)
self.assertNotIn("Repo origin deduced", output)
else:
self.assertEqual(scm_data.revision, "auto")
self.assertIn("There are uncommitted changes, skipping the replacement of 'scm.url' "
"and 'scm.revision' auto fields. Use --ignore-dirty to force it.",
output)
def test_url_auto_revision_auto(self, _, local_origin):
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
conanfile = mock.MagicMock()
conanfile.scm = {'type': 'git', 'url': 'auto', 'revision': 'auto'}
# Set the remote for the repo
url = self.git.folder if local_origin else "https://remote.url"
self.git.run("remote add origin \"{}\"".format(url))
scm_data, _ = _capture_scm_auto_fields(
conanfile=conanfile,
conanfile_dir=self.conanfile_dir,
package_layout=None,
output=output,
ignore_dirty=True,
scm_to_conandata=False)
self.assertEqual(scm_data.url, url)
self.assertEqual(scm_data.revision, self.rev)
self.assertIn("Repo origin deduced by 'auto': {}".format(url), output)
self.assertIn("Revision deduced by 'auto': {}".format(self.rev), output)
if local_origin:
self.assertIn("WARN: Repo origin looks like a local path: {}".format(url), output)
def test_multi_flag(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.includedirs.append("other_include_dir")
cpp_info.cxxflags = [
"-DGTEST_USE_OWN_TR1_TUPLE=1", "-DGTEST_LINKED_AS_SHARED_LIBRARY=1"
]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.cflags = ["-DSOMEFLAG=1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = CMakeGenerator(conanfile)
content = generator.content
cmake_lines = content.splitlines()
self.assertIn('set(CONAN_C_FLAGS_MYPKG2 "-DSOMEFLAG=1")', cmake_lines)
self.assertIn(
'set(CONAN_CXX_FLAGS_MYPKG "-DGTEST_USE_OWN_TR1_TUPLE=1'
' -DGTEST_LINKED_AS_SHARED_LIBRARY=1")', cmake_lines)
self.assertIn('set(CONAN_C_FLAGS "-DSOMEFLAG=1 ${CONAN_C_FLAGS}")',
cmake_lines)
self.assertIn(
'set(CONAN_CXX_FLAGS "-DGTEST_USE_OWN_TR1_TUPLE=1'
' -DGTEST_LINKED_AS_SHARED_LIBRARY=1 ${CONAN_CXX_FLAGS}")',
cmake_lines)
def _init(self):
temp_dir = temp_folder()
hook_path = os.path.join(temp_dir, "my_hook.py")
save(os.path.join(temp_dir, "my_hook.py"), my_hook)
output = TestBufferConanOutput()
hook_manager = HookManager(temp_dir, ["my_hook"], output)
return hook_manager, output, hook_path
def reject_removal_test(self):
mocked_user_io = UserIO(out=TestBufferConanOutput())
mocked_user_io.request_boolean = Mock(return_value=False)
self.client.run("remove hello/* -s -b -p", user_io=mocked_user_io)
self.assert_folders(local_folders={
"H1": [1, 2],
"H2": [1, 2],
"B": [1, 2],
"O": [1, 2]
},
remote_folders={
"H1": [1, 2],
"H2": [1, 2],
"B": [1, 2],
"O": [1, 2]
},
build_folders={
"H1": [1, 2],
"H2": [1, 2],
"B": [1, 2],
"O": [1, 2]
},
src_folders={
"H1": True,
"H2": True,
"B": True,
"O": True
})
def enable_disable_remotes_test(self):
f = os.path.join(temp_folder(), "aux_file")
Remotes().save(f)
cache = ClientCache(os.path.dirname(f), TestBufferConanOutput())
registry = cache.registry
registry.add("local", "http://localhost:9300")
registry.set_disabled_state("local", True)
self.assertEqual(list(registry.load_remotes().all_values()),
[("conan-center", "https://conan.bintray.com", True, False),
("local", "http://localhost:9300", True, True)])
self.assertEqual(list(registry.load_remotes().values()),
[("conan-center", "https://conan.bintray.com", True, False)])
registry.set_disabled_state("conan-center", True)
self.assertEqual(list(registry.load_remotes().all_values()),
[("conan-center", "https://conan.bintray.com", True, True),
("local", "http://localhost:9300", True, True)])
self.assertEqual(list(registry.load_remotes().values()), [])
registry.set_disabled_state("*", False)
self.assertEqual(list(registry.load_remotes().values()),
[("conan-center", "https://conan.bintray.com", True, False),
("local", "http://localhost:9300", True, False)])
registry.set_disabled_state("*", True)
self.assertEqual(list(registry.load_remotes().values()), [])
def apple_frameworks_test(self):
settings = Settings.loads(get_default_settings_yml())
settings.os = "Macos"
settings.compiler = "apple-clang"
settings.compiler.version = "9.1"
settings.compiler.libcxx = "libc++"
settings.arch = "x86_64"
settings.build_type = "Debug"
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
conanfile.settings = settings
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.frameworkdirs.extend(["path/to/Frameworks1", "path/to/Frameworks2"])
cpp_info.frameworks = ["OpenGL", "OpenCL"]
cpp_info.filter_empty = False
conanfile.deps_cpp_info.add(ref.name, cpp_info)
generator = CMakeGenerator(conanfile)
content = generator.content
self.assertIn('find_library(CONAN_FRAMEWORK_${_FRAMEWORK}_FOUND NAME ${_FRAMEWORK} PATHS'
' ${CONAN_FRAMEWORK_DIRS${SUFFIX}})', content)
self.assertIn('set(CONAN_FRAMEWORK_DIRS "dummy_root_folder1/Frameworks"\n'
'\t\t\t"dummy_root_folder1/path/to/Frameworks1"\n'
'\t\t\t"dummy_root_folder1/path/to/Frameworks2" '
'${CONAN_FRAMEWORK_DIRS})', content)
self.assertIn('set(CONAN_LIBS ${CONAN_LIBS} ${CONAN_SYSTEM_LIBS} '
'${CONAN_FRAMEWORKS_FOUND})', content)
generator = CMakeFindPackageGenerator(conanfile)
content = generator.content
content = content['FindMyPkg.cmake']
self.assertIn('conan_find_apple_frameworks(MyPkg_FRAMEWORKS_FOUND "${MyPkg_FRAMEWORKS}"'
' "${MyPkg_FRAMEWORK_DIRS}")', content)
def test_detect_default_in_mac_os_using_gcc_as_default(self):
"""
Test if gcc in Mac OS X is using apple-clang as frontend
"""
# See: https://github.com/conan-io/conan/issues/2231
try:
output = check_output_runner(["gcc", "--version"],
stderr=subprocess.STDOUT)
except subprocess.CalledProcessError:
# gcc is not installed or there is any error (no test scenario)
return
if "clang" not in output:
# Not test scenario gcc should display clang in output
# see: https://stackoverflow.com/questions/19535422/os-x-10-9-gcc-links-to-clang
raise Exception(
"Apple gcc doesn't point to clang with gcc frontend anymore!")
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
result = detect_defaults_settings(
output, profile_path=DEFAULT_PROFILE_NAME)
# result is a list of tuples (name, value) so converting it to dict
result = dict(result)
# No compiler should be detected
self.assertIsNone(result.get("compiler", None))
self.assertIn("gcc detected as a frontend using apple-clang", output)
self.assertIsNotNone(output.error)
def variables_setup_test(self):
conanfile = ConanFile(TestBufferConanOutput(), None)
conanfile.initialize(Settings({}), EnvValues())
ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder1")
cpp_info.defines = ["MYDEFINE1"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
ref = ConanFileReference.loads("MyPkg2/0.1@lasote/stables")
cpp_info = CppInfo(ref.name, "dummy_root_folder2")
cpp_info.defines = ["MYDEFINE2"]
conanfile.deps_cpp_info.add(ref.name, cpp_info)
conanfile.deps_user_info["LIB1"].myvar = "myvalue"
conanfile.deps_user_info["LIB1"].myvar2 = "myvalue2"
conanfile.deps_user_info["lib2"].MYVAR2 = "myvalue4"
generator = CMakeGenerator(conanfile)
content = generator.content
cmake_lines = content.splitlines()
self.assertIn('set(CONAN_DEFINES_MYPKG "-DMYDEFINE1")', cmake_lines)
self.assertIn('set(CONAN_DEFINES_MYPKG2 "-DMYDEFINE2")', cmake_lines)
self.assertIn('set(CONAN_COMPILE_DEFINITIONS_MYPKG "MYDEFINE1")', cmake_lines)
self.assertIn('set(CONAN_COMPILE_DEFINITIONS_MYPKG2 "MYDEFINE2")', cmake_lines)
self.assertIn('set(CONAN_USER_LIB1_myvar "myvalue")', cmake_lines)
self.assertIn('set(CONAN_USER_LIB1_myvar2 "myvalue2")', cmake_lines)
self.assertIn('set(CONAN_USER_LIB2_MYVAR2 "myvalue4")', cmake_lines)
def test_detect_file_profile(self, _):
output = TestBufferConanOutput()
with tools.environment_append({"CC": "gcc"}):
detect_defaults_settings(output, profile_path="./MyProfile")
self.assertIn(
"conan profile update settings.compiler.libcxx=libstdc++11 MyProfile",
output)
class VCVarsClangClTest(unittest.TestCase):
output = TestBufferConanOutput()
def test_simple(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'clang'
settings.compiler.version = '5.0'
settings.arch = 'x86'
settings.os = 'Windows'
command = vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('x86', command)
def test_no_version(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'clang'
settings.arch = 'x86_64'
settings.os = 'Windows'
command = vcvars_command(settings, output=self.output)
self.assertIn('vcvarsall.bat', command)
self.assertIn('amd64', command)
def test_no_msvc(self):
settings = Settings.loads(get_default_settings_yml())
settings.compiler = 'clang'
settings.arch = 'x86_64'
settings.os = 'Windows'
with mock.patch('conans.client.tools.win.latest_vs_version_installed',
mock.MagicMock(return_value=None)):
with self.assertRaises(ConanException):
vcvars_command(settings, output=self.output)
def test_in_cache_no_local_sources(self):
"""In cache, if we DON'T have cached scm sources in the scm_sources, it will clone"""
output = TestBufferConanOutput()
# Mock the conanfile (return scm_data)
subfolder = 'subfolder'
url = 'whatever'
conanfile = mock.MagicMock()
conanfile.scm = {
'type': 'git',
'url': url,
'revision': 'auto',
'subfolder': subfolder
}
conanfile.folders.base_source = self.src_folder
# Mock functions called from inside _run_scm (tests will be here)
def clean_source_folder(folder):
self.assertEqual(folder, os.path.join(self.src_folder, subfolder))
def scm_checkout(scm_itself):
self.assertEqual(scm_itself.repo_folder,
os.path.join(self.src_folder, subfolder))
with mock.patch("conans.client.source._clean_source_folder",
side_effect=clean_source_folder):
with mock.patch.object(SCM, "checkout", new=scm_checkout):
_run_cache_scm(conanfile,
scm_sources_folder="/not/existing/path",
output=output)
self.assertIn("SCM: Getting sources from url: '{}'".format(url),
output)
class ParseSCMFromConanDataTestCase(unittest.TestCase):
loader = ConanFileLoader(runner=None,
output=TestBufferConanOutput(),
python_requires=ConanPythonRequire(None, None))
def test_parse_data(self):
conanfile = textwrap.dedent("""
import os
from conans import ConanFile
class Recipe(ConanFile):
scm = {"type": "git", "url": "auto", "revision": "auto"}
""")
conan_data = {
'something_else': {},
'.conan': {
'scm': {
'type': 'git',
'url': 'http://myrepo.com',
'shallow': False,
'revision': 'abcdefghijk'
}
}
}
test_folder = tempfile.mkdtemp()
save_files(
test_folder, {
'conanfile.py': conanfile,
DATA_YML: yaml.safe_dump(conan_data, default_flow_style=False)
})
conanfile_path = os.path.join(test_folder, 'conanfile.py')
conanfile, _ = self.loader.load_basic_module(
conanfile_path=conanfile_path)
self.assertDictEqual(conanfile.scm, conan_data['.conan']['scm'])
def run_command(self, command, cwd=None, assert_error=False):
output = TestBufferConanOutput()
self.out = output
runner = ConanRunner(output=output)
ret = runner(command, cwd=cwd or self.current_folder)
self._handle_cli_result(command, assert_error=assert_error, error=ret)
return ret
def test_replace_in_file(self):
tmp_dir = temp_folder()
text_file = os.path.join(tmp_dir, "text.txt")
save(text_file, "ONE TWO THREE")
replace_in_file(text_file, "ONE TWO THREE", "FOUR FIVE SIX",
output=TestBufferConanOutput())
self.assertEqual(load(text_file), "FOUR FIVE SIX")
