daktari 0.0.254__py3-none-any.whl → 0.0.255__py3-none-any.whl

daktari/checks/misc.py

@@ -0,0 +1,302 @@
+import logging
+from os.path import expanduser
+from typing import Dict, Optional
+
+from python_hosts import Hosts
+from tabulate import tabulate
+
+from daktari.check import Check, CheckResult
+from daktari.os import OS, check_env_var_exists, get_env_var_value
+from daktari.version_utils import get_simple_cli_version
+from daktari.command_utils import can_run_command
+
+
+class WatchmanInstalled(Check):
+    name = "watchman.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install watchman</cmd>",
+        OS.GENERIC: "Install watchman: https://facebook.github.io/watchman/docs/install.html#buildinstall",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("watchman")
+
+
+class MkcertInstalled(Check):
+    name = "mkcert.installed"
+
+    suggestions = {
+        OS.OS_X: """
+            Install mkcert:
+            <cmd>brew install mkcert</cmd>
+            Install the local CA in the system trust store:
+            <cmd>mkcert -install</cmd>
+            """,
+        OS.GENERIC: """
+            Install mkcert: https://mkcert.dev/#installation
+            Install the local CA in the system trust store:
+            <cmd>mkcert -install</cmd>
+            """,
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("mkcert")
+
+
+class KtlintInstalled(Check):
+    name = "ktlint.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install ktlint</cmd>",
+        OS.GENERIC: "Install ktlint: https://github.com/pinterest/ktlint#installation",
+    }
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("ktlint")
+        return self.validate_semver_expression(
+            "ktlint", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class CmakeInstalled(Check):
+    name = "cmake.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install cmake</cmd>",
+        OS.UBUNTU: "<cmd>apt-get install cmake</cmd>",
+        OS.GENERIC: "Install cmake: https://cmake.org/install/",
+    }
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("cmake")
+        return self.validate_semver_expression(
+            "cmake", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class JqInstalled(Check):
+    name = "jq.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install jq</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install jq</cmd>",
+        OS.GENERIC: "Install jq: https://stedolan.github.io/jq/download/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("jq")
+
+
+class FlywayInstalled(Check):
+    name = "flyway.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install flyway</cmd>",
+        OS.UBUNTU: "<cmd>snap install flyway</cmd>",
+        OS.GENERIC: "Install flyway: https://flywaydb.org/documentation/usage/commandline/#download-and-installation",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("flyway", "-v")
+
+
+class ShellcheckInstalled(Check):
+    name = "shellcheck.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install shellcheck</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install shellcheck</cmd>",
+        OS.GENERIC: "Install shellcheck: https://github.com/koalaman/shellcheck#user-content-installing",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("shellcheck")
+
+
+class MakeInstalled(Check):
+    name = "make.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>xcode-select --install</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install make</cmd>",
+        OS.GENERIC: "Install make: https://www.gnu.org/software/make/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("make")
+
+
+class GccInstalled(Check):
+    name = "gcc.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>xcode-select --install</cmd>",
+        OS.UBUNTU: "<cmd>sudo apt install gcc</cmd>",
+        OS.GENERIC: "Install gcc: https://gcc.gnu.org/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("gcc")
+
+
+class EnvVarSet(Check):
+    def __init__(self, variable_name: str, variable_value: Optional[str] = "", provision_command: str = ""):
+        self.name = f"env.variableSet.{variable_name}"
+        self.suggestions = {OS.GENERIC: provision_command}
+        self.variable_name = variable_name
+        self.variable_value = variable_value
+
+    def check(self) -> CheckResult:
+        if self.variable_value:
+            return self.verify(
+                get_env_var_value(self.variable_name) == self.variable_value,
+                f"{self.variable_name} has <not/> got the required value of {self.variable_value}",
+            )
+        else:
+            return self.verify(check_env_var_exists(self.variable_name), f"{self.variable_name} is <not/> set")
+
+
+class ShfmtInstalled(Check):
+    name = "shfmt.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install shfmt</cmd>",
+        OS.UBUNTU: "<cmd>snap install shfmt</cmd>",
+        OS.GENERIC: "Install shfmt: https://github.com/mvdan/sh",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("shfmt")
+
+
+class Md5SumInstalled(Check):
+    name = "md5sum.installed"
+
+    suggestions = {OS.OS_X: "<cmd>brew install md5sha1sum</cmd>", OS.GENERIC: "Install md5sum"}
+
+    def check(self) -> CheckResult:
+        return self.verify_install("md5sum")
+
+
+class HostAliasesConfigured(Check):
+    name = "hostAliases.configured"
+
+    def __init__(self, required_aliases: Dict[str, str]):
+        self.required_aliases = required_aliases
+        hosts_path = Hosts.determine_hosts_path()
+        entries_text = tabulate([(addr, name) for (name, addr) in self.required_aliases.items()], tablefmt="plain")
+        self.suggestions = {OS.GENERIC: f"Add the following entries to {hosts_path}:\n\n{entries_text}"}
+
+    def check(self) -> CheckResult:
+        hosts = Hosts()
+        entries = [e for e in hosts.entries if e.entry_type in ("ipv4", "ipv6")]
+        entries_dict = {}
+        for entry in entries:
+            for name in entry.names:
+                entries_dict[name] = entry.address
+        logging.debug(f"Hosts file entries: {entries_dict}")
+        for name, address in self.required_aliases.items():
+            if entries_dict.get(name) != address:
+                return self.failed(f"{hosts.path} alias {name} -> {address} not present")
+
+        return self.passed(f"{hosts.path} aliases present")
+
+
+class DirectoryIsOnPath(Check):
+    name = "directory.on.path"
+
+    def __init__(self, directory: str):
+        self.directory = expanduser(directory)  # $PATH won't auto-expand ~
+        self.suggestions = {
+            OS.GENERIC: f"""
+                Append the following line to your profile (~/.bashrc or ~/.zshrc):
+                export PATH="{self.directory}:$PATH
+                """,
+            OS.UBUNTU: f"""
+                Append the following line to your profile (~/.bashrc):
+                export PATH="{self.directory}:$PATH"
+                For first time setup, you can run this:
+                <cmd>echo 'export PATH="{self.directory}:$PATH"' >> ~/.bashrc && source ~/.bashrc</cmd>
+                """,
+            OS.OS_X: f"""
+                Append the following line to your profile (~/.zshrc):
+                export PATH="{self.directory}:$PATH"
+                For first time setup, you can run this:
+                <cmd>echo 'export PATH="{self.directory}:$PATH"' >> ~/.zshrc && source ~/.zshrc</cmd>
+                """,
+        }
+
+    def check(self) -> CheckResult:
+        path_value = get_env_var_value("PATH")
+        return self.verify(path_value.__contains__(self.directory), f"{self.directory} is <not/> on the $PATH")
+
+
+class DetektInstalled(Check):
+    name = "detekt.installed"
+
+    def __init__(
+        self,
+        required_version: Optional[str] = None,
+        recommended_version: Optional[str] = None,
+        install_version: Optional[str] = None,
+    ):
+        self.install_version = install_version
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+        self.suggestions = {
+            OS.OS_X: self.get_install_cmd(),
+            OS.UBUNTU: self.get_install_cmd(),
+            OS.GENERIC: "Install detekt: https://detekt.dev/cli.html#install-the-cli",
+        }
+
+    def get_install_cmd(self) -> str:
+        version = self.install_version or "[desired version - see https://github.com/detekt/detekt/releases]"
+        url = "https://github.com/detekt/detekt/releases/download/v$DETEKT_VERSION/detekt-cli-$DETEKT_VERSION.zip"
+        return f"""
+            <cmd>DETEKT_VERSION={version}</cmd>
+            <cmd>LOCAL_BIN=~/.local/bin</cmd>
+            <cmd>TEMP_FILE=$(mktemp)</cmd>
+            <cmd>mkdir -p "$LOCAL_BIN"</cmd>
+            <cmd>curl -L {url} --output "$TEMP_FILE"</cmd>
+            <cmd>unzip -u "$TEMP_FILE" -d "$LOCAL_BIN"</cmd>
+            <cmd>rm "$TEMP_FILE"</cmd>
+            <cmd>chmod +x "$LOCAL_BIN/detekt-cli-$DETEKT_VERSION/bin/detekt-cli"</cmd>
+            <cmd>ln -f -s "$LOCAL_BIN/detekt-cli-$DETEKT_VERSION/bin/detekt-cli" "$LOCAL_BIN/detekt"</cmd>
+            """
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("detekt")
+        return self.validate_semver_expression(
+            "detekt", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class TaskInstalled(Check):
+    name = "task.installed"
+    suggestions = {
+        OS.OS_X: "<cmd>brew install go-task</cmd>",
+        OS.GENERIC: "Install task: https://taskfile.dev/installation/",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("task")
+
+
+class Rosetta2Installed(Check):
+    name = "rosetta2.installed"
+    run_on = OS.OS_X
+    suggestions = {OS.OS_X: "<cmd>softwareupdate --install-rosetta</cmd>"}
+
+    def check(self) -> CheckResult:
+        return self.verify(
+            can_run_command("arch -x86_64 true"), "Rosetta 2 is installed or not required", "Rosetta 2 is not installed"
+        )

daktari/checks/nodejs.py

@@ -0,0 +1,92 @@
+import logging
+from typing import List, Optional
+
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout, run_command
+from daktari.os import OS
+from daktari.version_utils import try_parse_semver
+
+
+def get_nodejs_version() -> Optional[VersionInfo]:
+    version_output = get_stdout("node --version")
+    version_output = None if version_output is None else version_output.lstrip("v")
+    return try_parse_semver(version_output)
+
+
+def run_nvm(nvm_args: List[str]):
+    return run_command(["sh", "-c", '. "$NVM_DIR/nvm.sh"; nvm "$@"', "--", *nvm_args])
+
+
+def can_run_nvm() -> bool:
+    try:
+        run_nvm(["--version"])
+        return True
+    except Exception:
+        logging.debug("Exception running nvm", exc_info=True)
+        return False
+
+
+def get_nvmrc_version() -> Optional[str]:
+    try:
+        with open(".nvmrc", "r") as nvmrc_file:
+            return nvmrc_file.readline().strip()
+    except IOError:
+        logging.debug("Could not read .nvmrc", exc_info=True)
+        return None
+
+
+class NodeJsVersion(Check):
+    name = "nodejs.version"
+
+    def __init__(self, required_version: str, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+
+    suggestions = {
+        OS.GENERIC: "Install node.js",
+    }
+
+    def check(self) -> CheckResult:
+        nodejs_version = get_nodejs_version()
+        logging.info(f"node.js version: {nodejs_version}")
+        return self.validate_semver_expression(
+            "node.js", nodejs_version, self.required_version, self.recommended_version
+        )
+
+
+class NvmInstalled(Check):
+    name = "nvm.installed"
+
+    suggestions = {OS.GENERIC: "Install nvm from: https://nvm.sh"}
+
+    def check(self) -> CheckResult:
+        return self.verify(can_run_nvm(), "nvm is <not/> installed")
+
+
+class NodeJsVersionMatchesNvmrc(Check):
+    name = "nodejs.nvmrc.version"
+
+    suggestions = {
+        OS.GENERIC: """
+            Run: <cmd>nvm install</cmd> (automatically picks up the right version from .nvmrc)
+            Run: <cmd>nvm use</cmd>
+            Run: <cmd>nvm alias default <version></cmd> to set the default node version to the newly
+            installed one
+            """
+    }
+
+    def check(self) -> CheckResult:
+        nvmrc_version = get_nvmrc_version()
+        if nvmrc_version is None:
+            return self.failed("Missing or invalid .nvmrc file")
+
+        active_version = get_nodejs_version()
+        if active_version is None:
+            return self.failed(f'node.js version "{nvmrc_version}" is not installed')
+
+        if active_version != nvmrc_version:
+            return self.failed(f'the active node.js version is {active_version}, "{nvmrc_version}" is required')
+
+        return self.passed(f"node.js version is {active_version}")

daktari/checks/onepassword.py

@@ -0,0 +1,105 @@
+import grp
+import json
+import os
+from stat import S_IMODE, S_ISGID
+from typing import Optional
+
+from daktari.check import Check, CheckResult
+from daktari.os import OS
+from daktari.command_utils import get_stdout
+from daktari.version_utils import get_simple_cli_version
+
+
+class OnePasswordCliInstalled(Check):
+    name = "onePasswordCli.installed"
+
+    def __init__(self, required_version: Optional[str] = None, recommended_version: Optional[str] = None):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+        self.suggestions = {
+            OS.GENERIC: """
+                Install the 1Password CLI (op):
+                https://support.1password.com/command-line-getting-started/#set-up-the-command-line-tool""",
+            OS.OS_X: """
+                Use these commands to update 1pass-cli to correct version:
+                <cmd>brew tap glean-notes/homebrew-tap git@github.com:glean-notes/homebrew-tap</cmd>
+                <cmd>brew reinstall glean-notes/homebrew-tap/1password-cli</cmd>""",
+        }
+
+    def check(self) -> CheckResult:
+        installed_version = get_simple_cli_version("op")
+        return self.validate_semver_expression(
+            "1Password CLI", installed_version, self.required_version, self.recommended_version
+        )
+
+
+class OnePasswordAccountConfigured(Check):
+    depends_on = [OnePasswordCliInstalled]
+    name = "onePassword.accountConfigured"
+
+    def __init__(self, account_shorthand: str):
+        self.account_shorthand = account_shorthand
+        self.account_url = f"{account_shorthand}.1password.com"
+        self.suggestions = {
+            OS.GENERIC: f"""
+            Use the 1Password desktop app integration: https://developer.1password.com/docs/cli/get-started/#sign-in
+            Otherwise:
+            <cmd>op signin -f --account {self.account_url}</cmd>""",
+        }
+
+    def check(self) -> CheckResult:
+        output = get_stdout("op account list")
+        if output is None:
+            return self.failed("1Password CLI command failed. Make sure it's installed and configured.")
+
+        account_present = contains_account(output, self.account_url)
+
+        if account_present:
+            return self.passed(f"{self.account_shorthand} is configured with OP CLI for the current user")
+        else:
+            return self.failed(f"{self.account_shorthand} is not configured with OP CLI for the current user")
+
+
+def contains_account(op_account_list_output: str, account_url: str) -> bool:
+    return account_url in op_account_list_output
+
+
+# If not set up, this breaks the integration between cli and desktop app (at least on Ubuntu)
+# https://github.com/NeoHsu/asdf-1password-cli/issues/6#issuecomment-1587502411
+class OnePasswordCliOwnedByCorrectGroup(Check):
+    depends_on = [OnePasswordCliInstalled]
+    name = "onePasswordCli.ownedByCorrectGroup"
+    run_on = OS.UBUNTU
+
+    def __init__(self):
+        self.suggestions = {
+            OS.UBUNTU: """
+            Ensure the onepassword-cli group exists:
+            <cmd>sudo groupadd -f onepassword-cli</cmd>
+            Then update the group ownership and set group id when executing:
+            <cmd>sudo chgrp onepassword-cli $(asdf which op) && sudo chmod g+s $(asdf which op)</cmd>
+            """,
+        }
+
+    def check(self) -> CheckResult:
+        op_path = get_stdout(["sh", "-c", "asdf which op"])
+        if op_path is None:
+            return self.failed("op not found")
+
+        op_stat = os.stat(op_path)
+        group_id = op_stat.st_gid
+        group_name = grp.getgrgid(group_id)[0]
+
+        if group_name != "onepassword-cli":
+            return self.failed(f"op group should be onepassword-cli, but was {group_name}")
+
+        if S_IMODE(op_stat.st_mode) & S_ISGID == 0:
+            return self.failed("op does not set groupid when running")
+
+        return self.passed("op has correct group and sets groupid when running")
+
+
+def account_exists(path: str, account_shorthand: str) -> bool:
+    with open(path) as f:
+        config = json.load(f)
+    return any(account.get("shorthand") == account_shorthand for account in config.get("accounts", []))

daktari/checks/python.py

@@ -0,0 +1,16 @@
+from daktari.check import Check, CheckResult
+from daktari.os import OS
+
+
+class PythonInstalled(Check):
+    def __init__(self, required_version: int):
+        self.required_version = required_version
+        self.name = f"python{required_version}.installed"
+        self.suggestions = {
+            OS.OS_X: f"<cmd>brew install python{required_version}</cmd>",
+            OS.UBUNTU: f"<cmd>sudo apt install python{required_version}-dev</cmd>",
+            OS.GENERIC: f"Download python {required_version}: https://www.python.org/downloads/",
+        }
+
+    def check(self) -> CheckResult:
+        return self.verify_install(f"python{self.required_version}")

daktari/checks/ssh.py

@@ -0,0 +1,33 @@
+from daktari.check import Check, CheckResult
+from daktari.file_utils import file_contains_text_regex, get_absolute_path
+from daktari.os import OS, detect_os
+
+
+def is_ssh_configured_to_use_macos_keychain(ssh_config_path: str = "~/.ssh/config") -> bool:
+    absolute_ssh_config_path = get_absolute_path(ssh_config_path)
+    return file_contains_text_regex(
+        absolute_ssh_config_path, "IgnoreUnknown\\s+UseKeychain"
+    ) and file_contains_text_regex(absolute_ssh_config_path, "UseKeychain\\s+yes")
+
+
+class SSHConfigSetup(Check):
+    name = "ssh.config.setup"
+
+    suggestions = {
+        OS.OS_X: """
+            Add "IgnoreUnknown UseKeychain" and "UseKeychain yes" to ~/.ssh/config.
+            E.g:
+                Host *
+                    IgnoreUnknown UseKeychain
+                    UseKeychain yes
+                    IdentityFile ~/.ssh/id_rsa
+            """
+    }
+
+    def check(self) -> CheckResult:
+        if detect_os() != OS.OS_X:
+            return self.passed("Setup not required on non-Macbook devices")
+        else:
+            if not is_ssh_configured_to_use_macos_keychain():
+                return self.failed("'IgnoreUnknown UseKeychain' or 'UseKeychain yes' not present in ~/.ssh/config")
+            return self.passed("~/.ssh/config setup correctly")

daktari/checks/terraform.py

@@ -0,0 +1,70 @@
+import logging
+import re
+from typing import Optional
+
+from semver import VersionInfo
+
+from daktari.check import Check, CheckResult
+from daktari.command_utils import get_stdout
+from daktari.os import OS
+from daktari.version_utils import try_parse_semver
+
+
+class TfenvInstalled(Check):
+    name = "tfenv.installed"
+
+    suggestions = {
+        OS.OS_X: "<cmd>brew install tfenv</cmd>",
+        OS.UBUNTU: """
+            <cmd>git clone https://github.com/tfutils/tfenv.git ~/.tfenv</cmd>
+            <cmd>sudo ln -s ~/.tfenv/bin/* /usr/local/bin</cmd>
+            """,
+        OS.GENERIC: "Install tfenv: https://github.com/tfutils/tfenv",
+    }
+
+    def check(self) -> CheckResult:
+        return self.verify_install("tfenv")
+
+
+class TerraformInstalled(Check):
+    def __init__(
+        self, required_version: Optional[str] = None, recommended_version: Optional[str] = None, use_tfenv: bool = False
+    ):
+        self.required_version = required_version
+        self.recommended_version = recommended_version
+        self.name = "terraform.installed"
+        self.use_tfenv = use_tfenv
+
+        if use_tfenv:
+            self.depends_on = [TfenvInstalled]
+
+            # Read the required tf-version from tfenv (i.e. .terraform-version files)
+            tfenv_version = open(".terraform-version", "r").read().strip()
+            logging.debug(f"Terraform version required from .terraform-version file is: {tfenv_version}")
+            self.required_version = f"=={tfenv_version}"
+            self.suggestions = {OS.GENERIC: "<cmd>tfenv install</cmd>"}
+        else:
+            self.suggestions = {
+                OS.OS_X: "<cmd>brew tap hashicorp/tap && brew install hashicorp/tap/terraform</cmd>",
+                OS.GENERIC: "Install Terraform: https://learn.hashicorp.com/tutorials/terraform/install-cli",
+            }
+
+    def check(self) -> CheckResult:
+        installed_version = get_terraform_version()
+        return self.validate_semver_expression(
+            "Terraform", installed_version, self.required_version, self.recommended_version
+        )
+
+
+version_pattern = re.compile("Terraform v([0-9\\.]+)")
+
+
+def get_terraform_version() -> Optional[VersionInfo]:
+    raw_version = get_stdout("terraform version")
+    if raw_version:
+        match = version_pattern.search(raw_version)
+        if match:
+            version = try_parse_semver(match.group(1))
+            logging.debug(f"Terraform version: {version}")
+            return version
+    return None

daktari/checks/test_certs.py

@@ -0,0 +1,32 @@
+import unittest
+from unittest import mock
+
+from daktari.check import CheckStatus
+from daktari.checks.certs import CertificateIsNotExpired
+from daktari.resource_utils import get_resource_path
+
+
+class TestCertificateIsNotExpired(unittest.TestCase):
+    @mock.patch("daktari.checks.certs.crypto.load_certificate")
+    def test_passes_with_warning_if_cannot_determine_expiry(self, mock_get_not_after):
+        mock_get_not_after.return_value.get_notAfter.return_value = None
+        check = CertificateIsNotExpired(get_resource_path("mock_cert.pem").__str__())
+        result = check.check()
+        self.assertEqual(result.status, CheckStatus.PASS_WITH_WARNING)
+        self.assertEqual(result.summary, "Unable to determine expiry date of mock_cert.pem")
+
+    @mock.patch("daktari.checks.certs.crypto.load_certificate")
+    def test_passes_for_valid_cert(self, mock_get_not_after):
+        mock_get_not_after.return_value.get_notAfter.return_value = b"20501231235959Z"
+        check = CertificateIsNotExpired(get_resource_path("mock_cert.pem").__str__())
+        result = check.check()
+        self.assertEqual(result.status, CheckStatus.PASS)
+        self.assertEqual(result.summary, "mock_cert.pem is not expired")
+
+    @mock.patch("daktari.checks.certs.crypto.load_certificate")
+    def test_fails_for_expired_cert(self, mock_get_not_after):
+        mock_get_not_after.return_value.get_notAfter.return_value = b"20201231235959Z"
+        check = CertificateIsNotExpired(get_resource_path("mock_cert.pem").__str__())
+        result = check.check()
+        self.assertEqual(result.status, CheckStatus.FAIL)
+        self.assertEqual(result.summary, "mock_cert.pem expired on 2020-12-31 23:59:59")