Esempio n. 1
0
    def install_outdated_and_dep_test(self):
        # regression test for https://github.com/conan-io/conan/issues/1053
        # A new recipe that depends on Hello0/0.1
        new_client = TestClient(servers=self.servers,
                                users={"default": [("lasote", "mypass")]})
        files = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], build=False)
        new_client.save(files)
        new_client.run("export lasote/stable")
        self.assertIn("A new conanfile.py version was exported", new_client.user_io.out)
        # It will retrieve from the remote Hello0 and build Hello1
        new_client.run("install Hello1/0.1@lasote/stable --build missing")

        # Then modify REMOTE Hello0 recipe files (WITH THE OTHER CLIENT)
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = files["conanfile.py"] + "\n#MODIFIED RECIPE"
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.assertIn("A new conanfile.py version was exported", self.client.user_io.out)
        self.client.run("install Hello0/0.1@lasote/stable --build missing")
        # Upload only the recipe, so the package is outdated in the server
        self.client.run("upload Hello0/0.1@lasote/stable")

        # Now, with the new_client, remove only the binary package from Hello0
        rmdir(new_client.paths.packages(self.ref))
        # And try to install Hello1 again, should not complain because the remote
        # binary is in the "same version" than local cached Hello0
        new_client.run("install Hello1/0.1@lasote/stable --build outdated --build Hello1")
        self.assertIn("Downloading conan_package.tgz", new_client.user_io.out)
        self.assertIn("Hello1/0.1@lasote/stable: WARN: Forced build from source",
                      new_client.user_io.out)
    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. 3
0
    def install_from_remotes_test(self):
        for i in range(3):
            conan_reference = ConanFileReference.loads("Hello%d/0.1@lasote/stable" % i)
            files = cpp_hello_conan_files("Hello%d" % i, "0.1", build=False)
            self.client.save(files)
            self.client.run("export . lasote/stable")
            self.client.run("upload %s -r=remote%d" % (str(conan_reference), i))

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

        # Now install it in other machine from remote 0
        client2 = TestClient(servers=self.servers, users=self.users)
        files = cpp_hello_conan_files("HelloX", "0.1", deps=["Hello0/0.1@lasote/stable",
                                                             "Hello1/0.1@lasote/stable",
                                                             "Hello2/0.1@lasote/stable"])
        files["conanfile.py"] = files["conanfile.py"].replace("def build(", "def build2(")
        client2.save(files)
        client2.run("install . --build=missing")
        self.assertIn("Hello0/0.1@lasote/stable from 'remote0'", client2.user_io.out)
        self.assertIn("Hello1/0.1@lasote/stable from 'remote1'", client2.user_io.out)
        self.assertIn("Hello2/0.1@lasote/stable from 'remote2'", client2.user_io.out)
        client2.run("info .")
        self.assertIn("Remote: remote0=http://", client2.user_io.out)
        self.assertIn("Remote: remote1=http://", client2.user_io.out)
        self.assertIn("Remote: remote2=http://", client2.user_io.out)
    def test_test_framework(self):
        client = TestClient()
        files = cpp_hello_conan_files("Test0")
        client.save(files, clean_first=True)
        client.run("export . lasote/stable")
        files = cpp_hello_conan_files("Test1", deps=["Test0/0.1@lasote/stable"])
        client.save(files, clean_first=True)
        client.run("export . lasote/stable")
        # client.run("install Test1/0.1@lasote/stable --build=missing")

        client.save({"conanfile.py": conanfile,
                     "test.cpp": test,
                     "CMakeLists.txt": cmake,
                     "profile.txt": test_profile}, clean_first=True)
        client.run("export . lasote/stable")
        client.run("install MyLib/0.1@lasote/stable --build=missing")
        self.assertIn("MyLib/0.1@lasote/stable: Generating the package", client.user_io.out)
        self.assertNotIn("100% tests passed", client.user_io.out)
        self.assertNotIn("Test0/0.1@lasote/stable", client.user_io.out)
        self.assertNotIn("Test1/0.1@lasote/stable", client.user_io.out)

        client.run("install MyLib/0.1@lasote/stable -pr=./profile.txt --build")
        self.assertIn("MyLib/0.1@lasote/stable: Generating the package", client.user_io.out)
        self.assertIn("Test0/0.1@lasote/stable", client.user_io.out)
        self.assertIn("Test1/0.1@lasote/stable", client.user_io.out)
        self.assertIn("100% tests passed", client.user_io.out)
Esempio n. 5
0
    def large_project_test(self):
        client = TestClient()
        num = 250
        deep = True  # True for N ... -> 3 -> 2 -> 1 -> 0, False for N -> 0, 3-> 0, 2->0, 1->0
        for i in range(num):
            if i == 0:
                files = cpp_hello_conan_files("Hello0", "0.1", build=False)
            else:
                if not deep:
                    files = cpp_hello_conan_files("Hello%d" % i, "0.1",
                                                  ["Hello0/0.1@lasote/stable"], build=False)
                else:
                    files = cpp_hello_conan_files("Hello%d" % i, "0.1",
                                                  ["Hello%s/0.1@lasote/stable" % (i-1)],
                                                  build=False)

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

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

        client.save(files, clean_first=True)
        t1 = time.time()
        client.run("install --build")
        print("Final time with build %s" % (time.time() - t1))
        t1 = time.time()
        client.run("install")
        print("Final time %s" % (time.time() - t1))
Esempio n. 6
0
    def install_outdated_dep_test(self):
        # A new recipe that depends on Hello0/0.1
        new_client = TestClient(servers=self.servers,
                                users={"default": [("lasote", "mypass")]})
        files = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], build=False)
        new_client.save(files)
        new_client.run("export . lasote/stable")
        self.assertIn("A new conanfile.py version was exported", new_client.user_io.out)
        # It will retrieve from the remote Hello0 and build Hello1
        new_client.run("install Hello1/0.1@lasote/stable --build missing")

        # Then modify REMOTE Hello0 recipe files (WITH THE OTHER CLIENT)
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = files["conanfile.py"] + "\n#MODIFIED RECIPE"
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.assertIn("A new conanfile.py version was exported", self.client.user_io.out)
        self.client.run("install Hello0/0.1@lasote/stable --build missing")
        # Upload only the recipe, so the package is outdated in the server
        self.client.run("upload Hello0/0.1@lasote/stable")

        # Now, with the new_client, remove only the binary package from Hello0
        rmdir(new_client.paths.packages(self.ref))
        # And try to install Hello1 again, should not complain because the remote
        # binary is in the "same version" than local cached Hello0
        new_client.run("install Hello1/0.1@lasote/stable --build outdated")
        self.assertIn("Downloading conan_package.tgz", new_client.user_io.out)
        self.assertIn("Hello0/0.1@lasote/stable: Package is up to date", new_client.user_io.out)

        # But if we remove the full Hello0 local package, will retrieve the updated
        # recipe and the outdated package
        new_client.run("remove Hello0* -f")
        new_client.run("install Hello1/0.1@lasote/stable --build outdated")
        self.assertIn("Hello0/0.1@lasote/stable: Outdated package!", new_client.user_io.out)
        self.assertIn("Hello0/0.1@lasote/stable: Building your package", new_client.user_io.out)
