From 09e532b6f9c31024b4be25e40846f5c71af47fd4 Mon Sep 17 00:00:00 2001
From: davidtam <davidtam@users.noreply.github.com>
Date: Mon, 7 Jun 2021 23:16:39 +0100
Subject: [PATCH] Terragrunt support (#32)

* Add Terragrunt integration and general parser (#24)

* - add kw parser
- add tg command methods

* - add plan_all parse output progress
- replace terra* command func cli params with **kw

* add tgbinary to ci

* - add tg shared doc string decorator
- separate some of the public methods tg_xxx() | tf_xxx()
- fix parse_args() styling

* - Rollback parse_args()
- Add tg global args to parse_args()
- Add tg global args decorator
- Add all param to tg_xxx methods

* - mv tg flags before tf flags for cli args
- add common tg args to tg methods

* - fix tg source module warning
- add output() fixture to tg test

* bump version

* Terragrunt support (#29)

* Don't fail when resource_changes key not present in output (#27)

* Resolves #26 tftest failed when terraform plan is empty

* add missing copyright boilerplate

Co-authored-by: Ludovico Magnocavallo <ludo@qix.it>

* Update CHANGELOG.md

* Update CHANGELOG.md

* v1.5.6 for pypi

* made minimal changes to fix tests (now all passed locally for me)

* added a bit of code to parse run-all output and test to assert output

* added terragrunt run in single dir test case + simplified run-all

* added test cases for terragrunt parse args

* refactored terragrunt cmd line parameters parsing

* refactored as a separated class(TerragruntTest) but reused most of TerraformTest

Co-authored-by: Mike Brown II <brownmike@users.noreply.github.com>
Co-authored-by: Ludovico Magnocavallo <ludo@qix.it>
Co-authored-by: Ludovico Magnocavallo <ludomagno@google.com>

* speed up tests(session scope to reuse fixtures) + work around for strange tf run-all plan behaviour

* added back change log

* adding newline at end of file

* Adding terragrunt section to readme

* added some doc strings

* remove binary param from _clean_up to fix tests

* Update README.md

* Update README.md

* Update CHANGELOG.md

* Update tftest.py

Co-authored-by: Marshall Mamiya <44485531+marshall7m@users.noreply.github.com>
Co-authored-by: Ludovico Magnocavallo <ludomagno@google.com>
Co-authored-by: Mike Brown II <brownmike@users.noreply.github.com>
Co-authored-by: Ludovico Magnocavallo <ludo@qix.it>
---
 .ci/cloudbuild.test.yaml                      |   5 +-
 CHANGELOG.md                                  |   2 +
 README.md                                     |  34 +++-
 test/fixtures/tg_apply_all/bar/terragrunt.hcl |  11 ++
 test/fixtures/tg_apply_all/foo/terragrunt.hcl |  11 ++
 test/fixtures/tg_apply_all/terragrunt.hcl     |  11 ++
 test/test_args.py                             |  49 ++++-
 test/test_no_outputs.py                       |   2 +-
 test/test_plan.py                             |   2 +-
 test/test_sample_apply.py                     |   2 +-
 test/test_sample_plan.py                      |   2 +-
 test/test_tg_all.py                           |  77 ++++++++
 tftest.py                                     | 181 +++++++++++++++---
 13 files changed, 354 insertions(+), 35 deletions(-)
 create mode 100644 test/fixtures/tg_apply_all/bar/terragrunt.hcl
 create mode 100644 test/fixtures/tg_apply_all/foo/terragrunt.hcl
 create mode 100644 test/fixtures/tg_apply_all/terragrunt.hcl
 create mode 100644 test/test_tg_all.py

diff --git a/.ci/cloudbuild.test.yaml b/.ci/cloudbuild.test.yaml
index 86dc4fc..5671854 100644
--- a/.ci/cloudbuild.test.yaml
+++ b/.ci/cloudbuild.test.yaml
@@ -23,7 +23,9 @@ steps:
         wget https://releases.hashicorp.com/terraform/${_TERRAFORM_VERSION}/terraform_${_TERRAFORM_VERSION}_linux_amd64.zip &&
         unzip terraform_${_TERRAFORM_VERSION}_linux_amd64.zip -d /builder/home/.local/bin &&
         rm terraform_${_TERRAFORM_VERSION}_linux_amd64.zip &&
-        chmod 755 /builder/home/.local/bin/terraform
+        wget -O /builder/home/.local/bin/terragrunt https://github.com/gruntwork-io/terragrunt/releases/download/v${_TERRAGRUNT_VERSION}/terragrunt_linux_amd64 &&
+        chmod 755 /builder/home/.local/bin/terraform &&
+        chmod 755 /builder/home/.local/bin/terragrunt
   # TODO(ludoo): split into two triggers with different filters
   - name: python:3.6-alpine
     id: test
@@ -36,6 +38,7 @@ steps:
 
 substitutions:
   _TERRAFORM_VERSION: 0.15.4
+  _TERRAGRUNT_VERSION: 0.29.8
 
 tags:
   - "ci"
diff --git a/CHANGELOG.md b/CHANGELOG.md
index dd69bbe..d05bf05 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+- Terragrunt support (@davidtam) [#32]
+
 ## [1.5.7]
 
 - improve Windows support [#28]
diff --git a/README.md b/README.md
index 1b4b79f..576cf41 100644
--- a/README.md
+++ b/README.md
@@ -6,7 +6,7 @@ It allows for different types of tests: lightweight tests that only use Terrafor
 
 As an additional convenience, the module also provides an easy way to request and access the plan output (via `terraform plan -out` and `terraform show`) and the outputs (via `terraform output -json`), and return them wrapped in simple classes that streamline accessing their attributes.
 
-This module is heavily inspired by two projects: [Terragrunt](https://github.com/gruntwork-io/terragrunt) for the lightweight approach to testing Terraform, and [python-terraform](https://github.com/beelit94/python-terraform) for wrapping the Terraform command in Python.
+This module is heavily inspired by two projects: [Terratest](https://github.com/gruntwork-io/terratest) for the lightweight approach to testing Terraform, and [python-terraform](https://github.com/beelit94/python-terraform) for wrapping the Terraform command in Python.
 
 ## Example Usage
 
@@ -46,6 +46,38 @@ def test_modules(plan):
   assert res['values']['location'] == plan.variables['gcs_location']
 ```
 
+## Terragrunt support
+
+Support for Terragrunt actually follows the same principle of the thin `TerraformTest` wrapper.
+
+Please see the following example for how to use it:
+
+```python
+import pytest
+import tftest
+
+
+@pytest.fixture
+def run_all_apply_out(fixtures_dir):
+  # notice for run-all, you need to specify when TerragruntTest is constructed
+  tg = tftest.TerragruntTest('tg_apply_all', fixtures_dir, tg_run_all=True)
+  # the rest is very similar to how you use TerraformTest
+  tg.setup()
+  # to use --terragrunt-<option>, pass in tg_<option in snake case>
+  tg.apply(output=False, tg_non_interactive=True)
+  yield tg.output()
+  tg.destroy(auto_approve=True, tg_non_interactive=True)
+
+  
+def test_run_all_apply(run_all_apply_out):
+    triggers = [o["triggers"] for o in run_all_apply_out]
+    assert [{'name': 'foo', 'template': 'sample template foo'}] in triggers
+    assert [{'name': 'bar', 'template': 'sample template bar'}] in triggers
+    assert [{'name': 'one', 'template': 'sample template one'},
+            {'name': 'two', 'template': 'sample template two'}] in triggers
+    assert len(run_all_apply_out) == 3
+```
+
 ## Compatibility
 
 Starting from version `1.0.0` Terraform `0.12` is required, and tests written with previous versions of this module are incompatible. Check the [`CHANGELOG.md`](https://github.com/GoogleCloudPlatform/terraform-python-testing-helper/blob/master/CHANGELOG.md) file for details on what's changed.
diff --git a/test/fixtures/tg_apply_all/bar/terragrunt.hcl b/test/fixtures/tg_apply_all/bar/terragrunt.hcl
new file mode 100644
index 0000000..1723ca2
--- /dev/null
+++ b/test/fixtures/tg_apply_all/bar/terragrunt.hcl
@@ -0,0 +1,11 @@
+include {
+  path = find_in_parent_folders()
+}
+
+terraform {
+  source = "../..//apply"
+}
+
+inputs = {
+    names = ["bar"]
+}
diff --git a/test/fixtures/tg_apply_all/foo/terragrunt.hcl b/test/fixtures/tg_apply_all/foo/terragrunt.hcl
new file mode 100644
index 0000000..5570601
--- /dev/null
+++ b/test/fixtures/tg_apply_all/foo/terragrunt.hcl
@@ -0,0 +1,11 @@
+include {
+  path = find_in_parent_folders()
+}
+
+terraform {
+  source = "../..//apply"
+}
+
+inputs = {
+    names = ["foo"]
+}
diff --git a/test/fixtures/tg_apply_all/terragrunt.hcl b/test/fixtures/tg_apply_all/terragrunt.hcl
new file mode 100644
index 0000000..2c8d0b7
--- /dev/null
+++ b/test/fixtures/tg_apply_all/terragrunt.hcl
@@ -0,0 +1,11 @@
+terraform {
+  source = "..//apply"
+}
+
+generate "provider" {
+  path      = "provider.tf"
+  if_exists = "overwrite_terragrunt"
+  contents  = <<EOF
+provider "null" {}
+EOF
+}
diff --git a/test/test_args.py b/test/test_args.py
index 294e608..45199c8 100644
--- a/test/test_args.py
+++ b/test/test_args.py
@@ -13,6 +13,7 @@
 # limitations under the License.
 
 "Test the function for mapping Terraform arguments."
+import pytest
 
 import tftest
 
@@ -45,10 +46,52 @@
 )
 
 
-def test_args():
+@pytest.mark.parametrize("kwargs, expected", ARGS_TESTS)
+def test_args(kwargs, expected):
   assert tftest.parse_args() == []
-  for kwargs, expected in ARGS_TESTS:
-    assert tftest.parse_args(**kwargs) == expected
+  assert tftest.parse_args(**kwargs) == expected
+
+
+TERRAGRUNT_ARGS_TESTCASES = [
+    ({"tg_config": "Obama"}, ['--terragrunt-config', 'Obama']),
+    ({"tg_tfpath": "Barrack"}, ['--terragrunt-tfpath', 'Barrack']),
+    ({"tg_no_auto_init": True}, ['--terragrunt-no-auto-init']),
+    ({"tg_no_auto_init": False}, []),
+    ({"tg_no_auto_retry": True}, ['--terragrunt-no-auto-retry']),
+    ({"tg_no_auto_retry": False}, []),
+    ({"tg_non_interactive": True}, ['--terragrunt-non-interactive']),
+    ({"tg_non_interactive": False}, []),
+    ({"tg_working_dir": "George"}, ['--terragrunt-working-dir', 'George']),
+    ({"tg_download_dir": "Bush"}, ['--terragrunt-download-dir', 'Bush']),
+    ({"tg_source": "Clinton"}, ['--terragrunt-source', 'Clinton']),
+    ({"tg_source_update": True}, ['--terragrunt-source-update']),
+    ({"tg_source_update": False}, []),
+    ({"tg_iam_role": "Bill"}, ['--terragrunt-iam-role', 'Bill']),
+    ({"tg_ignore_dependency_errors": True}, ['--terragrunt-ignore-dependency-errors']),
+    ({"tg_ignore_dependency_errors": False}, []),
+    ({"tg_ignore_dependency_order": True}, ['--terragrunt-ignore-dependency-order']),
+    ({"tg_ignore_dependency_order": False}, []),
+    ({"tg_ignore_external_dependencies": "dont care what is here"},
+     ['--terragrunt-ignore-external-dependencies']),
+    ({"tg_include_external_dependencies": True}, ['--terragrunt-include-external-dependencies']),
+    ({"tg_include_external_dependencies": False}, []),
+    ({"tg_parallelism": 20}, ['--terragrunt-parallelism 20']),
+    ({"tg_exclude_dir": "Ronald"}, ['--terragrunt-exclude-dir', 'Ronald']),
+    ({"tg_include_dir": "Reagan"}, ['--terragrunt-include-dir', 'Reagan']),
+    ({"tg_check": True}, ['--terragrunt-check']),
+    ({"tg_check": False}, []),
+    ({"tg_hclfmt_file": "Biden"}, ['--terragrunt-hclfmt-file', 'Biden']),
+    ({"tg_override_attr": {"Iron": "Man", "Captain": "America"}},
+     ['--terragrunt-override-attr=Iron=Man', '--terragrunt-override-attr=Captain=America']),
+    ({"tg_debug": True}, ['--terragrunt-debug']),
+    ({"tg_debug": False}, []),
+
+]
+
+
+@pytest.mark.parametrize("kwargs, expected", TERRAGRUNT_ARGS_TESTCASES)
+def test_terragrunt_args(kwargs, expected):
+  assert tftest.parse_args(**kwargs) == expected
 
 
 def test_var_args():
diff --git a/test/test_no_outputs.py b/test/test_no_outputs.py
index 5d88606..cea4228 100644
--- a/test/test_no_outputs.py
+++ b/test/test_no_outputs.py
@@ -18,7 +18,7 @@
 import tftest
 
 
-@pytest.fixture
+@pytest.fixture(scope="module")
 def plan(fixtures_dir):
   tf = tftest.TerraformTest('no_outputs', fixtures_dir)
   tf.setup(extra_files=['plan.auto.tfvars'])
diff --git a/test/test_plan.py b/test/test_plan.py
index 02b27fe..849f834 100644
--- a/test/test_plan.py
+++ b/test/test_plan.py
@@ -18,7 +18,7 @@
 import tftest
 
 
-@pytest.fixture
+@pytest.fixture(scope="module")
 def plan_out(fixtures_dir):
   import json
   with open('%s/plan_output.json' % fixtures_dir) as fp:
diff --git a/test/test_sample_apply.py b/test/test_sample_apply.py
index 91f52c6..a30cf2f 100644
--- a/test/test_sample_apply.py
+++ b/test/test_sample_apply.py
@@ -24,7 +24,7 @@ def output(fixtures_dir):
   tf.setup()
   tf.apply()
   yield tf.output()
-  tf.destroy()
+  tf.destroy(**{"auto_approve": True})
 
 
 def test_apply(output):
diff --git a/test/test_sample_plan.py b/test/test_sample_plan.py
index bac45e6..7bf80fe 100644
--- a/test/test_sample_plan.py
+++ b/test/test_sample_plan.py
@@ -18,7 +18,7 @@
 import tftest
 
 
-@pytest.fixture
+@pytest.fixture(scope="module")
 def plan(fixtures_dir):
   tf = tftest.TerraformTest('plan', fixtures_dir)
   tf.setup(extra_files=['plan.auto.tfvars'])
diff --git a/test/test_tg_all.py b/test/test_tg_all.py
new file mode 100644
index 0000000..061df1d
--- /dev/null
+++ b/test/test_tg_all.py
@@ -0,0 +1,77 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pytest
+import tftest
+
+import os
+
+
+@pytest.fixture
+def run_all_apply_out(fixtures_dir):
+  tg = tftest.TerragruntTest('tg_apply_all', fixtures_dir, tg_run_all=True)
+  tg.setup()
+  tg.apply(output=False, tg_non_interactive=True)
+  yield tg.output()
+  tg.destroy(auto_approve=True, tg_non_interactive=True)
+
+
+@pytest.fixture
+def run_all_plan_output(fixtures_dir):
+  tg = tftest.TerragruntTest('tg_apply_all', fixtures_dir, tg_run_all=True)
+  tg.setup()
+  return tg.plan(output=True, tg_working_dir=os.path.join(fixtures_dir, 'tg_apply_all'))
+
+
+@pytest.fixture
+def plan_foo_output(fixtures_dir):
+  tg = tftest.TerragruntTest(os.path.join('tg_apply_all', 'foo'), fixtures_dir)
+  tg.setup()
+  return tg.plan(output=True)
+
+
+@pytest.fixture
+def bar_output(fixtures_dir):
+  tg = tftest.TerragruntTest(os.path.join('tg_apply_all', 'bar'), fixtures_dir)
+  tg.setup()
+  tg.apply(output=False, tg_non_interactive=True)
+  yield tg.output()
+  tg.destroy(auto_approve=True, tg_non_interactive=True)
+
+
+def test_run_all_apply(run_all_apply_out):
+  triggers = [o["triggers"] for o in run_all_apply_out]
+  assert [{'name': 'foo', 'template': 'sample template foo'}] in triggers
+  assert [{'name': 'bar', 'template': 'sample template bar'}] in triggers
+  assert [{'name': 'one', 'template': 'sample template one'},
+          {'name': 'two', 'template': 'sample template two'}] in triggers
+  assert len(run_all_apply_out) == 3
+
+
+def test_tg_single_directory_apply(bar_output):
+  assert bar_output["triggers"] == [{'name': 'bar', 'template': 'sample template bar'}]
+
+
+def test_run_all_plan(run_all_plan_output):
+  triggers = [o.outputs["triggers"] for o in run_all_plan_output]
+  assert [{'name': 'foo', 'template': 'sample template foo'}] in triggers
+  assert [{'name': 'bar', 'template': 'sample template bar'}] in triggers
+  assert [{'name': 'one', 'template': 'sample template one'},
+          {'name': 'two', 'template': 'sample template two'}] in triggers
+  assert len(run_all_plan_output) == 3
+
+
+def test_tg_single_directory_plan(plan_foo_output):
+  assert plan_foo_output.outputs['triggers'] == [{'name': 'foo', 'template': 'sample template foo'}]
+  assert plan_foo_output.variables['names'] == ['foo']
diff --git a/tftest.py b/tftest.py
index bc4317b..994eb78 100644
--- a/tftest.py
+++ b/tftest.py
@@ -24,6 +24,8 @@
 from __future__ import unicode_literals
 
 import collections
+
+import glob
 import itertools
 import json
 import logging
@@ -32,6 +34,9 @@
 import subprocess
 import tempfile
 import weakref
+import re
+from functools import partial
+from typing import List
 
 __version__ = '1.5.7'
 
@@ -49,6 +54,33 @@ class TerraformTestError(Exception):
   pass
 
 
+_TG_BOOL_ARGS = [
+  "no_auto_init",
+  "no_auto_retry",
+  "source_update",
+  "ignore_dependency_errors",
+  "ignore_dependency_order",
+  "include_external_dependencies",
+  "check",
+  "debug",
+  'non_interactive',
+  'ignore_external_dependencies',
+]
+
+
+_TG_KV_ARGS = [
+  "iam_role",
+  "config",
+  "tfpath",
+  "working_dir",
+  "download_dir",
+  "source",
+  "exclude_dir",
+  "include_dir",
+  "hclfmt_file",
+]
+
+
 def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
   """Convert method arguments for use in Terraform commands.
 
@@ -62,6 +94,18 @@ def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
     A list of command arguments for use with subprocess.
   """
   cmd_args = []
+
+  cmd_args += [f'--terragrunt-{arg.replace("_", "-")}'
+               for arg in _TG_BOOL_ARGS if kw.get(f"tg_{arg}")]
+  for arg in _TG_KV_ARGS:
+    if kw.get(f"tg_{arg}"):
+      cmd_args += [f'--terragrunt-{arg.replace("_", "-")}', kw[f"tg_{arg}"]]
+  if kw.get('tg_parallelism'):
+    cmd_args.append(f'--terragrunt-parallelism {kw["tg_parallelism"]}')
+  if isinstance(kw.get('tg_override_attr'), dict):
+    cmd_args += ['--terragrunt-override-attr={}={}'.format(k, v)
+                 for k, v in kw.get('tg_override_attr').items()]
+
   if kw.get('auto_approve'):
     cmd_args.append('-auto-approve')
   if kw.get('backend') is False:
@@ -235,22 +279,25 @@ class TerraformTest(object):
       relative to basedir.
     basedir: optional base directory to use for relative paths, defaults to the
       directory above the one this module lives in.
-    terraform: path to the Terraform command.
+    binary: path to the Terraform command.
     env: a dict with custom environment variables to pass to terraform.
   """
 
-  def __init__(self, tfdir, basedir=None, terraform='terraform', env=None):
+  def __init__(self, tfdir, basedir=None, binary='terraform', env=None):
     """Set Terraform folder to operate on, and optional base directory."""
     self._basedir = basedir or os.getcwd()
-    self.terraform = terraform
+    self.binary = binary
     self.tfdir = self._abspath(tfdir)
     self.env = os.environ.copy()
+    self.tg_run_all = False
+    self._plan_formatter = lambda out: TerraformPlanOutput(json.loads(out))
+    self._output_formatter = lambda out: TerraformValueDict(json.loads(out))
     if env is not None:
       self.env.update(env)
 
   @classmethod
   def _cleanup(cls, tfdir, filenames, deep=True):
-    """Remove linked files and .terraform folder at instance deletion."""
+    """Remove linked files, .terraform and/or .terragrunt-cache folder at instance deletion."""
     _LOGGER.debug('cleaning up %s %s', tfdir, filenames)
     for filename in filenames:
       path = os.path.join(tfdir, filename)
@@ -263,13 +310,17 @@ def _cleanup(cls, tfdir, filenames, deep=True):
     path = os.path.join(tfdir, 'terraform.tfstate')
     if os.path.isfile(path):
       os.unlink(path)
+    path = os.path.join(tfdir, '**', '.terragrunt-cache*')
+    for tg_dir in glob.glob(path, recursive=True):
+      if os.path.isdir(tg_dir):
+        shutil.rmtree(tg_dir)
 
   def _abspath(self, path):
     """Make relative path absolute from base dir."""
     return path if path.startswith('/') else os.path.join(self._basedir, path)
 
   def setup(self, extra_files=None, plugin_dir=None, init_vars=None,
-            backend=True, cleanup_on_exit=True):
+            backend=True, cleanup_on_exit=True, **kw):
     """Setup method to use in test fixtures.
 
     This method prepares a new Terraform environment for testing the module
@@ -308,66 +359,94 @@ def setup(self, extra_files=None, plugin_dir=None, init_vars=None,
         _LOGGER.warning('no such file {}'.format(link_src))
     self._finalizer = weakref.finalize(
         self, self._cleanup, self.tfdir, filenames, deep=cleanup_on_exit)
-    return self.init(plugin_dir=plugin_dir, init_vars=init_vars, backend=backend)
+    return self.init(plugin_dir=plugin_dir, init_vars=init_vars, backend=backend, **kw)
 
   def init(self, input=False, color=False, force_copy=False, plugin_dir=None,
-           init_vars=None, backend=True):
+           init_vars=None, backend=True, **kw):
     """Run Terraform init command."""
     cmd_args = parse_args(input=input, color=color, backend=backend,
                           force_copy=force_copy, plugin_dir=plugin_dir,
-                          init_vars=init_vars)
+                          init_vars=init_vars, **kw)
     return self.execute_command('init', *cmd_args).out
 
-  def plan(self, input=False, color=False, refresh=True, tf_vars=None, targets=None, output=False, tf_var_file=None):
-    "Run Terraform plan command, optionally returning parsed plan output."
+  def plan(self, input=False, color=False, refresh=True, tf_vars=None,
+           targets=None, output=False, tf_var_file=None, **kw):
+    """
+    Run Terraform plan command, optionally returning parsed plan output.
+
+    Args:
+      input: Ask for input for variables if not directly set.
+      no_color: If specified, output won't contain any color.
+      refresh: Update state prior to checking for differences.
+      tf_vars: Dict of variables in the Terraform configuration.
+      targets: List of resources to target. Operation will be limited to this resource
+        and its dependencies
+      output: Determines if output will be returned.
+      tf_var_file: Path to terraform variable configuration file relative to `self.tfdir`.
+    """
     cmd_args = parse_args(input=input, color=color,
                           refresh=refresh, tf_vars=tf_vars,
-                          targets=targets,  tf_var_file=tf_var_file)
+                          targets=targets,  tf_var_file=tf_var_file, **kw)
     if not output:
       return self.execute_command('plan', *cmd_args).out
     with tempfile.NamedTemporaryFile() as fp:
       fp.close()
-      cmd_args.append('-out={}'.format(fp.name))
-      self.execute_command('plan', *cmd_args)
-      result = self.execute_command('show', '-no-color', '-json', fp.name)
+    # for tg we need to specify a temp name that is relative for the output to go into each
+    # of the .terragrunt-cache, then plan / show would work, otherwise it overwrites each other!
+    temp_file = fp.name if len(self._tg_ra()) == 0 else os.path.basename(fp.name)
+    cmd_args.append('-out={}'.format(temp_file))
+    self.execute_command('plan', *cmd_args)
+    result = self.execute_command('show', '-no-color', '-json', temp_file)
     try:
-      return TerraformPlanOutput(json.loads(result.out))
+      return self._plan_formatter(result.out)
     except json.JSONDecodeError as e:
       raise TerraformTestError('Error decoding plan output: {}'.format(e))
 
-  def apply(self, input=False, color=False, auto_approve=True, tf_vars=None, targets=None, tf_var_file=None):
-    """Run Terraform apply command."""
+  def apply(self, input=False, color=False, auto_approve=True,
+            tf_vars=None, targets=None, tf_var_file=None, **kw):
+    """
+    Run Terraform apply command.
+
+    Args:
+      input: Ask for input for variables if not directly set.
+      no_color: If specified, output won't contain any color.
+      auto_approve: Skip interactive approval of plan before applying.
+      tf_vars: Dict of variables in the Terraform configuration.
+      targets: List of resources to target. Operation will be limited to this resource
+        and its dependencies
+      tf_var_file: Path to terraform variable configuration file relative to `self.tfdir`.
+    """
     cmd_args = parse_args(input=input, color=color,
                           auto_approve=auto_approve, tf_vars=tf_vars,
-                          targets=targets, tf_var_file=tf_var_file)
+                          targets=targets, tf_var_file=tf_var_file, **kw)
     return self.execute_command('apply', *cmd_args).out
 
-  def output(self, name=None, color=False, json_format=True):
+  def output(self, name=None, color=False, json_format=True, **kw):
     """Run Terraform output command."""
     cmd_args = []
     if name:
       cmd_args.append(name)
-    cmd_args += parse_args(color=color, json_format=json_format)
+    cmd_args += parse_args(color=color, json_format=json_format, **kw)
     output = self.execute_command('output', *cmd_args).out
     _LOGGER.debug('output %s', output)
     if json_format:
       try:
-        output = TerraformValueDict(json.loads(output))
+        output = self._output_formatter(output)
       except json.JSONDecodeError as e:
         _LOGGER.warning('error decoding output: {}'.format(e))
     return output
 
-  def destroy(self, color=False, auto_approve=True, tf_vars=None, targets=None, tf_var_file=None):
+  def destroy(self, color=False, auto_approve=True, tf_vars=None, targets=None, tf_var_file=None,  **kw):
     """Run Terraform destroy command."""
     cmd_args = parse_args(color=color, auto_approve=auto_approve,
                           tf_vars=tf_vars, targets=targets,
-                          tf_var_file=tf_var_file)
+                          tf_var_file=tf_var_file,  **kw)
     return self.execute_command('destroy', *cmd_args).out
 
-  def refresh(self, color=False, lock=False, tf_vars=None, targets=None):
+  def refresh(self, color=False, lock=False, tf_vars=None, targets=None,  **kw):
     """Run Terraform refresh command."""
     cmd_args = parse_args(color=color, lock=lock,
-                          tf_vars=tf_vars, targets=targets)
+                          tf_vars=tf_vars, targets=targets,  **kw)
     return self.execute_command('refresh', *cmd_args).out
 
   def state_pull(self):
@@ -382,8 +461,9 @@ def state_pull(self):
   def execute_command(self, cmd, *cmd_args):
     """Run arbitrary Terraform command."""
     _LOGGER.debug([cmd, cmd_args])
-    cmdline = [self.terraform, cmd]
+    cmdline = [self.binary, *self._tg_ra(), cmd]
     cmdline += cmd_args
+    _LOGGER.info(cmdline)
     try:
       p = subprocess.Popen(cmdline, stdout=subprocess.PIPE,
                            stderr=subprocess.PIPE, cwd=self.tfdir, env=self.env)
@@ -399,3 +479,52 @@ def execute_command(self, cmd, *cmd_args):
       _LOGGER.critical(message)
       raise TerraformTestError(message)
     return TerraformCommandOutput(retcode, out, err)
+
+  def _tg_ra(self) -> List[str]:
+    """if run_all return ['run-all'] else [] """
+    return ['run-all'] if self._is_tg() and self.tg_run_all else []
+
+  def _is_tg(self) -> bool:
+    """based on the binary set determines if we are running terragrunt"""
+    return self.binary.endswith('terragrunt')
+
+
+def _parse_run_all_out(output: str, formatter: TerraformJSONBase) -> str:
+  """
+    run-all output a bunch of jsons back to back in one string(no comma),
+    this convert the output to a valid json (put b2b jsons into a list)
+  Args:
+    output: the back to back jsons in a string
+    formatter: output format, could be TerraformValueDict or TerraformPlanOutput
+  Returns:
+    convert the input into a list that is a valid json
+  """
+  dicts = json.loads("[" + re.sub(r"\}\s*\{", "}, {", output) + "]")
+  return [formatter(d) for d in dicts]
+
+
+class TerragruntTest(TerraformTest):
+
+  def __init__(self, tfdir, basedir=None, binary='terragrunt', env=None, tg_run_all=False):
+    """A helper class that could be used for testing terragrunt
+
+    Most operations that apply to :func:`~TerraformTest` also apply to this class.
+    Notice that to use this class for Terragrunt run-all, `tg_run_all` needs to be set to
+    True.  The class would then only be used just for run-all.  If you need individual
+    Terragrunt module testing, create another instance of this helper with
+    tg_run_all=False (default)
+
+    Args:
+      tfdir: the Terraform module directory to test, either an absolute path, or
+             relative to basedir.
+      basedir: optional base directory to use for relative paths, defaults to the
+               directory above the one this module lives in.
+      binary: (Optional) path to terragrunt command.
+      env: a dict with custom environment variables to pass to terraform.
+      tg_run_all: whether the test is for terragrunt run-all, default to False
+    """
+    TerraformTest.__init__(self, tfdir, basedir, binary, env)
+    self.tg_run_all = tg_run_all
+    if self.tg_run_all:
+      self._plan_formatter = partial(_parse_run_all_out, formatter=TerraformPlanOutput)
+      self._output_formatter = partial(_parse_run_all_out, formatter=TerraformValueDict)