def child_build_test(self):
client = TestClient()
repo_folder = client.current_folder
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
package_folder = os.path.join(build_folder, "package")
mkdir(package_folder)
client.save({"conanfile.py": conanfile_out})
client.current_folder = build_folder
client.run("install ..")
client.run("source ..")
client.run("build .. --source-folder=.")
client.current_folder = package_folder
client.run("package ../.. --build-folder=../")
self._assert_pkg(package_folder)
rmdir(package_folder)
client.current_folder = repo_folder
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=./build")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def child_build_test(self):
client = TestClient()
repo_folder = client.current_folder
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(package_folder)
client.save({"conanfile.py": conanfile,
"file.h": "file_h_contents!"})
client.current_folder = build_folder
client.run("install .. -g txt")
client.run("build ..")
client.current_folder = package_folder
client.run("package .. --build_folder=../build")
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export lasote/testing")
client.run("package_files Pkg/0.1@lasote/testing -pf=./pkg")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def parallel_folders_test(self):
client = TestClient()
repo_folder = os.path.join(client.current_folder, "recipe")
build_folder = os.path.join(client.current_folder, "build")
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(repo_folder)
mkdir(build_folder)
mkdir(package_folder)
client.current_folder = repo_folder # equivalent to git clone recipe
client.save({"conanfile.py": conanfile,
"file.h": "file_h_contents!"})
client.current_folder = build_folder
client.run("install ../recipe")
client.run("build ../recipe")
client.current_folder = package_folder
client.run("package ../recipe --build-folder=../build --package-folder='%s'" %
package_folder)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=../pkg")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def child_build_test(self):
client = TestClient()
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
package_folder = os.path.join(build_folder, "package")
mkdir(package_folder)
client.save({"conanfile.py": conanfile,
"file.h": "file_h_contents!"})
client.current_folder = build_folder
client.run("install ..")
client.run("build ..")
client.current_folder = package_folder
client.run("package ../.. --build-folder=../")
self._assert_pkg(package_folder)
rmdir(package_folder) # IMPORTANT: Symptom that package + package_folder is not fitting
# well now. (To discuss)
# But I think now you choose you way to develop, local or cache, if you use conan export-pkg
# you are done, if you use package() you need the "conan project" feature
client.current_folder = build_folder
client.run("export-pkg .. Pkg/0.1@lasote/testing --source-folder=.. ")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def child_build_test(self):
client = TestClient()
repo_folder = client.current_folder
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
package_folder = os.path.join(build_folder, "package")
mkdir(package_folder)
client.save({"conanfile.py": conanfile_out})
client.current_folder = build_folder
client.run("install ..")
client.run("source ..")
client.run("build .. --source-folder=.")
client.current_folder = package_folder
client.run("package ../.. --build-folder=../")
self._assert_pkg(package_folder)
rmdir(package_folder)
client.current_folder = repo_folder
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=./build")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.cache.packages(ref)
cache_package_folder = os.path.join(
cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def local_package_build_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
exports = "*file.h"
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo",
"include/file2.h": "bar",
CONANFILE: conanfile_template}
client.save(files)
origin_folder = client.current_folder
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install .. -g txt")
# client.run("source ..")
# self.assertEqual(os.listdir(os.path.join(client.current_folder, "include")), ["file.h"])
# client.run("build ..")
client.current_folder = temp_folder()
client.run('package "{0}" --build_folder="{0}/build" --source_folder="{0}"'.format(origin_folder))
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def parallel_folders_test(self):
client = TestClient()
repo_folder = os.path.join(client.current_folder, "recipe")
build_folder = os.path.join(client.current_folder, "build")
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(repo_folder)
mkdir(build_folder)
mkdir(package_folder)
client.current_folder = repo_folder # equivalent to git clone recipe
client.save({"conanfile.py": conanfile, "file.h": "file_h_contents!"})
client.current_folder = build_folder
client.run("install ../recipe")
client.run("build ../recipe")
client.current_folder = package_folder
client.run(
"package ../recipe --build-folder=../build --package-folder='%s'" %
package_folder)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=../pkg")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.cache.packages(ref)
cache_package_folder = os.path.join(
cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def child_build_test(self):
client = TestClient()
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
package_folder = os.path.join(build_folder, "package")
mkdir(package_folder)
client.save({"conanfile.py": conanfile, "file.h": "file_h_contents!"})
client.current_folder = build_folder
client.run("install ..")
client.run("build ..")
client.current_folder = package_folder
client.run("package ../.. --build-folder=../")
self._assert_pkg(package_folder)
rmdir(
package_folder
) # IMPORTANT: Symptom that package + package_folder is not fitting
# well now. (To discuss)
# But I think now you choose you way to develop, local or cache, if you use conan export-pkg
# you are done, if you use package() you need the "conan project" feature
client.current_folder = build_folder
client.run("export-pkg .. Pkg/0.1@lasote/testing --source-folder=.. ")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.cache.packages(ref)
cache_package_folder = os.path.join(
cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def local_package_build_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
exports = "*file.h"
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {
"include/file.h": "foo",
"include/file2.h": "bar",
CONANFILE: conanfile_template
}
client.save(files)
origin_folder = client.current_folder
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install .. -g txt")
# client.run("source ..")
# self.assertEqual(os.listdir(os.path.join(client.current_folder, "include")), ["file.h"])
# client.run("build ..")
client.current_folder = temp_folder()
client.run(
'package "{0}" --build_folder="{0}/build" --source_folder="{0}"'.
format(origin_folder))
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def local_package_build_test(self, default_folder, conanfile_path):
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
self.copy(pattern="*.lib")
"""
client.save({
"include/file.h": "foo",
"build/lib/mypkg.lib": "mylib",
CONANFILE: conanfile_template
})
path = client.current_folder
client.current_folder = os.path.join(client.current_folder, "build")
client.run("install ..")
if default_folder:
package_folder = os.path.join(client.current_folder, "package")
path = "../conanfile.py" if conanfile_path else ".."
client.run('package {0} --build-folder=.'.format(path))
self.assertEqual(
sorted(os.listdir(package_folder)),
sorted(
["include", "lib", "conaninfo.txt", "conanmanifest.txt"]))
else:
package_folder = temp_folder()
client.current_folder = package_folder
build_folder = os.path.join(path, "build")
if conanfile_path:
path = os.path.join(path, "conanfile.py")
client.run('package "{0}" --build-folder="{2}"'
' --package-folder="{1}"'.format(
path, package_folder, build_folder))
self.assertEqual(
sorted(os.listdir(package_folder)),
sorted(
["include", "lib", "conaninfo.txt", "conanmanifest.txt"]))
content = load(os.path.join(package_folder, "include/file.h"))
self.assertEqual(content, "foo")
self.assertEqual(os.listdir(os.path.join(package_folder, "include")),
["file.h"])
self.assertEqual(os.listdir(os.path.join(package_folder, "lib")),
["mypkg.lib"])
def test_transitive_editables(self):
# https://github.com/conan-io/conan/issues/4445
libc_ref = ConanFileReference.loads("LibC/0.1@user/testing")
libb_ref = ConanFileReference.loads("LibB/0.1@user/testing")
client = TestClient()
conanfileC = GenConanfile()
client.save({"conanfile.py": str(conanfileC)})
client.run("editable add . LibC/0.1@user/testing")
client2 = TestClient(client.cache_folder)
conanfileB = GenConanfile().with_name("LibB").with_version(
"0.1").with_require(libc_ref)
client2.save({"conanfile.py": str(conanfileB)})
client2.run("create . user/testing")
conanfileA = GenConanfile().with_name("LibA").with_version("0.1")\
.with_require(libb_ref)\
.with_require(libc_ref)
client2.save({"conanfile.py": str(conanfileA)})
client2.run("install .")
client2.current_folder = os.path.join(client2.current_folder, "build")
mkdir(client2.current_folder)
client2.run("install ..")
def remove_setting_test(self):
# https://github.com/conan-io/conan/issues/2327
client = TestClient()
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
settings = "os", "build_type"
def configure(self):
del self.settings.build_type
def source(self):
self.settings.build_type
"""
client.save({"conanfile.py": conanfile})
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run(
"source .."
) # Without install you can access build_type, no one has removed it
client.run("install ..")
# This raised an error because build_type wasn't defined
client.run("build ..")
error = client.run("source ..", ignore_error=True)
self.assertTrue(error)
self.assertIn("'settings.build_type' doesn't exist",
client.user_io.out)
def test_export_source_folders(self):
client = TestClient()
conanfile = textwrap.dedent("""
from conans import ConanFile
from conans.tools import save, load
import os
class MethodConan(ConanFile):
def export_sources(self):
content = load(os.path.join(os.getcwd(), "data.txt"))
save(os.path.join(self.export_sources_folder, "myfile.txt"), content)
""")
client.save({
"recipe/conanfile.py": conanfile,
"recipe/data.txt": "mycontent"
})
client.run("export recipe pkg/0.1@")
layout = client.cache.package_layout(
ConanFileReference.loads("pkg/0.1"))
self.assertEqual(
"mycontent",
load(os.path.join(layout.export_sources(), "myfile.txt")))
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . pkg/0.1@")
layout = client.cache.package_layout(
ConanFileReference.loads("pkg/0.1"))
self.assertEqual(
"mycontent",
load(os.path.join(layout.export_sources(), "myfile.txt")))
def local_flow_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo",
CONANFILE: conanfile_template}
client.save(files)
origin_folder = client.current_folder
client.run("install -g env -g txt")
client.run("source")
client.run("build")
client.run("package .", ignore_error=True)
self.assertIn("ERROR: Cannot 'conan package' to the build folder", client.user_io.out)
package_folder = os.path.join(origin_folder, "package")
mkdir(package_folder)
client.current_folder = package_folder
client.run('package .. --build_folder=..')
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def git_to_capture_branch_test(self):
conanfile = """
import re
from conans import ConanFile, tools
def get_version():
git = tools.Git()
try:
branch = git.get_branch()
branch = re.sub('[^0-9a-zA-Z]+', '_', branch)
return "%s_%s" % (branch, git.get_revision())
except:
return None
class HelloConan(ConanFile):
name = "Hello"
version = get_version()
def build(self):
assert("r3le_ase__" in self.version)
assert(len(self.version) == 50)
"""
path, _ = create_local_git_repo({"conanfile.py": conanfile},
branch="r3le-ase-")
client = TestClient()
client.current_folder = path
client.run("create . user/channel")
def local_package_source_test(self, default_folder):
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
self.copy(pattern="*.lib")
"""
client.save({"src/include/file.h": "foo",
"build/lib/mypkg.lib": "mylib",
CONANFILE: conanfile_template})
recipe_folder = client.current_folder
client.current_folder = os.path.join(client.current_folder, "build")
client.run("install ..")
if default_folder:
package_folder = os.path.join(client.current_folder, "package")
client.run('package .. --build_folder=. --source_folder=../src ')
else:
package_folder = temp_folder()
client.run('package "{0}" --build_folder="{0}/build" '
'--package_folder="{1}" --source_folder="{0}/src"'.
format(recipe_folder, package_folder))
content = load(os.path.join(package_folder, "include/file.h"))
self.assertEqual(content, "foo")
self.assertEqual(sorted(os.listdir(package_folder)),
sorted(["include", "lib", "conaninfo.txt", "conanmanifest.txt"]))
self.assertEqual(os.listdir(os.path.join(package_folder, "include")), ["file.h"])
self.assertEqual(os.listdir(os.path.join(package_folder, "lib")), ["mypkg.lib"])
def local_flow_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo", CONANFILE: conanfile_template}
client.save(files)
origin_folder = client.current_folder
client.run("install -g env -g txt")
client.run("source")
client.run("build")
client.run("package .", ignore_error=True)
self.assertIn("ERROR: Cannot 'conan package' to the build folder",
client.user_io.out)
package_folder = os.path.join(origin_folder, "package")
mkdir(package_folder)
client.current_folder = package_folder
client.run('package .. --build_folder=..')
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def remove_runtime_test(self):
# https://github.com/conan-io/conan/issues/2327
client = TestClient()
conanfile = """from conans import ConanFile, CMake
class Pkg(ConanFile):
settings = "os", "compiler", "arch"
def configure(self):
del self.settings.compiler.runtime
def build(self):
try:
self.settings.compiler.runtime
except Exception as e:
self.output.info(str(e))
cmake = CMake(self)
self.output.info(cmake.command_line)
"""
client.save({"conanfile.py": conanfile})
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run(
'install .. -s os=Windows -s compiler="Visual Studio" -s compiler.version=15 -s arch=x86'
)
# This raised an error because build_type wasn't defined
client.run("build ..")
self.assertIn(
"'settings.compiler.runtime' doesn't exist for 'Visual Studio'",
client.out)
self.assertNotIn("CONAN_LINK_RUNTIME", client.out)
self.assertIn('-DCONAN_COMPILER="Visual Studio"', client.out)
def local_package_test(self, child_folder):
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
client.save({"include/file.h": "foo", CONANFILE: conanfile_template})
client.run("install")
recipe_folder = client.current_folder
if child_folder:
package_folder = os.path.join(client.current_folder, "package")
os.makedirs(package_folder)
else:
package_folder = temp_folder()
client.current_folder = package_folder
client.run('package "%s"' % recipe_folder)
content = load(os.path.join(package_folder, "include/file.h"))
self.assertEqual(content, "foo")
self.assertEqual(
sorted(os.listdir(package_folder)),
sorted(["include", "conaninfo.txt", "conanmanifest.txt"]))
self.assertEqual(os.listdir(os.path.join(package_folder, "include")),
["file.h"])
def basic_test(self, no_copy_source, cmake_install):
client = TestClient()
if not cmake_install:
package_code = """
def package(self):
self.copy("*.h", src="src", dst="include")
"""
else:
package_code = "cmake.install()"
conanfile = """from conans import ConanFile, CMake, load
import os
class Conan(ConanFile):
settings = "os", "compiler", "arch", "build_type"
exports_sources = "src/*"
no_copy_source = {}
def build(self):
cmake = CMake(self)
cmake.configure(source_folder="src",
cache_build_folder="build")
cmake.build()
{}
def package_info(self):
self.output.info("HEADER %s" % load(os.path.join(self.package_folder, "include/header.h")))
""".format(no_copy_source, package_code)
cmake = """set(CMAKE_CXX_COMPILER_WORKS 1)
project(Chat NONE)
cmake_minimum_required(VERSION 2.8.12)
file(READ header.h MYCONTENTS)
message(STATUS "HEADER CMAKE CONTENTS ${MYCONTENTS}")
install(FILES header.h DESTINATION include)
"""
client.save({
"conanfile.py": conanfile,
"src/CMakeLists.txt": cmake,
"src/header.h": "//myheader.h"
})
client.run("create . Hello/0.1@lasote/channel")
self.assertIn("Hello/0.1@lasote/channel: HEADER //myheader.h",
client.out)
self.assertIn("-- HEADER CMAKE CONTENTS //myheader.h", client.out)
# Now local flow
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install ..")
client.run("build ..") # same as --build-folder=. --source-folder=..
self.assertIn("-- HEADER CMAKE CONTENTS //myheader.h", client.out)
if not cmake_install:
client.run(
"package ..") # same as --build-folder=. --source-folder=..
self.assertTrue(
os.path.exists(os.path.join(build_folder, "conaninfo.txt")))
self.assertTrue(
os.path.exists(os.path.join(build_folder, "conanbuildinfo.txt")))
self.assertEqual(
load(os.path.join(build_folder, "package/include/header.h")),
"//myheader.h")
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 local_package_build_test(self, default_folder, conanfile_path):
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
self.copy(pattern="*.lib")
"""
client.save({"include/file.h": "foo",
"build/lib/mypkg.lib": "mylib",
CONANFILE: conanfile_template})
path = client.current_folder
client.current_folder = os.path.join(client.current_folder, "build")
client.run("install ..")
if default_folder:
package_folder = os.path.join(client.current_folder, "package")
path = "../conanfile.py" if conanfile_path else ".."
client.run('package {0} --build-folder=.'.format(path))
self.assertEqual(sorted(os.listdir(package_folder)),
sorted(["include", "lib", "conaninfo.txt", "conanmanifest.txt"]))
else:
package_folder = temp_folder()
client.current_folder = package_folder
build_folder = os.path.join(path, "build")
if conanfile_path:
path = os.path.join(path, "conanfile.py")
client.run('package "{0}" --build-folder="{2}"'
' --package-folder="{1}"'.format(path, package_folder, build_folder))
self.assertEqual(sorted(os.listdir(package_folder)),
sorted(["include", "lib", "conaninfo.txt",
"conanmanifest.txt"]))
content = load(os.path.join(package_folder, "include/file.h"))
self.assertEqual(content, "foo")
self.assertEqual(os.listdir(os.path.join(package_folder, "include")), ["file.h"])
self.assertEqual(os.listdir(os.path.join(package_folder, "lib")), ["mypkg.lib"])
def test_local_package_source(self, default_folder, conanfile_path):
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
self.copy(pattern="*.lib")
self.copy(pattern="myapp", src="bin", dst="bin")
"""
client.save({
"src/include/file.h": "foo",
"build/lib/mypkg.lib": "mylib",
"build/bin/myapp": "",
CONANFILE: conanfile_template
})
conanfile_folder = client.current_folder
path = conanfile_folder
client.current_folder = os.path.join(client.current_folder, "build")
client.run("install ..")
if default_folder:
package_folder = os.path.join(client.current_folder, "package")
path = "../conanfile.py" if conanfile_path else ".."
client.run(
'package {0} --build-folder=. --source-folder=../src'.format(
path))
else:
package_folder = temp_folder()
if conanfile_path:
path = os.path.join(path, "conanfile.py")
client.run(
'package "{0}" --build-folder="{1}/build" '
'--package-folder="{2}" --source-folder="{1}/src"'.format(
path, conanfile_folder, package_folder))
self.assertNotIn("package(): Packaged 1 \'\' file", client.out)
self.assertIn("package(): Packaged 1 file: myapp", client.out)
content = load(os.path.join(package_folder, "include/file.h"))
self.assertEqual(content, "foo")
self.assertEqual(
sorted(os.listdir(package_folder)),
sorted([
"include", "lib", "bin", "conaninfo.txt", "conanmanifest.txt"
]))
self.assertEqual(os.listdir(os.path.join(package_folder, "include")),
["file.h"])
self.assertEqual(os.listdir(os.path.join(package_folder, "lib")),
["mypkg.lib"])
self.assertEqual(os.listdir(os.path.join(package_folder, "bin")),
["myapp"])
def parallel_folders_test(self):
client = TestClient()
repo_folder = os.path.join(client.current_folder, "recipe")
src_folder = os.path.join(client.current_folder, "src")
build_folder = os.path.join(client.current_folder, "build")
package_folder = os.path.join(build_folder, "package")
mkdir(repo_folder)
mkdir(src_folder)
mkdir(build_folder)
mkdir(package_folder)
client.current_folder = repo_folder # equivalent to git clone recipe
client.save({"conanfile.py": conanfile_out})
client.current_folder = build_folder
client.run("install ../recipe")
client.current_folder = src_folder
client.run("install ../recipe")
client.run("source ../recipe")
client.current_folder = build_folder
client.run("build ../recipe --source-folder=../src")
client.current_folder = package_folder
client.run(
"package ../../recipe --source-folder=../../src --build-folder=../"
)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=../build/package")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(
cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def insource_build_test(self):
client = TestClient()
repo_folder = client.current_folder
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(package_folder)
client.save({"conanfile.py": conanfile,
"file.h": "file_h_contents!"})
client.run("install .")
client.run("build .")
client.current_folder = package_folder
client.run("package .. --build-folder=.. --package-folder='%s' " % package_folder)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf='%s' -if=." % package_folder)
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def test_insource_build(self):
client = TestClient()
repo_folder = client.current_folder
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(package_folder)
client.save({"conanfile.py": conanfile,
"file.h": "file_h_contents!"})
client.run("install .")
client.run("build .")
client.current_folder = package_folder
client.run("package .. --build-folder=.. --package-folder='%s' " % package_folder)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf='%s' -if=." % package_folder)
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.cache.package_layout(ref).packages()
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def insource_build_test(self):
client = TestClient()
repo_folder = client.current_folder
package_folder = os.path.join(client.current_folder, "pkg")
mkdir(package_folder)
client.save({"conanfile.py": conanfile_out})
client.run("install .")
client.run("source .")
client.run("build . ")
client.current_folder = package_folder
client.run("package .. --build-folder=.. --package_folder='%s'" % package_folder)
self._assert_pkg(package_folder)
client.current_folder = repo_folder
client.run("export . lasote/testing")
client.run("export-pkg . Pkg/0.1@lasote/testing -bf=./pkg")
ref = ConanFileReference.loads("Pkg/0.1@lasote/testing")
cache_package_folder = client.client_cache.packages(ref)
cache_package_folder = os.path.join(cache_package_folder,
os.listdir(cache_package_folder)[0])
self._assert_pkg(cache_package_folder)
def basic_test(self, no_copy_source, cmake_install):
client = TestClient()
if not cmake_install:
package_code = """
def package(self):
self.copy("*.h", src="src", dst="include")
"""
else:
package_code = "cmake.install()"
conanfile = """from conans import ConanFile, CMake, load
import os
class Conan(ConanFile):
settings = "os", "compiler", "arch", "build_type"
exports_sources = "src/*"
no_copy_source = {}
def build(self):
cmake = CMake(self)
cmake.configure(source_folder="src",
cache_build_folder="build")
cmake.build()
{}
def package_info(self):
self.output.info("HEADER %s" % load(os.path.join(self.package_folder, "include/header.h")))
""".format(no_copy_source, package_code)
cmake = """set(CMAKE_CXX_COMPILER_WORKS 1)
project(Chat NONE)
cmake_minimum_required(VERSION 2.8.12)
file(READ header.h MYCONTENTS)
message(STATUS "HEADER CMAKE CONTENTS ${MYCONTENTS}")
install(FILES header.h DESTINATION include)
"""
client.save({"conanfile.py": conanfile,
"src/CMakeLists.txt": cmake,
"src/header.h": "//myheader.h"})
client.run("create . Hello/0.1@lasote/channel")
self.assertIn("Hello/0.1@lasote/channel: HEADER //myheader.h", client.out)
self.assertIn("-- HEADER CMAKE CONTENTS //myheader.h", client.out)
# Now local flow
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install ..")
client.run("build ..") # same as --build-folder=. --source-folder=..
self.assertIn("-- HEADER CMAKE CONTENTS //myheader.h", client.out)
if not cmake_install:
client.run("package ..") # same as --build-folder=. --source-folder=..
self.assertTrue(os.path.exists(os.path.join(build_folder, "conaninfo.txt")))
self.assertTrue(os.path.exists(os.path.join(build_folder, "conanbuildinfo.txt")))
self.assertEqual(load(os.path.join(build_folder, "package/include/header.h")), "//myheader.h")
def basic_test(self, no_copy_source):
# meson > py 3.4
if sys.version_info[0] < 3 or sys.version_info[1] < 5:
return
client = TestClient()
conanfile = """from conans import ConanFile, Meson, load
import os
class Conan(ConanFile):
settings = "os", "compiler", "arch", "build_type"
exports_sources = "src/*"
no_copy_source = {}
def build(self):
meson = Meson(self)
meson.configure(source_folder="src",
cache_build_folder="build")
meson.build()
def package(self):
self.copy("*.h", src="src", dst="include")
def package_info(self):
self.output.info("HEADER %s" % load(os.path.join(self.package_folder, "include/header.h")))
""".format(no_copy_source)
meson = """project('hello', 'cpp', version : '0.1.0',
default_options : ['cpp_std=c++11'])
"""
client.save({
"conanfile.py": conanfile,
"src/meson.build": meson,
"src/header.h": "//myheader.h"
})
client.run("create %s Hello/0.1@lasote/channel" % path_dot())
self.assertIn("Hello/0.1@lasote/channel: HEADER //myheader.h",
client.out)
# Now local flow
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install ..")
client.run("build ..")
client.run("package ..")
self.assertTrue(
os.path.exists(os.path.join(build_folder, "conaninfo.txt")))
self.assertTrue(
os.path.exists(os.path.join(build_folder, "conanbuildinfo.txt")))
self.assertEqual(
load(os.path.join(build_folder, "package/include/header.h")),
"//myheader.h")
def remove_options_test(self):
# https://github.com/conan-io/conan/issues/2327
client = TestClient()
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
options = {"opt1": [True, False], "opt2": [True, False]}
default_options = "opt1=True", "opt2=False"
def config_options(self):
del self.options.opt2
"""
client.save({"conanfile.py": conanfile})
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install ..")
client.run("build ..")
def test_code_sibling(self):
# if provided a path with slash, it will use as a export base
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports = "../sibling/*.txt"
"""
files = {"recipe/conanfile.py": conanfile,
"sibling/file.txt": "Hello World!"}
client.save(files)
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
conan_ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.paths.export(conan_ref)
content = load(os.path.join(export_path, "file.txt"))
self.assertEqual("Hello World!", content)
def test_code_parent(self):
# when referencing the parent, the relative folder "sibling" will be kept
base = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports = "../*.txt"
"""
for conanfile in (base, base.replace("../*.txt", "../sibling*")):
client = TestClient()
client.save({"recipe/conanfile.py": conanfile,
"sibling/file.txt": "Hello World!"})
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.cache.package_layout(ref).export()
content = load(os.path.join(export_path, "sibling/file.txt"))
self.assertEqual("Hello World!", content)
def test_in_local_cache_flag(self):
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("export . lasote/stable")
client.run("install Hello0/0.1@lasote/stable --build missing")
self.assertIn("build() IN LOCAL CACHE=> True", client.user_io.out)
self.assertIn("package() IN LOCAL CACHE=> True", client.user_io.out)
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("install .")
client.run("build .")
self.assertIn("build() IN LOCAL CACHE=> False", client.user_io.out)
pack_folder = os.path.join(client.current_folder, "package")
os.mkdir(pack_folder)
client.current_folder = pack_folder
client.run("package .. --build-folder ..")
self.assertIn("package() IN LOCAL CACHE=> False", client.user_io.out)
# Confirm that we have the flag depending on the recipe too
client = TestClient()
client.save({CONANFILE: conanfile})
client.run("export . lasote/stable")
conanfile_reuse = """
from conans import ConanFile, tools
class OtherConan(ConanFile):
name = "Hello1"
version = "0.1"
requires = "Hello0/0.1@lasote/stable"
def build(self):
pass
"""
client.save({CONANFILE: conanfile_reuse}, clean_first=True)
client.run("install . --build")
self.assertIn("build() IN LOCAL CACHE=> True", client.user_io.out)
self.assertIn("package() IN LOCAL CACHE=> True", client.user_io.out)
client.run("export . lasote/stable")
client.run("install Hello1/0.1@lasote/stable --build")
self.assertIn("build() IN LOCAL CACHE=> True", client.user_io.out)
self.assertIn("package() IN LOCAL CACHE=> True", client.user_io.out)
def test_code_sibling(self):
# if provided a path with slash, it will use as a export base
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports = "../sibling/*.txt"
"""
files = {"recipe/conanfile.py": conanfile,
"sibling/file.txt": "Hello World!"}
client.save(files)
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.cache.package_layout(ref).export()
content = load(os.path.join(export_path, "file.txt"))
self.assertEqual("Hello World!", content)
def test_transitive_editables(self):
# https://github.com/conan-io/conan/issues/4445
client = TestClient()
conanfileC = TestConanFile("LibC", "0.1")
client.save({"conanfile.py": str(conanfileC)})
client.run("editable add . LibC/0.1@user/testing")
client2 = TestClient(client.cache_folder)
conanfileB = TestConanFile("LibB", "0.1", requires=["LibC/0.1@user/testing"])
client2.save({"conanfile.py": str(conanfileB)})
client2.run("create . user/testing")
conanfileA = TestConanFile("LibA", "0.1", requires=["LibB/0.1@user/testing",
"LibC/0.1@user/testing"])
client2.save({"conanfile.py": str(conanfileA)})
client2.run("install .")
client2.current_folder = os.path.join(client2.current_folder, "build")
mkdir(client2.current_folder)
client2.run("install ..")
def test_code_several_sibling(self):
# if provided a path with slash, it will use as a export base
client = TestClient()
conanfile = textwrap.dedent("""
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports_sources = "../test/src/*", "../cpp/*", "../include/*"
""")
client.save({"recipe/conanfile.py": conanfile,
"test/src/file.txt": "Hello World!",
"cpp/file.cpp": "Hello World!",
"include/file.h": "Hello World!"})
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.cache.package_layout(ref).export_sources()
self.assertEqual(sorted(['file.txt', 'file.cpp', 'file.h']),
sorted(os.listdir(export_path)))
def local_package_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo", CONANFILE: conanfile_template}
client.save(files)
client.run("install -g txt")
client.run("build")
origin_folder = client.current_folder
client.current_folder = temp_folder()
client.run('package "{0}" --build_folder="{0}"'.format(origin_folder))
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def test_code_several_sibling(self):
# if provided a path with slash, it will use as a export base
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports_sources = "../test/src/*", "../cpp/*", "../include/*"
"""
files = {"recipe/conanfile.py": conanfile,
"test/src/file.txt": "Hello World!",
"cpp/file.cpp": "Hello World!",
"include/file.h": "Hello World!"}
client.save(files)
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
conan_ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.paths.export_sources(conan_ref)
self.assertEqual(sorted(['file.txt', 'file.cpp', 'file.h']),
sorted(os.listdir(export_path)))
def local_package_test(self):
"""Use 'conan package' to process locally the package method"""
client = TestClient()
conanfile_template = """
from conans import ConanFile
class MyConan(ConanFile):
def package(self):
self.copy(pattern="*.h", dst="include", src="include")
"""
files = {"include/file.h": "foo",
CONANFILE: conanfile_template}
client.save(files)
client.run("install -g txt")
client.run("build")
origin_folder = client.current_folder
client.current_folder = temp_folder()
client.run('package "{0}" --build_folder="{0}"'.format(origin_folder))
content = load(os.path.join(client.current_folder, "include/file.h"))
self.assertEqual(content, "foo")
def test_code_parent(self):
""" when referencing the parent, the relative folder "sibling" will be kept
"""
base = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "1.2"
exports = "../*.txt"
"""
for conanfile in (base, base.replace("../*.txt", "../sibling*")):
client = TestClient()
files = {"recipe/conanfile.py": conanfile,
"sibling/file.txt": "Hello World!"}
client.save(files)
client.current_folder = os.path.join(client.current_folder, "recipe")
client.run("export . lasote/stable")
conan_ref = ConanFileReference("Hello", "1.2", "lasote", "stable")
export_path = client.paths.export(conan_ref)
content = load(os.path.join(export_path, "sibling/file.txt"))
self.assertEqual("Hello World!", content)
def remove_setting_test(self):
# https://github.com/conan-io/conan/issues/2327
client = TestClient()
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
settings = "os", "build_type"
def configure(self):
del self.settings.build_type
def source(self):
self.settings.build_type
"""
client.save({"conanfile.py": conanfile})
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("source ..", assert_error=True)
self.assertIn("'settings.build_type' doesn't exist", client.out)
# This doesn't fail, it doesn't access build_type
client.run("install ..")
client.run("build ..")
def remove_options_test(self):
# https://github.com/conan-io/conan/issues/2327
# https://github.com/conan-io/conan/issues/2781
client = TestClient()
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
options = {"opt1": [True, False], "opt2": [True, False]}
default_options = "opt1=True", "opt2=False"
def config_options(self):
del self.options.opt2
def build(self):
assert "opt2" not in self.options
self.options.opt2
"""
client.save({"conanfile.py": conanfile})
build_folder = os.path.join(client.current_folder, "build")
mkdir(build_folder)
client.current_folder = build_folder
client.run("install ..")
error = client.run("build ..", ignore_error=True)
self.assertTrue(error)
self.assertIn("ConanException: 'options.opt2' doesn't exist", client.out)
self.assertIn("Possible options are ['opt1']", client.out)
