website/docs/troubleshoot/errors.mdx (4)

101-103: Fix wording and double period

Tighten the lead sentence and remove the trailing double period.

-The Terraform/OpenTofu error means Terraform noticed that your backend configuration (the section in your code that
-defines where and how Terraform stores state) has changed compared to what’s currently in use..
+This Terraform/OpenTofu error indicates that Terraform detected a change in your backend configuration (where and how Terraform stores state) compared to the currently configured backend.

---

109-114: Make list items parallel; move consequence out of the list; capitalize S3

The last bullet is not a cause; it’s the outcome. Also fix capitalization and phrasing.

-- Switching from local to s3
+- Switching from local to S3
 - Changing the bucket, key, or region for an S3 backend
-- Modifying a prefix or workspace config in Terraform Cloud
+- Modifying a prefix or workspace configuration in Terraform Cloud
 - Adjusting encryption or locking settings
-- Terraform detects that the state might need to be migrated from the old backend to the new one.
+
+When any of the above change, Terraform may need to migrate state from the old backend to the new one.

---

139-142: Clarify behavior; add a caution about skipping migration; tweak tone

“tell Atmos” → “configures Atmos”. Add an admonition warning that -reconfigure skips migration, which can orphan state if used unintentionally. Include a short runnable example.

-This will tell Atmos to run `terraform init -reconfigure` when executing Terraform commands.
-The `-reconfigure` option disregards any existing backend configuration and configures a new backend,
-preventing migration of any existing state.
+This configures Atmos to run `terraform init -reconfigure` when executing Terraform commands.
+The `-reconfigure` option disregards any existing backend configuration and configures a new backend,
+preventing migration of any existing state.
+
+:::caution
+Only use `-reconfigure` when you intentionally changed backends and do not want to migrate existing state.
+If you need to preserve state, follow Terraform's interactive migration prompt and answer "yes" to copy state.
+:::
+
+#### Example
+
+```console
+$ atmos terraform init -s <stack> -w <component>
+# or explicitly:
+$ atmos terraform init -s <stack> -w <component> --init-run-reconfigure
+```

---

130-137: All clear—flag and ENV var names are correct

I’ve verified that the ENV var and CLI flag are consistently defined and used across the codebase:

• The environment variable ATMOS_COMPONENTS_TERRAFORM_INIT_RUN_RECONFIGURE is read in pkg/config/utils.go (around lines 256–260).
• The CLI flag --init-run-reconfigure is implemented in the Terraform init logic (e.g. internal/exec/terraform_output_utils.go) and appears in all relevant docs (e.g. website/docs/troubleshoot/errors.mdx).

As an optional enhancement to improve usability, I recommend surfacing these alternative settings in the prose rather than only as YAML comments. For example, in website/docs/troubleshoot/errors.mdx (after the code block at lines 130–137), add a sentence like:

“You can also enable this behavior by setting the ATMOS_COMPONENTS_TERRAFORM_INIT_RUN_RECONFIGURE environment variable or by passing the --init-run-reconfigure flag to the Atmos CLI.”

You might:

• Add the above sentence immediately below the existing snippet in website/docs/troubleshoot/errors.mdx.
• Consider using a markdown callout/admonition to highlight the flag and ENV var for easier copy/paste.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: Listener430
PR: cloudposse/atmos#934
File: tests/fixtures/scenarios/docs-generate/README.md.gotmpl:99-118
Timestamp: 2025-01-25T03:51:57.689Z
Learning: For the cloudposse/atmos repository, changes to template contents should be handled in dedicated PRs and are typically considered out of scope for PRs focused on other objectives.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Clearly describe the changes in the PR description

Learnt from: aknysh
PR: cloudposse/atmos#944
File: go.mod:206-206
Timestamp: 2025-01-17T00:18:57.769Z
Learning: For indirect dependencies with license compliance issues in the cloudposse/atmos repository, the team prefers to handle them in follow-up PRs rather than blocking the current changes, as these issues often require deeper investigation of the dependency tree.