Esempio n. 7
0
    def update_not_date_test(self):
        # Regression for https://github.com/conan-io/conan/issues/949
        files0 = cpp_hello_conan_files("Hello0", "1.0", build=False)
        files0["conanfile.py"] = files0["conanfile.py"].replace("settings = ", "# settings = ")
        self.client.save(files0)
        self.client.run("export lasote/stable")
        files1 = cpp_hello_conan_files("Hello1", "1.0", build=False,
                                       deps=["Hello0/1.0@lasote/stable"])
        self.client.save(files1, clean_first=True)
        self.client.run("install --build")
        self.client.run("upload Hello0/1.0@lasote/stable --all")

        ref = ConanFileReference.loads("Hello0/1.0@lasote/stable")
        package_ref = PackageReference(ref, "55a3af76272ead64e6f543c12ecece30f94d3eda")
        recipe_manifest = self.client.client_cache.digestfile_conanfile(ref)
        package_manifest = self.client.client_cache.digestfile_package(package_ref)

        def timestamps():
            recipe_timestamp = load(recipe_manifest).splitlines()[0]
            package_timestamp = load(package_manifest).splitlines()[0]
            return recipe_timestamp, package_timestamp

        initial_timestamps = timestamps()

        import time
        time.sleep(1)

        # Change and rebuild package
        files0["helloHello0.h"] = files0["helloHello0.h"] + " // useless comment"
        self.client.save(files0, clean_first=True)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/1.0@lasote/stable --build")
        rebuild_timestamps = timestamps()
        self.assertNotEqual(rebuild_timestamps, initial_timestamps)

        # back to the consumer, try to update
        self.client.save(files1, clean_first=True)
        self.client.run("install --update")
        self.assertIn("ERROR: Current conanfile is newer than myremote's one",
                      self.client.user_io.out)
        failed_update_timestamps = timestamps()
        self.assertEqual(rebuild_timestamps, failed_update_timestamps)

        # hack manifests, put old time
        for manifest_file in (recipe_manifest, package_manifest):
            manifest = load(manifest_file)
            lines = manifest.splitlines()
            lines[0] = "123"
            save(manifest_file, "\n".join(lines))

        self.client.run("install --update")
        update_timestamps = timestamps()
        self.assertEqual(update_timestamps, initial_timestamps)
Esempio n. 8
0
    def dual_compiler_settings_and_env_test(self):

        def patch_conanfile(conanfile):
            return conanfile + '''
    def build(self):
        import os
        self.output.warn("COMPILER: %s=>%s" % (self.name, self.settings.compiler))
        self.output.warn("CXX: %s=>%s" % (self.name, os.environ["CXX"]))
        self.output.warn("CC: %s=>%s" % (self.name, os.environ["CC"]))
'''

        client = TestClient()
        files = cpp_hello_conan_files("Hello0", "1.0", deps=[], build=False)
        files[CONANFILE] = patch_conanfile(files[CONANFILE])
        client.save(files)
        client.run("export lasote/stable")

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

        # Both with same settings
        client.run("install Hello1/1.0@lasote/stable --build -s compiler=gcc"
                   " -s compiler.version=4.6 -s compiler.libcxx=libstdc++11"
                   " -e CXX=/mycompilercxx -e CC=/mycompilercc")

        self.assertIn("COMPILER: Hello0=>gcc", client.user_io.out)
        self.assertIn("CXX: Hello0=>/mycompilercxx", client.user_io.out)
        self.assertIn("CC: Hello0=>/mycompilercc", client.user_io.out)

        self.assertIn("COMPILER: Hello1=>gcc", client.user_io.out)
        self.assertIn("CXX: Hello1=>/mycompilercxx", client.user_io.out)
        self.assertIn("CC: Hello1=>/mycompilercc", client.user_io.out)

        # Different for Hello0
        client.run("install Hello1/1.0@lasote/stable --build -s compiler=gcc"
                   " -s compiler.version=4.6 -s compiler.libcxx=libstdc++11"
                   " -e CXX=/mycompilercxx -e CC=/mycompilercc"
                   " -s Hello0:compiler=clang -s Hello0:compiler.version=3.7"
                   " -s Hello0:compiler.libcxx=libstdc++"
                   " -e Hello0:CXX=/othercompilercxx -e Hello0:CC=/othercompilercc")

        self.assertIn("COMPILER: Hello0=>clang", client.user_io.out)
        self.assertIn("CXX: Hello0=>/othercompilercxx", client.user_io.out)
        self.assertIn("CC: Hello0=>/othercompilercc", client.user_io.out)

        self.assertIn("COMPILER: Hello1=>gcc", client.user_io.out)
        self.assertIn("CXX: Hello1=>/mycompilercxx", client.user_io.out)
        self.assertIn("CC: Hello1=>/mycompilercc", client.user_io.out)
