293-actualize-main-with-develop

.github/workflows/integration-tests.yml

@@ -0,0 +1,18 @@
+name: integration-tests [experimental]
+on: [pull_request]
+jobs:
+  integration_tests:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: 3.11
+      - name: Install dependencies
+        run: pip install --no-cache-dir -U pip .['test']
+      - name: Docker login
+        run: docker login -u kamforka -p ${{ secrets.DOCKER_TOKEN }}
+      - name: Run integration tests
+        run: scripts/ci.py --test

.github/workflows/ci.yml → .github/workflows/static-checks.yml

@@ -1,4 +1,4 @@
-name: CI
+name: static-checks
 on: [pull_request]
 jobs:
   build:
@@ -15,12 +15,12 @@ jobs:
       - name: Install dependencies
         run: pip install --no-cache-dir -U pip .['dev']
       - name: Lint check with flake8
-        run: scripts/ci.py lint
+        run: scripts/ci.py --lint
       - name: Format check with black
-        run: scripts/ci.py format
+        run: scripts/ci.py --format
       - name: Type check with mypy
-        run: scripts/ci.py type 
+        run: scripts/ci.py --type 
       - name: CVE check with pip-audit
-        run: scripts/ci.py cve
+        run: scripts/ci.py --cve
       - name: Security check with bandit
-        run: scripts/ci.py security
+        run: scripts/ci.py --security

pyproject.toml

@@ -28,11 +28,14 @@ authors = [{ name = "Szabolcs Antal", email = "antalszabolcs01@gmail.com" }]
 audit = ["bandit", "pip-audit"]
 build = ["build", "twine"]
 lint = ["black", "flake8", "mypy", "pre-commit"]
-test = ["pytest"]
+test = ["pytest", "pytest-cov"]
 dev = ["thehive4py[audit, lint, test, build]"]
 
 [tool.setuptools.packages.find]
 include = ["thehive4py*"]
 
 [tool.setuptools.package-data]
 thehive4py = ["py.typed"]
+
+[tool.coverage.run]
+omit = ["tests/*", "thehive4py/types/*"]

scripts/ci.py

@@ -1,141 +1,154 @@
 #!/usr/bin/env python
 import argparse
 import subprocess
+from typing import List
 
 
 def _run_subprocess(
-    args: str,
+    command: str,
     init_message: str,
     success_message: str,
-    error_message: str,
-    verbose=False,
+    quiet=False,
 ):
     print(init_message)
-    proc = subprocess.run(args, shell=True, capture_output=True)
 
-    process_output = proc.stdout.decode() or proc.stderr.decode()
-    indented_process_output = "\n".join(
-        [f"\t{output_line}" for output_line in process_output.splitlines()]
-    )
-
-    if proc.returncode != 0:
-        exit_message = "\n".join([error_message, indented_process_output])
-        exit(exit_message)
+    if not quiet:
+        stdout = stderr = None
+    else:
+        stdout = stderr = subprocess.DEVNULL
 
-    if verbose:
-        print(indented_process_output)
+    import shlex
 
-    print(success_message)
+    try:
+        subprocess.run(shlex.split(command), stdout=stdout, stderr=stderr, check=True)
+    except subprocess.CalledProcessError as err:
+        error_output = (
+            f"ERROR: Execution of command '{command}' returned: {err.returncode}\n"
+        )
+        print(error_output)
+        exit(err.returncode)
+    else:
+        print(success_message, end="\n\n")
 
 
-def check_all(verbose=False):
+def check_all(quiet=False):
     print("Run all checks...")
-    check_lint(verbose=verbose)
-    check_format(verbose=verbose)
-    check_type(verbose=verbose)
-    check_cve(verbose=verbose)
-    check_security(verbose=verbose)
+    check_lint(quiet=quiet)
+    check_format(quiet=quiet)
+    check_type(quiet=quiet)
+    check_cve(quiet=quiet)
+    check_security(quiet=quiet)
     print("All checks succeeded!")
 
 
-def check_lint(verbose=False):
+def check_lint(quiet=False):
     _run_subprocess(
-        args="flake8 thehive4py/ tests/",
+        command="flake8 thehive4py/ tests/",
         init_message="Run lint checks with flake8...",
         success_message="Lint checks succeeded!",
-        error_message="Lint checks failed due to:",
-        verbose=verbose,
+        quiet=quiet,
     )
 
 
