Exemplo n.º 1
0
    def test_txt(self):

        base = '''[requires]
lib/0.1@user/channel
'''
        extension = '''[requires]
lib/0.1@user/channel
otherlib/0.2@user/channel

[options]
otherlib:otherlib_option = 1
'''
        files = {"conanfile.txt": base,
                 "conanfile_dev.txt": extension}

        client = TestClient(self.base_folder)
        client.save(files)
        client.run("install --build")
        conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
        self.assertIn("lib/0.1@user/channel", conaninfo)
        self.assertNotIn("otherlib/0.2@user/channel", conaninfo)
        self.assertNotIn("otherlib:otherlib_option=1", conaninfo)

        client.run("install --build --file=conanfile_dev.txt")
        conaninfo = load(os.path.join(client.current_folder, "conaninfo.txt"))
        self.assertIn("lib/0.1@user/channel", conaninfo)
        self.assertIn("otherlib/0.2@user/channel", conaninfo)
        self.assertIn("otherlib:otherlib_option=1", conaninfo)
Exemplo n.º 2
0
class InstallUpdateTest(unittest.TestCase):

    def setUp(self):
        test_server = TestServer()
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})

    def reuse_test(self):
        files = cpp_hello_conan_files("Hello0", "1.0", build=False)

        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/1.0@lasote/stable --build")
        self.client.run("upload Hello0/1.0@lasote/stable --all")

        client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
        client2.run("install Hello0/1.0@lasote/stable")

        files["helloHello0.h"] = "//EMPTY!"
        self.client.save(files, clean_first=True)
        sleep(1)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/1.0@lasote/stable --build")
        self.client.run("upload Hello0/1.0@lasote/stable --all")

        client2.run("install Hello0/1.0@lasote/stable --update")
        ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
        package_ids = client2.paths.conan_packages(ref)
        package_path = client2.paths.package(PackageReference(ref, package_ids[0]))
        header = load(os.path.join(package_path, "include/helloHello0.h"))
        self.assertEqual(header, "//EMPTY!")
Exemplo n.º 3
0
    def setUp(self):
        client = TestClient()
        base = '''
from conans import ConanFile

class ConanLib(ConanFile):
    name = "lib"
    version = "0.1"
'''

        files = {"conanfile.py": base}
        client.save(files)
        client.run("export user/channel")
        base = '''
from conans import ConanFile

class ConanOtherLib(ConanFile):
    name = "otherlib"
    version = "0.2"
    options = {"otherlib_option": [1, 2, 3]}
    default_options="otherlib_option=3"
'''

        files = {"conanfile.py": base}
        client.save(files)
        client.run("export user/channel")

        self.base_folder = client.base_folder
Exemplo n.º 4
0
    def upload_test(self):
        test_server = TestServer([],  # write permissions
                                 users={"lasote": "mypass"})  # exported users and passwords
        servers = {"default": test_server}
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        files = {"conanfile.py": base}
        client.save(files)
        client.run("export lasote/channel")
        client.run("install lib/0.1@lasote/channel --build")
        client.run("upload lib/0.1@lasote/channel --all")
        client.run("remove lib/0.1@lasote/channel -f")
        client.run("search")
        self.assertIn("There are no packages", client.user_io.out)

        for download in ("", "--all"):
            client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
            client2.run("install lib/0.1@lasote/channel %s" % download)
            reference = ConanFileReference.loads("lib/0.1@lasote/channel")
            export_folder = client2.client_cache.export(reference)
            export_files = os.listdir(export_folder)
            self.assertNotIn('conan_export.tgz', export_files)
            package_ref = PackageReference.loads("lib/0.1@lasote/channel:"
                                                 "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
            package_folder = client2.client_cache.package(package_ref, short_paths=None)
            if platform.system() == "Windows":
                original_folder = client2.client_cache.package(package_ref)
                link = load(os.path.join(original_folder, ".conan_link"))
                self.assertEqual(link, package_folder)

            files = os.listdir(package_folder)
            self.assertIn("myfile.txt", files)
            self.assertIn("myfile2.txt", files)
            self.assertNotIn("conan_package.tgz", files)
Exemplo n.º 5
0
    def test_export_the_same_code(self):
        file_list = self._create_packages_and_builds()
        # Export the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        conan2.save(files2)
        conan2.run("export lasote/stable")
        reg_path2 = conan2.paths.export(self.conan_ref)
        digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
        self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
        self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
        self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
        self.assertIn('conanfile.py exported as %s in %s'
                      % (self.conan_ref, reg_path2), conan2.user_io.out)
        self.assertTrue(os.path.exists(reg_path2))

        for name in files2.keys():
            self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08',
                         'conanfile.py': '4df4b5266ad6d5d55cbdd0a8b12c9d1a',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest2.file_sums)

        for f in file_list:
            self.assertTrue(os.path.exists(f))
Exemplo n.º 6
0
    def test_export_a_new_version(self):
        self._create_packages_and_builds()
        # Export an update of the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
        conan2.save(files2)
        conan2.run("export lasote/stable")

        reg_path3 = conan2.paths.export(self.conan_ref)
        digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertIn('A new conanfile.py version was exported', conan2.user_io.out)
        # self.assertIn('All the previous packs were cleaned', conan2.user_io.out)
        self.assertIn('conanfile.py exported as %s in %s'
                      % (self.conan_ref, reg_path3), conan2.user_io.out)

        self.assertTrue(os.path.exists(reg_path3))

        for name in files2.keys():
            self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': '310d65b60943b879286cf8839cf9ba08',
                         'conanfile.py': '5a2c6e2d6b39638b7d8560786d7935a3',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest3.file_sums)
Exemplo n.º 7
0
 def copy_test(self):
     client = TestClient()
     client.save({CONANFILE: conanfile})
     client.run("export lasote/stable")
     client.run("install Hello0/0.1@lasote/stable --build=missing")
     error = client.run("copy hello0/0.1@lasote/stable otheruser/testing", ignore_error=True)
     self._check(error, client)
Exemplo n.º 8
0
    def complete_build_flow_test(self):
        """In local user folder"""
        client = TestClient()
        command = os.sep.join([".", "bin", "say_hello"])

        for install, lang, static in [("install", 0, True),
                                      ("install -o language=1", 1, True),
                                      ("install -o language=1 -o static=False", 1, False),
                                      ("install -o static=False", 0, False)]:
            dll_export = client.default_compiler_visual_studio and not static
            files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export)
            client.save(files)
            client.run(install)
            time.sleep(1)  # necessary so the conaninfo.txt is flushed to disc
            client.run('build')
            client.runner(command, client.current_folder)
            msg = "Hello" if lang == 0 else "Hola"
            self.assertIn("%s Hello0" % msg, client.user_io.out)
            conan_info_path = os.path.join(client.current_folder, CONANINFO)
            conan_info = ConanInfo.loads(load(conan_info_path))
            self.assertTrue(conan_info.full_options.language == lang)
            if static:
                self.assertTrue(conan_info.full_options.static)
            else:
                self.assertFalse(conan_info.full_options.static)
Exemplo n.º 9
0
    def basic_source_test(self):
        conanfile = """
from conans import ConanFile

class ConanLib(ConanFile):
    name = "Hello"
    version = "0.1"

    def source(self):
        self.output.info("Running source!")
"""
        client = TestClient()
        client.save({CONANFILE: conanfile})
        client.run("export lasote/stable")
        client.run("source Hello/0.1@lasote/stable")
        self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
        self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)

        # The second call shouldn't have effect
        client.run("source Hello/0.1@lasote/stable")
        self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
        self.assertNotIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)

        # Forced should have effect
        client.run("source Hello/0.1@lasote/stable --force")
        self.assertIn("WARN: Forced removal of source folder", client.user_io.out)
        self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out)
        self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
Exemplo n.º 10
0
class InstallUpdateTest(unittest.TestCase):

    def setUp(self):
        test_server = TestServer([("*/*@*/*", "*")],  # read permissions
                                 [],  # write permissions
                                 users={"lasote": "mypass"})  # exported users and passwords
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})

    def reuse_test(self):
        files = cpp_hello_conan_files("Hello0", "1.0")
        # To avoid building
        files[CONANFILE] = files[CONANFILE].replace("build(", "build2(")
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/1.0@lasote/stable --build")
        self.client.run("upload Hello0/1.0@lasote/stable --all")

        client2 = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
        client2.run("install Hello0/1.0@lasote/stable")

        files["helloHello0.h"] = "//EMPTY!"
        self.client.save(files, clean_first=True)
        sleep(1)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/1.0@lasote/stable --build")
        self.client.run("upload Hello0/1.0@lasote/stable --all")

        client2.run("install Hello0/1.0@lasote/stable --update")
        ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
        package_ids = client2.paths.conan_packages(ref)
        package_path = client2.paths.package(PackageReference(ref, package_ids[0]))
        header = load(os.path.join(package_path, "include/helloHello0.h"))
        self.assertEqual(header, "//EMPTY!")
Exemplo n.º 11
0
    def test_export_the_same_code(self):
        file_list = self._create_packages_and_builds()
        # Export the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        conan2.save(files2)
        conan2.run("export lasote/stable")
        reg_path2 = conan2.paths.export(self.conan_ref)
        digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
        self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
        self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
        self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
        self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref),
                      self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
        self.assertTrue(os.path.exists(reg_path2))

        for name in files2.keys():
            self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': 'f21a98d974e9294b0d709070042c6e78',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest2.file_sums)

        for f in file_list:
            self.assertTrue(os.path.exists(f))
Exemplo n.º 12
0
    def fail_test_package_test(self):
        client = TestClient()
        conanfile = """
from conans import ConanFile

class HelloConan(ConanFile):
    name = "Hello"
    version = "0.1"
    exports = "*"

    def package(self):
        self.copy("*")
"""
        test_conanfile = """
from conans import ConanFile, CMake
import os

class HelloReuseConan(ConanFile):
    requires = "Hello/0.1@lasote/stable"

    def test(self):
        self.conanfile_directory
"""
        client.save({"conanfile.py": conanfile,
                     "FindXXX.cmake": "Hello FindCmake",
                     "test/conanfile.py": test_conanfile})
        client.run("test_package")
        ref = PackageReference.loads("Hello/0.1@lasote/stable:"
                                     "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
        self.assertEqual("Hello FindCmake",
                         load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
        client.save({"FindXXX.cmake": "Bye FindCmake"})
        client.run("test_package")
        self.assertEqual("Bye FindCmake",
                         load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
Exemplo n.º 13
0
    def scopes_test_package_test(self):
        client = TestClient()
        conanfile = """
from conans import ConanFile

class HelloConan(ConanFile):
    name = "Hello"
    version = "0.1"

    def build(self):
        self.output.info("Scope: %s" % self.scope)
"""
        test_conanfile = """
from conans import ConanFile, CMake
import os

class HelloReuseConan(ConanFile):
    requires = "Hello/0.1@lasote/stable"

    def test(self):
        self.conanfile_directory
"""
        client.save({"conanfile.py": conanfile,
                     "test/conanfile.py": test_conanfile})
        client.run("test_package --scope Hello:dev=True --build=missing")
        self.assertIn("Hello/0.1@lasote/stable: Scope: dev=True", client.user_io.out)
Exemplo n.º 14
0
    def test_export_a_new_version(self):
        self._create_packages_and_builds()
        # Export an update of the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
        conan2.save(files2)
        conan2.run("export lasote/stable")

        reg_path3 = conan2.paths.export(self.conan_ref)
        digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertIn('A new conanfile.py version was exported', conan2.user_io.out)
        self.assertIn('%s: conanfile.py exported to local storage' % str(self.conan_ref),
                      self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out)

        self.assertTrue(os.path.exists(reg_path3))

        for name in files2.keys():
            self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': 'c5889ea6485599c7a0cae02b54270b35',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest3.file_sums)
Exemplo n.º 15
0
    def change_option_txt_test(self):
        self._create("Hello0", "0.1")

        client = TestClient(base_folder=self.client.base_folder)
        files = {CONANFILE_TXT: """[requires]
        Hello0/0.1@lasote/stable

        [options]
        Hello0:language=1
        """}
        client.save(files)

        client.run("install %s --build missing" % self.settings)
        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        self.assertIn("Hello0:language=1", conan_info.full_options.dumps())
        self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b",
                      conan_info.full_requires.dumps())

        files = {CONANFILE_TXT: """[requires]
        Hello0/0.1@lasote/stable

        [options]
        Hello0:language=0
        """}
        client.save(files)
        client.run("install %s --build missing" % self.settings)

        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
        self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
                      conan_info.full_requires.dumps())
Exemplo n.º 16
0
    def check_multi_server_test(self):
        # Check what happen if we have 2 servers and one is outdated
        # The expected behavior: If we specify the remote with (-r), the commmand will fail
        # if the client fot that remote is outdated. If we are just looking for a package (not with -r)
        # the client will look for the package on each remote.

        # Client deprecated for "the_last_server" but OK for "normal_server"
        self.servers = OrderedDict({"the_last_server": self._get_server(10, 4),
                                    "normal_server": self._get_server(4, 2)})

        # First upload a package ok with an ok client
        tmp_client = TestClient(servers=self.servers,
                                users=[("lasote", "mypass")], client_version=4)
        files = cpp_hello_conan_files("Hello0", "0.1")
        tmp_client.save(files)
        tmp_client.run("export lasote/stable")
        errors = tmp_client.run("upload Hello0/0.1@lasote/stable -r normal_server --all")
        errors |= tmp_client.run("upload Hello0/0.1@lasote/stable -r the_last_server --all")
        self.assertFalse(errors)

        # Now with a conflictive client...try to look in servers
        self.client = TestClient(servers=self.servers,
                                 users=[("lasote", "mypass")], client_version=2)
        errors = self.client.run("search something -r the_last_server", ignore_error=True)
        self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
        self.assertTrue(errors)  # Errors

        errors = self.client.run("install Hello0/0.1@lasote/stable --build missing", ignore_error=True)
        self.assertIn("Your conan's client version is deprecated for the current remote (v10). Upgrade conan client.", self.client.user_io.out)
        self.assertFalse(errors)  # No Errors! because it finds the package in the second remote
Exemplo n.º 17
0
    def _test_with_conanfile(self, test_conanfile):
        client = TestClient()
        files = cpp_hello_conan_files("Hello0", "0.1")
        print_build = 'self.output.warn("BUILD_TYPE=>%s" % self.settings.build_type)'
        files[CONANFILE] = files[CONANFILE].replace("def build(self):",
                                                    'def build(self):\n        %s' % print_build)

        # Add build_type setting
        files[CONANFILE] = files[CONANFILE].replace(', "arch"',
                                                    ', "arch", "build_type"')

        cmakelist = """PROJECT(MyHello)
cmake_minimum_required(VERSION 2.8)

include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
conan_basic_setup()

ADD_EXECUTABLE(greet main.cpp)
TARGET_LINK_LIBRARIES(greet ${CONAN_LIBS})
"""
        files["test_package/CMakeLists.txt"] = cmakelist
        files["test_package/conanfile.py"] = test_conanfile
        files["test_package/main.cpp"] = files["main.cpp"]
        client.save(files)
        client.run("export lasote/stable")
        error = client.run("test -s build_type=Release")
        self.assertFalse(error)
        self.assertNotIn("Project: WARN: conanbuildinfo.txt file not found", client.user_io.out)
        self.assertNotIn("Project: WARN: conanenv.txt file not found", client.user_io.out)
        self.assertIn('Hello Hello0', client.user_io.out)
        error = client.run("test -s Hello0:build_type=Debug -o Hello0:language=1")
        self.assertFalse(error)
        self.assertIn('Hola Hello0', client.user_io.out)
        self.assertIn('BUILD_TYPE=>Debug', client.user_io.out)
Exemplo n.º 18
0
    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 ..')
        content = load(os.path.join(client.current_folder, "include/file.h"))
        self.assertEqual(content, "foo")
Exemplo n.º 19
0
    def build_policies_update_test(self):
        client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
        conanfile = """
from conans import ConanFile

class MyPackage(ConanFile):
    name = "test"
    version = "1.9"
    build_policy = 'always'

    def source(self):
        self.output.info("Getting sources")
    def build(self):
        self.output.info("Building sources")
    def package(self):
        self.output.info("Packaging this test package")
        """

        files = {CONANFILE: conanfile}
        client.save(files, clean_first=True)
        client.run("export lasote/stable")
        client.run("install test/1.9@lasote/stable")
        self.assertIn("Getting sources", client.user_io.out)
        self.assertIn("Building sources", client.user_io.out)
        self.assertIn("Packaging this test package", client.user_io.out)
        self.assertIn("Building package from source as defined by build_policy='always'",
                      client.user_io.out)
        client.run("upload test/1.9@lasote/stable")
Exemplo n.º 20
0
    def package_errors_test(self):
        client = TestClient()
        client.run("package whatever@user/channel", ignore_error=True)
        self.assertIn("Wrong package recipe", client.user_io.out)

        client.run("package whatever/1.0@user/channel", ignore_error=True)
        self.assertIn("ERROR: Package recipe 'whatever/1.0@user/channel' does not exist",
                      client.user_io.out)

        conanfile_template = """
from conans import ConanFile

class MyConan(ConanFile):
    name = "MyLib"
    version = "0.1"
"""
        client.save({CONANFILE: conanfile_template})
        client.run("export lasote/stable")
        client.run("package MyLib/0.1@lasote/stable", ignore_error=True)
        self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally",
                      client.user_io.out)

        builds_dir = client.paths.builds(ConanFileReference.loads("MyLib/0.1@lasote/stable"))
        os.makedirs(builds_dir)
        client.run("package MyLib/0.1@lasote/stable", ignore_error=True)
        self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package recipe has not been built locally",
                      client.user_io.out)

        client.run("package MyLib/0.1@lasote/stable 1234", ignore_error=True)
        self.assertIn("ERROR: MyLib/0.1@lasote/stable: Package binary '1234' folder doesn't exist",
                      client.user_io.out)
Exemplo n.º 21
0
    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):
    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
        build_folder = os.path.join(client.current_folder, "build")
        mkdir(build_folder)
        client.current_folder = build_folder
        client.run("install .. -g env -g txt")
        client.run("source ..")
        client.run("build ..")
        client.current_folder = temp_folder()
        client.run('package "%s/build"' % origin_folder)
        content = load(os.path.join(client.current_folder, "include/file.h"))
        self.assertEqual(content, "foo")
Exemplo n.º 22
0
    def upload_reuse_test(self):
        server = TestServer()
        servers = {"default": server}
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        client.save({CONANFILE: conanfile, "__init__.py": "", "mytest.py": test})
        client.run("export lasote/stable")

        client.save({CONANFILE: reuse}, clean_first=True)
        client.run("export lasote/stable")
        client.run("install Consumer/0.1@lasote/stable --build")
        lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
                 if line.startswith("Consumer/0.1@lasote/stable: Hello")]
        self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
                         lines)

        client.run("upload conantool/1.0@lasote/stable --all")
        client.run("remove * -f")
        client.run("search")
        self.assertNotIn("lasote/stable", client.user_io.out)
        client.run("export lasote/stable")
        client.run("install Consumer/0.1@lasote/stable --build")
        lines = [line.split(":")[1] for line in str(client.user_io.out).splitlines()
                 if line.startswith("Consumer/0.1@lasote/stable: Hello")]
        self.assertEqual([' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'],
                         lines)
        # Try again, just in case
        client.run("upload conantool/1.0@lasote/stable --all")
        client.run("remove * -f -r=default")
        client.run("upload conantool/1.0@lasote/stable --all")
