def uncompress_packaged_files(paths, package_reference):
package_path = paths.package(package_reference)
if not(os.path.exists(os.path.join(package_path, PACKAGE_TGZ_NAME))):
raise ConanException("%s not found in %s" % (PACKAGE_TGZ_NAME, package_path))
tmp = temp_folder()
untargz(os.path.join(package_path, PACKAGE_TGZ_NAME), tmp)
return tmp
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 uncompress_packaged_files(paths, pref):
rev = paths.get_last_revision(pref.ref).revision
prev = paths.get_last_package_revision(pref.copy_with_revs(rev, None)).revision
pref = pref.copy_with_revs(rev, prev)
package_path = paths.package(pref)
if not(os.path.exists(os.path.join(package_path, PACKAGE_TGZ_NAME))):
raise ConanException("%s not found in %s" % (PACKAGE_TGZ_NAME, package_path))
tmp = temp_folder()
untargz(os.path.join(package_path, PACKAGE_TGZ_NAME), tmp)
return tmp
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)
