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)