Exemplo n.º 23
0
    def test_path(self):
        base_folder = temp_folder()
        source_folder = os.path.join(base_folder, "source")
        current_folder = os.path.join(base_folder, "current")
        client = TestClient(current_folder=current_folder)
        files = cpp_hello_conan_files("Hello0", "0.1")
        conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
        conanfile = files.pop("conanfile.py")
        client.save(files, path=source_folder)
        conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"')

        client.save({"conanfile.py": conanfile})
        client.run("export lasote/stable")
        reg_path = client.paths.export(conan_ref)
        manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))

        self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
                      client.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
        self.assertTrue(os.path.exists(reg_path))

        for name in ['conanfile.py', 'conanmanifest.txt', 'source/main.cpp',
                     'source/executable', 'source/hello.cpp', 'source/CMakeLists.txt',
                     'source/helloHello0.h']:
            self.assertTrue(os.path.exists(os.path.join(reg_path, name)))

        expected_sums = {'source/hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'source/main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'source/CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': 'c0bb94a3da6eb978cb94f5faff037ed3',
                         'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)
Exemplo n.º 24
0
    def test_rel_path(self):
        base_folder = temp_folder()
        source_folder = os.path.join(base_folder, "source")
        current_folder = os.path.join(base_folder, "current")
        os.makedirs(current_folder)
        client = TestClient(current_folder=current_folder)
        files = cpp_hello_conan_files("Hello0", "0.1")
        conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
        client.save(files, path=source_folder)
        client.run("export lasote/stable --path=../source")
        reg_path = client.paths.export(conan_ref)
        manif = FileTreeManifest.loads(load(client.paths.digestfile_conanfile(conan_ref)))

        self.assertIn('%s: A new conanfile.py version was exported' % str(conan_ref),
                      client.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(conan_ref), reg_path), client.user_io.out)
        self.assertTrue(os.path.exists(reg_path))

        for name in list(files.keys()):
            self.assertTrue(os.path.exists(os.path.join(reg_path, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': '5632cf850a7161388ab24f42b9bdb3fd',
                         'executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)
Exemplo n.º 25
0
    def global_test(self):
        client = TestClient()
        files = {'conanfile.py': base_conanfile.replace("%GLOBAL%",
                                                        "self.global_system_requirements=True")}
        client.save(files)
        client.run("export user/testing")
        client.run("install Test/0.1@user/testing --build missing")
        self.assertIn("*+Running system requirements+*", client.user_io.out)
        conan_ref = ConanFileReference.loads("Test/0.1@user/testing")
        package_ref = PackageReference(conan_ref, "a527106fd9f2e3738a55b02087c20c0a63afce9d")
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
        load_file = load(client.paths.system_reqs(conan_ref))
        self.assertIn("Installed my stuff", load_file)

        # Run again
        client.run("install Test/0.1@user/testing --build missing")
        self.assertNotIn("*+Running system requirements+*", client.user_io.out)
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
        load_file = load(client.paths.system_reqs(conan_ref))
        self.assertIn("Installed my stuff", load_file)

        # Run with different option
        client.run("install Test/0.1@user/testing -o myopt=False --build missing")
        self.assertNotIn("*+Running system requirements+*", client.user_io.out)
        package_ref2 = PackageReference(conan_ref, "54c9626b48cefa3b819e64316b49d3b1e1a78c26")
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2)))
        load_file = load(client.paths.system_reqs(conan_ref))
        self.assertIn("Installed my stuff", load_file)

        # remove packages
        client.run("remove Test* -f -p")
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref)))
        self.assertFalse(os.path.exists(client.paths.system_reqs_package(package_ref2)))
        self.assertFalse(os.path.exists(client.paths.system_reqs(conan_ref)))
Exemplo n.º 26
0
 def test_no_remotes(self):
     client = TestClient()
     files = cpp_hello_conan_files("Hello0", "0.1")
     client.save(files)
     client.run("export lasote/stable")
     client.run("upload Hello0/0.1@lasote/stable", ignore_error=True)
     self.assertIn("ERROR: No default remote defined", client.user_io.out)
Exemplo n.º 27
0
    def test_clean(self):
        test_server = TestServer()
        servers = {"default": test_server}
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        base = '''
from conans import ConanFile

class ConanLib(ConanFile):
    name = "lib"
    version = "0.1"
'''

        files = {"conanfile.py": base}
        client.save(files)
        client.run("export lasote/stable")
        client.run("upload lib/0.1@lasote/stable")
        client.run("user")
        self.assertIn("Current 'default' user: lasote", client.user_io.out)
        client.run("user --clean")
        client.run("user")
        self.assertNotIn("lasote", client.user_io.out)
        self.assertEqual("Current 'default' user: None (anonymous)\n", client.user_io.out)
        client.run("upload lib/0.1@lasote/stable")
        client.run("user")
        self.assertIn("Current 'default' user: lasote", client.user_io.out)
Exemplo n.º 28
0
    def large_project_test(self):
        client = TestClient()
        num = 250
        deep = True  # True for N ... -> 3 -> 2 -> 1 -> 0, False for N -> 0, 3-> 0, 2->0, 1->0
        for i in range(num):
            if i == 0:
                files = cpp_hello_conan_files("Hello0", "0.1", build=False)
            else:
                if not deep:
                    files = cpp_hello_conan_files("Hello%d" % i, "0.1",
                                                  ["Hello0/0.1@lasote/stable"], build=False)
                else:
                    files = cpp_hello_conan_files("Hello%d" % i, "0.1",
                                                  ["Hello%s/0.1@lasote/stable" % (i-1)],
                                                  build=False)

            client.save(files, clean_first=True)
            client.run("export lasote/stable")

        # Now lets depend on it
        if deep:
            files = cpp_hello_conan_files("HelloFinal", "0.1",
                                          ["Hello%s/0.1@lasote/stable" % (num - 1)], build=False)
        else:
            files = cpp_hello_conan_files("HelloFinal", "0.1",
                                          ["Hello%s/0.1@lasote/stable" % (i) for i in range(num)],
                                          build=False)

        client.save(files, clean_first=True)
        t1 = time.time()
        client.run("install --build")
        print("Final time with build %s" % (time.time() - t1))
        t1 = time.time()
        client.run("install")
        print("Final time %s" % (time.time() - t1))
Exemplo n.º 29
0
    def no_signature_test(self):
        auth = AuthorizationHeaderSpy()
        retur = ReturnHandlerPlugin()
        server = TestServer(plugins=[auth, retur])
        server.app
        servers = {"default": server}
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        client.save({"conanfile.py": conanfile})
        client.run("export lasote/stable")
        errors = client.run("upload Hello/0.1@lasote/stable")
        self.assertFalse(errors)

        expected_calls = [('get_conan_digest_url', None),
                          ('check_credentials', None),
                          ('authenticate', 'Basic'),
                          ('get_conanfile_snapshot', 'Bearer'),
                          ('get_conanfile_upload_urls', 'Bearer'),
                          ('put', 'Bearer')]

        self.assertEqual(len(expected_calls), len(auth.auths))
        for i, (method, auth_type) in enumerate(expected_calls):
            real_call = auth.auths[i]
            self.assertEqual(method, real_call[0])
            if auth_type:
                self.assertIn(auth_type, real_call[1])

        # The Bearer of the last two calls must be identical
        self.assertEqual(auth.auths[-1][1], auth.auths[-2][1])
Exemplo n.º 30
0
class ConfigureEnvironmentTest(unittest.TestCase):

    def setUp(self):
        self.client = TestClient()

    def build_with_profile_test(self):
        self._create_profile("scopes_env", {},
                             {},  # undefined scope do not apply to my packages
                             {"CXX": "/path/tomy/g++_build", "CC": "/path/tomy/gcc_build"})

        self.client.save({CONANFILE: conanfile_dep})
        self.client.run("export lasote/testing")

        self.client.save({CONANFILE: conanfile_scope_env}, clean_first=True)
        self.client.run("install --build=missing")
        self.client.run("build -pr scopes_env")
        self.assertRegexpMatches(str(self.client.user_io.out), "PATH=['\"]?/path/to/my/folder")
        self._assert_env_variable_printed("CC", "/path/tomy/gcc_build")
        self._assert_env_variable_printed("CXX", "/path/tomy/g++_build")

    def _assert_env_variable_printed(self, name, value):
        if platform.system() == "Windows":
            self.assertIn("%s=%s" % (name, value), self.client.user_io.out)
        elif platform.system() == "Darwin":
            self.assertIn('%s="%s"' % (name, value), self.client.user_io.out)
        else:
            self.assertIn("%s='%s'" % (name, value), self.client.user_io.out)

    def _create_profile(self, name, settings, scopes=None, env=None):
        profile = Profile()
        profile.settings = settings or {}
        if scopes:
            profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])
        profile.env = env or {}
        save(self.client.client_cache.profile_path(name), profile.dumps())
Exemplo n.º 31
0
class MultiRemoteTest(unittest.TestCase):
    def setUp(self):
        self.servers = OrderedDict()
        self.users = {}
        for i in range(3):
            test_server = TestServer(
                [("*/*@*/*", "*")],  # read permissions
                [],  # write permissions
                users={"lasote": "mypass"})  # exported users and passwords
            self.servers["remote%d" % i] = test_server
            self.users["remote%d" % i] = [("lasote", "mypass")]

        self.client = TestClient(servers=self.servers, users=self.users)

    def upload_test(self):
        conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1")
        files["conanfile.py"] = files["conanfile.py"].replace(
            "def build(", "def build2(")
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("upload %s" % str(conan_reference))

        self.client.run("info %s" % str(conan_reference))
        self.assertIn("remote0=http://", self.client.user_io.out)

        # The remote, once fixed does not change
        self.client.run("upload %s -r=remote1" % str(conan_reference))
        self.client.run("info %s" % str(conan_reference))
        self.assertIn("remote0=http://", self.client.user_io.out)

        # Now install it in other machine from remote 0
        client2 = TestClient(servers=self.servers, users=self.users)
        client2.run("install %s --build=missing" % str(conan_reference))
        client2.run("info %s" % str(conan_reference))
        self.assertIn("remote0=http://", client2.user_io.out)

        # Now install it in other machine from remote 1
        servers = self.servers.copy()
        servers.pop("remote0")
        client3 = TestClient(servers=servers, users=self.users)
        client3.run("install %s --build=missing" % str(conan_reference))
        client3.run("info %s" % str(conan_reference))
        self.assertIn("remote1=http://", client3.user_io.out)

    def install_from_remotes_test(self):
        for i in range(3):
            conan_reference = ConanFileReference.loads(
                "Hello%d/0.1@lasote/stable" % i)
            files = cpp_hello_conan_files("Hello%d" % i, "0.1")
            files["conanfile.py"] = files["conanfile.py"].replace(
                "def build(", "def build2(")
            self.client.save(files)
            self.client.run("export lasote/stable")
            self.client.run("upload %s -r=remote%d" %
                            (str(conan_reference), i))

            self.client.run("info %s" % str(conan_reference))
            self.assertIn("remote%d=http://" % i, self.client.user_io.out)

        # Now install it in other machine from remote 0
        client2 = TestClient(servers=self.servers, users=self.users)
        conan_reference = ConanFileReference.loads("HelloX/0.1@lasote/stable")
        files = cpp_hello_conan_files("HelloX",
                                      "0.1",
                                      deps=[
                                          "Hello0/0.1@lasote/stable",
                                          "Hello1/0.1@lasote/stable",
                                          "Hello2/0.1@lasote/stable"
                                      ])
        files["conanfile.py"] = files["conanfile.py"].replace(
            "def build(", "def build2(")
        client2.save(files)
        client2.run("install --build=missing")
        self.assertIn("Hello0/0.1@lasote/stable from remote0",
                      client2.user_io.out)
        self.assertIn("Hello1/0.1@lasote/stable from remote1",
                      client2.user_io.out)
        self.assertIn("Hello2/0.1@lasote/stable from remote2",
                      client2.user_io.out)
        client2.run("info")
        self.assertIn("Remote: remote0=http://", client2.user_io.out)
        self.assertIn("Remote: remote1=http://", client2.user_io.out)
        self.assertIn("Remote: remote2=http://", client2.user_io.out)
