atlas-init 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

atlas_init/__init__.py

@@ -1,12 +1,9 @@
 from pathlib import Path
 
-VERSION = "0.4.1"
+VERSION = "0.4.3"
 
 
 def running_in_repo() -> bool:
-    py_directory = Path(__file__).parent.parent
-    if py_directory.name != "py":
-        return False
-    git_directory = py_directory.parent / ".git"
-    git_config = git_directory / "config"
-    return git_directory.exists() and git_config.exists() and "atlas-init" in git_config.read_text()
+    maybe_git_directory = Path(__file__).parent.parent / ".git"
+    git_config = maybe_git_directory / "config"
+    return git_config.exists() and "atlas-init" in git_config.read_text()

atlas_init/atlas_init.yaml

@@ -13,6 +13,9 @@ test_suites:
 - name: clusterm10
   vars:
     cluster_info_m10: true
+- name: encryption_at_rest
+  vars:
+    use_encryption_at_rest: true
 - name: federated
   repo_go_packages:
     tf:

atlas_init/cli_helper/go.py

@@ -24,6 +24,7 @@ logger = logging.getLogger(__name__)
 class GoTestMode(StrEnum):
     package = "package"
     individual = "individual"
+    regex = "regex"
 
 
 class GoEnvVars(StrEnum):
@@ -31,6 +32,24 @@ class GoEnvVars(StrEnum):
     vscode = "vscode"
 
 
+class GoTestCaptureMode(StrEnum):
+    capture = "capture"
+    replay = "replay"
+    replay_and_update = "replay-and-update"
+    no_capture = "no-capture"
+
+
+def env_vars_for_capture(mode: GoTestCaptureMode) -> dict[str, str]:
+    env = {}
+    if mode == GoTestCaptureMode.capture:
+        env["HTTP_MOCKER_CAPTURE"] = "true"
+    if mode in {GoTestCaptureMode.replay, GoTestCaptureMode.replay_and_update}:
+        env["HTTP_MOCKER_REPLAY"] = "true"
+    if mode == GoTestCaptureMode.replay_and_update:
+        env["HTTP_MOCKER_DATA_UPDATE"] = "true"
+    return env
+
+
 class GoTestResult(Entity):
     runs: dict[str, list[GoTestRun]] = Field(default_factory=dict)
     failure_names: set[str] = Field(default_factory=set)
