def test_code_manager():
"""Verify the code manager"""
project_dir: str = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"data", "plugins_project")
project: Project = Project(project_dir)
Project.set(project)
project.load()
ModuleTool().install("single_plugin_file")
ModuleTool().install("multiple_plugin_files")
import inmanta_plugins.multiple_plugin_files.handlers as multi
import inmanta_plugins.single_plugin_file as single
mgr = loader.CodeManager()
mgr.register_code("std::File", single.MyHandler)
mgr.register_code("std::Directory", multi.MyHandler)
def assert_content(source_info: SourceInfo, handler) -> str:
filename = inspect.getsourcefile(handler)
content: str
with open(filename, "r", encoding="utf-8") as fd:
content = fd.read()
assert source_info.content == content
assert len(source_info.hash) > 0
return content
# get types
types = dict(mgr.get_types())
assert "std::File" in types
assert "std::Directory" in types
single_type_list: List[SourceInfo] = types["std::File"]
multi_type_list: List[SourceInfo] = types["std::Directory"]
assert len(single_type_list) == 1
single_content: str = assert_content(single_type_list[0], single.MyHandler)
assert len(multi_type_list) == 3
multi_content: str = assert_content(
next(s for s in multi_type_list if s.module_name ==
"inmanta_plugins.multiple_plugin_files.handlers"),
multi.MyHandler)
# get_file_hashes
mgr_contents: Set[str] = {
mgr.get_file_content(hash)
for hash in mgr.get_file_hashes()
}
assert single_content in mgr_contents
assert multi_content in mgr_contents
with pytest.raises(KeyError):
mgr.get_file_content("test")
# register type without source
with pytest.raises(loader.SourceNotFoundException):
mgr.register_code("test2", str)
def deploy_code(self,
conn: protocol.Client,
tid: uuid.UUID,
version: int = None) -> None:
"""Deploy code to the server"""
if version is None:
version = int(time.time())
code_manager = loader.CodeManager()
LOGGER.info("Sending resources and handler source to server")
# Load both resource definition and handlers
for type_name, resource_definition in resource.get_resources():
code_manager.register_code(type_name, resource_definition)
for type_name, handler_definition in Commander.get_providers():
code_manager.register_code(type_name, handler_definition)
LOGGER.info("Uploading source files")
upload_code(conn, tid, version, code_manager)
async def test_batched_code_upload(server_multi, client_multi,
sync_client_multi, environment_multi,
agent_multi, snippetcompiler):
"""Test uploading all code definitions at once"""
config.Config.set("compiler_rest_transport", "request_timeout", "1")
snippetcompiler.setup_for_snippet("""
h = std::Host(name="test", os=std::linux)
f = std::ConfigFile(host=h, path="/etc/motd", content="test", purge_on_delete=true)
""")
version, _ = await snippetcompiler.do_export_and_deploy(do_raise=False)
code_manager = loader.CodeManager()
for type_name, resource_definition in resources.resource.get_resources():
code_manager.register_code(type_name, resource_definition)
for type_name, handler_definition in handler.Commander.get_providers():
code_manager.register_code(type_name, handler_definition)
await asyncio.get_event_loop().run_in_executor(
None, lambda: upload_code(sync_client_multi, environment_multi,
version, code_manager))
for name, source_info in code_manager.get_types():
res = await agent_multi._client.get_code(tid=environment_multi,
id=version,
resource=name)
assert res.code == 200
assert len(source_info) == 2
for info in source_info:
assert info.hash in res.result["sources"]
code = res.result["sources"][info.hash]
assert info.content == code[2]
assert info.requires == code[3]