atlas-init 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

atlas_init/cli_tf/example_update_test.py

@@ -0,0 +1,96 @@
+import os
+from pathlib import Path
+
+import pytest
+
+from atlas_init.cli_tf.example_update import (
+    TFConfigDescriptionChange,
+    UpdateExamples,
+    update_examples,
+)
+from atlas_init.cli_tf.hcl.modifier import BLOCK_TYPE_VARIABLE, update_descriptions
+
+
+def test_description_change(tmp_path):
+    assert TFConfigDescriptionChange(
+        block_type=BLOCK_TYPE_VARIABLE,
+        path=tmp_path,
+        name="cluster_name",
+        before="",
+        after="description of cluster name",
+    ).changed
+    assert not TFConfigDescriptionChange(
+        block_type=BLOCK_TYPE_VARIABLE,
+        path=tmp_path,
+        name="cluster_name",
+        before="description of cluster name",
+        after="description of cluster name",
+    ).changed
+    assert not TFConfigDescriptionChange(
+        block_type=BLOCK_TYPE_VARIABLE,
+        path=tmp_path,
+        name="cluster_name",
+        before="description of cluster name",
+        after="",
+    ).changed
+
+
+example_variables_tf = """variable "cluster_name" {
+  type = string
+}
+variable "replication_specs" {
+  description = "List of replication specifications in legacy mongodbatlas_cluster format"
+  default     = []
+  type = list(object({
+    num_shards = number
+    zone_name  = string
+    regions_config = set(object({
+      region_name     = string
+      electable_nodes = number
+      priority        = number
+      read_only_nodes = optional(number, 0)
+    }))
+  }))
+}
+
+variable "provider_name" {
+  type    = string
+  default = "" # optional in v3
+}
+"""
+
+
+def test_update_example(tmp_path, file_regression):
+    base_dir = tmp_path / "example_base"
+    base_dir.mkdir()
+    example_variables_tf_path = base_dir / "example_variables.tf"
+    example_variables_tf_path.write_text(example_variables_tf)
+    output = update_examples(
+        UpdateExamples(
+            examples_base_dir=base_dir,
+            var_descriptions={
+                "cluster_name": "description of cluster name",
+                "replication_specs": "Updated description",
+            },
+        )
+    )
+    assert output.before_var_descriptions == {
+        "cluster_name": "",
+        "provider_name": "",
+        "replication_specs": "List of replication specifications in legacy mongodbatlas_cluster format",
+    }
+    assert len(output.changes) == 3  # noqa: PLR2004
+    assert [
+        ("cluster_name", True),
+        ("provider_name", False),
+        ("replication_specs", True),
+    ] == [(change.name, change.changed) for change in output.changes]
+    file_regression.check(example_variables_tf_path.read_text(), extension=".tf")
+
+
+@pytest.mark.skipif(os.environ.get("TF_FILE", "") == "", reason="needs os.environ[TF_FILE]")
+def test_parsing_tf_file():
+    file = Path(os.environ["TF_FILE"])
+    assert file.exists()
+    response, _ = update_descriptions(file, {}, block_type=BLOCK_TYPE_VARIABLE)
+    assert response

atlas_init/cli_tf/github_logs.py

