Esempio n. 1
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)
Esempio n. 2
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))
Esempio n. 3
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)
Esempio n. 4
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())
Esempio n. 5
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)
Esempio n. 6
0
    def test_conanfile_not_found(self):
        """If package is OpenSSL is not openssl"""

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

        files = cpp_hello_conan_files("Hello0", "0.1")

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

        self.assertRaises(Exception, self.client.run, "install hello0/0.1@lasote/stable")
        self.client.run("install Hello0/0.1@lasote/stable --build missing")
        self.client.run("upload Hello0/0.1@lasote/stable")

        # Now with requirements.txt (bug in server)
        self.client = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]})
        self.client.save({"conanfile.txt": "[requires]\nHello0/0.1@lasote/stable\n[generators]\ntxt"})
        self.client.run("install --build missing ")
        build_info = load(os.path.join(self.client.current_folder, "conanbuildinfo.txt"))
        self.assertIn("helloHello0", build_info)

        self.client = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]})
        self.client.save({"conanfile.txt": "[requires]\nhello0/0.1@lasote/stable\n[generators]\ntxt"})
        self.assertRaises(Exception, self.client.run, "install")
Esempio n. 7
0
    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!")
Esempio n. 8
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)
Esempio n. 9
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))
Esempio n. 10
0
 def test_command_user(self):
     """ Test that the user can be shown and changed, and it is reflected in the
     user cache localdb
     """
     client = TestClient()
     client.run('user', ignore_error=True)
     self.assertIn("ERROR: No default remote defined", client.user_io.out)
Esempio n. 11
0
    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)
Esempio n. 12
0
 def list_test(self):
     client = TestClient()
     create_profile(client.client_cache.profiles_path, "profile1")
     create_profile(client.client_cache.profiles_path, "profile2")
     create_profile(client.client_cache.profiles_path, "profile3")
     client.run("profile list")
     self.assertEqual(set(["profile1", "profile2", "profile3"]),
                      set(str(client.user_io.out).splitlines()))
Esempio n. 13
0
class InfoTest(unittest.TestCase):

    def _create(self, number, version, deps=None, export=True):
        files = cpp_hello_conan_files(number, version, deps)
        # To avoid building
        files = {CONANFILE: files[CONANFILE].replace("build(", "build2(")}

        self.client.save(files, clean_first=True)
        if export:
            self.client.run("export lasote/stable")
            expected_output = textwrap.dedent(
                """\
                WARN: Conanfile doesn't have 'url'.
                It is recommended to add your repo URL as attribute
                WARN: Conanfile doesn't have a 'license'.
                It is recommended to add the package license as attribute""")
            self.assertIn(expected_output, self.client.user_io.out)

        files[CONANFILE] = files[CONANFILE].replace('version = "0.1"',
                                                    'version = "0.1"\n'
                                                    '    url= "myurl"\n'
                                                    '    license = "MIT"')
        self.client.save(files)
        if export:
            self.client.run("export lasote/stable")
            self.assertNotIn("WARN: Conanfile doesn't have 'url'", self.client.user_io.out)

    def reuse_test(self):
        self.client = TestClient()
        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)

        self.client.run("info")
        expected_output = textwrap.dedent(
            """\
            Hello2/0.1@PROJECT
                URL: myurl
                License: MIT
                Requires:
                    Hello1/0.1@lasote/stable
            Hello0/0.1@lasote/stable
                Remote: None
                URL: myurl
                License: MIT
                Updates: You have the latest version (None)
                Required by:
                    Hello1/0.1@lasote/stable
            Hello1/0.1@lasote/stable
                Remote: None
                URL: myurl
                License: MIT
                Updates: You have the latest version (None)
                Required by:
                    Hello2/0.1@PROJECT
                Requires:
                    Hello0/0.1@lasote/stable""")
        self.assertIn(expected_output, self.client.user_io.out)
Esempio n. 14
0
    def local_source_test(self):
        conanfile = """
from conans import ConanFile
from conans.util.files import save

class ConanLib(ConanFile):

    def source(self):
        self.output.info("Running source!")
        err
        save("file1.txt", "Hello World")
"""
        # First, failing source()
        client = TestClient()
        client.save({CONANFILE: conanfile})

        client.run("source .", ignore_error=True)
        self.assertIn("PROJECT: Running source!", client.user_io.out)
        self.assertIn("ERROR: PROJECT: Error in source() method, line 9", client.user_io.out)

        # Fix the error and repeat
        client.save({CONANFILE: conanfile.replace("err", "")})
        client.run("source .")
        self.assertIn("PROJECT: Configuring sources in", client.user_io.out)
        self.assertIn("PROJECT: WARN: Your previous source command failed", client.user_io.out)
        self.assertIn("PROJECT: Running source!", client.user_io.out)
        self.assertEqual("Hello World", load(os.path.join(client.current_folder, "file1.txt")))
Esempio n. 15
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)
Esempio n. 16
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())
Esempio n. 17
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")
Esempio n. 18
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
Esempio n. 19
0
    def check_versions_test(self):
        # Client deprecated
        self.servers = {"default": self._get_server(10, 5)}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]}, client_version=4)

        errors = self.client.run("search something -r default", 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)  # Not Errors

        # Client outdated
        self.servers = {"default": self._get_server(10, 4)}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]}, client_version=4)

        errors = self.client.run("search something -r default", ignore_error=False)
        self.assertIn(" A new conan version (v10) is available in current remote. Please, "
                      "upgrade conan client to avoid deprecation.", self.client.user_io.out)
        self.assertFalse(errors)  # Not Errors

        # Client ok
        self.servers = {"default": self._get_server(10, 4)}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]}, client_version=10)

        errors = self.client.run("search something -r default", ignore_error=False)
        self.assertNotIn("conan client", self.client.user_io.out)
        self.assertFalse(errors)  # Not Errors

        # Server outdated
        self.servers = {"default": self._get_server(1, 1)}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]}, client_version=10,
                                 min_server_compatible_version=1)

        errors = self.client.run("search something -r default", ignore_error=True)
        self.assertNotIn("The conan remote version is outdated (v1). Please, contact"
                         " with your system administrator and upgrade the remote to"
                         " avoid deprecation", self.client.user_io.out)
        self.assertFalse(errors)  # No Errors

        # Server deprecated
        self.servers = {"default": self._get_server(1, 1)}
        self.client = TestClient(servers=self.servers,
                                 users={"default": [("lasote", "mypass")]}, client_version=10,
                                 min_server_compatible_version=2)

        errors = self.client.run("search something -r default", ignore_error=True)
        self.assertIn("Your conan's client is incompatible with this remote."
                      " The server is deprecated. "
                      "(v1). Please, contact with your system administrator and"
                      " upgrade the server.",
                      self.client.user_io.out)
        self.assertTrue(errors)  # Errors
Esempio n. 20
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")))
Esempio n. 21
0
 def new_without_test(self):
     """ Test that the user can be shown and changed, and it is reflected in the
     user cache localdb
     """
     client = TestClient()
     client.run('new MyPackage/1.3@myuser/testing')
     root = client.current_folder
     self.assertTrue(os.path.exists(os.path.join(root, "conanfile.py")))
     self.assertFalse(os.path.exists(os.path.join(root, "test_package/conanfile.py")))
     self.assertFalse(os.path.exists(os.path.join(root, "test_package/CMakeLists.txt")))
     self.assertFalse(os.path.exists(os.path.join(root, "test_package/example.cpp")))
Esempio n. 22
0
    def duplicate_requires_test(self):
        client = TestClient()
        conanfile = '''
[requires]
foo/0.1@user/testing
foo/0.2@user/testing
'''
        files = {"conanfile.txt": conanfile}
        client.save(files)
        error = client.run("install . --build", ignore_error=True)
        self.assertTrue(error)
        self.assertIn("ERROR: Duplicated requirement", client.user_io.out)
