def setUp(self):
self.servers = {
"local":
TestServer(server_capabilities=[]),
"search_able":
TestServer(server_capabilities=[COMPLEX_SEARCH_CAPABILITY])
}
self.client = TestClient(servers=self.servers)
# 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
self.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'
root_folder11 = 'Hello/1.4.11/fenix/testing'
root_folder12 = 'Hello/1.4.12/fenix/testing'
self.client.save(
{
"Empty/1.10/fake/test/reg/fake.txt":
"//",
"%s/%s/WindowsPackageSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder11, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/WindowsPackageSHA/%s" % (root_folder12, PACKAGES_FOLDER, CONANINFO):
conan_vars1,
"%s/%s/PlatformIndependantSHA/%s" % (self.root_folder1, PACKAGES_FOLDER, CONANINFO):
conan_vars1b,
"%s/%s/LinuxPackageSHA/%s" % (self.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)
# Fake some manifests to be able to calculate recipe hash
fake_manifest = FileTreeManifest(1212, {})
fake_manifest.save(
os.path.join(self.client.paths.store, self.root_folder1,
EXPORT_FOLDER))
fake_manifest.save(
os.path.join(self.client.paths.store, root_folder2, EXPORT_FOLDER))
fake_manifest.save(
os.path.join(self.client.paths.store, root_folder3, EXPORT_FOLDER))
fake_manifest.save(
os.path.join(self.client.paths.store, root_folder4, EXPORT_FOLDER))
fake_manifest.save(
os.path.join(self.client.paths.store, root_folder5, EXPORT_FOLDER))
def force_test(self):
'''Tries to upload a conans exported after than remote version.'''
# Upload all conans and packages
self.client.run('upload %s --all' % str(self.conan_ref))
if not self.client.block_v2:
rev = self.client.get_revision(self.conan_ref)
self.conan_ref = self.conan_ref.copy_with_rev(rev)
prev = self.client.get_package_revision(self.package_ref)
self.package_ref = self.package_ref.copy_with_revs(rev, prev)
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.server_pack_folder = self.test_server.paths.package(self.package_ref)
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
# Fake datetime from exported date and upload again
old_digest = self.client.paths.load_manifest(self.conan_ref)
old_digest.file_sums["new_file"] = "012345"
fake_digest = FileTreeManifest(2, old_digest.file_sums)
fake_digest.save(self.client.paths.export(self.conan_ref))
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("Remote recipe is newer than local recipe", self.client.user_io.out)
self.client.run('upload %s --force' % str(self.conan_ref))
self.assertIn("Uploading %s" % str(self.conan_ref),
self.client.user_io.out)
# Repeat transfer, to make sure it is uploading again
self.client.run('upload %s --force' % str(self.conan_ref))
self.assertIn("Uploading conan_export.tgz", self.client.out)
self.assertIn("Uploading conanfile.py", self.client.out)
def _upload_recipe(self,
conan_reference,
base_files=None,
retry=1,
retry_wait=0):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
content = """
from conans import ConanFile
class MyConan(ConanFile):
name = "%s"
version = "%s"
settings = arch, compiler, os
""" % (conan_reference.name, conan_reference.version)
files[CONANFILE] = content
files_md5s = {
filename: md5(content)
for filename, content in files.items()
}
conan_digest = FileTreeManifest(123123123, files_md5s)
tmp_dir = temp_folder()
abs_paths = {}
for filename, content in files.items():
abs_path = os.path.join(tmp_dir, filename)
save(abs_path, content)
abs_paths[filename] = abs_path
abs_paths[CONAN_MANIFEST] = os.path.join(tmp_dir, CONAN_MANIFEST)
conan_digest.save(tmp_dir)
self.api.upload_recipe(conan_reference, abs_paths, retry, retry_wait,
False, None)
def _upload_recipe(self, ref, base_files=None, retry=1, retry_wait=0):
files = {"conanfile.py": GenConanfile("3").with_requires("1", "12")}
if base_files:
files.update(base_files)
content = """
from conans import ConanFile
class MyConan(ConanFile):
name = "%s"
version = "%s"
settings = arch, compiler, os
""" % (ref.name, ref.version)
files[CONANFILE] = content
files_md5s = {filename: md5(content) for filename, content in files.items()}
conan_digest = FileTreeManifest(123123123, files_md5s)
tmp_dir = temp_folder()
abs_paths = {}
for filename, content in files.items():
abs_path = os.path.join(tmp_dir, filename)
save(abs_path, content)
abs_paths[filename] = abs_path
abs_paths[CONAN_MANIFEST] = os.path.join(tmp_dir, CONAN_MANIFEST)
conan_digest.save(tmp_dir)
self.api.upload_recipe(ref, abs_paths, None, retry, retry_wait)
def setUp(self):
servers = {}
# All can write (for avoid authentication until we mock user_io)
self.test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")],
users={"lasote": "mypass"})
servers["default"] = self.test_server
conan_digest = FileTreeManifest('123123123', {})
self.client = TestClient(servers=servers,
users={"default": [("lasote", "mypass")]})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn(
"There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(
self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"),
"//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(
os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin",
"executable")).st_mode | stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(
self.package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def deploy_manifest_content(self, copied_files):
date = calendar.timegm(time.gmtime())
file_dict = {}
for f in copied_files:
abs_path = os.path.join(self.output_path, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
return repr(manifest)
def deploy_manifest_content(self, copied_files):
date = timestamp_now()
file_dict = {}
for f in copied_files:
abs_path = os.path.join(self.output_path, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
return repr(manifest)
def setUp(self):
self.client = self._get_client()
conan_digest = FileTreeManifest('123123123', {})
self.conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = self.client.paths.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn(
"There is no local conanfile exported as %s" % str(self.conan_ref),
self.client.user_io.out)
files = hello_source_files()
self.client.save(files, path=reg_folder)
self.client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
exports_sources_dir = os.path.join(reg_folder, EXPORT_SOURCES_DIR)
os.makedirs(exports_sources_dir)
self.package_ref = PackageReference(self.conan_ref, "myfakeid")
self.server_pack_folder = self.test_server.paths.package(
self.package_ref)
package_folder = self.client.paths.package(self.package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
save(os.path.join(package_folder, "bin", "my_bin", "executable"),
"//bin")
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
os.chmod(
os.path.join(package_folder, "bin", "my_bin", "executable"),
os.stat(os.path.join(package_folder, "bin", "my_bin",
"executable")).st_mode | stat.S_IRWXU)
digest_path = self.client.client_cache.digestfile_package(
self.package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
self.server_reg_folder = self.test_server.paths.export(self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
def _report_save_manifest(copied_files, output, dest_folder, manifest_name):
report_copied_files(copied_files, output)
if copied_files:
date = calendar.timegm(time.gmtime())
file_dict = {}
for f in copied_files:
abs_path = os.path.join(dest_folder, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
manifest.save(dest_folder, manifest_name)
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)
# Fake some manifests to be able to calculate recipe hash
fake_manifest = FileTreeManifest(1212, {})
self.client.save(
{
os.path.join(root_folder1, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder2, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder3, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
os.path.join(root_folder4, EXPORT_FOLDER, CONAN_MANIFEST):
str(fake_manifest),
}, self.client.paths.store)
def run_imports(conanfile, current_path, output):
file_importer = FileImporter(conanfile, current_path)
conanfile.copy = file_importer
conanfile.imports()
copied_files = file_importer.execute()
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
if copied_files:
date = calendar.timegm(time.gmtime())
file_dict = {}
for f in copied_files:
abs_path = os.path.join(current_path, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
save(os.path.join(current_path, IMPORTS_MANIFESTS), str(manifest))
return copied_files
def run_imports(conanfile, current_path, output):
file_importer = FileImporter(conanfile, current_path)
conanfile.copy = file_importer
# FIXME: The environment has to be properly defined even for "conan imports"
with environment_append(conanfile.env or []):
conanfile.imports()
copied_files = file_importer.execute()
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
if copied_files:
date = calendar.timegm(time.gmtime())
file_dict = {}
for f in copied_files:
abs_path = os.path.join(current_path, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
save(os.path.join(current_path, IMPORTS_MANIFESTS), str(manifest))
return copied_files
def run_imports(conanfile, dest_folder, output):
file_importer = _FileImporter(conanfile, dest_folder)
conanfile.copy = file_importer
conanfile.imports_folder = dest_folder
with environment_append(conanfile.env):
conanfile.imports()
copied_files = file_importer.copied_files
import_output = ScopedOutput("%s imports()" % output.scope, output)
report_copied_files(copied_files, import_output)
if copied_files:
date = calendar.timegm(time.gmtime())
file_dict = {}
for f in copied_files:
abs_path = os.path.join(dest_folder, f)
file_dict[f] = md5sum(abs_path)
manifest = FileTreeManifest(date, file_dict)
save(os.path.join(dest_folder, IMPORTS_MANIFESTS), str(manifest))
return copied_files
def force_test(self):
'''Tries to upload a conans exported after than remote version.'''
# Upload all conans and packages
self.client.run('upload %s --all' % str(self.conan_ref))
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
# Fake datetime from exported date and upload again
old_digest = self.client.paths.load_manifest(self.conan_ref)
old_digest.file_sums["new_file"] = "012345"
fake_digest = FileTreeManifest(2, old_digest.file_sums)
fake_digest.save(self.client.paths.export(self.conan_ref))
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("Remote recipe is newer than local recipe", self.client.user_io.out)
self.client.run('upload %s --force' % str(self.conan_ref))
self.assertIn("Uploading %s" % str(self.conan_ref),
self.client.user_io.out)
def force_test(self):
'''Tries to upload a conans exported after than remote version.'''
# Upload all conans and packages
self.client.run('upload %s --all' % str(self.conan_ref))
self.assertTrue(os.path.exists(self.server_reg_folder))
self.assertTrue(os.path.exists(self.server_pack_folder))
# Fake datetime from exported date and upload again
digest_path = os.path.join(self.client.paths.export(self.conan_ref), CONAN_MANIFEST)
old_digest = self.client.paths.load_digest(self.conan_ref)
fake_digest = FileTreeManifest(2, old_digest.file_sums)
save(digest_path, str(fake_digest))
self.client.run('upload %s' % str(self.conan_ref), ignore_error=True)
self.assertIn("Remote conans is newer than local conans", self.client.user_io.out)
self.client.run('upload %s --force' % str(self.conan_ref))
self.assertIn("Uploading %s" % str(self.conan_ref),
self.client.user_io.out)
def _upload_conan(self, conan_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
content = """
from conans import ConanFile
class MyConan(ConanFile):
name = "%s"
version = "%s"
settings = arch, compiler, os
""" % (conan_reference.name, conan_reference.version)
files[CONANFILE] = content
files_md5s = {
filename: md5(content)
for filename, content in files.items()
}
conan_digest = FileTreeManifest(123123123, files_md5s)
files[CONAN_MANIFEST] = str(conan_digest)
self.api.upload_conan(conan_reference, files)
def force_test(self):
# Tries to upload a package exported after than remote version.
# Upload all recipes and packages
self.client.run('upload %s --all' % str(self.ref))
if self.client.cache.config.revisions_enabled:
layout = self.client.cache.package_layout(self.ref)
rev = layout.recipe_revision()
self.ref = self.ref.copy_with_rev(rev)
prev = layout.package_revision(self.pref)
self.pref = self.pref.copy_with_revs(rev, prev)
self.server_reg_folder = self.test_server.server_store.export(self.ref)
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))
# Fake datetime from exported date and upload again
old_digest = self.client.cache.package_layout(
self.ref).recipe_manifest()
old_digest.file_sums["new_file"] = "012345"
fake_digest = FileTreeManifest(2, old_digest.file_sums)
fake_digest.save(self.client.cache.package_layout(self.ref).export())
self.client.run('upload %s' % str(self.ref), assert_error=True)
self.assertIn("Remote recipe is newer than local recipe",
self.client.out)
self.client.run('upload %s --force' % str(self.ref))
self.assertIn("Uploading %s" % str(self.ref), self.client.out)
# Repeat transfer, to make sure it is uploading again
self.client.run('upload %s --force' % str(self.ref))
self.assertIn("Uploading conan_export.tgz", self.client.out)
self.assertIn("Uploading conanfile.py", self.client.out)
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"
},
path=reg_folder)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
client.remote_manager.upload_conan(conan_ref)
client.remote_manager.upload_package(package_ref)
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
loader = ConanFileLoader(TestBufferConanOutput(), None, Settings(),
OptionsValues.loads(""))
installer = ConanInstaller(client2.paths, client2.user_io, loader,
client2.remote_manager, "default")
installer.retrieve_conanfile(conan_ref)
installer._retrieve_remote_package(package_ref)
reg_path = client2.paths.export(
ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# 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(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "include", "lib1.h")))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "lib", "my_lib/libd.a")))
self.assertTrue(
os.path.exists(
os.path.join(pack_folder, "res", "shares/readme.txt")))
def complete_test(self):
""" basic installation of a new conans
"""
servers = {}
# All can write (for avoid authentication until we mock user_io)
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers["default"] = test_server
conan_digest = FileTreeManifest(123123123, {})
client = TestClient(servers=servers)
client.init_dynamic_vars()
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.paths.export(conan_ref)
files = hello_source_files()
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONAN_MANIFEST: str(conan_digest),
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy"
},
path=reg_folder)
exports_sources_dir = client.paths.export_sources(conan_ref)
os.makedirs(exports_sources_dir)
package_ref = PackageReference(conan_ref, "fakeid")
package_folder = client.paths.package(package_ref)
save(os.path.join(package_folder, CONANINFO), "info")
save(os.path.join(package_folder, CONAN_MANIFEST), "manifest")
save(os.path.join(package_folder, "include", "lib1.h"), "//header")
save(os.path.join(package_folder, "lib", "my_lib", "libd.a"), "//lib")
save(os.path.join(package_folder, "res", "shares", "readme.txt"),
"//res")
digest_path = client.client_cache.digestfile_package(package_ref)
expected_manifest = FileTreeManifest.create(
os.path.dirname(digest_path))
save(os.path.join(package_folder, CONAN_MANIFEST),
str(expected_manifest))
client.run("upload %s" % str(conan_ref))
client.run("upload %s -p %s" %
(str(conan_ref), package_ref.package_id))
client2 = TestClient(servers=servers)
client2.init_dynamic_vars()
installer = ConanProxy(client2.paths, client2.user_io,
client2.remote_manager, "default")
installer.get_recipe(conan_ref)
installer.get_package(package_ref, short_paths=False)
# Check that the output is done in order
lines = [
line.strip() for line in str(client2.user_io.out).splitlines()
if line.startswith("Downloading")
]
self.assertEqual(lines, [
"Downloading conanmanifest.txt", "Downloading conanfile.py",
"Downloading conan_export.tgz", "Downloading conanmanifest.txt",
"Downloading conaninfo.txt", "Downloading conan_package.tgz"
])
reg_path = client2.paths.export(
ConanFileReference.loads("Hello/1.2.1/frodo/stable"))
pack_folder = client2.paths.package(package_ref)
# 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(reg_path, _file)))
self.assertTrue(os.path.exists(pack_folder))
# Test the file in the downloaded package
self.assertTrue(os.path.exists(pack_folder))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "include", "lib1.h")))
self.assertTrue(
os.path.exists(os.path.join(pack_folder, "lib", "my_lib/libd.a")))
self.assertTrue(
os.path.exists(
os.path.join(pack_folder, "res", "shares/readme.txt")))
