From 964696fe40fa777a391fd884628f8bf6b22fec64 Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Mon, 30 Mar 2026 17:26:50 +0000
Subject: [PATCH 1/6] Refactor: remove Terragrunt support

Strip out all Terragrunt-specific logic, arguments, and classes (e.g., TerragruntTest).
Remove Terragrunt test fixtures and associated test files (test_tg_all.py).
Clean up test_args.py to remove Terragrunt argument tests.
Update README.md to remove the Terragrunt documentation.

Going forward, this library will only support Terraform and OpenTofu.
---
 README.md                                     |  32 -----
 .../plan_no_resource_changes/terragrunt.hcl   |   3 -
 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                             |  46 -------
 test/test_tg_all.py                           |  81 ------------
 tftest.py                                     | 116 +-----------------
 8 files changed, 4 insertions(+), 307 deletions(-)
 delete mode 100644 test/fixtures/plan_no_resource_changes/terragrunt.hcl
 delete mode 100644 test/fixtures/tg_apply_all/bar/terragrunt.hcl
 delete mode 100644 test/fixtures/tg_apply_all/foo/terragrunt.hcl
 delete mode 100644 test/fixtures/tg_apply_all/terragrunt.hcl
 delete mode 100644 test/test_tg_all.py

diff --git a/README.md b/README.md
index 66ca837..10e6377 100644
--- a/README.md
+++ b/README.md
@@ -46,38 +46,6 @@ 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
-```
-
 ## Caching
 
 The `TerraformTest` `setup`, `init`, `plan`, `apply`, `output` and `destroy` methods have the ability to cache it's associate output to a local `.tftest-cache` directory. For subsequent calls of the method, the cached value can be returned instead of calling the actual underlying `terraform` command. Using the cache value can be significantly faster than running the Terraform command again especially if the command is time-intensive.
diff --git a/test/fixtures/plan_no_resource_changes/terragrunt.hcl b/test/fixtures/plan_no_resource_changes/terragrunt.hcl
deleted file mode 100644
index f372e89..0000000
--- a/test/fixtures/plan_no_resource_changes/terragrunt.hcl
+++ /dev/null
@@ -1,3 +0,0 @@
-terraform {
-    source = get_terragrunt_dir()
-}
\ No newline at end of file
diff --git a/test/fixtures/tg_apply_all/bar/terragrunt.hcl b/test/fixtures/tg_apply_all/bar/terragrunt.hcl
deleted file mode 100644
index 1723ca2..0000000
--- a/test/fixtures/tg_apply_all/bar/terragrunt.hcl
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 5570601..0000000
--- a/test/fixtures/tg_apply_all/foo/terragrunt.hcl
+++ /dev/null
@@ -1,11 +0,0 @@
-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
deleted file mode 100644
index 2c8d0b7..0000000
--- a/test/fixtures/tg_apply_all/terragrunt.hcl
+++ /dev/null
@@ -1,11 +0,0 @@
-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 d070c00..2ea653e 100644
--- a/test/test_args.py
+++ b/test/test_args.py
@@ -64,52 +64,6 @@ def test_args(kwargs, expected):
   assert tftest.parse_args() == []
   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():
   assert sorted(tftest.parse_args(init_vars={'a': 1, 'b': '["2"]'})) == sorted(
       ["-backend-config=a=1", '-backend-config=b=["2"]'])
diff --git a/test/test_tg_all.py b/test/test_tg_all.py
deleted file mode 100644
index cc36a7b..0000000
--- a/test/test_tg_all.py
+++ /dev/null
@@ -1,81 +0,0 @@
-# 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 5b0ffbc..6fcaa1e 100644
--- a/tftest.py
+++ b/tftest.py
@@ -41,7 +41,6 @@
 from functools import partial
 from hashlib import sha1
 from pathlib import Path
-from typing import List
 
 __version__ = '1.8.5'
 
@@ -61,32 +60,6 @@ def cmd_error(self):
     return self.args[1] if len(self.args) > 1 else None
 
 
-_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.
 
@@ -101,22 +74,6 @@ def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
   """
   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:
@@ -334,7 +291,6 @@ def __init__(self, tfdir, basedir=None, binary='terraform', env=None,
     self.tfdir = self._abspath(tfdir)
     self._env = env or {}
     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))
@@ -349,7 +305,7 @@ def __init__(self, tfdir, basedir=None, binary='terraform', env=None,
 
   @classmethod
   def _cleanup(cls, tfdir, filenames, deep=True, restore_files=False):
-    """Remove linked files, .terraform and/or .terragrunt-cache folder at instance deletion."""
+    """Remove linked files and .terraform folder at instance deletion."""
 
     def remove_readonly(func, path, excinfo):
       _LOGGER.warning(f'Issue deleting file {path}, caused by {excinfo}')
@@ -374,10 +330,6 @@ def remove_readonly(func, path, excinfo):
     for path in glob.glob(os.path.join(tfdir, 'terraform.tfstate.backup*')):
       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, onerror=remove_readonly)
     _LOGGER.debug(
         'Restoring original TF files after prevent destroy changes')
     if restore_files:
@@ -496,8 +448,7 @@ def cache(self, **kwargs):
 
       if out:
         # the hash value will now include any changes
-        # to the tfdir directory including any terragrunt
-        # generated files
+        # to the tfdir directory
         hash_filename = self.generate_cache_hash(kwargs)
         cache_key = cache_dir / hash_filename
         _LOGGER.debug("Cache key: %s", cache_key)
@@ -641,10 +592,7 @@ def plan(self, input=False, color=False, refresh=True, tf_vars=None,
       return self.execute_command('plan', *cmd_args).out
     with tempfile.NamedTemporaryFile() as fp:
       fp.close()
-    # 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)
+    temp_file = 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)
@@ -718,7 +666,7 @@ def state_pull(self):
   def execute_command(self, cmd, *cmd_args):
     """Run arbitrary Terraform command."""
     _LOGGER.debug([cmd, cmd_args])
-    cmdline = [self.binary, *self._tg_ra(), cmd]
+    cmdline = [self.binary, cmd]
     cmdline += cmd_args
     _LOGGER.info(cmdline)
     retcode = None
@@ -748,59 +696,3 @@ def execute_command(self, cmd, *cmd_args):
       _LOGGER.critical(message)
       raise TerraformTestError(message, err)
     return TerraformCommandOutput(retcode, full_output, 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, enable_cache=False, cache_dir=None):
-    """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
-      enable_cache: Determines if the caching enabled for specific methods
-      cache_dir: optional base directory to use for caching, defaults to
-        the directory of the python file that instantiates this class
-    """
-    TerraformTest.__init__(self, tfdir, basedir, binary, env, enable_cache,
-                           cache_dir)
-    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)

From 8bae0e65529a50d2147b1fe7765c9784a92e9706 Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Tue, 31 Mar 2026 04:58:04 +0000
Subject: [PATCH 2/6] Refactor: Python modernization

- Remove legacy Python 2 future imports.
- Migrate string formatting to f-strings via flynt.
- Replace os.path usage with pathlib.Path.
- Add comprehensive type hinting to TerraformTest and related methods.
---
 test/test_plan.py  |   4 +-
 test/test_state.py |   2 +-
 tftest.py          | 174 ++++++++++++++++++++++++---------------------
 3 files changed, 95 insertions(+), 85 deletions(-)

diff --git a/test/test_plan.py b/test/test_plan.py
index 319d340..6eb2cb9 100644
--- a/test/test_plan.py
+++ b/test/test_plan.py
@@ -21,14 +21,14 @@
 @pytest.fixture(scope="module")
 def plan_out(fixtures_dir):
   import json
-  with open('%s/plan_output.json' % fixtures_dir) as fp:
+  with open(f'{fixtures_dir}/plan_output.json') as fp:
     return tftest.TerraformPlanOutput(json.load(fp))
 
 
 @pytest.fixture(scope="module")
 def plan_out_no_prior(fixtures_dir):
   import json
-  with open('%s/plan_output_no_prior.json' % fixtures_dir) as fp:
+  with open(f'{fixtures_dir}/plan_output_no_prior.json') as fp:
     return tftest.TerraformPlanOutput(json.load(fp))
 
 
diff --git a/test/test_state.py b/test/test_state.py
index 7f450a3..778f1cf 100644
--- a/test/test_state.py
+++ b/test/test_state.py
@@ -21,7 +21,7 @@
 @pytest.fixture
 def state(fixtures_dir):
   import json
-  with open('%s/state.json' % fixtures_dir) as fp:
+  with open(f'{fixtures_dir}/state.json') as fp:
     return tftest.TerraformState(json.load(fp))
 
 
diff --git a/tftest.py b/tftest.py
index 6fcaa1e..c41556e 100644
--- a/tftest.py
+++ b/tftest.py
@@ -17,13 +17,7 @@
 inspired by https://github.com/beelit94/python-terraform
 """
 
-from __future__ import absolute_import
-from __future__ import division
-from __future__ import print_function
-from __future__ import unicode_literals
-
 import collections
-import glob
 import inspect
 import itertools
 import json
@@ -38,9 +32,9 @@
 import tempfile
 import weakref
 
-from functools import partial
 from hashlib import sha1
 from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
 
 __version__ = '1.8.5'
 
@@ -97,27 +91,23 @@ def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
   if kw.get('upgrade'):
     cmd_args.append('-upgrade')
   if isinstance(init_vars, dict):
-    cmd_args += [
-        '-backend-config={}={}'.format(k, v) for k, v in init_vars.items()
-    ]
+    cmd_args += [f'-backend-config={k}={v}' for k, v in init_vars.items()]
   elif isinstance(init_vars, str):
-    cmd_args += ['-backend-config', '{}'.format(init_vars)]
+    cmd_args += ['-backend-config', f'{init_vars}']
   if tf_vars:
     cmd_args += list(
         itertools.chain.from_iterable(
             ("-var",
-             "{}={}".format(k,
-                            json.dumps(v) if isinstance(v, (dict,
-                                                            list)) else v))
+             f"{k}={json.dumps(v) if isinstance(v, (dict, list)) else v}")
             for k, v in tf_vars.items()))
   if targets:
-    cmd_args += [("-target={}".format(t)) for t in targets]
+    cmd_args += [f"-target={t}" for t in targets]
   if kw.get('tf_var_file'):
     tf_var_file = kw['tf_var_file']
     if isinstance(tf_var_file, (list, tuple)):
-      cmd_args += ['-var-file={}'.format(v) for v in tf_var_file]
+      cmd_args += [f'-var-file={v}' for v in tf_var_file]
     else:
-      cmd_args.append('-var-file={}'.format(tf_var_file))
+      cmd_args.append(f'-var-file={tf_var_file}')
   return cmd_args
 
 
@@ -237,8 +227,7 @@ def resources(self):
     if not self._resources:
       resources = {}
       for res in self._raw['resources']:
-        name = '%s.%s.%s' % (res.get('module'), res.get('type'),
-                             res.get('name'))
+        name = f"{res.get('module')}.{res.get('type')}.{res.get('name')}"
         resources[name] = res
       self._resources = resources
     return self._resources
@@ -292,12 +281,11 @@ def __init__(self, tfdir, basedir=None, binary='terraform', env=None,
     self._env = env or {}
     self.env = os.environ.copy()
     self._plan_formatter = lambda out: TerraformPlanOutput(json.loads(out))
-    self._output_formatter = lambda out: TerraformValueDict(
-        json.loads(out))
+    self._output_formatter = lambda out: TerraformValueDict(json.loads(out))
     self.enable_cache = enable_cache
     if not cache_dir:
-      self.cache_dir = Path(os.path.dirname(
-          inspect.stack()[1].filename)) / ".tftest-cache"
+      self.cache_dir = Path(
+          inspect.stack()[1].filename).parent / ".tftest-cache"
     else:
       self.cache_dir = Path(cache_dir)
     if env is not None:
@@ -313,49 +301,55 @@ def remove_readonly(func, path, excinfo):
       func(path)
 
     _LOGGER.debug('cleaning up %s %s', tfdir, filenames)
+    tf_path = Path(tfdir)
     for filename in filenames:
-      path = os.path.join(tfdir, filename)
-      os.unlink(path)
+      (tf_path / filename).unlink(missing_ok=True)
+
     if not deep:
       return
-    path = os.path.join(tfdir, '.terraform')
-    if os.path.isdir(path):
-      shutil.rmtree(path, onerror=remove_readonly)
-    path = os.path.join(tfdir, '.terraform.lock.hcl')
-    if os.path.isfile(path):
-      os.unlink(path)
-    path = os.path.join(tfdir, 'terraform.tfstate')
-    if os.path.isfile(path):
-      os.unlink(path)
-    for path in glob.glob(os.path.join(tfdir, 'terraform.tfstate.backup*')):
-      if os.path.isfile(path):
-        os.unlink(path)
-    _LOGGER.debug(
-        'Restoring original TF files after prevent destroy changes')
+
+    terraform_dir = tf_path / '.terraform'
+    if terraform_dir.is_dir():
+      shutil.rmtree(terraform_dir, onerror=remove_readonly)
+
+    lock_file = tf_path / '.terraform.lock.hcl'
+    if lock_file.is_file():
+      lock_file.unlink()
+
+    state_file = tf_path / 'terraform.tfstate'
+    if state_file.is_file():
+      state_file.unlink()
+
+    for backup_path in tf_path.glob('terraform.tfstate.backup*'):
+      if backup_path.is_file():
+        backup_path.unlink()
+
+    _LOGGER.debug('Restoring original TF files after prevent destroy changes')
     if restore_files:
-      for bkp_file in Path(tfdir).rglob('*.bkp'):
+      for bkp_file in tf_path.rglob('*.bkp'):
         try:
-          shutil.copy(str(bkp_file),
-                      f'{str(bkp_file).strip(".bkp")}')
+          shutil.copy(str(bkp_file), f'{str(bkp_file).strip(".bkp")}')
         except (IOError, OSError):
           _LOGGER.exception(
               f'Unable to restore terraform file {bkp_file.resolve()}')
           raise TerraformTestError(
               f'Restore of terraform file ({bkp_file.resolve()}) failed')
         else:
-          bkp_file.unlink(True)
+          bkp_file.unlink(missing_ok=True)
 
   def _abspath(self, path):
     """Make relative path absolute from base dir."""
-    return path if os.path.isabs(path) else os.path.join(self._basedir, path)
+    path_obj = Path(path)
+    if path_obj.is_absolute():
+      return str(path_obj)
+    return str(Path(self._basedir) / path)
 
   def _dirhash(self, directory, hash, ignore_hidden=False,
                exclude_directories=[], excluded_extensions=[]):
     """Returns hash of directory's file contents"""
     assert Path(directory).is_dir()
     try:
-      dir_iter = sorted(Path(directory).iterdir(),
-                        key=lambda p: str(p).lower())
+      dir_iter = sorted(Path(directory).iterdir(), key=lambda p: str(p).lower())
     except FileNotFoundError:
       return hash
     for path in dir_iter:
@@ -402,7 +396,7 @@ def generate_cache_hash(self, method_kwargs):
     params["tfdir"] = self._dirhash(self.tfdir, sha1(), ignore_hidden=True,
                                     exclude_directories=[".terraform"],
                                     excluded_extensions=['.backup', '.tfstate'
-                                                         ]).hexdigest()
+                                                        ]).hexdigest()
 
     return sha1(
         json.dumps(params, sort_keys=True,
@@ -467,9 +461,13 @@ def cache(self, **kwargs):
     return cache
 
   @_cache
-  def setup(self, extra_files=None, plugin_dir=None, init_vars=None,
-            backend=True, cleanup_on_exit=True, disable_prevent_destroy=False,
-            workspace_name=None, use_cache=False, **kw):
+  def setup(self, extra_files: Optional[List[str]] = None,
+            plugin_dir: Optional[str] = None,
+            init_vars: Optional[Union[Dict[str, Any],
+                                      str]] = None, backend: bool = True,
+            cleanup_on_exit: bool = True, disable_prevent_destroy: bool = False,
+            workspace_name: Optional[str] = None, use_cache: bool = False,
+            **kw: Any) -> str:
     """Setup method to use in test fixtures.
 
     This method prepares a new Terraform environment for testing the module
@@ -521,22 +519,22 @@ def setup(self, extra_files=None, plugin_dir=None, init_vars=None,
     # link extra files inside dir
     filenames = []
     for link_src in (extra_files or []):
-      link_src = self._abspath(link_src)
-      filename = os.path.basename(link_src)
-      if os.path.isfile(link_src):
-        link_dst = os.path.join(self.tfdir, filename)
+      link_src_path = Path(self._abspath(link_src))
+      filename = link_src_path.name
+      if link_src_path.is_file():
+        link_dst = Path(self.tfdir) / filename
         try:
           if os.name == 'nt':
-            shutil.copy(link_src, link_dst)
+            shutil.copy(link_src_path, link_dst)
           else:
-            os.symlink(link_src, link_dst)
+            os.symlink(link_src_path, link_dst)
           filenames.append(filename)
         except FileExistsError as e:  # pylint:disable=undefined-variable
           _LOGGER.warning(e)
         else:
-          _LOGGER.debug('linked %s', link_src)
+          _LOGGER.debug('linked %s', link_src_path)
       else:
-        _LOGGER.warning('no such file {}'.format(link_src))
+        _LOGGER.warning(f'no such file {link_src_path}')
     self._finalizer = weakref.finalize(self, self._cleanup, self.tfdir,
                                        filenames, deep=cleanup_on_exit,
                                        restore_files=disable_prevent_destroy)
@@ -547,15 +545,17 @@ def setup(self, extra_files=None, plugin_dir=None, init_vars=None,
     return setup_output
 
   @_cache
-  def init(self, input=False, color=False, force_copy=False, plugin_dir=None,
-           init_vars=None, backend=True, use_cache=False, **kw):
+  def init(self, input: bool = False, color: bool = False,
+           force_copy: bool = False, plugin_dir: Optional[str] = None,
+           init_vars: Optional[Union[Dict[str, Any], str]] = None,
+           backend: bool = True, use_cache: bool = False, **kw: Any) -> str:
     """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, **kw)
     return self.execute_command('init', *cmd_args).out
 
-  def workspace(self, name=None):
+  def workspace(self, name: str) -> str:
     """Run Terraform workspace command."""
     raw_ws_out = self.execute_command('workspace', *['list']).out
     cmd_args = ['select', name]
@@ -568,9 +568,12 @@ def workspace(self, name=None):
     return self.execute_command('workspace', *cmd_args).out
 
   @_cache
-  def plan(self, input=False, color=False, refresh=True, tf_vars=None,
-           targets=None, output=False, tf_var_file=None, state=None,
-           use_cache=False, **kw):
+  def plan(self, input: bool = False, color: bool = False, refresh: bool = True,
+           tf_vars: Optional[Dict[str, Any]] = None,
+           targets: Optional[List[str]] = None, output: bool = False,
+           tf_var_file: Optional[Union[str, List[str]]] = None,
+           state: Optional[str] = None, use_cache: bool = False,
+           **kw: Any) -> Union[str, TerraformPlanOutput]:
     """
     Run Terraform plan command, optionally returning parsed plan output.
 
@@ -593,18 +596,20 @@ def plan(self, input=False, color=False, refresh=True, tf_vars=None,
     with tempfile.NamedTemporaryFile() as fp:
       fp.close()
     temp_file = fp.name
-    cmd_args.append('-out={}'.format(temp_file))
+    cmd_args.append(f'-out={temp_file}')
     self.execute_command('plan', *cmd_args)
     result = self.execute_command('show', '-no-color', '-json', temp_file)
     try:
       return self._plan_formatter(result.out)
     except json.JSONDecodeError as e:
-      raise TerraformTestError(
-          'Error decoding plan output: {}'.format(e))
+      raise TerraformTestError(f'Error decoding plan output: {e}')
 
   @_cache
-  def apply(self, input=False, color=False, auto_approve=True, tf_vars=None,
-            targets=None, tf_var_file=None, use_cache=False, **kw):
+  def apply(self, input: bool = False, color: bool = False,
+            auto_approve: bool = True, tf_vars: Optional[Dict[str, Any]] = None,
+            targets: Optional[List[str]] = None,
+            tf_var_file: Optional[Union[str, List[str]]] = None,
+            use_cache: bool = False, **kw: Any) -> str:
     """
     Run Terraform apply command.
 
@@ -623,8 +628,9 @@ def apply(self, input=False, color=False, auto_approve=True, tf_vars=None,
     return self.execute_command('apply', *cmd_args).out
 
   @_cache
-  def output(self, name=None, color=False, json_format=True, use_cache=False,
-             **kw):
+  def output(self, name: Optional[str] = None, color: bool = False,
+             json_format: bool = True, use_cache: bool = False,
+             **kw: Any) -> Union[str, dict]:
     """Run Terraform output command."""
     cmd_args = []
     if name:
@@ -636,34 +642,39 @@ def output(self, name=None, color=False, json_format=True, use_cache=False,
       try:
         output = self._output_formatter(output)
       except json.JSONDecodeError as e:
-        _LOGGER.warning('error decoding output: {}'.format(e))
+        _LOGGER.warning(f'error decoding output: {e}')
     return output
 
   @_cache
-  def destroy(self, color=False, auto_approve=True, tf_vars=None, targets=None,
-              tf_var_file=None, use_cache=False, **kw):
+  def destroy(self, color: bool = False, auto_approve: bool = True,
+              tf_vars: Optional[Dict[str, Any]] = None,
+              targets: Optional[List[str]] = None,
+              tf_var_file: Optional[Union[str, List[str]]] = None,
+              use_cache: bool = False, **kw: Any) -> str:
     """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, **kw)
     return self.execute_command('destroy', *cmd_args).out
 
-  def refresh(self, color=False, lock=False, tf_vars=None, targets=None, **kw):
+  def refresh(self, color: bool = False, lock: bool = False,
+              tf_vars: Optional[Dict[str, Any]] = None,
+              targets: Optional[List[str]] = None, **kw: Any) -> str:
     """Run Terraform refresh command."""
     cmd_args = parse_args(color=color, lock=lock, tf_vars=tf_vars,
                           targets=targets, **kw)
     return self.execute_command('refresh', *cmd_args).out
 
-  def state_pull(self):
+  def state_pull(self) -> Union[str, TerraformState]:
     """Pull state."""
     state = self.execute_command('state', 'pull')
     try:
       state = TerraformState(json.loads(state.out))
     except json.JSONDecodeError as e:
-      _LOGGER.warning('error decoding state: {}'.format(e))
+      _LOGGER.warning(f'error decoding state: {e}')
     return state
 
-  def execute_command(self, cmd, *cmd_args):
+  def execute_command(self, cmd: str, *cmd_args: str) -> TerraformCommandOutput:
     """Run arbitrary Terraform command."""
     _LOGGER.debug([cmd, cmd_args])
     cmdline = [self.binary, cmd]
@@ -687,12 +698,11 @@ def execute_command(self, cmd, *cmd_args):
       retcode = p.poll()
       p.wait()
     except FileNotFoundError as e:
-      raise TerraformTestError('Terraform executable not found: %s' % e)
-    out, err = p.communicate()
+      raise TerraformTestError(f'Terraform executable not found: {e}')
+    _, err = p.communicate()
     full_output = "".join(full_output_lines)
     if retcode in [1, 11]:
-      message = 'Error running command {command}: {retcode} {out} {err}'.format(
-          command=cmd, retcode=retcode, out=full_output, err=err)
+      message = f'Error running command {cmd}: {retcode} {full_output} {err}'
       _LOGGER.critical(message)
       raise TerraformTestError(message, err)
     return TerraformCommandOutput(retcode, full_output, err)

From e54f1717850c89490e50c7e5870725f3e28170d2 Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Tue, 31 Mar 2026 05:29:53 +0000
Subject: [PATCH 3/6] Refactor: parse_args mapping

Replaced long list of if/elif statements with declarative mappings
(bool_flags, inverse_bool_flags, kv_flags) to simplify adding new
flags and reduce cyclomatic complexity.
---
 tftest.py | 51 +++++++++++++++++++++++++++++----------------------
 1 file changed, 29 insertions(+), 22 deletions(-)

diff --git a/tftest.py b/tftest.py
index c41556e..1565cb6 100644
--- a/tftest.py
+++ b/tftest.py
@@ -68,28 +68,35 @@ def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
   """
   cmd_args = []
 
-  if kw.get('auto_approve'):
-    cmd_args.append('-auto-approve')
-  if kw.get('backend') is False:
-    cmd_args.append('-backend=false')
-  if kw.get('color') is False:
-    cmd_args.append('-no-color')
-  if kw.get('force_copy'):
-    cmd_args.append('-force-copy')
-  if kw.get('input') is False:
-    cmd_args.append('-input=false')
-  if kw.get('json_format') is True:
-    cmd_args.append('-json')
-  if kw.get('lock') is False:
-    cmd_args.append('-lock=false')
-  if kw.get('plugin_dir'):
-    cmd_args += ['-plugin-dir', kw['plugin_dir']]
-  if kw.get('refresh') is False:
-    cmd_args.append('-refresh=false')
-  if kw.get('state'):
-    cmd_args += ['-state', kw['state']]
-  if kw.get('upgrade'):
-    cmd_args.append('-upgrade')
+  bool_flags = {
+      'auto_approve': '-auto-approve',
+      'force_copy': '-force-copy',
+      'json_format': '-json',
+      'upgrade': '-upgrade',
+  }
+  for kwarg, flag in bool_flags.items():
+    if kw.get(kwarg):
+      cmd_args.append(flag)
+
+  inverse_bool_flags = {
+      'backend': '-backend=false',
+      'color': '-no-color',
+      'input': '-input=false',
+      'lock': '-lock=false',
+      'refresh': '-refresh=false',
+  }
+  for kwarg, flag in inverse_bool_flags.items():
+    if kw.get(kwarg) is False:
+      cmd_args.append(flag)
+
+  kv_flags = {
+      'plugin_dir': '-plugin-dir',
+      'state': '-state',
+  }
+  for kwarg, flag in kv_flags.items():
+    if kw.get(kwarg):
+      cmd_args.extend([flag, kw[kwarg]])
+
   if isinstance(init_vars, dict):
     cmd_args += [f'-backend-config={k}={v}' for k, v in init_vars.items()]
   elif isinstance(init_vars, str):

From 25ab7e7b9861149c1d493f36f5af407f08561357 Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Tue, 31 Mar 2026 05:51:58 +0000
Subject: [PATCH 4/6] Chore: configure and apply yapf formatting

Add .style.yapf using google style to match the Cloud Foundation
Fabric repository. Apply yapf formatting across all python files.
---
 .style.yapf                           |   4 +
 test/test_args.py                     | 168 +++++++++++++++++++-------
 test/test_backend_config.py           |   1 -
 test/test_cache.py                    |  34 +++---
 test/test_files.py                    |   9 +-
 test/test_no_outputs.py               |   1 -
 test/test_pickle.py                   |   1 -
 test/test_plan.py                     |   7 +-
 test/test_prevent_destroy.py          |  12 +-
 test/test_sample_apply.py             |   1 -
 test/test_sample_plan.py              |   1 -
 test/test_sample_plan_error.py        |   1 -
 test/test_sample_plan_no_variables.py |   1 -
 test/test_state.py                    |   1 -
 test/test_value_dict.py               |   2 -
 test/test_workspace.py                |   1 -
 16 files changed, 162 insertions(+), 83 deletions(-)
 create mode 100644 .style.yapf

diff --git a/.style.yapf b/.style.yapf
new file mode 100644
index 0000000..86926ff
--- /dev/null
+++ b/.style.yapf
@@ -0,0 +1,4 @@
+[style]
+based_on_style=google
+indent_width=2
+split_before_named_assigns=false
\ No newline at end of file
diff --git a/test/test_args.py b/test/test_args.py
index 2ea653e..5d39aec 100644
--- a/test/test_args.py
+++ b/test/test_args.py
@@ -11,51 +11,128 @@
 # 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.
-
 "Test the function for mapping Terraform arguments."
 import pytest
 
 import tftest
 
-
 ARGS_TESTS = (
-    ({'auto_approve': True}, ['-auto-approve']),
-    ({'auto_approve': False}, []),
-    ({'backend': True}, []),
-    ({'backend': None}, []),
-    ({'backend': False}, ['-backend=false']),
-    ({'color': True}, []),
-    ({'color': False}, ['-no-color']),
-    ({'color': False, 'input': False}, ['-no-color', '-input=false']),
-    ({'force_copy': True}, ['-force-copy']),
-    ({'force_copy': None}, []),
-    ({'force_copy': False}, []),
-    ({'input': True}, []),
-    ({'input': False}, ['-input=false']),
-    ({'json_format': True}, ['-json']),
-    ({'json_format': False}, []),
-    ({'lock': True}, []),
-    ({'lock': False}, ['-lock=false']),
-    ({'plugin_dir': ''}, []),
-    ({'plugin_dir': 'abc'}, ['-plugin-dir', 'abc']),
-    ({'refresh': True}, []),
-    ({'refresh': None}, []),
-    ({'refresh': False}, ['-refresh=false']),
-    ({'upgrade': True}, ['-upgrade']),
-    ({'upgrade': False}, []),
-    ({'tf_var_file': None}, []),
-    ({'tf_var_file': 'foo.tfvar'}, ['-var-file=foo.tfvar']),
-    ({'tf_var_file': ['foo.tfvar', 'bar.tfvar']}, [
-     '-var-file=foo.tfvar', '-var-file=bar.tfvar']),
-    ({'tf_vars': {'text': 'text'}}, ['-var', 'text=text']),
-    ({'tf_vars': {'number': 0}}, ['-var', 'number=0']),
-    ({'tf_vars': {'bool': False}}, ['-var', 'bool=False']),
-    ({'tf_vars': {'dict': {'text': 'text'}}},
-     ['-var', 'dict={"text": "text"}']),
-    ({'tf_vars': {'list': ['item1', 'item2']}},
-     ['-var', 'list=["item1", "item2"]']),
-    ({'tf_vars': {'dict': {'list': ['item1', 'item2']}}},
-     ['-var', 'dict={"list": ["item1", "item2"]}']),
+    ({
+        'auto_approve': True
+    }, ['-auto-approve']),
+    ({
+        'auto_approve': False
+    }, []),
+    ({
+        'backend': True
+    }, []),
+    ({
+        'backend': None
+    }, []),
+    ({
+        'backend': False
+    }, ['-backend=false']),
+    ({
+        'color': True
+    }, []),
+    ({
+        'color': False
+    }, ['-no-color']),
+    ({
+        'color': False,
+        'input': False
+    }, ['-no-color', '-input=false']),
+    ({
+        'force_copy': True
+    }, ['-force-copy']),
+    ({
+        'force_copy': None
+    }, []),
+    ({
+        'force_copy': False
+    }, []),
+    ({
+        'input': True
+    }, []),
+    ({
+        'input': False
+    }, ['-input=false']),
+    ({
+        'json_format': True
+    }, ['-json']),
+    ({
+        'json_format': False
+    }, []),
+    ({
+        'lock': True
+    }, []),
+    ({
+        'lock': False
+    }, ['-lock=false']),
+    ({
+        'plugin_dir': ''
+    }, []),
+    ({
+        'plugin_dir': 'abc'
+    }, ['-plugin-dir', 'abc']),
+    ({
+        'refresh': True
+    }, []),
+    ({
+        'refresh': None
+    }, []),
+    ({
+        'refresh': False
+    }, ['-refresh=false']),
+    ({
+        'upgrade': True
+    }, ['-upgrade']),
+    ({
+        'upgrade': False
+    }, []),
+    ({
+        'tf_var_file': None
+    }, []),
+    ({
+        'tf_var_file': 'foo.tfvar'
+    }, ['-var-file=foo.tfvar']),
+    ({
+        'tf_var_file': ['foo.tfvar', 'bar.tfvar']
+    }, ['-var-file=foo.tfvar', '-var-file=bar.tfvar']),
+    ({
+        'tf_vars': {
+            'text': 'text'
+        }
+    }, ['-var', 'text=text']),
+    ({
+        'tf_vars': {
+            'number': 0
+        }
+    }, ['-var', 'number=0']),
+    ({
+        'tf_vars': {
+            'bool': False
+        }
+    }, ['-var', 'bool=False']),
+    ({
+        'tf_vars': {
+            'dict': {
+                'text': 'text'
+            }
+        }
+    }, ['-var', 'dict={"text": "text"}']),
+    ({
+        'tf_vars': {
+            'list': ['item1', 'item2']
+        }
+    }, ['-var', 'list=["item1", "item2"]']),
+    ({
+        'tf_vars': {
+            'dict': {
+                'list': ['item1', 'item2']
+            }
+        }
+    }, ['-var', 'dict={"list": ["item1", "item2"]}']),
 )
 
 
@@ -64,11 +141,16 @@ def test_args(kwargs, expected):
   assert tftest.parse_args() == []
   assert tftest.parse_args(**kwargs) == expected
 
+
 def test_var_args():
-  assert sorted(tftest.parse_args(init_vars={'a': 1, 'b': '["2"]'})) == sorted(
-      ["-backend-config=a=1", '-backend-config=b=["2"]'])
-  assert sorted(tftest.parse_args(tf_vars={'a': 1, 'b': '["2"]'})) == sorted(
-      ['-var', 'b=["2"]', '-var', 'a=1'])
+  assert sorted(tftest.parse_args(init_vars={
+      'a': 1,
+      'b': '["2"]'
+  })) == sorted(["-backend-config=a=1", '-backend-config=b=["2"]'])
+  assert sorted(tftest.parse_args(tf_vars={
+      'a': 1,
+      'b': '["2"]'
+  })) == sorted(['-var', 'b=["2"]', '-var', 'a=1'])
 
 
 def test_targets():
diff --git a/test/test_backend_config.py b/test/test_backend_config.py
index 01505ea..3e1ebd0 100644
--- a/test/test_backend_config.py
+++ b/test/test_backend_config.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test the plan output wrapper classes."
 
 import pytest
diff --git a/test/test_cache.py b/test/test_cache.py
index d1bb196..8fea6ae 100644
--- a/test/test_cache.py
+++ b/test/test_cache.py
@@ -53,26 +53,22 @@ def test_use_cache(tf):
   method only
   """
   for method in cache_methods:
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(2):
         getattr(tf, method)(use_cache=True)
       assert mock_execute_command.call_count == 1
 
 
 @pytest.mark.parametrize("tf", [
-    pytest.param(
-        True,
-        id="enable_cache"
-    ),
-    pytest.param(
-        False,
-        id="disable_cache"
-    ),
+    pytest.param(True, id="enable_cache"),
+    pytest.param(False, id="disable_cache"),
 ], indirect=True)
 def test_no_use_cache(tf):
   expected_call_count = 2
   for method in cache_methods:
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(expected_call_count):
         getattr(tf, method)(use_cache=False)
       assert mock_execute_command.call_count == expected_call_count
@@ -90,7 +86,8 @@ def test_use_cache_with_same_tf_var_file(tf, tmp_path):
   tf_vars_file.write_text(json.dumps({"foo": "old"}))
 
   for method in tf_var_file_methods:
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(2):
         getattr(tf, method)(use_cache=True, tf_var_file=tf_vars_file)
 
@@ -110,7 +107,8 @@ def test_use_cache_with_new_tf_var_file(tf, tmp_path):
 
   for method in tf_var_file_methods:
     tf_vars_file.write_text(json.dumps({"foo": "old"}))
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(expected_call_count):
         getattr(tf, method)(use_cache=True, tf_var_file=tf_vars_file)
         tf_vars_file.write_text(json.dumps({"foo": "new"}))
@@ -128,7 +126,8 @@ def test_use_cache_with_new_extra_files(tf, tmp_path):
   tf_vars_file = tmp_path / (str(uuid.uuid4()) + '.json')
   tf_vars_file.write_text(json.dumps({"foo": "old"}))
 
-  with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+  with patch.object(tf, 'execute_command',
+                    wraps=tf.execute_command) as mock_execute_command:
     for _ in range(expected_call_count):
       tf.setup(use_cache=True, extra_files=[tf_vars_file])
       tf_vars_file.write_text(json.dumps({"foo": "new"}))
@@ -145,7 +144,8 @@ def test_use_cache_with_same_extra_files(tf, tmp_path):
   tf_vars_file = tmp_path / (str(uuid.uuid4()) + '.json')
   tf_vars_file.write_text(json.dumps({"foo": "old"}))
 
-  with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+  with patch.object(tf, 'execute_command',
+                    wraps=tf.execute_command) as mock_execute_command:
     for _ in range(2):
       tf.setup(use_cache=True, extra_files=[tf_vars_file])
 
@@ -160,7 +160,8 @@ def test_use_cache_with_new_env(tf):
   """
   expected_call_count = 2
   for method in cache_methods:
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(expected_call_count):
         getattr(tf, method)(use_cache=True)
         tf._env["foo"] = "bar"
@@ -189,7 +190,8 @@ def test_use_cache_with_new_tf_content(tf, dummy_tf_filepath):
   """
   expected_call_count = 2
   for method in cache_methods:
-    with patch.object(tf, 'execute_command', wraps=tf.execute_command) as mock_execute_command:
+    with patch.object(tf, 'execute_command',
+                      wraps=tf.execute_command) as mock_execute_command:
       for _ in range(expected_call_count):
         getattr(tf, method)(use_cache=True)
         with open(dummy_tf_filepath, "w") as f:
diff --git a/test/test_files.py b/test/test_files.py
index 902043d..8b5435f 100644
--- a/test/test_files.py
+++ b/test/test_files.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test fixture file setup and removal."
 
 import os
@@ -25,10 +24,10 @@ def test_setup_files():
       with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
         tf = tftest.TerraformTest(tmpdir)
         tf.setup(extra_files=[tmpfile.name])
-        assert os.path.exists(os.path.join(
-            tmpdir, os.path.basename(tmpfile.name)))
+        assert os.path.exists(
+            os.path.join(tmpdir, os.path.basename(tmpfile.name)))
         tf = None
-        assert not os.path.exists(os.path.join(
-            tmpdir, os.path.basename(tmpfile.name)))
+        assert not os.path.exists(
+            os.path.join(tmpdir, os.path.basename(tmpfile.name)))
     finally:
       os.unlink(tmpfile.name)
diff --git a/test/test_no_outputs.py b/test/test_no_outputs.py
index cea4228..e95060d 100644
--- a/test/test_no_outputs.py
+++ b/test/test_no_outputs.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test plan withno outputs."
 
 import pytest
diff --git a/test/test_pickle.py b/test/test_pickle.py
index 5bddb3e..1325179 100644
--- a/test/test_pickle.py
+++ b/test/test_pickle.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test serialization of tftest instances"
 
 import pytest
diff --git a/test/test_plan.py b/test/test_plan.py
index 6eb2cb9..e680bae 100644
--- a/test/test_plan.py
+++ b/test/test_plan.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test the plan output wrapper classes."
 
 import pytest
@@ -98,8 +97,10 @@ def test_plan_stdout(fixtures_dir):
 def test_plan_prior_state(plan_out):
   prior_resources = plan_out.prior_resources
   assert len(prior_resources) == 1
-  assert prior_resources['data.google_client_config.current']['type'] == 'google_client_config'
-  assert prior_resources['data.google_client_config.current']['values']['description'] == 'foo-value'
+  assert prior_resources['data.google_client_config.current'][
+      'type'] == 'google_client_config'
+  assert prior_resources['data.google_client_config.current']['values'][
+      'description'] == 'foo-value'
 
 
 def test_plan_no_prior_state(plan_out_no_prior):
diff --git a/test/test_prevent_destroy.py b/test/test_prevent_destroy.py
index 609c533..874943c 100644
--- a/test/test_prevent_destroy.py
+++ b/test/test_prevent_destroy.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test init and plan with prevent_destroy lifecycles"
 import logging
 from unittest.mock import mock_open, patch
@@ -40,20 +39,23 @@ def test_with_with_lifecycle_override(fixtures_dir):
 def test_raises_exception_if_file_backup_fails(mock_copy, fixtures_dir, caplog):
   caplog.set_level(logging.ERROR)
   tf = tftest.TerraformTest('prevent_destroy', fixtures_dir)
-  mock_copy.side_effect = [FileNotFoundError(
-      '[Errno 2] No such file or directory: "sddsdsds"')]
+  mock_copy.side_effect = [
+      FileNotFoundError('[Errno 2] No such file or directory: "sddsdsds"')
+  ]
   with pytest.raises(tftest.TerraformTestError):
     tf.setup(disable_prevent_destroy=True)
   assert caplog.messages[0].startswith('Unable to backup terraform file ')
 
 
 @patch('tftest.shutil.copy')
-def test_raises_exception_when_read_or_write_fails(mock_copy, fixtures_dir, caplog):
+def test_raises_exception_when_read_or_write_fails(mock_copy, fixtures_dir,
+                                                   caplog):
   caplog.set_level(logging.ERROR)
   tf = tftest.TerraformTest('prevent_destroy', fixtures_dir)
   with patch('builtins.open', mock_open(read_data='')) as mock_file:
     mock_file.return_value.write.side_effect = [
-        IOError('[Errno 13] Permission denied: "sddsdsds"')]
+        IOError('[Errno 13] Permission denied: "sddsdsds"')
+    ]
     with pytest.raises(tftest.TerraformTestError):
       tf.setup(disable_prevent_destroy=True)
   assert caplog.messages[0].startswith(
diff --git a/test/test_sample_apply.py b/test/test_sample_apply.py
index a30cf2f..e93e952 100644
--- a/test/test_sample_apply.py
+++ b/test/test_sample_apply.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test init and apply using an actual example."
 
 import pytest
diff --git a/test/test_sample_plan.py b/test/test_sample_plan.py
index 7bf80fe..2e9e107 100644
--- a/test/test_sample_plan.py
+++ b/test/test_sample_plan.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test init and plan using an actual example."
 
 import pytest
diff --git a/test/test_sample_plan_error.py b/test/test_sample_plan_error.py
index b4769e9..0ea1f1e 100644
--- a/test/test_sample_plan_error.py
+++ b/test/test_sample_plan_error.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test command out attribute of tftest exception class."
 
 import pytest
diff --git a/test/test_sample_plan_no_variables.py b/test/test_sample_plan_no_variables.py
index ff856c4..6f37604 100644
--- a/test/test_sample_plan_no_variables.py
+++ b/test/test_sample_plan_no_variables.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test init and plan using an actual example."
 
 import pytest
diff --git a/test/test_state.py b/test/test_state.py
index 778f1cf..72ccbae 100644
--- a/test/test_state.py
+++ b/test/test_state.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test the Terraform state wrapper class."
 
 import pytest
diff --git a/test/test_value_dict.py b/test/test_value_dict.py
index 7b67b21..f7a511c 100644
--- a/test/test_value_dict.py
+++ b/test/test_value_dict.py
@@ -11,13 +11,11 @@
 # 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.
-
 "Test the Terraform value dict wrapper class."
 
 import pytest
 import tftest
 
-
 _RAW = {'a': {'value': 1, 'sensitive': True}, 'b': {'value': 2}}
 
 
diff --git a/test/test_workspace.py b/test/test_workspace.py
index b93e3e7..2737c67 100644
--- a/test/test_workspace.py
+++ b/test/test_workspace.py
@@ -11,7 +11,6 @@
 # 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.
-
 "Test init and plan using an actual example."
 
 import pytest

From 964aa99442aa51e9f1865eeb5987c2802520e3af Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Tue, 31 Mar 2026 05:57:07 +0000
Subject: [PATCH 5/6] Chore: update CI to use yapf for linting

Replace autopep8 with yapf in the GitHub Actions linting workflow
and DEV-REQUIREMENTS.txt to enforce the new Google-style formatting
rules defined in .style.yapf.
---
 .github/workflows/linting.yml | 4 +---
 DEV-REQUIREMENTS.txt          | 2 +-
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml
index 1481913..296c506 100644
--- a/.github/workflows/linting.yml
+++ b/.github/workflows/linting.yml
@@ -47,7 +47,5 @@ jobs:
       - name: Check python formatting
         id: lint
         run: |
-          echo '[pep8]' > pep8
-          echo 'indent-size = 2' >> pep8
-          autopep8 --diff --global-config pep8 --recursive --exit-code \
+          yapf --diff --recursive --parallel \
            *.py test
diff --git a/DEV-REQUIREMENTS.txt b/DEV-REQUIREMENTS.txt
index 3368830..9c6e94c 100644
--- a/DEV-REQUIREMENTS.txt
+++ b/DEV-REQUIREMENTS.txt
@@ -1,2 +1,2 @@
-autopep8>=2.0
+yapf>=0.40
 pytest>=7.2
\ No newline at end of file

From 9a15ec011aa7f1ff394f20bcff74f93fabf22cda Mon Sep 17 00:00:00 2001
From: Ludovico Magnocavallo <ludomagno@google.com>
Date: Tue, 31 Mar 2026 05:59:19 +0000
Subject: [PATCH 6/6] Fix: format setup.py with yapf

---
 setup.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/setup.py b/setup.py
index 5f869e9..d14e223 100644
--- a/setup.py
+++ b/setup.py
@@ -16,11 +16,9 @@
 
 from tftest import __version__
 
-
 with open("README.md", "r") as fh:
   long_description = fh.read()
 
-
 setuptools.setup(
     name="tftest",
     version=__version__,