Cache at action level instead of group (#213)

#208 fixed one caching bug by changing when we update the cache.  
I'm unsure if that PR introduced this bug (it may have) but this PR
fixes another.

When ever the _same_ file path is used to cache on in subsequent
actions, the cache is updated when the first succeeds, so the cache is
read as valid for the second action when it should be invalid.

Example config file

```yaml
apiVersion: scope.github.com/v1alpha
kind: ScopeDoctorGroup
metadata:
  name: ssh
  description: Setup SSH keys for GitHub authentication
spec:
  include: when-required
  needs: []
  actions:
    - name: private-key-exists
      description: Ensures SSH private key exists
      check:
        paths:
          - ~/.ssh/id_ed25519
        commands:
          - ./bin/ssh.sh check private-key
      fix:
        commands:
          - ./bin/ssh.sh fix private-key
    - name: public-key-exists
      description: Ensures SSH public key exists
      check:
        paths:
          - ~/.ssh/id_ed25519.pub
        commands:
          - ./bin/ssh.sh check public-key
      fix:
        commands:
          - ./bin/ssh.sh fix public-key
    - name: key-added
      description: Uploads the pub key to GitHub
      check:
        # The paths in this were previously erroneously cached too early
        # so the check was always passing
        paths:
          # if either of these files have changed, we need to re-check
          - ~/.ssh/id_ed25519
          - ~/.ssh/id_ed25519.pub
        commands:
          - ./bin/ssh.sh check github
      fix:
        commands:
          - ./bin/ssh.sh fix github
```


This because we were keying _only_ off the group name and the fully
qualified file name.

This PR updates the cache to _also_ key off of the action name, so that
each check has a unique key in the cache.

Old cache format

```json
{
  "checksums": {
    "rails-group": {
      "/path/to/file1.txt": "abc123",
      "/path/to/file2.txt": "def456"
    },
    "ruby-group": {
      "/path/to/ruby-version": "xyz789"
    }
  }
}
```

New cache format

```json
{
  "checksums": {
    "rails-group": {
        "action-1": { "/path/to/file1.txt": "abc123" },
        "action-2": { "/path/to/file2.txt": "def456" }
    },
    "ruby-group": {
      "action-3": { "/path/to/ruby-version": "xyz789" }
    }
  }
}
```

_IMPORTANT:_ This will invalidate any existing cache on a user's
machine. The first time a user runs with this new version, we will
invalidate all of their existing caches.

Author: rubberduck203

Cargo.lock

@@ -87,6 +87,7 @@ assert_cmd = "2.0.16"
 assert_fs = "1.1.2"
 escargot = "0.5.12"
 predicates = "3.1.2"
+tempfile = "3.0"
 
 [build-dependencies]
 vergen = { version = "8.3", features = ["build", "git", "git2"] }

scope/Cargo.toml

@@ -268,6 +268,7 @@ impl DefaultDoctorActionRun {
                     &cache_path.base_path,
                     &cache_path.paths,
                     &self.model.metadata.name(),
+                    &self.action.name,
                     self.file_cache.clone(),
                 )
                 .await;
@@ -592,6 +593,7 @@ impl DefaultDoctorActionRun {
                 &paths.base_path,
                 &paths.paths,
                 &self.model.metadata.name(),
+                &self.action.name,
                 self.file_cache.clone(),
             )
             .await?;
@@ -682,6 +684,7 @@ pub trait GlobWalker: Send + Sync {
         base_dir: &Path,
         paths: &[String],
         cache_name: &str,
+        action_name: &str,
         file_cache: Arc<dyn FileCache>,
     ) -> Result<bool, RuntimeError>;
 
@@ -690,6 +693,7 @@ pub trait GlobWalker: Send + Sync {
         base_dir: &Path,
         paths: &[String],
         cache_name: &str,
+        action_name: &str,
         file_cache: Arc<dyn FileCache>,
     ) -> Result<(), RuntimeError>;
 }