Esempio n. 9
0
    def reuse_test(self):
        conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1")

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

        configs = []  # ("gcc", "4.8")]
        # Place to add different compilers
        if platform.system() == "Windows2":
            configs.append(("Visual Studio", "12"))
        for compiler, compiler_version in configs:
            client.default_settings(compiler, compiler_version)
            client.run("install %s --build missing" % str(conan_reference))

        # Check compilation ok
        package_ids = client.paths.conan_packages(conan_reference)
        self.assertEquals(len(package_ids), len(configs))
        for package_id in package_ids:
            package_ref = PackageReference(conan_reference, package_id)
            self._assert_library_exists(package_ref, client.paths)

        # Reuse them
        conan_reference = ConanFileReference.loads("Hello1/0.2@lasote/stable")
        files3 = cpp_hello_conan_files("Hello1", "0.1", ["Hello0/0.1@lasote/stable"])
        client.current_folder = temp_folder()

        client.save(files3)
        for compiler, compiler_version in configs:
            client.default_settings(compiler, compiler_version)
            client.run('install')
            client.run('build')

            command = os.sep.join([".", "bin", "say_hello"])
            client.runner(command, cwd=client.current_folder)
            self.assertIn("Hello Hello1", client.user_io.out)
            self.assertIn("Hello Hello0", client.user_io.out)

        new_conanfile = files3[CONANFILE].replace('"language": 0', '"language": 1')
        for compiler, compiler_version in configs:
            client.default_settings(compiler, compiler_version)
            client.save({CONANFILE: new_conanfile})
            client.run('install')
            client.run('build')
            time.sleep(1)

            client.runner(command, cwd=client.current_folder)
            self.assertIn("Hola Hello1", client.user_io.out)
            self.assertIn("Hola Hello0", client.user_io.out)
Esempio n. 10
0
    def test_json_generation(self):

        files = cpp_hello_conan_files("CC", "1.0", build=False)
        self.client.save(files, clean_first=True)
        self.client.run("create . private_user/channel --json=myfile.json ")

        self.client.run('upload "*" -c --all')

        files = cpp_hello_conan_files("BB", "1.0", build=False)
        files["conanfile.py"] += """
    def configure(self):
        self.options["CC"].static = False

    def build_requirements(self):
        self.build_requires("CC/1.0@private_user/channel")

"""
        self.client.save(files, clean_first=True)
        self.client.run("create . private_user/channel --build missing")
        self.client.run('upload "*" -c --all')

        files = cpp_hello_conan_files("AA", "1.0",
                                      deps=["BB/1.0@private_user/channel"], build=False)
        self.client.save(files, clean_first=True)
        self.client.run("create . private_user/channel")
        self.client.run('upload "*" -c --all')

        save(os.path.join(self.client.client_cache.profiles_path, "mybr"),
             """
include(default)
[build_requires]
AA*: CC/1.0@private_user/channel
""")
        files = cpp_hello_conan_files("PROJECT", "1.0",
                                      deps=["AA/1.0@private_user/channel"], build=False)
        self.client.save(files, clean_first=True)
        self.client.run("install . --profile mybr --json=myfile.json --build AA --build BB")
        my_json = load(os.path.join(self.client.current_folder, "myfile.json"))
        my_json = json.loads(my_json)

        self.assertTrue(my_json["installed"][0]["recipe"]["dependency"])
        self.assertTrue(my_json["installed"][1]["recipe"]["dependency"])
        self.assertTrue(my_json["installed"][2]["recipe"]["dependency"])

        # Installed the build require CC with two options
        self.assertEquals(len(my_json["installed"][2]["packages"]), 2)
        self.assertEquals(my_json["installed"][2]["recipe"]["id"], "CC/1.0@private_user/channel")
        self.assertTrue(my_json["installed"][2]["recipe"]["cache"])
        self.assertTrue(my_json["installed"][2]["packages"][0]["cache"])
        self.assertTrue(my_json["installed"][2]["packages"][1]["cache"])
Esempio n. 11
0
    def upper_option_txt_test(self):
        self._create("Hello0", "0.1", no_config=True)
        self._create("Hello1", "0.1", ["Hello0/0.1@lasote/stable"], no_config=True)

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

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

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

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

        package_ref1 = PackageReference(ConanFileReference.loads("Hello1/0.1@lasote/stable"),
                                        "44671ecdd9c606eb7166f2197ab50be8d36a3c3b")
        hello1 = self.client.paths.package(package_ref1)
        hello1_info = os.path.join(hello1, CONANINFO)
        hello1_conan_info = ConanInfo.load_file(hello1_info)
        self.assertEqual(0, hello1_conan_info.options.language)
Esempio n. 12
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. 13
0
 def _create(self, client, number, version, deps=None, export=True, modifier=""):
     files = cpp_hello_conan_files(number, version, deps, build=False)
     # To avoid building
     files = {CONANFILE: files[CONANFILE].replace("config(", "config2(") + modifier}
     client.save(files, clean_first=True)
     if export:
         client.run("export lasote/stable")
Esempio n. 14
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. 15
0
 def _export_upload(self, name=0, version=None, deps=None, msg=None, static=True):
     files = cpp_hello_conan_files(name, version, deps, msg=msg, static=static,
                                    private_includes=True)
     conan_ref = ConanFileReference(name, version, "lasote", "stable")
     self.client.save(files, clean_first=True)
     self.client.run("export lasote/stable")
     self.client.run("upload %s" % str(conan_ref))
Esempio n. 16
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. 17
0
    def test_run_environment(self):
        client = TestClient()
        files = cpp_hello_conan_files("Hello0", "0.1")
        files[CONANFILE] = files[CONANFILE].replace('self.copy(pattern="*.so", dst="lib", keep_path=False)',
                                                    '''self.copy(pattern="*.so", dst="lib", keep_path=False)
        self.copy(pattern="*say_hello*", dst="bin", keep_path=False)''')
        client.save(files)
        client.run("export . lasote/stable")

        reuse = '''
from conans import ConanFile, RunEnvironment, tools

class HelloConan(ConanFile):
    name = "Reuse"
    version = "0.1"
    build_policy = "missing"
    requires = "Hello0/0.1@lasote/stable"

    def build(self):
        run_env = RunEnvironment(self)
        with tools.environment_append(run_env.vars):
            self.run("say_hello")
'''

        client.save({"conanfile.py": reuse}, clean_first=True)
        client.run("install . --build missing")
        client.run("build .")
