def install_reference(self, reference, settings=None, options=None, env=None,
remote_name=None, verify=None, manifests=None,
manifests_interactive=None, build=None, profile_name=None,
update=False, generators=None, install_folder=None, cwd=None):
try:
recorder = ActionRecorder()
cwd = cwd or os.getcwd()
install_folder = _make_abs_path(install_folder, cwd)
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
if not generators: # We don't want the default txt
generators = False
mkdir(install_folder)
manager = self._init_manager(recorder)
manager.install(reference=reference, install_folder=install_folder,
remote_name=remote_name, profile=profile, build_modes=build,
update=update, manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators)
return recorder.get_info()
except ConanException as exc:
recorder.error = True
exc.info = recorder.get_info()
raise
def test_returns_on_failures(self):
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers = {"default": test_server}
class Response(object):
ok = None
status_code = None
charset = None
text = ""
headers = {}
def __init__(self, ok, status_code):
self.ok = ok
self.status_code = status_code
class BuggyRequester(object):
def __init__(self, *args, **kwargs):
pass
def get(self, *args, **kwargs):
return Response(False, 404)
client2 = TestClient(servers=servers, requester_class=BuggyRequester)
conan_ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
registry = RemoteRegistry(client2.client_cache.registry, client2.out)
installer = ConanProxy(client2.paths,
client2.user_io.out,
client2.remote_manager,
registry=registry)
with self.assertRaises(NotFoundException):
installer.get_recipe(conan_ref, False, False, None,
ActionRecorder())
class BuggyRequester2(BuggyRequester):
def get(self, *args, **kwargs):
return Response(False, 500)
client2 = TestClient(servers=servers, requester_class=BuggyRequester2)
registry = RemoteRegistry(client2.client_cache.registry, client2.out)
installer = ConanProxy(client2.paths,
client2.user_io.out,
client2.remote_manager,
registry=registry)
try:
installer.get_recipe(conan_ref, False, False, None,
ActionRecorder())
except NotFoundException:
self.assertFalse(True) # Shouldn't capture here
except ConanException:
pass
def install(self, path="", settings=None, options=None, env=None,
remote_name=None, verify=None, manifests=None,
manifests_interactive=None, build=None, profile_name=None,
update=False, generators=None, no_imports=False, install_folder=None, cwd=None):
try:
recorder = ActionRecorder()
cwd = cwd or os.getcwd()
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
wspath = _make_abs_path(path, cwd)
if install_folder:
if os.path.isabs(install_folder):
wsinstall_folder = install_folder
else:
wsinstall_folder = os.path.join(cwd, install_folder)
else:
wsinstall_folder = None
workspace = Workspace.get_workspace(wspath, wsinstall_folder)
if workspace:
self._user_io.out.success("Using conanws.yml file from %s" % workspace._base_folder)
manager = self._init_manager(recorder)
manager.install_workspace(profile, workspace, remote_name, build, update)
return
install_folder = _make_abs_path(install_folder, cwd)
conanfile_path = _get_conanfile_path(path, cwd, py=None)
manager = self._init_manager(recorder)
manager.install(reference=conanfile_path,
install_folder=install_folder,
remote_name=remote_name,
profile=profile,
build_modes=build,
update=update,
manifest_folder=manifest_folder,
manifest_verify=manifest_verify,
manifest_interactive=manifest_interactive,
generators=generators,
no_imports=no_imports)
return recorder.get_info()
except ConanException as exc:
recorder.error = True
exc.info = recorder.get_info()
raise
def inspect(self, path, attributes, remote_name=None):
try:
reference = ConanFileReference.loads(path)
except ConanException:
reference = None
cwd = get_cwd()
conanfile_path = _get_conanfile_path(path, cwd, py=True)
else:
update = True if remote_name else False
result = self._proxy.get_recipe(reference, update, update, remote_name,
ActionRecorder())
conanfile_path, _, _, reference = result
conanfile = self._loader.load_basic(conanfile_path, self._user_io.out)
result = OrderedDict()
if not attributes:
attributes = ['name', 'version', 'url', 'license', 'author', 'description',
'generators', 'exports', 'exports_sources', 'short_paths',
'apply_env', 'build_policy']
for attribute in attributes:
try:
attr = getattr(conanfile, attribute)
result[attribute] = attr
except AttributeError as e:
raise ConanException(str(e))
return result
def build_graph(self,
content,
profile_build_requires=None,
ref=None,
create_ref=None,
install=True):
path = temp_folder()
path = os.path.join(path, "conanfile.py")
save(path, str(content))
self.loader.cached_conanfiles = {}
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = [] # Means build all
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options, root_ref=ref)
deps_graph, _ = self.manager.load_graph(path, create_ref, graph_info,
build_mode, check_updates,
update, remotes, recorder)
if install:
self.binary_installer.install(deps_graph, None, False, graph_info)
return deps_graph
def __call__(self, require):
try:
m, reference = self._modules[require]
self._references.append(reference)
return m
except KeyError:
r = ConanFileReference.loads(require)
requirement = Requirement(r)
self._range_resolver.resolve(requirement,
"python_require",
update=False,
remote_name=None)
r = requirement.conan_reference
result = self._proxy.get_recipe(r,
False,
False,
remote_name=None,
recorder=ActionRecorder())
path, _, _, reference = result
self._references.append(reference)
try:
sys.path.append(os.path.dirname(path))
module = imp.load_source("python_require", path)
finally:
sys.path.pop()
self._modules[require] = module, reference
return module
def test(self,
path,
reference,
profile_name=None,
settings=None,
options=None,
env=None,
remote=None,
update=False,
build_modes=None,
cwd=None,
test_build_folder=None):
settings = settings or []
options = options or []
env = env or []
conanfile_path = _get_conanfile_path(path, cwd, py=True)
cwd = cwd or get_cwd()
profile = profile_from_args(profile_name, settings, options, env, cwd,
self._client_cache)
reference = ConanFileReference.loads(reference)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
pt = PackageTester(manager, self._user_io)
pt.install_build_and_test(conanfile_path,
reference,
profile,
remote,
update,
build_modes=build_modes,
test_build_folder=test_build_folder)
def _build_graph(self, profile_host, profile_build, install=False):
path = temp_folder()
path = os.path.join(path, "conanfile.txt")
save(path, textwrap.dedent("""
[requires]
app/testing@user/channel
"""))
ref = ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile_host=profile_host, profile_build=profile_build,
options=options, root_ref=ref)
recorder = ActionRecorder()
app = self._get_app()
deps_graph = app.graph_manager.load_graph(path, create_reference=None, graph_info=graph_info,
build_mode=[], check_updates=False, update=False,
remotes=Remotes(), recorder=recorder)
if install:
build_mode = [] # Means build all
binary_installer = BinaryInstaller(app, recorder)
build_mode = BuildMode(build_mode, app.out)
binary_installer.install(deps_graph, None, build_mode, update=False,
profile_host=profile_host, profile_build=profile_build,
graph_lock=None,
keep_build=False)
return deps_graph
def _look_for_require(self, require):
try:
python_require = self._cached_requires[require]
except KeyError:
ref = ConanFileReference.loads(require)
requirement = Requirement(ref)
self._range_resolver.resolve(requirement,
"python_require",
update=False,
remote_name=None)
ref = requirement.ref
result = self._proxy.get_recipe(ref,
self._check_updates,
self._update,
remote_name=self._remote_name,
recorder=ActionRecorder())
path, _, _, new_ref = result
module, conanfile = parse_conanfile(conanfile_path=path,
python_requires=self)
# Check for alias
if getattr(conanfile, "alias", None):
# Will register also the aliased
python_require = self._look_for_require(conanfile.alias)
else:
python_require = PythonRequire(new_ref, module, conanfile)
self._cached_requires[require] = python_require
return python_require
def package(self,
path,
build_folder,
package_folder,
source_folder=None,
install_folder=None,
cwd=None):
cwd = cwd or get_cwd()
conanfile_path = _get_conanfile_path(path, cwd, py=True)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder,
cwd,
default=build_folder)
source_folder = _make_abs_path(source_folder,
cwd,
default=os.path.dirname(conanfile_path))
default_pkg_folder = os.path.join(build_folder, "package")
package_folder = _make_abs_path(package_folder,
cwd,
default=default_pkg_folder)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.local_package(package_folder, conanfile_path, build_folder,
source_folder, install_folder)
def _look_for_require(self, reference):
ref = ConanFileReference.loads(reference)
ref = self.locked_versions[ref.name] if self.locked_versions is not None else ref
try:
python_require = self._cached_requires[ref]
except KeyError:
requirement = Requirement(ref)
self._range_resolver.resolve(requirement, "python_require", update=self._update,
remotes=self._remotes)
ref = requirement.ref
result = self._proxy.get_recipe(ref, self._check_updates, self._update,
remotes=self._remotes,
recorder=ActionRecorder())
path, _, _, new_ref = result
module, conanfile = parse_conanfile(conanfile_path=path, python_requires=self)
# Check for alias
if getattr(conanfile, "alias", None):
# Will register also the aliased
python_require = self._look_for_require(conanfile.alias)
else:
package_layout = self._proxy._cache.package_layout(new_ref, conanfile.short_paths)
exports_sources_folder = package_layout.export_sources()
exports_folder = package_layout.export()
python_require = PythonRequire(new_ref, module, conanfile,
exports_folder, exports_sources_folder)
self._cached_requires[ref] = python_require
return python_require
def build_consumer(self,
path,
profile_build_requires=None,
ref=None,
create_ref=None,
install=True):
profile = Profile()
if profile_build_requires:
profile.build_requires = profile_build_requires
profile.process_settings(self.cache)
update = check_updates = False
recorder = ActionRecorder()
remotes = Remotes()
build_mode = [] # Means build all
ref = ref or ConanFileReference(None, None, None, None, validate=False)
options = OptionsValues()
graph_info = GraphInfo(profile, options, root_ref=ref)
app = self._get_app()
deps_graph = app.graph_manager.load_graph(path, create_ref, graph_info,
build_mode, check_updates,
update, remotes, recorder)
if install:
binary_installer = BinaryInstaller(app, recorder)
build_mode = BuildMode(build_mode, app.out)
binary_installer.install(deps_graph, None, build_mode, update,
False, graph_info)
return deps_graph
def build(self,
conanfile_path,
source_folder=None,
package_folder=None,
build_folder=None,
install_folder=None,
should_configure=True,
should_build=True,
should_install=True,
cwd=None):
cwd = cwd or get_cwd()
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder,
cwd,
default=build_folder)
source_folder = _make_abs_path(source_folder,
cwd,
default=os.path.dirname(conanfile_path))
default_pkg_folder = os.path.join(build_folder, "package")
package_folder = _make_abs_path(package_folder,
cwd,
default=default_pkg_folder)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.build(conanfile_path,
source_folder,
build_folder,
package_folder,
install_folder,
should_configure=should_configure,
should_build=should_build,
should_install=should_install)
def remove(self, pattern, query=None, packages=None, builds=None, src=False, force=False,
remote=None, outdated=False):
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.remove(pattern, package_ids_filter=packages, build_ids=builds,
src=src, force=force, remote_name=remote, packages_query=query,
outdated=outdated)
def download(self, reference, remote=None, package=None, recipe=False):
if package and recipe:
raise ConanException("recipe parameter cannot be used together with package")
# Install packages without settings (fixed ids or all)
conan_ref = ConanFileReference.loads(reference)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.download(conan_ref, package, remote_name=remote, recipe=recipe)
def download(self, reference, remote_name=None, package=None, recipe=False):
if package and recipe:
raise ConanException("recipe parameter cannot be used together with package")
# Install packages without settings (fixed ids or all)
conan_ref = ConanFileReference.loads(reference)
recorder = ActionRecorder()
download(conan_ref, package, remote_name, recipe, self._registry, self._remote_manager,
self._client_cache, self._user_io.out, recorder, self._loader)
def info(self, reference, remote_name=None, settings=None, options=None, env=None,
profile_name=None, update=False, install_folder=None, build=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
deps_graph, conanfile, _ = self._graph_manager.load_graph(reference, None, profile, build, update,
False, remote_name, recorder, workspace=None)
return deps_graph, conanfile
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None,
profile_name=None, remote_name=None, check_updates=None, install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
deps_graph, conanfile, _ = self._graph_manager.load_graph(reference, None, profile, build_modes, check_updates,
False, remote_name, recorder, workspace=None)
nodes_to_build = deps_graph.nodes_to_build()
return nodes_to_build, conanfile
def info_build_order(self, reference, settings=None, options=None, env=None,
profile_name=None, remote_name=None, build_order=None, check_updates=None,
install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
deps_graph, _, _ = self._graph_manager.load_graph(reference, None, profile, ["missing"], check_updates,
False, remote_name, recorder, workspace=None)
return deps_graph.build_order(build_order)
def export_pkg(self, conanfile_path, name, channel, source_folder=None, build_folder=None,
package_folder=None, install_folder=None, profile_name=None, settings=None,
options=None, env=None, force=False, user=None, version=None, cwd=None):
settings = settings or []
options = options or []
env = env or []
cwd = cwd or get_cwd()
# Checks that info files exists if the install folder is specified
if install_folder and not existing_info_files(_make_abs_path(install_folder, cwd)):
raise ConanException("The specified install folder doesn't contain '%s' and '%s' "
"files" % (CONANINFO, BUILD_INFO))
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
if package_folder:
if build_folder or source_folder:
raise ConanException("package folder definition incompatible with build and source folders")
package_folder = _make_abs_path(package_folder, cwd)
build_folder = _make_abs_path(build_folder, cwd)
install_folder = _make_abs_path(install_folder, cwd, default=build_folder)
source_folder = _make_abs_path(source_folder, cwd, default=os.path.dirname(conanfile_path))
# Checks that no both settings and info files are specified
if install_folder and existing_info_files(install_folder) and \
(profile_name or settings or options or env):
raise ConanException("%s and %s are found, at '%s' folder, so specifying profile, "
"settings, options or env is not allowed" % (CONANINFO, BUILD_INFO,
install_folder))
infos_present = existing_info_files(install_folder)
if not infos_present:
profile = profile_from_args(profile_name, settings, options, env=env,
cwd=cwd, client_cache=self._client_cache)
else:
profile = read_conaninfo_profile(install_folder)
conanfile = load_conanfile_class(conanfile_path)
if (name and conanfile.name and conanfile.name != name) or \
(version and conanfile.version and conanfile.version != version):
raise ConanException("Specified name/version doesn't match with the "
"name/version in the conanfile")
cmd_export(conanfile_path, name, version, user, channel, False,
self._user_io.out, self._client_cache)
if not (name and version):
name = conanfile.name
version = conanfile.version
reference = ConanFileReference(name, version, user, channel)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.export_pkg(reference, source_folder=source_folder, build_folder=build_folder,
package_folder=package_folder, install_folder=install_folder,
profile=profile, force=force)
def test_returns_on_failures(self):
test_server = TestServer([("*/*@*/*", "*")], [("*/*@*/*", "*")])
servers = {"default": test_server}
class Response(object):
ok = None
status_code = None
charset = None
text = ""
headers = {}
def __init__(self, ok, status_code):
self.ok = ok
self.status_code = status_code
class BuggyRequester(object):
def __init__(self, *args, **kwargs):
pass
def get(self, *args, **kwargs):
return Response(False, 404)
client2 = TestClient(servers=servers, requester_class=BuggyRequester)
ref = ConanFileReference.loads("Hello/1.2.1@frodo/stable")
proxy = client2.proxy
remotes = Remotes()
remotes.add("remotename", "url")
with self.assertRaises(NotFoundException):
proxy.get_recipe(ref, False, False, remotes, ActionRecorder())
class BuggyRequester2(BuggyRequester):
def get(self, *args, **kwargs):
return Response(False, 500)
client2 = TestClient(servers=servers, requester_class=BuggyRequester2)
proxy = client2.proxy
try:
proxy.get_recipe(ref, False, False, remotes, ActionRecorder())
except NotFoundException:
self.assertFalse(True) # Shouldn't capture here
except ConanException:
pass
def workspace_install(self,
path,
settings=None,
options=None,
env=None,
remote_name=None,
build=None,
profile_name=None,
update=False,
cwd=None,
install_folder=None):
cwd = cwd or get_cwd()
abs_path = os.path.normpath(os.path.join(cwd, path))
remotes = self.app.load_remotes(remote_name=remote_name, update=update)
# remotes = self.app.cache.registry.load_remotes()
# remotes.select(remote_name)
# self.app.python_requires.enable_remotes(update=update, remotes=remotes)
workspace = Workspace(abs_path, self.app.cache)
graph_info = get_graph_info(profile_name, settings, options, env, cwd,
None, self.app.cache, self.app.out)
self.app.out.info("Configuration:")
self.app.out.writeln(graph_info.profile_host.dumps())
self.app.cache.editable_packages.override(workspace.get_editable_dict())
recorder = ActionRecorder()
deps_graph = self.app.graph_manager.load_graph(workspace.root, None,
graph_info, build, False,
update, remotes, recorder)
print_graph(deps_graph, self.app.out)
# Inject the generators before installing
for node in deps_graph.nodes:
if node.recipe == RECIPE_EDITABLE:
generators = workspace[node.ref].generators
if generators is not None:
tmp = list(node.conanfile.generators)
tmp.extend([g for g in generators if g not in tmp])
node.conanfile.generators = tmp
installer = BinaryInstaller(self.app, recorder)
installer.install(deps_graph,
remotes,
build,
update,
keep_build=False,
graph_info=graph_info)
install_folder = install_folder or cwd
workspace.generate(install_folder, deps_graph, self.app.out)
workspace.build(install_folder, deps_graph, self.app.out, self.app)
def incomplete_process_test(self):
tracer = ActionRecorder()
tracer.recipe_install_error(self.ref1, INSTALL_ERROR_NETWORK, "SSL wtf", "http://drl.com")
tracer.add_recipe_being_developed(self.ref1)
install_info = tracer.get_info()
self.assertTrue(install_info["error"])
self.assertEquals(install_info["installed"][0]["packages"], [])
self.assertEquals(install_info["installed"][0]["recipe"]["dependency"], False)
def info_build_order(self, reference, settings=None, options=None, env=None,
profile_name=None, remote=None, build_order=None, check_updates=None,
install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
graph = manager.info_build_order(reference, profile, build_order, remote, check_updates)
return graph
def info_nodes_to_build(self, reference, build_modes, settings=None, options=None, env=None,
profile_name=None, remote=None, check_updates=None, install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
ret = manager.info_nodes_to_build(reference, profile, build_modes, remote,
check_updates)
ref_list, project_reference = ret
return ref_list, project_reference
def info_get_graph(self, reference, remote=None, settings=None, options=None, env=None,
profile_name=None, update=False, install_folder=None):
reference, profile = self._info_get_profile(reference, install_folder, profile_name, settings,
options, env)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
ret = manager.info_get_graph(reference, remote_name=remote, profile=profile,
check_updates=update)
deps_graph, graph_updates_info, project_reference = ret
return deps_graph, graph_updates_info, project_reference
def double_actions_test(self):
tracer = ActionRecorder()
tracer.recipe_downloaded(self.ref1, "http://drl.com")
tracer.recipe_fetched_from_cache(self.ref1)
tracer.package_downloaded(self.ref_p1, "http://drl.com")
tracer.package_fetched_from_cache(self.ref_p1)
install_info = tracer.get_info()
self.assertFalse(install_info["error"])
first_installed = install_info["installed"][0]
self.assertFalse(first_installed["recipe"]["cache"])
self.assertTrue(first_installed["recipe"]["downloaded"])
self.assertIsNone(first_installed["recipe"]["error"])
self.assertEquals(str(first_installed["recipe"]["id"]), "lib1/1.0@conan/stable")
self.assertFalse(first_installed["packages"][0]["cache"])
self.assertTrue(first_installed["packages"][0]["downloaded"])
self.assertIsNone(first_installed["packages"][0]["error"])
self.assertEquals(first_installed["packages"][0]["remote"], 'http://drl.com')
self.assertEquals(str(first_installed["packages"][0]["id"]), "1")
def source(self, path, source_folder=None, info_folder=None, cwd=None):
cwd = cwd or get_cwd()
conanfile_path = _get_conanfile_path(path, cwd, py=True)
source_folder = _make_abs_path(source_folder, cwd)
info_folder = _make_abs_path(info_folder, cwd)
mkdir(source_folder)
if not os.path.exists(info_folder):
raise ConanException("Specified info-folder doesn't exist")
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.source(conanfile_path, source_folder, info_folder)
def create(self, conanfile_path, name=None, version=None, user=None, channel=None,
profile_name=None, settings=None,
options=None, env=None, test_folder=None, not_export=False,
build_modes=None,
keep_source=False, keep_build=False, verify=None,
manifests=None, manifests_interactive=None,
remote_name=None, update=False, cwd=None, test_build_folder=None):
"""
API method to create a conan package
:param test_folder: default None - looks for default 'test' or 'test_package' folder),
string - test_folder path
False - disabling tests
"""
settings = settings or []
options = options or []
env = env or []
try:
cwd = cwd or os.getcwd()
recorder = ActionRecorder()
conanfile_path = _get_conanfile_path(conanfile_path, cwd, py=True)
reference, conanfile = self._loader.load_export(conanfile_path, name, version, user,
channel)
# Make sure keep_source is set for keep_build
keep_source = keep_source or keep_build
# Forcing an export!
if not not_export:
cmd_export(conanfile_path, conanfile, reference, keep_source, self._user_io.out,
self._client_cache, self._plugin_manager)
if build_modes is None: # Not specified, force build the tested library
build_modes = [conanfile.name]
manifests = _parse_manifests_arguments(verify, manifests, manifests_interactive, cwd)
manifest_folder, manifest_interactive, manifest_verify = manifests
profile = profile_from_args(profile_name, settings, options, env,
cwd, self._client_cache)
manager = self._init_manager(recorder)
recorder.add_recipe_being_developed(reference)
create(reference, manager, self._user_io, profile, remote_name, update, build_modes,
manifest_folder, manifest_verify, manifest_interactive, keep_build,
test_build_folder, test_folder, conanfile_path)
return recorder.get_info()
except ConanException as exc:
recorder.error = True
exc.info = recorder.get_info()
raise
def incomplete_process_test(self):
tracer = ActionRecorder()
tracer.recipe_install_error(self.ref1, INSTALL_ERROR_NETWORK, "SSL wtf", "http://drl.com")
tracer.add_recipe_being_developed(self.ref1)
install_info = tracer.get_info()
self.assertTrue(install_info["error"])
self.assertEquals(install_info["installed"][0]["packages"], [])
self.assertEquals(install_info["installed"][0]["recipe"]["dependency"], False)
def _load_pyreq_conanfile(self, loader, lock_python_requires, ref):
recipe = self._proxy.get_recipe(ref, self._check_updates, self._update,
remotes=self._remotes, recorder=ActionRecorder())
path, _, _, new_ref = recipe
conanfile, module = loader.load_basic_module(path, lock_python_requires, user=new_ref.user,
channel=new_ref.channel)
conanfile.name = new_ref.name
conanfile.version = str(new_ref.version) \
if os.environ.get(CONAN_V2_MODE_ENVVAR, False) else new_ref.version
if getattr(conanfile, "alias", None):
ref = ConanFileReference.loads(conanfile.alias)
conanfile, module, new_ref, path = self._load_pyreq_conanfile(loader,
lock_python_requires,
ref)
return conanfile, module, new_ref, os.path.dirname(path)
def imports(self, path, dest=None, info_folder=None, cwd=None):
"""
:param path: Path to the conanfile
:param dest: Dir to put the imported files. (Abs path or relative to cwd)
:param info_folder: Dir where the conaninfo.txt and conanbuildinfo.txt files are
:param cwd: Current working directory
:return: None
"""
cwd = cwd or get_cwd()
info_folder = _make_abs_path(info_folder, cwd)
dest = _make_abs_path(dest, cwd)
mkdir(dest)
conanfile_abs_path = _get_conanfile_path(path, cwd, py=None)
recorder = ActionRecorder()
manager = self._init_manager(recorder)
manager.imports(conanfile_abs_path, dest, info_folder)
def test_install(self):
tracer = ActionRecorder()
tracer.recipe_fetched_from_cache(self.ref1)
tracer.package_downloaded(self.ref_p1, "http://drl.com")
tracer.recipe_downloaded(self.ref2, "http://drl.com")
tracer.package_install_error(self.ref_p2, INSTALL_ERROR_MISSING, "no package found",
remote="https://drl.com")
tracer.recipe_fetched_from_cache(self.ref3)
tracer.package_built(self.ref_p3)
tracer.add_recipe_being_developed(self.ref1)
install_info = tracer.get_info()
self.assertTrue(install_info["error"])
first_installed = install_info["installed"][0]
self.assertTrue(first_installed["recipe"]["cache"])
self.assertFalse(first_installed["recipe"]["dependency"])
self.assertFalse(first_installed["recipe"]["downloaded"])
self.assertIsNone(first_installed["recipe"]["error"])
self.assertEquals(str(first_installed["recipe"]["id"]), "lib1/1.0@conan/stable")
self.assertFalse(first_installed["packages"][0]["cache"])
self.assertTrue(first_installed["packages"][0]["downloaded"])
self.assertIsNone(first_installed["packages"][0]["error"])
self.assertEquals(first_installed["packages"][0]["remote"], 'http://drl.com')
self.assertEquals(str(first_installed["packages"][0]["id"]), "1")
second_installed = install_info["installed"][1]
self.assertFalse(second_installed["recipe"]["cache"])
self.assertTrue(second_installed["recipe"]["dependency"])
self.assertTrue(second_installed["recipe"]["downloaded"])
self.assertIsNone(second_installed["recipe"]["error"])
self.assertEquals(str(second_installed["recipe"]["id"]), "lib2/1.0@conan/stable")
self.assertFalse(second_installed["packages"][0]["cache"])
self.assertEquals(second_installed["packages"][0]["error"],
{'type': 'missing', 'description': 'no package found',
'remote': 'https://drl.com'})
self.assertEquals(second_installed["packages"][0]["remote"], 'https://drl.com')
self.assertEquals(str(second_installed["packages"][0]["id"]), "2")
third_installed = install_info["installed"][2]
self.assertTrue(third_installed["recipe"]["dependency"])
self.assertFalse(third_installed["packages"][0]["cache"])
self.assertFalse(third_installed["packages"][0]["error"])
self.assertTrue(third_installed["packages"][0]["built"])
self.assertIsNone(third_installed["packages"][0]["remote"])
self.assertEquals(str(third_installed["packages"][0]["id"]), "3")