-def check_format(verbose=False):
+def check_format(quiet=False):
     _run_subprocess(
-        args="black --diff thehive4py/ tests/",
+        command="black --check thehive4py/ tests/",
         init_message="Run format checks with black...",
         success_message="Format checks succeeded!",
-        error_message="Lint checks failed due to:",
-        verbose=verbose,
+        quiet=quiet,
     )
 
 
-def check_type(verbose=False):
+def check_type(quiet=False):
     _run_subprocess(
-        args="mypy --install-types --non-interactive thehive4py/",
+        command="mypy --install-types --non-interactive thehive4py/",
         init_message="Run type checks with mypy...",
         success_message="Type checks succeeded!",
-        error_message="Type checks failed due to:",
-        verbose=verbose,
+        quiet=quiet,
     )
 
 
-def check_cve(verbose=False):
+def check_cve(quiet=False):
     _run_subprocess(
-        args="pip-audit .",
+        command="pip-audit .",
         init_message="Run CVE checks with pip-audit...",
         success_message="CVE checks succeeded!",
-        error_message="CVE checks failed due to:",
-        verbose=verbose,
+        quiet=quiet,
     )
 
 
-def check_security(verbose=False):
+def check_security(quiet=False):
     _run_subprocess(
-        args="bandit -r thehive4py/",
+        command="bandit -r thehive4py/",
         init_message="Run security checks with bandit...",
         success_message="Security checks succeeded!",
-        error_message="Security checks failed due to:",
-        verbose=verbose,
+        quiet=quiet,
+    )
+
+
+def check_test(quiet=False):
+    _run_subprocess(
+        command="pytest -v --cov",
+        init_message="Run integration tests with pytest...",
+        success_message="Integration tests succeeded!",
+        quiet=quiet,
     )
 
 
-def parse_arguments():
-    main_parser = argparse.ArgumentParser(
+def build_check_options() -> List[dict]:
+    return [
+        {"name": "lint", "help": "run lint checks", "check": check_lint},
+        {"name": "format", "help": "run format checks", "check": check_format},
+        {"name": "type", "help": "run type checks", "check": check_type},
+        {"name": "cve", "help": "run cve checks", "check": check_cve},
+        {"name": "security", "help": "run security checks", "check": check_security},
+        {"name": "test", "help": "run integration tests", "check": check_test},
+    ]
+
+
+def parse_arguments(check_options: List[dict]):
+    parser = argparse.ArgumentParser(
         prog="thehive4py-ci",
         description=(
-            "run all ci checks or use sub commands to run ci checks individually"
+            "run all ci checks except tests by default, "
+            "use options to run ci checks selectively"
         ),
     )
-    main_parser.add_argument(
-        "-v",
-        "--verbose",
+    parser.add_argument(
+        "-q",
+        "--quiet",
         action="store_true",
         default=False,
-        help="generate verbose output",
+        help="silence verbose output",
     )
-    main_parser.set_defaults(func=check_all)
-
-    subparsers = main_parser.add_subparsers(help="commands")
-    subparser_options = [
-        {"name": "lint", "help": "run lint checks only", "default_func": check_lint},
-        {
-            "name": "format",
-            "help": "run format checks only",
-            "default_func": check_format,
-        },
-        {"name": "type", "help": "run type checks only", "default_func": check_type},
-        {"name": "cve", "help": "run cve checks only", "default_func": check_cve},
-        {
-            "name": "security",
-            "help": "run security checks",
-            "default_func": check_security,
-        },
-    ]
-
-    for subparser_option in subparser_options:
-        _subparser = subparsers.add_parser(
-            name=subparser_option["name"],
-            help=subparser_option["help"],
-            parents=[main_parser],
-            add_help=False,
+    for check_option in check_options:
+        parser.add_argument(
+            f"--{check_option['name']}",
+            help=check_option["help"],
+            action="store_true",
         )
-        _subparser.set_defaults(func=subparser_option["default_func"])
 
-    return main_parser.parse_args()
+    return parser.parse_args()
 
 
 def main():
-    args = parse_arguments()
-    args.func(verbose=args.verbose)
+    check_options = build_check_options()
+    args = parse_arguments(check_options=check_options)
+
+    quiet = args.quiet
+
+    selective_checks = [
+        check_option["check"]
+        for check_option in check_options
+        if getattr(args, check_option["name"])
+    ]
+
+    if selective_checks:
+        for check in selective_checks:
+            check(quiet=quiet)
+    else:
+        check_all(quiet=quiet)
+    print()
 
 
 if __name__ == "__main__":