Esempio n. 18
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. 19
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. 20
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. 21
0
    def upload_newer_recipe_test(self):
        servers = {}
        test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                                 users={"lasote": "mypass"})
        servers["default"] = test_server
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})

        files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
        client.save(files)
        client.run("export frodo/stable")
        client.run("install Hello0/1.2.1@frodo/stable --build=missing")
        client.run("upload Hello0/1.2.1@frodo/stable --all")

        client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
        client2.save(files)
        client2.run("export frodo/stable")
        ref = ConanFileReference.loads("Hello0/1.2.1@frodo/stable")
        manifest = client2.client_cache.load_manifest(ref)
        manifest.time += 10
        save(client2.client_cache.digestfile_conanfile(ref), str(manifest))
        client2.run("install Hello0/1.2.1@frodo/stable --build=missing")
        client2.run("upload Hello0/1.2.1@frodo/stable --all")
        self.assertNotIn("conanfile", client2.user_io.out)
        self.assertIn("Package is up to date.", client2.user_io.out)
        self.assertIn("Uploading conanmanifest.txt", client2.user_io.out)

        # Now try again with the other client, which timestamp is older
        client.run("upload Hello0/1.2.1@frodo/stable --all")
        self.assertNotIn("conanfile", client2.user_io.out)
        self.assertIn("Package is up to date.", client2.user_io.out)
        self.assertIn("Uploading conanmanifest.txt", client.user_io.out)
Esempio n. 22
0
    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. 23
0
    def setUp(self):
        self.client = TestClient()
        files = cpp_hello_conan_files(name="MinGWBuild", version="0.1", build=False)
        self._patch_build_to_print_compiler(files)

        self.client.save(files)
        self.client.run("export . lasote/testing")
Esempio n. 24
0
    def test_override(self):

        files = cpp_hello_conan_files(name="VisualBuild",
                                      version="0.1", build=False, deps=["MinGWBuild/0.1@lasote/testing"])
        self._patch_build_to_print_compiler(files)
        self.client.save(files)
        self.client.run("export . lasote/testing")
        self.client.run("install VisualBuild/0.1@lasote/testing --build missing -s compiler='Visual Studio' "
                        "-s compiler.version=14 -s compiler.runtime=MD "
                        "-s MinGWBuild:compiler='gcc' -s MinGWBuild:compiler.libcxx='libstdc++' "
                        "-s MinGWBuild:compiler.version=4.8")

        self.assertIn("COMPILER=> MinGWBuild gcc", self.client.user_io.out)
        self.assertIn("COMPILER=> VisualBuild Visual Studio", self.client.user_io.out)

        # CHECK CONANINFO FILE
        packs_dir = self.client.paths.packages(ConanFileReference.loads("MinGWBuild/0.1@lasote/testing"))
        pack_dir = os.path.join(packs_dir, os.listdir(packs_dir)[0])
        conaninfo = load(os.path.join(pack_dir, CONANINFO))
        self.assertIn("compiler=gcc", conaninfo)

        # CHECK CONANINFO FILE
        packs_dir = self.client.paths.packages(ConanFileReference.loads("VisualBuild/0.1@lasote/testing"))
        pack_dir = os.path.join(packs_dir, os.listdir(packs_dir)[0])
        conaninfo = load(os.path.join(pack_dir, CONANINFO))
        self.assertIn("compiler=Visual Studio", conaninfo)
        self.assertIn("compiler.version=14", conaninfo)
Esempio n. 25
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. 26
0
    def not_reupload_test(self):
        """ Check that if the package has not been modified, it is not uploaded
        again
        """
        servers = {}
        test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                                 users={"lasote": "mypass"})
        servers["default"] = test_server
        client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})

        files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
        client.save(files)
        client.run("export frodo/stable")
        client.run("install Hello0/1.2.1@frodo/stable --build=missing")
        client.run("upload Hello0/1.2.1@frodo/stable -r default --all")
        self.assertIn("Uploading conan_package.tgz", client.user_io.out)
        client.run("remove Hello0/1.2.1@frodo/stable -f")
        client.run("search")
        self.assertNotIn("Hello0/1.2.1@frodo/stable", client.user_io.out)
        client.run("install Hello0/1.2.1@frodo/stable")
        self.assertIn("Downloading conan_package.tgz", client.user_io.out)
        client.run("upload Hello0/1.2.1@frodo/stable -r default --all")
        self.assertIn("Uploaded conan recipe", client.user_io.out)
        self.assertNotIn("Uploading conan_package.tgz", client.user_io.out)
        self.assertIn("Package is up to date", client.user_io.out)
Esempio n. 27
0
    def fail_when_not_notfound_test(self):
        """
        If a remote fails with a 404 it has to keep looking in the next remote, but if it fails by
        any other reason it has to stop
        """
        servers = OrderedDict()
        servers["s0"] = TestServer()
        servers["s1"] = TestServer()
        servers["s2"] = TestServer()

        client = TestClient(servers=servers, users=self.users)
        files = cpp_hello_conan_files("MyLib", "0.1", build=False)
        client.save(files)
        client.run("create . lasote/testing")
        client.run("user lasote -p mypass -r s1")
        client.run("upload MyLib* -r s1 -c")

        servers["s1"].fake_url = "http://asdlhaljksdhlajkshdljakhsd"  # Do not exist
        client2 = TestClient(servers=servers, users=self.users)
        err = client2.run("install MyLib/0.1@conan/testing --build=missing", ignore_error=True)
        self.assertTrue(err)
        self.assertIn("MyLib/0.1@conan/testing: Trying with 's0'...", client2.out)
        self.assertIn("MyLib/0.1@conan/testing: Trying with 's1'...", client2.out)
        self.assertIn("Unable to connect to s1=http://asdlhaljksdhlajkshdljakhsd", client2.out)
        # s2 is not even tried
        self.assertNotIn("MyLib/0.1@conan/testing: Trying with 's2'...", client2.out)
