def upload_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files["conanfile.py"] = files["conanfile.py"].replace( "def build(", "def build2(") self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) self.client.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", self.client.user_io.out) # The remote, once fixed does not change self.client.run("upload %s -r=remote1" % str(conan_reference)) self.client.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", self.client.user_io.out) # Now install it in other machine from remote 0 client2 = TestClient(servers=self.servers, users=self.users) client2.run("install %s --build=missing" % str(conan_reference)) client2.run("info %s" % str(conan_reference)) self.assertIn("remote0=http://", client2.user_io.out) # Now install it in other machine from remote 1 servers = self.servers.copy() servers.pop("remote0") client3 = TestClient(servers=servers, users=self.users) client3.run("install %s --build=missing" % str(conan_reference)) client3.run("info %s" % str(conan_reference)) self.assertIn("remote1=http://", client3.user_io.out)
def 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={"default":[("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={"default":[("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
def conan_test_test(self): '''Checks --build in test command''' client_a = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")], "local": [("lasote", "mypass")]}) client_b = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")], "local": [("lasote", "mypass")]}) # Upload Hello0 to local and default from client_a self._create(client_a, "Hello0", "0.0") client_a.run("upload Hello0/0.0@lasote/stable -r local") client_a.run("upload Hello0/0.0@lasote/stable -r default") client_a.run("remote list_ref") self.assertIn("Hello0/0.0@lasote/stable: local", str(client_a.user_io.out)) sleep(1) # For timestamp and updates checks # Download Hello0 from local with client_b client_b.run("install Hello0/0.0@lasote/stable -r local --build missing") client_b.run("remote list_ref") self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out)) # Update Hello0 with client_a and reupload self._create(client_a, "Hello0", "0.0", modifier="\n") client_a.run("upload Hello0/0.0@lasote/stable -r local") # Execute info method in client_b, should advise that there is an update client_b.run("info Hello0/0.0@lasote/stable -u") self.assertIn("Updates: There is a newer version (local)", str(client_b.user_io.out)) # Now try to update the package with install -u client_b.run("remote list_ref") self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out)) client_b.run("install Hello0/0.0@lasote/stable -u --build") self.assertIn("Hello0/0.0@lasote/stable: Retrieving from remote 'local'", str(client_b.user_io.out)) client_b.run("remote list_ref") self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out)) # Upload a new version from client A, but only to the default server (not the ref-listed) # Upload Hello0 to local and default from client_a sleep(1) # For timestamp and updates checks self._create(client_a, "Hello0", "0.0", modifier="\n\n") client_a.run("upload Hello0/0.0@lasote/stable -r default") # Now client_b checks for updates without -r parameter client_b.run("info Hello0/0.0@lasote/stable") self.assertIn("Remote: local", str(client_b.user_io.out)) self.assertIn("You have the latest version (local)", str(client_b.user_io.out)) # But if we connect to default, should tell us that there is an update IN DEFAULT! client_b.run("info Hello0/0.0@lasote/stable -r default") self.assertIn("Remote: local", str(client_b.user_io.out)) self.assertIn("There is a newer version (default)", str(client_b.user_io.out)) client_b.run("remote list_ref") self.assertIn("Hello0/0.0@lasote/stable: local", str(client_b.user_io.out)) # Well, now try to update the package with -r default -u client_b.run("install Hello0/0.0@lasote/stable -r default -u --build") self.assertIn("Hello0/0.0@lasote/stable: Retrieving from remote 'default'", str(client_b.user_io.out)) client_b.run("info Hello0/0.0@lasote/stable") self.assertIn("Updates: The local file is newer than remote's one (local)", str(client_b.user_io.out))
def reuse_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1", build=False) client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) client.save(files) client.run("export lasote/stable") client.run("upload %s" % str(conan_reference)) gen_reference = ConanFileReference.loads( "MyCustomGen/0.2@lasote/stable") files = {CONANFILE: generator} client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) client.save(files) client.run("export lasote/stable") client.run("upload %s" % str(gen_reference)) # Test local, no retrieval files = {CONANFILE_TXT: consumer} client.save(files, clean_first=True) client.run("install --build") generated = load(os.path.join(client.current_folder, "customfile.gen")) self.assertEqual(generated, "My custom generator content") # Test retrieval from remote client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files = {CONANFILE_TXT: consumer} client.save(files) client.run("install --build") generated = load(os.path.join(client.current_folder, "customfile.gen")) self.assertEqual(generated, "My custom generator content")
def setUp(self): test_server = TestServer() self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self.package_ids = self._upload_some_packages(self.client) self.new_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
def reuse_test(self): self._export_upload("hello0/0.1@lasote/stable") self._export_upload("hello1/0.1@lasote/stable", 1, [0]) self._export_upload("hello2/0.1@lasote/stable", 2, [0]) self._export_upload("hello3/0.1@lasote/stable", 3, [1, 2]) client = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable") files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go') client.save(files3) os.chdir(client.current_folder) client.run("install --build missing") client.run("build") command = os.sep.join([".", "bin", "say_hello"]) with CustomEnvPath(paths_to_add=['$GOPATH/bin'], var_to_add=[('GOPATH', client.current_folder), ]): client.runner('go install hello4_main', os.path.join(client.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client.runner(command, os.path.join(client.current_folder, 'bin')) self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'], str(client.user_io.out).splitlines()[-6:]) # Try to upload and reuse the binaries client.run("upload hello3/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client.run("upload hello1/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client.run("upload hello2/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) client.run("upload hello0/0.1@lasote/stable --all") self.assertEqual(str(client.user_io.out).count("Uploading package"), 1) # client2 = TestClient(servers=self.servers, users=[("lasote", "mypass")]) # Mocked userio conan_reference = ConanFileReference.loads("hello4/0.2@lasote/stable") files3 = hello_conan_files(conan_reference=conan_reference, number=4, deps=[3], lang='go') client2.save(files3) client2.run("install --build missing") command = os.sep.join([".", "bin", "say_hello"]) with CustomEnvPath(paths_to_add=['$GOPATH/bin'], var_to_add=[('GOPATH', client2.current_folder), ]): client2.runner('go install hello4_main', os.path.join(client2.current_folder, 'src')) if platform.system() == "Windows": command = "hello4_main" else: command = './hello4_main' client2.runner(command, os.path.join(client2.current_folder, 'bin')) self.assertEqual(['Hello 4', 'Hello 3', 'Hello 1', 'Hello 0', 'Hello 2', 'Hello 0'], str(client2.user_io.out).splitlines()[-6:])
def reuse_test(self): conan_reference = ConanFileReference.loads("stringutil/0.1@lasote/stable") files = {'conanfile.py': stringutil_conanfile, 'reverse.go': reverse, 'reverse_test.go': reverse_test, 'reverse.txt': reverse, 'hello/helloreverse.txt': reverse} self.client.save(files) self.client.run("export lasote/stable") self.client.run("install %s --build missing" % str(conan_reference)) # Check compilation ok package_ids = self.client.paths.conan_packages(conan_reference) self.assertEquals(len(package_ids), 1) package_ref = PackageReference(conan_reference, package_ids[0]) self._assert_package_exists(package_ref, self.client.paths, list(files.keys())) # Upload conans self.client.run("upload %s" % str(conan_reference)) # Check that conans exists on server server_paths = self.servers["default"].paths conan_path = server_paths.export(conan_reference) self.assertTrue(os.path.exists(conan_path)) # Upload package self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check library on server self._assert_package_exists_in_server(package_ref, server_paths, list(files.keys())) # Now from other "computer" install the uploaded conans with same options (nothing) other_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) other_conan.run("install %s --build missing" % str(conan_reference)) # Build should be empty build_path = other_conan.paths.build(package_ref) self.assertFalse(os.path.exists(build_path)) # Lib should exist self._assert_package_exists(package_ref, other_conan.paths, list(files.keys())) reuse_conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) files = {'conanfile.py': reuse_conanfile, 'src/hello/main.go': main} reuse_conan.save(files) reuse_conan.run("install --build missing") with CustomEnvPath(paths_to_add=['$GOPATH/bin'], var_to_add=[('GOPATH', reuse_conan.current_folder), ]): if platform.system() == "Windows": command = "hello" else: command = './hello' reuse_conan.runner('go install hello', cwd=reuse_conan.current_folder) reuse_conan.runner(command, cwd=os.path.join(reuse_conan.current_folder, 'bin')) self.assertIn("Hello, Go!", reuse_conan.user_io.out)
def setUp(self): test_server = TestServer( [("*/*@*/*", "*")], # read permissions [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]}) self.package_ids = self._upload_some_packages(self.client) self.new_client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
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.assertIn("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
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")
def test_export_a_new_version(self): self._create_packages_and_builds() # Export an update of the same conans conan2 = TestClient(self.conan.base_folder) files2 = cpp_hello_conan_files("Hello0", "0.1") files2[CONANFILE] = "# insert comment\n %s" % files2[CONANFILE] conan2.save(files2) conan2.run("export lasote/stable") reg_path3 = conan2.paths.export(self.conan_ref) digest3 = FileTreeManifest.loads( load(conan2.paths.digestfile_conanfile(self.conan_ref))) self.assertIn( '%s: A new conanfile.py version was exported' % str(self.conan_ref), self.conan.user_io.out) self.assertIn('%s: Folder: %s' % (str(self.conan_ref), reg_path3), self.conan.user_io.out) self.assertTrue(os.path.exists(reg_path3)) for name in list(files2.keys()): self.assertTrue(os.path.exists(os.path.join(reg_path3, name))) expected_sums = { 'hello.cpp': '4f005274b2fdb25e6113b69774dac184', 'main.cpp': '0479f3c223c9a656a718f3148e044124', 'CMakeLists.txt': 'bc3405da4bb0b51a3b9f05aca71e58c8', 'conanfile.py': '6b19dfd1241712a6c694c7c397f909ce', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd' } self.assertEqual(expected_sums, digest3.file_sums)
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)
def setUp(self): test_server = TestServer( [], # write permissions users={"lasote": "mypass"}) # exported users and passwords self.servers = {"default": test_server} self.conan = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
def build_order_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 -bo=Hello0/0.1@lasote/stable") self.assertIn("[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]", self.client.user_io.out) self.client.run("info -bo=Hello1/0.1@lasote/stable") self.assertIn("[Hello1/0.1@lasote/stable]", self.client.user_io.out) self.client.run( "info -bo=Hello1/0.1@lasote/stable -bo=Hello0/0.1@lasote/stable") self.assertIn("[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]", self.client.user_io.out) self.client.run( "info Hello1/0.1@lasote/stable -bo=Hello0/0.1@lasote/stable") self.assertEqual( "[Hello0/0.1@lasote/stable], [Hello1/0.1@lasote/stable]\n", self.client.user_io.out)
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))
def reuse_test(self): client = TestClient() client.save({ CONANFILE: conanfile, "__init__.py": "", "mytest.py": test }) client.run("export lasote/stable") client.save({CONANFILE: reuse}, clean_first=True) client.run("install . -g txt -g env") content = load(os.path.join(client.current_folder, CONANENV)) self.assertIn("PYTHONPATH", content) self.assertIn("Hello Bar", client.user_io.out) self.assertNotIn("Hello Foo", client.user_io.out) client.run("build") self.assertNotIn("Hello Bar", client.user_io.out) self.assertIn("Hello Foo", client.user_io.out) client.run("export lasote/stable") client.run("install Consumer/0.1@lasote/stable --build") lines = [ line.split(":")[1] for line in str(client.user_io.out).splitlines() if line.startswith("Consumer/0.1@lasote/stable: Hello") ] self.assertEqual( [' Hello Baz', ' Hello Foo', ' Hello Boom', ' Hello Bar'], lines)
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)
def test_declared_stdlib_and_passed(self): client = TestClient() client.save(self.files) client.run("export lasote/testing") client.run( 'install -s compiler=clang -s compiler.version=3.3 -s compiler.libcxx=libstdc++ ', ignore_error=False) client.run('build') self.assertIn("-stdlib=libstdc++", str(client.user_io.out)) self.assertIn("Found Define: _GLIBCXX_USE_CXX11_ABI=0", str(client.user_io.out)) client.run('install -s compiler=clang -s compiler.libcxx=libstdc++11', ignore_error=False) client.run('build') self.assertIn("-stdlib=libstdc++", str(client.user_io.out)) self.assertIn("Found Define: _GLIBCXX_USE_CXX11_ABI=1", str(client.user_io.out)) client.run( 'install -s compiler=clang -s compiler.version=3.3 -s compiler.libcxx=libc++', ignore_error=False) client.run('build') self.assertIn("-stdlib=libc++", str(client.user_io.out)) self.assertNotIn("Found Define: _GLIBCXX_USE_CXX11", str(client.user_io.out))
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)
def basic_source_test(self): conanfile = ''' from conans import ConanFile class ConanLib(ConanFile): name = "Hello" version = "0.1" def source(self): self.output.info("Running source!") ''' client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") client.run("source Hello/0.1@lasote/stable") self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # The second call shouldn't have effect client.run("source Hello/0.1@lasote/stable") self.assertNotIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertNotIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out) # Forced should have effect client.run("source Hello/0.1@lasote/stable --force") self.assertIn("WARN: Forced removal of source folder", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Configuring sources", client.user_io.out) self.assertIn("Hello/0.1@lasote/stable: Running source!", client.user_io.out)
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)
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")
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': '05bd2ffe3ff0c35b3a1deede3264a8b6', 'executable': '68b329da9893e34099c7d8ad5cb9c940', 'helloHello0.h': '9448df034392fc8781a47dd03ae71bdd' } self.assertEqual(expected_sums, manif.file_sums)
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!")
def setUp(self): self.conan = TestClient() self.files = cpp_hello_conan_files("Hello0", "0.1") self.conan_ref = ConanFileReference("Hello0", "0.1", "lasote", "stable") self.conan.save(self.files) self.conan.run("export lasote/stable")
def 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")))
def external_python_with_simple_var_test(self): client = TestClient() conanfile_simple = """from conans import ConanFile, tools class ToolsTest(ConanFile): name = "Hello" version = "0.1" def build(self): with tools.pythonpath(self): import external external.external_baz() """ external_py = ''' def external_baz(): print("External baz") ''' external_dir = temp_folder() save(os.path.join(external_dir, "external.py"), external_py) client.save({CONANFILE: conanfile_simple}) client.run("export lasote/stable") # Should work even if PYTHONPATH is not declared as [], only external resource needed client.run( 'install Hello/0.1@lasote/stable --build missing -e PYTHONPATH="%s"' % external_dir)
def use_short_paths_test(self): client = TestClient() shorted_path = temp_folder() short_paths_refs_file = os.path.join(client.paths.conan_folder, SHORTED_REFERENCES_FILENAME) save(short_paths_refs_file, "Hello0/0.1@lasote/stable: %s" % shorted_path) files = cpp_hello_conan_files("Hello0", "0.1") client.save(files, clean_first=True) client.run("export lasote/stable") self.assertTrue(os.path.exists(os.path.join(shorted_path, "e"))) self.assertFalse(os.path.exists(os.path.join(shorted_path, "p"))) self.assertFalse(os.path.exists(os.path.join(shorted_path, "b"))) client.run("install Hello0/0.1@lasote/stable --build") self.assertTrue(os.path.exists(os.path.join(shorted_path, "p"))) self.assertTrue(os.path.exists(os.path.join(shorted_path, "b"))) sha_short = os.listdir(os.path.join(os.path.join(shorted_path, "p")))[0] self.assertEquals(len(sha_short), 6) self.assertTrue( os.path.exists(os.path.join(shorted_path, "p", sha_short, "lib"))) client.run("search Hello0*") self.assertIn("Hello0/0.1@lasote/stable", str(client.user_io.out))
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)
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])