Exemplo n.º 32
0
class SearchTest(unittest.TestCase):

    def setUp(self):
        self.servers = {"local": TestServer()}
        self.client = TestClient(servers=self.servers)

        # No conans created
        self.client.run("search")
        output = self.client.user_io.out
        self.assertIn('There are no packages', output)

        # Conans with and without packages created
        self.root_folder1 = 'Hello/1.4.10/fenix/testing'
        root_folder2 = 'helloTest/1.4.10/fenix/stable'
        root_folder3 = 'Bye/0.14/fenix/testing'
        root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
        root_folder5 = 'MissFile/1.0.2/fenix/stable'
        root_folder11 = 'Hello/1.4.11/fenix/testing'
        root_folder12 = 'Hello/1.4.12/fenix/testing'

        self.client.save({"Empty/1.10/fake/test/reg/fake.txt": "//",
                          "%s/%s/WindowsPackageSHA/%s" % (self.root_folder1,
                                                          PACKAGES_FOLDER,
                                                          CONANINFO): conan_vars1,
                          "%s/%s/WindowsPackageSHA/%s" % (root_folder11,
                                                          PACKAGES_FOLDER,
                                                          CONANINFO): conan_vars1,
                          "%s/%s/WindowsPackageSHA/%s" % (root_folder12,
                                                          PACKAGES_FOLDER,
                                                          CONANINFO): conan_vars1,
                          "%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1,
                                                               PACKAGES_FOLDER,
                                                               CONANINFO): conan_vars1b,
                          "%s/%s/LinuxPackageSHA/%s" % (self.root_folder1,
                                                        PACKAGES_FOLDER,
                                                        CONANINFO): conan_vars1c,
                          "%s/%s/a44f541cd44w57/%s" % (root_folder2,
                                                       PACKAGES_FOLDER,
                                                       CONANINFO): conan_vars2,
                          "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3,
                                                       PACKAGES_FOLDER,
                                                       CONANINFO): conan_vars3,
                          "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4,
                                                       PACKAGES_FOLDER,
                                                       CONANINFO): conan_vars4,
                          "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5,
                                                       PACKAGES_FOLDER,
                                                       "hello.txt"): "Hello"},
                         self.client.paths.store)

        # Fake some manifests to be able to calculate recipe hash
        fake_manifest = FileTreeManifest(1212, {})
        self.client.save({os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
                          os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
                          os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
                          os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST): str(fake_manifest),
                          },
                         self.client.paths.store)

    def recipe_search_test(self):
        self.client.run("search Hello*")
        self.assertEquals("Existing package recipes:\n\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n"
                          "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

        self.client.run("search Hello* --case-sensitive")
        self.assertEquals("Existing package recipes:\n\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n",
                          self.client.user_io.out)

        self.client.run("search *fenix* --case-sensitive")
        self.assertEquals("Existing package recipes:\n\n"
                          "Bye/0.14@fenix/testing\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n"
                          "MissFile/1.0.2@fenix/stable\n"
                          "NodeInfo/1.0.2@fenix/stable\n"
                          "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

    def recipe_pattern_search_test(self):
        self.client.run("search Hello*")
        self.assertEquals("Existing package recipes:\n\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n"
                          "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

        self.client.run("search Hello* --case-sensitive")
        self.assertEquals("Existing package recipes:\n\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n", self.client.user_io.out)

        self.client.run("search *fenix* --case-sensitive")
        self.assertEquals("Existing package recipes:\n\n"
                          "Bye/0.14@fenix/testing\n"
                          "Hello/1.4.10@fenix/testing\n"
                          "Hello/1.4.11@fenix/testing\n"
                          "Hello/1.4.12@fenix/testing\n"
                          "MissFile/1.0.2@fenix/stable\n"
                          "NodeInfo/1.0.2@fenix/stable\n"
                          "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

    def package_search_with_invalid_reference_test(self):
        self.client.run("search Hello -q 'a=1'", ignore_error=True)
        self.assertIn("-q parameter only allowed with a valid recipe", str(self.client.user_io.out))

    def package_search_with_empty_query_test(self):
        self.client.run("search Hello/1.4.10/fenix/testing")
        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

    def package_search_nonescaped_characters_test(self):
        self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"')
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"')
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        # Now search with a remote
        os.rmdir(self.servers["local"].paths.store)
        shutil.copytree(self.client.paths.store, self.servers["local"].paths.store)
        self.client.run("remove Hello* -f")
        self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local')
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local')
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

    def package_search_with_invalid_query_test(self):
        self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'", ignore_error=True)
        self.assertIn("Invalid package query: invalid", self.client.user_io.out)

    def package_search_properties_filter_test(self):

        # All packages without filter
        self.client.run("search Hello/1.4.10/fenix/testing -q ''")

        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows')
        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"')
        self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"')
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"')
        self.assertIn("There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"')
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"')
        # One package will be outdated from recipe and another don't
        self.assertEquals("""Existing packages for recipe Hello/1.4.10@fenix/testing:

    Package_ID: LinuxPackageSHA
        [options]
            use_Qt: False
        [settings]
            arch: x86
            compiler: gcc
            compiler.libcxx: libstdc++11
            compiler.version: 4.5
            os: Linux
        [requires]
            Hello2/0.1@lasote/stable:11111
            HelloInfo1/0.45@fenix/testing:33333
            OpenSSL/2.10@lasote/testing:2222
        outdated from recipe: False

    Package_ID: PlatformIndependantSHA
        [options]
            use_Qt: True
        [settings]
            arch: x86
            compiler: gcc
            compiler.libcxx: libstdc++
            compiler.version: 4.3
        outdated from recipe: True

""", self.client.user_io.out)

        self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=False')
        self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
                      "matching the query 'use_OpenGL=False'", self.client.user_io.out)

        self.client.run('search helloTest/1.4.10@fenix/stable -q use_OpenGL=True')
        self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out)

        self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"')
        self.assertIn("Existing packages for recipe helloTest/1.4.10@fenix/stable", self.client.user_io.out)

        self.client.run('search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"')
        self.assertIn("There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
                      "matching the query 'use_OpenGL=True AND arch=x86'", self.client.user_io.out)

    def search_with_no_local_test(self):
        client = TestClient()
        client.run("search nonexist/1.0@lasote/stable")
        self.assertIn("There are no packages", self.client.user_io.out)
Exemplo n.º 33
0
    def cmake_multi_test(self):
        if platform.system() == "Windows":
            generator = "Visual Studio 14 Win64"
            debug_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MDd'
            release_install = '-s compiler="Visual Studio" -s compiler.version=14 -s compiler.runtime=MD'
        elif platform.system() == "Darwin":
            generator = "Xcode"
            debug_install = ''
            release_install = ''
        else:
            return
        client = TestClient()

        def prepare_files(files, number):
            # Change language according to build_type, to check
            orig = "lang = '-DCONAN_LANGUAGE=%s' % self.options.language"
            replace = "lang = '-DCONAN_LANGUAGE=%s' % (0 if self.settings.build_type=='Debug' else 1)"
            conanfile = files["conanfile.py"]
            # The test files, surprisingly, dont use build_type
            conanfile = conanfile.replace(orig, replace).replace(
                '"arch"', '"arch", "build_type"')
            # Header of the package will contain a different DEFINE, to make sure that it includes
            # the correct one
            conanfile = conanfile.replace(
                "def build(self):\n", """def build(self):
        with open("helloHello{0}.h", "a") as f:
            f.write('#define HELLO{0}BUILD "%s"' % self.settings.build_type)
""".format(number))
            conanfile = conanfile.replace(
                "def package_info(self):\n", """def package_info(self):
        self.cpp_info.defines = ['HELLO{}DEFINE="%s"' % self.settings.build_type]
""".format(number))
            files["conanfile.py"] = conanfile
            client.save(files, clean_first=True)
            client.run("export lasote/testing")

        files = cpp_hello_conan_files("Hello0", "0.1")
        prepare_files(files, 0)
        files = cpp_hello_conan_files("Hello1",
                                      "0.1",
                                      deps=["Hello0/0.1@lasote/testing"])
        prepare_files(files, 1)

        # better in one test instead of two, because install time is amortized
        for cmake_file in (
                cmake,
                cmake_targets,
        ):
            client.save(
                {
                    "conanfile.txt": conanfile,
                    "CMakeLists.txt": cmake_file,
                    "main.cpp": main
                },
                clean_first=True)
            client.run('install -s build_type=Debug %s --build=missing' %
                       debug_install)
            client.run('install -s build_type=Release %s --build=missing' %
                       release_install)
            output = StringIO()
            runner = TestRunner(output)
            runner('cmake . -G "%s"' % generator, cwd=client.current_folder)
            self.assertNotIn("WARN: Unknown compiler '", output.getvalue())
            self.assertNotIn("', skipping the version check...",
                             output.getvalue())
            runner('cmake --build . --config Debug', cwd=client.current_folder)
            hello_comand = os.sep.join([".", "Debug", "say_hello"])
            runner(hello_comand, cwd=client.current_folder)
            outstr = output.getvalue()
            self.assertIn("Hello0:Debug Hello1:Debug", outstr)
            self.assertIn("Hello Hello1", outstr)
            self.assertIn("Hello Hello0", outstr)
            runner('cmake --build . --config Release',
                   cwd=client.current_folder)
            hello_comand = os.sep.join([".", "Release", "say_hello"])
            runner(hello_comand, cwd=client.current_folder)
            outstr = output.getvalue()
            self.assertIn("Hello0:Release Hello1:Release", outstr)
            self.assertIn("Hola Hello1", outstr)
            self.assertIn("Hola Hello0", outstr)
            if cmake_file == cmake_targets:
                self.assertIn("Conan: Using cmake targets configuration",
                              outstr)
            else:
                self.assertIn("Conan: Using cmake global configuration",
                              outstr)
Exemplo n.º 34
0
    def complete_test(self):
        """ basic installation of a new conans
        """
        servers = {}
        # All can write (for avoid authentication until we mock user_io)
        test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
        servers["default"] = test_server

        conan_digest = FileTreeManifest(123123123, {})

        client = TestClient(servers=servers)
        client.init_dynamic_vars()
        conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
        reg_folder = client.paths.export(conan_ref)

        files = hello_source_files()
        client.save(files, path=reg_folder)
        client.save(
            {
                CONANFILE: myconan1,
                CONAN_MANIFEST: str(conan_digest),
                "include/math/lib1.h": "//copy",
                "my_lib/debug/libd.a": "//copy",
                "my_data/readme.txt": "//copy"
            },
            path=reg_folder)

        package_ref = PackageReference(conan_ref, "fakeid")
        package_folder = client.paths.package(package_ref)
        save(os.path.join(package_folder, CONANINFO), "info")
        save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
        save(os.path.join(package_folder, "include", "lib1.h"), "//header")
        save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
        save(os.path.join(package_folder, "res", "shares", "readme.txt"),
             "//res")

        digest_path = client.client_cache.digestfile_package(package_ref)
        expected_manifest = FileTreeManifest.create(
            os.path.dirname(digest_path))
        save(os.path.join(package_folder, CONAN_MANIFEST),
             str(expected_manifest))

        client.run("upload %s" % str(conan_ref))
        client.run("upload %s -p %s" %
                   (str(conan_ref), package_ref.package_id))

        client2 = TestClient(servers=servers)
        client2.init_dynamic_vars()

        installer = ConanProxy(client2.paths, client2.user_io,
                               client2.remote_manager, "default")

        installer.get_recipe(conan_ref)
        installer.get_package(package_ref,
                              force_build=False,
                              short_paths=False)
        # Check that the output is done in order
        lines = [
            line.strip() for line in str(client2.user_io.out).splitlines()
            if line.startswith("Downloading")
        ]
        self.assertEqual(lines, [
            "Downloading conanmanifest.txt", "Downloading conanfile.py",
            "Downloading conan_export.tgz", "Downloading conanmanifest.txt",
            "Downloading conaninfo.txt", "Downloading conan_package.tgz"
        ])

        reg_path = client2.paths.export(
            ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
        pack_folder = client2.paths.package(package_ref)

        # Test the file in the downloaded conans
        files = [
            'CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h',
            CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h',
            'my_data/readme.txt'
        ]

        for _file in files:
            self.assertTrue(os.path.exists(os.path.join(reg_path, _file)))
        self.assertTrue(os.path.exists(pack_folder))

        # Test the file in the downloaded package
        self.assertTrue(os.path.exists(pack_folder))
        self.assertTrue(
            os.path.exists(os.path.join(pack_folder, "include", "lib1.h")))
        self.assertTrue(
            os.path.exists(os.path.join(pack_folder, "lib", "my_lib/libd.a")))
        self.assertTrue(
            os.path.exists(
                os.path.join(pack_folder, "res", "shares/readme.txt")))
Exemplo n.º 35
0
class UploadTest(unittest.TestCase):

    def setUp(self):
        servers = {}
        # All can write (for avoid authentication until we mock user_io)
        self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                                      users={"lasote": "mypass"})
        servers["default"] = self.test_server
        conan_digest = FileTreeManifest('123123123', {})

        self.client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
        reg_folder = self.client.paths.export(self.conan_ref)

        self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
        self.assertIn("There is no local conanfile exported as %s" % str(self.conan_ref),
                      self.client.user_io.out)

        files = hello_source_files()
        self.client.save(files, path=reg_folder)
        self.client.save({CONANFILE: myconan1,
                          CONAN_MANIFEST: str(conan_digest),
                          "include/math/lib1.h": "//copy",
                          "my_lib/debug/libd.a": "//copy",
                          "my_data/readme.txt": "//copy",
                          "my_bin/executable": "//copy"}, path=reg_folder)

        self.package_ref = PackageReference(self.conan_ref, "myfakeid")
        self.server_pack_folder = self.test_server.paths.package(self.package_ref)

        package_folder = self.client.paths.package(self.package_ref)
        save(os.path.join(package_folder, "include", "lib1.h"), "//header")
        save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
        save(os.path.join(package_folder, "res", "shares", "readme.txt"),
             "//res")
        save(os.path.join(package_folder, "bin", "my_bin", "executable"), "//bin")
        save(os.path.join(package_folder, CONANINFO), "info")
        save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")

        os.chmod(os.path.join(package_folder, "bin", "my_bin", "executable"),
                 os.stat(os.path.join(package_folder, "bin", "my_bin", "executable")).st_mode |
                 stat.S_IRWXU)

        digest_path = self.client.client_cache.digestfile_package(self.package_ref)
        expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
        save(os.path.join(package_folder, CONAN_MANIFEST), str(expected_manifest))

        self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
        self.assertFalse(os.path.exists(self.server_reg_folder))
        self.assertFalse(os.path.exists(self.server_pack_folder))

    def try_upload_bad_recipe_test(self):
        files = hello_conan_files("Hello0", "1.2.1")
        self.client.save(files)
        self.client.run("export frodo/stable")
        ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable")
        os.unlink(os.path.join(self.client.client_cache.export(ref), CONAN_MANIFEST))
        with self.assertRaisesRegexp(Exception, "Command failed"):
            self.client.run("upload %s" % str(ref))

        self.assertIn("Cannot upload corrupted recipe", self.client.user_io.out)

    def upload_same_package_dont_compress_test(self):
        # Create a manifest for the faked package
        pack_path = self.client.paths.package(self.package_ref)
        digest_path = self.client.client_cache.digestfile_package(self.package_ref)
        expected_manifest = FileTreeManifest.create(os.path.dirname(digest_path))
        save(os.path.join(pack_path, CONAN_MANIFEST), str(expected_manifest))

        self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
        self.assertIn("Compressing exported files", self.client.user_io.out)
        self.assertIn("Compressing package", str(self.client.user_io.out))

        self.client.run("upload %s --all" % str(self.conan_ref), ignore_error=False)
        self.assertNotIn("Compressing exported files", self.client.user_io.out)
        self.assertNotIn("Compressing package", str(self.client.user_io.out))
        self.assertIn("Package is up to date", str(self.client.user_io.out))

    def upload_with_no_valid_settings_test(self):
        '''Check if upload is still working even if the specified setting is not valid.
        If this test fails, will fail in Linux/OSx'''
        conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
    name = "Hello"
    version = "1.2"
    settings = {"os": ["Windows"]}
"""
        files = {CONANFILE: conanfile}
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.assertIn("WARN: Conanfile doesn't have a 'license'", self.client.user_io.out)
        self.client.run("upload Hello/1.2@lasote/stable", ignore_error=False)
        self.assertIn("Uploading conan_export.tgz", self.client.user_io.out)

    def simple_test(self):
        """ basic installation of a new conans
        """

        # Try to upload an package without upload conans first
        self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)),
                        ignore_error=True)
        self.assertIn("There are no remote conanfiles like %s" % str(self.conan_ref),
                      self.client.user_io.out)

        # Upload conans
        self.client.run('upload %s' % str(self.conan_ref))
        self.assertTrue(os.path.exists(self.server_reg_folder))
        self.assertFalse(os.path.exists(self.server_pack_folder))
        # Upload package
        self.client.run('upload %s -p %s'
                        % (str(self.conan_ref), str(self.package_ref.package_id)))
        self.assertTrue(os.path.exists(self.server_reg_folder))
        self.assertTrue(os.path.exists(self.server_pack_folder))

        # Test the file in the downloaded conans
        files = ['CMakeLists.txt',
                 'my_lib/debug/libd.a',
                 'hello.cpp',
                 'hello0.h',
                 CONANFILE,
                 CONAN_MANIFEST,
                 'main.cpp',
                 'include/math/lib1.h',
                 'my_data/readme.txt',
                 'my_bin/executable']

        self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, CONANFILE)))
        self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME)))
        tmp = temp_folder()
        untargz(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME), tmp)
        for f in files:
            if f not in (CONANFILE, CONAN_MANIFEST):
                self.assertTrue(os.path.exists(os.path.join(tmp, f)))
            else:
                self.assertFalse(os.path.exists(os.path.join(tmp, f)))

        folder = uncompress_packaged_files(self.test_server.paths, self.package_ref)

        self.assertTrue(os.path.exists(os.path.join(folder,
                                                    "include",
                                                    "lib1.h")))
        self.assertTrue(os.path.exists(os.path.join(folder,
                                                    "lib",
                                                    "my_lib/libd.a")))
        self.assertTrue(os.path.exists(os.path.join(folder,
                                                    "res",
                                                    "shares/readme.txt")))

        if platform.system() != "Windows":
            self.assertEqual(os.stat(os.path.join(folder,
                                                  "bin",
                                                  "my_bin/executable")).st_mode &
                             stat.S_IRWXU, stat.S_IRWXU)

    def upload_all_test(self):
        '''Upload conans and package together'''
        # Try to upload all conans and packages
        self.client.run('upload %s --all' % str(self.conan_ref))
        lines = [line.strip() for line in str(self.client.user_io.out).splitlines()
                 if line.startswith("Uploading")]
        self.assertEqual(lines, ["Uploading Hello/1.2.1@frodo/stable",
                                 "Uploading conanmanifest.txt",
                                 "Uploading conanfile.py",
                                 "Uploading conan_export.tgz",
                                 "Uploading package 1/1: myfakeid",
                                 "Uploading conanmanifest.txt",
                                 "Uploading conaninfo.txt",
                                 "Uploading conan_package.tgz",
                                 ])
        self.assertTrue(os.path.exists(self.server_reg_folder))
        self.assertTrue(os.path.exists(self.server_pack_folder))

    def force_test(self):
        '''Tries to upload a conans exported after than remote version.'''
        # Upload all conans and packages
        self.client.run('upload %s --all' % str(self.conan_ref))
        self.assertTrue(os.path.exists(self.server_reg_folder))
        self.assertTrue(os.path.exists(self.server_pack_folder))

        # Fake datetime from exported date and upload again
        digest_path = os.path.join(self.client.paths.export(self.conan_ref), CONAN_MANIFEST)
        old_digest = self.client.paths.load_manifest(self.conan_ref)
        fake_digest = FileTreeManifest(2, old_digest.file_sums)
        save(digest_path, str(fake_digest))

        self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
        self.assertIn("Remote conans is newer than local conans", self.client.user_io.out)

        self.client.run('upload %s --force' % str(self.conan_ref))
        self.assertIn("Uploading %s" % str(self.conan_ref),
                      self.client.user_io.out)
Exemplo n.º 36
0
    def reuse_test(self):
        conan_reference = ConanFileReference.loads(
            "stringutil/0.1@lasote/stable")
        files = {
            'conanfile.py': stringutil_conanfile,
            'reverse.go': reverse,
            'reverse_test.go': reverse_test,
            'reverse.txt': reverse,
            'hello/helloreverse.txt': reverse
        }
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install %s --build missing" % str(conan_reference))
        # Check compilation ok
        package_ids = self.client.paths.conan_packages(conan_reference)
        self.assertEquals(len(package_ids), 1)
        package_ref = PackageReference(conan_reference, package_ids[0])
        self._assert_package_exists(package_ref, self.client.paths,
                                    list(files.keys()))

        # Upload conans
        self.client.run("upload %s" % str(conan_reference))

        # Check that conans exists on server
        server_paths = self.servers["default"].paths
        conan_path = server_paths.export(conan_reference)
        self.assertTrue(os.path.exists(conan_path))

        # Upload package
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))

        # Check library on server
        self._assert_package_exists_in_server(package_ref, server_paths,
                                              list(files.keys()))

        # Now from other "computer" install the uploaded conans with same options (nothing)
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build missing" % str(conan_reference))
        # Build should be empty
        build_path = other_conan.paths.build(package_ref)
        self.assertFalse(os.path.exists(build_path))
        # Lib should exist
        self._assert_package_exists(package_ref, other_conan.paths,
                                    list(files.keys()))

        reuse_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        files = {'conanfile.py': reuse_conanfile, 'src/hello/main.go': main}
        reuse_conan.save(files)
        reuse_conan.run("install --build missing")

        with CustomEnvPath(paths_to_add=['$GOPATH/bin'],
                           var_to_add=[
                               ('GOPATH', reuse_conan.current_folder),
                           ]):

            if platform.system() == "Windows":
                command = "hello"
            else:
                command = './hello'
            reuse_conan.runner('go install hello',
                               cwd=reuse_conan.current_folder)
            reuse_conan.runner(command,
                               cwd=os.path.join(reuse_conan.current_folder,
                                                'bin'))
        self.assertIn("Hello, Go!", reuse_conan.user_io.out)
Exemplo n.º 37
0
    def reuse_test(self):
        self._export_upload("Hello0", "0.1")
        self._export_upload("Hello00", "0.2", msg="#")
        self._export_upload("Hello1",
                            "0.1",
                            deps=[("Hello0/0.1@lasote/stable", "private")],
                            static=False)
        self._export_upload("Hello2",
                            "0.1",
                            deps=[("Hello00/0.2@lasote/stable", "private")],
                            static=False)

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        # WE need to copy the DLLs and dylib
        client.save(files3)

        client.run('install --build missing')
        client.run('build')

        # assert Hello3 only depends on Hello2, and Hello1
        info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
        build_info_cmake = load(info_path)
        # Ensure it does not depend on Hello0 to build, as private in dlls
        self.assertNotIn("Hello0", repr(build_info_cmake))

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
            'Hello #'
        ],
                         str(client.user_io.out).splitlines()[-5:])

        # assert Hello3 only depends on Hello2, and Hello1
        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.loads(load(info_path))

        self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())

        # Try to upload and reuse the binaries
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files2 = cpp_hello_conan_files(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        # WE need to copy the DLLs
        client2.save(files2)

        client2.run("install . --build missing")
        self.assertNotIn("Package installed in Hello0/0.1",
                         client2.user_io.out)
        self.assertNotIn("Building", client2.user_io.out)
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)

        self.assertEqual([
            'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
            'Hello #'
        ],
                         str(client2.user_io.out).splitlines()[-5:])
        files3 = cpp_hello_conan_files(
            "Hello3",
            "0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
            language=1)

        client2.save(files3)
        client2.run('install -o language=1 --build missing')
        client2.run('build')
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
            'Hola #'
        ],
                         str(client2.user_io.out).splitlines()[-5:])

        # Issue 79, fixing private deps from current project
        files3 = cpp_hello_conan_files(
            "Hello3",
            "0.2", [
                "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable",
                ("Hello0/0.1@lasote/stable", "private"),
                ("Hello00/0.2@lasote/stable", "private")
            ],
            language=1)

        client2.save(files3, clean_first=True)
        client2.run('install -o language=1 --build missing')
        client2.run('build')
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
            'Hola #', 'Hola Hello0', 'Hola #'
        ],
                         str(client2.user_io.out).splitlines()[-7:])
Exemplo n.º 38
0
class ProfileTest(unittest.TestCase):

    def setUp(self):
        self.client = TestClient()

    def bad_syntax_test(self):
        self.client.save({CONANFILE: conanfile_scope_env})
        self.client.run("export lasote/stable")

        profile = '''
        [settings
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self.assertIn("Error reading 'clang' profile", self.client.user_io.out)
        self.assertIn("Bad syntax", self.client.user_io.out)

        profile = '''
        [settings]
        [invented]
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self.assertIn("Unrecognized field 'invented'", self.client.user_io.out)
        self.assertIn("Error reading 'clang' profile", self.client.user_io.out)

        profile = '''
        [settings]
        as
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self.assertIn("Error reading 'clang' profile: Invalid setting line 'as'", self.client.user_io.out)

        profile = '''
        [env]
        as
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self.assertIn("Error reading 'clang' profile: Invalid env line 'as'", self.client.user_io.out)

        profile = '''
        [scopes]
        as
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self.assertIn("Error reading 'clang' profile: Bad scope as", self.client.user_io.out)

        profile = '''
        [settings]
        os =   a value
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        # stripped "a value"
        self.assertIn("'a value' is not a valid 'settings.os'", self.client.user_io.out)

        profile = '''
        [env]
        ENV_VAR =   a value
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr clang", ignore_error=True)
        self._assert_env_variable_printed("ENV_VAR", "a value")

        profile = '''
        # Line with comments is not a problem
        [env]
        # Not even here
        ENV_VAR =   a value
        '''
        save(self.client.client_cache.profile_path("clang"), profile)
        self.client.run("install Hello0/0.1@lasote/stable --build -pr clang", ignore_error=True)
        self._assert_env_variable_printed("ENV_VAR", "a value")

    def build_with_profile_test(self):
        self._create_profile("scopes_env", settings={},
                             scopes={},  # undefined scope do not apply to my packages
                             env=[("CXX", "/path/tomy/g++_build"), ("CC", "/path/tomy/gcc_build")])

        self.client.save({CONANFILE: conanfile_scope_env})
        self.client.run("build -pr scopes_env")
        self._assert_env_variable_printed("CC", "/path/tomy/gcc_build")
        self._assert_env_variable_printed("CXX", "/path/tomy/g++_build")

    def install_profile_env_test(self):
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = conanfile_scope_env

        self._create_profile("envs", settings={}, env=[("A_VAR", "A_VALUE")],
                             package_env={"Hello0": [("OTHER_VAR", 2)]})

        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr envs")
        self._assert_env_variable_printed("A_VAR", "A_VALUE")
        self._assert_env_variable_printed("OTHER_VAR", "2")

        # Override with package var
        self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE")
        self._assert_env_variable_printed("A_VAR", "OTHER_VALUE")
        self._assert_env_variable_printed("OTHER_VAR", "2")

        # Override package var with package var
        self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE -e Hello0:OTHER_VAR=3")
        self._assert_env_variable_printed("A_VAR", "OTHER_VALUE")
        self._assert_env_variable_printed("OTHER_VAR", "3")

    def install_profile_settings_test(self):
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = files["conanfile.py"].replace("generators =", "generators = \"txt\",")

        # Create a profile and use it
        profile_settings = {"compiler": "Visual Studio",
                            "compiler.version": "12",
                            "compiler.runtime": "MD",
                            "arch": "x86"}

        self._create_profile("vs_12_86", settings=profile_settings, package_settings={})

        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install --build missing -pr vs_12_86")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        for setting, value in profile_settings.items():
            self.assertIn("%s=%s" % (setting, value), info)

        # Try to override some settings in install command
        self.client.run("install --build missing -pr vs_12_86 -s compiler.version=14")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        for setting, value in profile_settings.items():
            if setting != "compiler.version":
                self.assertIn("%s=%s" % (setting, value), info)
            else:
                self.assertIn("compiler.version=14", info)

        # Use package settings in profile
        tmp_settings = OrderedDict()
        tmp_settings["compiler"] = "gcc"
        tmp_settings["compiler.libcxx"] = "libstdc++11"
        tmp_settings["compiler.version"] = "4.8"
        package_settings = {"Hello0": tmp_settings}
        self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
                             package_settings=package_settings)
        # Try to override some settings in install command
        self.client.run("install --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        self.assertIn("compiler=gcc", info)
        self.assertIn("compiler.libcxx=libstdc++11", info)

        # If other package is specified compiler is not modified
        package_settings = {"NoExistsRecipe": tmp_settings}
        self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
                             package_settings=package_settings)
        # Try to override some settings in install command
        self.client.run("install --build missing -pr vs_12_86_Hello0_gcc -s compiler.version=14")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        self.assertIn("compiler=Visual Studio", info)
        self.assertNotIn("compiler.libcxx", info)

        # Mix command line package settings with profile
        package_settings = {"Hello0": tmp_settings}
        self._create_profile("vs_12_86_Hello0_gcc", settings=profile_settings,
                             package_settings=package_settings)

        # Try to override some settings in install command
        self.client.run("install --build missing -pr vs_12_86_Hello0_gcc"
                        " -s compiler.version=14 -s Hello0:compiler.libcxx=libstdc++")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        self.assertIn("compiler=gcc", info)
        self.assertNotIn("compiler.libcxx=libstdc++11", info)
        self.assertIn("compiler.libcxx=libstdc++", info)

    def scopes_env_test(self):
        # Create a profile and use it
        self._create_profile("scopes_env", settings={},
                             scopes={"Hello0:myscope": "1",
                                     "ALL:otherscope": "2",
                                     "undefined": "3"},  # undefined scope do not apply to my packages
                             env=[("CXX", "/path/tomy/g++"), ("CC", "/path/tomy/gcc")])
        self.client.save({CONANFILE: conanfile_scope_env})
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/0.1@lasote/stable --build missing -pr scopes_env")

        self.assertIn("Scope myscope: 1", self.client.user_io.out)
        self.assertIn("Scope otherscope: 2", self.client.user_io.out)
        self.assertIn("Scope undefined: None", self.client.user_io.out)

        self._assert_env_variable_printed("CC", "/path/tomy/gcc")
        self._assert_env_variable_printed("CXX", "/path/tomy/g++")

        # The env variable shouldn't persist after install command
        self.assertFalse(os.environ.get("CC", None) == "/path/tomy/gcc")
        self.assertFalse(os.environ.get("CXX", None) == "/path/tomy/g++")

    def test_package_test(self):
        test_conanfile = '''from conans.model.conan_file import ConanFile
from conans import CMake
import os

class DefaultNameConan(ConanFile):
    name = "DefaultName"
    version = "0.1"
    settings = "os", "compiler", "arch", "build_type"
    requires = "Hello0/0.1@lasote/stable"

    def build(self):
        # Print environment vars
        # self.run('cmake %s %s' % (self.conanfile_directory, cmake.command_line))
        if self.settings.os == "Windows":
            self.run('echo "My var is %ONE_VAR%"')
        else:
            self.run('echo "My var is $ONE_VAR"')

    def test(self):
        pass

'''
        files = {}
        files["conanfile.py"] = conanfile_scope_env
        files["test_package/conanfile.py"] = test_conanfile
        # Create a profile and use it
        self._create_profile("scopes_env", settings={},
                             scopes={},
                             env=[("ONE_VAR", "ONE_VALUE")])

        self.client.save(files)
        self.client.run("test_package --profile scopes_env")

        self._assert_env_variable_printed("ONE_VAR", "ONE_VALUE")
        self.assertIn("My var is ONE_VALUE", str(self.client.user_io.out))

        # Try now with package environment vars
        self._create_profile("scopes_env2", settings={},
                             scopes={},
                             package_env={"DefaultName": [("ONE_VAR", "IN_TEST_PACKAGE")],
                                          "Hello0": [("ONE_VAR", "PACKAGE VALUE")]})

        self.client.run("test_package --profile scopes_env2")

        self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE")
        self.assertIn("My var is IN_TEST_PACKAGE", str(self.client.user_io.out))

        # Try now overriding some variables with command line
        self.client.run("test_package --profile scopes_env2 -e DefaultName:ONE_VAR=InTestPackageOverride "
                        "-e Hello0:ONE_VAR=PackageValueOverride ")

        self._assert_env_variable_printed("ONE_VAR", "PackageValueOverride")
        self.assertIn("My var is InTestPackageOverride", str(self.client.user_io.out))

        # A global setting in command line won't override a scoped package variable
        self.client.run("test_package --profile scopes_env2 -e ONE_VAR=AnotherValue")
        self._assert_env_variable_printed("ONE_VAR", "PACKAGE VALUE")

    def _assert_env_variable_printed(self, name, value):
        if platform.system() == "Windows":
            self.assertIn("%s=%s" % (name, value), self.client.user_io.out)
        elif platform.system() == "Darwin":
            self.assertIn('%s="%s"' % (name, value), self.client.user_io.out)
        else:
            self.assertIn("%s='%s'" % (name, value), self.client.user_io.out)

    def _create_profile(self, name, settings, scopes=None, package_settings=None, 
                        env=None, package_env=None):

        package_env = package_env or {}

        profile = Profile()
        profile._settings = settings or {}
        if scopes:
            profile.scopes = Scopes.from_list(["%s=%s" % (key, value) for key, value in scopes.items()])

        if package_settings:
            profile._package_settings = package_settings

        for package_name, envs in package_env.items():
            for var_name, value in envs:
                profile._package_env[package_name][var_name] = value

        for var_name, value in env or {}:
            profile._env[var_name] = value
        save(self.client.client_cache.profile_path(name), profile.dumps())
Exemplo n.º 39
0
    def package_test(self):
        """Use 'conan package' command to repackage a generated package (without build it)"""
        client = TestClient(users={"default": [("lasote", "mypass")]})
        conanfile_template = """
from conans import ConanFile

class MyConan(ConanFile):
    name = "MyLib"
    version = "0.1"
    exports = '*'

    def package(self):
        self.copy(pattern="*.h", dst="include", keep_path=False)
        #self.copy(pattern="*.a", dst="lib", keep_path=False)
"""
        files = {
            "lib/file1.a": "foo",
            "include/file.h": "foo",
            CONANFILE: conanfile_template
        }

        client.save(files)
        client.run("export lasote/stable")

        # Build and package conan file
        conan_reference = ConanFileReference.loads("MyLib/0.1@lasote/stable")
        client.run("install %s --build missing" % str(conan_reference))
        package_id = "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9"
        package_path = client.paths.package(
            PackageReference(conan_reference, package_id))
        # Verify the headers are there but lib doesn't
        self.assertTrue(
            os.path.exists(os.path.join(package_path, "include", "file.h")))
        self.assertFalse(
            os.path.exists(os.path.join(package_path, "lib", "file1.a")))

        # Fix conanfile and re-package
        client.save({CONANFILE: conanfile_template.replace("#", "")})
        client.run("export lasote/stable")
        # Build and package conan file
        client.run("package %s %s" % (conan_reference, package_id))
        self.assertIn(
            "MyLib/0.1@lasote/stable: "
            "Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
            client.user_io.out)
        self.assertTrue(
            os.path.exists(os.path.join(package_path, "include", "file.h")))
        self.assertTrue(
            os.path.exists(os.path.join(package_path, "lib", "file1.a")))

        # Fix again conanfile and re-package with AL
        client.save(
            {CONANFILE: conanfile_template.replace("self.copy", "pass #")})
        client.run("export lasote/stable")
        # Build and package conan file
        client.run("package %s" % str(conan_reference))
        self.assertIn(
            "MyLib/0.1@lasote/stable: "
            "Re-packaging 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
            client.user_io.out)
        self.assertFalse(
            os.path.exists(os.path.join(package_path, "include", "file.h")))
        self.assertFalse(
            os.path.exists(os.path.join(package_path, "lib", "file1.a")))
Exemplo n.º 40
0
    def conan_test_test(self):
        '''Checks --build in test command'''

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        self._create(client, "Hello0", "0.0")
        self._create(client, "Hello1", "1.1", ["Hello0/0.0@lasote/stable"])

        # Now test out Hello2
        self._create(client,
                     "Hello2",
                     "2.2", ["Hello1/1.1@lasote/stable"],
                     export=True)
        hello2conanfile = load(os.path.join(client.current_folder, CONANFILE))
        client.save({CONANFILE: hello2conanfile})

        test_conanfile = '''
from conans.model.conan_file import ConanFile

class DefaultNameConan(ConanFile):
    settings = "os", "compiler", "arch"
    requires = "Hello2/2.2@lasote/stable"
    generators = "cmake"

    def test(self):
        pass
        '''
        client.save({"test/%s" % CONANFILE: test_conanfile})

        # Should recognize the hello package
        # Will Fail because Hello0/0.0 and Hello1/1.1 has not built packages
        # and by default no packages are built
        error = client.run("test", ignore_error=True)
        self.assertTrue(error)
        self.assertIn('Try to build from sources with "--build Hello0"',
                      client.user_io.out)

        # We generate the package for Hello0/0.0
        client.run("install Hello0/0.0@lasote/stable --build Hello0")

        # Still missing Hello1/1.1
        error = client.run("test", ignore_error=True)
        self.assertTrue(error)
        self.assertIn('Try to build from sources with "--build Hello1"',
                      client.user_io.out)

        # We generate the package for Hello1/1.1
        client.run("install Hello1/1.1@lasote/stable --build Hello1")

        # Now Hello2 should be built and not fail
        client.run("test")
        self.assertNotIn("Can't find a 'Hello2/2.2@lasote/stable' package",
                         client.user_io.out)
        self.assertIn(
            'Hello2/2.2@lasote/stable: WARN: Forced build from source',
            client.user_io.out)

        # Now package is generated but should be built again
        client.run("test")
        self.assertIn(
            'Hello2/2.2@lasote/stable: WARN: Forced build from source',
            client.user_io.out)
Exemplo n.º 41
0
class SettingsTest(unittest.TestCase):
    def setUp(self):
        self.client = TestClient()

    def settings_as_a_str_test(self):
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = "os"
"""
        self.client.save({CONANFILE: content})
        self.client.run("install -s os=Windows --build missing")
        # Now read the conaninfo and verify that settings applied is only os and value is windows
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.os, "Windows")

        self.client.run("install -s os=Linux --build missing")
        # Now read the conaninfo and verify that settings applied is only os and value is windows
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.os, "Linux")

    def settings_as_a_list_conanfile_test(self):
        """Declare settings as a list"""
        # Now with conanfile as a list
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = "os", "arch"
"""
        self.client.save({CONANFILE: content})
        self.client.run("install -s os=Windows --build missing")
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.os, "Windows")
        self.assertEquals(conan_info.settings.fields, ["arch", "os"])

    def settings_as_a_dict_conanfile_test(self):
        """Declare settings as a dict"""
        # Now with conanfile as a dict
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = {"os": ["Windows"], "arch": ["x86_64"]}
"""
        self.client.save({CONANFILE: content})
        self.client.run("install -s os=Windows --build missing")
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.os, "Windows")
        self.assertEquals(conan_info.settings.fields, ["arch", "os"])

    def invalid_settings_test(self):
        '''Test wrong values and wrong constraints'''

        # MISSING VALUE FOR A SETTING
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = "os", "build_type"
"""

        self.client.save({CONANFILE: content})
        self.client.run("install --build missing", ignore_error=True)
        self.assertIn(undefined_value("settings.build_type"),
                      str(self.client.user_io.out))

    def invalid_settings_test2(self):
        # MISSING A DEFAULT VALUE BECAUSE ITS RESTRICTED TO OTHER, SO ITS REQUIRED
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = {"os": ["Windows", "Linux", "Macos"], "compiler": ["Visual Studio"]}
"""

        self.client.save({CONANFILE: content})
        self.client.run(
            "install -s compiler=gcc -s compiler.version=4.8 --build missing",
            ignore_error=True)
        self.assertIn(
            bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]),
            str(self.client.user_io.out))

    def invalid_settings_test3(self):
        # dict without options
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = {"os": None, "compiler": ["Visual Studio"]}
"""

        self.client.save({CONANFILE: content})
        self.client.run(
            "install -s compiler=gcc -s compiler.version=4.8 --build missing",
            ignore_error=True)
        self.assertIn(
            bad_value_msg("settings.compiler", "gcc", ["Visual Studio"]),
            str(self.client.user_io.out))

        # Test wrong settings in conanfile
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = invalid
"""

        self.client.save({CONANFILE: content})
        self.client.run("install --build missing", ignore_error=True)
        self.assertIn("invalid' is not defined", str(self.client.user_io.out))

        # Test wrong values in conanfile
    def invalid_settings_test4(self):
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = "os"
"""

        self.client.save({CONANFILE: content})
        self.client.run("install -s os=ChromeOS --build missing",
                        ignore_error=True)
        self.assertIn(
            bad_value_msg("settings.os", "ChromeOS",
                          ['Android', 'Linux', 'Macos', 'Windows']),
            str(self.client.user_io.out))

        # Now add new settings to config and try again
        config = load(self.client.paths.settings_path)
        config = config.replace("Windows,", "Windows, ChromeOS,")

        save(self.client.paths.settings_path, config)
        self.client.run("install -s os=ChromeOS --build missing")
        self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))

        # Settings is None
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = None
"""
        self.client.save({CONANFILE: content})
        self.client.run("install --build missing")
        self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.dumps(), "")

        # Settings is {}
        content = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    settings = {}