@@ -746,6 +750,7 @@ impl GlobWalker for DefaultGlobWalker {
         base_dir: &Path,
         paths: &[String],
         cache_name: &str,
+        action_name: &str,
         file_cache: Arc<dyn FileCache>,
     ) -> Result<bool, RuntimeError> {
         for glob_str in paths {
@@ -757,7 +762,9 @@ impl GlobWalker for DefaultGlobWalker {
             }
 
             for path in files {
-                let file_result = file_cache.check_file(cache_name.to_string(), &path).await?;
+                let file_result = file_cache
+                    .check_file(cache_name, action_name, &path)
+                    .await?;
                 debug!(target: "user", "CacheStatus for file {}: {:?}", path.display(), file_result);
                 let check_result = file_result == FileCacheStatus::FileMatches;
                 if !check_result {
@@ -774,13 +781,14 @@ impl GlobWalker for DefaultGlobWalker {
         base_dir: &Path,
         paths: &[String],
         cache_name: &str,
+        action_name: &str,
         file_cache: Arc<dyn FileCache>,
     ) -> Result<(), RuntimeError> {
         for glob_str in paths {
             let glob_path = make_absolute(base_dir, glob_str);
             for path in self.file_system.find_files(&glob_path)? {
                 file_cache
-                    .update_cache_entry(cache_name.to_string(), &path)
+                    .update_cache_entry(cache_name, action_name, &path)
                     .await?;
             }
         }
@@ -1068,11 +1076,11 @@ pub(crate) mod tests {
         glob_walker
             .expect_have_globs_changed()
             .times(1)
-            .returning(|_, _, _, _| Ok(false));
+            .returning(|_, _, _, _, _| Ok(false));
         glob_walker
             .expect_update_cache()
             .times(1)
-            .returning(|_, _, _, _| Ok(()));
+            .returning(|_, _, _, _, _| Ok(()));
 
         let run = setup_test(vec![action], exec_runner, glob_walker);
 
@@ -1098,11 +1106,11 @@ pub(crate) mod tests {
         glob_walker
             .expect_have_globs_changed()
             .times(1)
-            .returning(|_, _, _, _| Ok(false));
+            .returning(|_, _, _, _, _| Ok(false));
         glob_walker
             .expect_update_cache()
             .times(1)
-            .returning(|_, _, _, _| Err(RuntimeError::AnyError(anyhow!("bogus error"))));
+            .returning(|_, _, _, _, _| Err(RuntimeError::AnyError(anyhow!("bogus error"))));
 
         let run = setup_test(vec![action], exec_runner, glob_walker);
 
@@ -1128,7 +1136,7 @@ pub(crate) mod tests {
         glob_walker
             .expect_have_globs_changed()
             .times(1)
-            .returning(|_, _, _, _| Ok(false));
+            .returning(|_, _, _, _, _| Ok(false));
         glob_walker.expect_update_cache().never();
 
         let run = setup_test(vec![action], exec_runner, glob_walker);
@@ -1170,11 +1178,11 @@ pub(crate) mod tests {
         glob_walker
             .expect_have_globs_changed()
             .times(1)
-            .returning(|_, _, _, _| Ok(true));
+            .returning(|_, _, _, _, _| Ok(true));
         glob_walker
             .expect_update_cache()
             .once()
-            .returning(|_, _, _, _| Ok(()));
+            .returning(|_, _, _, _, _| Ok(()));
 
         exec_runner
             .expect_run_command()
@@ -1228,11 +1236,11 @@ pub(crate) mod tests {
         glob_walker
             .expect_have_globs_changed()
             .times(1)
-            .returning(|_, _, _, _| Ok(false));
+            .returning(|_, _, _, _, _| Ok(false));
         glob_walker
             .expect_update_cache()
             .once()
-            .returning(|_, _, _, _| Ok(()));
+            .returning(|_, _, _, _, _| Ok(()));
 
         exec_runner
             .expect_run_command()
@@ -1267,9 +1275,10 @@ pub(crate) mod tests {
             .once()
             .with(
                 predicate::eq("file_cache".to_string()),
+                predicate::eq("action_name".to_string()),
                 predicate::eq(Path::new("/foo/bar")),
             )
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         file_system
             .expect_find_files()
@@ -1286,6 +1295,7 @@ pub(crate) mod tests {
                 Path::new("/foo/root"),
                 &["*.txt".to_string()],
                 "file_cache",
+                "action_name",
                 Arc::new(file_cache),
             )
             .await;
@@ -1302,9 +1312,10 @@ pub(crate) mod tests {
             .once()
             .with(
                 predicate::eq("file_cache".to_string()),
+                predicate::eq("action_name".to_string()),
                 predicate::eq(Path::new("/foo/bar")),
             )
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         file_system
             .expect_find_files()
@@ -1321,6 +1332,7 @@ pub(crate) mod tests {
                 Path::new("/foo/root"),
                 &["/a/abs/path/*.txt".to_string()],
                 "file_cache",
+                "action_name",
                 Arc::new(file_cache),
             )
             .await;
@@ -1340,9 +1352,10 @@ pub(crate) mod tests {
             .once()
             .with(
                 predicate::eq("group_name".to_string()),
+                predicate::eq("action_name".to_string()),
                 predicate::eq(resolved_path.clone()),
             )
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         file_system
             .expect_find_files()
@@ -1367,6 +1380,7 @@ pub(crate) mod tests {
                 Path::new("/foo/root"),
                 &["~/path/*.txt".to_string()],
                 "group_name",
+                "action_name",
                 Arc::new(file_cache),
             )
             .await;
@@ -1385,9 +1399,10 @@ pub(crate) mod tests {
             .once()
             .with(
                 predicate::eq("group_name".to_string()),
+                predicate::eq("action_name".to_string()),
                 predicate::eq(Path::new("/foo/path/foo.txt")),
             )
-            .returning(|_, _| Ok(()));
+            .returning(|_, _, _| Ok(()));
 
         file_system
             .expect_find_files()
@@ -1407,6 +1422,7 @@ pub(crate) mod tests {
                 Path::new("/foo/root"),
                 &["../path/*.txt".to_string()],
                 "group_name",
+                "action_name",
                 Arc::new(file_cache),
             )
             .await;