Esempio n. 1
0
    def __init__(self, base_folder=None, current_folder=None,
                 servers=None, users=None, client_version=CLIENT_VERSION,
                 min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION):
        """
        storage_folder: Local storage path
        current_folder: Current execution folder
        servers: dict of {remote_name: TestServer}
        logins is a list of (user, password) for auto input in order
        if required==> [("lasote", "mypass"), ("other", "otherpass")]
        """
        self.users = users or {"default":
                               [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]}
        self.servers = servers or {}

        self.client_version = Version(str(client_version))
        self.min_server_compatible_version = Version(str(min_server_compatible_version))

        self.base_folder = base_folder or temp_folder()
        # Define storage_folder, if not, it will be read from conf file & pointed to real user home
        self.storage_folder = os.path.join(self.base_folder, ".conan", "data")
        self.paths = ConanPaths(self.base_folder, self.storage_folder, TestBufferConanOutput())
        self.default_settings(get_env("CONAN_COMPILER", "gcc"),
                              get_env("CONAN_COMPILER_VERSION", "4.8"))

        self.init_dynamic_vars()

        save(self.paths.registry, "")
        registry = RemoteRegistry(self.paths.registry, TestBufferConanOutput())
        for name, server in self.servers.items():
            registry.add(name, server.fake_url)

        logger.debug("Client storage = %s" % self.storage_folder)
        self.current_folder = current_folder or temp_folder()
Esempio n. 2
0
    def testMd5Name(self):
        files = {
            "one_file.txt": {
                "contents": b"The contents",
                "mode": 0o777
            },
            "Two_file.txt": {
                "contents": b"Two contents",
                "mode": 0o777
            }
        }
        new_files = compress_files(files, PACKAGE_TGZ_NAME, excluded=[])
        folder = temp_folder()
        file_path = os.path.join(folder, PACKAGE_TGZ_NAME)
        save(file_path, new_files[PACKAGE_TGZ_NAME])

        md5_a = md5sum(file_path)

        time.sleep(1)  # Timestamps change

        new_files = compress_files(files, PACKAGE_TGZ_NAME, excluded=[])
        folder = temp_folder()
        file_path = os.path.join(folder, PACKAGE_TGZ_NAME)
        save(file_path, new_files[PACKAGE_TGZ_NAME])

        md5_b = md5sum(file_path)

        self.assertEquals(md5_a, md5_b)
Esempio n. 3
0
    def test_md5_compress(self):
        folder = temp_folder()
        save(os.path.join(folder, "one_file.txt"), b"The contents")
        save(os.path.join(folder, "Two_file.txt"), b"Two contents")

        files = {
            "one_file.txt": os.path.join(folder, "one_file.txt"),
            "Two_file.txt": os.path.join(folder, "Two_file.txt"),
        }

        compress_files(files, {}, PACKAGE_TGZ_NAME, dest_dir=folder)
        file_path = os.path.join(folder, PACKAGE_TGZ_NAME)

        md5_a = md5sum(file_path)
        self.assertEqual(md5_a, "df220cfbc0652e8992a89a77666c03b5")

        time.sleep(1)  # Timestamps change

        folder = temp_folder()
        compress_files(files, {}, PACKAGE_TGZ_NAME, dest_dir=folder)
        file_path = os.path.join(folder, PACKAGE_TGZ_NAME)

        md5_b = md5sum(file_path)

        self.assertEquals(md5_a, md5_b)
Esempio n. 4
0
    def __init__(
        self,
        base_folder=None,
        current_folder=None,
        servers=None,
        users=None,
        client_version=CLIENT_VERSION,
        min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION,
    ):
        """
        storage_folder: Local storage path
        current_folder: Current execution folder
        servers: dict of {remote_name: TestServer}
        logins is a list of (user, password) for auto input in order
        if required==> [("lasote", "mypass"), ("other", "otherpass")]
        """
        if users is None:
            users = [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]
        self.users = users
        self.servers = servers or {}

        self.client_version = Version(client_version)
        self.min_server_compatible_version = Version(min_server_compatible_version)

        self.base_folder = base_folder or temp_folder()
        # Define storage_folder, if not, it will be readed from conf file and pointed to real user home
        self.storage_folder = os.path.join(self.base_folder, ".conan", "data")
        # First initialization for set paths (some test copies data before first real initialization)
        self.init_dynamic_vars()
        self.default_settings(get_env("CONAN_COMPILER", "gcc"), get_env("CONAN_COMPILER_VERSION", "4.8"))

        logger.debug("Client storage = %s" % self.storage_folder)
        self.current_folder = current_folder or temp_folder()
    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")
Esempio n. 6
0
    def __init__(self, base_folder=None, current_folder=None,
                 servers=None, users=None, client_version=CLIENT_VERSION,
                 min_server_compatible_version=MIN_SERVER_COMPATIBLE_VERSION,
                 requester_class=None, runner=None, path_with_spaces=True):
        """
        storage_folder: Local storage path
        current_folder: Current execution folder
        servers: dict of {remote_name: TestServer}
        logins is a list of (user, password) for auto input in order
        if required==> [("lasote", "mypass"), ("other", "otherpass")]
        """
        self.all_output = ""  # For debugging purpose, append all the run outputs
        self.users = users or {"default":
                               [(TESTING_REMOTE_PRIVATE_USER, TESTING_REMOTE_PRIVATE_PASS)]}

        self.client_version = Version(str(client_version))
        self.min_server_compatible_version = Version(str(min_server_compatible_version))

        self.base_folder = base_folder or temp_folder(path_with_spaces)

        # Define storage_folder, if not, it will be read from conf file & pointed to real user home
        self.storage_folder = os.path.join(self.base_folder, ".conan", "data")
        self.client_cache = ClientCache(self.base_folder, self.storage_folder, TestBufferConanOutput())

        self.search_manager = DiskSearchManager(self.client_cache)

        self.requester_class = requester_class
        self.conan_runner = runner

        self.update_servers(servers)
        self.init_dynamic_vars()

        logger.debug("Client storage = %s" % self.storage_folder)
        self.current_folder = current_folder or temp_folder(path_with_spaces)