Esempio n. 23
0
 def _export_upload(self, name, version=None, deps=None):
     conan = TestClient(servers=self.servers, users=[("lasote", "mypass")])
     files = cpp_hello_conan_files(name, version, deps, static=self.static)
     conan_ref = ConanFileReference(name, version, "lasote", "stable")
     conan.save(files, clean_first=True)
     conan.run("export lasote/stable")
     conan.run("install '%s' -o static=False -o language=0 --build missing" % str(conan_ref))
     conan.run("upload %s --all" % str(conan_ref))
     rmdir(conan.current_folder)
     shutil.rmtree(conan.paths.store, ignore_errors=True)
Esempio n. 24
0
    def copy_error_test(self):
        client = TestClient()
        conanfile = '''
from conans import ConanFile

class HelloConan(ConanFile):
    name = "Hello"
    version = "0.1"
    exports = "*"
    def package(self):
        self.copy2("*.h", dst="include", src=["include","platform"])
'''
        files = {"conanfile.py": conanfile, "test.txt": "Hello world"}
        client.save(files)
        client.run("export lasote/stable")
        client.run("install Hello/0.1@lasote/stable --build",
                   ignore_error=True)
        self.assertIn(
            "Hello/0.1@lasote/stable: Error in package() method, line 9",
            client.user_io.out)
        self.assertIn(
            'self.copy2("*.h", dst="include", src=["include","platform"]',
            client.user_io.out)
        self.assertIn("'HelloConan' object has no attribute 'copy2'",
                      client.user_io.out)
Esempio n. 25
0
    def test_complex_deps_propagation_override(self):
        client = TestClient()
        # Try injecting some package level ENV in the install, but without priority
        self._export(client, "A", [], {}, {
            "VAR1": "900",
            "VAR2": "23",
            "VAR3": "-23"
        })
        self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
        self._export(client, "C", ["B"], {"VAR3": "bestvalue"},
                     {"VAR1": "700"})

        client.save({"conanfile.py": reuse})
        client.run("install . --build missing -e LIB_B:VAR3=override")
        self.assertIn("Building LIB_A, VAR1:None", client.user_io.out)
        self.assertIn("Building LIB_A, VAR2:None", client.user_io.out)
        self.assertIn("Building LIB_A, VAR3:None", client.user_io.out)

        self.assertIn("Building LIB_B, VAR1:900", client.user_io.out)
        self.assertIn("Building LIB_B, VAR2:23", client.user_io.out)
        self.assertIn("Building LIB_B, VAR3:override", client.user_io.out)

        self.assertIn("Building LIB_C, VAR1:800", client.user_io.out)
        self.assertIn("Building LIB_C, VAR2:24", client.user_io.out)
        self.assertIn("Building LIB_C, VAR3:-23", client.user_io.out)

        client.run("build")
        self.assertInSep("VAR1=>700:800:900", client.user_io.out)
        self.assertInSep("VAR2=>24:23*", client.user_io.out)
        self.assertInSep("VAR3=>bestvalue*", client.user_io.out)
Esempio n. 26
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
Esempio n. 27
0
    def local_system_requirements_test(self):
        client = TestClient()
        files = {'conanfile.py': base_conanfile.replace("%GLOBAL%", "")}
        client.save(files)
        client.run("install .")
        self.assertIn("*+Running system requirements+*", client.user_io.out)

        files = {
            'conanfile.py':
            base_conanfile.replace("%GLOBAL%", "self.run('fake command!')")
        }
        client.save(files)
        with self.assertRaisesRegexp(Exception, "Command failed"):
            client.run("install .")
Esempio n. 28
0
 def new_without_test(self):
     """ Test that the user can be shown and changed, and it is reflected in the
     user cache localdb
     """
     client = TestClient()
     client.run('new MyPackage/1.3@myuser/testing')
     root = client.current_folder
     self.assertTrue(os.path.exists(os.path.join(root, "conanfile.py")))
     self.assertFalse(
         os.path.exists(os.path.join(root, "test_package/conanfile.py")))
     self.assertFalse(
         os.path.exists(os.path.join(root, "test_package/CMakeLists.txt")))
     self.assertFalse(
         os.path.exists(os.path.join(root, "test_package/example.cpp")))