"""
        self.client.save({CONANFILE: content})
        self.client.run("install --build missing")
        self.assertIn('Generated conaninfo.txt', str(self.client.user_io.out))
        conan_info = ConanInfo.loads(
            load(os.path.join(self.client.current_folder, CONANINFO)))
        self.assertEquals(conan_info.settings.dumps(), "")
Exemplo n.º 42
0
class SameUserChannelTest(unittest.TestCase):
    def setUp(self):
        self.client = TestClient()
        conanfile = """
from conans import ConanFile

class SayConan(ConanFile):
    name = "Say"
    version = "0.1"
    build_policy = "missing"

    def build(self):
        self.output.info("Building %s")
"""
        for channel in ("lasote/stable", "other/testing"):
            self.client.save({"conanfile.py": conanfile % channel})
            self.client.run("export %s" % channel)

        self.conanfile = """
from conans import ConanFile

class HelloConan(ConanFile):
    name = "Hello"
    version = "0.1"
    build_policy = "missing"

    def requirements(self):
        self.requires("Say/0.1@%s/%s" % (self.user, self.channel))

    def build(self):
        self.output.info("Building %s/%s" % (self.user, self.channel) )
"""

        self.test_conanfile = """
from conans import ConanFile, CMake
import os

class HelloReuseConan(ConanFile):
    requires = "Hello/0.1@lasote/stable"

    def test(self):
        self.conanfile_directory
