def _scss_files() -> Set[Path]: return set( chain( Path(cmk_path(), "web", "htdocs", "themes").glob("**/*.scss"), Path(cmk_path(), "enterprise", "web", "htdocs", "themes").glob("**/*.scss"), ) )
def test_all_agents_tested(): agents = { os.path.basename(os.path.splitext(agent_file)[0]) for agent_file in glob("%s/cmk/special_agents/agent_*.py" % cmk_path()) } untested = agents - set(REQUIRED_ARGUMENTS) - NOT_TESTED_YET assert not untested, "Please add test cases for special agents %s" % untested
def _git_tag_exists(tag): return (subprocess.Popen( ["git", "rev-list", tag], stdout=open(os.devnull, "w"), stderr=subprocess.STDOUT, cwd=testlib.cmk_path(), ).wait() == 0)
def test_write_precompiled_werks(tmp_path, monkeypatch): tmp_dir = str(tmp_path) all_werks = cmk.utils.werks.load_raw_files(Path(testlib.cmk_path()) / ".werks") cre_werks = {w["id"]: w for w in all_werks.values() if w["edition"] == "cre"} cee_werks = {w["id"]: w for w in all_werks.values() if w["edition"] == "cee"} cme_werks = {w["id"]: w for w in all_werks.values() if w["edition"] == "cme"} assert len(cre_werks) > 1000 assert [w for w in cre_werks.keys() if 9000 <= w < 10000] == [] cmk.utils.werks.write_precompiled_werks(Path(tmp_dir) / "werks", cre_werks) assert len(cee_werks) > 700 cmk.utils.werks.write_precompiled_werks(Path(tmp_dir) / "werks-enterprise", cee_werks) assert len(cme_werks) > 5 cmk.utils.werks.write_precompiled_werks(Path(tmp_dir) / "werks-managed", cme_werks) monkeypatch.setattr(cmk.utils.werks, "_compiled_werks_dir", lambda: Path(tmp_dir)) werks_loaded = cmk.utils.werks.load() merged_werks = cre_werks merged_werks.update(cee_werks) merged_werks.update(cme_werks) assert merged_werks == werks_loaded
def add_file(f, path): relpath = os.path.relpath(os.path.realpath(path), cmk_path()) f.write("# -*- encoding: utf-8 -*-") f.write("#\n") f.write("# ORIG-FILE: " + relpath + "\n") f.write("#\n") f.write("\n") f.write(Path(path).read_text())
def test_permissions() -> None: for pattern, check_func, excludes in _PERMISSIONS: git_dir = Path(cmk_path()) for f in git_dir.glob(pattern): if not f.is_file(): continue if f.name in excludes or f.name in _GLOBAL_EXCLUDES: continue assert check_func(f), "%s has wrong permissions (%r)" % (f, check_func)
def python_container(request, docker_client): c = docker_client.containers.run( image="shimizukawa/python-all", command=["python2.5", "-c", "import time; time.sleep(9999)"], detach=True, volumes={ testlib.cmk_path(): {"bind": "/cmk", "mode": "ro"}, }, ) yield c c.remove(force=True)
def _werks_in_git_tag(tag: str): werks_in_tag = (subprocess.check_output( [b"git", b"ls-tree", b"-r", b"--name-only", tag.encode(), b".werks"], cwd=testlib.cmk_path().encode(), ).decode().split("\n")) # Populate the map of all tags a werk is in for werk_file in werks_in_tag: try: werk_id = int(os.path.basename(werk_file)) except ValueError: continue _werk_to_git_tag[werk_id].append(tag) return werks_in_tag
class CMKModuleLayerChecker(BaseChecker): __implements__ = IAstroidChecker name = "cmk-module-layer-violation" msgs = { "C8410": ("Import of %r not allowed in module %r", "cmk-module-layer-violation", "whoop?"), } # This doesn't change during a pylint run, so let's save a realpath() call per import. cmk_path_cached = cmk_path() + "/" @utils.check_messages("cmk-module-layer-violation") def visit_import(self, node: Import) -> None: for name, _ in node.names: self._check_import(node, ModuleName(name)) @utils.check_messages("cmk-module-layer-violation") def visit_importfrom(self, node: ImportFrom) -> None: # handle 'from . import foo, bar' imported = [node.modname ] if node.modname else [n for n, _ in node.names] for modname in imported: self._check_import( node, ModuleName(modname) if node.level is None else _get_absolute_importee( root_name=node.root().name, modname=modname, level=node.level, is_package=_is_package(node), ), ) def _check_import(self, node: Statement, imported: ModuleName) -> None: # We only care about imports of our own modules. if not imported.startswith("cmk"): return # We use paths relative to our project root, but not for our "pasting magic". absolute_path: str = node.root().file importing_path = ModulePath( removeprefix(absolute_path, self.cmk_path_cached)) # Tests are allowed to import anyting. if str(importing_path).startswith("tests/"): return importing = self._get_module_name_of_files(importing_path) if not self._is_import_allowed(importing_path, importing, imported): self.add_message("cmk-module-layer-violation", node=node, args=(imported, importing)) @staticmethod def _get_module_name_of_files(importing_path: ModulePath) -> ModuleName: # Due to our symlinks and pasting magic, astroid gets confused, so we need to compute the # real module name from the file path of the module. parts = importing_path.split("/") parts[-1] = removesuffix(parts[-1], ".py") # Emacs' flycheck stores files to be checked in a temporary file with a prefix. parts[-1] = removeprefix(parts[-1], "flycheck_") # Strip CEE/CME/CPE prefix, we use symlink magic to combine editions. :-P if parts[:2] in (["enterprise", "cmk"], ["managed", "cmk"], ["plus", "cmk"]): parts = parts[1:] # Pretend that the combined checks and inventory/bakery plugins live below cmk.base. if len(parts) >= 2 and parts[-2].startswith("cmk_pylint_"): parts = ["cmk", "base", parts[-1]] # For all modules which don't live below cmk after mangling, just assume a toplevel module. if parts[0] != "cmk": parts = [parts[-1]] return ModuleName(".".join(parts)) def _is_import_allowed(self, importing_path: ModulePath, importing: ModuleName, imported: ModuleName) -> bool: for component, component_specific_checker in _COMPONENTS: if not self._is_part_of_component(importing, importing_path, component): continue return component_specific_checker( imported=imported, component=component, ) # the rest (matched no component) return _is_allowed_import(imported) @staticmethod def _is_part_of_component(importing: ModuleName, importing_path: ModulePath, component: Component) -> bool: if _in_component(importing, component): return True explicit_component = _EXPLICIT_FILE_TO_COMPONENT.get(importing_path) if explicit_component is not None: return explicit_component == component # The check and bakery plugins are all compiled together by tests/pylint/test_pylint.py. # They clearly belong to the cmk.base component. if component == Component("cmk.base") and importing.startswith( "cmk_pylint"): return True if component == Component( "cmk.notification_plugins") and importing_path.startswith( "notifications/"): return True if component == Component( "cmk.special_agents") and importing_path.startswith( "agents/special/"): return True return False
def _change_path_to_repo_path(self, msg): return os.path.relpath(msg.abspath, cmk_path())
def _get_python_plugins(): return [ "agents/plugins/%s" % p.name for p in Path(testlib.cmk_path(), "agents", "plugins").iterdir() if is_python_file(str(p), "python") or is_python_file(str(p), "python3") ]
def locale_base_dir(): return Path("%s/locale" % cmk_path())
def precompiled_werks(tmp_path, monkeypatch): all_werks = cmk.utils.werks.load_raw_files(Path(testlib.cmk_path()) / ".werks") cmk.utils.werks.write_precompiled_werks(tmp_path / "werks", all_werks) monkeypatch.setattr(cmk.utils.werks, "_compiled_werks_dir", lambda: tmp_path)
def _files_to_scan(): to_scan = [Path(cmk_path(), "web", "app", "index.wsgi")] for matched_file in Path(cmk_path(), "cmk", "gui").glob("**/*.py"): if matched_file.is_file(): to_scan.append(matched_file) return to_scan
# At the moment it's not possible to display attributes and table # below same node. assert filtered_node.count_entries() == 9 assert filtered_node.get_node(["path", "to", "nta", "nt"]) is None assert filtered_node.get_node(["path", "to", "nta", "na"]) is None assert filtered_node.get_node(["path", "to", "another", "node1"]) is not None assert filtered_node.get_node(["path", "to", "another", "node2"]) is not None # Tests with real host data TEST_DIR = "%s/tests/unit/cmk/utils/structured_data/tree_test_data" % cmk_path( ) TEST_DATA_STORE = StructuredDataStore(Path(TEST_DIR)) tree_name_old_addresses_arrays_memory = HostName( "tree_old_addresses_arrays_memory") tree_name_old_addresses = HostName("tree_old_addresses") tree_name_old_arrays = HostName("tree_old_arrays") tree_name_old_interfaces = HostName("tree_old_interfaces") tree_name_old_memory = HostName("tree_old_memory") tree_name_old_heute = HostName("tree_old_heute") tree_name_new_addresses_arrays_memory = HostName( "tree_new_addresses_arrays_memory") tree_name_new_addresses = HostName("tree_new_addresses") tree_name_new_arrays = HostName("tree_new_arrays")