Esempio n. 29
0
    def setUp(self):
        test_server = TestServer()
        self.servers = {"default": test_server}
        self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
        self.new_client = TestClient(servers=self.servers,
                                     users={"default": [("lasote", "mypass")]})

        self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        self.client.save(files)
        self.client.run("export lasote/stable")

        self.client.run("install Hello0/0.1@lasote/stable --build missing")
        self.client.run("upload  Hello0/0.1@lasote/stable --all")
Esempio n. 30
0
    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")
        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)

        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))
Esempio n. 31
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)
    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)
Esempio n. 33
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.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)
Esempio n. 34
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': 'c90fe9d800e1f48c8ea0999e8e5929d8',
                         'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
                         'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'}
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 35
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)
Esempio n. 36
0
    def test_override_simple2(self):
        client = TestClient()
        # Try injecting some package level ENV in the install
        self._export(client, "A", [], {"VAR3": "-23"}, {
            "VAR1": "900",
            "VAR2": "23"
        })
        self._export(client, "B", ["A"], {}, {"VAR1": "800", "VAR2": "24"})
        self._export(client, "C", ["B"], {}, {"VAR1": "700"})

        client.save({"conanfile.py": reuse})
        client.run("install . --build missing -e VAR3=override")
        self.assertIn("Building LIB_A, VAR1:None", client.user_io.out)
        self.assertIn("Building LIB_A, VAR2:None", client.user_io.out)
        self.assertIn("Building LIB_A, VAR3:override", client.user_io.out)

        self.assertIn("Building LIB_B, VAR1:900", client.user_io.out)
        self.assertIn("Building LIB_B, VAR2:23", client.user_io.out)
        self.assertIn("Building LIB_B, VAR3:override", client.user_io.out)

        self.assertIn("Building LIB_C, VAR1:800", client.user_io.out)
        self.assertIn("Building LIB_C, VAR2:24", client.user_io.out)
        self.assertIn("Building LIB_C, VAR3:override", client.user_io.out)

        client.run("build")
        self.assertInSep("VAR1=>700:800:900", client.user_io.out)
        self.assertInSep("VAR2=>24:23*", client.user_io.out)
        self.assertInSep("VAR3=>override*", client.user_io.out)
Esempio n. 37
0
    def test_error_patch(self):
        file_content = base_conanfile + '''
    def build(self):
        patch_content = "some corrupted patch"
        patch(patch_string=patch_content, output=self.output)

'''
        client = TestClient()
        client.save({"conanfile.py": file_content})
        error = client.run("build", ignore_error=True)
        self.assertTrue(error)
        self.assertIn("patch: error: no patch data found!", client.user_io.out)
        self.assertIn("ERROR: Failed to parse patch: string",
                      client.user_io.out)
Esempio n. 38
0
    def basic_test(self):
        client = TestClient()
        base = '''
from conans import ConanFile
from conans.util.files import load, save
import os

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

    def source(self):
        extra_path = "1/" * 108
        os.makedirs(extra_path)
        myfile = os.path.join(extra_path, "myfile.txt")
        # print("File length ", len(myfile))
        save(myfile, "Hello extra path length")

    def build(self):
        extra_path = "1/" * 108
        myfile = os.path.join(extra_path, "myfile2.txt")
        # print("File length ", len(myfile))
        save(myfile, "Hello2 extra path length")

    def package(self):
        self.copy("*.txt", keep_path=False)
'''

        files = {"conanfile.py": base}
        client.save(files)
        client.run("export user/channel")
        client.run("install lib/0.1@user/channel --build")
        package_ref = PackageReference.loads("lib/0.1@user/channel:"
                                             "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
        package_folder = client.client_cache.package(package_ref)
        file1 = load(os.path.join(package_folder, "myfile.txt"))
        self.assertEqual("Hello extra path length", file1)
        file2 = load(os.path.join(package_folder, "myfile2.txt"))
        self.assertEqual("Hello2 extra path length", file2)

        if platform.system() == "Windows":
            conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
            source_folder = client.client_cache.source(conan_ref)
            link_source = load(os.path.join(source_folder, ".conan_link"))
            self.assertTrue(os.path.exists(link_source))

            build_folder = client.client_cache.build(package_ref)
            link_build = load(os.path.join(build_folder, ".conan_link"))
            self.assertTrue(os.path.exists(link_build))

            client.run("remove lib* -f")
            self.assertFalse(os.path.exists(link_source))
            self.assertFalse(os.path.exists(link_build))
    def diamond_build_order_test(self):
        self.client = TestClient()
        self._create("LibA", "0.1")
        self._create("Dev1", "0.1")
        self._create("LibE", "0.1", deps_dev=["Dev1/0.1@lasote/stable"])
        self._create("LibF", "0.1")
        self._create("LibG", "0.1")
        self._create("Dev2", "0.1", deps=["LibG/0.1@lasote/stable"])

        self._create("LibB", "0.1", ["LibA/0.1@lasote/stable", "LibE/0.1@lasote/stable"])
        self._create("LibC", "0.1", ["LibA/0.1@lasote/stable", "LibF/0.1@lasote/stable"],
                     deps_dev=["Dev2/0.1@lasote/stable"])

        self._create("LibD", "0.1", ["LibB/0.1@lasote/stable", "LibC/0.1@lasote/stable"],
                     export=False)

        self.client.run("info -bo=LibA/0.1@lasote/stable")
        self.assertIn("[LibA/0.1@lasote/stable], "
                      "[LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]",
                      self.client.user_io.out)
        self.client.run("info -bo=LibB/0.1@lasote/stable")
        self.assertIn("[LibB/0.1@lasote/stable]", self.client.user_io.out)
        self.client.run("info -bo=LibE/0.1@lasote/stable")
        self.assertIn("[LibE/0.1@lasote/stable], [LibB/0.1@lasote/stable]",
                      self.client.user_io.out)
        self.client.run("info -bo=LibF/0.1@lasote/stable")
        self.assertIn("[LibF/0.1@lasote/stable], [LibC/0.1@lasote/stable]",
                      self.client.user_io.out)
        self.client.run("info -bo=Dev1/0.1@lasote/stable")
        self.assertEqual("\n", self.client.user_io.out)
        self.client.run("info --scope=LibE:dev=True -bo=Dev1/0.1@lasote/stable")
        self.assertIn("[Dev1/0.1@lasote/stable], [LibE/0.1@lasote/stable], "
                      "[LibB/0.1@lasote/stable]", self.client.user_io.out)
        self.client.run("info -bo=LibG/0.1@lasote/stable")
        self.assertEqual("\n", self.client.user_io.out)
        self.client.run("info --scope=LibC:dev=True -bo=LibG/0.1@lasote/stable")
        self.assertIn("[LibG/0.1@lasote/stable], [Dev2/0.1@lasote/stable], "
                      "[LibC/0.1@lasote/stable]", self.client.user_io.out)

        self.client.run("info --build_order=ALL")
        self.assertIn("[LibA/0.1@lasote/stable, LibE/0.1@lasote/stable, LibF/0.1@lasote/stable], "
                      "[LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]",
                      self.client.user_io.out)

        self.client.run("info --build_order=ALL --scope=ALL:dev=True")
        self.assertIn("[Dev1/0.1@lasote/stable, LibG/0.1@lasote/stable], "
                      "[Dev2/0.1@lasote/stable, LibA/0.1@lasote/stable, LibE/0.1@lasote/stable, "
                      "LibF/0.1@lasote/stable], [LibB/0.1@lasote/stable, LibC/0.1@lasote/stable]",
                      self.client.user_io.out)
Esempio n. 40
0
    def failure_test(self):

        base = '''
from conans import ConanFile
from conans.util.files import load, save
import os

class ConanLib(ConanFile):
    name = "lib"
    version = "0.1"
    short_paths = True
    exports = "*"
    generators = "cmake"

    def build(self):
        self.output.info("%s/%s" % (self.conanfile_directory, self.name))
        # print os.listdir(self.conanfile_directory)
        path = os.path.join(self.conanfile_directory, self.name)
        # print "PATH EXISTS ", os.path.exists(path)
        # print os.listdir(path)
        path = os.path.join(path, "myfile.txt")
        # print "PATH EXISTS ", os.path.exists(path)

    def package(self):
        self.copy("*.txt", keep_path=False)
'''

        client = TestClient()
        files = {"conanfile.py": base, "lib/myfile.txt": "Hello world!"}
        client.save(files)
        client.run("export user/channel")
        client.run("install lib/0.1@user/channel --build")
        # print client.paths.store
        package_ref = PackageReference.loads(
            "lib/0.1@user/channel:"
            "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
        package_folder = client.client_cache.package(package_ref,
                                                     short_paths=None)
        file1 = load(os.path.join(package_folder, "myfile.txt"))
        self.assertEqual("Hello world!", file1)

        client.run("install lib/0.1@user/channel --build")
        package_ref = PackageReference.loads(
            "lib/0.1@user/channel:"
            "5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
        package_folder = client.client_cache.package(package_ref,
                                                     short_paths=None)
        file1 = load(os.path.join(package_folder, "myfile.txt"))
        self.assertEqual("Hello world!", file1)
Esempio n. 41
0
 def shared_folder_test(self):
     hello_files = cpp_hello_conan_files("Hello")
     client = TestClient()
     client.save(hello_files)
     client.run("export lasote/stable")
     path = os.path.join(client.storage_folder, "Hello/0.1/lasote/stable")
     self.assertTrue(os.path.exists(path))
     client.run("export lasote2/stable")
     path = os.path.join(client.storage_folder, "Hello/0.1/lasote2/stable")
     self.assertTrue(os.path.exists(path))
     client.run("remove Hello/0.1@lasote/stable -f")
     path = os.path.join(client.storage_folder, "Hello/0.1/lasote")
     self.assertFalse(os.path.exists(path))
     path = os.path.join(client.storage_folder, "Hello/0.1")
     self.assertTrue(os.path.exists(path))
Esempio n. 42
0
    def test_copy_command(self):
        client = TestClient(users=[("lasote", "mypass")])
        self._export_some_packages(client)
        # Copy all packages
        new_reference = ConanFileReference.loads("Hello0/0.1@pepe/testing")
        client.run("copy Hello0/0.1@lasote/stable pepe/testing --all --force")
        p1 = client.paths.packages(new_reference)
        packages = os.listdir(p1)
        self.assertEquals(len(packages), 3)

        # Copy just one
        rmdir(p1)
        client.run("copy Hello0/0.1@lasote/stable pepe/testing -p %s --force" % packages[0])
        packages = os.listdir(p1)
        self.assertEquals(len(packages), 1)
Esempio n. 43
0
    def uploaded_chain_test(self):
        self._export_upload("Hello0", "0.1")
        self._export_upload("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])

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

        client.run("install . --build missing")
        client.run("build .")
        command = os.sep.join([".", "bin", "say_hello"])

        client.runner(command, cwd=client.current_folder)
        self.assertEqual(['Hello Hello2', 'Hello Hello1', 'Hello Hello0'],
                         str(client.user_io.out).splitlines()[-3:])
Esempio n. 44
0
    def setUp(self):
        self.client = TestClient()

        # 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
        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'

        self.client.save(
            {
                "Empty/1.10/fake/test/reg/fake.txt":
                "//",
                "%s/%s/WindowsPackageSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1,
                "%s/%s/PlatformIndependantSHA/%s" % (root_folder1, PACKAGES_FOLDER, CONANINFO):
                conan_vars1b,
                "%s/%s/LinuxPackageSHA/%s" % (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(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)
Esempio n. 45
0
    def _export_upload(self, name, version=None, deps=None):
        conan = TestClient(servers=self.servers, users={"default":[("lasote", "mypass")]})
        dll_export = conan.default_compiler_visual_studio
        files = cpp_hello_conan_files(name, version, deps, static=False, dll_export=dll_export)
        conan_ref = ConanFileReference(name, version, "lasote", "stable")
        conan.save(files, clean_first=True)

        conan.run("export lasote/stable")
        conan.run("install '%s' --build missing" % str(conan_ref))
        conan.run("upload %s --all" % str(conan_ref))
        rmdir(conan.current_folder)
        shutil.rmtree(conan.paths.store, ignore_errors=True)
Esempio n. 46
0
class BasicBuildTest(unittest.TestCase):

    def setUp(self):
        self.client = TestClient()
        self.command = os.sep.join([".", "bin", "say_hello"])

    def _build(self, cmd, static, pure_c, use_cmake, lang):
        dll_export = self.client.default_compiler_visual_studio and not static
        files = cpp_hello_conan_files("Hello0", "0.1", dll_export=dll_export,
                                      pure_c=pure_c, use_cmake=use_cmake)
        self.client.save(files, clean_first=True)
        self.client.run(cmd)
        time.sleep(1)  # necessary so the conaninfo.txt is flushed to disc
        self.client.run('build')
        ld_path = ("LD_LIBRARY_PATH=$(pwd)"
                   if not static and not platform.system() == "Windows" else "")
        self.client.runner("%s %s" % (ld_path, self.command), cwd=self.client.current_folder)
        msg = "Hello" if lang == 0 else "Hola"
        self.assertIn("%s Hello0" % msg, self.client.user_io.out)
        conan_info_path = os.path.join(self.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)

    def build_cmake_test(self):
        for pure_c in (False, True):
            for cmd, 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)]:
                self._build(cmd, static, pure_c, use_cmake=True, lang=lang)

    def build_default_test(self):
        "build default (gcc in nix, VS in win)"
        for pure_c in (False, True):
            for cmd, 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)]:
                self._build(cmd, static, pure_c, use_cmake=False, lang=lang)

    def build_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"
        for pure_c in (False, True):
            for cmd, 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)]:
                self._build(cmd, static, pure_c, use_cmake=False, lang=lang)
Esempio n. 47
0
    def reuse_test(self):
        self.client = TestClient()
        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)

        self.client.run("info")
        expected_output = textwrap.dedent(
            """\
            Hello2/0.1@PROJECT
                URL: myurl
                License: MIT
                Requires:
                    Hello1/0.1@lasote/stable
            Hello0/0.1@lasote/stable
                Remote: None
                URL: myurl
                License: MIT
                Updates: You have the latest version (None)
                Required by:
                    Hello1/0.1@lasote/stable
            Hello1/0.1@lasote/stable
                Remote: None
                URL: myurl
                License: MIT
                Updates: You have the latest version (None)
                Required by:
                    Hello2/0.1@PROJECT
                Requires:
                    Hello0/0.1@lasote/stable""")
        self.assertIn(expected_output, self.client.user_io.out)
Esempio n. 48
0
    def _export_upload(self, name, version=None, deps=None):
        conan = TestClient(servers=self.servers, users=[("lasote", "mypass")])
        dll_export = conan.default_compiler_visual_studio
        files = cpp_hello_conan_files(name,
                                      version,
                                      deps,
                                      static=False,
                                      dll_export=dll_export)
        conan_ref = ConanFileReference(name, version, "lasote", "stable")
        conan.save(files, clean_first=True)

        conan.run("export lasote/stable")
        conan.run("install '%s' --build missing" % str(conan_ref))
        conan.run("upload %s --all" % str(conan_ref))
        rmdir(conan.current_folder)
        shutil.rmtree(conan.paths.store, ignore_errors=True)
Esempio n. 49
0
    def duplicate_requires_py_test(self):
        client = TestClient()
        conanfile = '''
from conans import ConanFile

class HelloConan(ConanFile):
    name = "Hello"
    version = "0.1"
    requires = "foo/0.1@user/testing", "foo/0.2@user/testing"
'''
        files = {"conanfile.py": conanfile}
        client.save(files)
        error = client.run("install . --build", ignore_error=True)
        self.assertTrue(error)
        self.assertIn("Error while initializing requirements. Duplicated requirement",
                      client.user_io.out)
Esempio n. 50
0
 def _install_and_build(self, conanfile_text, runner=None):
     client = TestClient(runner=runner)
     files = {"conanfile.py": conanfile_text}
     test_folder = os.path.join(client.current_folder, "test_folder")
     self.assertFalse(os.path.exists(test_folder))
     client.save(files)
     client.run("install")
     client.run("build")
     return client
