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_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)