Esempio n. 28
0
    def upload_test(self):
        conan_reference = 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("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. 29
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. 30
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. 31
0
 def _upload_some_packages(self, client):
     self.ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
     self.files = cpp_hello_conan_files("Hello0", "0.1")
     # No build.
     self.files[CONANFILE] = self.files[CONANFILE].replace(
         "def build(self):", "def build(self):\n        return\n")
     client.save(self.files)
     client.run("export . lasote/stable")
     client.run(
         "install Hello0/0.1@lasote/stable -s os=Windows --build missing")
     client.run(
         "install Hello0/0.1@lasote/stable -s os=Linux --build missing")
     client.run(
         "install Hello0/0.1@lasote/stable -s os=Linux -s compiler=gcc -s "
         "compiler.version=4.6 -s compiler.libcxx=libstdc++ --build missing"
     )
     client.run("upload  Hello0/0.1@lasote/stable --all")
     return os.listdir(self.client.client_cache.packages(self.ref))
Esempio n. 32
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. 33
0
def hello_conan_files(conan_reference,
                      number=0,
                      deps=None,
                      language=0,
                      lang='cpp'):
    """Generate hello_files, as described above, plus the necessary
    CONANFILE to manage it
    param number: integer, defining name of the conans Hello0, Hello1, HelloX
    param deps: [] list of integers, defining which dependencies this conans
                depends on
    param language: 0 = English, 1 = Spanish
    e.g. (3, [4, 7]) means that a Hello3 conans will be created, with message
         "Hello 3", that depends both in Hello4 and Hello7.
         The output of such a conans exe could be like: Hello 3, Hello 4, Hello7"""
    if lang == 'cpp':
        return cpp_hello_conan_files(conan_reference, number, deps, language)
    elif lang == 'go':
        return go_hello_conan_files(conan_reference, number, deps)
Esempio n. 34
0
 def basic_test(self):
     server = TestServer()
     servers = {"default": server}
     client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
     files = cpp_hello_conan_files()
     client.save(files)
     client.run("export . lasote/stable")
     ref = ConanFileReference.loads("Hello/0.1@lasote/stable")
     self.assertTrue(os.path.exists(client.paths.export(ref)))
     client.run("upload Hello/0.1@lasote/stable")
     client.run("remove Hello/0.1@lasote/stable -f")
     self.assertFalse(os.path.exists(client.paths.export(ref)))
     path = server.test_server.server_store.export(ref)
     tgz = os.path.join(path, "conan_export.tgz")
     save(tgz, "contents")  # dummy content to break it, so the download decompress will fail
     client.run("install Hello/0.1@lasote/stable --build", ignore_error=True)
     self.assertIn("ERROR: Error while downloading/extracting files to", client.user_io.out)
     self.assertFalse(os.path.exists(client.paths.export(ref)))
Esempio n. 35
0
    def test_override_setting_with_env_variables(self):
        files = cpp_hello_conan_files(name="VisualBuild",
                                      version="0.1",
                                      build=False,
                                      deps=["MinGWBuild/0.1@lasote/testing"])
        self._patch_build_to_print_compiler(files)
        self.client.save(files)
        self.client.run("export . lasote/testing")
        with tools.environment_append({
                "CONAN_ENV_COMPILER": "Visual Studio",
                "CONAN_ENV_COMPILER_VERSION": "14",
                "CONAN_ENV_COMPILER_RUNTIME": "MD"
        }):
            self.client.run(
                "install VisualBuild/0.1@lasote/testing --build missing")

        self.assertIn("COMPILER=> MinGWBuild Visual Studio",
                      self.client.user_io.out)
Esempio n. 36
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': '52546396c42f16be3daf72ecf7ab7143',
            'conanfile.py': '3ac566eb5b2e4df4417003f0e606e237',
            'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
            'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'
        }
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 37
0
    def put_properties_test(self):
        wanted_vars = {"MyHeader1": "MyHeaderValue1;MyHeaderValue2", "Other": "Value"}

        class RequesterCheckHeaders(TestRequester):
            def put(self, url, **kwargs):
                for name, value in wanted_vars.items():
                    value1 = kwargs["headers"][name]
                    if value1 != value:
                        raise Exception()
                return super(RequesterCheckHeaders, self).put(url, **kwargs)

        self.client = TestClient(requester_class=RequesterCheckHeaders, servers=self.servers,
                                 users={"default": [("lasote", "mypass")]})
        _create_property_files(self.client, wanted_vars)

        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run("upload Hello0/0.1@lasote/stable -c")
Esempio n. 38
0
 def upload_login_prompt_disabled_user_not_authenticated_test(self):
     """ When a user is not authenticated, uploads should fail when login prompt has been disabled.
     """
     files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
     client = self._client()
     client.save(files)
     client.run("config set general.non_interactive=True")
     client.run("create . user/testing")
     client.run("user -c")
     client.run("user lasote")
     error = client.run("upload Hello0/1.2.1@user/testing",
                        ignore_error=True)
     self.assertTrue(error)
     self.assertIn('ERROR: Conan interactive mode disabled', client.out)
     self.assertNotIn("Uploading conanmanifest.txt", client.out)
     self.assertNotIn("Uploading conanfile.py", client.out)
     self.assertNotIn("Uploading conan_export.tgz", client.out)
     self.assertNotIn("Please enter a password for \"lasote\" account:",
                      client.out)
Esempio n. 39
0
    def upload_only_tgz_if_needed_test(self):
        ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0",
                                      "0.1",
                                      need_patch=True,
                                      build=False)
        files["lib/another_export_file.lib"] = "to compress"
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run("install %s --build missing" % str(ref))

        # Upload conans
        self.client.run("upload %s" % str(ref))
        self.assertIn("Compressing recipe", str(self.client.user_io.out))

        # Not needed to tgz again
        self.client.run("upload %s" % str(ref))
        self.assertNotIn("Compressing recipe", str(self.client.user_io.out))

        # Check that conans exists on server
        server_paths = self.servers["default"].server_store
        conan_path = server_paths.conan_revisions_root(ref)
        self.assertTrue(os.path.exists(conan_path))
        package_ids = self.client.cache.package_layout(ref).conan_packages()
        pref = PackageReference(ref, package_ids[0])

        # Upload package
        self.client.run("upload %s -p %s" % (str(ref), str(package_ids[0])))
        self.assertIn("Compressing package", str(self.client.user_io.out))

        # Not needed to tgz again
        self.client.run("upload %s -p %s" % (str(ref), str(package_ids[0])))
        self.assertNotIn("Compressing package", str(self.client.user_io.out))

        # If we install the package again will be removed and re tgz
        self.client.run("install %s --build missing" % str(ref))
        # Upload package
        self.client.run("upload %s -p %s" % (str(ref), str(package_ids[0])))
        self.assertNotIn("Compressing package", str(self.client.user_io.out))

        # Check library on server
        self._assert_library_exists_in_server(pref, server_paths)