Esempio n. 7
0
    def basic_test(self):
        folder1 = temp_folder()
        sub1 = os.path.join(folder1, "subdir1")
        sub2 = os.path.join(folder1, "subdir2")
        save(os.path.join(sub1, "file1.txt"), "Hello1")
        save(os.path.join(sub1, "file2.c"), "Hello2")
        save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")
        save(os.path.join(sub1, "sub1/file2.c"), "Hello2 sub")
        save(os.path.join(sub2, "file1.txt"), "2 Hello1")
        save(os.path.join(sub2, "file2.c"), "2 Hello2")

        folder2 = temp_folder()
        copier = FileCopier(folder1, folder2)
        copier("*.txt", "texts")
        self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
        self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
        self.assertEqual("2 Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
        self.assertEqual(['file1.txt'], os.listdir(os.path.join(folder2, "texts/subdir2")))

        folder2 = temp_folder()
        copier = FileCopier(folder1, folder2)
        copier("*.txt", "texts", "subdir1")
        self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
        self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
        self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
Esempio n. 8
0
    def basic_with_linked_dir_test(self):
        if platform.system() == "Linux" or platform.system() == "Darwin":
            folder1 = temp_folder()
            sub1 = os.path.join(folder1, "subdir1")
            sub2 = os.path.join(folder1, "subdir2")
            os.makedirs(sub1)
            os.symlink("subdir1", sub2)
            save(os.path.join(sub1, "file1.txt"), "Hello1")
            save(os.path.join(sub1, "file2.c"), "Hello2")
            save(os.path.join(sub1, "sub1/file1.txt"), "Hello1 sub")

            folder2 = temp_folder()
            copier = FileCopier(folder1, folder2)
            copier("*.txt", "texts")
            self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir1/file1.txt")))
            self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/subdir1/sub1/file1.txt")))
            self.assertEqual("Hello1", load(os.path.join(folder2, "texts/subdir2/file1.txt")))
            self.assertEqual(['file1.txt', 'sub1'].sort(), os.listdir(os.path.join(folder2, "texts/subdir2")).sort())

            folder2 = temp_folder()
            copier = FileCopier(folder1, folder2)
            copier("*.txt", "texts", "subdir1")
            self.assertEqual("Hello1", load(os.path.join(folder2, "texts/file1.txt")))
            self.assertEqual("Hello1 sub", load(os.path.join(folder2, "texts/sub1/file1.txt")))
            self.assertNotIn("subdir2", os.listdir(os.path.join(folder2, "texts")))
    def valid_xml_test(self):
        conanfile = ConanFile(None, None, Settings({}), None)
        ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
        folder1 = temp_folder()
        folder1 = folder1.replace("\\", "/")
        os.makedirs(os.path.join(folder1, "include"))
        os.makedirs(os.path.join(folder1, "lib"))
        cpp_info = CppInfo(folder1)
        conanfile.deps_cpp_info.update(cpp_info, ref.name)
        ref = ConanFileReference.loads("My.Fancy-Pkg_2/0.1@user/testing")
        folder2 = temp_folder()
        folder2 = folder2.replace("\\", "/")
        os.makedirs(os.path.join(folder2, "include"))
        os.makedirs(os.path.join(folder2, "lib"))
        cpp_info = CppInfo(folder2)
        conanfile.deps_cpp_info.update(cpp_info, ref.name)
        generator = VisualStudioLegacyGenerator(conanfile)

        content = generator.content
        xml.etree.ElementTree.fromstring(content)

        self.assertIn('AdditionalIncludeDirectories=""%s/include";"%s/include";"'
                      % (folder1, folder2), content)
        self.assertIn('AdditionalLibraryDirectories=""%s/lib";"%s/lib";"'
                      % (folder1, folder2), content)
Esempio n. 10
0
 def setUp(self):
     self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
     self.package_reference = PackageReference(self.conan_reference, "123123123")
     self.remote_client = MockRemoteClient()
     self.output = TestBufferConanOutput()
     self.client_cache = ClientCache(temp_folder(), temp_folder(), self.output)
     self.manager = RemoteManager(self.client_cache, self.remote_client, self.output)
Esempio n. 11
0
 def setUp(self):
     self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
     self.package_reference = PackageReference(self.conan_reference, "123123123")
     self.remote_client = MockRemoteClient()
     self.output = TestBufferConanOutput()
     self.paths = ConanPaths(temp_folder(), temp_folder(), self.output)
     self.remotes = [("default", "url1"), ("other", "url2"), ("last", "url3")]
     self.manager = RemoteManager(self.paths, self.remote_client, self.output)
Esempio n. 12
0
    def download_retries_test(self):
        out = TestBufferConanOutput()
        set_global_instances(out, requests)
        # Connection error
        with self.assertRaisesRegexp(ConanException, "HTTPConnectionPool"):
            tools.download("http://fakeurl3.es/nonexists",
                           os.path.join(temp_folder(), "file.txt"), out=out,
                           retry=3, retry_wait=0)

        # Not found error
        self.assertEquals(str(out).count("Waiting 0 seconds to retry..."), 2)
        with self.assertRaisesRegexp(NotFoundException, "Not found: "):
            tools.download("https://github.com/conan-io/conan/blob/develop/FILE_NOT_FOUND.txt",
                           os.path.join(temp_folder(), "README.txt"), out=out,
                           retry=3, retry_wait=0)

        # And OK
        dest = os.path.join(temp_folder(), "manual.html")
        tools.download("http://www.zlib.net/manual.html",
                       dest, out=out,
                       retry=3, retry_wait=0)

        self.assertTrue(os.path.exists(dest))
        content = load(dest)

        # overwrite = False
        with self.assertRaises(ConanException):
            tools.download("http://www.zlib.net/manual.html",
                           dest, out=out,
                           retry=3, retry_wait=0, overwrite=False)

        # overwrite = True
        tools.download("http://www.zlib.net/manual.html",
                       dest, out=out,
                       retry=3, retry_wait=0, overwrite=True)

        self.assertTrue(os.path.exists(dest))
        content_new = load(dest)
        self.assertEqual(content, content_new)

        # Not authorized
        with self.assertRaises(ConanException):
            tools.download("https://httpbin.org/basic-auth/user/passwd", dest, overwrite=True)

        # Authorized
        tools.download("https://httpbin.org/basic-auth/user/passwd", dest, auth=("user", "passwd"),
                       overwrite=True)

        # Authorized using headers
        tools.download("https://httpbin.org/basic-auth/user/passwd", dest,
                       headers={"Authorization": "Basic dXNlcjpwYXNzd2Q="}, overwrite=True)
Esempio n. 13
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")
Esempio n. 14
0
    def test_replace_in_file(self):
        file_content = '''
from conans import ConanFile
from conans.tools import download, unzip, replace_in_file
import os

class ConanFileToolsTest(ConanFile):
    name = "test"
    version = "1.9.10"
    settings = []

    def source(self):
        pass

    def build(self):
        replace_in_file("otherfile.txt", "ONE TWO THREE", "FOUR FIVE SIX")

'''
        tmp_dir = temp_folder()
        file_path = os.path.join(tmp_dir, "conanfile.py")
        other_file = os.path.join(tmp_dir, "otherfile.txt")
        save(file_path, file_content)
        save(other_file, "ONE TWO THREE")
        loader = ConanFileLoader(None, None, Settings(), OptionsValues.loads(""))
        ret = loader.load_conan(file_path)
        curdir = os.path.abspath(os.curdir)
        os.chdir(tmp_dir)
        try:
            ret.build()
        finally:
            os.chdir(curdir)

        content = load(other_file)
        self.assertEquals(content, "FOUR FIVE SIX")
Esempio n. 15
0
 def test_paths(self):
     """Unit test of path_exists"""
     tmp_dir = temp_folder()
     new_path = os.path.join(tmp_dir, "CapsDir")
     mkdir(new_path)
     self.assertTrue(path_exists(new_path, tmp_dir))
     self.assertFalse(path_exists(os.path.join(tmp_dir, "capsdir"), tmp_dir))
    def test_basic(self):
        """ check that we do not generate anymore tgz with .c_src.
        also, they are not present any more in the cache layout, even if they come from a .c_src
        tgz server file
        """
        test_server = TestServer()
        servers = {"default": test_server}
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        client.save({"conanfile.py": """from conans import ConanFile
class MyPkg(ConanFile):
    name= "Pkg"
    version = "0.1"
    exports_sources = "*.txt"
""", "myfile.txt": "Hello world"})
        client.run("export . lasote/testing")
        client.run("upload Pkg/0.1@lasote/testing")
        client.run("remove * -f")
        client.run("search")
        self.assertIn("There are no packages", client.user_io.out)
        conan_reference = ConanFileReference.loads("Pkg/0.1@lasote/testing")
        path = test_server.paths.export(conan_reference)
        sources_tgz = os.path.join(path, "conan_sources.tgz")
        self.assertTrue(os.path.exists(sources_tgz))
        folder = temp_folder()
        with open(sources_tgz, 'rb') as file_handler:
            tar_extract(file_handler, folder)
        self.assertEqual(os.listdir(folder), ["myfile.txt"])
        # Now install again
        client.run("install Pkg/0.1@lasote/testing --build=missing")
        export = client.client_cache.export(conan_reference)
        self.assertNotIn(EXPORT_SOURCES_DIR_OLD, os.listdir(export))
        export_sources = client.client_cache.export_sources(conan_reference)
        self.assertEqual(os.listdir(export_sources), ["myfile.txt"])
Esempio n. 17
0
    def test_values(self):
        config = ConanServerConfigParser(self.file_path, environment=self.environ)
        self.assertEquals(config.jwt_secret, "mysecret")
        self.assertEquals(config.jwt_expire_time, timedelta(minutes=121))
        self.assertEquals(config.disk_storage_path, self.storage_path)
        self.assertTrue(config.ssl_enabled)
        self.assertEquals(config.port, 9220)
        self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")])
        self.assertEquals(config.read_permissions, [("*/*@*/*", "*"),
                                                    ("openssl/2.0.1@lasote/testing", "pepe")])
        self.assertEquals(config.users, {"lasote": "defaultpass", "pepe": "pepepass"})

        # Now check with environments
        tmp_storage = temp_folder()
        self.environ["CONAN_STORAGE_PATH"] = tmp_storage
        self.environ["CONAN_JWT_SECRET"] = "newkey"
        self.environ["CONAN_JWT_EXPIRE_MINUTES"] = "123"
        self.environ["CONAN_SSL_ENABLED"] = "False"
        self.environ["CONAN_SERVER_PORT"] = "1233"
        self.environ["CONAN_SERVER_USERS"] = "lasote:lasotepass,pepe2:pepepass2"

        config = ConanServerConfigParser(self.file_path, environment=self.environ)
        self.assertEquals(config.jwt_secret,  "newkey")
        self.assertEquals(config.jwt_expire_time, timedelta(minutes=123))
        self.assertEquals(config.disk_storage_path, os.path.expanduser(tmp_storage))
        self.assertFalse(config.ssl_enabled)
        self.assertEquals(config.port, 1233)
        self.assertEquals(config.write_permissions, [("openssl/2.0.1@lasote/testing", "pepe")])
        self.assertEquals(config.read_permissions, [("*/*@*/*", "*"),
                                                    ("openssl/2.0.1@lasote/testing", "pepe")])
        self.assertEquals(config.users, {"lasote": "lasotepass", "pepe2": "pepepass2"})
Esempio n. 18
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': '52546396c42f16be3daf72ecf7ab7143',
                         'conanfile.py': '3ac566eb5b2e4df4417003f0e606e237',
                         'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 19
0
    def _upload_recipe(self, conan_reference, base_files=None, retry=1, retry_wait=0):

        files = hello_source_files(3, [1, 12])
        if base_files:
            files.update(base_files)
        content = """
from conans import ConanFile

class MyConan(ConanFile):
    name = "%s"
    version = "%s"
    settings = arch, compiler, os
""" % (conan_reference.name, conan_reference.version)
        files[CONANFILE] = content
        files_md5s = {filename: md5(content) for filename, content in files.items()}
        conan_digest = FileTreeManifest(123123123, files_md5s)
        files[CONAN_MANIFEST] = str(conan_digest)

        tmp_dir = temp_folder()
        abs_paths = {}
        for filename, content in files.items():
            abs_path = os.path.join(tmp_dir, filename)
            save(abs_path, content)
            abs_paths[filename] = abs_path

        self.api.upload_recipe(conan_reference, abs_paths, retry, retry_wait, False)
Esempio n. 20
0
 def setUp(self):
     folder = temp_folder()
     paths = SimplePaths(folder)
     search_adapter = DiskSearchAdapter()
     self.search_manager = DiskSearchManager(paths, search_adapter)
     os.chdir(paths.store)
     self.paths = paths
Esempio n. 21
0
 def _save_files(self, file_content):
     tmp_dir = temp_folder()
     file_path = os.path.join(tmp_dir, "conanfile.py")
     text_file = os.path.join(tmp_dir, "text.txt")
     save(file_path, file_content)
     save(text_file, "ONE TWO THREE")
     return tmp_dir, file_path, text_file
Esempio n. 22
0
    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"]))
Esempio n. 23
0
    def unzip_output_test(self):
        tmp_dir = temp_folder()
        file_path = os.path.join(tmp_dir, "example.txt")
        save(file_path, "Hello world!")

        zip_path = os.path.join(tmp_dir, 'example.zip')
        zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
        for root, _, files in os.walk(tmp_dir):
            for f in files:
                zipf.write(os.path.join(root, f), f)
        zipf.close()

        output_dir = os.path.join(tmp_dir, "output_dir")
        new_out = StringIO()
        old_out = sys.stdout
        try:
            sys.stdout = new_out
            tools.unzip(zip_path, output_dir)
        finally:
            sys.stdout = old_out

        output = new_out.getvalue()
        self.assertRegexpMatches(output, "Unzipping [\d]+ bytes, this can take a while")
        content = load(os.path.join(output_dir, "example.txt"))
        self.assertEqual(content, "Hello world!")
Esempio n. 24
0
 def env_vars_test_inheritance(self):
     tmp_dir = temp_folder()
     p1 = '''[env]\nVAR=1'''
     p2 = '''include(p1)\n[env]\nVAR=2'''
     save(os.path.join(tmp_dir, "p1"), p1)
     new_profile, _ = _load_profile(p2, tmp_dir, tmp_dir)
     self.assertEquals(new_profile.env_values.data[None]["VAR"], "2")
Esempio n. 25
0
    def setUp(self):
        self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
        self.package_reference = PackageReference(self.conan_reference, "123123123")
        self.tmp_dir = temp_folder()

        read_perms = [("*/*@*/*", "*")]
        write_perms = []
        authorizer = BasicAuthorizer(read_perms, write_perms)

        self.fake_url = "http://url"
        updown_auth_manager = JWTUpDownAuthManager("secret",
                                                   timedelta(seconds=200))
        adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
        self.paths = SimplePaths(self.tmp_dir)
        self.file_manager = FileManager(self.paths, adapter)

        search_adapter = DiskSearchAdapter()
        self.search_manager = DiskSearchManager(self.paths, search_adapter)

        self.service = ConanService(authorizer, self.file_manager, "lasote")
        self.search_service = SearchService(authorizer, self.search_manager, "lasote")

        files = hello_source_files("test")
        save_files(self.paths.export(self.conan_reference), files)
        self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference))
        conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST)
        save(conan_digest_path, str(self.conan_digest))

        files = hello_source_files("package")
        save_files(self.paths.package(self.package_reference), files)
