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

atlas_init/__init__.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-VERSION = "0.4.0"
+VERSION = "0.4.2"
 
 
 def running_in_repo() -> bool:

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.py

@@ -78,7 +78,7 @@ def apply(context: typer.Context, *, skip_outputs: bool = False):
             hook_func()  # type: ignore
 
 
-def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool) -> list[TestSuite]:
+def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool) -> list[TestSuite]:  # type: ignore
     settings = init_settings()
     logger.info(f"using the '{command}' command, extra args: {extra_args}")
     try:

atlas_init/cli_cfn/aws.py

@@ -50,7 +50,7 @@ def deregister_cfn_resource_type(type_name: str, deregister: bool, region_filter
                     logger.info(f"deregistering: {arn}")
                     client.deregister_type(Arn=arn)
             if default_version_arn is not None:
-                logger.info(f"deregistering default-arn: {arn}")
+                logger.info(f"deregistering default-arn: {default_version_arn}")
                 client.deregister_type(Arn=default_version_arn)
         except Exception as e:
             if "The type does not exist" in repr(e):
@@ -336,7 +336,7 @@ def get_last_cfn_type(
         "Filters": {"Category": category, "TypeNamePrefix": prefix},
         "MaxResults": 100,
     }
-    next_token = ""
+    next_token = ""  # nosec
     for _ in range(100):
         types_response: ListTypesOutputTypeDef = client.list_types(**kwargs)  # type: ignore
         next_token = types_response.get("NextToken", "")

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],
-    mode: GoTestMode = GoTestMode.package,
+    groups: list[TestSuite],  # type: ignore
+    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_helper/run.py

@@ -1,5 +1,5 @@
 import os
-import subprocess
+import subprocess  # nosec
 import sys
 from logging import Logger
 from pathlib import Path
@@ -34,7 +34,7 @@ def run_command_is_ok(
         stdout=output,
         cwd=cwd,
         env=env,
-        shell=True,  # noqa: S602 # We control the calls to this function and don't suspect any shell injection
+        shell=True,  # noqa: S602 # We control the calls to this function and don't suspect any shell injection #nosec
     )
     is_ok = exit_code == 0
     if is_ok:
@@ -104,6 +104,6 @@ def run_command_is_ok_output(command: str, cwd: Path, logger: Logger, env: dict
 
 def add_to_clipboard(clipboard_content: str, logger: Logger):
     if pb_binary := find_binary_on_path("pbcopy", logger, allow_missing=True):
-        subprocess.run(pb_binary, text=True, input=clipboard_content, check=True)
+        subprocess.run(pb_binary, text=True, input=clipboard_content, check=True)  # nosec
     else:
         logger.warning("pbcopy not found on $PATH")

atlas_init/cli_helper/run_manager.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import os
 import signal
-import subprocess
+import subprocess  # nosec
 import sys
 import threading
 import time
@@ -194,7 +194,7 @@ class RunManager:
         sys_stderr = sys.stderr
 
         def read_stderr(process: subprocess.Popen):
-            for line in process.stderr:
+            for line in process.stderr:  # type: ignore
                 sys_stderr.write(line)
                 result._add_line(line)
 
@@ -211,7 +211,7 @@ class RunManager:
             stderr=subprocess.PIPE,
             stdin=sys.stdin,
             start_new_session=True,
-            shell=True,  # noqa: S602 # We control the calls to this function and don't suspect any shell injection
+            shell=True,  # noqa: S602 # We control the calls to this function and don't suspect any shell injection #nosec
             bufsize=0,
             text=True,  # This makes it return strings instead of bytes
         ) as process:

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

@@ -154,7 +154,7 @@ MARKER_TEST = "Starting TestSteps: "
 
 
 class FileRef(NamedTuple):
-    index: int
+    request_index: int
     line_start: int
     line_end: int
 
@@ -249,12 +249,12 @@ def parse_raw_req_responses(
             in_response = True
             current_start = i + 1
         if in_request and line.startswith(MARKER_END):
-            key = FileRef(index=request_count, line_start=current_start, line_end=i)
+            key = FileRef(request_index=request_count, line_start=current_start, line_end=i)
             requests[key] = log_lines[current_start:i]
             request_count += 1
             in_request = False
         if in_response and line.startswith(MARKER_END):
-            key = FileRef(index=request_count, line_start=current_start, line_end=i)
+            key = FileRef(request_index=request_count, line_start=current_start, line_end=i)
             responses[key] = log_lines[current_start:i]
             response_count += 1
             in_response = False

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
+}