"""
        self.client.save({
            "conanfile.py": self.conanfile,
            "test/conanfile.py": self.test_conanfile
        })

    def test_testpackage(self):
        self.client.run("test_package")
        self.assertIn("Say/0.1@lasote/stable: Building lasote/stable",
                      self.client.user_io.out)
        self.assertIn("Hello/0.1@lasote/stable: Building lasote/stable",
                      self.client.user_io.out)
        self.assertNotIn("other/testing", self.client.user_io.out)

        self.client.save({
            "conanfile.py":
            self.conanfile,
            "test/conanfile.py":
            self.test_conanfile.replace("lasote/stable", "other/testing")
        })
        self.client.run("test_package")
        self.assertIn("Say/0.1@other/testing: Building other/testing",
                      self.client.user_io.out)
        self.assertIn("Hello/0.1@other/testing: Building other/testing",
                      self.client.user_io.out)
        self.assertNotIn("lasote/stable", self.client.user_io.out)

    def test_local_commands(self):
        error = self.client.run("install", ignore_error=True)
        self.assertEqual(error, True)
        self.assertIn(
            "ERROR: Conanfile: CONAN_USERNAME environment variable not defined, "
            "but self.user is used in conanfile", self.client.user_io.out)

        os.environ["CONAN_USERNAME"] = "******"
        error = self.client.run("install", ignore_error=True)
        self.assertEqual(error, True)
        self.assertIn(
            "ERROR: Conanfile: CONAN_CHANNEL environment variable not defined, "
            "but self.channel is used in conanfile", self.client.user_io.out)

        os.environ["CONAN_CHANNEL"] = "stable"
        self.client.run("install")
        self.assertIn("Say/0.1@lasote/stable: Building lasote/stable",
                      self.client.user_io.out)
        self.assertNotIn("other/testing", self.client.user_io.out)

        os.environ["CONAN_USERNAME"] = "******"
        os.environ["CONAN_CHANNEL"] = "testing"
        self.client.run("install")
        self.assertIn("Say/0.1@other/testing: Building other/testing",
                      self.client.user_io.out)
        self.assertNotIn("lasote/stable", self.client.user_io.out)

        del os.environ["CONAN_USERNAME"]
        del os.environ["CONAN_CHANNEL"]
Exemplo n.º 43
0
class SynchronizeTest(unittest.TestCase):
    def setUp(self):
        test_server = TestServer(
            [("*/*@*/*", "*")],  # read permissions
            [],  # write permissions
            users={"lasote": "mypass"})  # exported users and passwords
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})

    def upload_test(self):
        conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1")
        files["to_be_deleted.txt"] = "delete me"
        files["to_be_deleted2.txt"] = "delete me2"

        remote_paths = self.client.servers["default"].paths
        server_conan_path = remote_paths.export(conan_reference)

        self.client.save(files)
        self.client.run("export lasote/stable")

        # Upload conan file
        self.client.run("upload %s" % str(conan_reference))

        # Verify the files are there
        self.assertTrue(
            os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
        tmp = temp_folder()
        untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
        self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")),
                        "delete me")
        self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")),
                        "delete me2")

        # Now delete local files export and upload and check that they are not in server
        os.remove(os.path.join(self.client.current_folder,
                               "to_be_deleted.txt"))
        self.client.run("export lasote/stable")
        self.client.run("upload %s" % str(conan_reference))
        self.assertTrue(
            os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
        tmp = temp_folder()
        untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
        self.assertFalse(os.path.exists(os.path.join(tmp,
                                                     "to_be_deleted.txt")))
        self.assertTrue(os.path.exists(os.path.join(tmp,
                                                    "to_be_deleted2.txt")))

        # Now modify a file, and delete other, and put a new one.
        files["to_be_deleted2.txt"] = "modified content"
        files["new_file.lib"] = "new file"
        del files["to_be_deleted.txt"]
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("upload %s" % str(conan_reference))

        # Verify all is correct
        self.assertTrue(
            os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME)))
        tmp = temp_folder()
        untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp)
        self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")),
                        "modified content")
        self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file")
        self.assertFalse(os.path.exists(os.path.join(tmp,
                                                     "to_be_deleted.txt")))

        ##########################
        # Now try with the package
        ##########################

        self.client.run("install %s --build missing" % str(conan_reference))
        # Upload package
        package_ids = self.client.paths.conan_packages(conan_reference)
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))

        # Check that conans exists on server
        package_reference = PackageReference(conan_reference,
                                             str(package_ids[0]))
        package_server_path = remote_paths.package(package_reference)
        self.assertTrue(os.path.exists(package_server_path))

        # Add a new file to package (artificially), upload again and check
        new_file_source_path = os.path.join(
            self.client.paths.package(package_reference), "newlib.lib")
        save(new_file_source_path, "newlib")
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))

        folder = uncompress_packaged_files(remote_paths, package_reference)
        remote_file_path = os.path.join(folder, "newlib.lib")
        self.assertTrue(os.path.exists(remote_file_path))

        # Now modify the file and check again
        save(new_file_source_path, "othercontent")
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))
        folder = uncompress_packaged_files(remote_paths, package_reference)
        remote_file_path = os.path.join(folder, "newlib.lib")
        self.assertTrue(os.path.exists(remote_file_path))
        self.assertTrue(load(remote_file_path), "othercontent")

        # Now delete the file and check again
        os.remove(new_file_source_path)
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))
        folder = uncompress_packaged_files(remote_paths, package_reference)
        remote_file_path = os.path.join(folder, "newlib.lib")

        self.assertFalse(os.path.exists(remote_file_path))
        self.assertNotEquals(remote_file_path, new_file_source_path)
Exemplo n.º 44
0
class PrivateDepsTest(unittest.TestCase):
    def setUp(self):
        test_server = TestServer(
            [("*/*@*/*", "*")],  # read permissions
            [],  # write permissions
            users={"lasote": "mypass"})  # exported users and passwords
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})

    def _export_upload(self,
                       name=0,
                       version=None,
                       deps=None,
                       msg=None,
                       static=True):
        dll_export = self.client.default_compiler_visual_studio and not static
        files = cpp_hello_conan_files(name,
                                      version,
                                      deps,
                                      msg=msg,
                                      static=static,
                                      private_includes=True,
                                      dll_export=dll_export)
        conan_ref = ConanFileReference(name, version, "lasote", "stable")
        self.client.save(files, clean_first=True)
        self.client.run("export lasote/stable")
        self.client.run("upload %s" % str(conan_ref))

    def reuse_test(self):
        self._export_upload("Hello0", "0.1")
        self._export_upload("Hello00", "0.2", msg="#")
        self._export_upload("Hello1",
                            "0.1",
                            deps=[("Hello0/0.1@lasote/stable", "private")],
                            static=False)
        self._export_upload("Hello2",
                            "0.1",
                            deps=[("Hello00/0.2@lasote/stable", "private")],
                            static=False)

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        # WE need to copy the DLLs and dylib
        client.save(files3)

        client.run('install --build missing')
        client.run('build')

        # assert Hello3 only depends on Hello2, and Hello1
        info_path = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
        build_info_cmake = load(info_path)
        # Ensure it does not depend on Hello0 to build, as private in dlls
        self.assertNotIn("Hello0", repr(build_info_cmake))

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
            'Hello #'
        ],
                         str(client.user_io.out).splitlines()[-5:])

        # assert Hello3 only depends on Hello2, and Hello1
        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.loads(load(info_path))

        self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())

        # Try to upload and reuse the binaries
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 1)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files2 = cpp_hello_conan_files(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        # WE need to copy the DLLs
        client2.save(files2)

        client2.run("install . --build missing")
        self.assertNotIn("Package installed in Hello0/0.1",
                         client2.user_io.out)
        self.assertNotIn("Building", client2.user_io.out)
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)

        self.assertEqual([
            'Hello Hello3', 'Hello Hello1', 'Hello Hello0', 'Hello Hello2',
            'Hello #'
        ],
                         str(client2.user_io.out).splitlines()[-5:])
        files3 = cpp_hello_conan_files(
            "Hello3",
            "0.2", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
            language=1)

        client2.save(files3)
        client2.run('install -o language=1 --build missing')
        client2.run('build')
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
            'Hola #'
        ],
                         str(client2.user_io.out).splitlines()[-5:])

        # Issue 79, fixing private deps from current project
        files3 = cpp_hello_conan_files(
            "Hello3",
            "0.2", [
                "Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable",
                ("Hello0/0.1@lasote/stable", "private"),
                ("Hello00/0.2@lasote/stable", "private")
            ],
            language=1)

        client2.save(files3, clean_first=True)
        client2.run('install -o language=1 --build missing')
        client2.run('build')
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello00.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello3', 'Hola Hello1', 'Hola Hello0', 'Hola Hello2',
            'Hola #', 'Hola Hello0', 'Hola #'
        ],
                         str(client2.user_io.out).splitlines()[-7:])
Exemplo n.º 45
0
class InstallTest(unittest.TestCase):

    def setUp(self):
        self.client = TestClient()
        self.settings = ("-s os=Windows -s compiler='Visual Studio' -s compiler.version=12 "
                         "-s arch=x86 -s compiler.runtime=MD")

    def _create(self, number, version, deps=None, export=True, no_config=False):
        files = cpp_hello_conan_files(number, version, deps, build=False, config=not no_config)

        self.client.save(files, clean_first=True)
        if export:
            self.client.run("export lasote/stable")

    def reuse_test(self):
        self._create("Hello0", "0.1")
        self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
        self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False)

        for lang, id0, id1 in [(0, "2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
                                   "44671ecdd9c606eb7166f2197ab50be8d36a3c3b"),
                               (1, "8b964e421a5b7e48b7bc19b94782672be126be8b",
                                   "3eeab577a3134fa3afdcd82881751789ec48e08f")]:

            self.client.run("install -o language=%d %s --build missing" % (lang, self.settings))
            info_path = os.path.join(self.client.current_folder, CONANINFO)
            conan_info = ConanInfo.load_file(info_path)
            self.assertEqual("arch=x86\n"
                             "compiler=Visual Studio\n"
                             "compiler.runtime=MD\n"
                             "compiler.version=12\n"
                             "os=Windows",
                             conan_info.settings.dumps())
            self.assertEqual("language=%s\nstatic=True" % lang, conan_info.options.dumps())
            conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")

            hello0 = self.client.paths.package(PackageReference(conan_ref, id0))
            hello0_info = os.path.join(hello0, CONANINFO)
            hello0_conan_info = ConanInfo.load_file(hello0_info)
            self.assertEqual(lang, hello0_conan_info.options.language)

            package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
                                            id1)
            hello1 = self.client.paths.package(package_ref1)
            hello1_info = os.path.join(hello1, CONANINFO)
            hello1_conan_info = ConanInfo.load_file(hello1_info)
            self.assertEqual(lang, hello1_conan_info.options.language)

    def upper_option_test(self):
        self._create("Hello0", "0.1", no_config=True)
        self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)
        self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True)

        self.client.run("install -o Hello2:language=1 -o Hello1:language=0 -o Hello0:language=1 %s"
                        " --build missing" % self.settings)
        info_path = os.path.join(self.client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("language=1\nstatic=True", conan_info.options.dumps())
        conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")

        hello0 = self.client.paths.package(PackageReference(conan_ref,
                                           "8b964e421a5b7e48b7bc19b94782672be126be8b"))
        hello0_info = os.path.join(hello0, CONANINFO)
        hello0_conan_info = ConanInfo.load_file(hello0_info)
        self.assertEqual(1, hello0_conan_info.options.language)

        package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
                                        "44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
        hello1 = self.client.paths.package(package_ref1)
        hello1_info = os.path.join(hello1, CONANINFO)
        hello1_conan_info = ConanInfo.load_file(hello1_info)
        self.assertEqual(0, hello1_conan_info.options.language)

    def inverse_upper_option_test(self):
        self._create("Hello0", "0.1", no_config=True)
        self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)
        self._create("Hello2", "0.1", ["Hello1/0.1@lasote/stable"], export=False, no_config=True)

        self.client.run("install -o language=0 -o Hello1:language=1 -o Hello0:language=0 %s "
                        "--build missing" % self.settings)
        info_path = os.path.join(self.client.current_folder, CONANINFO)

        conan_info = ConanInfo.load_file(info_path)

        self.assertEqual("language=0\nstatic=True", conan_info.options.dumps())
        conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")

        hello0 = self.client.paths.package(PackageReference(conan_ref,
                                           "2e38bbc2c3ef1425197c8e2ffa8532894c347d26"))
        hello0_info = os.path.join(hello0, CONANINFO)
        hello0_conan_info = ConanInfo.load_file(hello0_info)
        self.assertEqual("language=0\nstatic=True", hello0_conan_info.options.dumps())

        package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
                                        "3eeab577a3134fa3afdcd82881751789ec48e08f")
        hello1 = self.client.paths.package(package_ref1)
        hello1_info = os.path.join(hello1, CONANINFO)
        hello1_conan_info = ConanInfo.load_file(hello1_info)
        self.assertEqual("language=1\nstatic=True", hello1_conan_info.options.dumps())

    def upper_option_txt_test(self):
        self._create("Hello0", "0.1", no_config=True)
        self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)

        files = cpp_hello_conan_files("Hello2", "0.1", ["Hello1/0.1@lasote/stable"])
        files.pop(CONANFILE)
        files[CONANFILE_TXT] = """[requires]
        Hello1/0.1@lasote/stable

        [options]
        Hello0:language=1
        Hello1:language=0
        """
        self.client.save(files, clean_first=True)

        self.client.run("install %s --build missing" % self.settings)
        info_path = os.path.join(self.client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        conan_ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")

        hello0 = self.client.paths.package(PackageReference(conan_ref,
                                           "8b964e421a5b7e48b7bc19b94782672be126be8b"))
        hello0_info = os.path.join(hello0, CONANINFO)
        hello0_conan_info = ConanInfo.load_file(hello0_info)
        self.assertEqual(1, hello0_conan_info.options.language)

        package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
                                        "44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
        hello1 = self.client.paths.package(package_ref1)
        hello1_info = os.path.join(hello1, CONANINFO)
        hello1_conan_info = ConanInfo.load_file(hello1_info)
        self.assertEqual(0, hello1_conan_info.options.language)

    def change_option_txt_test(self):
        self._create("Hello0", "0.1")

        client = TestClient(base_folder=self.client.base_folder)
        files = {CONANFILE_TXT: """[requires]
        Hello0/0.1@lasote/stable

        [options]
        Hello0:language=1
        """}
        client.save(files)

        client.run("install %s --build missing" % self.settings)
        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        self.assertIn("Hello0:language=1", conan_info.full_options.dumps())
        self.assertIn("Hello0/0.1@lasote/stable:8b964e421a5b7e48b7bc19b94782672be126be8b",
                      conan_info.full_requires.dumps())

        files = {CONANFILE_TXT: """[requires]
        Hello0/0.1@lasote/stable

        [options]
        Hello0:language=0
        """}
        client.save(files)
        client.run("install %s --build missing" % self.settings)

        info_path = os.path.join(client.current_folder, CONANINFO)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        self.assertIn("Hello0:language=1", conan_info.full_options.dumps())

        # it is necessary to clean the cached conaninfo
        client.save(files, clean_first=True)
        client.run("install %s --build missing" % self.settings)
        conan_info = ConanInfo.load_file(info_path)
        self.assertEqual("", conan_info.options.dumps())
        self.assertIn("Hello0:language=0", conan_info.full_options.dumps())
        self.assertIn("Hello0/0.1@lasote/stable:2e38bbc2c3ef1425197c8e2ffa8532894c347d26",
                      conan_info.full_requires.dumps())

    def warn_bad_os_test(self):
        bad_os = "Linux" if platform.system() != "Linux" else "Macos"
        message = "You are building this package with settings.os='%s" % bad_os
        self._create("Hello0", "0.1")
        self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % bad_os, ignore_error=True)
        self.assertIn(message, self.client.user_io.out)

        self.client.run("install Hello0/0.1@lasote/stable -s os=%s" % detected_os(),
                        ignore_error=True)
        self.assertNotIn("You are building this package with settings.os", self.client.user_io.out)
Exemplo n.º 46
0
    def reuse_test(self):
        conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True)

        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install %s --build missing" % str(conan_reference))

        self.assertIn(
            "Hello0/0.1@lasote/stable package(): Copied 1 '.h' files: helloHello0.h",
            self.client.user_io.out)
        # Check compilation ok
        package_ids = self.client.paths.conan_packages(conan_reference)
        self.assertEquals(len(package_ids), 1)
        package_ref = PackageReference(conan_reference, package_ids[0])
        self._assert_library_exists(package_ref, self.client.paths)

        # Upload conans
        self.client.run("upload %s" % str(conan_reference))

        # Check that conans exists on server
        server_paths = self.servers["default"].paths
        conan_path = server_paths.export(conan_reference)
        self.assertTrue(os.path.exists(conan_path))

        # Upload package
        self.client.run("upload %s -p %s" %
                        (str(conan_reference), str(package_ids[0])))

        # Check library on server
        self._assert_library_exists_in_server(package_ref, server_paths)

        # Now from other "computer" install the uploaded conans with same options (nothing)
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build missing" % str(conan_reference))
        # Build should be empty
        build_path = other_conan.paths.build(package_ref)
        self.assertFalse(os.path.exists(build_path))
        # Lib should exist
        self._assert_library_exists(package_ref, other_conan.paths)

        # Now install it but with other options
        other_conan.run('install %s -o language=1 --build missing' %
                        (str(conan_reference)))
        # Should have two packages
        package_ids = other_conan.paths.conan_packages(conan_reference)
        self.assertEquals(len(package_ids), 2)
        for package_id in package_ids:
            ref = PackageReference(conan_reference, package_id)
            self._assert_library_exists(ref, other_conan.paths)

        client3 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
        files3 = cpp_hello_conan_files("Hello1", "0.1",
                                       ["Hello0/0.1@lasote/stable"])
        client3.save(files3)
        client3.run('install')
        client3.run('build')
        command = os.sep.join([".", "bin", "say_hello"])
        client3.runner(command, cwd=client3.current_folder)
        self.assertIn("Hello Hello1", client3.user_io.out)
        self.assertIn("Hello Hello0", client3.user_io.out)

        client3.run('install -o language=1 --build missing')
        time.sleep(1)
        client3.run('build')

        command = os.sep.join([".", "bin", "say_hello"])
        client3.runner(command, cwd=client3.current_folder)
        self.assertIn("Hola Hello1", client3.user_io.out)
        self.assertIn("Hola Hello0", client3.user_io.out)
Exemplo n.º 47
0
class ExportTest(unittest.TestCase):

    def setUp(self):
        self.conan = TestClient()
        self.files = cpp_hello_conan_files("Hello0", "0.1")
        self.conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable")
        self.conan.save(self.files)
        self.conan.run("export lasote/stable")

    def test_basic(self):
        """ simple registration of a new conans
        """
        reg_path = self.conan.paths.export(self.conan_ref)
        manif = FileTreeManifest.loads(load(self.conan.paths.digestfile_conanfile(self.conan_ref)))

        self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
                      self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path), self.conan.user_io.out)
        self.assertTrue(os.path.exists(reg_path))

        for name in list(self.files.keys()):
            self.assertTrue(os.path.exists(os.path.join(reg_path, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': '9e26c9274ae837c03764d1418c063ebb',
                         'executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)

    def test_case_sensitive(self):
        self.files = cpp_hello_conan_files("hello0", "0.1")
        self.conan_ref = ConanFileReference("hello0", "0.1", "lasote", "stable")
        self.conan.save(self.files)
        error = self.conan.run("export lasote/stable", ignore_error=True)
        self.assertTrue(error)
        self.assertIn("ERROR: Cannot export package with same name but different case",
                      self.conan.user_io.out)

    def test_export_filter(self):
        content = """
from conans import ConanFile

class OpenSSLConan(ConanFile):
    name = "openssl"
    version = "2.0.1"
"""
        save(os.path.join(self.conan.current_folder, CONANFILE), content)
        self.conan.run("export lasote/stable")
        reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
        self.assertEqual(sorted(os.listdir(reg_path)),
                         [EXPORT_SOURCES_DIR, CONANFILE, CONAN_MANIFEST])

        content = """
from conans import ConanFile

class OpenSSLConan(ConanFile):
    name = "openssl"
    version = "2.0.1"
    exports = ('*.txt', '*.h')
"""
        save(os.path.join(self.conan.current_folder, CONANFILE), content)
        self.conan.run("export lasote/stable")
        reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
        self.assertEqual(sorted(os.listdir(reg_path)),
                         [EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST,
                          'helloHello0.h'])

        # Now exports being a list instead a tuple
        content = """
from conans import ConanFile

class OpenSSLConan(ConanFile):
    name = "openssl"
    version = "2.0.1"
    exports = ['*.txt', '*.h']
"""
        save(os.path.join(self.conan.current_folder, CONANFILE), content)
        self.conan.run("export lasote/stable")
        reg_path = self.conan.paths.export(ConanFileReference.loads('openssl/2.0.1@lasote/stable'))
        self.assertEqual(sorted(os.listdir(reg_path)),
                         [EXPORT_SOURCES_DIR, 'CMakeLists.txt', CONANFILE, CONAN_MANIFEST,
                          'helloHello0.h'])

    def test_export_the_same_code(self):
        file_list = self._create_packages_and_builds()
        # Export the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        conan2.save(files2)
        conan2.run("export lasote/stable")
        reg_path2 = conan2.paths.export(self.conan_ref)
        digest2 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertNotIn('A new Conan version was exported', conan2.user_io.out)
        self.assertNotIn('Cleaning the old builds ...', conan2.user_io.out)
        self.assertNotIn('Cleaning the old packs ...', conan2.user_io.out)
        self.assertNotIn('All the previous packs were cleaned', conan2.user_io.out)
        self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
                      self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2), self.conan.user_io.out)
        self.assertTrue(os.path.exists(reg_path2))

        for name in list(files2.keys()):
            self.assertTrue(os.path.exists(os.path.join(reg_path2, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': '9e26c9274ae837c03764d1418c063ebb',
                         'executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest2.file_sums)

        for f in file_list:
            self.assertTrue(os.path.exists(f))

    def test_export_a_new_version(self):
        self._create_packages_and_builds()
        # Export an update of the same conans

        conan2 = TestClient(self.conan.base_folder)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE]
        conan2.save(files2)
        conan2.run("export lasote/stable")

        reg_path3 = conan2.paths.export(self.conan_ref)
        digest3 = FileTreeManifest.loads(load(conan2.paths.digestfile_conanfile(self.conan_ref)))

        self.assertIn('%s: A new conanfile.py version was exported' % str(self.conan_ref),
                      self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out)

        self.assertTrue(os.path.exists(reg_path3))

        for name in list(files2.keys()):
            self.assertTrue(os.path.exists(os.path.join(reg_path3, name)))

        expected_sums = {'hello.cpp': '4f005274b2fdb25e6113b69774dac184',
                         'main.cpp': '0479f3c223c9a656a718f3148e044124',
                         'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8',
                         'conanfile.py': 'b6ac37b87cf6cfd63991d355b48db40e',
                         'executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, digest3.file_sums)

        # for f in file_list:
        #    self.assertFalse(os.path.exists(f))

    def _create_packages_and_builds(self):
        reg_builds = self.conan.paths.builds(self.conan_ref)
        reg_packs = self.conan.paths.packages(self.conan_ref)

        folders = [os.path.join(reg_builds, '342525g4f52f35f'),
                   os.path.join(reg_builds, 'ew9o8asdf908asdf80'),
                   os.path.join(reg_packs, '342525g4f52f35f'),
                   os.path.join(reg_packs, 'ew9o8asdf908asdf80')]

        file_list = []
        for f in folders:
            for name, content in {'file1.h': 'asddfasdf', 'file1.dll': 'asddfasdf'}.items():
                file_path = os.path.join(f, name)
                save(file_path, content)
                file_list.append(file_path)
        return file_list
Exemplo n.º 48
0
class InstallSelectedPackagesTest(unittest.TestCase):
    def setUp(self):
        test_server = TestServer()
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        self.package_ids = self._upload_some_packages(self.client)
        self.new_client = TestClient(servers=self.servers,
                                     users={"default": [("lasote", "mypass")]})

    def install_all_test(self):
        # Should retrieve the three packages
        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        p1 = os.path.join(self.new_client.paths.packages(self.ref))
        packages = os.listdir(p1)
        self.assertEquals(len(packages), 3)

    def install_some_reference_test(self):
        # Should retrieve the specified packages
        self.new_client.run("install Hello0/0.1@lasote/stable -p %s" %
                            self.package_ids[0])
        packages = os.listdir(self.new_client.paths.packages(self.ref))
        self.assertEquals(len(packages), 1)
        self.assertEquals(packages[0], self.package_ids[0])

        self.new_client.run("install Hello0/0.1@lasote/stable -p %s -p %s" %
                            (self.package_ids[0], self.package_ids[1]))
        packages = os.listdir(self.new_client.paths.packages(self.ref))
        self.assertEquals(len(packages), 2)

    def download_recipe_twice_test(self):
        expected_conanfile_contents = self.files[CONANFILE]
        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_conanfile = load(
            os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
        self.assertEquals(expected_conanfile_contents, got_conanfile)

        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_conanfile = load(
            os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
        self.assertEquals(expected_conanfile_contents, got_conanfile)

        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_conanfile = load(
            os.path.join(self.new_client.paths.export(self.ref), CONANFILE))
        self.assertEquals(expected_conanfile_contents, got_conanfile)

    def download_packages_twice_test(self):
        expected_header_contents = self.files["helloHello0.h"]
        package_folder = self.new_client.paths.package(
            PackageReference(self.ref, self.package_ids[0]))

        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_header = load(
            os.path.join(package_folder, "include", "helloHello0.h"))
        self.assertEquals(expected_header_contents, got_header)

        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_header = load(
            os.path.join(package_folder, "include", "helloHello0.h"))
        self.assertEquals(expected_header_contents, got_header)

        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        got_header = load(
            os.path.join(package_folder, "include", "helloHello0.h"))
        self.assertEquals(expected_header_contents, got_header)

    def install_all_but_no_packages_test(self):

        # Remove all from remote
        self.new_client.run("remove Hello* -f -r default")

        # Try to install all
        self.new_client.run("install Hello0/0.1@lasote/stable --all",
                            ignore_error=True)
        self.assertIn("'Hello0/0.1@lasote/stable' not found in remote",
                      self.new_client.user_io.out)

        # Upload only the recipe
        self.new_client.save(self.files)
        self.new_client.run("export lasote/stable")
        self.new_client.run("upload  Hello0/0.1@lasote/stable --all")

        # And try to download all
        self.new_client.run("install Hello0/0.1@lasote/stable --all")
        self.assertIn("No remote binary packages found in remote",
                      self.new_client.user_io.out)

    def _upload_some_packages(self, client):
        self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        self.files = cpp_hello_conan_files("Hello0", "0.1")
        # No build.
        self.files[CONANFILE] = self.files[CONANFILE].replace(
            "def build(self):", "def build(self):\n        return\n")
        client.save(self.files)
        client.run("export lasote/stable")
        client.run(
            "install Hello0/0.1@lasote/stable -s os=Windows --build missing")
        client.run(
            "install Hello0/0.1@lasote/stable -s os=Linux --build missing")
        client.run(
            "install Hello0/0.1@lasote/stable -s os=Linux -s compiler=gcc -s "
            "compiler.version=4.6 -s compiler.libcxx=libstdc++ --build missing"
        )
        client.run("upload  Hello0/0.1@lasote/stable --all")
        return os.listdir(self.client.paths.packages(self.ref))
Exemplo n.º 49
0
class ImportsTest(unittest.TestCase):
    def setUp(self):
        self.client = TestClient()
        self.client.save({"conanfile.py": conanfile})
        self.client.run("export lasote/stable")

    def imports_global_path_test(self):
        """ Ensure that when importing files in a global path, outside the package build,
        they are not deleted
        """
        dst_global_folder = temp_folder().replace("\\", "/")
        conanfile2 = '''
from conans import ConanFile

class ConanLib(ConanFile):
    name = "Say"
    version = "0.1"
    requires = "Hello/0.1@lasote/stable"

    def imports(self):
        self.copy("file*.txt", dst="%s")
''' % dst_global_folder

        self.client.save({"conanfile.py": conanfile2}, clean_first=True)
        self.client.run("export lasote/stable")

        self.client.current_folder = temp_folder()
        self.client.run("install Say/0.1@lasote/stable --build=missing")
        for filename, content in [("file1.txt", "Hello"),
                                  ("file2.txt", "World")]:
            filecontent = load(os.path.join(dst_global_folder, filename))
            self.assertTrue(content, filecontent)

    def imports_env_var_test(self):
        conanfile2 = '''
from conans import ConanFile
import os

class ConanLib(ConanFile):
    requires = "Hello/0.1@lasote/stable"

    def imports(self):
        self.copy("file*.txt", dst=os.environ["MY_IMPORT_PATH"])
'''
        for folder in ("folder1", "folder2"):
            self.client.save({"conanfile.py": conanfile2}, clean_first=True)
            self.client.run("install -e MY_IMPORT_PATH=%s" % folder)
            self.assertEqual(
                "Hello",
                load(
                    os.path.join(self.client.current_folder, folder,
                                 "file1.txt")))

    def imports_error_test(self):
        self.client.save({"conanfile.txt": test1}, clean_first=True)
        self.client.run("install --no-imports")
        self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))

        error = self.client.run("imports", ignore_error=True)
        self.assertTrue(error)
        self.assertIn("conanbuildinfo.txt file not found",
                      self.client.user_io.out)

    def install_manifest_test(self):
        self.client.save({"conanfile.txt": test1}, clean_first=True)
        self.client.run("install -g txt")
        self.assertIn("imports(): Copied 2 '.txt' files",
                      self.client.user_io.out)
        self.assertIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertIn("file2.txt", os.listdir(self.client.current_folder))
        self._check_manifest()

    def undo_install_manifest_test(self):
        self.client.save({"conanfile.txt": test1}, clean_first=True)
        self.client.run("install -g txt")
        self.client.run("imports --undo")
        self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
        self.assertNotIn(IMPORTS_MANIFESTS,
                         os.listdir(self.client.current_folder))
        self.assertIn("Removed 2 imported files", self.client.user_io.out)
        self.assertIn("Removed imports manifest file", self.client.user_io.out)

    def _check_manifest(self):
        manifest_content = load(
            os.path.join(self.client.current_folder, IMPORTS_MANIFESTS))
        manifest = FileTreeManifest.loads(manifest_content)
        self.assertEqual(
            manifest.file_sums, {
                os.path.join(self.client.current_folder, "file1.txt"):
                "8b1a9953c4611296a827abf8c47804d7",
                os.path.join(self.client.current_folder, "file2.txt"):
                "f5a7924e621e84c9280a9a27e1bcb7f6"
            })

    def imports_test(self):
        self.client.save({"conanfile.txt": test1}, clean_first=True)
        self.client.run("install --no-imports -g txt")
        self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))
        self.client.run("imports")
        self.assertIn("imports(): Copied 2 '.txt' files",
                      self.client.user_io.out)
        self.assertIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertIn("file2.txt", os.listdir(self.client.current_folder))
        self._check_manifest()

    def imports_filename_test(self):
        self.client.save(
            {
                "conanfile.txt": test1,
                "conanfile.py": test2,
                "conanfile2.py": test3
            },
            clean_first=True)
        self.client.run("install --no-imports -g txt")
        self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))

        self.client.run("imports -f=conanfile2.py")
        self.assertNotIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertIn("file2.txt", os.listdir(self.client.current_folder))

        os.unlink(os.path.join(self.client.current_folder, "file2.txt"))
        self.client.run("imports")
        self.assertIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertNotIn("file2.txt", os.listdir(self.client.current_folder))

        os.unlink(os.path.join(self.client.current_folder, "file1.txt"))
        self.client.run("imports -f conanfile.txt")
        self.assertIn("file1.txt", os.listdir(self.client.current_folder))
        self.assertIn("file2.txt", os.listdir(self.client.current_folder))
Exemplo n.º 50
0
    def complete_test(self):
        """ basic installation of a new conans
        """
        client = TestClient()
        client.init_dynamic_vars()
        files = hello_source_files()

        conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
        reg_folder = client.paths.export(conan_ref)

        client.save(files, path=reg_folder)
        client.save(
            {
                CONANFILE: myconan1,
                CONANINFO: "//empty",
                "include/no_copy/lib0.h": "NO copy",
                "include/math/lib1.h": "copy",
                "include/math/lib2.h": "copy",
                "include/physics/lib.hpp": "copy",
                "my_lib/debug/libd.a": "copy",
                "my_data/readme.txt": "copy",
                "my_data/readme.md": "NO copy",
                "contrib/math/math.h": "copy",
                "contrib/physics/gravity.h": "copy",
                "contrib/contrib.h": "copy",
                "include/opencv/opencv.hpp": "copy",
                "include/opencv2/opencv2.hpp": "copy",
                "modules/simu/src/simu.cpp": "NO copy",
                "modules/simu/include/opencv2/simu/simu.hpp": "copy",
                "modules/3D/doc/readme.md": "NO copy",
                "modules/3D/include/opencv2/3D/3D.hpp": "copy",
                "modules/dev/src/dev.cpp": "NO copy",
                "modules/dev/include/opencv2/dev/dev.hpp": "copy",
                "modules/opencv_mod.hpp": "copy"
            },
            path=reg_folder)

        conanfile_path = os.path.join(reg_folder, CONANFILE)
        package_ref = PackageReference(conan_ref, "myfakeid")
        build_folder = client.paths.build(package_ref)
        package_folder = client.paths.package(package_ref)

        shutil.copytree(reg_folder, build_folder)

        loader = ConanFileLoader(None, Settings(), OptionsValues.loads(""))
        conanfile = loader.load_conan(conanfile_path, None)
        create_package(conanfile, build_folder, package_folder,
                       TestBufferConanOutput())

        # test build folder
        self.assertTrue(os.path.exists(build_folder))
        self.assertTrue(os.path.exists(os.path.join(package_folder,
                                                    CONANINFO)))

        # test pack folder
        self.assertTrue(os.path.exists(package_folder))

        def exist(rel_path):
            return os.path.exists(os.path.join(package_folder, rel_path))

        # Expected files
        self.assertTrue(exist("include/lib1.h"))
        self.assertTrue(exist("include/lib2.h"))
        self.assertTrue(exist("include/physics/lib.hpp"))
        self.assertTrue(exist("include/contrib/math/math.h"))
        self.assertTrue(exist("include/contrib/physics/gravity.h"))
        self.assertTrue(exist("include/contrib/contrib.h"))
        self.assertTrue(exist("include/opencv/opencv.hpp"))
        self.assertTrue(exist("include/opencv2/opencv2.hpp"))
        self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
        self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
        self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
        self.assertTrue(exist("lib/my_lib/libd.a"))
        self.assertTrue(exist("res/shares/readme.txt"))

        # Not expected files
        self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
        self.assertFalse(exist("include/opencv2/simu.hpp"))
        self.assertFalse(exist("include/opencv2/3D.hpp"))
        self.assertFalse(exist("include/opencv2/dev.hpp"))
        self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
        self.assertFalse(exist("include/modules/3D/doc/readme.md"))
        self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
        self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
        self.assertFalse(exist("include/include/no_copy/lib0.h"))
        self.assertFalse(exist("res/my_data/readme.md"))
Exemplo n.º 51
0
    def _diamond_test(self, install="install", use_cmake=True):
        def wait_until_removed(folder):
            latest_exception = None
            for _ in range(50):  # Max 5 seconds
                time.sleep(0.1)
                try:
                    shutil.rmtree(folder)
                    break
                except Exception as e:
                    latest_exception = e
            else:
                raise Exception("Could remove folder %s: %s" %
                                (folder, latest_exception))

        self._export_upload("Hello0", "0.1", use_cmake=use_cmake)
        self._export_upload("Hello1",
                            "0.1", ["Hello0/0.1@lasote/stable"],
                            use_cmake=use_cmake)
        self._export_upload("Hello2",
                            "0.1", ["Hello0/0.1@lasote/stable"],
                            use_cmake=use_cmake)
        self._export_upload(
            "Hello3",
            "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
            use_cmake=use_cmake)

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       use_cmake=use_cmake)

        # Add some stuff to base project conanfile to test further the individual
        # flags in build_info (txt, cmake) files
        content = files3[CONANFILE]
        content = content.replace("generators =", 'generators = "txt",')
        content = content.replace(
            "def build(self):", "def build(self):\n"
            "        self.output.info('INCLUDE %s' "
            "% self.deps_cpp_info['Hello0'].include_paths)")
        files3[CONANFILE] = content
        client.save(files3)

        client.run("%s . --build missing" % install)
        client.run("build .")
        self._check_individual_deps(client)

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1,
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        wait_until_removed(client.current_folder)
        client.save(files3)
        client.run("%s . --build missing" % install)
        client.run("build .")

        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        # Try to upload and reuse the binaries
        client.run("upload Hello3/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello0/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        client2.save(files3)
        client2.run("%s . --build missing" % install)
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1,
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        wait_until_removed(client2.current_folder)
        client2.save(files3)
        client2.run("%s . --build missing" % install)
        client2.run("build .")
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])
Exemplo n.º 52
0
    def test_update_settings(self):
        file_content = '''
from conans import ConanFile

class ConanFileToolsTest(ConanFile):
    name = "test"
    version = "1.9"
    settings = "os", "compiler", "arch"

    def source(self):
        self.output.warn("Sourcing...")

    def build(self):
        self.output.warn("Building...")
    '''
        prev_settings = """
os: [Windows, Linux, Macos, Android]
arch: [x86, x86_64, armv6, armv7, armv7hf, armv8]
compiler:
    gcc:
        version: ["4.4", "4.5", "4.6", "4.7", "4.8", "4.9", "5.1", "5.2", "5.3"]
        libcxx: [libstdc++, libstdc++11]
    Visual Studio:
        runtime: [None, MD, MT, MTd, MDd]
        version: ["8", "9", "10", "11", "12", "14"]
    clang:
        version: ["3.3", "3.4", "3.5", "3.6", "3.7", "3.8"]
        libcxx: [libstdc++, libstdc++11, libc++]
    apple-clang:
        version: ["5.0", "5.1", "6.0", "6.1", "7.0", "7.1", "7.2", "7.3"]
        libcxx: [libstdc++, libc++]

"""
        files = {"conanfile.py": file_content}
        client = TestClient()
        save(client.paths.settings_path, prev_settings)
        conf = load(client.paths.conan_conf_path)
        conf = conf.replace("build_type=Release", "")
        self.assertNotIn("build_type", conf)
        save(client.paths.conan_conf_path, conf)
        self.assertNotIn("build_type",
                         client.paths.conan_config.settings_defaults.dumps())
        client.save(files)
        client.run("export lasote/testing")
        self.assertNotIn("build_type", load(client.paths.settings_path))
        self.assertNotIn("build_type", load(client.paths.conan_conf_path))
        self.assertNotIn("build_type",
                         client.paths.conan_config.settings_defaults.dumps())

        client.run(
            "install test/1.9@lasote/testing --build -s compiler=gcc "
            "-s compiler.version=4.9 -s os=Windows -s compiler.libcxx=libstdc++"
        )
        self.assertIn("390146894f59dda18c902ee25e649ef590140732",
                      client.user_io.out)

        # Now the new one
        files = {
            "conanfile.py": file_content.replace('"arch"',
                                                 '"arch", "build_type"')
        }
        client = TestClient()
        client.save(files)
        client.run("export lasote/testing")
        self.assertIn("build_type", load(client.paths.settings_path))

        client.run(
            "install test/1.9@lasote/testing --build -s compiler=gcc "
            "-s compiler.version=4.9 -s os=Windows -s build_type=None -s compiler.libcxx=libstdc++"
        )
        self.assertIn("390146894f59dda18c902ee25e649ef590140732",
                      client.user_io.out)
Exemplo n.º 53
0
class DiamondTest(unittest.TestCase):
    def setUp(self):
        test_server = TestServer(
            [("*/*@*/*", "*")],  # read permissions
            [],  # write permissions
            users={"lasote": "mypass"})  # exported users and passwords
        self.servers = {"default": test_server}
        self.conan = TestClient(servers=self.servers,
                                users={"default": [("lasote", "mypass")]})

    def _export_upload(self, name, version=None, deps=None):
        files = cpp_hello_conan_files(name, version, deps, need_patch=True)
        conan_ref = ConanFileReference(name, version, "lasote", "stable")
        self.conan.save(files, clean_first=True)
        self.conan.run("export lasote/stable")
        self.conan.run("upload %s" % str(conan_ref))

    def _check_individual_deps(self, client):
        self.assertIn("INCLUDE [", client.user_io.out)
        self.assertIn(".conan/data/Hello0/0.1/lasote/stable",
                      client.user_io.out)
        build_file = os.path.join(client.current_folder, BUILD_INFO)
        content = load(build_file)
        cmakebuildinfo = load(
            os.path.join(client.current_folder, BUILD_INFO_CMAKE))
        self.assertIn(
            "set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0",
            cmakebuildinfo)
        self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)",
                      cmakebuildinfo)
        deps_cpp_info = DepsCppInfo.loads(content)
        self.assertEqual(len(deps_cpp_info.include_paths), 4)
        for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
            self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
            self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
            self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
        build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
        content = load(build_file)
        for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
            self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
            self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
            self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep),
                          content)

    def reuse_test(self):
        self._export_upload("Hello0", "0.1")
        self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
        self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"])
        self._export_upload(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4", "0.1",
                                       ["Hello3/0.1@lasote/stable"])

        # Add some stuff to base project conanfile to test further the individual
        # flags in build_info (txt, cmake) files
        content = files3[CONANFILE]
        content = content.replace("generators =", 'generators = "txt",')
        content = content.replace(
            "def build(self):", "def build(self):\n"
            "        self.output.info('INCLUDE %s' "
            "% self.deps_cpp_info['Hello0'].include_paths)")
        files3[CONANFILE] = content
        client.save(files3)

        client.run("install . --build missing")
        client.run("build .")
        self._check_individual_deps(client)

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1)
        client.save(files3, clean_first=True)
        client.run("install . --build missing")
        client.run("build .")

        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        # Try to upload and reuse the binaries
        client.run("upload Hello3/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello0/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4", "0.1",
                                       ["Hello3/0.1@lasote/stable"])
        client2.save(files3)
        client2.run("install . --build missing")
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1)
        client2.save(files3, clean_first=True)
        client2.run("install . --build missing")
        client2.run("build .")
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])
Exemplo n.º 54
0
class SearchTest(unittest.TestCase):
    def setUp(self):
        self.servers = {
            "local":
            TestServer(server_capabilities=[]),
            "search_able":
            TestServer(server_capabilities=[COMPLEX_SEARCH_CAPABILITY])
        }
        self.client = TestClient(servers=self.servers)

        # No conans created
        self.client.run("search")
        output = self.client.user_io.out
        self.assertIn('There are no packages', output)

        # Conans with and without packages created
        self.root_folder1 = 'Hello/1.4.10/fenix/testing'
        root_folder2 = 'helloTest/1.4.10/fenix/stable'
        root_folder3 = 'Bye/0.14/fenix/testing'
        root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
        root_folder5 = 'MissFile/1.0.2/fenix/stable'
        root_folder11 = 'Hello/1.4.11/fenix/testing'
        root_folder12 = 'Hello/1.4.12/fenix/testing'

        self.client.save(
            {
                "Empty/1.10/fake/test/reg/fake.txt":
                "//",
                "%s/%s/WindowsPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1,
                "%s/%s/WindowsPackageSHA/%s" % (root_folder11, PACKAGES_FOLDER, CONANINFO):
                conan_vars1,
                "%s/%s/WindowsPackageSHA/%s" % (root_folder12, PACKAGES_FOLDER, CONANINFO):
                conan_vars1,
                "%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1b,
                "%s/%s/LinuxPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1c,
                "%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO):
                conan_vars2,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO):
                conan_vars3,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO):
                conan_vars4,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"):
                "Hello"
            }, self.client.paths.store)

        # Fake some manifests to be able to calculate recipe hash
        fake_manifest = FileTreeManifest(1212, {})
        self.client.save(
            {
                os.path.join(self.root_folder1, EXPORT_FOLDER, CONAN_MANIFEST):
                str(fake_manifest),
                os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST):
                str(fake_manifest),
                os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST):
                str(fake_manifest),
                os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST):
                str(fake_manifest),
            }, self.client.paths.store)

    def recipe_search_test(self):
        self.client.run("search Hello*")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n"
            "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

        self.client.run("search Hello* --case-sensitive")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n", self.client.user_io.out)

        self.client.run("search *fenix* --case-sensitive")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Bye/0.14@fenix/testing\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n"
            "MissFile/1.0.2@fenix/stable\n"
            "NodeInfo/1.0.2@fenix/stable\n"
            "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

    def recipe_pattern_search_test(self):
        self.client.run("search Hello*")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n"
            "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

        self.client.run("search Hello* --case-sensitive")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n", self.client.user_io.out)

        self.client.run("search *fenix* --case-sensitive")
        self.assertEquals(
            "Existing package recipes:\n\n"
            "Bye/0.14@fenix/testing\n"
            "Hello/1.4.10@fenix/testing\n"
            "Hello/1.4.11@fenix/testing\n"
            "Hello/1.4.12@fenix/testing\n"
            "MissFile/1.0.2@fenix/stable\n"
            "NodeInfo/1.0.2@fenix/stable\n"
            "helloTest/1.4.10@fenix/stable\n", self.client.user_io.out)

    def package_search_with_invalid_reference_test(self):
        self.client.run("search Hello -q 'a=1'", ignore_error=True)
        self.assertIn("-q parameter only allowed with a valid recipe",
                      str(self.client.user_io.out))

    def package_search_with_empty_query_test(self):
        self.client.run("search Hello/1.4.10/fenix/testing")
        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

    def package_search_nonescaped_characters_test(self):
        self.client.run(
            'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11"'
        )
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++"'
        )
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        # Now search with a remote
        os.rmdir(self.servers["local"].paths.store)
        shutil.copytree(self.client.paths.store,
                        self.servers["local"].paths.store)
        self.client.run("remove Hello* -f")
        self.client.run(
            'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++11" -r local'
        )
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10@fenix/testing -q "compiler=gcc AND compiler.libcxx=libstdc++" -r local'
        )
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)

    def _assert_pkg_q(self, query, packages_found, remote):

        command = 'search Hello/1.4.10@fenix/testing -q \'%s\'' % query
        if remote:
            command += " -r %s" % remote
        self.client.run(command)

        for pack_name in [
                "LinuxPackageSHA", "PlatformIndependantSHA",
                "WindowsPackageSHA"
        ]:
            self.assertEquals(pack_name in self.client.user_io.out, pack_name
                              in packages_found, "%s fail" % pack_name)

    def package_search_complex_queries_test(self):
        def test_cases(remote=None):

            if remote:  # Simulate upload to remote
                os.rmdir(self.servers[remote].paths.store)
                shutil.copytree(self.client.paths.store,
                                self.servers[remote].paths.store)

            q = ''
            self._assert_pkg_q(q, [
                "LinuxPackageSHA", "PlatformIndependantSHA",
                "WindowsPackageSHA"
            ], remote)
            q = 'compiler="gcc"'
            self._assert_pkg_q(q,
                               ["LinuxPackageSHA", "PlatformIndependantSHA"],
                               remote)

            q = 'compiler='  # No packages found with empty value
            self._assert_pkg_q(q, [], remote)

            q = 'compiler="gcc" OR compiler.libcxx=libstdc++11'
            # Should find Visual because of the OR, visual doesn't care about libcxx
            self._assert_pkg_q(q, [
                "LinuxPackageSHA", "PlatformIndependantSHA",
                "WindowsPackageSHA"
            ], remote)

            q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR compiler.version=4.5'
            self._assert_pkg_q(q, ["LinuxPackageSHA"], remote)

            q = '(compiler="gcc" AND compiler.libcxx=libstdc++11) OR '\
                '(compiler.version=4.5 OR compiler.version=8.1)'
            self._assert_pkg_q(q, ["LinuxPackageSHA", "WindowsPackageSHA"],
                               remote)

            q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\
                '(compiler.version=4.5 OR compiler.version=8.1)'
            self._assert_pkg_q(q, [
                "LinuxPackageSHA", "PlatformIndependantSHA",
                "WindowsPackageSHA"
            ], remote)

            q = '(compiler="gcc" AND compiler.libcxx=libstdc++) OR '\
                '(compiler.version=4.3 OR compiler.version=8.1)'
            self._assert_pkg_q(q,
                               ["PlatformIndependantSHA", "WindowsPackageSHA"],
                               remote)

            q = '(os="Linux" OR os=Windows)'
            self._assert_pkg_q(q, [
                "PlatformIndependantSHA", "LinuxPackageSHA",
                "WindowsPackageSHA"
            ], remote)

            q = '(os="Linux" OR os=Windows) AND use_Qt=True'
            self._assert_pkg_q(q,
                               ["PlatformIndependantSHA", "WindowsPackageSHA"],
                               remote)

            q = '(os="Linux" OR os=Windows) AND use_Qt=True AND nonexistant_option=3'
            self._assert_pkg_q(q,
                               ["PlatformIndependantSHA", "WindowsPackageSHA"],
                               remote)

            q = '(os="Linux" OR os=Windows) AND use_Qt=True OR nonexistant_option=3'
            self._assert_pkg_q(q, [
                "PlatformIndependantSHA", "WindowsPackageSHA",
                "LinuxPackageSHA"
            ], remote)

        # test in local
        test_cases()

        # test in remote
        test_cases(remote="local")

        # test in remote with search capabilities
        test_cases(remote="search_able")

    def package_search_with_invalid_query_test(self):
        self.client.run("search Hello/1.4.10/fenix/testing -q 'invalid'",
                        ignore_error=True)
        self.assertIn("Invalid package query: invalid",
                      self.client.user_io.out)

        self.client.run("search Hello/1.4.10/fenix/testing -q 'os= 3'",
                        ignore_error=True)
        self.assertIn("Invalid package query: os= 3", self.client.user_io.out)

        self.client.run("search Hello/1.4.10/fenix/testing -q 'os=3 FAKE '",
                        ignore_error=True)
        self.assertIn("Invalid package query: os=3 FAKE ",
                      self.client.user_io.out)

        self.client.run(
            "search Hello/1.4.10/fenix/testing -q 'os=3 os.compiler=4'",
            ignore_error=True)
        self.assertIn("Invalid package query: os=3 os.compiler=4",
                      self.client.user_io.out)

        self.client.run(
            "search Hello/1.4.10/fenix/testing -q 'not os=3 AND os.compiler=4'",
            ignore_error=True)
        self.assertIn(
            "Invalid package query: not os=3 AND os.compiler=4. 'not' operator is not allowed",
            self.client.user_io.out)

        self.client.run(
            "search Hello/1.4.10/fenix/testing -q 'os=3 AND !os.compiler=4'",
            ignore_error=True)
        self.assertIn(
            "Invalid package query: os=3 AND !os.compiler=4. '!' character is not allowed",
            self.client.user_io.out)

    def package_search_properties_filter_test(self):

        # All packages without filter
        self.client.run("search Hello/1.4.10/fenix/testing -q ''")

        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q os=Windows')
        self.assertIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertNotIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10/fenix/testing -q "os=Windows AND compiler.version=4.5"'
        )
        self.assertIn(
            "There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'os=Windows AND compiler.version=4.5'",
            self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10/fenix/testing -q "os=Linux AND compiler.version=4.5"'
        )
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10/fenix/testing -q "compiler.version=1.0"')
        self.assertIn(
            "There are no packages for reference 'Hello/1.4.10@fenix/testing' matching the query 'compiler.version=1.0'",
            self.client.user_io.out)

        self.client.run(
            'search Hello/1.4.10/fenix/testing -q "compiler=gcc AND compiler.version=4.5"'
        )
        self.assertNotIn("WindowsPackageSHA", self.client.user_io.out)
        self.assertNotIn("PlatformIndependantSHA", self.client.user_io.out)
        self.assertIn("LinuxPackageSHA", self.client.user_io.out)

        self.client.run('search Hello/1.4.10/fenix/testing -q "arch=x86"')
        # One package will be outdated from recipe and another don't
        self.assertEquals(
            """Existing packages for recipe Hello/1.4.10@fenix/testing:

    Package_ID: LinuxPackageSHA
        [options]
            use_Qt: False
        [settings]
            arch: x86
            compiler: gcc
            compiler.libcxx: libstdc++11
            compiler.version: 4.5
            os: Linux
        [requires]
            Hello2/0.1@lasote/stable:11111
            HelloInfo1/0.45@fenix/testing:33333
            OpenSSL/2.10@lasote/testing:2222
        outdated from recipe: False

    Package_ID: PlatformIndependantSHA
        [options]
            use_Qt: True
        [settings]
            arch: x86
            compiler: gcc
            compiler.libcxx: libstdc++
            compiler.version: 4.3
        outdated from recipe: True

""", self.client.user_io.out)

        self.client.run(
            'search helloTest/1.4.10@fenix/stable -q use_OpenGL=False')
        self.assertIn(
            "There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
            "matching the query 'use_OpenGL=False'", self.client.user_io.out)

        self.client.run(
            'search helloTest/1.4.10@fenix/stable -q use_OpenGL=True')
        self.assertIn(
            "Existing packages for recipe helloTest/1.4.10@fenix/stable",
            self.client.user_io.out)

        self.client.run(
            'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x64"'
        )
        self.assertIn(
            "Existing packages for recipe helloTest/1.4.10@fenix/stable",
            self.client.user_io.out)

        self.client.run(
            'search helloTest/1.4.10@fenix/stable -q "use_OpenGL=True AND arch=x86"'
        )
        self.assertIn(
            "There are no packages for reference 'helloTest/1.4.10@fenix/stable' "
            "matching the query 'use_OpenGL=True AND arch=x86'",
            self.client.user_io.out)

    def search_with_no_local_test(self):
        client = TestClient()
        client.run("search nonexist/1.0@lasote/stable")
        self.assertIn("There are no packages", self.client.user_io.out)
Exemplo n.º 55
0
class FlatRequirementsTest(unittest.TestCase):
    def setUp(self):
        self.conan_reference = ConanFileReference.loads(
            "Hello0/0.1@lasote/stable")
        self.files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        self.conan = TestClient()
        self.conan.save(self.files)
        self.conan.run("export lasote/stable")

    def consumer_with_flat_requirement_test(self):
        # We want to reuse exported Hello0/0.1@lasote/stable
        tmp_dir = temp_folder()
        req_file = '''[requires]
Hello0/0.1@lasote/stable # My req comment
[generators]
gcc # I need this generator for..
cmake
visual_studio
xcode
'''
        save(os.path.join(tmp_dir, CONANFILE_TXT), req_file)

        self.conan.current_folder = tmp_dir
        # Install requirements
        self.conan.run('install --build missing')
        self.assertEqual(
            sorted([
                CONANFILE_TXT, BUILD_INFO_GCC, BUILD_INFO_CMAKE,
                BUILD_INFO_VISUAL_STUDIO, BUILD_INFO_XCODE, CONANINFO
            ]), sorted(os.listdir(tmp_dir)))

        cmake = load(os.path.join(tmp_dir, BUILD_INFO_CMAKE))
        gcc = load(os.path.join(tmp_dir, BUILD_INFO_GCC))

        self.assertIn("CONAN_INCLUDE_DIRS", cmake)
        self.assertIn("CONAN_LIB_DIRS", cmake)
        self.assertIn("CONAN_LIBS", cmake)

        self.assertIn("CONAN_INCLUDE_DIRS", cmake)
        self.assertIn("CONAN_LIB_DIRS", cmake)
        self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", cmake)

        self.assertIn("-L", gcc)
        self.assertIn("-l", gcc)
        self.assertIn("-I", gcc)

        self.assertIn(".conan/data/Hello0/0.1/lasote/stable/package", gcc)

        # CHECK VISUAL STUDIO GENERATOR

        from xml.dom import minidom
        xmldoc = minidom.parse(os.path.join(tmp_dir, BUILD_INFO_VISUAL_STUDIO))
        definition_group = xmldoc.getElementsByTagName(
            'ItemDefinitionGroup')[0]
        compiler = definition_group.getElementsByTagName("ClCompile")[0]

        include_dirs = compiler.getElementsByTagName(
            "AdditionalIncludeDirectories")[0].firstChild.data
        definitions = compiler.getElementsByTagName(
            "PreprocessorDefinitions")[0].firstChild.data

        linker = definition_group.getElementsByTagName("Link")[0]
        lib_dirs = linker.getElementsByTagName(
            "AdditionalLibraryDirectories")[0].firstChild.data
        libs = linker.getElementsByTagName(
            "AdditionalDependencies")[0].firstChild.data

        package_id = os.listdir(self.conan.paths.packages(
            self.conan_reference))[0]
        package_ref = PackageReference(self.conan_reference, package_id)
        package_paths = self.conan.paths.package(package_ref).replace(
            "\\", "/")

        expected_lib_dirs = os.path.join(package_paths,
                                         "lib").replace("\\", "/")
        expected_include_dirs = os.path.join(package_paths,
                                             "include").replace("\\", "/")

        self.assertIn(expected_lib_dirs, lib_dirs)
        self.assertEquals("helloHello0.lib;%(AdditionalDependencies)", libs)
        self.assertEquals("%(PreprocessorDefinitions)", definitions)
        self.assertIn(expected_include_dirs, include_dirs)

        # CHECK XCODE GENERATOR
        xcode = load(os.path.join(tmp_dir, BUILD_INFO_XCODE))

        self.assertIn(
            'LIBRARY_SEARCH_PATHS = $(inherited) "%s"' % expected_lib_dirs,
            xcode)
        self.assertIn(
            'HEADER_SEARCH_PATHS = $(inherited) "%s"' % expected_include_dirs,
            xcode)
        self.assertIn("GCC_PREPROCESSOR_DEFINITIONS = $(inherited)", xcode)
        self.assertIn("OTHER_CFLAGS = $(inherited)", xcode)
        self.assertIn("OTHER_CPLUSPLUSFLAGS = $(inherited)", xcode)
Exemplo n.º 56
0
    def reuse_test(self):
        self._export_upload("Hello0", "0.1")
        self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
        self._export_upload("Hello2", "0.1", ["Hello0/0.1@lasote/stable"])
        self._export_upload(
            "Hello3", "0.1",
            ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"])

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4", "0.1",
                                       ["Hello3/0.1@lasote/stable"])

        # Add some stuff to base project conanfile to test further the individual
        # flags in build_info (txt, cmake) files
        content = files3[CONANFILE]
        content = content.replace("generators =", 'generators = "txt",')
        content = content.replace(
            "def build(self):", "def build(self):\n"
            "        self.output.info('INCLUDE %s' "
            "% self.deps_cpp_info['Hello0'].include_paths)")
        files3[CONANFILE] = content
        client.save(files3)

        client.run("install . --build missing")
        client.run("build .")
        self._check_individual_deps(client)

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1)
        client.save(files3, clean_first=True)
        client.run("install . --build missing")
        client.run("build .")

        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        # Try to upload and reuse the binaries
        client.run("upload Hello3/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello0/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4", "0.1",
                                       ["Hello3/0.1@lasote/stable"])
        client2.save(files3)
        client2.run("install . --build missing")
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1)
        client2.save(files3, clean_first=True)
        client2.run("install . --build missing")
        client2.run("build .")
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])
Exemplo n.º 57
0
    def local_test(self):
        client = TestClient()

        # No conans created
        client.run("search")
        output = client.user_io.out
        self.assertIn('There are no packages', output)

        # Conans with and without packages created
        root_folder1 = 'Hello/1.4.10/fenix/testing'
        root_folder2 = 'helloTest/1.4.10/fenix/stable'
        root_folder3 = 'Bye/0.14/fenix/testing'
        root_folder4 = 'NodeInfo/1.0.2/fenix/stable'
        root_folder5 = 'MissFile/1.0.2/fenix/stable'

        client.save(
            {
                "Empty/1.10/fake/test/reg/fake.txt":
                "//",
                "%s/%s/d91960d4c06b38/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1,
                "%s/%s/a44f541cd44w57/%s" % (root_folder2, PACKAGES_FOLDER, CONANINFO):
                conan_vars2,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder3, PACKAGES_FOLDER, CONANINFO):
                conan_vars3,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder4, PACKAGES_FOLDER, CONANINFO):
                conan_vars4,
                "%s/%s/e4f7vdwcv4w55d/%s" % (root_folder5, PACKAGES_FOLDER, "hello.txt"):
                "Hello"
            }, client.paths.store)

        client.run("search -v")
        self.assertEqual(
            """Existing packages info:

Bye/0.14@fenix/testing
    Package_ID: e4f7vdwcv4w55d
        [options]
            HAVE_TESTS=True
            USE_CONFIG=False
        [settings]
            os=Darwin
        [requirements]
Empty/1.10@fake/test
    There are no packages
Hello/1.4.10@fenix/testing
    Package_ID: d91960d4c06b38
        [options]
            use_Qt=True
        [settings]
            arch=x64
            os=Windows
            version=8.1
        [requirements]
MissFile/1.0.2@fenix/stable
    There are no packages
NodeInfo/1.0.2@fenix/stable
    Package_ID: e4f7vdwcv4w55d
        [options]
            language=1
        [settings]
            arch=x86_64
            compiler=gcc
            os=Windows
        [requirements]
helloTest/1.4.10@fenix/stable
    Package_ID: a44f541cd44w57
        [options]
            use_OpenGL=True
        [settings]
            arch=x64
            os=Ubuntu
            version=15.04
        [requirements]
""", client.user_io.out)

        client.run("search")
        self.assertEqual(
            """Existing packages info:

Bye/0.14@fenix/testing
    Package_ID: e4f7vdwcv4w55d
            (Darwin)
Empty/1.10@fake/test
    There are no packages
Hello/1.4.10@fenix/testing
    Package_ID: d91960d4c06b38
            (x64, Windows, 8.1)
MissFile/1.0.2@fenix/stable
    There are no packages
NodeInfo/1.0.2@fenix/stable
    Package_ID: e4f7vdwcv4w55d
            (x86_64, gcc, Windows)
helloTest/1.4.10@fenix/stable
    Package_ID: a44f541cd44w57
            (x64, Ubuntu, 15.04)
""", client.user_io.out)

        client.run("search Bye/* -v")
        self.assertEqual(
            """Existing packages info:

Bye/0.14@fenix/testing
    Package_ID: e4f7vdwcv4w55d
        [options]
            HAVE_TESTS=True
            USE_CONFIG=False
        [settings]
            os=Darwin
        [requirements]
""", client.user_io.out)

        # bad pattern
        client.run("search OpenCV/*")
        self.assertIn("There are no packages matching the OpenCV/* pattern",
                      client.user_io.out)

        # pattern case-sensitive
        client.run("search hello* --case-sensitive -v")
        self.assertIn("helloTest/1.4.10@fenix/stable", client.user_io.out)
        self.assertNotIn("Empty/1.10@fake/test", client.user_io.out)
        self.assertNotIn("Hello/1.4.10@fenix/testing", client.user_io.out)
        self.assertNotIn("NodeInfo/1.0.2@fenix/stable", client.user_io.out)

        # Package search
        client.run("search -p e4*")
        self.assertIn(
            '''Bye/0.14@fenix/testing
    Package_ID: e4f7vdwcv4w55d
            (Darwin)
NodeInfo/1.0.2@fenix/stable
    Package_ID: e4f7vdwcv4w55d
            (x86_64, gcc, Windows)''', client.user_io.out)

        client.run("search -p d9")
        self.assertIn(
            '''Hello/1.4.10@fenix/testing
    Package_ID: d91960d4c06b38
            (x64, Windows, 8.1)''', client.user_io.out)

        client.run("search Bye/0.14@fenix/testing -p e4*")
        self.assertNotIn('''NodeInfo/1.0.2@fenix/stable''', client.user_io.out)
Exemplo n.º 58
0
class DiamondTest(unittest.TestCase):
    def setUp(self):
        test_server = TestServer(
            [],  # write permissions
            users={"lasote": "mypass"})  # exported users and passwords
        self.servers = {"default": test_server}
        self.conan = TestClient(servers=self.servers,
                                users={"default": [("lasote", "mypass")]})

    def _export_upload(self, name, version=None, deps=None, use_cmake=True):
        files = cpp_hello_conan_files(name,
                                      version,
                                      deps,
                                      need_patch=True,
                                      use_cmake=use_cmake)
        conan_ref = ConanFileReference(name, version, "lasote", "stable")
        self.conan.save(files, clean_first=True)
        self.conan.run("export lasote/stable")
        self.conan.run("upload %s" % str(conan_ref))

    def _check_individual_deps(self, client):
        self.assertIn("INCLUDE [", client.user_io.out)
        self.assertIn(".conan/data/Hello0/0.1/lasote/stable",
                      client.user_io.out)
        build_file = os.path.join(client.current_folder, BUILD_INFO)
        content = load(build_file)
        cmakebuildinfo = load(
            os.path.join(client.current_folder, BUILD_INFO_CMAKE))
        self.assertIn(
            "set(CONAN_LIBS helloHello3 helloHello1 helloHello2 helloHello0",
            cmakebuildinfo)
        self.assertIn("set(CONAN_DEPENDENCIES Hello3 Hello1 Hello2 Hello0)",
                      cmakebuildinfo)
        deps_cpp_info = DepsCppInfo.loads(content)
        self.assertEqual(len(deps_cpp_info.include_paths), 4)
        for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
            self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
            self.assertEqual(len(deps_cpp_info[dep].lib_paths), 1)
            self.assertEqual(deps_cpp_info[dep].libs, ["hello%s" % dep])
        build_file = os.path.join(client.current_folder, BUILD_INFO_CMAKE)
        content = load(build_file)
        for dep in ("Hello3", "Hello2", "Hello1", "Hello0"):
            self.assertEqual(len(deps_cpp_info[dep].include_paths), 1)
            self.assertIn("set(CONAN_INCLUDE_DIRS_%s " % dep.upper(), content)
            self.assertIn("set(CONAN_LIBS_%s hello%s)" % (dep.upper(), dep),
                          content)

    def diamond_cmake_test(self):
        self._diamond_test(use_cmake=True)

    def diamond_default_test(self):
        self._diamond_test(use_cmake=False)

    def diamond_mingw_test(self):
        if platform.system() != "Windows":
            return
        not_env = os.system("g++ --version > nul")
        if not_env != 0:
            logger.error("This platform does not support G++ command")
            return
        install = "install -s compiler=gcc -s compiler.libcxx=libstdc++ -s compiler.version=4.9"
        self._diamond_test(install=install, use_cmake=False)

    def _diamond_test(self, install="install", use_cmake=True):
        def wait_until_removed(folder):
            latest_exception = None
            for _ in range(50):  # Max 5 seconds
                time.sleep(0.1)
                try:
                    shutil.rmtree(folder)
                    break
                except Exception as e:
                    latest_exception = e
            else:
                raise Exception("Could remove folder %s: %s" %
                                (folder, latest_exception))

        self._export_upload("Hello0", "0.1", use_cmake=use_cmake)
        self._export_upload("Hello1",
                            "0.1", ["Hello0/0.1@lasote/stable"],
                            use_cmake=use_cmake)
        self._export_upload("Hello2",
                            "0.1", ["Hello0/0.1@lasote/stable"],
                            use_cmake=use_cmake)
        self._export_upload(
            "Hello3",
            "0.1", ["Hello1/0.1@lasote/stable", "Hello2/0.1@lasote/stable"],
            use_cmake=use_cmake)

        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       use_cmake=use_cmake)

        # Add some stuff to base project conanfile to test further the individual
        # flags in build_info (txt, cmake) files
        content = files3[CONANFILE]
        content = content.replace("generators =", 'generators = "txt",')
        content = content.replace(
            "def build(self):", "def build(self):\n"
            "        self.output.info('INCLUDE %s' "
            "% self.deps_cpp_info['Hello0'].include_paths)")
        files3[CONANFILE] = content
        client.save(files3)

        client.run("%s . --build missing" % install)
        client.run("build .")
        self._check_individual_deps(client)

        command = os.sep.join([".", "bin", "say_hello"])
        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1,
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        wait_until_removed(client.current_folder)
        client.save(files3)
        client.run("%s . --build missing" % install)
        client.run("build .")

        client.runner(command, cwd=client.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client.user_io.out).splitlines()[-6:])

        # Try to upload and reuse the binaries
        client.run("upload Hello3/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello1/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello2/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)
        client.run("upload Hello0/0.1@lasote/stable --all")
        self.assertEqual(str(client.user_io.out).count("Uploading package"), 2)

        client2 = TestClient(servers=self.servers,
                             users={"default": [("lasote", "mypass")]})
        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        client2.save(files3)
        client2.run("%s . --build missing" % install)
        client2.run("build .")

        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])

        files3 = cpp_hello_conan_files("Hello4",
                                       "0.1", ["Hello3/0.1@lasote/stable"],
                                       language=1,
                                       use_cmake=use_cmake)
        files3[CONANFILE] = files3[CONANFILE].replace("generators =",
                                                      'generators = "txt",')
        wait_until_removed(client2.current_folder)
        client2.save(files3)
        client2.run("%s . --build missing" % install)
        client2.run("build .")
        self.assertNotIn("libhello0.a", client2.user_io.out)
        self.assertNotIn("libhello1.a", client2.user_io.out)
        self.assertNotIn("libhello2.a", client2.user_io.out)
        self.assertNotIn("libhello3.a", client2.user_io.out)
        client2.runner(command, cwd=client2.current_folder)
        self.assertEqual([
            'Hola Hello4', 'Hola Hello3', 'Hola Hello1', 'Hola Hello0',
            'Hola Hello2', 'Hola Hello0'
        ],
                         str(client2.user_io.out).splitlines()[-6:])
Exemplo n.º 59
0
    def reuse_test(self):
        client = TestClient(servers=self.servers,
                            users={"default": [("lasote", "mypass")]})
        conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1")
        files[CONANFILE] = files[CONANFILE].replace("build", "build2")

        client.save(files)
        client.run("export lasote/stable")
        client.run("install %s --build missing" % str(conan_reference))

        self.assertTrue(os.path.exists(client.paths.builds(conan_reference)))
        self.assertTrue(os.path.exists(client.paths.packages(conan_reference)))

        # Upload
        client.run("upload %s --all" % str(conan_reference))

        # Now from other "computer" install the uploaded conans with same options (nothing)
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build missing" % str(conan_reference))
        self.assertFalse(
            os.path.exists(other_conan.paths.builds(conan_reference)))
        self.assertTrue(
            os.path.exists(other_conan.paths.packages(conan_reference)))

        # Now from other "computer" install the uploaded conans with same options (nothing)
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build" % str(conan_reference))
        self.assertTrue(
            os.path.exists(other_conan.paths.builds(conan_reference)))
        self.assertTrue(
            os.path.exists(other_conan.paths.packages(conan_reference)))

        # Use an invalid pattern and check that its not builded from source
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build HelloInvalid" %
                        str(conan_reference))
        self.assertFalse(
            os.path.exists(other_conan.paths.builds(conan_reference)))
        self.assertTrue(
            os.path.exists(other_conan.paths.packages(conan_reference)))

        # Use another valid pattern and check that its not builded from source
        other_conan = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        other_conan.run("install %s --build HelloInvalid -b Hello" %
                        str(conan_reference))
        self.assertTrue(
            os.path.exists(other_conan.paths.builds(conan_reference)))
        self.assertTrue(
            os.path.exists(other_conan.paths.packages(conan_reference)))

        # Now even if the package is in local store, check that's rebuilded
        other_conan.run("install %s -b Hello*" % str(conan_reference))
        self.assertIn("Copying sources to build folder",
                      other_conan.user_io.out)

        other_conan.run("install %s" % str(conan_reference))
        self.assertNotIn("Copying sources to build folder",
                         other_conan.user_io.out)
Exemplo n.º 60
0
class MyBuildInfo(unittest.TestCase):
    def setUp(self):
        test_server = TestServer(users={"lasote": "lasote"})
        test_server2 = TestServer(users={"lasote": "lasote"})
        self.servers = {"default": test_server, "alternative": test_server2}
        self.client = TestClient(servers=self.servers,
                                 users={
                                     "default": [("lasote", "lasote")],
                                     "alternative": [("lasote", "lasote")]
                                 })

    def test_only_download(self):
        files = cpp_hello_conan_files("Hello", "1.0", build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("upload '*' -c --all")
        trace_file = os.path.join(temp_folder(), "conan_trace.log")
        self.client.run("remove '*' -f")
        with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
            self.client.run("install Hello/1.0@lasote/stable --build")

        data = get_build_info(trace_file).serialize()
        self.assertEquals(len(data["modules"]), 1)
        self.assertEquals(data["modules"][0]["id"], "DownloadOnly")
        self.assertEquals(len(data["modules"][0]["artifacts"]), 0)
        self.assertEquals(len(data["modules"][0]["dependencies"]), 3)

    def test_json(self):

        # Upload to server Hello1 => Hello0 and Hello2 => Hello0
        files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")

        files = cpp_hello_conan_files("Hello1",
                                      "1.0",
                                      deps=["Hello0/1.0@lasote/stable"],
                                      build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")

        files = cpp_hello_conan_files("Hello2",
                                      "1.0",
                                      deps=["Hello0/1.0@lasote/stable"],
                                      build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install Hello1/1.0@lasote/stable --build missing")
        self.client.run("install Hello2/1.0@lasote/stable --build missing")
        self.client.run("upload '*' -c --all")

        # Remove all from local cache
        self.client.run("remove '*' -f")

        # Now activate logs and install both Hello1 and Hello2
        trace_file = os.path.join(temp_folder(), "conan_trace.log")
        with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
            self.client.run("install Hello0/1.0@lasote/stable")
            self.client.run("upload '*' -c --all")
            data = get_build_info(trace_file).serialize()
            # Only uploaded 2 modules, the Hello0 recipe and the Hello0 package
            # without dependencies
            self.assertEquals(len(data["modules"]), 2)
            self.assertEquals(len(data["modules"][0]["dependencies"]), 0)
            self.assertEquals(len(data["modules"][0]["dependencies"]), 0)
            self.assertEquals(len(data["modules"][0]["artifacts"]), 3)

            # Now upload the rest of them
            self.client.run("install Hello1/1.0@lasote/stable --build missing")
            self.client.run("install Hello2/1.0@lasote/stable --build missing")
            self.client.run("upload '*' -c --all")
            data = get_build_info(trace_file).serialize()
            self.assertEquals(len(data["modules"]), 6)
            for mod_name in [
                    "Hello1/1.0@lasote/stable", "Hello2/1.0@lasote/stable"
            ]:
                module = _get_module(data, mod_name)
                self.assertEquals(3, len(module["dependencies"]))
                self.assertEquals(3, len(module["artifacts"]))
                for dep in module["dependencies"]:
                    self.assertTrue(
                        dep["id"].startswith("Hello0/1.0@lasote/stable"))

    def test_invalid_tracer(self):
        trace_file = os.path.join(temp_folder(), "conan_trace.log")
        save(trace_file, "invalid contents")
        with self.assertRaisesRegexp(Exception, "INVALID TRACE FILE!"):
            get_build_info(trace_file).serialize()

    def test_cross_remotes(self):

        # Upload to alternative server Hello0 but Hello1 to the default
        files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")

        files = cpp_hello_conan_files("Hello1",
                                      "1.0",
                                      deps=["Hello0/1.0@lasote/stable"],
                                      build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")

        self.client.run("export lasote/stable")
        self.client.run("install Hello1/1.0@lasote/stable --build missing")

        self.client.run("upload 'Hello0*' -c --all -r alternative")
        self.client.run("upload 'Hello1*' -c --all -r default")

        trace_file = os.path.join(temp_folder(), "conan_trace.log")
        with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
            # Will retrieve the Hello0 deps from the alternative
            self.client.run("install Hello1/1.0@lasote/stable --build")

            # Upload to the default, not matching the Hello0 remote
            self.client.run("upload 'Hello1*' -c --all -r default")

            data = get_build_info(trace_file).serialize()
            self.assertEquals(len(data["modules"]), 2)
            module = _get_module(data, "Hello1/1.0@lasote/stable")
            self.assertEquals(0, len(module["dependencies"]))

    def trace_command_test(self):
        from conans.build_info.command import run
        trace_file = os.path.join(temp_folder(), "conan_trace.log")
        # Generate some traces
        with tools.environment_append({"CONAN_TRACE_FILE": trace_file}):
            files = cpp_hello_conan_files("Hello0",
                                          "1.0",
                                          deps=[],
                                          build=False)
            self.client.save(files)
            self.client.run("export lasote/stable")
            self.client.run("install Hello0/1.0@lasote/stable --build")
            self.client.run("upload '*' --all -c")

        # Get json from file
        output = os.path.join(temp_folder(), "build_info.json")
        sys.argv = ['conan_build_info', trace_file, '--output', output]
        run()

        the_json = json.loads(load(output))
        self.assertTrue(the_json["modules"][0]["id"],
                        "Hello0/1.0@lasote/stable")

        # Now get from stdout
        sys.argv = ['conan_build_info', trace_file]
        run()

        try:  # in IDEs or with --nocapture it will fail
            stdout_value = sys.stdout.getvalue()
        except AttributeError:
            pass
        else:
            the_json = json.loads(stdout_value)
            self.assertTrue(the_json["modules"][0]["id"],
                            "Hello0/1.0@lasote/stable")