Esempio n. 26
0
    def unzip_output_test(self):
        tmp_dir = temp_folder()
        file_path = os.path.join(tmp_dir, "example.txt")
        save(file_path, "Hello world!")

        zip_path = os.path.join(tmp_dir, 'example.zip')
        zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
        for root, _, files in os.walk(tmp_dir):
            for f in files:
                zipf.write(os.path.join(root, f), f)
        zipf.close()

        output_dir = os.path.join(tmp_dir, "output_dir")
        new_out = StringIO()
        old_out = sys.stdout
        try:
            import requests
            import conans

            conans.tools.set_global_instances(ConanOutput(new_out), requests)
            tools.unzip(zip_path, output_dir)
        finally:
            conans.tools.set_global_instances(ConanOutput(old_out), requests)

        output = new_out.getvalue()
        self.assertRegexpMatches(output, "Unzipping [\d]+B")
        content = load(os.path.join(output_dir, "example.txt"))
        self.assertEqual(content, "Hello world!")
Esempio n. 27
0
    def test_basic(self):
        current_folder = temp_folder()
        source_folder = os.path.join(current_folder, "source")
        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)
Esempio n. 28
0
    def short_paths_unzip_output_test(self):
        if platform.system() != "Windows":
            return
        tmp_dir = temp_folder()
        file_path = os.path.join(tmp_dir, "src/"*40, "example.txt")
        save(file_path, "Hello world!")

        zip_path = os.path.join(tmp_dir, 'example.zip')
        zipf = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
        for root, _, files in os.walk(tmp_dir):
            for f in files:
                zipf.write(os.path.join(root, f), os.path.join("src/"*20, f))
        zipf.close()

        output_dir = os.path.join(tmp_dir, "dst/"*40, "output_dir")
        new_out = StringIO()
        old_out = sys.stdout
        try:
            import conans
            conans.tools.set_global_instances(ConanOutput(new_out), None)
            tools.unzip(zip_path, output_dir)
        finally:
            conans.tools.set_global_instances(ConanOutput(old_out), None)

        output = new_out.getvalue()
        self.assertIn("ERROR: Error extract src/src", output)
