def simple_test(self): """ basic installation of a new conans """ # Try to upload an package without upload conans first self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)), ignore_error=True) self.assertIn("There are no remote conanfiles like %s" % str(self.conan_ref), self.client.user_io.out) # Upload conans self.client.run('upload %s' % str(self.conan_ref)) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertFalse(os.path.exists(self.server_pack_folder)) # Upload package self.client.run('upload %s -p %s' % (str(self.conan_ref), str(self.package_ref.package_id))) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Test the file in the downloaded conans files = ['CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt', 'my_bin/executable'] self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, CONANFILE))) self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME), tmp) for f in files: if f not in (CONANFILE, CONAN_MANIFEST): self.assertTrue(os.path.exists(os.path.join(tmp, f))) else: self.assertFalse(os.path.exists(os.path.join(tmp, f))) folder = uncompress_packaged_files(self.test_server.paths, self.package_ref) self.assertTrue(os.path.exists(os.path.join(folder, "include", "lib1.h"))) self.assertTrue(os.path.exists(os.path.join(folder, "lib", "my_lib/libd.a"))) self.assertTrue(os.path.exists(os.path.join(folder, "res", "shares/readme.txt"))) if platform.system() != "Windows": self.assertEqual(os.stat(os.path.join(folder, "bin", "my_bin/executable")).st_mode & stat.S_IRWXU, stat.S_IRWXU)
def simple_test(self): """ basic installation of a new conans """ # Upload conans self.client.run('upload %s' % str(self.ref)) self.server_reg_folder = self.test_server.server_store.export(self.ref) self.assertTrue(os.path.exists(self.server_reg_folder)) if not self.client.cache.config.revisions_enabled: self.assertFalse(os.path.exists(self.server_pack_folder)) # Upload package self.client.run('upload %s -p %s' % (str(self.ref), str(self.pref.id))) self.server_pack_folder = self.test_server.server_store.package(self.pref) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Test the file in the downloaded conans files = ['CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt', 'my_bin/executable'] self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, CONANFILE))) self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(self.server_reg_folder, EXPORT_TGZ_NAME), tmp) for f in files: if f not in (CONANFILE, CONAN_MANIFEST): self.assertTrue(os.path.exists(os.path.join(tmp, f))) else: self.assertFalse(os.path.exists(os.path.join(tmp, f))) folder = uncompress_packaged_files(self.test_server.server_store, self.pref) self.assertTrue(os.path.exists(os.path.join(folder, "include", "lib1.h"))) self.assertTrue(os.path.exists(os.path.join(folder, "lib", "my_lib/libd.a"))) self.assertTrue(os.path.exists(os.path.join(folder, "res", "shares/readme.txt"))) if platform.system() != "Windows": self.assertEqual(os.stat(os.path.join(folder, "bin", "my_bin/executable")).st_mode & stat.S_IRWXU, stat.S_IRWXU)
def simple_test(self): """ basic installation of a new conans """ # Try to upload an package without upload conans first self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)), ignore_error=True) self.assertIn("There are no remote conanfiles like %s" % str(self.conan_ref), self.client.user_io.out) # Upload conans self.client.run('upload %s' % str(self.conan_ref)) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertFalse(os.path.exists(self.server_pack_folder)) # Upload package self.client.run('upload %s -p %s' % (str(self.conan_ref), str(self.package_ref.package_id))) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Test the file in the downloaded conans files = ['CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt'] for _file in files: self.assertTrue(os.path.exists(os.path.join(self.server_reg_folder, _file))) folder = uncompress_packaged_files(self.test_server.paths, self.package_ref) self.assertTrue(os.path.exists(os.path.join(folder, "include", "lib1.h"))) self.assertTrue(os.path.exists(os.path.join(folder, "lib", "my_lib/libd.a"))) self.assertTrue(os.path.exists(os.path.join(folder, "res", "shares/readme.txt")))
def test_upload_only_tgz_if_needed(): client = TestClient(default_server_user=True) ref = ConanFileReference.loads("Hello0/0.1@user/stable") files = cpp_hello_conan_files("Hello0", "0.1", need_patch=True, build=False) files["lib/another_export_file.lib"] = "to compress" client.save(files) client.run("create . user/stable") # Upload conans client.run("upload %s" % str(ref)) assert "Compressing recipe" in client.out # Not needed to tgz again client.run("upload %s" % str(ref)) assert "Compressing recipe" not in client.out # Check that conans exists on server server_paths = client.servers["default"].server_store conan_path = server_paths.conan_revisions_root(ref) assert os.path.exists(conan_path) package_ids = client.cache.package_layout(ref).package_ids() pref = PackageReference(ref, package_ids[0]) # Upload package client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) assert "Compressing package" in client.out # Not needed to tgz again client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) assert "Compressing package" not in client.out # If we install the package again will be removed and re tgz client.run("install %s --build missing" % str(ref)) # Upload package client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) assert "Compressing package" not in client.out # Check library on server folder = uncompress_packaged_files(server_paths, pref) libraries = os.listdir(os.path.join(folder, "lib")) assert len(libraries) == 1
def simple_test(self): """ basic installation of a new conans """ # Try to upload an package without upload conans first self.client.run('upload %s -p %s' % (self.conan_ref, str(self.package_ref.package_id)), ignore_error=True) self.assertIn( "There are no remote conanfiles like %s" % str(self.conan_ref), self.client.user_io.out) # Upload conans self.client.run('upload %s' % str(self.conan_ref)) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertFalse(os.path.exists(self.server_pack_folder)) # Upload package self.client.run( 'upload %s -p %s' % (str(self.conan_ref), str(self.package_ref.package_id))) self.assertTrue(os.path.exists(self.server_reg_folder)) self.assertTrue(os.path.exists(self.server_pack_folder)) # Test the file in the downloaded conans files = [ 'CMakeLists.txt', 'my_lib/debug/libd.a', 'hello.cpp', 'hello0.h', CONANFILE, CONAN_MANIFEST, 'main.cpp', 'include/math/lib1.h', 'my_data/readme.txt' ] for _file in files: self.assertTrue( os.path.exists(os.path.join(self.server_reg_folder, _file))) folder = uncompress_packaged_files(self.test_server.paths, self.package_ref) self.assertTrue( os.path.exists(os.path.join(folder, "include", "lib1.h"))) self.assertTrue( os.path.exists(os.path.join(folder, "lib", "my_lib/libd.a"))) self.assertTrue( os.path.exists(os.path.join(folder, "res", "shares/readme.txt")))
def upload_test(self): conan_reference = ConanFileReference.loads( "Hello0/0.1@lasote/stable#%s" % DEFAULT_REVISION_V1) files = cpp_hello_conan_files("Hello0", "0.1") files["to_be_deleted.txt"] = "delete me" files["to_be_deleted2.txt"] = "delete me2" remote_paths = self.client.servers["default"].server_store self.client.save(files) self.client.run("export . lasote/stable") # Upload conan file self.client.run("upload %s" % str(conan_reference)) # Verify the files are there if not self.client.block_v2: rev = self.client.get_revision(conan_reference) conan_reference = conan_reference.copy_with_rev(rev) server_conan_path = remote_paths.export(conan_reference) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")), "delete me") self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "delete me2") # Now delete local files export and upload and check that they are not in server os.remove(os.path.join(self.client.current_folder, "to_be_deleted.txt")) self.client.run("export . lasote/stable") self.client.run("upload %s" % str(conan_reference)) if not self.client.block_v2: rev = self.client.get_revision(conan_reference) conan_reference = conan_reference.copy_with_rev(rev) server_conan_path = remote_paths.export(conan_reference) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) self.assertTrue(os.path.exists(os.path.join(tmp, "to_be_deleted2.txt"))) # Now modify a file, and delete other, and put a new one. files["to_be_deleted2.txt"] = "modified content" files["new_file.lib"] = "new file" del files["to_be_deleted.txt"] self.client.save(files) self.client.run("export . lasote/stable") self.client.run("upload %s" % str(conan_reference)) if not self.client.block_v2: rev = self.client.get_revision(conan_reference) conan_reference = conan_reference.copy_with_rev(rev) server_conan_path = remote_paths.export(conan_reference) # Verify all is correct self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "modified content") self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file") self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) ########################## # Now try with the package ########################## self.client.run("install %s --build missing" % str(conan_reference)) # Upload package package_ids = self.client.client_cache.conan_packages(conan_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check that conans exists on server package_reference = PackageReference(conan_reference, str(package_ids[0])) package_server_path = remote_paths.package(package_reference) self.assertTrue(os.path.exists(package_server_path)) # Add a new file to package (artificially), upload again and check pack_path = self.client.client_cache.package(package_reference) new_file_source_path = os.path.join(pack_path, "newlib.lib") save(new_file_source_path, "newlib") os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz self._create_manifest(package_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) # Now modify the file and check again save(new_file_source_path, "othercontent") self._create_manifest(package_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) self.assertTrue(load(remote_file_path), "othercontent") # Now delete the file and check again os.remove(new_file_source_path) self._create_manifest(package_reference) os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") # With revisions makes no sense because there is a new revision always that sources change if not self.client.revisions: self.assertFalse(os.path.exists(remote_file_path)) self.assertNotEquals(remote_file_path, new_file_source_path)
def upload_test(self): client = TestClient(servers={"default": TestServer()}, users={"default": [("lasote", "mypass")]}) ref = ConanFileReference.loads("Hello0/0.1@lasote/stable#%s" % DEFAULT_REVISION_V1) files = cpp_hello_conan_files("Hello0", "0.1", build=False) files["to_be_deleted.txt"] = "delete me" files["to_be_deleted2.txt"] = "delete me2" remote_paths = client.servers["default"].server_store client.save(files) client.run("export . lasote/stable") # Upload conan file client.run("upload %s" % str(ref)) # Verify the files are there if client.cache.config.revisions_enabled: rev = client.cache.package_layout(ref).recipe_revision() ref = ref.copy_with_rev(rev) server_conan_path = remote_paths.export(ref) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")), "delete me") self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "delete me2") # Now delete local files export and upload and check that they are not in server os.remove(os.path.join(client.current_folder, "to_be_deleted.txt")) client.run("export . lasote/stable") client.run("upload %s" % str(ref)) if client.cache.config.revisions_enabled: rev = client.cache.package_layout(ref).recipe_revision() ref = ref.copy_with_rev(rev) server_conan_path = remote_paths.export(ref) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) self.assertTrue(os.path.exists(os.path.join(tmp, "to_be_deleted2.txt"))) # Now modify a file, and delete other, and put a new one. files["to_be_deleted2.txt"] = "modified content" files["new_file.lib"] = "new file" del files["to_be_deleted.txt"] client.save(files) client.run("export . lasote/stable") client.run("upload %s" % str(ref)) if client.cache.config.revisions_enabled: rev = client.cache.package_layout(ref).recipe_revision() ref = ref.copy_with_rev(rev) server_conan_path = remote_paths.export(ref) # Verify all is correct self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "modified content") self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file") self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) ########################## # Now try with the package ########################## client.run("install %s --build missing" % str(ref)) # Upload package package_ids = client.cache.package_layout(ref).conan_packages() client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) # Check that package exists on server pref = PackageReference(ref, str(package_ids[0])) prev = remote_paths.get_last_package_revision(pref) pref = pref.copy_with_revs(pref.ref.revision, prev.revision) package_server_path = remote_paths.package(pref) self.assertTrue(os.path.exists(package_server_path)) # Add a new file to package (artificially), upload again and check pack_path = client.cache.package_layout(pref.ref).package(pref) new_file_source_path = os.path.join(pack_path, "newlib.lib") save(new_file_source_path, "newlib") os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz self._create_manifest(client, pref) client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, pref) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) # Now modify the file and check again save(new_file_source_path, "othercontent") self._create_manifest(client, pref) client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, pref) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) self.assertTrue(load(remote_file_path), "othercontent") # Now delete the file and check again os.remove(new_file_source_path) self._create_manifest(client, pref) os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz client.run("upload %s -p %s" % (str(ref), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, pref) remote_file_path = os.path.join(folder, "newlib.lib") # With revisions makes no sense because there is a new revision always that sources change if not client.cache.config.revisions_enabled: self.assertFalse(os.path.exists(remote_file_path)) self.assertNotEqual(remote_file_path, new_file_source_path)
def _assert_library_exists_in_server(self, package_ref, paths): folder = uncompress_packaged_files(paths, package_ref) self._assert_library_files(folder)
def _assert_package_exists_in_server(self, package_ref, paths, files): folder = uncompress_packaged_files(paths, package_ref) real_files = scan_folder(folder) for f in files: self.assertIn(f, real_files)
def _assert_package_exists_in_server(self, pref, paths, files): folder = uncompress_packaged_files(paths, pref) real_files = scan_folder(folder) for f in files: self.assertIn(f, real_files)
def upload_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files["to_be_deleted.txt"] = "delete me" files["to_be_deleted2.txt"] = "delete me2" remote_paths = self.client.servers["default"].paths server_conan_path = remote_paths.export(conan_reference) self.client.save(files) self.client.run("export . lasote/stable") # Upload conan file self.client.run("upload %s" % str(conan_reference)) # Verify the files are there self.assertTrue(os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")), "delete me") self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "delete me2") # Now delete local files export and upload and check that they are not in server os.remove(os.path.join(self.client.current_folder, "to_be_deleted.txt")) self.client.run("export . lasote/stable") self.client.run("upload %s" % str(conan_reference)) self.assertTrue(os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) self.assertTrue(os.path.exists(os.path.join(tmp, "to_be_deleted2.txt"))) # Now modify a file, and delete other, and put a new one. files["to_be_deleted2.txt"] = "modified content" files["new_file.lib"] = "new file" del files["to_be_deleted.txt"] self.client.save(files) self.client.run("export . lasote/stable") self.client.run("upload %s" % str(conan_reference)) # Verify all is correct self.assertTrue(os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "modified content") self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file") self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) ########################## # Now try with the package ########################## self.client.run("install %s --build missing" % str(conan_reference)) # Upload package package_ids = self.client.paths.conan_packages(conan_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check that conans exists on server package_reference = PackageReference(conan_reference, str(package_ids[0])) package_server_path = remote_paths.package(package_reference) self.assertTrue(os.path.exists(package_server_path)) # Add a new file to package (artificially), upload again and check pack_path = self.client.paths.package(package_reference) new_file_source_path = os.path.join(pack_path, "newlib.lib") save(new_file_source_path, "newlib") os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz self._create_manifest(package_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) # Now modify the file and check again save(new_file_source_path, "othercontent") self._create_manifest(package_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) self.assertTrue(load(remote_file_path), "othercontent") # Now delete the file and check again os.remove(new_file_source_path) self._create_manifest(package_reference) os.unlink(os.path.join(pack_path, PACKAGE_TGZ_NAME)) # Force new tgz self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertFalse(os.path.exists(remote_file_path)) self.assertNotEquals(remote_file_path, new_file_source_path)
def upload_test(self): conan_reference = ConanFileReference.loads("Hello0/0.1@lasote/stable") files = cpp_hello_conan_files("Hello0", "0.1") files["to_be_deleted.txt"] = "delete me" files["to_be_deleted2.txt"] = "delete me2" remote_paths = self.client.servers["default"].paths server_conan_path = remote_paths.export(conan_reference) self.client.save(files) self.client.run("export lasote/stable") # Upload conan file self.client.run("upload %s" % str(conan_reference)) # Verify the files are there self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted.txt")), "delete me") self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "delete me2") # Now delete local files export and upload and check that they are not in server os.remove(os.path.join(self.client.current_folder, "to_be_deleted.txt")) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) self.assertTrue(os.path.exists(os.path.join(tmp, "to_be_deleted2.txt"))) # Now modify a file, and delete other, and put a new one. files["to_be_deleted2.txt"] = "modified content" files["new_file.lib"] = "new file" del files["to_be_deleted.txt"] self.client.save(files) self.client.run("export lasote/stable") self.client.run("upload %s" % str(conan_reference)) # Verify all is correct self.assertTrue( os.path.exists(os.path.join(server_conan_path, EXPORT_TGZ_NAME))) tmp = temp_folder() untargz(os.path.join(server_conan_path, EXPORT_TGZ_NAME), tmp) self.assertTrue(load(os.path.join(tmp, "to_be_deleted2.txt")), "modified content") self.assertTrue(load(os.path.join(tmp, "new_file.lib")), "new file") self.assertFalse(os.path.exists(os.path.join(tmp, "to_be_deleted.txt"))) ########################## # Now try with the package ########################## self.client.run("install %s --build missing" % str(conan_reference)) # Upload package package_ids = self.client.paths.conan_packages(conan_reference) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) # Check that conans exists on server package_reference = PackageReference(conan_reference, str(package_ids[0])) package_server_path = remote_paths.package(package_reference) self.assertTrue(os.path.exists(package_server_path)) # Add a new file to package (artificially), upload again and check new_file_source_path = os.path.join( self.client.paths.package(package_reference), "newlib.lib") save(new_file_source_path, "newlib") self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) # Now modify the file and check again save(new_file_source_path, "othercontent") self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertTrue(os.path.exists(remote_file_path)) self.assertTrue(load(remote_file_path), "othercontent") # Now delete the file and check again os.remove(new_file_source_path) self.client.run("upload %s -p %s" % (str(conan_reference), str(package_ids[0]))) folder = uncompress_packaged_files(remote_paths, package_reference) remote_file_path = os.path.join(folder, "newlib.lib") self.assertFalse(os.path.exists(remote_file_path)) self.assertNotEquals(remote_file_path, new_file_source_path)