@@ -27,7 +27,7 @@ from atlas_init.settings.path import (
 
 logger = logging.getLogger(__name__)
 
-GH_TOKEN_ENV_NAME = "GH_TOKEN"  # noqa: S105
+GH_TOKEN_ENV_NAME = "GH_TOKEN"  # noqa: S105 #nosec
 GITHUB_CI_RUN_LOGS_ENV_NAME = "GITHUB_CI_RUN_LOGS"
 GITHUB_CI_SUMMARY_DIR_ENV_NAME = "GITHUB_CI_SUMMARY_DIR_ENV_NAME"
 REQUIRED_GH_ENV_VARS = [GH_TOKEN_ENV_NAME, GITHUB_CI_RUN_LOGS_ENV_NAME]
@@ -88,7 +88,7 @@ def find_test_runs(
     repository = tf_repo()
     for workflow in repository.get_workflow_runs(
         created=f">{since.strftime('%Y-%m-%d')}",
-        branch=branch,
+        branch=branch,  # type: ignore
         exclude_pull_requests=True,  # type: ignore
     ):
         if not include_workflow(workflow):
@@ -130,7 +130,10 @@ def parse_job_logs(job: WorkflowJob, logs_path: Path) -> list[GoTestRun]:
     if job.conclusion in {"skipped", "cancelled", None}:
         return []
     step, logs_lines = select_step_and_log_content(job, logs_path)
-    return list(parse(logs_lines, job, step))
+    test_runs = list(parse(logs_lines, job, step))
+    for run in test_runs:
+        run.log_path = logs_path
+    return test_runs
 
 
 def download_job_safely(workflow_dir: Path, job: WorkflowJob) -> Path | None:

atlas_init/cli_tf/go_test_run.py

@@ -18,7 +18,7 @@ logger = logging.getLogger(__name__)
 
 class GoTestStatus(StrEnum):
     RUN = "RUN"
-    PASS = "PASS"  # noqa: S105
+    PASS = "PASS"  # noqa: S105 #nosec
     FAIL = "FAIL"
     SKIP = "SKIP"
 
@@ -55,6 +55,25 @@ class GoTestContext(Entity):
         # return cls(name=name, steps=steps)
 
 
+def extract_group_name(log_path: Path | None) -> str:
+    """
+    >>> extract_group_name(
+    ...     Path(
+    ...         "40216340925_tests-1.11.x-latest_tests-1.11.x-latest-false_search_deployment.txt"
+    ...     )
+    ... )
+    'search_deployment'
+    >>> extract_group_name(None)
+    ''
+    """
+    if log_path is None:
+        return ""
+    if "-" not in log_path.name:
+        return ""
+    last_part = log_path.stem.split("-")[-1]
+    return "_".join(last_part.split("_")[1:]) if "_" in last_part else last_part
+
+
 @total_ordering
 class GoTestRun(Entity):
     name: str
@@ -112,6 +131,10 @@ class GoTestRun(Entity):
     def is_pass(self) -> bool:
         return self.status == GoTestStatus.PASS
 
+    @property
+    def group_name(self) -> str:
+        return extract_group_name(self.log_path)
+
     def add_line_match(self, match: LineMatch, line: str, line_number: int) -> None:
         self.run_seconds = match.run_seconds or self.run_seconds
         self.finish_line = LineInfo(number=line_number, text=line)

atlas_init/cli_tf/go_test_summary.py

@@ -43,6 +43,10 @@ class GoTestSummary(Entity):
     def success_rate_human(self) -> str:
         return f"{self.success_rate:.2%}"
 
+    @property
+    def group_name(self) -> str:
+        return next((r.group_name for r in self.results if r.group_name), "unknown-group")
+
     def last_pass_human(self) -> str:
         return next(
             (f"Passed {test.when}" for test in reversed(self.results) if test.status == GoTestStatus.PASS),
@@ -124,7 +128,9 @@ def create_detailed_summary(
         test_summary_path = summary_dir_path / f"{summary.success_rate_human}_{summary.name}.md"
         test_summary_md = summary_str(summary, start_test_date, end_test_date)
         file_utils.ensure_parents_write_text(test_summary_path, test_summary_md)
-        top_level_summary.append(f"- {summary.name} ({summary.success_rate_human}) ({summary.last_pass_human()})")
+        top_level_summary.append(
+            f"- {summary.name} - {summary.group_name} ({summary.success_rate_human}) ({summary.last_pass_human()}) ('{test_summary_path}')"
+        )
     return top_level_summary
 
 

atlas_init/cli_tf/hcl/modifier.py

@@ -0,0 +1,144 @@
+import logging
+from collections import defaultdict
+from copy import deepcopy
+from pathlib import Path
+
+import hcl2
+from lark import Token, Tree, UnexpectedToken
+
+logger = logging.getLogger(__name__)
+
+BLOCK_TYPE_VARIABLE = "variable"
+BLOCK_TYPE_OUTPUT = "output"
+
+
+def process_token(node: Token, indent=0):
+    logger.debug(f"[{indent}] (token)\t|", " " * indent, node.type, node.value)
+    return deepcopy(node)
+
+
+def is_identifier_block_type(tree: Tree | Token, block_type: str) -> bool:
+    if not isinstance(tree, Tree):
+        return False
+    try:
+        return tree.children[0].value == block_type  # type: ignore
+    except (IndexError, AttributeError):
+        return False
+
+
+def is_block_type(tree: Tree, block_type: str) -> bool:
+    try:
+        return tree.data == "block" and is_identifier_block_type(tree.children[0], block_type)
+    except (IndexError, AttributeError):
+        return False
+
+
+def update_description(tree: Tree, new_descriptions: dict[str, str], existing_names: dict[str, list[str]]) -> Tree:
+    new_children = tree.children.copy()
+    variable_body = new_children[2]
+    assert variable_body.data == "body"
+    name = token_name(new_children[1])
+    old_description = read_description_attribute(variable_body)
+    existing_names[name].append(old_description)
+    new_description = new_descriptions.get(name, "")
+    if not new_description:
+        logger.debug(f"no description found for variable {name}")
+        return tree
+    new_children[2] = update_body_with_description(variable_body, new_description)
+    return Tree(tree.data, new_children)
+
+
+def token_name(token: Token | Tree) -> str:
+    if isinstance(token, Token):
+        return token.value.strip('"')
+    err_msg = f"unexpected token type {type(token)} for token name"
+    raise ValueError(err_msg)
+
+
+def has_attribute_description(maybe_attribute: Token | Tree) -> bool:
+    if not isinstance(maybe_attribute, Tree):
+        return False
+    return maybe_attribute.data == "attribute" and maybe_attribute.children[0].children[0].value == "description"  # type: ignore
+
+
+def update_body_with_description(tree: Tree, new_description: str) -> Tree:
+    new_description = new_description.replace('"', '\\"')
+    new_children = tree.children.copy()
+    found_description = False
+    for i, maybe_attribute in enumerate(new_children):
+        if has_attribute_description(maybe_attribute):
+            found_description = True
+            new_children[i] = create_description_attribute(new_description)
+    if not found_description:
+        new_children.insert(0, new_line())
+        new_children.insert(1, create_description_attribute(new_description))
+    return Tree(tree.data, new_children)
+
+
+def new_line() -> Tree:
+    return Tree(
+        Token("RULE", "new_line_or_comment"),
+        [Token("NL_OR_COMMENT", "\n  ")],
+    )
+
+
+def read_description_attribute(tree: Tree) -> str:
+    return next(
+        (
+            token_name(maybe_attribute.children[-1].children[0])
+            for maybe_attribute in tree.children
+            if has_attribute_description(maybe_attribute)
+        ),
+        "",
+    )
+
+
+def create_description_attribute(description_value: str) -> Tree:
+    children = [
+        Tree(Token("RULE", "identifier"), [Token("NAME", "description")]),
+        Token("EQ", " ="),
+        Tree(Token("RULE", "expr_term"), [Token("STRING_LIT", f'"{description_value}"')]),
+    ]
+    return Tree(Token("RULE", "attribute"), children)
+
+
+def process_descriptions(
+    node: Tree,
+    name_updates: dict[str, str],
+    existing_names: dict[str, list[str]],
+    depth=0,
+    *,
+    block_type: str,
+) -> Tree:
+    new_children = []
+    logger.debug(f"[{depth}] (tree)\t|", " " * depth, node.data)
+    for child in node.children:
+        if isinstance(child, Tree):
+            if is_block_type(child, block_type):
+                child = update_description(  # noqa: PLW2901
+                    child, name_updates, existing_names
+                )
+            new_children.append(
+                process_descriptions(child, name_updates, existing_names, depth + 1, block_type=block_type)
+            )
+        else:
+            new_children.append(process_token(child, depth + 1))
+
+    return Tree(node.data, new_children)
+
+
+def update_descriptions(tf_path: Path, new_names: dict[str, str], block_type: str) -> tuple[str, dict[str, list[str]]]:
+    try:
+        tree = hcl2.parses(tf_path.read_text())  # type: ignore
+    except UnexpectedToken as e:
+        logger.warning(f"failed to parse {tf_path}: {e}")
+        return "", {}
+    existing_descriptions = defaultdict(list)
+    new_tree = process_descriptions(
+        tree,
+        new_names,
+        existing_descriptions,
+        block_type=block_type,
+    )
+    new_tf = hcl2.writes(new_tree)  # type: ignore
+    return new_tf, existing_descriptions

atlas_init/cli_tf/hcl/modifier_test/test_process_variables_output_.tf

@@ -0,0 +1,25 @@
+provider "mongodbatlas" {
+  public_key  = var.public_key
+  private_key = var.private_key
+}
+
+module "cluster" {
+  source = "../../module_maintainer/v3"
+
+  cluster_name           = var.cluster_name
+  cluster_type           = var.cluster_type
+  mongo_db_major_version = var.mongo_db_major_version
+  project_id             = var.project_id
+  replication_specs_new  = var.replication_specs_new
+  tags                   = var.tags
+}
+
+output "mongodb_connection_strings" {
+  description = "new connection strings desc"
+  value = module.cluster.mongodb_connection_strings
+}
+
+output "with_desc" {
+  value = "with_desc"
+  description = "description new"
+}

atlas_init/cli_tf/hcl/modifier_test/test_process_variables_variable_.tf

@@ -0,0 +1,24 @@
+variable "cluster_name" {
+  description = "description of \"cluster\" name"
+  type = string
+}
+variable "replication_specs" {
+  description = "List of replication specifications in legacy mongodbatlas_cluster format"
+  default     = []
+  type = list(object({
+    num_shards = number
+    zone_name  = string
+    regions_config = set(object({
+      region_name     = string
+      electable_nodes = number
+      priority        = number
+      read_only_nodes = optional(number, 0)
+    }))
+  }))
+}
+
+variable "provider_name" {
+  description = "azure/aws/gcp"
+  type    = string
+  default = ""# optional in v3
+}

atlas_init/cli_tf/hcl/modifier_test.py

@@ -0,0 +1,95 @@
+import pytest
+
+from atlas_init.cli_tf.hcl.modifier import BLOCK_TYPE_OUTPUT, BLOCK_TYPE_VARIABLE, update_descriptions
+
+example_variables_tf = """variable "cluster_name" {
+  type = string
+}
+variable "replication_specs" {
+  description = "List of replication specifications in legacy mongodbatlas_cluster format"
+  default     = []
+  type = list(object({
+    num_shards = number
+    zone_name  = string
+    regions_config = set(object({
+      region_name     = string
+      electable_nodes = number
+      priority        = number
+      read_only_nodes = optional(number, 0)
+    }))
+  }))
+}
+
+variable "provider_name" {
+  type    = string
+  default = "" # optional in v3
+}
+"""
+
+_existing_descriptions_variables = {
+    "cluster_name": [""],
+    "provider_name": [""],
+    "replication_specs": ["List of replication specifications in legacy "],
+}
+
+example_outputs_tf = """provider "mongodbatlas" {
+  public_key  = var.public_key
+  private_key = var.private_key
+}
+
+module "cluster" {
+  source = "../../module_maintainer/v3"
+
+  cluster_name           = var.cluster_name
+  cluster_type           = var.cluster_type
+  mongo_db_major_version = var.mongo_db_major_version
+  project_id             = var.project_id
+  replication_specs_new  = var.replication_specs_new
+  tags                   = var.tags
+}
+
+output "mongodb_connection_strings" {
+  value = module.cluster.mongodb_connection_strings
+}
+
+output "with_desc" {
+  value = "with_desc"
+  description = "description old"
+}
+"""
+_existing_descriptions_outputs = {
+    "mongodb_connection_strings": [""],
+    "with_desc": ["description old"],
+}
+
+
+@pytest.mark.parametrize(
+    ("block_type", "new_names", "existing_descriptions", "tf_config"),
+    [
+        (
+            BLOCK_TYPE_VARIABLE,
+            {
+                "cluster_name": 'description of "cluster" name',
+                "provider_name": "azure/aws/gcp",
+            },
+            _existing_descriptions_variables,
+            example_variables_tf,
+        ),
+        (
+            BLOCK_TYPE_OUTPUT,
+            {
+                "with_desc": "description new",
+                "mongodb_connection_strings": "new connection strings desc",
+            },
+            _existing_descriptions_outputs,
+            example_outputs_tf,
+        ),
+    ],
+    ids=[BLOCK_TYPE_VARIABLE, BLOCK_TYPE_OUTPUT],
+)
+def test_process_variables(tmp_path, file_regression, block_type, new_names, existing_descriptions, tf_config):
+    example_tf_path = tmp_path / "example.tf"
+    example_tf_path.write_text(tf_config)
+    new_tf, existing_descriptions = update_descriptions(example_tf_path, new_names, block_type=block_type)
+    file_regression.check(new_tf, extension=".tf")
+    assert dict(existing_descriptions.items()) == existing_descriptions

atlas_init/cli_tf/hcl/parser.py

@@ -108,7 +108,7 @@ def iter_blocks(block: Block, level: int | None = None) -> Iterable[Block]:
                     hcl="\n".join(block_lines),
                 )
     if line_level_start_names.get(level) is not None:
-        raise ValueError(f"Unfinished block @ {line_nr} in {block.name} at level {level}")
+        raise ValueError(f"Unfinished block @ {line_nr} in {block.name} at level {level}")  # pyright: ignore
 
 
 def hcl_attrs(block: Block) -> dict[str, str]:

atlas_init/cli_tf/log_clean.py

@@ -0,0 +1,29 @@
+import logging
+from pathlib import Path
+
+import typer
+
+logger = logging.getLogger(__name__)
+SPLIT_STR = "mongodbatlas: "
+
+
+def remove_prefix(line: str) -> str:
+    """
+    >>> remove_prefix(
+    ...     "2025-02-14T15:47:14.157Z [DEBUG] provider.terraform-provider-mongodbatlas: {"
+    ... )
+    '{'
+    >>> remove_prefix(
+    ...     '2025-02-14T15:47:14.158Z [DEBUG] provider.terraform-provider-mongodbatlas:  "biConnector": {'
+    ... )
+    ' "biConnector": {'
+    """
+    return line if SPLIT_STR not in line else line.split(SPLIT_STR, 1)[1]
+
+
+def log_clean(log_path: str = typer.Argument(..., help="Path to the log file")):
+    log_path_parsed = Path(log_path)
+    assert log_path_parsed.exists(), f"file not found: {log_path}"
+    new_lines = [remove_prefix(line) for line in log_path_parsed.read_text().splitlines()]
+    log_path_parsed.write_text("\n".join(new_lines))
+    logger.info(f"cleaned log file: {log_path}")

atlas_init/cli_tf/schema_table.py

@@ -1,6 +1,4 @@
-# import typer
-
-
+# pyright: reportIncompatibleMethodOverride=none
 from collections import defaultdict
 from collections.abc import Iterable
 from functools import total_ordering

atlas_init/cli_tf/schema_v3.py

@@ -210,7 +210,7 @@ class Schema(BaseModelLocal):
 
 
 class Resource(BaseModelLocal):
-    schema: Schema
+    schema: Schema  # pyright: ignore
     name: SnakeCaseString
 
     @property

atlas_init/repos/path.py

@@ -16,6 +16,15 @@ _KNOWN_OWNER_PROJECTS = {
 }
 
 
+def package_glob(package_path: str) -> str:
+    return f"{package_path}/*.go"
+
+
+def go_package_prefix(repo_path: Path) -> str:
+    owner_project = owner_project_name(repo_path)
+    return f"github.com/{owner_project}"
+
+
 def _owner_project_name(repo_path: Path) -> str:
     owner_project = owner_project_name(repo_path)
     if owner_project not in _KNOWN_OWNER_PROJECTS:
@@ -61,6 +70,11 @@ class Repo(StrEnum):
     TF = "tf"
 
 
+def as_repo_alias(path: Path) -> Repo:
+    owner = owner_project_name(path)
+    return _owner_lookup(owner)
+
+
 _owner_repos = {
     GH_OWNER_TERRAFORM_PROVIDER_MONGODBATLAS: Repo.TF,
     GH_OWNER_MONGODBATLAS_CLOUDFORMATION_RESOURCES: Repo.CFN,

atlas_init/settings/config.py

@@ -2,22 +2,22 @@ from __future__ import annotations
 
 import fnmatch
 import logging
+from collections import defaultdict
 from collections.abc import Iterable
 from functools import total_ordering
 from os import getenv
 from pathlib import Path
 from typing import Any
 
-from model_lib import Entity, dump_ignore_falsy
+from model_lib import Entity, IgnoreFalsy
 from pydantic import Field, model_validator
 
-from atlas_init.repos.path import owner_project_name
+from atlas_init.repos.path import as_repo_alias, go_package_prefix, owner_project_name, package_glob
 
 logger = logging.getLogger(__name__)
 
 
-@dump_ignore_falsy
-class TerraformVars(Entity):
+class TerraformVars(IgnoreFalsy):
     cluster_info: bool = False
     cluster_info_m10: bool = False
     stream_instance: bool = False
@@ -28,6 +28,7 @@ class TerraformVars(Entity):
     use_aws_vpc: bool = False
     use_aws_s3: bool = False
     use_federated_vars: bool = False
+    use_encryption_at_rest: bool = False
 
     def __add__(self, other: TerraformVars):  # type: ignore
         assert isinstance(other, TerraformVars)  # type: ignore
@@ -59,6 +60,8 @@ class TerraformVars(Entity):
             config["use_project_extra"] = True
         if self.use_federated_vars:
             config["use_federated_vars"] = True
+        if self.use_encryption_at_rest:
+            config["use_encryption_at_rest"] = True
         if self.stream_instance:
             # hack until backend bug with stream instance is fixed
             config["stream_instance_config"] = {"name": getenv("ATLAS_STREAM_INSTANCE_NAME", "atlas-init")}
@@ -70,15 +73,13 @@ class PyHook(Entity):
     locate: str
 
 
-@dump_ignore_falsy
 @total_ordering
-class TestSuite(Entity):
+class TestSuite(IgnoreFalsy):
     __test__ = False
 
     name: str
     sequential_tests: bool = False
     repo_go_packages: dict[str, list[str]] = Field(default_factory=dict)
-    repo_globs: dict[str, list[str]] = Field(default_factory=dict)
     vars: TerraformVars = Field(default_factory=TerraformVars)  # type: ignore
     post_apply_hooks: list[PyHook] = Field(default_factory=list)
 
@@ -87,13 +88,23 @@ class TestSuite(Entity):
             raise TypeError
         return self.name < other.name
 
-    def all_globs(self, repo_alias: str) -> list[str]:
-        go_packages = self.repo_go_packages.get(repo_alias, [])
-        return self.repo_globs.get(repo_alias, []) + [f"{pkg}/*.go" for pkg in go_packages] + go_packages
+    def package_url_tests(self, repo_path: Path, prefix: str = "") -> dict[str, dict[str, Path]]:
+        alias = as_repo_alias(repo_path)
+        packages = self.repo_go_packages.get(alias, [])
+        names = defaultdict(dict)
+        for package in packages:
+            pkg_name = f"{go_package_prefix(repo_path)}/{package}"
+            for go_file in repo_path.glob(f"{package}/*.go"):
+                with go_file.open() as f:
+                    for line in f:
+                        if line.startswith(f"func {prefix}"):
+                            test_name = line.split("(")[0].strip().removeprefix("func ")
+                            names[pkg_name][test_name] = go_file.parent
+        return names
 
     def is_active(self, repo_alias: str, change_paths: Iterable[str]) -> bool:
         """changes paths should be relative to the repo"""
-        globs = self.all_globs(repo_alias)
+        globs = [package_glob(pkg) for pkg in self.repo_go_packages.get(repo_alias, [])]
         return any(any(fnmatch.fnmatch(path, glob) for glob in globs) for path in change_paths)
 
     def cwd_is_repo_go_pkg(self, cwd: Path, repo_alias: str) -> bool:
@@ -145,9 +156,9 @@ class AtlasInitConfig(Entity):
     @model_validator(mode="after")
     def ensure_all_repo_aliases_are_found(self):
         missing_aliases = set()
-        aliases = set(self.repo_aliases.keys())
+        aliases = set(self.repo_aliases.values())
         for group in self.test_suites:
-            if more_missing := group.repo_globs.keys() - aliases:
+            if more_missing := (group.repo_go_packages.keys() - aliases):
                 logger.warning(f"repo aliases not found for group={group.name}: {more_missing}")
                 missing_aliases |= more_missing
         if missing_aliases:

atlas_init/settings/env_vars.py

@@ -254,7 +254,7 @@ class AtlasInitSettings(AtlasInitPaths, ExternalSettings):
         return variables
 
 
-def active_suites(settings: AtlasInitSettings) -> list[TestSuite]:
+def active_suites(settings: AtlasInitSettings) -> list[TestSuite]:  # type: ignore
     repo_path, cwd_rel_path = repo_path_rel_path()
     return config_active_suites(settings.config, repo_path, cwd_rel_path, settings.test_suites_parsed)