Esempio n. 29
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': '52546396c42f16be3daf72ecf7ab7143',
                         'conanfile.py': '355949fbf0b4fc32b8f1c5a338dfe1ae',
                         'executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 30
0
    def test_tree_manifest(self):
        tmp_dir = temp_folder()
        files = {"one.ext": "aalakjshdlkjahsdlkjahsdljkhsadljkhasljkdhlkjashd",
                 "path/to/two.txt": "asdas13123",
                 "two.txt": "asdasdasdasdasdasd",
                 "folder/damn.pyc": "binarythings",
                 "folder/damn.pyo": "binarythings2",
                 "pythonfile.pyc": "binarythings3"}
        for filename, content in files.items():
            save(os.path.join(tmp_dir, filename), content)

        manifest = FileTreeManifest.create(tmp_dir)

        save(os.path.join(tmp_dir, "THEMANIFEST.txt"), str(manifest))

        readed_manifest = FileTreeManifest.loads(load(os.path.join(tmp_dir, "THEMANIFEST.txt")))

        self.assertEqual(readed_manifest.time, manifest.time)
        self.assertEqual(readed_manifest, manifest)
        # Not included the pycs or pyo
        self.assertEquals(set(manifest.file_sums.keys()),
                          set(["one.ext", "path/to/two.txt", "two.txt"]))

        for filepath, md5readed in manifest.file_sums.items():
            content = files[filepath]
            self.assertEquals(md5(content), md5readed)
Esempio n. 31
0
 def test_install_multiple_configs(self):
     folder = temp_folder()
     save_files(folder, {
         "subf/file.txt": "hello",
         "subf2/file2.txt": "bye"
     })
     self.client.run('config install "%s" -sf=subf' % folder)
     content = load(os.path.join(self.client.cache_folder, "file.txt"))
     file2 = os.path.join(self.client.cache_folder, "file2.txt")
     self.assertEqual(content, "hello")
     self.assertFalse(os.path.exists(file2))
     self.client.run('config install "%s" -sf=subf2' % folder)
     content = load(file2)
     self.assertEqual(content, "bye")
     save_files(folder, {
         "subf/file.txt": "HELLO!!",
         "subf2/file2.txt": "BYE!!"
     })
     self.client.run('config install')
     content = load(os.path.join(self.client.cache_folder, "file.txt"))
     self.assertEqual(content, "HELLO!!")
     content = load(file2)
     self.assertEqual(content, "BYE!!")
Esempio n. 32
0
    def profile_dir_test(self):
        tmp = temp_folder()
        txt = '''
[env]
PYTHONPATH=$PROFILE_DIR/my_python_tools
'''

        def assert_path(profile):
            pythonpath = profile.env_values.env_dicts("")[0]["PYTHONPATH"]
            self.assertEqual(
                pythonpath,
                os.path.join(tmp, "my_python_tools").replace('\\', '/'))

        abs_profile_path = os.path.join(tmp, "Myprofile.txt")
        save(abs_profile_path, txt)
        profile, _ = read_profile(abs_profile_path, None, None)
        assert_path(profile)

        profile, _ = read_profile("./Myprofile.txt", tmp, None)
        assert_path(profile)

        profile, _ = read_profile("Myprofile.txt", None, tmp)
        assert_path(profile)
Esempio n. 33
0
    def _upload_package(self, package_reference, base_files=None):

        files = {
            "conanfile.py":
            GenConanfile("3").with_requires("1", "12").with_exports("*"),
            "hello.cpp":
            "hello"
        }
        if base_files:
            files.update(base_files)

        tmp_dir = temp_folder()
        abs_paths = {}
        for filename, content in files.items():
            abs_path = os.path.join(tmp_dir, filename)
            save(abs_path, str(content))
            abs_paths[filename] = abs_path

        self.api.upload_package(package_reference,
                                abs_paths,
                                None,
                                retry=1,
                                retry_wait=0)
Esempio n. 34
0
    def test_dirty_download(self):
        # https://github.com/conan-io/conan/issues/8578
        client = TestClient(default_server_user=True)
        cache_folder = temp_folder()
        client.run('config set storage.download_cache="%s"' % cache_folder)
        client.save({
            "conanfile.py":
            GenConanfile().with_package_file("file.txt", "content")
        })
        client.run("create . pkg/0.1@")
        client.run("upload * --all -c")
        client.run("remove * -f")
        client.run("install pkg/0.1@")
        for f in os.listdir(cache_folder):
            # damage the file
            path = os.path.join(cache_folder, f)
            if os.path.isfile(path):
                save(path, "broken!")
                set_dirty(path)

        client.run("remove * -f")
        client.run("install pkg/0.1@")
        assert "pkg/0.1: Downloaded package" in client.out
Esempio n. 35
0
    def test_define_prefix(self):
        if platform.system() == "Windows":
            return
        tmp_dir = temp_folder()
        filename = os.path.join(tmp_dir, 'libastral.pc')
        with open(filename, 'w') as f:
            f.write(libastral_pc)
        with environment_append({'PKG_CONFIG_PATH': tmp_dir}):
            pkg_config = PkgConfig("libastral", variables={'prefix': '/home/conan'})

            self.assertEquals(frozenset(pkg_config.cflags),
                              frozenset(['-D_USE_LIBASTRAL', '-I/home/conan/include/libastral']))
            self.assertEquals(frozenset(pkg_config.cflags_only_I), frozenset(['-I/home/conan/include/libastral']))
            self.assertEquals(frozenset(pkg_config.cflags_only_other), frozenset(['-D_USE_LIBASTRAL']))

            self.assertEquals(frozenset(pkg_config.libs),
                              frozenset(['-L/home/conan/lib/libastral', '-lastral', '-Wl,--whole-archive']))
            self.assertEquals(frozenset(pkg_config.libs_only_L), frozenset(['-L/home/conan/lib/libastral']))
            self.assertEquals(frozenset(pkg_config.libs_only_l), frozenset(['-lastral', ]))
            self.assertEquals(frozenset(pkg_config.libs_only_other), frozenset(['-Wl,--whole-archive']))

            self.assertEquals(pkg_config.variables['prefix'], '/home/conan')
        os.unlink(filename)
Esempio n. 36
0
def test_env_files_sh(env, prevenv):
    display = textwrap.dedent("""\
        echo MyVar=$MyVar!!
        echo MyVar1=$MyVar1!!
        echo MyVar2=$MyVar2!!
        echo MyVar3=$MyVar3!!
        echo MyVar4=$MyVar4!!
        echo MyVar5=$MyVar5!!
        echo MyVar6=$MyVar6!!
        echo MyPath1=$MyPath1!!
        echo MyPath2=$MyPath2!!
        echo MyPath3=$MyPath3!!
        echo MyPath4=$MyPath4!!
        """)

    with chdir(temp_folder()):
        env = env.vars(ConanFileMock())
        env.save_sh("test.sh")
        save("display.sh", display)
        os.chmod("display.sh", 0o777)
        # We include the "set -e" to test it is robust against errors
        cmd = 'set -e && . ./test.sh && ./display.sh && . ./deactivate_test.sh && ./display.sh'
        check_env_files_output(cmd, prevenv)
Esempio n. 37
0
    def test_build_info_old_lockfile_version(self, mock_cache, user_home_mock):
        base_folder = temp_folder(True)
        cache_folder = os.path.join(base_folder, ".conan")
        client = TestClient(cache_folder=cache_folder)
        client.save({"conan.lock": '{"version": "0.2"}'})
        mock_cache.return_value = client.cache
        user_home_mock.return_value = cache_folder

        sys.argv = ["conan_build_info", "--v2", "start", "MyBuildName", "42"]
        run()
        sys.argv = ["conan_build_info", "--v2", "create",
                    os.path.join(client.current_folder, "buildinfo.json"), "--lockfile",
                    os.path.join(client.current_folder, "conan.lock")]

        old_stderr = sys.stderr
        try:
            result = StringIO()
            sys.stderr = result
            run()
            result = result.getvalue()
            self.assertIn("This lockfile was created with an incompatible version of Conan", result)
        finally:
            sys.stderr = old_stderr
Esempio n. 38
0
def test_env_files_ps1(env, prevenv):
    prevenv.update(dict(os.environ.copy()))

    display = textwrap.dedent("""\
        echo "MyVar=$env:MyVar!!"
        echo "MyVar1=$env:MyVar1!!"
        echo "MyVar2=$env:MyVar2!!"
        echo "MyVar3=$env:MyVar3!!"
        echo "MyVar4=$env:MyVar4!!"
        echo "MyVar5=$env:MyVar5!!"
        echo "MyVar6=$env:MyVar6!!"
        echo "MyPath1=$env:MyPath1!!"
        echo "MyPath2=$env:MyPath2!!"
        echo "MyPath3=$env:MyPath3!!"
        echo "MyPath4=$env:MyPath4!!"
    """)

    with chdir(temp_folder()):
        env = env.vars(ConanFileMock())
        env.save_ps1("test.ps1")
        save("display.ps1", display)
        cmd = "powershell.exe .\\test.ps1 ; .\\display.ps1 ; .\\deactivate_test.ps1 ; .\\display.ps1"
        check_env_files_output(cmd, prevenv)
Esempio n. 39
0
    def test_basic(self):
        folder = temp_folder()
        file_path = os.path.join(folder, "myfile.txt")
        self.cached_downloader.download("testurl", file_path)
        self.assertEqual(self.file_downloader.calls["testurl"], 1)
        self.assertEqual("testurl", load(file_path))

        # Try again, the count will be the same
        self.cached_downloader.download("testurl", file_path)
        self.assertEqual(self.file_downloader.calls["testurl"], 1)
        # Try direct content
        content = self.cached_downloader.download("testurl")
        self.assertEqual(content.decode("utf-8"), "testurl")
        self.assertEqual(self.file_downloader.calls["testurl"], 1)

        # Try another file
        file_path = os.path.join(folder, "myfile2.txt")
        self.cached_downloader.download("testurl2", file_path)
        self.assertEqual(self.file_downloader.calls["testurl2"], 1)
        self.assertEqual("testurl2", load(file_path))
        self.cached_downloader.download("testurl2", file_path)
        self.assertEqual(self.file_downloader.calls["testurl"], 1)
        self.assertEqual(self.file_downloader.calls["testurl2"], 1)
Esempio n. 40
0
    def test_deleted_source_folder(self):
        path, _ = create_local_git_repo({"myfile": "contents"},
                                        branch="my_release")
        curdir = self.client.current_folder.replace("\\", "/")
        conanfile = base_git.format(url=_quoted("auto"), revision="auto")
        self.client.save({
            "conanfile.py": conanfile,
            "myfile.txt": "My file is copied"
        })
        create_local_git_repo(folder=self.client.current_folder)
        self.client.run_command('git remote add origin "%s"' %
                                path.replace("\\", "/"))
        self.client.run("export . user/channel")

        new_curdir = temp_folder()
        self.client.current_folder = new_curdir
        # delete old source, so it will try to checkout the remote because of the missing local dir
        rmdir(curdir)
        self.client.run("install lib/0.1@user/channel --build",
                        assert_error=True)
        self.assertIn(
            "Getting sources from url: '%s'" % path.replace("\\", "/"),
            self.client.out)
Esempio n. 41
0
    def test_migration_editables_to_conanfile_name(self):
        # Create the old editable_packages.json file (and user workspace)
        tmp_folder = temp_folder()
        conanfile1 = os.path.join(tmp_folder, 'dir1', 'conanfile.py')
        conanfile2 = os.path.join(tmp_folder, 'dir2', 'conanfile.py')
        save(conanfile1, "anything")
        save(conanfile2, "anything")
        save(os.path.join(tmp_folder, EDITABLE_PACKAGES_FILE),
             json.dumps({"name/version": {"path": os.path.dirname(conanfile1), "layout": None},
                         "other/version@user/testing": {"path": os.path.dirname(conanfile2),
                                                        "layout": "anyfile"}}))

        cache = TestClient(cache_folder=tmp_folder).cache
        migrate_editables_use_conanfile_name(cache)

        # Now we have same info and full paths
        with open(os.path.join(tmp_folder, EDITABLE_PACKAGES_FILE)) as f:
            data = json.load(f)

        self.assertEqual(data["name/version"]["path"], conanfile1)
        self.assertEqual(data["name/version"]["layout"], None)
        self.assertEqual(data["other/version@user/testing"]["path"], conanfile2)
        self.assertEqual(data["other/version@user/testing"]["layout"], "anyfile")
Esempio n. 42
0
    def test_deleted_source_folder(self):
        path, _ = create_local_git_repo({"myfile": "contents"}, branch="my_release")
        conanfile = base_git.format(url=_quoted("auto"), revision="auto")
        self.client.save({"conanfile.py": conanfile, "myfile.txt": "My file is copied"})
        self.client.init_git_repo()
        self.client.run_command('git remote add origin "%s"' % path.replace("\\", "/"))
        self.client.run_command('git push origin master')
        self.client.run("export . user/channel")

        # delete old source, but it doesn't matter because the sources are in the cache
        rmdir(self.client.current_folder)
        new_curdir = temp_folder()
        self.client.current_folder = new_curdir

        self.client.run("install lib/0.1@user/channel --build")
        self.assertNotIn("Getting sources from url: '%s'" % path.replace("\\", "/"),
                         self.client.out)

        # If the remove the source folder, then it is fetched from the "remote" doing an install
        self.client.run("remove lib/0.1@user/channel -f -s")
        self.client.run("install lib/0.1@user/channel --build")
        self.assertIn("SCM: Getting sources from url: '%s'" % path.replace("\\", "/"),
                      self.client.out)
Esempio n. 43
0
 def paths_cmake_multi_user_vars_test(self):
     settings_mock = namedtuple("Settings",
                                "build_type, os, os_build, constraint")
     conanfile = ConanFile(TestBufferConanOutput(), None)
     conanfile.initialize(settings_mock("Release", None, None, lambda x: x),
                          EnvValues())
     ref = ConanFileReference.loads("MyPkg/0.1@lasote/stables")
     tmp_folder = temp_folder()
     save(os.path.join(tmp_folder, "lib", "mylib.lib"), "")
     save(os.path.join(tmp_folder, "include", "myheader.h"), "")
     cpp_info = CppInfo(tmp_folder)
     cpp_info.release.libs = ["hello"]
     cpp_info.debug.libs = ["hello_D"]
     conanfile.deps_cpp_info.update(cpp_info, ref.name)
     generator = CMakeMultiGenerator(conanfile)
     release = generator.content["conanbuildinfo_release.cmake"]
     release = release.replace(tmp_folder.replace("\\", "/"), "root_folder")
     cmake_lines = release.splitlines()
     self.assertIn(
         'set(CONAN_INCLUDE_DIRS_MYPKG_RELEASE "root_folder/include")',
         cmake_lines)
     self.assertIn('set(CONAN_LIB_DIRS_MYPKG_RELEASE "root_folder/lib")',
                   cmake_lines)
