Finer grained cache hash input (#60)

* add checksumdir to requirements

* Update README.md

* add tests

* add new hash params

* fix pep8 indenting

Author: marshall7m

DEV-REQUIREMENTS.txt

@@ -1,2 +1,3 @@
 autopep8
 pytest>=5.2.2
+checksumdir

README.md

@@ -82,7 +82,7 @@ def test_run_all_apply(run_all_apply_out):
 
 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.
 
-To determine if the cache should be used, first a hash value is generated using the current `TerraformTest` instance `__init__` and calling method arguments. The hash value is compared to the hash value of the cached instance's associated arguments. If the hash is the same then the cache is used, otherwise the method is executed.
+To determine if the cache should be used, first a hash value is generated using the current `TerraformTest` instance `__init__` and calling method arguments, file contents of the `tfdir` and file contents of any `tf_var_file` or `extra_files` method argument. The hash value is compared to the hash value of the cached instance's associated arguments. If the hash is the same then the cache is used, otherwise the method is executed.
 
 The benefits of the caching feature include:
 - Faster setup time for testing terraform modules that don't change between testing sessions
@@ -124,4 +124,4 @@ Tests use the `pytest` framework and have no other dependency except on the Terr
 
 ## Disclaimer
 
-This is not an officially supported Google product.
+This is not an officially supported Google product.

test/test_cache.py

@@ -15,6 +15,8 @@
 import logging
 import os
 import shutil
+import uuid
+import json
 import pytest
 import tftest
 from unittest.mock import patch, DEFAULT, Mock
@@ -78,3 +80,99 @@ def test_no_use_cache(tf):
       for _ in range(expected_call_count):
         getattr(tf, method)(use_cache=False)
       assert mock_execute_command.call_count == expected_call_count
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+def test_use_cache_with_same_tf_var_file(tf, tmp_path):
+  tf_var_file_methods = ["plan", "apply", "destroy"]
+
+  tf_vars_file = tmp_path / (str(uuid.uuid4()) + '.json')
+  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:
+      for _ in range(2):
+        getattr(tf, method)(use_cache=True, tf_var_file=tf_vars_file)
+
+    assert mock_execute_command.call_count == 1
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+def test_use_cache_with_new_tf_var_file(tf, tmp_path):
+  tf_var_file_methods = ["plan", "apply", "destroy"]
+  expected_call_count = 2
+
+  tf_vars_file = tmp_path / (str(uuid.uuid4()) + '.json')
+
+  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:
+      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"}))
+
+    assert mock_execute_command.call_count == expected_call_count
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+def test_use_cache_with_new_extra_files(tf, tmp_path):
+  expected_call_count = 2
+  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:
+    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"}))
+
+    assert mock_execute_command.call_count == expected_call_count
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+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:
+    for _ in range(2):
+      tf.setup(use_cache=True, extra_files=[tf_vars_file])
+
+    assert mock_execute_command.call_count == 1
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+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:
+      for _ in range(expected_call_count):
+        getattr(tf, method)(use_cache=True)
+        tf._env["foo"] = "bar"
+
+      assert mock_execute_command.call_count == expected_call_count
+
+      del tf._env["foo"]
+
+
+@pytest.fixture
+def dummy_tf_filepath(tf):
+  filepath = os.path.join(tf.tfdir, "bar.txt")
+  with open(filepath, "w") as f:
+    f.write("old")
+
+  yield filepath
+
+  os.remove(filepath)
+
+
+@pytest.mark.parametrize("tf", [True], indirect=True)
+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:
+      for _ in range(expected_call_count):
+        getattr(tf, method)(use_cache=True)
+        with open(dummy_tf_filepath, "w") as f:
+          f.write(str(uuid.uuid4()))
+
+      assert mock_execute_command.call_count == expected_call_count

tftest.py

@@ -42,6 +42,7 @@
 from hashlib import sha1
 from pathlib import Path
 from typing import List
+from checksumdir import dirhash
 
 __version__ = '1.7.4'
 
@@ -107,7 +108,8 @@ def parse_args(init_vars=None, tf_vars=None, targets=None, **kw):
   ]
   for arg in _TG_KV_ARGS:
     if kw.get(f"tg_{arg}"):
-      cmd_args += [f'--terragrunt-{arg.replace("_", "-")}', kw[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):
@@ -321,10 +323,12 @@ def __init__(self, tfdir, basedir=None, binary='terraform', env=None,
     self._basedir = basedir or os.getcwd()
     self.binary = binary
     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))
+    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(
@@ -359,11 +363,13 @@ def remove_readonly(func, path, excinfo):
     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')
+    _LOGGER.debug(
+        'Restoring original TF files after prevent destroy changes')
     if restore_files:
       for bkp_file in Path(tfdir).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()}')
@@ -404,11 +410,27 @@ def cache(self, **kwargs):
               k: v for k, v in self.__dict__.items()
               # only uses instance attributes that are involved in the results of
               # the decorated method
-              if k in ["binary", "_basedir", "tfdir", "env"]
+              if k in ["binary", "_basedir", "tfdir", "_env"]
           },
           **kwargs,
       }
 
+      # creates hash of file contents
+      for path_param in ["extra_files", "tf_var_file"]:
+        if path_param in kwargs:
+          if isinstance(kwargs[path_param], list):
+            params[path_param] = [
+                sha1(open(fp, 'rb').read()).hexdigest() for fp in kwargs[path_param]]
+          else:
+            params[path_param] = sha1(
+                open(kwargs[path_param], 'rb').read()).hexdigest()
+
+      # creates hash of all file content within tfdir
+      # excludes hidden files from being used within hash (ignores .terraform/ or .terragrunt-cache/)
+      # and excludes any local tfstate files
+      params["tfdir"] = dirhash(
+          self.tfdir, 'sha1', ignore_hidden=True, excluded_extensions=['backup', 'tfstate'])
+
       hash_filename = sha1(
           json.dumps(params, sort_keys=True,
                      default=str).encode("cp037")).hexdigest() + ".pickle"
@@ -575,7 +597,8 @@ def plan(self, input=False, color=False, refresh=True, tf_vars=None,
     try:
       return self._plan_formatter(result.out)
     except json.JSONDecodeError as e:
-      raise TerraformTestError('Error decoding plan output: {}'.format(e))
+      raise TerraformTestError(
+          'Error decoding plan output: {}'.format(e))
 
   @_cache
   def apply(self, input=False, color=False, auto_approve=True, tf_vars=None,