website/docs/troubleshoot/errors.mdx (1)

147-151: Verify internal link to CLI configuration exists

Past review flagged this link as broken when it was /cli/configuration/#configuration. It’s now /cli/configuration/, but we still need to ensure the target file exists.

Run from repo root:

#!/bin/bash
set -euo pipefail

# Check configuration page presence
echo "Looking for CLI configuration page..."
if find website/docs/cli -maxdepth 1 -type f \( -name 'configuration.md' -o -name 'configuration.mdx' \) | grep -q .; then
  echo "  ✓ Found:"
  find website/docs/cli -maxdepth 1 -type f \( -name 'configuration.md' -o -name 'configuration.mdx' \) | sed 's|^|    |'
else
  echo "  ✗ Missing website/docs/cli/configuration.md(x). Consider updating the link or adding the page."
fi

# Sanity-check referenced describe pages
echo ""
echo "Checking describe pages..."
for p in website/docs/cli/commands/describe/affected.mdx website/docs/cli/commands/describe/dependents.mdx; do
  [[ -f "$p" ]] && echo "  ✓ Found $p" || echo "  ✗ Missing $p"
done

website/docs/core-concepts/stacks/define-components.mdx (1)

221-223: Tighten the disambiguation: explicitly call out precedence and execution behavior.

Good clarification. Minor wording tweak will make the difference unambiguous and avoid readers assuming vars.enabled affects Atmos execution.

Apply this diff to strengthen the note:

-This should not be confused with [Cloud Posse's conventions and best practices](/best-practices/terraform/) of
-having modules and components define a Terraform input named `enabled`.
-This is a general convention and `vars.enabled` is not a special variable. Atmos does not treat it differently from any other variable.
+This should not be confused with [Cloud Posse's conventions and best practices](/best-practices/terraform/) of
+having modules and components define a Terraform input named `enabled`.
+That module input is a general convention and may be surfaced in stacks as `vars.enabled`, but it does not change whether Atmos executes or renders the component.
+Only `metadata.enabled` controls Atmos processing. Atmos treats `vars.enabled` like any other variable.

Optional example to drive it home—want me to add this right below the note?

components:
  terraform:
    vpc:
      metadata:
        enabled: true        # Atmos will process and run terraform for this component
      vars:
        enabled: false       # Module-specific semantics (e.g., count = 0); Atmos still runs terraform

website/docs/troubleshoot/errors.mdx (3)

101-103: Tighten wording + fix double period

Rephrase for clarity and remove the trailing double period.

-The Terraform/OpenTofu error means Terraform noticed that your backend configuration (the section in your code that
-defines where and how Terraform stores state) has changed compared to what’s currently in use..
+This Terraform/OpenTofu error indicates that your backend configuration (the section in your code that
+defines where and how Terraform stores state) differs from what’s currently in use.

---

109-114: Restructure bullets; move non-example sentence out of the list

The last bullet is not an example; it’s an effect. Move it below the list and keep examples as bullets.

 - Switching from local to s3
 - Changing the bucket, key, or region for an S3 backend
 - Modifying a prefix or workspace config in Terraform Cloud
 - Adjusting encryption or locking settings
-- Terraform detects that the state might need to be migrated from the old backend to the new one.
+
+When any of the above changes, Terraform detects that the state might need to be migrated from the old backend to the new one.

---

145-151: Consider adding OpenTofu docs link

You reference Terraform docs; consider adding a link to the OpenTofu init docs alongside for parity.

I can propose exact wording once you confirm the preferred OpenTofu reference.

website/docs/core-concepts/components/terraform/backends.mdx (1)

12-14: Minor grammar: plural subject should use “their”

Terraform and OpenTofu are two subjects; prefer “their state.”

-Backends define where [Terraform](https://opentofu.org/docs/language/state/) and
-[OpenTofu](https://opentofu.org/docs/language/state/) store its state.
+Backends define where [Terraform](https://opentofu.org/docs/language/state/) and
+[OpenTofu](https://opentofu.org/docs/language/state/) store their state.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: Listener430
PR: cloudposse/atmos#934
File: tests/fixtures/scenarios/docs-generate/README.md.gotmpl:99-118
Timestamp: 2025-01-25T03:51:57.689Z
Learning: For the cloudposse/atmos repository, changes to template contents should be handled in dedicated PRs and are typically considered out of scope for PRs focused on other objectives.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Clearly describe the changes in the PR description

Learnt from: aknysh
PR: cloudposse/atmos#944
File: go.mod:206-206
Timestamp: 2025-01-17T00:18:57.769Z
Learning: For indirect dependencies with license compliance issues in the cloudposse/atmos repository, the team prefers to handle them in follow-up PRs rather than blocking the current changes, as these issues often require deeper investigation of the dependency tree.

Learnt from: osterman
PR: cloudposse/atmos#942
File: internal/exec/describe_affected_utils.go:802-807
Timestamp: 2025-01-16T11:41:35.531Z
Learning: When checking if a component is enabled in Atmos, use standardized helper function that includes logging. The function should check the `enabled` field in the component's metadata section and log a trace message when skipping disabled components.

cmd/describe_affected_test.go (6)

60-66: Clarify the coupling between --upload and include flags

The expectation that Upload: true implies IncludeDependents: true and IncludeSettings: true is fine if intentional. If this coupling is incidental (or will change), consider documenting it in the test to avoid future brittleness.

---

97-116: Add the --exclude-locked flag to the test FlagSet

To keep this unit test in parity with the CLI and the PR objective, wire the new flag into the local FlagSet so SetDescribeAffectedFlagValueInCliArgs can populate it.

 fs.Bool("include-settings", false, "Include settings")
 fs.Bool("upload", false, "Upload")
 fs.String("clone-target-ref", "", "Clone target ref")
+fs.Bool("exclude-locked", false, "Exclude components with metadata.locked: true")
 fs.Bool("process-templates", false, "Process templates")
 fs.Bool("process-functions", false, "Process YAML functions")
 fs.Bool("skip", false, "Skip")

---

28-90: Expand table tests: explicitly disabled processing and exclude-locked

Add two cases to cover key paths:

• When users explicitly set --process-templates=false and --process-functions=false, args should reflect false.
• When users set --exclude-locked=true, args should reflect true (assuming DescribeAffectedCmdArgs has ExcludeLocked).

   tests := []struct {
     name          string
     setFlags      func(*pflag.FlagSet)
     expected      *exec.DescribeAffectedCmdArgs
     expectedPanic bool
     panicMessage  string
   }{
@@
     {
       name: "Set format explicitly, no override",
       setFlags: func(fs *pflag.FlagSet) {
         fs.Set("format", "json")
       },
       expected: &exec.DescribeAffectedCmdArgs{
         Format:               "json",
         ProcessTemplates:     true,
         ProcessYamlFunctions: true,
       },
     },
+    {
+      name: "Explicitly disable processing flags",
+      setFlags: func(fs *pflag.FlagSet) {
+        fs.Set("process-templates", "false") // mark as changed
+        fs.Set("process-functions", "false") // mark as changed
+      },
+      expected: &exec.DescribeAffectedCmdArgs{
+        Format:               "json",
+        ProcessTemplates:     false,
+        ProcessYamlFunctions: false,
+      },
+    },
+    {
+      name: "Exclude locked components",
+      setFlags: func(fs *pflag.FlagSet) {
+        fs.Set("exclude-locked", "true")
+      },
+      expected: &exec.DescribeAffectedCmdArgs{
+        Format:               "json",
+        ProcessTemplates:     true,
+        ProcessYamlFunctions: true,
+        ExcludeLocked:        true,
+      },
+    },
   }

If ExcludeLocked is modeled elsewhere, we can tailor the assertion accordingly.

---

20-26: Assert that defaults actually reach the executor

Strengthen the mock to validate ProcessTemplates/ProcessYamlFunctions are true at the boundary.

-describeAffectedMock.EXPECT().Execute(gomock.Any()).Return(nil)
+describeAffectedMock.EXPECT().
+  Execute(gomock.AssignableToTypeOf(&exec.DescribeAffectedCmdArgs{})).
+  DoAndReturn(func(args *exec.DescribeAffectedCmdArgs) error {
+    assert.True(t, args.ProcessTemplates, "ProcessTemplates should default to true")
+    assert.True(t, args.ProcessYamlFunctions, "ProcessYamlFunctions should default to true")
+    return nil
+  })

---

145-161: Prefer t.Setenv over os.Setenv + manual cleanup

Use testing.T’s helpers for cleaner setup/teardown.

-err := os.Setenv("ATMOS_CLI_CONFIG_PATH", stacksPath)
-assert.NoError(t, err, "Setting 'ATMOS_CLI_CONFIG_PATH' environment variable should execute without error")
-
-err = os.Setenv("ATMOS_BASE_PATH", stacksPath)
-assert.NoError(t, err, "Setting 'ATMOS_BASE_PATH' environment variable should execute without error")
-
-// Unset ENV variables after testing
-defer func() {
-  os.Unsetenv("ATMOS_CLI_CONFIG_PATH")
-  os.Unsetenv("ATMOS_BASE_PATH")
-}()
+t.Setenv("ATMOS_CLI_CONFIG_PATH", stacksPath)
+t.Setenv("ATMOS_BASE_PATH", stacksPath)

---

121-131: Remove unused panic harness or add a case that exercises it

No table entry sets expectedPanic. Either delete this block to reduce noise or add a negative test that triggers the panic path.

cmd/describe_dependents_test.go (6)

58-61: Default mismatch: test expects JSON, flag help says YAML.

The test expects Format: "json" when no flags change, but the flag is declared with default "yaml" and the help mentions YAML default. This is confusing and brittle.

• Either the CLI default is JSON (preferred per PR objectives), in which case update the flag definition/help here to "json".
• Or the CLI default is YAML, in which case update the expectation.

Suggested fix (align test flag with JSON default):

-      fs.StringP("format", "f", "yaml", "Specify the output format (`yaml` is default)")
+      fs.StringP("format", "f", "json", "Specify the output format (`json` is default)")

Also applies to: 75-76

---

16-31: Verify that Execute receives defaulted processing flags.

Right now the test only verifies that Execute is called. It doesn’t assert the new defaults are actually propagated. Capture the arg and assert both flags are true.

 func TestDescribeDependents(t *testing.T) {
   ctrl := gomock.NewController(t)
+  t.Cleanup(ctrl.Finish)
   describeDependentsMock := exec.NewMockDescribeDependentsExec(ctrl)
-  describeDependentsMock.EXPECT().Execute(gomock.Any()).Return(nil)
+  describeDependentsMock.EXPECT().
+    Execute(gomock.AssignableToTypeOf(exec.DescribeDependentsExecProps{})).
+    Do(func(p exec.DescribeDependentsExecProps) {
+      assert.True(t, p.ProcessTemplates, "ProcessTemplates should default to true")
+      assert.True(t, p.ProcessYamlFunctions, "ProcessYamlFunctions should default to true")
+    }).
+    Return(nil)

---

72-89: Avoid brittle struct-wide equality; assert only relevant fields.

Comparing the entire DescribeDependentsExecProps makes the test fragile as the struct evolves (e.g., Skip, IncludeSettings). It can also break on nil vs empty-slice semantics.

Replace with field-level assertions:

-      assert.NoError(t, err)
-      assert.Equal(t, tt.expected, describeDependentArgs)
+      assert.NoError(t, err)
+      assert.Equal(t, tt.expected.Format, describeDependentArgs.Format)
+      assert.Equal(t, tt.expected.ProcessTemplates, describeDependentArgs.ProcessTemplates)
+      assert.Equal(t, tt.expected.ProcessYamlFunctions, describeDependentArgs.ProcessYamlFunctions)

---

75-78: Define the new flags in the test FlagSet and add a negative-case test.

Currently the test never sets --process-templates/--process-functions flags to false. Define them in the FlagSet and add a table case to validate disabling processing.

       fs := pflag.NewFlagSet("test", pflag.ContinueOnError)
-      fs.StringP("format", "f", "yaml", "Specify the output format (`yaml` is default)")
+      fs.StringP("format", "f", "json", "Specify the output format (`json` is default)")
       fs.StringP("output", "o", "list", "Specify the output type (`list` is default)")
       fs.StringP("query", "q", "", "Specify a query to filter the output")
+      fs.Bool("process-templates", true, "Process templates in components and dependents")
+      fs.Bool("process-functions", true, "Process YAML functions in components and dependents")
+      fs.StringSlice("skip", nil, "List of components to skip")
       tt.setFlags(fs)

And extend the table with a negative-case:

       {
         name: "Set invalid format, no override",
         setFlags: func(fs *pflag.FlagSet) {
           fs.Set("format", "invalid_format")
         },
         expectedErr: true,
       },
+      {
+        name: "Disable processing flags",
+        setFlags: func(fs *pflag.FlagSet) {
+          fs.Set("process-templates", "false")
+          fs.Set("process-functions", "false")
+        },
+        expected: &exec.DescribeDependentsExecProps{
+          Format:               "json",
+          ProcessTemplates:     false,
+          ProcessYamlFunctions: false,
+        },
+      },

---

91-108: Use t.Setenv for hermetic env handling.

t.Setenv is simpler and auto-cleans per test, avoiding manual defers.

 func TestDescribeDependentsCmd_Error(t *testing.T) {
   stacksPath := "../tests/fixtures/scenarios/terraform-apply-affected"
-
-  err := os.Setenv("ATMOS_CLI_CONFIG_PATH", stacksPath)
-  assert.NoError(t, err, "Setting 'ATMOS_CLI_CONFIG_PATH' environment variable should execute without error")
-
-  err = os.Setenv("ATMOS_BASE_PATH", stacksPath)
-  assert.NoError(t, err, "Setting 'ATMOS_BASE_PATH' environment variable should execute without error")
-
-  // Unset ENV variables after testing
-  defer func() {
-    os.Unsetenv("ATMOS_CLI_CONFIG_PATH")
-    os.Unsetenv("ATMOS_BASE_PATH")
-  }()
+  t.Setenv("ATMOS_CLI_CONFIG_PATH", stacksPath)
+  t.Setenv("ATMOS_BASE_PATH", stacksPath)

If you apply this, also drop the unused os import.

---

3-14: Drop unused import after switching to t.Setenv.

If you adopt t.Setenv, remove os from imports to keep golangci-lint happy.

 import (
-  "os"
   "testing"

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: Listener430
PR: cloudposse/atmos#934
File: tests/fixtures/scenarios/docs-generate/README.md.gotmpl:99-118
Timestamp: 2025-01-25T03:51:57.689Z
Learning: For the cloudposse/atmos repository, changes to template contents should be handled in dedicated PRs and are typically considered out of scope for PRs focused on other objectives.

Learnt from: aknysh
PR: cloudposse/atmos#944
File: go.mod:206-206
Timestamp: 2025-01-17T00:18:57.769Z
Learning: For indirect dependencies with license compliance issues in the cloudposse/atmos repository, the team prefers to handle them in follow-up PRs rather than blocking the current changes, as these issues often require deeper investigation of the dependency tree.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Clearly describe the changes in the PR description

Learnt from: aknysh
PR: cloudposse/atmos#1327
File: cmd/terraform.go:111-117
Timestamp: 2025-06-23T02:14:30.937Z
Learning: In cmd/terraform.go, flags for the DescribeAffected function are added dynamically at runtime when info.Affected is true. This is intentional to avoid exposing internal flags like "file", "format", "verbose", "include-spacelift-admin-stacks", "include-settings", and "upload" in the terraform command interface, while still providing them for the shared DescribeAffected function used by both `atmos describe affected` and `atmos terraform apply --affected`.

internal/exec/describe_dependents_test.go (9)

40-45: Assert new flag defaults are forwarded by Execute()

Nice update to the mock signature to include the new flags. Add quick assertions to ensure DescribeDependentsExec forwards the intended defaults (processTemplates/processFunctions=true, skip=nil) and the same config pointer. This catches regressions in flag plumbing.

Apply this diff inside the mock:

 mockExecuteDescribeDependents := func(config *schema.AtmosConfiguration, component, stack string, includeSettings bool, processTemplates bool, processFunctions bool, skip []string) ([]schema.Dependent, error) {
+   assert.Equal(t, atmosConfig, config)
    assert.Equal(t, "test-component", component)
    assert.Equal(t, "test-stack", stack)
    assert.False(t, includeSettings)
+   assert.True(t, processTemplates)
+   assert.True(t, processFunctions)
+   assert.Nil(t, skip)
    return dependents, nil
 }

If helpful, I can add a focused test that toggles these flags and validates pass-through.

---

105-111: Mirror assertions for flag defaults in the query path

This path should also assert processTemplates/processFunctions default to true and skip is nil to keep coverage consistent.

 executeDescribeDependents: func(atmosConfig *schema.AtmosConfiguration, component, stack string, includeSettings bool, processTemplates bool, processFunctions bool, skip []string) ([]schema.Dependent, error) {
+  assert.True(t, processTemplates)
+  assert.True(t, processFunctions)
+  assert.Nil(t, skip)
   return dependents, nil
 },

---

135-140: Good negative test for plumbing errors

This ensures Execute short-circuits on executeDescribeDependents failure. Optionally, add a control to prove evaluateYqExpression is not invoked when upstream fails (e.g., set a panic in a stub if called). Not required, just a guard against accidental reordering.

---

263-265: Avoid writing artifacts to repo root in format/file matrix

The first case writes output.json to CWD. Use t.TempDir to isolate filesystem effects and avoid CI flakes.

Here’s a minimal tweak for the per-test file path:

// before building props
file := tc.file
if file != "" {
  file = filepath.Join(t.TempDir(), filepath.Base(tc.file))
}

// in props
File: file,

---

684-702: Sorting: add t.Parallel for speed and isolation

The test is pure and deterministic—safe to parallelize.

 func TestSortDependentsByStackSlug_BasicOrder(t *testing.T) {
+  t.Parallel()
   deps := []schema.Dependent{

---

704-714: Nil/empty cases well covered; can parallelize

Same rationale as above.

 func TestSortDependentsByStackSlugRecursive_EmptyAndNil(t *testing.T) {
+  t.Parallel()
   // nil slice

---

716-749: Recursive sort: great coverage of nested ordering

Consider t.Parallel here as well.

 func TestSortDependentsByStackSlugRecursive_BasicAndNested(t *testing.T) {
+  t.Parallel()
   // Unsorted tree

---

751-765: Tie stability verified

Good use of SliceStable behavior. Also safe to parallelize.

 func TestSortDependentsByStackSlugRecursive_TieStabilityAtNestedLevel(t *testing.T) {
+  t.Parallel()
   // Children have identical (Stack, Component) → identical StackSlug; order should be stable.

---

40-45: Add explicit coverage for non-default flags and skip propagation

Right now we validate defaults. Add one focused test proving that DescribeDependentsExec forwards IncludeSettings=true, ProcessTemplates=false, ProcessYamlFunctions=false, and a non-empty Skip slice to ExecuteDescribeDependents. Keeps the new flags from regressing.

Here’s a small test you can drop in:

func TestDescribeDependentsExec_Execute_ForwardsFlagsAndSkip(t *testing.T) {
  t.Parallel()
  atmosConfig := &schema.AtmosConfiguration{}
  called := false
  skipIn := []string{"aws-profile", "lock"}
  exec := &describeDependentsExec{
    atmosConfig: atmosConfig,
    executeDescribeDependents: func(cfg *schema.AtmosConfiguration, component, stack string, includeSettings, processTemplates, processFunctions bool, skip []string) ([]schema.Dependent, error) {
      called = true
      assert.Equal(t, atmosConfig, cfg)
      assert.Equal(t, "c", component)
      assert.Equal(t, "s", stack)
      assert.True(t, includeSettings)
      assert.False(t, processTemplates)
      assert.False(t, processFunctions)
      assert.Equal(t, skipIn, skip)
      return []schema.Dependent{{Component: "x", Stack: "s"}}, nil
    },
    isTTYSupportForStdout: func() bool { return false },
    newPageCreator:        pager.NewMockPageCreator(gomock.NewController(t)),
    evaluateYqExpression:  func(_ *schema.AtmosConfiguration, data any, _ string) (any, error) { return data, nil },
  }

  err := exec.Execute(&DescribeDependentsExecProps{
    Component:           "c",
    Stack:               "s",
    Format:              "yaml",
    IncludeSettings:     true,
    ProcessTemplates:    false,
    ProcessYamlFunctions:false,
    Skip:                skipIn,
  })
  require.NoError(t, err)
  require.True(t, called)
}

Also applies to: 105-111

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: Listener430
PR: cloudposse/atmos#934
File: tests/fixtures/scenarios/docs-generate/README.md.gotmpl:99-118
Timestamp: 2025-01-25T03:51:57.689Z
Learning: For the cloudposse/atmos repository, changes to template contents should be handled in dedicated PRs and are typically considered out of scope for PRs focused on other objectives.

Learnt from: aknysh
PR: cloudposse/atmos#944
File: go.mod:206-206
Timestamp: 2025-01-17T00:18:57.769Z
Learning: For indirect dependencies with license compliance issues in the cloudposse/atmos repository, the team prefers to handle them in follow-up PRs rather than blocking the current changes, as these issues often require deeper investigation of the dependency tree.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Clearly describe the changes in the PR description

Learnt from: aknysh
PR: cloudposse/atmos#1405
File: internal/exec/describe_dependents_test.go:455-456
Timestamp: 2025-08-16T23:32:40.412Z
Learning: In the cloudposse/atmos Go codebase, `InitCliConfig` returns a `schema.AtmosConfiguration` value (not a pointer), while `ExecuteDescribeDependents` expects a `*schema.AtmosConfiguration` pointer parameter. Therefore, when passing the result of `InitCliConfig` to `ExecuteDescribeDependents`, use `&atmosConfig` to pass the address of the value.

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Consider using testify/mock for creating mock implementations

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Test both happy paths and error conditions

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*.go : Use interfaces for external dependencies to facilitate mocking

Learnt from: aknysh
PR: cloudposse/atmos#1405
File: internal/exec/describe_dependents_test.go:651-652
Timestamp: 2025-08-16T23:33:07.477Z
Learning: In the cloudposse/atmos Go codebase, ExecuteDescribeDependents expects a pointer to AtmosConfiguration (*schema.AtmosConfiguration), so when calling it with a value returned by cfg.InitCliConfig (which returns schema.AtmosConfiguration), the address-of operator (&) is necessary: ExecuteDescribeDependents(&atmosConfig, ...).

Learnt from: CR
PR: cloudposse/atmos#0
File: .cursor/rules/atmos-rules.mdc:0-0
Timestamp: 2025-07-01T02:22:25.901Z
Learning: Applies to **/*_test.go : Use table-driven tests for testing multiple scenarios