Esempio n. 40
0
    def conan_test_test(self):
        client = TestClient()
        files = cpp_hello_conan_files("Hello0", "0.1")
        test_conanfile = '''
from conans import ConanFile, CMake
import os

class HelloReuseConan(ConanFile):
    settings = "os", "compiler", "build_type", "arch"
    requires = "Hello0/0.1@ lasote/stable"
    generators = "cmake"

    def build(self):
        cmake = CMake(self.settings)
        self.run('cmake "%s" %s' % (self.conanfile_directory, cmake.command_line))
        self.run("cmake --build . %s" % cmake.build_config)

    def test(self):
        # equal to ./bin/greet, but portable win: .\bin\greet
        self.run(os.sep.join([".","bin", "greet"]))
        '''

        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 build_type=Release -o Hello0:language=1")
        self.assertFalse(error)
        self.assertIn('Hola Hello0', client.user_io.out)
Esempio n. 41
0
 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)
Esempio n. 42
0
 def test_upload_key_error(self):
     files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
     server1 = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                          users={"lasote": "mypass"})
     server2 = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                          users={"lasote": "mypass"})
     servers = OrderedDict()
     servers["server1"] = server1
     servers["server2"] = server2
     client = TestClient(servers=servers)
     client.save(files)
     client.run("create . user/testing")
     client.run("user lasote -p mypass")
     client.run("user lasote -p mypass -r server2")
     client.run("upload Hello0/1.2.1@user/testing --all -r server1")
     client.run("remove * --force")
     client.run("install Hello0/1.2.1@user/testing -r server1")
     client.run("remote remove server1")
     client.run("upload Hello0/1.2.1@user/testing --all -r server2")
     self.assertNotIn("ERROR: 'server1'", client.out)
Esempio n. 43
0
    def test_reuse_uploaded_tgz(self):
        # Download packages from a remote, then copy to another channel
        # and reupload them. Because they have not changed, the tgz is not created again

        # UPLOAD A PACKAGE
        ref = ConanFileReference.loads("Hello0/0.1@lasote/stable")
        files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True, build=False)
        files["another_export_file.lib"] = "to compress"
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run("install %s --build missing" % str(ref))
        self.client.run("upload %s --all" % str(ref))
        self.assertIn("Compressing recipe", self.client.out)
        self.assertIn("Compressing package", self.client.out)

        # UPLOAD TO A DIFFERENT CHANNEL WITHOUT COMPRESS AGAIN
        self.client.run("copy %s lasote/testing --all" % str(ref))
        self.client.run("upload Hello0/0.1@lasote/testing --all")
        self.assertNotIn("Compressing recipe", self.client.out)
        self.assertNotIn("Compressing package", self.client.out)
Esempio n. 44
0
    def skip_upload_test(self):
        """ Check that the option --dry does not upload anything
        """
        servers = {}
        test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
                                 users={"lasote": "mypass"})
        servers["default"] = test_server
        client = TestClient(servers=servers,
                            users={"default": [("lasote", "mypass")]})

        files = cpp_hello_conan_files("Hello0", "1.2.1", build=False)
        client.save(files)
        client.run("export frodo/stable")
        client.run("install Hello0/1.2.1@frodo/stable --build=missing")
        client.run(
            "upload Hello0/1.2.1@frodo/stable -r default --all --skip_upload")

        # dry run should not upload
        self.assertNotIn("Uploading conan_package.tgz", client.user_io.out)

        # but dry run should compress
        self.assertIn("Compressing recipe...", client.user_io.out)
        self.assertIn("Compressing package...", client.user_io.out)

        client.run("search -r default")
        # after dry run nothing should be on the server ...
        self.assertNotIn("Hello0/1.2.1@frodo/stable", client.user_io.out)

        # now upload, the stuff should NOT be recompressed
        client.run("upload Hello0/1.2.1@frodo/stable -r default --all")

        # check for upload message
        self.assertIn("Uploading conan_package.tgz", client.user_io.out)

        # check if compressed files are re-used
        self.assertNotIn("Compressing recipe...", client.user_io.out)
        self.assertNotIn("Compressing package...", client.user_io.out)

        # now it should be on the server
        client.run("search -r default")
        self.assertIn("Hello0/1.2.1@frodo/stable", client.user_io.out)
Esempio n. 45
0
    def install_profile_env_test(self):
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = conanfile_scope_env

        create_profile(self.client.cache.profiles_path,
                       "envs",
                       settings={},
                       env=[("A_VAR", "A_VALUE"),
                            ("PREPEND_VAR", ["new_path", "other_path"])],
                       package_env={"Hello0": [("OTHER_VAR", "2")]})

        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run(
            "install Hello0/0.1@lasote/stable --build missing -pr envs")
        self._assert_env_variable_printed(
            "PREPEND_VAR", os.pathsep.join(["new_path", "other_path"]))
        self.assertEqual(1,
                         str(self.client.out).count(
                             "PREPEND_VAR=new_path"))  # prepended once
        self._assert_env_variable_printed("A_VAR", "A_VALUE")
        self._assert_env_variable_printed("OTHER_VAR", "2")

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

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

        # Pass a variable with "=" symbol
        self.client.run(
            "install Hello0/0.1@lasote/stable --build -pr envs "
            "-e Hello0:A_VAR=Valuewith=equal -e Hello0:OTHER_VAR=3")
        self._assert_env_variable_printed("A_VAR", "Valuewith=equal")
        self._assert_env_variable_printed("OTHER_VAR", "3")
Esempio n. 46
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': 'bd569d8f69284ce8127fee724dac2a70',
            'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
            'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'
        }
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 47
0
    def install_profile_package_settings_test(self):
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        self.client.save(files)

        # Create a profile and use it
        profile_settings = OrderedDict([("os", "Windows"),
                                        ("compiler", "Visual Studio"),
                                        ("compiler.version", "12"),
                                        ("compiler.runtime", "MD"),
                                        ("arch", "x86")])

        # Use package settings in profile
        tmp_settings = OrderedDict()
        tmp_settings["compiler"] = "gcc"
        tmp_settings["compiler.libcxx"] = "libstdc++11"
        tmp_settings["compiler.version"] = "4.8"
        package_settings = {"*@lasote/*": tmp_settings}
        _create_profile(self.client.cache.profiles_path,
                        "myprofile",
                        settings=profile_settings,
                        package_settings=package_settings)
        # Try to override some settings in install command
        self.client.run("install . lasote/testing -pr myprofile")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        self.assertIn("compiler=gcc", info)
        self.assertIn("compiler.libcxx=libstdc++11", info)
        self.assertIn("compiler.version=4.8", info)

        package_settings = {"*@other/*": tmp_settings}
        _create_profile(self.client.cache.profiles_path,
                        "myprofile",
                        settings=profile_settings,
                        package_settings=package_settings)
        # Try to override some settings in install command
        self.client.run("install . lasote/testing -pr myprofile")
        info = load(os.path.join(self.client.current_folder, "conaninfo.txt"))
        self.assertIn("compiler=Visual Studio", info)
        self.assertIn("compiler.runtime=MD", info)
        self.assertIn("compiler.version=12", info)
        self.assertNotIn("gcc", info)
        self.assertNotIn("libcxx", info)
Esempio n. 48
0
 def _export_upload(self,
                    name=0,
                    version=None,
                    deps=None,
                    msg=None,
                    static=True,
                    build=True,
                    upload=True):
     files = cpp_hello_conan_files(name,
                                   version,
                                   deps,
                                   msg=msg,
                                   static=static,
                                   private_includes=True,
                                   build=build,
                                   cmake_targets=False)
     ref = ConanFileReference(name, version, "lasote", "stable")
     self.client.save(files, clean_first=True)
     self.client.run("export . lasote/stable")
     if upload:
         self.client.run("upload %s" % str(ref))
Esempio n. 49
0
    def test_conanfile_not_found(self):
        """If package is OpenSSL is not openssl"""

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

        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. 50
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: A new conanfile.py version was exported' %
            str(self.conan_ref), self.conan.user_io.out)
        self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path2),
                      self.conan.user_io.out)
        self.assertTrue(os.path.exists(reg_path2))

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

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

        for f in file_list:
            self.assertTrue(os.path.exists(f))
Esempio n. 51
0
    def install_outdated_test(self):
        # If we try to install the same package with --build oudated it's already ok
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
                      self.client.user_io.out)
        self.assertIn("Hello0/0.1@lasote/stable: Package is up to date",
                      self.client.user_io.out)

        # Then we can export a modified recipe and try to install without --build outdated
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = files["conanfile.py"] + "\n#Otherline"
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("install Hello0/0.1@lasote/stable")
        self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
                      self.client.user_io.out)
        self.assertNotIn("Package is up to date", self.client.user_io.out)
        self.assertNotIn("Outdated package!", self.client.user_io.out)

        # Try now with the --build outdated
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
                      self.client.user_io.out)
        self.assertNotIn("Package is up to date", self.client.user_io.out)
        self.assertIn("Outdated package!", self.client.user_io.out)
        self.assertIn("Building your package", self.client.user_io.out)

        # Remove all local references, export again (the modified version not uploaded)
        # and try to install, it will discard the remote package too
        self.client.run("remove Hello0* -f")
        self.client.save(files)
        self.client.run("export lasote/stable")
        self.client.run("remote add_ref Hello0/0.1@lasote/stable default")
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertIn("Downloading conan_package.tgz", self.client.user_io.out)
        self.assertNotIn("Hello0/0.1@lasote/stable: Already installed!",
                         self.client.user_io.out)
        self.assertNotIn("Package is up to date", self.client.user_io.out)
        self.assertIn("Outdated package!", self.client.user_io.out)
        self.assertIn("Building your package", self.client.user_io.out)
Esempio n. 52
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 = """set(CMAKE_CXX_COMPILER_WORKS 1)
set(CMAKE_CXX_ABI_COMPILED 1)
project(MyHello CXX)
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("create lasote/stable")
        error = client.run("test test_package -s build_type=Release")
        self.assertFalse(error)
        self.assertNotIn("WARN: conanbuildinfo.txt file not found",
                         client.user_io.out)
        self.assertNotIn("WARN: conanenv.txt file not found",
                         client.user_io.out)
        self.assertIn('Hello Hello0', client.user_io.out)
        error = client.run(
            "test test_package -s Hello0:build_type=Debug -o Hello0:language=1 --build missing"
        )
        self.assertFalse(error)
        self.assertIn('Hola Hello0', client.user_io.out)
        self.assertIn('BUILD_TYPE=>Debug', client.user_io.out)
Esempio n. 53
0
    def matrix_params_test(self):
        test_server = TestServer(server_capabilities=[MATRIX_PARAMS, ])
        servers = {"default": test_server}

        wanted_vars = {"key0": "value",
                       "key1": "with space",
                       "key2": "with/slash",
                       "key3": "with.dot",
                       "key4": "with;semicolon",
                       "key5": "with~virgul",
                       "key6": "with#hash"
                       }

        class RequesterCheckArtifactProperties(TestRequester):
            def put(self_requester, url, **kwargs):
                # Check headers
                self.assertListEqual(list(kwargs["headers"].keys()),
                                     ["X-Checksum-Sha1", "User-Agent"])

                # Check matrix params
                m = re.match(r"^[^;\s]+;(?P<matrix_params>[^/]+)/.*", url)
                mp = m.group("matrix_params")
                values = [it.split("=") for it in mp.split(';')]
                values = {key: unquote(value) for (key, value) in values}
                for name, value in wanted_vars.items():
                    value1 = values[name]
                    self.assertEqual(value1, value)

                slice_start, slice_end = m.span(1)
                url = url[: slice_start-1] + url[slice_end:]  # matrix params are not implemented for conan-server
                return super(RequesterCheckArtifactProperties, self_requester).put(url, **kwargs)

        client = TestClient(requester_class=RequesterCheckArtifactProperties,
                            servers=servers, users={"default": [("lasote", "mypass")]})
        _create_property_files(client, wanted_vars)

        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        client.save(files)
        client.run("export . lasote/stable")
        client.run("upload Hello0/0.1@lasote/stable -c")
Esempio n. 54
0
    def test_export_the_same_code(self):
        file_list = self._create_packages_and_builds()
        # Export the same conans
        # Do not adjust cpu_count, it is reusing a cache
        conan2 = TestClient(self.conan.base_folder, cpu_count=False)
        files2 = cpp_hello_conan_files("Hello0", "0.1")
        conan2.save(files2)
        conan2.run("export . lasote/stable")
        reg_path2 = conan2.client_cache.export(self.conan_ref)
        digest2 = FileTreeManifest.load(
            conan2.client_cache.export(self.conan_ref))

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

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

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

        for f in file_list:
            self.assertTrue(os.path.exists(f))
Esempio n. 55
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")
        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.cache.package_layout(ref).export()
        manif = FileTreeManifest.load(
            client.cache.package_layout(ref).export())

        self.assertIn('%s: A new conanfile.py version was exported' % str(ref),
                      client.out)
        self.assertIn('%s: Folder: %s' % (str(ref), reg_path), client.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': '10d907c160c360b28f6991397a5aa9b4',
            'conanfile.py': '3ac566eb5b2e4df4417003f0e606e237',
            'source/executable': '68b329da9893e34099c7d8ad5cb9c940',
            'source/helloHello0.h': '9448df034392fc8781a47dd03ae71bdd'
        }
        self.assertEqual(expected_sums, manif.file_sums)
Esempio n. 56
0
def build(tester, cmd, static, pure_c, use_cmake, lang):
    client = TestClient()
    files = cpp_hello_conan_files("Hello0", "0.1", pure_c=pure_c, use_cmake=use_cmake)

    client.save(files)
    client.run(cmd)
    client.run('build .')
    ld_path = ("LD_LIBRARY_PATH=`pwd`"
               if not static and not platform.system() == "Windows" else "")
    if platform.system() == "Darwin":
        ld_path += ' DYLD_LIBRARY_PATH="%s"' % os.path.join(client.current_folder, 'lib')
    command = os.sep.join([".", "bin", "say_hello"])
    client.run_command("%s %s" % (ld_path, command))
    msg = "Hello" if lang == 0 else "Hola"
    tester.assertIn("%s Hello0" % msg, client.out)
    conan_info_path = os.path.join(client.current_folder, CONANINFO)
    conan_info = ConanInfo.loads(load(conan_info_path))
    tester.assertTrue(conan_info.full_options.language == lang)
    if static:
        tester.assertTrue(conan_info.full_options.static)
    else:
        tester.assertFalse(conan_info.full_options.static)
Esempio n. 57
0
    def _build(self, cmd, static, pure_c, use_cmake, lang):
        client = TestClient()
        dll_export = 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)

        client.save(files)
        client.run(cmd)
        client.run('build .')
        ld_path = ("LD_LIBRARY_PATH=`pwd`"
                   if not static and not platform.system() == "Windows" else "")
        command = os.sep.join([".", "bin", "say_hello"])
        client.runner("%s %s" % (ld_path, command), cwd=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. 58
0
    def install_profile_env_test(self):
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] = conanfile_scope_env

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

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

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

        # Override package var with package var
        self.client.run("install Hello0/0.1@lasote/stable --build -pr envs -e Hello0:A_VAR=OTHER_VALUE -e Hello0:OTHER_VAR=3")
        self._assert_env_variable_printed("A_VAR", "OTHER_VALUE")
        self._assert_env_variable_printed("OTHER_VAR", "3")
Esempio n. 59
0
    def install_outdated_test(self):
        # If we try to install the same package with --build oudated it's already ok
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertIn("Hello0/0.1@lasote/stable: Package is up to date",
                      self.client.user_io.out)

        # Then we can export a modified recipe and try to install without --build outdated
        files = cpp_hello_conan_files("Hello0", "0.1", build=False)
        files["conanfile.py"] += "\n#Otherline"
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run("install Hello0/0.1@lasote/stable")
        self.assertIn("Hello0/0.1@lasote/stable: Already installed!",
                      self.client.user_io.out)
        self.assertNotIn("Package is up to date", self.client.user_io.out)
        self.assertNotIn("Outdated package!", self.client.user_io.out)

        # Try now with the --build outdated
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertNotIn("Package is up to date", self.client.user_io.out)
        self.assertIn("Outdated package!", self.client.user_io.out)
        self.assertIn("Building your package", self.client.user_io.out)

        # Remove all local references, export again (the modified version not uploaded)
        # and try to install, it will discard the remote package too
        self.client.run("remove Hello0* -f")
        self.client.save(files)
        self.client.run("export . lasote/stable")
        self.client.run("remote add_ref Hello0/0.1@lasote/stable default")
        self.client.run("install Hello0/0.1@lasote/stable --build outdated")
        self.assertNotIn("Hello0/0.1@lasote/stable: Already installed!",
                         self.client.user_io.out)
        self.assertNotIn("Package is up to date", self.client.user_io.out)

        # With revisions it looks in the server a package for the changed local recipe and it
        # doesn't find it, so there is no Outdated package alert, just building
        if not self.client.revisions:
            self.assertIn("Outdated package!", self.client.user_io.out)
        self.assertIn("Building your package", self.client.user_io.out)
Esempio n. 60
0
    def _create(self, number, version, deps=None, deps_dev=None, export=True):
        files = cpp_hello_conan_files(number, version, deps, build=False)
        files[CONANFILE] = files[CONANFILE].replace("config(", "configure(")
        if deps_dev:
            files[CONANFILE] = files[CONANFILE].replace(
                "exports = '*'", """exports = '*'
    dev_requires=%s
""" % ",".join('"%s"' % d for d in deps_dev))

        self.client.save(files, clean_first=True)
        if export:
            self.client.run("export . lasote/stable")
            expected_output = textwrap.dedent("""\
                [HOOK - attribute_checker.py] pre_export(): WARN: Conanfile doesn't have 'url'. It is recommended to add it as attribute
                [HOOK - attribute_checker.py] pre_export(): WARN: Conanfile doesn't have 'license'. It is recommended to add it as attribute
                [HOOK - attribute_checker.py] pre_export(): WARN: Conanfile doesn't have 'description'. It is recommended to add it as attribute
                """)
            self.assertIn(expected_output, self.client.out)

        if number != "Hello2":
            files[CONANFILE] = files[CONANFILE].replace(
                'version = "0.1"', 'version = "0.1"\n'
                '    url= "myurl"\n'
                '    license = "MIT"\n'
                '    description = "blah"')
        else:
            files[CONANFILE] = files[CONANFILE].replace(
                'version = "0.1"', 'version = "0.1"\n'
                '    url= "myurl"\n'
                '    license = "MIT", "GPL"\n'
                '    description = """Yo no creo en brujas,\n'
                '                 pero que las hay,\n'
                '                 las hay"""')

        self.client.save(files)
        if export:
            self.client.run("export . lasote/stable")
            self.assertNotIn("WARN: Conanfile doesn't have 'url'",
                             self.client.out)