@@ -55,11 +74,9 @@ class GoTestResult(Entity):
 
 def run_go_tests(
     repo_path: Path,
-    repo_alias: str,
-    package_prefix: str,
     settings: AtlasInitSettings,
     groups: list[TestSuite],  # type: ignore
-    mode: GoTestMode = GoTestMode.package,
+    mode: GoTestMode | str = GoTestMode.package,
     *,
     dry_run: bool = False,
     timeout_minutes: int = 300,
@@ -67,37 +84,30 @@ def run_go_tests(
     re_run: bool = False,
     env_vars: GoEnvVars = GoEnvVars.vscode,
     names: set[str] | None = None,
-    use_replay_mode: bool = False,
+    capture_mode: GoTestCaptureMode = GoTestCaptureMode.capture,
+    use_old_schema: bool = False,
 ) -> GoTestResult:
-    test_env = _resolve_env_vars(settings, env_vars, use_replay_mode=use_replay_mode)
+    test_env = resolve_env_vars(
+        settings,
+        env_vars,
+        capture_mode=capture_mode,
+        use_old_schema=use_old_schema,
+    )
     if ci_value := test_env.pop("CI", None):
-        logger.warning(f"pooped CI={ci_value}")
+        logger.warning(f"popped CI={ci_value}")
     results = GoTestResult()
     commands_to_run: dict[str, str] = {}
     for group in groups:
-        package_paths = group.repo_go_packages.get(repo_alias, [])
-        packages = ",".join(f"{package_prefix}/{pkg}" for pkg in package_paths)
-        if not packages:
-            logger.warning(f"no go packages for suite: {group}")
+        if group.sequential_tests:
+            logger.info(f"running individual tests sequentially as {group.name} is set to sequential_tests")
+            concurrent_runs = 1
+        group_commands_to_run = group_commands_for_mode(
+            repo_path, mode, concurrent_runs, timeout_minutes, names, results, group
+        )
+        if not group_commands_to_run:
+            logger.warning(f"no tests for suite: {group.name}")
             continue
-        if mode == GoTestMode.individual:
-            if group.sequential_tests:
-                logger.info(f"running individual tests sequentially as {group.name} is set to sequential_tests")
-                concurrent_runs = 1
-            test_names = find_individual_tests(repo_path, package_paths)
-            for name, pkg_path in test_names.items():
-                if names and name not in names:
-                    continue
-                results.add_test_package_path(name, pkg_path)
-                commands_to_run[name] = f"go test {packages} -v -run ^{name}$ -timeout {timeout_minutes}m"
-        elif mode == GoTestMode.package:
-            name_regex = f'^({"|".join(names)})$' if names else "^TestAcc*"
-            command = f"go test {packages} -v -run {name_regex} -timeout {timeout_minutes}m"
-            if not group.sequential_tests:
-                command = f"{command} -parallel {concurrent_runs}"
-            commands_to_run[group.name] = command
-        else:
-            raise NotImplementedError(f"mode={mode}")
+        commands_to_run |= group_commands_to_run
     commands_str = "\n".join(f"'{name}': '{command}'" for name, command in sorted(commands_to_run.items()))
     logger.info(f"will run the following commands:\n{commands_str}")
     if dry_run:
@@ -116,31 +126,63 @@ def run_go_tests(
     )
 
 
-def _resolve_env_vars(settings: AtlasInitSettings, env_vars: GoEnvVars, *, use_replay_mode: bool) -> dict[str, str]:
+def group_commands_for_mode(
+    repo_path: Path,
+    mode: GoTestMode | str,
+    concurrent_runs: int,
+    timeout_minutes: int,
+    names: set[str] | None,
+    results: GoTestResult,
+    group: TestSuite,  # type: ignore
+) -> dict[str, str]:
+    commands_to_run: dict[str, str] = {}
+    if mode == GoTestMode.package:
+        name_regex = f"^({'|'.join(names)})$" if names else "^TestAcc*"
+        for pkg_url in group.package_url_tests(repo_path):
+            command = f"go test {pkg_url} -v -run {name_regex} -timeout {timeout_minutes}m"
+            if not group.sequential_tests:
+                command = f"{command} -parallel {concurrent_runs}"
+            pkg_name = pkg_url.rsplit("/")[-1]
+            commands_to_run[f"{group.name}-{pkg_name}"] = command
+        return commands_to_run
+    if mode == GoTestMode.individual:
+        prefix = "TestAcc"
+    else:
+        logger.info(f"using {GoTestMode.regex} with {mode}")
+        prefix = mode
+    for pkg_url, tests in group.package_url_tests(repo_path, prefix=prefix).items():
+        for name, pkg_path in tests.items():
+            if names and name not in names:
+                continue
+            results.add_test_package_path(name, pkg_path)
+            commands_to_run[name] = f"go test {pkg_url} -v -run ^{name}$ -timeout {timeout_minutes}m"
+    return commands_to_run
+
+
+def resolve_env_vars(
+    settings: AtlasInitSettings,
+    env_vars: GoEnvVars,
+    *,
+    capture_mode: GoTestCaptureMode,
+    use_old_schema: bool,
+    skip_os: bool = False,
+) -> dict[str, str]:
     if env_vars == GoEnvVars.manual:
-        extra_vars = settings.load_profile_manual_env_vars(skip_os_update=True)
+        test_env_vars = settings.load_profile_manual_env_vars(skip_os_update=True)
     elif env_vars == GoEnvVars.vscode:
-        extra_vars = settings.load_env_vars(settings.env_vars_vs_code)
+        test_env_vars = settings.load_env_vars(settings.env_vars_vs_code)
     else:
         raise NotImplementedError(f"don't know how to load env_vars={env_vars}")
-    mocker_env_name = "HTTP_MOCKER_REPLAY" if use_replay_mode else "HTTP_MOCKER_CAPTURE"
-    extra_vars |= {"TF_ACC": "1", "TF_LOG": "DEBUG", mocker_env_name: "true"}
-    test_env = os.environ | extra_vars
-    logger.info(f"go test env-vars-extra: {sorted(extra_vars)}")
-    return test_env
-
-
-def find_individual_tests(repo_path: Path, package_paths: list[str]) -> dict[str, Path]:
-    tests = {}
-    for package_path in package_paths:
-        package_abs_path = repo_path / package_path.lstrip(".").lstrip("/")
-        for go_file in package_abs_path.glob("*.go"):
-            with go_file.open() as f:
-                for line in f:
-                    if line.startswith("func TestAcc"):
-                        test_name = line.split("(")[0].strip().removeprefix("func ")
-                        tests[test_name] = package_abs_path
-    return tests
+    test_env_vars |= {
+        "TF_ACC": "1",
+        "TF_LOG": "DEBUG",
+        "MONGODB_ATLAS_PREVIEW_PROVIDER_V2_ADVANCED_CLUSTER": "false" if use_old_schema else "true",
+    }
+    test_env_vars |= env_vars_for_capture(capture_mode)
+    logger.info(f"go test env-vars-extra: {sorted(test_env_vars)}")
+    if not skip_os:
+        test_env_vars = os.environ | test_env_vars  # os.environ on the left side, prefer explicit args
+    return test_env_vars
 
 
 def _run_tests(
@@ -158,9 +200,13 @@ def _run_tests(
     with ThreadPoolExecutor(max_workers=actual_workers) as pool:
         for name, command in sorted(commands_to_run.items()):
             log_path = _log_path(name)
-            if log_path.exists() and log_path.read_text() and not re_run:
-                logger.info(f"skipping {name} because log exists")
-                continue
+            if log_path.exists() and log_path.read_text():
+                if re_run:
+                    logger.info(f"moving existing logs of {name} to old dir")
+                    move_logs_to_dir({name}, dir_name="old")
+                else:
+                    logger.info(f"skipping {name} because log exists")
+                    continue
             command_env = {**test_env, "TF_LOG_PATH": str(log_path)}
             future = pool.submit(
                 run_command_is_ok_output,
@@ -204,20 +250,20 @@ def _run_tests(
         if not results.add_test_results_all_pass(name, parsed_tests):
             results.failure_names.add(name)
     if failure_names := results.failure_names:
-        move_failed_logs_to_error_dir(failure_names)
+        move_logs_to_dir(failure_names)
         logger.error(f"failed to run tests: {sorted(failure_names)}")
     return results
 
 
-def move_failed_logs_to_error_dir(failures: set[str]):
-    error_dir = DEFAULT_DOWNLOADS_DIR / "failures"
+def move_logs_to_dir(names: set[str], dir_name: str = "failures"):
+    new_dir = DEFAULT_DOWNLOADS_DIR / dir_name
     for log in DEFAULT_DOWNLOADS_DIR.glob("*.log"):
-        if log.stem in failures:
+        if log.stem in names:
             text = log.read_text()
             assert "\n" in text
             first_line = text.split("\n", maxsplit=1)[0]
             ts = first_line.split(" ")[0]
-            log.rename(error_dir / f"{ts}.{log.name}")
+            log.rename(new_dir / f"{ts}.{log.name}")
 
 
 def _log_path(name: str) -> Path:

atlas_init/cli_root/go_test.py

@@ -2,7 +2,7 @@ import logging
 
 import typer
 
-from atlas_init.cli_helper.go import GoEnvVars, GoTestMode, GoTestResult, run_go_tests
+from atlas_init.cli_helper.go import GoEnvVars, GoTestCaptureMode, GoTestMode, GoTestResult, run_go_tests
 from atlas_init.cli_tf.mock_tf_log import MockTFLog, mock_tf_log, resolve_admin_api_path
 from atlas_init.repos.path import Repo, current_repo, current_repo_path
 from atlas_init.settings.env_vars import active_suites, init_settings
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 
 @app_command()
 def go_test(
-    mode: GoTestMode = typer.Option("package", "-m", "--mode", help="package|individual"),
+    mode: str = typer.Option("package", "-m", "--mode", help="package|individual or a prefix"),
     dry_run: bool = typer.Option(False, help="only log out the commands to be run"),
     timeout_minutes: int = typer.Option(300, "-t", "--timeout", help="timeout in minutes"),
     concurrent_runs: int = typer.Option(20, "-c", "--concurrent", help="number of concurrent runs"),
@@ -22,11 +22,16 @@ def go_test(
     export_mock_tf_log_verbose: bool = typer.Option(
         False, "--export-verbose", help="log roundtrips when exporting the mock-tf-log"
     ),
-    env_method: GoEnvVars = typer.Option(GoEnvVars.manual, "--env", help="|".join(list(GoEnvVars))),
+    env_method: GoEnvVars = typer.Option(GoEnvVars.manual, "--env"),
     names: list[str] = typer.Option(
-        ..., "-n", "--names", default_factory=list, help="run only the tests with these names"
+        ...,
+        "-n",
+        "--names",
+        default_factory=list,
+        help="run only the tests with these names",
     ),
-    use_replay_mode: bool = typer.Option(False, "--replay", help="use replay mode and stored responses"),
+    capture_mode: GoTestCaptureMode = typer.Option(GoTestCaptureMode.capture, "--capture"),
+    use_old_schema: bool = typer.Option(False, "--old-schema", help="use the old schema for the tests"),
 ):
     if export_mock_tf_log and mode != GoTestMode.individual:
         err_msg = "exporting mock-tf-log is only supported for individual tests"
@@ -36,16 +41,13 @@ def go_test(
     sorted_suites = sorted(suite.name for suite in suites)
     logger.info(f"running go tests for {len(suites)} test-suites: {sorted_suites}")
     results: GoTestResult | None = None
-    match repo_alias := current_repo():
+    match current_repo():
         case Repo.CFN:
             raise NotImplementedError
         case Repo.TF:
             repo_path = current_repo_path()
-            package_prefix = settings.config.go_package_prefix(repo_alias)
             results = run_go_tests(
                 repo_path,
-                repo_alias,
-                package_prefix,
                 settings,
                 suites,
                 mode,
@@ -55,7 +57,8 @@ def go_test(
                 re_run=re_run,
                 env_vars=env_method,
                 names=set(names),
-                use_replay_mode=use_replay_mode,
+                capture_mode=capture_mode,
+                use_old_schema=use_old_schema,
             )
         case _:
             raise NotImplementedError

atlas_init/cli_tf/app.py

@@ -17,6 +17,7 @@ from atlas_init.cli_helper.run import (
     run_command_receive_result,
 )
 from atlas_init.cli_tf.changelog import convert_to_changelog
+from atlas_init.cli_tf.example_update import update_example_cmd
 from atlas_init.cli_tf.github_logs import (
     GH_TOKEN_ENV_NAME,
     find_test_runs,
@@ -28,6 +29,7 @@ from atlas_init.cli_tf.go_test_summary import (
     create_detailed_summary,
     create_short_summary,
 )
+from atlas_init.cli_tf.log_clean import log_clean
 from atlas_init.cli_tf.mock_tf_log import mock_tf_log_cmd
 from atlas_init.cli_tf.schema import (
     dump_generator_config,
@@ -48,6 +50,8 @@ from atlas_init.settings.interactive import confirm
 
 app = typer.Typer(no_args_is_help=True)
 app.command(name="mock-tf-log")(mock_tf_log_cmd)
+app.command(name="example-update")(update_example_cmd)
+app.command(name="log-clean")(log_clean)
 logger = logging.getLogger(__name__)
 
 

atlas_init/cli_tf/debug_logs.py

@@ -225,7 +225,7 @@ def match_request(
                 step_number=step_number,
             )
     remaining_responses = [resp for i, resp in enumerate(responses_list) if i not in used_responses]
-    err_msg = f"Could not match request {request.path} ({ref}) with any response\n\n{request}\n\n\nThere are #{len(remaining_responses)} responses left that doesn't match\n{'-'*80}\n{'\n'.join(r.text for r in remaining_responses)}"
+    err_msg = f"Could not match request {request.path} ({ref}) with any response\n\n{request}\n\n\nThere are #{len(remaining_responses)} responses left that doesn't match\n{'-' * 80}\n{'\n'.join(r.text for r in remaining_responses)}"
     raise ValueError(err_msg)
 
 
@@ -260,9 +260,9 @@ def parse_raw_req_responses(
             in_response = False
     assert not in_request, "Request not closed"
     assert not in_response, "Response not closed"
-    assert (
-        request_count == response_count
-    ), f"Mismatch in request and response count: {request_count} != {response_count}"
+    assert request_count == response_count, (
+        f"Mismatch in request and response count: {request_count} != {response_count}"
+    )
     parsed_requests = {}
     for ref, request_lines in requests.items():
         parsed_requests[ref] = parse_request(request_lines)

atlas_init/cli_tf/example_update.py

@@ -0,0 +1,142 @@
+import logging
+from collections import defaultdict
+from functools import total_ordering
+from pathlib import Path
+
+import typer
+from model_lib import Entity, Event, dump, parse_payload
+from pydantic import Field
+
+from atlas_init.cli_helper.run import run_binary_command_is_ok
+from atlas_init.cli_tf.hcl.modifier import (
+    BLOCK_TYPE_OUTPUT,
+    BLOCK_TYPE_VARIABLE,
+    update_descriptions,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class UpdateExamples(Entity):
+    examples_base_dir: Path
+    var_descriptions: dict[str, str]
+    output_descriptions: dict[str, str] = Field(default_factory=dict)
+    skip_tf_fmt: bool = False
+
+
+@total_ordering
+class TFConfigDescriptionChange(Event):
+    path: Path
+    name: str
+    before: str
+    after: str
+    block_type: str
+
+    @property
+    def changed(self) -> bool:
+        return self.after not in ("", self.before)
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, TFConfigDescriptionChange):
+            raise TypeError
+        return (self.path, self.name) < (other.path, other.name)
+
+
+class UpdateExamplesOutput(Entity):
+    before_var_descriptions: dict[str, str] = Field(default_factory=dict)
+    before_output_descriptions: dict[str, str] = Field(default_factory=dict)
+    changes: list[TFConfigDescriptionChange] = Field(default_factory=list)
+
+
+def update_examples(event_in: UpdateExamples) -> UpdateExamplesOutput:
+    changes = []
+    existing_var_descriptions = update_block_descriptions(
+        event_in.examples_base_dir,
+        changes,
+        event_in.var_descriptions,
+        BLOCK_TYPE_VARIABLE,
+    )
+    existing_output_descriptions = update_block_descriptions(
+        event_in.examples_base_dir,
+        changes,
+        event_in.output_descriptions,
+        BLOCK_TYPE_OUTPUT,
+    )
+    if event_in.skip_tf_fmt:
+        logger.info("skipping terraform fmt")
+    else:
+        assert run_binary_command_is_ok("terraform", "fmt -recursive", cwd=event_in.examples_base_dir, logger=logger), (
+            "terraform fmt failed"
+        )
+    return UpdateExamplesOutput(
+        before_var_descriptions=flatten_descriptions(existing_var_descriptions),
+        before_output_descriptions=flatten_descriptions(existing_output_descriptions),
+        changes=sorted(changes),
+    )
+
+
+def flatten_descriptions(descriptions: dict[str, list[str]]) -> dict[str, str]:
+    return {
+        key: "\n".join(desc for desc in sorted(set(descriptions)) if desc != "")
+        for key, descriptions in descriptions.items()
+    }
+
+
+def update_block_descriptions(
+    base_dir: Path,
+    changes: list[TFConfigDescriptionChange],
+    new_names: dict[str, str],
+    block_type: str,
+):
+    all_existing_descriptions = defaultdict(list)
+    in_files = sorted(base_dir.rglob("*.tf"))
+    for tf_file in in_files:
+        logger.info(f"looking for {block_type} in {tf_file}")
+        new_tf, existing_descriptions = update_descriptions(tf_file, new_names, block_type=block_type)
+        if not existing_descriptions:  # probably no variables in the file
+            continue
+        for name, descriptions in existing_descriptions.items():
+            changes.extend(
+                TFConfigDescriptionChange(
+                    path=tf_file,
+                    name=name,
+                    before=description,
+                    after=new_names.get(name, ""),
+                    block_type=block_type,
+                )
+                for description in descriptions
+            )
+            all_existing_descriptions[name].extend(descriptions)
+        if tf_file.read_text() == new_tf:
+            logger.debug(f"no {block_type} changes for {tf_file}")
+            continue
+        tf_file.write_text(new_tf)
+    return all_existing_descriptions
+
+
+def update_example_cmd(
+    examples_base_dir: Path = typer.Argument(
+        ..., help="Directory containing *.tf files (can have many subdirectories)"
+    ),
+    var_descriptions: Path = typer.Option("", "--vars", help="Path to a JSON/yaml file with variable descriptions"),
+    output_descriptions: Path = typer.Option("", "--outputs", help="Path to a JSON/yaml file with output descriptions"),
+    skip_log_existing: bool = typer.Option(False, help="Log existing descriptions"),
+    skip_log_changes: bool = typer.Option(False, help="Log variable updates"),
+):
+    var_descriptions_dict = parse_payload(var_descriptions) if var_descriptions else {}
+    output_descriptions_dict = parse_payload(output_descriptions) if output_descriptions else {}
+    event = UpdateExamples(
+        examples_base_dir=examples_base_dir,
+        var_descriptions=var_descriptions_dict,  # type: ignore
+        output_descriptions=output_descriptions_dict,  # type: ignore
+    )
+    output = update_examples(event)
+    if not skip_log_changes:
+        for change in output.changes:
+            if change.changed:
+                logger.info(f"{change.path}({change.block_type}) {change.name}: {change.before} -> {change.after}")
+    if not skip_log_existing:
+        existing_var_yaml = dump(output.before_var_descriptions, "yaml")
+        logger.info(f"Existing Variables:\n{existing_var_yaml}")
+        existing_output_yaml = dump(output.before_output_descriptions, "yaml")
+        logger.info(f"Existing Outputs:\n{existing_output_yaml}")

atlas_init/cli_tf/example_update_test/test_update_example.tf

@@ -0,0 +1,23 @@
+variable "cluster_name" {
+  description = "description of cluster name"
+  type        = string
+}
+variable "replication_specs" {
+  description = "Updated description"
+  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
+}

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

@@ -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: