def _check_conaninfo(self, client):
# Check that conaninfo is correct
ref_debug = PackageReference.loads("Pkg/0.1@user/channel:"
"f3989dcba0ab50dc5ed9b40ede202bdd7b421f09")
conaninfo = load(os.path.join(client.client_cache.package(ref_debug), "conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertIn("build_type=Debug", conaninfo)
self.assertNotIn("Release", conaninfo)
ref_release = PackageReference.loads("Pkg/0.1@user/channel:"
"ab2e9f86b4109980930cdc685f4a320b359e7bb4")
conaninfo = load(os.path.join(client.client_cache.package(ref_release), "conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertIn("build_type=Release", conaninfo)
self.assertNotIn("Debug", conaninfo)
ref_debug = PackageReference.loads("Pkg/0.1@user/channel:"
"322de4b4a41f905f6b18f454ab5f498690b39c2a")
conaninfo = load(os.path.join(client.client_cache.package(ref_debug), "conaninfo.txt"))
self.assertIn("os=Linux", conaninfo)
self.assertIn("build_type=Debug", conaninfo)
self.assertNotIn("Release", conaninfo)
ref_release = PackageReference.loads("Pkg/0.1@user/channel:"
"24c3aa2d6c5929d53bd86b31e020c55d96b265c7")
conaninfo = load(os.path.join(client.client_cache.package(ref_release), "conaninfo.txt"))
self.assertIn("os=Linux", conaninfo)
self.assertIn("build_type=Release", conaninfo)
self.assertNotIn("Debug", conaninfo)
def _check_conaninfo(self, client):
# Check that conaninfo is correct
ref_debug = PackageReference.loads("Pkg/0.1@user/channel:"
"5a67a79dbc25fd0fa149a0eb7a20715189a0d988")
conaninfo = load(os.path.join(client.client_cache.package(ref_debug), "conaninfo.txt"))
self.assertIn("build_type=Debug", conaninfo)
self.assertNotIn("Release", conaninfo)
ref_release = PackageReference.loads("Pkg/0.1@user/channel:"
"4024617540c4f240a6a5e8911b0de9ef38a11a72")
conaninfo = load(os.path.join(client.client_cache.package(ref_release), "conaninfo.txt"))
self.assertIn("build_type=Release", conaninfo)
self.assertNotIn("Debug", conaninfo)
def failure_test(self):
base = '''
from conans import ConanFile
from conans.util.files import load, save
import os
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
short_paths = True
exports = "*"
generators = "cmake"
def build(self):
self.output.info("%s/%s" % (self.conanfile_directory, self.name))
# print os.listdir(self.conanfile_directory)
path = os.path.join(self.conanfile_directory, self.name)
# print "PATH EXISTS ", os.path.exists(path)
# print os.listdir(path)
path = os.path.join(path, "myfile.txt")
# print "PATH EXISTS ", os.path.exists(path)
def package(self):
self.copy("*.txt", keep_path=False)
'''
client = TestClient()
files = {"conanfile.py": base, "lib/myfile.txt": "Hello world!"}
client.save(files)
client.run("export user/channel")
client.run("install lib/0.1@user/channel --build")
# print client.paths.store
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref,
short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
client.run("install lib/0.1@user/channel --build")
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref,
short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
def conanfile_capture_verify_manifest_folder_test(self):
files = {"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}
self.client.save(files, clean_first=True)
folder = "mymanifests"
self._capture_verify_manifest(".", folder=folder)
conanfile = """from conans import ConanFile
class ConanFileTest(ConanFile):
name = "Hello2"
version = "0.1"
"""
# Do not adjust cpu_count, it is reusing a cache
client = TestClient(base_folder=self.client.base_folder, cpu_count=False)
client.save({CONANFILE: conanfile})
client.run("export . lasote/stable")
files = {"conanfile.txt": "[requires]\nHello2/0.1@lasote/stable\nHello/0.1@lasote/stable"}
self.client.save(files)
self.client.run("install . --build missing --manifests %s" % folder)
remote = "local cache"
pref = PackageReference.loads("Hello/0.1@lasote/stable:%s" % NO_SETTINGS_PACKAGE_ID)
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(pref), self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable:%s' from %s" %
(NO_SETTINGS_PACKAGE_ID, remote), self.client.user_io.out)
output_folder = os.path.join(self.client.current_folder, folder)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(os.path.join(paths.export(self.ref), CONAN_MANIFEST)))
self.assertTrue(os.path.exists(os.path.join(paths.package(pref), CONAN_MANIFEST)))
def broken_package_tgz_test(self):
# https://github.com/conan-io/conan/issues/2854
client = self._client()
client.save({"conanfile.py": conanfile, "source.h": "my source"})
client.run("create . user/testing")
pref = PackageReference.loads("Hello0/1.2.1@user/testing:" +
NO_SETTINGS_PACKAGE_ID)
def gzopen_patched(name,
mode="r",
fileobj=None,
compresslevel=None,
**kwargs):
if name == PACKAGE_TGZ_NAME:
raise ConanException("Error gzopen %s" % name)
return gzopen_without_timestamps(name, mode, fileobj,
compresslevel, **kwargs)
with mock.patch('conans.client.cmd.uploader.gzopen_without_timestamps',
new=gzopen_patched):
client.run("upload * --confirm --all", assert_error=True)
self.assertIn("ERROR: Error gzopen conan_package.tgz", client.out)
export_folder = client.cache.package_layout(pref.ref).package(pref)
tgz = os.path.join(export_folder, PACKAGE_TGZ_NAME)
self.assertTrue(os.path.exists(tgz))
self.assertTrue(is_dirty(tgz))
client.run("upload * --confirm --all")
self.assertIn(
"WARN: Hello0/1.2.1@user/testing:%s: "
"Removing conan_package.tgz, marked as dirty" %
NO_SETTINGS_PACKAGE_ID, client.out)
self.assertTrue(os.path.exists(tgz))
self.assertFalse(is_dirty(tgz))
def _get_package_snapshot(self, p_ref):
url = self._package_url(p_ref)
repr_ref = p_ref.full_repr()
snap, p_reference, rev_time = self._get_snapshot(url, repr_ref)
reference = PackageReference.loads(p_reference)
return snap, reference, rev_time
def _capture_verify_manifest(self, reference, remote="local cache", folder=""):
self.client.run("install %s --build missing --manifests %s" % (str(reference), folder))
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
real_folder = folder or ".conan_manifests"
output_folder = os.path.join(self.client.current_folder, real_folder)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
# again should do nothing
self.client.run("install %s --build missing --manifests %s"
% (str(self.reference), folder))
self.assertNotIn("manifest", self.client.user_io.out)
# now verify
self.client.run("install %s --build missing --verify %s" % (str(self.reference), folder))
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
def conanfile_capture_verify_manifest_folder_test(self):
files = {"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}
self.client.save(files, clean_first=True)
folder = "mymanifests"
self._capture_verify_manifest(".", folder=folder)
conanfile = """from conans import ConanFile
class ConanFileTest(ConanFile):
name = "Hello2"
version = "0.1"
"""
client = TestClient(base_folder=self.client.base_folder)
client.save({CONANFILE: conanfile})
client.run("export . lasote/stable")
files = {"conanfile.txt": "[requires]\nHello2/0.1@lasote/stable\nHello/0.1@lasote/stable"}
self.client.save(files)
self.client.run("install . --build missing --manifests %s" % folder)
remote = "local cache"
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
output_folder = os.path.join(self.client.current_folder, folder)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(os.path.join(paths.export(self.reference), CONAN_MANIFEST)))
self.assertTrue(os.path.exists(os.path.join(paths.package(package_reference), CONAN_MANIFEST)))
def basic_disabled_test(self):
client = TestClient()
conanfile = '''
from conans import ConanFile
class ConanLib(ConanFile):
short_paths = True
'''
client.save({"conanfile.py": conanfile})
client.run("create . lib/0.1@user/channel")
pref = PackageReference.loads("lib/0.1@user/channel:%s" %
NO_SETTINGS_PACKAGE_ID)
client.run("search")
self.assertIn("lib/0.1@user/channel", client.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: %s" % NO_SETTINGS_PACKAGE_ID, client.out)
if platform.system() == "Windows":
ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.cache.package_layout(ref, False).source()
build_folder = client.cache.package_layout(ref, False).build(pref)
package_folder = client.cache.package_layout(ref,
False).package(pref)
link_source = os.path.join(source_folder, ".conan_link")
link_build = os.path.join(build_folder, ".conan_link")
link_package = os.path.join(package_folder, ".conan_link")
self.assertTrue(os.path.exists(link_source))
self.assertTrue(os.path.exists(link_build))
self.assertTrue(os.path.exists(link_package))
def basic_disabled_test(self):
client = TestClient()
base = '''
from conans import ConanFile
class ConanLib(ConanFile):
short_paths = True
'''
files = {"conanfile.py": base}
client.save(files)
client.client_cache.conan_config.set_item("general.user_home_short",
"None")
client.run("create lib/0.1@user/channel")
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
client.run("search")
self.assertIn("lib/0.1@user/channel", client.user_io.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
client.user_io.out)
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
link_source = os.path.join(source_folder, ".conan_link")
self.assertFalse(os.path.exists(link_source))
build_folder = client.client_cache.build(package_ref)
link_build = os.path.join(build_folder, ".conan_link")
self.assertFalse(os.path.exists(link_build))
package_folder = client.client_cache.package(package_ref)
link_package = os.path.join(package_folder, ".conan_link")
self.assertFalse(os.path.exists(link_package))
def export_source_test(self):
client = TestClient()
files = {
"conanfile.py": base,
"path/" * 20 + "file0.txt": "file0 content"
}
client.save(files)
client.run("export user/channel")
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
if platform.system() == "Windows":
source_folder = client.client_cache.export_sources(conan_ref)
link_source = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
self.assertEqual(
load(os.path.join(link_source + "/path" * 20 + "/file0.txt")),
"file0 content")
client.run("install lib/0.1@user/channel --build=missing")
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref)
link_source = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
self.assertEqual(load(os.path.join(link_source + "/file0.txt")),
"file0 content")
def upload_test(self):
test_server = TestServer([], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
files = {"conanfile.py": base}
client.save(files)
client.run("export . lasote/channel")
client.run("install lib/0.1@lasote/channel --build")
client.run("upload lib/0.1@lasote/channel --all")
client.run("remove lib/0.1@lasote/channel -f")
client.run("search")
self.assertIn("There are no packages", client.user_io.out)
for command in ("install", "download"):
client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client2.run("%s lib/0.1@lasote/channel" % command)
reference = ConanFileReference.loads("lib/0.1@lasote/channel")
export_folder = client2.client_cache.export(reference)
export_files = os.listdir(export_folder)
self.assertNotIn('conan_export.tgz', export_files)
package_ref = PackageReference.loads("lib/0.1@lasote/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client2.client_cache.package(package_ref, short_paths=None)
if platform.system() == "Windows":
original_folder = client2.client_cache.package(package_ref)
link = load(os.path.join(original_folder, ".conan_link"))
self.assertEqual(link, package_folder)
files = os.listdir(package_folder)
self.assertIn("myfile.txt", files)
self.assertIn("myfile2.txt", files)
self.assertNotIn("conan_package.tgz", files)
def upload_test(self):
test_server = TestServer([], # write permissions
users={"lasote": "mypass"}) # exported users and passwords
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
files = {"conanfile.py": base}
client.save(files)
client.run("export . lasote/channel")
client.run("install lib/0.1@lasote/channel --build")
client.run("upload lib/0.1@lasote/channel --all")
client.run("remove lib/0.1@lasote/channel -f")
client.run("search")
self.assertIn("There are no packages", client.user_io.out)
for command in ("install", "download"):
client2 = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client2.run("%s lib/0.1@lasote/channel" % command)
ref = ConanFileReference.loads("lib/0.1@lasote/channel")
export_folder = client2.cache.export(ref)
export_files = os.listdir(export_folder)
self.assertNotIn('conan_export.tgz', export_files)
pref = PackageReference.loads("lib/0.1@lasote/channel:" + NO_SETTINGS_PACKAGE_ID)
package_folder = client2.cache.package(pref, short_paths=None)
if platform.system() == "Windows":
original_folder = client2.cache.package(pref)
link = load(os.path.join(original_folder, ".conan_link"))
self.assertEqual(link, package_folder)
files = os.listdir(package_folder)
self.assertIn("myfile.txt", files)
self.assertIn("myfile2.txt", files)
self.assertNotIn("conan_package.tgz", files)
def package_files_test(self):
if platform.system() == "Windows":
return
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
def package(self):
self.copy("*", symlinks=True)
"""
client.save({"recipe/conanfile.py": conanfile})
file1 = os.path.join(client.current_folder, "file1.txt")
file2 = os.path.join(client.current_folder, "version1/file2.txt")
file11 = os.path.join(client.current_folder, "file1.txt.1")
latest = os.path.join(client.current_folder, "latest")
save(file1, "Hello1")
os.symlink("file1.txt", file11)
save(file2, "Hello2")
os.symlink("version1", latest)
client.run("export-pkg ./recipe Hello/0.1@lasote/stable")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self._check(client, ref, build=False)
def basic_disabled_test(self):
client = TestClient()
base = '''
from conans import ConanFile
class ConanLib(ConanFile):
short_paths = True
'''
client.save({"conanfile.py": base})
client.run("create . lib/0.1@user/channel")
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
client.run("search")
self.assertIn("lib/0.1@user/channel", client.user_io.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", client.user_io.out)
if platform.system() == "Windows":
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
build_folder = client.client_cache.build(package_ref)
package_folder = client.client_cache.package(package_ref)
link_source = os.path.join(source_folder, ".conan_link")
link_build = os.path.join(build_folder, ".conan_link")
link_package = os.path.join(package_folder, ".conan_link")
self.assertTrue(os.path.exists(link_source))
self.assertTrue(os.path.exists(link_build))
self.assertTrue(os.path.exists(link_package))
def basic_test(self):
client = TestClient()
files = {"conanfile.py": base}
client.save(files)
client.run("export user/channel")
client.run("install lib/0.1@user/channel --build")
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref,
short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello extra path length", file1)
file2 = load(os.path.join(package_folder, "myfile2.txt"))
self.assertEqual("Hello2 extra path length", file2)
if platform.system() == "Windows":
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
link_source = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
build_folder = client.client_cache.build(package_ref)
link_build = load(os.path.join(build_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_build))
package_folder = client.client_cache.package(package_ref)
link_package = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_package))
client.run("remove lib* -f")
self.assertFalse(os.path.exists(link_source))
self.assertFalse(os.path.exists(link_build))
self.assertFalse(os.path.exists(link_package))
def custom_settings_test(self):
settings = """os:
None:
Windows:
subsystem: [None, cygwin]
Linux:
compiler: [gcc, visual]
"""
client = TestClient()
save(client.paths.settings_path, settings)
save(client.paths.default_profile_path, "")
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
settings = "os", "compiler"
"""
client.save({"conanfile.py": conanfile})
client.run("create . Pkg/0.1@lasote/testing -s compiler=gcc")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertNotIn("os: None", client.out)
package_reference = PackageReference.loads("Pkg/0.1@lasote/testing:544c1d8c53e9d269737e68e00ec66716171d2704")
info_path = os.path.join(client.paths.package(package_reference), CONANINFO)
info = load(info_path)
self.assertNotIn("os", info)
# Explicitly specifying None, put it in the conaninfo.txt, but does not affect the hash
client.run("create . Pkg/0.1@lasote/testing -s compiler=gcc -s os=None")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertIn("os: None", client.out)
info = load(info_path)
self.assertIn("os", info)
def basic_disabled_test(self):
client = TestClient()
base = '''
from conans import ConanFile
class ConanLib(ConanFile):
short_paths = True
'''
client.save({"conanfile.py": base})
client.run("create . lib/0.1@user/channel")
package_ref = PackageReference.loads(
"lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
client.run("search")
self.assertIn("lib/0.1@user/channel", client.user_io.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9",
client.user_io.out)
if platform.system() == "Windows":
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
build_folder = client.client_cache.build(package_ref)
package_folder = client.client_cache.package(package_ref)
link_source = os.path.join(source_folder, ".conan_link")
link_build = os.path.join(build_folder, ".conan_link")
link_package = os.path.join(package_folder, ".conan_link")
self.assertTrue(os.path.exists(link_source))
self.assertTrue(os.path.exists(link_build))
self.assertTrue(os.path.exists(link_package))
def test_custom_settings(self):
settings = textwrap.dedent("""\
os:
None:
Windows:
subsystem: [None, cygwin]
Linux:
compiler: [gcc, visual]
""")
client = TestClient()
save(client.cache.settings_path, settings)
save(client.cache.default_profile_path, "")
client.save({"conanfile.py": GenConanfile().with_settings("os", "compiler")})
client.run("create . Pkg/0.1@lasote/testing -s compiler=gcc")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertNotIn("os: None", client.out)
pref = PackageReference.loads("Pkg/0.1@lasote/testing:"
"544c1d8c53e9d269737e68e00ec66716171d2704")
info_path = os.path.join(client.cache.package_layout(pref.ref).package(pref), CONANINFO)
info = load(info_path)
self.assertNotIn("os", info)
# Explicitly specifying None, put it in the conaninfo.txt, but does not affect the hash
client.run("create . Pkg/0.1@lasote/testing -s compiler=gcc -s os=None")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertIn("os: None", client.out)
info = load(info_path)
self.assertIn("os", info)
def package_files_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
def package(self):
self.copy("*", symlinks=True)
"""
client.save({"recipe/conanfile.py": conanfile})
file1 = os.path.join(client.current_folder, "file1.txt")
file2 = os.path.join(client.current_folder, "version1/file2.txt")
file11 = os.path.join(client.current_folder, "file1.txt.1")
latest = os.path.join(client.current_folder, "latest")
edge = os.path.join(client.current_folder, "edge")
save(file1, "Hello1")
os.symlink("file1.txt", file11)
save(file2, "Hello2")
os.symlink("version1", latest)
os.symlink("latest", edge)
client.run("export-pkg ./recipe Hello/0.1@lasote/stable")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self._check(client, ref, build=False)
def basic_test(self):
client = TestClient()
files = {"conanfile.py": base}
client.save(files)
client.run("export . user/channel")
client.run("install lib/0.1@user/channel --build")
pref = PackageReference.loads("lib/0.1@user/channel:%s" % NO_SETTINGS_PACKAGE_ID)
client.run("search")
self.assertIn("lib/0.1@user/channel", client.user_io.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: %s" % NO_SETTINGS_PACKAGE_ID, client.user_io.out)
package_folder = client.cache.package(pref, short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello extra path length", file1)
file2 = load(os.path.join(package_folder, "myfile2.txt"))
self.assertEqual("Hello2 extra path length", file2)
if platform.system() == "Windows":
ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.cache.source(ref)
link_source = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
build_folder = client.cache.build(pref)
link_build = load(os.path.join(build_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_build))
package_folder = client.cache.package(pref)
link_package = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_package))
client.run("remove lib* -f")
self.assertFalse(os.path.exists(link_source))
self.assertFalse(os.path.exists(link_build))
self.assertFalse(os.path.exists(link_package))
def export_source_test(self):
client = TestClient()
files = {
"conanfile.py": base,
"path/" * 20 + "file0.txt": "file0 content"
}
client.save(files)
client.run("export . user/channel")
ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.cache.package_layout(ref,
False).export_sources()
if platform.system() == "Windows":
source_folder = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(source_folder))
self.assertEqual(
load(os.path.join(source_folder + "/path" * 20 + "/file0.txt")),
"file0 content")
client.run("install lib/0.1@user/channel --build=missing")
pref = PackageReference.loads("lib/0.1@user/channel:%s" %
NO_SETTINGS_PACKAGE_ID)
package_folder = client.cache.package_layout(
pref.ref, short_paths=False).package(pref)
if platform.system() == "Windows":
package_folder = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(package_folder))
self.assertEqual(load(os.path.join(package_folder + "/file0.txt")),
"file0 content")
def test_package_files(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
def package(self):
self.copy("*", symlinks=True)
"""
client.save({"recipe/conanfile.py": conanfile})
file1 = os.path.join(client.current_folder, "file1.txt")
file2 = os.path.join(client.current_folder, "version1/file2.txt")
file11 = os.path.join(client.current_folder, "file1.txt.1")
latest = os.path.join(client.current_folder, "latest")
edge = os.path.join(client.current_folder, "edge")
save(file1, "Hello1")
os.symlink("file1.txt", file11)
save(file2, "Hello2")
os.symlink("version1", latest)
os.symlink("latest", edge)
client.run("export-pkg ./recipe Hello/0.1@lasote/stable")
pref = PackageReference.loads("Hello/0.1@lasote/stable:%s" %
NO_SETTINGS_PACKAGE_ID)
self._check(client, pref, build=False)
def upload_without_user_channel_test(self):
server = TestServer(users={"user": "******"},
write_permissions=[("*/*@*/*", "*")])
servers = {"default": server}
client = TestClient(servers=servers,
users={"default": [("user", "password")]})
client.save({"conanfile.py": GenConanfile()})
client.run('create . lib/1.0@')
self.assertIn(
"lib/1.0: Package '{}' created".format(NO_SETTINGS_PACKAGE_ID),
client.out)
client.run('upload lib/1.0 -c --all')
self.assertIn("Uploaded conan recipe 'lib/1.0' to 'default'",
client.out)
# Verify that in the remote it is stored as "_"
pref = PackageReference.loads(
"lib/1.0@#0:{}#0".format(NO_SETTINGS_PACKAGE_ID))
path = server.server_store.export(pref.ref)
self.assertIn("/lib/1.0/_/_/0/export", path.replace("\\", "/"))
path = server.server_store.package(pref)
self.assertIn("/lib/1.0/_/_/0/package", path.replace("\\", "/"))
def package_files_test(self):
if platform.system() == "Windows":
return
client = TestClient()
conanfile = """
from conans import ConanFile
class TestConan(ConanFile):
name = "Hello"
version = "0.1"
"""
client.save({"conanfile.py": conanfile})
client.run("export lasote/stable")
client.save({}, clean_first=True)
file1 = os.path.join(client.current_folder, "file1.txt")
file2 = os.path.join(client.current_folder, "version1/file2.txt")
file11 = os.path.join(client.current_folder, "file1.txt.1")
latest = os.path.join(client.current_folder, "latest")
save(file1, "Hello1")
os.symlink("file1.txt", file11)
save(file2, "Hello2")
os.symlink("version1", latest)
client.run("package_files Hello/0.1@lasote/stable")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self._check(client, ref, build=False)
def _capture_verify_manifest(self, reference, remote="local cache", folder=""):
self.client.run("install %s --build missing --manifests %s" % (str(reference), folder))
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
real_folder = folder or ".conan_manifests"
output_folder = os.path.join(self.client.current_folder, real_folder)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
# again should do nothing
self.client.run("install %s --build missing --manifests %s"
% (str(self.reference), folder))
self.assertNotIn("Installed manifest", self.client.user_io.out)
# now verify
self.client.run("install %s --build missing --verify %s" % (str(self.reference), folder))
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
def test_corrupted_manifest(self):
remote_url = "http://some.url"
pref = PackageReference.loads("lib/version@user/channel#rrev:123#prev")
returned_files = {CONAN_MANIFEST: b"not expected content"}
with patch.object(RestV1Methods, "_get_file_to_url_dict", return_value=None), \
patch.object(RestV1Methods, "_download_files", return_value=returned_files):
config = namedtuple("ConfigMock", "download_cache")(None)
v1 = RestV1Methods(remote_url,
token=None,
custom_headers=None,
output=None,
requester=None,
config=config,
verify_ssl=None)
with self.assertRaises(ConanException) as exc:
v1.get_package_manifest(pref=pref)
# Exception tells me about the originating error and the request I was doing.
# It doesn't show the PREV because it is v1
self.assertIn(
"Error retrieving manifest file for package '{}'"
" from remote ({})".format(pref, remote_url),
str(exc.exception))
self.assertIn("invalid literal for int() with base 10",
str(exc.exception))
def fail_test_package_test(self):
client = TestClient()
conanfile = """
from conans import ConanFile
class HelloConan(ConanFile):
name = "Hello"
version = "0.1"
exports = "*"
def package(self):
self.copy("*")
"""
test_conanfile = """
from conans import ConanFile, CMake
import os
class HelloReuseConan(ConanFile):
requires = "Hello/0.1@lasote/stable"
def test(self):
self.conanfile_directory
"""
client.save({"conanfile.py": conanfile,
"FindXXX.cmake": "Hello FindCmake",
"test/conanfile.py": test_conanfile})
client.run("test_package")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertEqual("Hello FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
client.save({"FindXXX.cmake": "Bye FindCmake"})
client.run("test_package")
self.assertEqual("Bye FindCmake",
load(os.path.join(client.paths.package(ref), "FindXXX.cmake")))
def test_broken_package_tgz(self):
# https://github.com/conan-io/conan/issues/2854
client = TestClient(default_server_user=True)
client.save({"conanfile.py": conanfile, "source.h": "my source"})
client.run("create . user/testing")
pref = PackageReference.loads("Hello0/1.2.1@user/testing:" +
NO_SETTINGS_PACKAGE_ID)
def gzopen_patched(name, mode="r", fileobj=None, **kwargs):
if name == PACKAGE_TGZ_NAME:
raise ConanException("Error gzopen %s" % name)
return gzopen_without_timestamps(name, mode, fileobj, **kwargs)
with patch('conans.client.cmd.uploader.gzopen_without_timestamps',
new=gzopen_patched):
client.run("upload * --confirm --all", assert_error=True)
self.assertIn(
"ERROR: Hello0/1.2.1@user/testing:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9"
": Upload package to 'default' failed: Error gzopen conan_package.tgz",
client.out)
download_folder = client.cache.package_layout(
pref.ref).download_package(pref)
tgz = os.path.join(download_folder, PACKAGE_TGZ_NAME)
self.assertTrue(os.path.exists(tgz))
self.assertTrue(is_dirty(tgz))
client.run("upload * --confirm --all")
self.assertIn(
"WARN: Hello0/1.2.1@user/testing:%s: "
"Removing conan_package.tgz, marked as dirty" %
NO_SETTINGS_PACKAGE_ID, client.out)
self.assertTrue(os.path.exists(tgz))
self.assertFalse(is_dirty(tgz))
def _get_package_snapshot(self, pref):
url = self.conans_router.package_snapshot(pref)
pref_str = pref.full_repr()
snap, package_reference, rev_time = self._get_snapshot(url, pref_str)
pref = PackageReference.loads(package_reference)
return snap, pref, rev_time
def test_upload_without_user_channel(self):
server = TestServer(users={"user": "******"},
write_permissions=[("*/*@*/*", "*")])
servers = {"default": server}
client = TestClient(servers=servers,
users={"default": [("user", "password")]})
client.save({"conanfile.py": GenConanfile()})
client.run('create . lib/1.0@')
self.assertIn(
"lib/1.0: Package '{}' created".format(NO_SETTINGS_PACKAGE_ID),
client.out)
client.run('upload lib/1.0 -c --all')
assert "Uploading lib/1.0 to remote" in client.out
# Verify that in the remote it is stored as "_"
pref = PackageReference.loads(
"lib/1.0@#0:{}#0".format(NO_SETTINGS_PACKAGE_ID))
path = server.server_store.export(pref.ref)
self.assertIn("/lib/1.0/_/_/0/export", path.replace("\\", "/"))
path = server.server_store.package(pref)
self.assertIn("/lib/1.0/_/_/0/package", path.replace("\\", "/"))
# Should be possible with explicit package
client.run('upload lib/1.0:5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9')
self.assertIn(
"Uploading package 1/1: 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9 to 'default'",
client.out)
def custom_settings_test(self):
settings = """os:
None:
Windows:
subsystem: [None, cygwin]
Linux:
compiler: [gcc, visual]
"""
client = TestClient()
save(client.client_cache.settings_path, settings)
save(client.client_cache.default_profile_path, "")
conanfile = """from conans import ConanFile
class Pkg(ConanFile):
settings = "os", "compiler"
"""
client.save({"conanfile.py": conanfile})
client.run("create . Pkg/0.1@lasote/testing -s compiler=gcc")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertNotIn("os: None", client.out)
package_reference = PackageReference.loads(
"Pkg/0.1@lasote/testing:"
"544c1d8c53e9d269737e68e00ec66716171d2704")
info_path = os.path.join(
client.client_cache.package(package_reference), CONANINFO)
info = load(info_path)
self.assertNotIn("os", info)
# Explicitly specifying None, put it in the conaninfo.txt, but does not affect the hash
client.run(
"create . Pkg/0.1@lasote/testing -s compiler=gcc -s os=None")
self.assertIn("544c1d8c53e9d269737e68e00ec66716171d2704", client.out)
client.run("search Pkg/0.1@lasote/testing")
self.assertIn("os: None", client.out)
info = load(info_path)
self.assertIn("os", info)
def get_conaninfo(info):
package_id = info["installed"][0]["packages"][0]["id"]
pref = PackageReference.loads("lib/1.0@conan/stable:%s" %
package_id)
cache = ClientCache(api.cache_folder,
TestBufferConanOutput())
folder = cache.package_layout(pref.ref).package(pref)
return load(os.path.join(folder, "conaninfo.txt"))
def failure_test(self):
base = '''
from conans import ConanFile
from conans.util.files import load, save
import os
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
short_paths = True
exports = "*"
generators = "cmake"
def build(self):
self.output.info("%s/%s" % (self.conanfile_directory, self.name))
# print os.listdir(self.conanfile_directory)
path = os.path.join(self.conanfile_directory, self.name)
# print "PATH EXISTS ", os.path.exists(path)
# print os.listdir(path)
path = os.path.join(path, "myfile.txt")
# print "PATH EXISTS ", os.path.exists(path)
def package(self):
self.copy("*.txt", keep_path=False)
'''
client = TestClient()
files = {"conanfile.py": base,
"lib/myfile.txt": "Hello world!"}
client.save(files)
client.run("export user/channel")
client.run("install lib/0.1@user/channel --build")
# print client.paths.store
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref, short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
client.run("install lib/0.1@user/channel --build")
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref, short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
def failure_test(self):
conanfile = '''
from conans import ConanFile
from conans.util.files import load, save
import os
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
short_paths = True
exports = "*"
generators = "cmake"
def build(self):
self.output.info("%s/%s" % (self.build_folder, self.name))
path = os.path.join(self.build_folder, self.name)
# print "PATH EXISTS ", os.path.exists(path)
# print os.listdir(path)
path = os.path.join(path, "myfile.txt")
# print "PATH EXISTS ", os.path.exists(path)
def package(self):
self.copy("*.txt", keep_path=False)
'''
client = TestClient()
files = {"conanfile.py": conanfile, "lib/myfile.txt": "Hello world!"}
client.save(files)
client.run("export . user/channel")
client.run("install lib/0.1@user/channel --build")
# print client.paths.store
pref = PackageReference.loads("lib/0.1@user/channel:%s" %
NO_SETTINGS_PACKAGE_ID)
package_folder = client.cache.package_layout(
pref.ref, short_paths=None).package(pref)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
client.run("install lib/0.1@user/channel --build")
pref = PackageReference.loads("lib/0.1@user/channel:%s" %
NO_SETTINGS_PACKAGE_ID)
package_folder = client.cache.package_layout(
pref.ref, short_paths=None).package(pref)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello world!", file1)
def test_package_test(self, use_abs_folder):
self.client.run("install Hello/0.1@lasote/stable --build missing")
conanfile = """from conans import ConanFile
class ConsumerFileTest(ConanFile):
name = "Chat"
version = "0.1"
requires = "Hello/0.1@lasote/stable"
"""
test_conanfile = """from conans import ConanFile
class ConsumerFileTest(ConanFile):
requires = "Chat/0.1@lasote/stable"
def test(self):
self.output.info("TEST OK")
"""
if use_abs_folder:
output_folder = temp_folder()
dest = '="%s"' % output_folder
else:
dest = ""
output_folder = os.path.join(self.client.current_folder,
".conan_manifests")
self.client.save(
{
"conanfile.py": conanfile,
"test_package/conanfile.py": test_conanfile
},
clean_first=True)
self.client.run("create . lasote/stable --manifests%s" % dest)
self.assertIn("Chat/0.1@lasote/stable (test package): TEST OK",
self.client.user_io.out)
self.assertIn(
"Installed manifest for 'Chat/0.1@lasote/stable' from local cache",
self.client.user_io.out)
self.assertIn(
"Installed manifest for 'Hello/0.1@lasote/stable' from local cache",
self.client.user_io.out)
paths = SimplePaths(output_folder)
self.assertTrue(
os.path.exists(
os.path.join(paths.export(self.reference), CONAN_MANIFEST)))
package_reference = PackageReference.loads(
"Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(
os.path.exists(
os.path.join(paths.package(package_reference),
CONAN_MANIFEST)))
# now verify
self.client.run("create . lasote/stable --verify%s" % dest)
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK",
self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference),
self.client.user_io.out)
def _check_conaninfo(self, client):
# Check that conaninfo is correct
pref_debug = PackageReference.loads(
"Pkg/0.1@user/channel:"
"f3989dcba0ab50dc5ed9b40ede202bdd7b421f09")
conaninfo = load(
os.path.join(
client.cache.package_layout(
pref_debug.ref).package(pref_debug), "conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertIn("build_type=Debug", conaninfo)
self.assertNotIn("Release", conaninfo)
pref_release = PackageReference.loads(
"Pkg/0.1@user/channel:"
"ab2e9f86b4109980930cdc685f4a320b359e7bb4")
conaninfo = load(
os.path.join(
client.cache.package_layout(
pref_release.ref).package(pref_release), "conaninfo.txt"))
self.assertIn("os=Windows", conaninfo)
self.assertIn("build_type=Release", conaninfo)
self.assertNotIn("Debug", conaninfo)
pref_debug = PackageReference.loads(
"Pkg/0.1@user/channel:"
"322de4b4a41f905f6b18f454ab5f498690b39c2a")
conaninfo = load(
os.path.join(
client.cache.package_layout(
pref_debug.ref).package(pref_debug), "conaninfo.txt"))
self.assertIn("os=Linux", conaninfo)
self.assertIn("build_type=Debug", conaninfo)
self.assertNotIn("Release", conaninfo)
pref_release = PackageReference.loads(
"Pkg/0.1@user/channel:"
"24c3aa2d6c5929d53bd86b31e020c55d96b265c7")
conaninfo = load(
os.path.join(
client.cache.package_layout(
pref_release.ref).package(pref_release), "conaninfo.txt"))
self.assertIn("os=Linux", conaninfo)
self.assertIn("build_type=Release", conaninfo)
self.assertNotIn("Debug", conaninfo)
def remove_all(self, ref):
assert (isinstance(ref, ConanFileReference))
with fasteners.InterProcessLock(self._lockfile, logger=logger):
remotes, rrefs, prefs = self._load()
ret = {}
for p, r in prefs.items():
if PackageReference.loads(p).ref != ref.copy_clear_rev():
ret[p] = r
self._save(remotes, rrefs, ret)
def basic_test(self):
client = TestClient()
base = '''
from conans import ConanFile
from conans.util.files import load, save
import os
class ConanLib(ConanFile):
name = "lib"
version = "0.1"
short_paths = True
def source(self):
extra_path = "1/" * 108
os.makedirs(extra_path)
myfile = os.path.join(extra_path, "myfile.txt")
# print("File length ", len(myfile))
save(myfile, "Hello extra path length")
def build(self):
extra_path = "1/" * 108
myfile = os.path.join(extra_path, "myfile2.txt")
# print("File length ", len(myfile))
save(myfile, "Hello2 extra path length")
def package(self):
self.copy("*.txt", keep_path=False)
'''
files = {"conanfile.py": base}
client.save(files)
client.run("export user/channel")
client.run("install lib/0.1@user/channel --build")
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello extra path length", file1)
file2 = load(os.path.join(package_folder, "myfile2.txt"))
self.assertEqual("Hello2 extra path length", file2)
if platform.system() == "Windows":
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
link_source = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
build_folder = client.client_cache.build(package_ref)
link_build = load(os.path.join(build_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_build))
client.run("remove lib* -f")
self.assertFalse(os.path.exists(link_source))
self.assertFalse(os.path.exists(link_build))
def test_corrupted_package(self):
self.client.run("install %s --build missing" % str(self.reference))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_path = self.client.paths.package(package_reference)
file_path = os.path.join(package_path, "conaninfo.txt")
save(file_path, load(file_path) + "RANDOM STRING")
self.client.run("install %s --build missing --manifests" % str(self.reference),
ignore_error=True)
self.assertIn("%s local cache package is corrupted" % str(package_reference),
self.client.user_io.out)
def conanfile_capture_verify_manifest_folder_test(self):
files = {"conanfile.txt": "[requires]\nHello/0.1@lasote/stable"}
self.client.save(files, clean_first=True)
folder = "mymanifests"
self._capture_verify_manifest(".", folder=folder)
conanfile = """from conans import ConanFile
class ConanFileTest(ConanFile):
name = "Hello2"
version = "0.1"
"""
client = TestClient(base_folder=self.client.base_folder)
client.save({CONANFILE: conanfile})
client.run("export lasote/stable")
files = {"conanfile.txt": "[requires]\nHello2/0.1@lasote/stable\nHello/0.1@lasote/stable"}
self.client.save(files)
self.client.run("install . --build missing --manifests %s" % folder)
remote = "local cache"
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello2/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
output_folder = os.path.join(self.client.current_folder, folder)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
package_reference = PackageReference.loads("Hello2/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
def basic_test(self):
if platform.system() == "Windows":
return
client = TestClient()
client.save({"conanfile.py": conanfile,
"conanfile.txt": test_conanfile})
client.run("export lasote/stable")
client.run("install --build -f=conanfile.txt")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self._check(client, ref)
client.run("install --build -f=conanfile.txt")
self._check(client, ref)
def __init__(self, value_str, indirect=False):
""" parse the input into fields name, version...
"""
ref = PackageReference.loads(value_str)
self.package = ref
self.full_name = ref.conan.name
self.full_version = ref.conan.version
self.full_user = ref.conan.user
self.full_channel = ref.conan.channel
self.full_package_id = ref.package_id
# sha values
if indirect:
self.unrelated_mode()
else:
self.semver()
def build_test(self):
""" Try to reuse variables loaded from txt generator => deps_cpp_info
"""
client = TestClient()
client.save({CONANFILE: conanfile_dep})
client.run("export lasote/testing")
client.save({CONANFILE: conanfile_scope_env}, clean_first=True)
client.run("install --build=missing")
client.run("build")
ref = PackageReference.loads("Hello/0.1@lasote/testing:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.paths.package(ref).replace("\\", "/")
self.assertIn("Project: INCLUDE PATH: %s/include" % package_folder, client.user_io.out)
self.assertIn("Project: HELLO ROOT PATH: %s" % package_folder, client.user_io.out)
self.assertIn("Project: HELLO INCLUDE PATHS: %s/include"
% package_folder, client.user_io.out)
def test_package_test(self, use_abs_folder):
self.client.run("install Hello/0.1@lasote/stable --build missing")
conanfile = """from conans import ConanFile
class ConsumerFileTest(ConanFile):
name = "Chat"
version = "0.1"
requires = "Hello/0.1@lasote/stable"
"""
test_conanfile = """from conans import ConanFile
class ConsumerFileTest(ConanFile):
requires = "Chat/0.1@lasote/stable"
def test(self):
self.output.info("TEST OK")
"""
if use_abs_folder:
output_folder = temp_folder()
dest = '="%s"' % output_folder
else:
dest = ""
output_folder = os.path.join(self.client.current_folder, ".conan_manifests")
self.client.save({"conanfile.py": conanfile,
"test_package/conanfile.py": test_conanfile}, clean_first=True)
self.client.run("create . lasote/stable --manifests%s" % dest)
self.assertIn("Chat/0.1@lasote/stable (test package): TEST OK", self.client.user_io.out)
self.assertIn("Installed manifest for 'Chat/0.1@lasote/stable' from local cache",
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable' from local cache",
self.client.user_io.out)
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
# now verify
self.client.run("create . lasote/stable --verify%s" % dest)
self.assertIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
def upload_test(self):
if platform.system() == "Windows":
return
test_server = TestServer()
servers = {"default": test_server}
client = TestClient(servers=servers, users={"default": [("lasote", "mypass")]})
client.save({"conanfile.py": conanfile,
"conanfile.txt": test_conanfile})
client.run("export lasote/stable")
client.run("install --build -f=conanfile.txt")
ref = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
client.run("upload Hello/0.1@lasote/stable --all")
client.run('remove "*" -f')
client.save({"conanfile.txt": test_conanfile}, clean_first=True)
client.run("install")
self._check(client, ref, build=False)
def _failed_package_verify(self, reference, remote="local cache"):
self.client.run("install %s --build missing --manifests" % str(reference))
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
output_folder = os.path.join(self.client.current_folder, ".conan_manifests")
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
client.save(self.files)
client.run("export lasote/stable")
client.run("install Hello/0.1@lasote/stable --build=missing")
info = os.path.join(client.paths.package(package_reference), "conaninfo.txt")
info_content = load(info)
info_content += "# Dummy string"
save(info, info_content)
manifest = client.paths.load_package_manifest(package_reference)
manifest.file_sums["conaninfo.txt"] = md5(info_content)
save(client.paths.digestfile_package(package_reference), str(manifest))
manifest = client.paths.load_package_manifest(package_reference)
client.run("upload %s --all" % str(self.reference))
# now verify, with update
self.client.run("remove Hello/0.1@lasote/stable -f")
self.client.run("install %s --build missing --verify"
% str(self.reference),
ignore_error=True)
self.assertNotIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertNotIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
self.assertIn("Modified or new manifest '%s' detected" % str(package_reference),
self.client.user_io.out)
def export_source_test(self):
client = TestClient()
files = {"conanfile.py": base,
"path/"*20 + "file0.txt": "file0 content"}
client.save(files)
client.run("export . user/channel")
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.export_sources(conan_ref)
if platform.system() == "Windows":
source_folder = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(source_folder))
self.assertEqual(load(os.path.join(source_folder + "/path"*20 + "/file0.txt")),
"file0 content")
client.run("install lib/0.1@user/channel --build=missing")
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
package_folder = client.client_cache.package(package_ref)
if platform.system() == "Windows":
package_folder = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(package_folder))
self.assertEqual(load(os.path.join(package_folder + "/file0.txt")), "file0 content")
def _failed_verify(self, reference, remote="local cache"):
self.client.run("install %s --build missing --manifests" % str(reference))
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable' from %s" % remote,
self.client.user_io.out)
self.assertIn("Installed manifest for 'Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9' from %s" % remote,
self.client.user_io.out)
output_folder = os.path.join(self.client.current_folder, ".conan_manifests")
paths = SimplePaths(output_folder)
self.assertTrue(os.path.exists(paths.digestfile_conanfile(self.reference)))
package_reference = PackageReference.loads("Hello/0.1@lasote/stable:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
self.assertTrue(os.path.exists(paths.digestfile_package(package_reference)))
client = TestClient(servers=self.servers, users={"default": [("lasote", "mypass")]})
conanfile = """from conans import ConanFile
class ConanFileTest(ConanFile):
name = "Hello"
version = "0.1"
exports = "*"
"""
files = {CONANFILE: conanfile, "data.txt": "MyDataHacked"}
# Export and upload the conanfile
client.save(files)
client.run("export lasote/stable")
client.run("upload %s --all" % str(self.reference))
# now verify, with update
self.client.run("remove Hello/0.1@lasote/stable -f")
self.client.run("install %s --build missing --verify"
% str(self.reference),
ignore_error=True)
self.assertNotIn("Manifest for 'Hello/0.1@lasote/stable': OK", self.client.user_io.out)
self.assertNotIn("Manifest for '%s': OK" % str(package_reference), self.client.user_io.out)
self.assertIn("Modified or new manifest 'Hello/0.1@lasote/stable' detected",
self.client.user_io.out)
def basic_test(self):
client = TestClient()
files = {"conanfile.py": base}
client.save(files)
client.run("export user/channel")
client.run("install lib/0.1@user/channel --build")
package_ref = PackageReference.loads("lib/0.1@user/channel:"
"5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9")
client.run("search")
self.assertIn("lib/0.1@user/channel", client.user_io.out)
client.run("search lib/0.1@user/channel")
self.assertIn("Package_ID: 5ab84d6acfe1f23c4fae0ab88f26e3a396351ac9", client.user_io.out)
package_folder = client.client_cache.package(package_ref, short_paths=None)
file1 = load(os.path.join(package_folder, "myfile.txt"))
self.assertEqual("Hello extra path length", file1)
file2 = load(os.path.join(package_folder, "myfile2.txt"))
self.assertEqual("Hello2 extra path length", file2)
if platform.system() == "Windows":
conan_ref = ConanFileReference.loads("lib/0.1@user/channel")
source_folder = client.client_cache.source(conan_ref)
link_source = load(os.path.join(source_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_source))
build_folder = client.client_cache.build(package_ref)
link_build = load(os.path.join(build_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_build))
package_folder = client.client_cache.package(package_ref)
link_package = load(os.path.join(package_folder, ".conan_link"))
self.assertTrue(os.path.exists(link_package))
client.run("remove lib* -f")
self.assertFalse(os.path.exists(link_source))
self.assertFalse(os.path.exists(link_build))
self.assertFalse(os.path.exists(link_package))
def check_conaninfo_completion_test(self):
"""
consumer -> B -> C
-> D (conditional)
The overwritten environment variables caused by the consumer have to be reflected in B's conaninfo.txt
"""
client = TestClient()
conanfile = """
from conans import ConanFile
class LibConan(ConanFile):
name = "libC"
version = "1.0"
def package_info(self):
self.env_info.MYVAR = "ValueByLibC"
"""
client.save({"conanfile.py": conanfile})
client.run("export . foo/bar")
conanfile = """
from conans import ConanFile
class LibConan(ConanFile):
name = "libD"
version = "1.0"
def package_info(self):
self.env_info.MYVAR = "ValueByLibD"
"""
client.save({"conanfile.py": conanfile})
client.run("export . foo/bar")
conanfile = """
import os
from conans import ConanFile
class LibConan(ConanFile):
name = "libB"
version = "1.0"
def requirements(self):
if os.environ.get("DEP", None) == "C":
self.requires.add("libC/1.0@foo/bar")
else:
self.requires.add("libD/1.0@foo/bar")
def build_info(self):
self.output.warn("Value of MYVAR: %s" % os.environ["MYVAR"])
"""
client.save({"conanfile.py": conanfile})
client.run("export . foo/bar")
refb = PackageReference.loads("libB/1.0@foo/bar:5fecb9aaf431791c8c06ab146f3451823f982bb8")
# With no overrides, B takes dependency D and the value should be ValueByLibD
client.run("install libB/1.0@foo/bar --build")
self.assertTrue("Value of MYVAR: ValueByLibD")
conaninfo = load(os.path.join(client.client_cache.package(refb), CONANINFO))
self.assertTrue(conaninfo.endswith("[env]\n\n")) # Not user input env
# B takes dependency C and the value should be ValueByLibC
client.run("install libB/1.0@foo/bar --build -e DEP=C")
self.assertTrue("Value of MYVAR: ValueByLibC")
conaninfo = load(os.path.join(client.client_cache.package(refb), CONANINFO))
self.assertTrue(conaninfo.endswith("[env]\n\n")) # Not user input env
# Consumer overrides MYVAR, so his conaninfo should have it
client.run("install libB/1.0@foo/bar --build -e MYVAR=ValueByConsumer")
self.assertTrue("Value of MYVAR: ValueByConsumer")
conaninfo = load(os.path.join(client.client_cache.package(refb), CONANINFO))
self.assertTrue(conaninfo.endswith("[env]\n MYVAR=ValueByConsumer\n"))
# Consumer overrides MYVAR, so his conaninfo should have it, but not the libC, because
# is not a dependency
client.run("install libB/1.0@foo/bar --build -e libB:MYVAR=ValueByConsumer "
"-e libC:MYVAR=OtherValue")
self.assertTrue("Value of MYVAR: ValueByConsumer")
conaninfo = load(os.path.join(client.client_cache.package(refb), CONANINFO))
self.assertTrue(conaninfo.endswith("[env]\n libB:MYVAR=ValueByConsumer\n"))
# Consumer overrides MYVAR, so his conaninfo should have it, both libB and libD
client.run("install libB/1.0@foo/bar --build -e libB:MYVAR=ValueByConsumer "
"-e libD:MYVAR=OtherValue")
self.assertTrue("Value of MYVAR: ValueByConsumer")
conaninfo = load(os.path.join(client.client_cache.package(refb), CONANINFO))
self.assertTrue(conaninfo.endswith("[env]\n libB:MYVAR=ValueByConsumer\n"
" libD:MYVAR=OtherValue\n")) # Not user input env
def deserialize(data):
return RequirementsList([PackageReference.loads(line) for line in data])
def deserialize(data):
ret = RequirementsInfo({}, None)
for ref, requinfo in data.items():
ref = PackageReference.loads(ref)
ret._data[ref] = RequirementInfo.deserialize(requinfo)
return ret