Esempio n. 44
0
    def local_package_build_test(self, default_folder):
        client = TestClient()
        conanfile_template = """
from conans import ConanFile

class MyConan(ConanFile):
    def package(self):
        self.copy(pattern="*.h", dst="include", src="include")
        self.copy(pattern="*.lib")
"""

        client.save({"include/file.h": "foo",
                     "build/lib/mypkg.lib": "mylib",
                     CONANFILE: conanfile_template})
        recipe_folder = client.current_folder
        client.current_folder = os.path.join(client.current_folder, "build")
        client.run("install ..")

        if default_folder:
            package_folder = os.path.join(client.current_folder, "package")
            client.run('package .. --build-folder=.')
            self.assertEqual(sorted(os.listdir(package_folder)),
                             sorted(["include", "lib", "conaninfo.txt", "conanmanifest.txt"]))
        else:
            package_folder = temp_folder()
            client.current_folder = package_folder
            build_folder = os.path.join(recipe_folder, "build")
            client.run('package "{0}" --build_folder="{2}"'
                       ' --package_folder="{1}"'.format(recipe_folder, package_folder, build_folder))
            self.assertEqual(sorted(os.listdir(package_folder)),
                             sorted(["include", "lib", "conaninfo.txt",
                                     "conanmanifest.txt"]))

        content = load(os.path.join(package_folder, "include/file.h"))
        self.assertEqual(content, "foo")
        self.assertEqual(os.listdir(os.path.join(package_folder, "include")), ["file.h"])
        self.assertEqual(os.listdir(os.path.join(package_folder, "lib")), ["mypkg.lib"])
Esempio n. 45
0
        def validate_additional_dependencies(libname, additional_dep):
            tempdir = temp_folder()
            with chdir(tempdir):
                conanfile = ConanFile(TestBufferConanOutput(), None)
                conanfile.initialize(Settings({}), EnvValues())

                ref = ConanFileReference.loads("MyPkg/0.1@user/testing")
                cpp_info = CppInfo(ref.name, "dummy_root_folder1")
                cpp_info.libs = [libname]
                conanfile.deps_cpp_info.add(ref.name, cpp_info)

                settings = Settings.loads(get_default_settings_yml())
                settings.os = "Windows"
                settings.arch = "x86_64"
                settings.build_type = "Release"
                settings.compiler = "Visual Studio"
                settings.compiler.version = "15"
                settings.compiler.runtime = "MD"
                settings.compiler.toolset = "v141"
                conanfile.settings = settings

                generator = VisualStudioMultiGenerator(conanfile)
                generator.output_path = ""
                content = generator.content

                self.assertIn('conanbuildinfo_release_x64_v141.props',
                              content.keys())

                content_release = content[
                    'conanbuildinfo_release_x64_v141.props']
                self.assertIn(
                    "<ConanLibraries>%s;</ConanLibraries>" % additional_dep,
                    content_release)
                self.assertIn(
                    "<AdditionalDependencies>"
                    "$(ConanLibraries)%(AdditionalDependencies)"
                    "</AdditionalDependencies>", content_release)
Esempio n. 46
0
def test_bazeldeps_get_lib_file_path_by_basename():
    conanfile = ConanFile(Mock(), None)

    cpp_info = CppInfo("mypkg", "dummy_root_folder1")
    cpp_info.defines = ["DUMMY_DEFINE=\"string/value\""]
    cpp_info.system_libs = ["system_lib1"]
    cpp_info.libs = ["liblib1.a"]

    conanfile_dep = ConanFile(Mock(), None)
    conanfile_dep.cpp_info = cpp_info
    conanfile_dep._conan_node = Mock()
    conanfile_dep._conan_node.ref = ConanFileReference.loads(
        "OriginalDepName/1.0")
    package_folder = temp_folder()
    save(os.path.join(package_folder, "lib", "liblib1.a"), "")
    conanfile_dep.folders.set_base_package(package_folder)

    # FIXME: This will run infinite loop if conanfile.dependencies.host.topological_sort.
    #  Move to integration test
    with mock.patch('conans.ConanFile.dependencies',
                    new_callable=mock.PropertyMock) as mock_deps:
        req = Requirement(ConanFileReference.loads("OriginalDepName/1.0"))
        mock_deps.return_value = ConanFileDependencies(
            {req: ConanFileInterface(conanfile_dep)})

        bazeldeps = BazelDeps(conanfile)

        for dependency in bazeldeps._conanfile.dependencies.host.values():
            dependency_content = bazeldeps._get_dependency_buildfile_content(
                dependency)
            assert 'cc_library(\n    name = "OriginalDepName",' in dependency_content
            assert """defines = ["DUMMY_DEFINE=\\\\\\"string/value\\\\\\""]""" in dependency_content
            if platform.system() == "Windows":
                assert 'linkopts = ["/DEFAULTLIB:system_lib1"]' in dependency_content
            else:
                assert 'linkopts = ["-lsystem_lib1"],' in dependency_content
            assert 'deps = [\n    \n    ":liblib1.a_precompiled",' in dependency_content
Esempio n. 47
0
def test_msbuild_and_intel_cc_props(mode, expected_toolset):
    test_folder = temp_folder()
    settings = Settings({
        "build_type": ["Release"],
        "compiler": {
            "intel-cc": {
                "version": ["2021.3"],
                "mode": [mode]
            },
            "msvc": {
                "version": ["193"],
                "cppstd": ["20"]
            }
        },
        "os": ["Windows"],
        "arch": ["x86_64"]
    })
    conanfile = ConanFile(Mock(), None)
    conanfile.folders.set_base_generators(test_folder)
    conanfile.folders.set_base_install(test_folder)
    conanfile.conf = Conf()
    conanfile.conf["tools.intel:installation_path"] = "my/intel/oneapi/path"
    conanfile.conf["tools.microsoft.msbuild:installation_path"] = "."
    conanfile.settings = "os", "compiler", "build_type", "arch"
    conanfile.initialize(settings, EnvValues())
    conanfile.settings.build_type = "Release"
    conanfile.settings.compiler = "intel-cc"
    conanfile.settings.compiler.version = "2021.3"
    conanfile.settings.compiler.mode = mode
    conanfile.settings.os = "Windows"
    conanfile.settings.arch = "x86_64"

    msbuild = MSBuildToolchain(conanfile)
    props_file = os.path.join(test_folder, 'conantoolchain_release_x64.props')
    msbuild.generate()
    assert '<PlatformToolset>%s</PlatformToolset>' % expected_toolset in load(
        props_file)
Esempio n. 48
0
    def test_pc(self):
        tmp_dir = temp_folder()
        filename = os.path.join(tmp_dir, 'libastral.pc')
        with open(filename, 'w') as f:
            f.write(libastral_pc)
        with environment_append({'PKG_CONFIG_PATH': tmp_dir}):
            pkg_config = PkgConfig("libastral")

            self.assertEqual(
                frozenset(pkg_config.cflags),
                frozenset(
                    ['-D_USE_LIBASTRAL', '-I/usr/local/include/libastral']))
            self.assertEqual(frozenset(pkg_config.cflags_only_I),
                             frozenset(['-I/usr/local/include/libastral']))
            self.assertEqual(frozenset(pkg_config.cflags_only_other),
                             frozenset(['-D_USE_LIBASTRAL']))

            self.assertEqual(
                frozenset(pkg_config.libs),
                frozenset([
                    '-L/usr/local/lib/libastral', '-lastral',
                    '-Wl,--whole-archive'
                ]))
            self.assertEqual(frozenset(pkg_config.libs_only_L),
                             frozenset(['-L/usr/local/lib/libastral']))
            self.assertEqual(frozenset(pkg_config.libs_only_l),
                             frozenset([
                                 '-lastral',
                             ]))
            self.assertEqual(frozenset(pkg_config.libs_only_other),
                             frozenset(['-Wl,--whole-archive']))

            self.assertEqual(pkg_config.variables['prefix'], '/usr/local')

            self.assertEqual(frozenset(pkg_config.version),
                             frozenset(['6.6.6']))
        os.unlink(filename)
