def setUp(self):
self.conan_reference = ConanFileReference.loads(
"openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference,
"123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = DiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(
self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(
self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
def setUp(self):
self.conan_reference = ConanFileReference.loads("openssl/2.0.3@lasote/testing")
self.package_reference = PackageReference(self.conan_reference, "123123123")
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret",
timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.paths = SimplePaths(self.tmp_dir)
self.file_manager = FileManager(self.paths, adapter)
search_adapter = DiskSearchAdapter()
self.search_manager = DiskSearchManager(self.paths, search_adapter)
self.service = ConanService(authorizer, self.file_manager, "lasote")
self.search_service = SearchService(authorizer, self.search_manager, "lasote")
files = hello_source_files("test")
save_files(self.paths.export(self.conan_reference), files)
self.conan_digest = FileTreeManifest.create(self.paths.export(self.conan_reference))
conan_digest_path = os.path.join(self.paths.export(self.conan_reference), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.paths.package(self.package_reference), files)
def setUp(self):
self.ref = ConanFileReference.loads("openssl/2.0.3@lasote/testing#%s" % DEFAULT_REVISION_V1)
self.pref = PackageReference(self.ref, "123123123", DEFAULT_REVISION_V1)
self.tmp_dir = temp_folder()
read_perms = [("*/*@*/*", "*")]
write_perms = []
authorizer = BasicAuthorizer(read_perms, write_perms)
self.fake_url = "http://url"
updown_auth_manager = JWTUpDownAuthManager("secret", timedelta(seconds=200))
adapter = ServerDiskAdapter(self.fake_url, self.tmp_dir, updown_auth_manager)
self.server_store = ServerStore(storage_adapter=adapter)
self.service = ConanService(authorizer, self.server_store, "lasote")
self.search_service = SearchService(authorizer, self.server_store, "lasote")
files = hello_source_files("test")
save_files(self.server_store.export(self.ref), files)
self.server_store.update_last_revision(self.ref)
self.conan_digest = FileTreeManifest.create(self.server_store.export(self.ref))
conan_digest_path = os.path.join(self.server_store.export(self.ref), CONAN_MANIFEST)
save(conan_digest_path, str(self.conan_digest))
files = hello_source_files("package")
save_files(self.server_store.package(self.pref), files)
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, 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)
files[CONAN_MANIFEST] = str(conan_digest)
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
self.api.upload_recipe(conan_reference, abs_paths, retry, retry_wait, False)
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 setUp(self):
self.client = self._get_client()
self.conan_ref = ConanFileReference.loads(
"Hello/1.2.1@frodo/stable#%s" % DEFAULT_REVISION_V1)
reg_folder = self.client.client_cache.export(self.conan_ref)
self.client.run('upload %s' % str(self.conan_ref), assert_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,
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"
},
path=reg_folder)
mkdir(self.client.client_cache.export_sources(self.conan_ref))
manifest = FileTreeManifest.create(reg_folder)
manifest.time = '123123123'
manifest.save(reg_folder)
self.test_server.server_store.update_last_revision(self.conan_ref)
self.package_ref = PackageReference(self.conan_ref, "myfakeid",
DEFAULT_REVISION_V1)
self.server_pack_folder = self.test_server.server_store.package(
self.package_ref)
package_folder = self.client.client_cache.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),
"""[recipe_hash]\n%s""" % manifest.summary_hash)
FileTreeManifest.create(package_folder).save(package_folder)
self.test_server.server_store.update_last_package_revision(
self.package_ref)
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)
package_path = self.client.client_cache.package(self.package_ref)
expected_manifest = FileTreeManifest.create(package_path)
expected_manifest.save(package_folder)
self.server_reg_folder = self.test_server.server_store.export(
self.conan_ref)
self.assertFalse(os.path.exists(self.server_reg_folder))
self.assertFalse(os.path.exists(self.server_pack_folder))
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 _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
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
self.api.upload_package(package_reference, abs_paths, retry=1, retry_wait=0)
def _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
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
self.api.upload_package(package_reference, abs_paths, retry=1, retry_wait=0)
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 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,
"include/math/lib1.h": "//copy",
"my_lib/debug/libd.a": "//copy",
"my_data/readme.txt": "//copy",
"my_bin/executable": "//copy"}, path=reg_folder)
conan_digest.save(reg_folder)
mkdir(self.client.client_cache.export_sources(self.conan_ref))
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))
expected_manifest.save(package_folder)
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 _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.iteritems()}
conan_digest = FileTreeManifest(123123123, files_md5s)
files[CONAN_MANIFEST] = str(conan_digest)
self.api.upload_conan(conan_reference, files)
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 complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"
},
path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
output = ScopedOutput("", TestBufferConanOutput())
loader = ConanFileLoader(None, Settings(), Profile())
conanfile = loader.load_conan(conanfile_path, None)
create_package(conanfile,
build_folder,
build_folder,
package_folder,
output,
copy_info=True)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder,
CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
def _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
self.api.upload_package(package_reference, files)
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
"""
client = TestClient()
files = hello_source_files()
ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
reg_folder = client.cache.package_layout(ref).export()
client.save(files, path=reg_folder)
client.save(
{
CONANFILE: myconan1,
"infos/%s" % CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"
},
path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
pref = PackageReference(ref, "myfakeid")
build_folder = client.cache.package_layout(pref.ref).build(pref)
package_folder = client.cache.package_layout(pref.ref).package(pref)
install_folder = os.path.join(build_folder, "infos")
shutil.copytree(reg_folder, build_folder)
loader = ConanFileLoader(None, TestBufferConanOutput(),
ConanPythonRequire(None, None))
conanfile = loader.load_consumer(conanfile_path, test_profile())
run_package_method(conanfile,
None,
build_folder,
build_folder,
package_folder,
install_folder,
Mock(),
conanfile_path,
ref,
copy_info=True)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder,
CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
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, 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, force_build=False, short_paths=False, check_outdated=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")))
def complete_test(self):
""" basic installation of a new conans
"""
client = TestClient()
client.init_dynamic_vars()
files = hello_source_files()
conan_ref = ConanFileReference.loads("Hello/1.2.1/frodo/stable")
reg_folder = client.paths.export(conan_ref)
client.save(files, path=reg_folder)
client.save({CONANFILE: myconan1,
CONANINFO: "//empty",
"include/no_copy/lib0.h": "NO copy",
"include/math/lib1.h": "copy",
"include/math/lib2.h": "copy",
"include/physics/lib.hpp": "copy",
"my_lib/debug/libd.a": "copy",
"my_data/readme.txt": "copy",
"my_data/readme.md": "NO copy",
"contrib/math/math.h": "copy",
"contrib/physics/gravity.h": "copy",
"contrib/contrib.h": "copy",
"include/opencv/opencv.hpp": "copy",
"include/opencv2/opencv2.hpp": "copy",
"modules/simu/src/simu.cpp": "NO copy",
"modules/simu/include/opencv2/simu/simu.hpp": "copy",
"modules/3D/doc/readme.md": "NO copy",
"modules/3D/include/opencv2/3D/3D.hpp": "copy",
"modules/dev/src/dev.cpp": "NO copy",
"modules/dev/include/opencv2/dev/dev.hpp": "copy",
"modules/opencv_mod.hpp": "copy"}, path=reg_folder)
conanfile_path = os.path.join(reg_folder, CONANFILE)
package_ref = PackageReference(conan_ref, "myfakeid")
build_folder = client.paths.build(package_ref)
package_folder = client.paths.package(package_ref)
shutil.copytree(reg_folder, build_folder)
loader = ConanFileLoader(None, Settings(), OptionsValues.loads(""))
conanfile = loader.load_conan(conanfile_path, None)
output = ScopedOutput("", TestBufferConanOutput())
create_package(conanfile, build_folder, package_folder, output)
# test build folder
self.assertTrue(os.path.exists(build_folder))
self.assertTrue(os.path.exists(os.path.join(package_folder, CONANINFO)))
# test pack folder
self.assertTrue(os.path.exists(package_folder))
def exist(rel_path):
return os.path.exists(os.path.join(package_folder, rel_path))
# Expected files
self.assertTrue(exist("include/lib1.h"))
self.assertTrue(exist("include/lib2.h"))
self.assertTrue(exist("include/physics/lib.hpp"))
self.assertTrue(exist("include/contrib/math/math.h"))
self.assertTrue(exist("include/contrib/physics/gravity.h"))
self.assertTrue(exist("include/contrib/contrib.h"))
self.assertTrue(exist("include/opencv/opencv.hpp"))
self.assertTrue(exist("include/opencv2/opencv2.hpp"))
self.assertTrue(exist("include/opencv2/simu/simu.hpp"))
self.assertTrue(exist("include/opencv2/3D/3D.hpp"))
self.assertTrue(exist("include/opencv2/dev/dev.hpp"))
self.assertTrue(exist("lib/my_lib/libd.a"))
self.assertTrue(exist("res/shares/readme.txt"))
# Not expected files
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/opencv2/simu.hpp"))
self.assertFalse(exist("include/opencv2/3D.hpp"))
self.assertFalse(exist("include/opencv2/dev.hpp"))
self.assertFalse(exist("include/modules/simu/src/simu.cpp"))
self.assertFalse(exist("include/modules/3D/doc/readme.md"))
self.assertFalse(exist("include/modules/dev/src/dev.cpp"))
self.assertFalse(exist("include/opencv2/opencv_mod.hpp"))
self.assertFalse(exist("include/include/no_copy/lib0.h"))
self.assertFalse(exist("res/my_data/readme.md"))
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")))
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.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_conanfile(conan_ref)
installer.get_package(package_ref, force_build=False)
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 _upload_package(self, package_reference, base_files=None):
files = hello_source_files(3, [1, 12])
if base_files:
files.update(base_files)
self.api.upload_package(package_reference, files)