Esempio n. 51
0
 def _export(self, name=0, version=None, deps=None):
     client = TestClient(servers=self.servers,
                         users={"default": [("lu", "mypass")]})
     self.clients[name] = client
     # Not necessary to actually build binaries
     files = cpp_hello_conan_files(name, version, deps, build=False)
     client.save(files, clean_first=True)
     client.run("export lu/st")
     client.run("upload %s/%s@lu/st" % (name, version))
Esempio n. 52
0
    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=[("lasote", "mypass")])

        # Export and upload the conanfile
        self.conan_reference = ConanFileReference.loads(
            "hello0/0.1@lasote/stable")
        self.files = hello_conan_files(conan_reference=self.conan_reference,
                                       lang='go')
        self.conan.save(self.files, clean_first=True)
        self.conan.run("export lasote/stable")
        self.conan.run("upload %s" % str(self.conan_reference))
Esempio n. 53
0
    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
        })
Esempio n. 54
0
 def _get_client(self, requester=None):
     servers = {}
     # All can write (for avoid authentication until we mock user_io)
     self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                                   users={"lasote": "mypass"})
     servers["default"] = self.test_server
     return TestClient(servers=servers, users={"default": [("lasote", "mypass")]},
                       requester_class=requester)
Esempio n. 55
0
class PythonDiamondTest(unittest.TestCase):
    def setUp(self):
        self.client = TestClient()

    def _export_upload(self, name, version=None, deps=None):
        files = py_hello_conan_files(name, version, deps)
        self.client.save(files, clean_first=True)
        self.client.run("export lasote/stable")

    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"])

        files3 = py_hello_conan_files("Hello4", "0.1",
                                      ["Hello3/0.1@lasote/stable"])
        self.client.save(files3, clean_first=True)

        self.client.run("install .")
        self.assertIn("Hello1/0.1@lasote/stable: Build stuff Hello0",
                      self.client.user_io.out)
        self.assertIn("Hello2/0.1@lasote/stable: Build stuff Hello0",
                      self.client.user_io.out)

        self.assertIn(
            " ".join([
                "Hello3/0.1@lasote/stable: Build stuff Hello1",
                "Hello3/0.1@lasote/stable: Build stuff Hello0",
                "Hello3/0.1@lasote/stable: Build stuff Hello2",
                "Hello3/0.1@lasote/stable: Build stuff Hello0"
            ]), " ".join(str(self.client.user_io.out).splitlines()))

        if platform.system() == "Windows":
            command = "activate && python main.py"
        else:
            command = 'bash -c "source activate.sh && python main.py"'
        self.client.runner(command, cwd=self.client.current_folder)
        self.assertEqual([
            'Hello Hello4', 'Hello Hello3', 'Hello Hello1', 'Hello Hello0',
            'Hello Hello2', 'Hello Hello0'
        ],
                         str(self.client.user_io.out).splitlines()[-6:])
Esempio n. 56
0
 def install_same_test(self):
     client = TestClient()
     client.save({CONANFILE: conanfile})
     client.run("export lasote/stable")
     error = client.run("install hello0/0.1@lasote/stable --build=missing",
                        ignore_error=True)
     self._check(error, client)
Esempio n. 57
0
 def source_test(self):
     client = TestClient()
     client.save({CONANFILE: conanfile})
     client.run("export lasote/stable")
     error = client.run("source hello0/0.1@lasote/stable",
                        ignore_error=True)
     self._check(error, client)
Esempio n. 58
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
Esempio n. 59
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])