Esempio n. 49
0
def create_local_svn_checkout(files,
                              repo_url,
                              rel_project_path=None,
                              commit_msg='default commit message',
                              delete_checkout=True,
                              folder=None):
    tmp_dir = folder or temp_folder()
    try:
        rel_project_path = rel_project_path or str(uuid.uuid4())
        # Do not use SVN class as it is what we will be testing
        subprocess.check_output('svn co "{url}" "{path}"'.format(url=repo_url,
                                                                 path=tmp_dir),
                                shell=True)
        tmp_project_dir = os.path.join(tmp_dir, rel_project_path)
        mkdir(tmp_project_dir)
        save_files(tmp_project_dir, files)
        with chdir(tmp_project_dir):
            subprocess.check_output("svn add .", shell=True)
            subprocess.check_output('svn commit -m "{}"'.format(commit_msg),
                                    shell=True)
            if SVN.get_version() >= SVN.API_CHANGE_VERSION:
                rev = subprocess.check_output("svn info --show-item revision",
                                              shell=True).decode().strip()
            else:
                import xml.etree.ElementTree as ET
                output = subprocess.check_output("svn info --xml",
                                                 shell=True).decode().strip()
                root = ET.fromstring(output)
                rev = root.findall("./entry")[0].get("revision")
        project_url = repo_url + "/" + quote(
            rel_project_path.replace("\\", "/"))
        return project_url, rev
    finally:
        if delete_checkout:
            shutil.rmtree(tmp_dir,
                          ignore_errors=False,
                          onerror=try_remove_readonly)
Esempio n. 50
0
    def test_basic(self):
        """ check that we do not generate anymore tgz with .c_src.
        also, they are not present any more in the cache layout, even if they come from a .c_src
        tgz server file
        """
        test_server = TestServer()
        servers = {"default": test_server}
        client = TestClient(servers=servers,
                            users={"default": [("lasote", "mypass")]})
        client.save({
            "conanfile.py": """from conans import ConanFile
class MyPkg(ConanFile):
    name= "Pkg"
    version = "0.1"
    exports_sources = "*.txt"
""",
            "myfile.txt": "Hello world"
        })
        client.run("export lasote/testing")
        client.run("upload Pkg/0.1@lasote/testing")
        client.run("remove * -f")
        client.run("search")
        self.assertIn("There are no packages", client.user_io.out)
        conan_reference = ConanFileReference.loads("Pkg/0.1@lasote/testing")
        path = test_server.paths.export(conan_reference)
        sources_tgz = os.path.join(path, "conan_sources.tgz")
        self.assertTrue(os.path.exists(sources_tgz))
        folder = temp_folder()
        with open(sources_tgz, 'rb') as file_handler:
            tar_extract(file_handler, folder)
        self.assertEqual(os.listdir(folder), ["myfile.txt"])
        # Now install again
        client.run("install Pkg/0.1@lasote/testing --build=missing")
        export = client.client_cache.export(conan_reference)
        self.assertNotIn(EXPORT_SOURCES_DIR_OLD, os.listdir(export))
        export_sources = client.client_cache.export_sources(conan_reference)
        self.assertEqual(os.listdir(export_sources), ["myfile.txt"])
Esempio n. 51
0
    def config_patch_deps_test(self):
        conan_file = ConanFileMock()
        conan_file.name = "MyPkg"
        conan_file.settings = Settings()
        conan_file.source_folder = os.path.join(self.tempdir, "src")
        conan_file.build_folder = os.path.join(self.tempdir, "build")
        conan_file.package_folder = os.path.join(self.tempdir, "pkg")
        conan_file.deps_cpp_info = DepsCppInfo()

        ref = ConanFileReference.loads("MyPkg1/0.1@user/channel")
        cpp_info = CppInfo(self.tempdir2)
        conan_file.deps_cpp_info.update(cpp_info, ref.name)
        self.tempdir = temp_folder(path_with_spaces=False)

        self.assertEqual(list(conan_file.deps_cpp_info.deps), ['MyPkg1'])
        self.assertEqual(conan_file.deps_cpp_info['MyPkg1'].rootpath,
                         self.tempdir2)

        msg = "FOLDER: " + self.tempdir2
        for folder in (conan_file.build_folder, conan_file.package_folder):
            save(os.path.join(folder, "file1.cmake"), "Nothing")
            save(os.path.join(folder, "file2"), msg)
            save(os.path.join(folder, "file3.txt"), msg)
            save(os.path.join(folder, "file3.cmake"), msg)
            save(os.path.join(folder, "sub", "file3.cmake"), msg)

        cmake = CMake(conan_file, generator="Unix Makefiles")
        cmake.patch_config_paths()
        for folder in (conan_file.build_folder, conan_file.package_folder):
            self.assertEqual("Nothing",
                             load(os.path.join(folder, "file1.cmake")))
            self.assertEqual(msg, load(os.path.join(folder, "file2")))
            self.assertEqual(msg, load(os.path.join(folder, "file3.txt")))
            self.assertEqual("FOLDER: ${CONAN_MYPKG1_ROOT}",
                             load(os.path.join(folder, "file3.cmake")))
            self.assertEqual("FOLDER: ${CONAN_MYPKG1_ROOT}",
                             load(os.path.join(folder, "sub", "file3.cmake")))
Esempio n. 52
0
    def setUp(self):
        self.server_folder = temp_folder()
        test_server = TestServer([("*/*@*/*", "*")],  # read permissions
                                 [],  # write permissions
                                 users={"fenix": "mypass"},
                                 base_path=self.server_folder)  # exported users and passwords
        self.server = test_server
        servers = {"default": test_server}
        client = TestClient(servers=servers, users={"default":[("fenix", "mypass")]})

        # Conans with and without packages created
        self.root_folder = {"H1": 'Hello/1.4.10/fenix/testing',
                            "H2": 'Hello/2.4.11/fenix/testing',
                            "B": 'Bye/0.14/fenix/testing',
                            "O": 'Other/1.2/fenix/testing'}

        files = {}
        for key, folder in self.root_folder.items():
            files["%s/%s/conanfile.py" % (folder, EXPORT_FOLDER)] = ""
            files["%s/%s/conanmanifest.txt" % (folder, EXPORT_FOLDER)] = ""
            files["%s/%s/conans.txt" % (folder, SRC_FOLDER)] = ""
            for pack_id in (1, 2):
                pack_id = "%s_%s" % (pack_id, key)
                files["%s/%s/%s/conans.txt" % (folder, BUILD_FOLDER, pack_id)] = ""
                files["%s/%s/%s/conans.txt" % (folder, PACKAGES_FOLDER, pack_id)] = ""

        client.save(files, client.paths.store)
        self.client = client

        for folder in self.root_folder.values():
            client.run("upload %s --all" % folder.replace("/fenix", "@fenix"))

        self.assert_folders({"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
                            {"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
                            {"H1": [1, 2], "H2": [1, 2], "B": [1, 2], "O": [1, 2]},
                            {"H1": True, "H2": True, "B": True, "O": True})
    def _create_and_load(myfunc, value, subdir_name, add_subdir_init):
        subdir_content = textwrap.dedent("""
            def get_value():
                return {value}
            def {myfunc}():
                return "{myfunc}"
        """)

        side_content = textwrap.dedent("""
            def get_side_value():
                return {value}
            def side_{myfunc}():
                return "{myfunc}"
        """)

        conanfile = textwrap.dedent("""
            import pickle
            from {subdir}.api import get_value, {myfunc}
            from file import get_side_value, side_{myfunc}
            from fractions import Fraction
            def conanfile_func():
                return get_value(), {myfunc}(), get_side_value(), side_{myfunc}(), str(Fraction(1,1))
        """)
        expected_return = (value, myfunc, value, myfunc, "1")

        tmp = temp_folder()
        with chdir(tmp):
            save("conanfile.py", conanfile.format(value=value, myfunc=myfunc, subdir=subdir_name))
            save("file.py", side_content.format(value=value, myfunc=myfunc))
            save("{}/api.py".format(subdir_name), subdir_content.format(value=value, myfunc=myfunc))
            if add_subdir_init:
                save("__init__.py", "")
                save("{}/__init__.py".format(subdir_name), "")

        loaded, module_id = _parse_conanfile(os.path.join(tmp, "conanfile.py"))
        return loaded, module_id, expected_return
Esempio n. 54
0
    def insert_test(self):
        tmp_folder = temp_folder()
        f = os.path.join(tmp_folder, "remotes.json")
        save(
            f, """
{
 "remotes": [
  {
   "url": "https://server.conan.io",
   "verify_ssl": true,
   "name": "conan.io"
  }
 ]
}
""")
        output = TestBufferConanOutput()
        cache = ClientCache(tmp_folder, output)
        registry = RemoteRegistry(cache, output)
        registry.add("repo1", "url1", True, insert=0)
        self.assertEqual(list(registry.load_remotes().values()), [
            Remote("repo1", "url1", True, False),
            Remote("conan.io", "https://server.conan.io", True, False)
        ])
        registry.add("repo2", "url2", True, insert=1)
        self.assertEqual(list(registry.load_remotes().values()), [
            Remote("repo1", "url1", True, False),
            Remote("repo2", "url2", True, False),
            Remote("conan.io", "https://server.conan.io", True, False)
        ])
        registry.add("repo3", "url3", True, insert=5)
        self.assertEqual(list(registry.load_remotes().values()), [
            Remote("repo1", "url1", True, False),
            Remote("repo2", "url2", True, False),
            Remote("conan.io", "https://server.conan.io", True, False),
            Remote("repo3", "url3", True, False)
        ])
Esempio n. 55
0
    def test_remote_none(self):
        """ RemoteRegistry should be able to deal when the URL is None
        """
        f = os.path.join(temp_folder(), "add_none_test")
        Remotes().save(f)
        cache = ClientCache(os.path.dirname(f), TestBufferConanOutput())
        registry = cache.registry

        registry.add("foobar", None)
        self.assertEqual(
            list(registry.load_remotes().values()),
            [("conan-center", "https://conan.bintray.com", True, False),
             ("foobar", None, True, False)])
        self.assertIn(
            "WARN: The URL is empty. It must contain scheme and hostname.",
            cache._output)
        registry.remove("foobar")

        registry.update("conan-center", None)
        self.assertEqual(list(registry.load_remotes().values()),
                         [("conan-center", None, True, False)])
        self.assertIn(
            "WARN: The URL is empty. It must contain scheme and hostname.",
            cache._output)
Esempio n. 56
0
    def test_concurrent_locks(self):
        folder = temp_folder()

        def download(index):
            if index % 2:
                content = self.cached_downloader.download("slow_testurl")
                content = content.decode("utf-8")
            else:
                file_path = os.path.join(folder, "myfile%s.txt" % index)
                self.cached_downloader.download("slow_testurl", file_path)
                content = load(file_path)
            self.assertEqual(content, "slow_testurl")
            self.assertEqual(self.file_downloader.calls["slow_testurl"], 1)

        ps = []
        for i in range(8):
            thread = Thread(target=download, args=(i, ))
            thread.start()
            ps.append(thread)

        for p in ps:
            p.join()

        self.assertEqual(self.file_downloader.calls["slow_testurl"], 1)
Esempio n. 57
0
    def test_rpaths_libs(self):
        if platform.system() == "Windows":
            return
        pc_content = """prefix=/my_prefix/path
libdir=/my_absoulte_path/fake/mylib/lib
libdir3=${prefix}/lib2
includedir=/my_absoulte_path/fake/mylib/include

Name: MyLib
Description: Conan package: MyLib
Version: 0.1
Libs: -L${libdir} -L${libdir3} -Wl,-rpath="${libdir}" -Wl,-rpath="${libdir3}"
Cflags: -I${includedir}"""
        tmp_dir = temp_folder()
        filename = os.path.join(tmp_dir, 'MyLib.pc')
        with open(filename, 'w') as f:
            f.write(pc_content)
        with environment_append({'PKG_CONFIG_PATH': tmp_dir}):
            expected = ("-L/my_absoulte_path/fake/mylib/lib "
                        "-L/my_prefix/path/lib2 "
                        "-Wl,-rpath=/my_absoulte_path/fake/mylib/lib "
                        "-Wl,-rpath=/my_prefix/path/lib2")
            pkg_config = PkgConfig("MyLib")
            self.assertIn(expected, " ".join(lib for lib in pkg_config.libs))
Esempio n. 58
0
    def test_conanfile_without_compiler_but_cppstd(self):
        conanfile = textwrap.dedent("""
            from conans import ConanFile

            class Lib(ConanFile):
                settings = "os", "arch", "cppstd"

                def configure(self):
                    self.output.info(">>> cppstd: {}".format(self.settings.cppstd))
        """)
        t = TestClient(base_folder=temp_folder())
        t.save({'conanfile.py': conanfile}, clean_first=True)

        with catch_deprecation_warning(self):
            # No mismatch, because settings for this conanfile does not include `compiler`
            t.run(
                "create . hh/0.1@user/channel"
                " -s cppstd=17"
                " -s hh:compiler=gcc"
                " -s hh:compiler.cppstd=14",
                assert_error=True)
        self.assertIn(
            "ERROR: Error in resulting settings for package 'hh': Do not use settings"
            " 'compiler.cppstd' together with 'cppstd'", t.out)
Esempio n. 59
0
def test_profile_load_dump():
    # Empty profile
    tmp = temp_folder()
    profile = Profile()
    dumps = profile.dumps()
    new_profile, _ = get_profile(tmp, dumps)
    assert new_profile.settings == profile.settings

    # Settings
    profile = Profile()
    profile.settings["arch"] = "x86_64"
    profile.settings["compiler"] = "Visual Studio"
    profile.settings["compiler.version"] = "12"

    profile.env_values.add("CXX", "path/to/my/compiler/g++")
    profile.env_values.add("CC", "path/to/my/compiler/gcc")

    profile.build_requires["*"] = ["android_toolchain/1.2.8@lasote/testing"]
    profile.build_requires["zlib/*"] = ["cmake/1.0.2@lasote/stable",
                                        "autotools/1.0.3@lasote/stable"]

    dump = profile.dumps()
    new_profile, _ = get_profile(tmp, dump)
    assert new_profile.settings == profile.settings
    assert new_profile.settings["arch"] == "x86_64"
    assert new_profile.settings["compiler.version"] == "12"
    assert new_profile.settings["compiler"] == "Visual Studio"

    assert new_profile.env_values.env_dicts("") == ({'CXX': 'path/to/my/compiler/g++',
                                                     'CC': 'path/to/my/compiler/gcc'}, {})

    assert new_profile.build_requires["zlib/*"] == \
           [ConanFileReference.loads("cmake/1.0.2@lasote/stable"),
            ConanFileReference.loads("autotools/1.0.3@lasote/stable")]
    assert new_profile.build_requires["*"] == \
           [ConanFileReference.loads("android_toolchain/1.2.8@lasote/testing")]
Esempio n. 60
0
    def test_combined(self):
        base_folder = temp_folder()
        source_folder = os.path.join(base_folder, "source")
        conanfile_folder = os.path.join(base_folder, "conan")
        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")
        conanfile = files.pop("conanfile.py")
        client.save(files, path=source_folder)
        conanfile = conanfile.replace("exports = '*'", 'exports = "../source*"')

        client.save({"conanfile.py": conanfile}, path=conanfile_folder)
        client.run("export lasote/stable --path=../conan")
        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': '40c9a26a156aecb0304fded35c1db93b',
                         'conanfile.py': '41c0a463c6f20084671502154f5b33f4',
                         'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)