Add unit tests for previously untested code paths

jobsh/src/jobfile.rs:
  Add 16 tests for JobFileSet and JobFile parsing. The JobFileSet
  struct has complex logic for duplicate name detection, dependency
  cycle detection, and reference validation that was previously
  untested.

github/database/src/tables/check_run.rs:
  Add 4 tests for CheckRun::get_dependencies(). This method
  deserializes JSON dependency data and was not covered by existing
  enum serialization tests.

github/database/src/tables/user.rs:
  Add 2 tests for UserType::from_github_str(). The error path for
  invalid GitHub API strings was untested.

types/src/config.rs:
  Add 2 tests for ConfigFileDiag inheritance. The explicit
  "inherit: true" case and mixed inheritance scenarios were not
  covered by existing tests.

Author: lzrd

github/database/src/tables/check_run.rs

@@ -216,7 +216,7 @@ impl CheckRunDependency {
  */
 #[cfg(test)]
 mod test {
-    use super::CheckRunVariety;
+    use super::*;
     use std::str::FromStr;
 
     const CHECK_RUN_VARIETIES: &'static [(&'static str, CheckRunVariety)] = &[
@@ -239,4 +239,75 @@ mod test {
             assert_eq!(CheckRunVariety::from_str(s).unwrap(), *e);
         }
     }
+
+    fn make_check_run(dependencies: Option<serde_json::Value>) -> CheckRun {
+        CheckRun {
+            id: CheckRunId::generate(),
+            check_suite: CheckSuiteId::generate(),
+            name: "test-run".to_string(),
+            variety: CheckRunVariety::Basic,
+            content: None,
+            config: None,
+            private: None,
+            active: true,
+            flushed: false,
+            github_id: None,
+            dependencies: dependencies.map(JsonValue),
+        }
+    }
+
+    #[test]
+    fn check_run_get_dependencies_none() {
+        let cr = make_check_run(None);
+        let deps = cr.get_dependencies().unwrap();
+        assert!(deps.is_empty());
+    }
+
+    #[test]
+    fn check_run_get_dependencies_empty() {
+        let cr = make_check_run(Some(serde_json::json!({})));
+        let deps = cr.get_dependencies().unwrap();
+        assert!(deps.is_empty());
+    }
+
+    #[test]
+    fn check_run_get_dependencies_single() {
+        let cr = make_check_run(Some(serde_json::json!({
+            "build": {
+                "job": "build-job",
+                "config": {}
+            }
+        })));
+        let deps = cr.get_dependencies().unwrap();
+        assert_eq!(deps.len(), 1);
+        assert_eq!(deps.get("build").unwrap().job(), "build-job");
+    }
+
+    #[test]
+    fn check_run_get_dependencies_multiple() {
+        let cr = make_check_run(Some(serde_json::json!({
+            "build": {
+                "job": "build-job",
+                "config": {"copy_outputs": true}
+            },
+            "test": {
+                "job": "test-job",
+                "config": {}
+            }
+        })));
+        let deps = cr.get_dependencies().unwrap();
+        assert_eq!(deps.len(), 2);
+        assert_eq!(deps.get("build").unwrap().job(), "build-job");
+        assert_eq!(deps.get("test").unwrap().job(), "test-job");
+
+        // Verify we can extract config from dependency
+        #[derive(serde::Deserialize)]
+        struct DepConfig {
+            #[serde(default)]
+            copy_outputs: bool,
+        }
+        let build_config: DepConfig =
+            deps.get("build").unwrap().get_config().unwrap();
+        assert!(build_config.copy_outputs);
+    }
 }

github/database/src/tables/user.rs

@@ -123,4 +123,34 @@ mod test {
             assert_eq!(UserType::from_str(s).unwrap(), *e);
         }
     }
+
+    /*
+     * Test conversion from GitHub API strings.
+     */
+    const GITHUB_USER_TYPES: &[(&str, UserType)] = &[
+        ("User", UserType::User),
+        ("Bot", UserType::Bot),
+        ("Organization", UserType::Organisation),
+    ];
+
+    #[test]
+    fn user_type_from_github_str() {
+        for (s, e) in GITHUB_USER_TYPES {
+            assert_eq!(UserType::from_github_str(s).unwrap(), *e);
+        }
+    }
+
+    #[test]
+    fn user_type_from_github_str_invalid() {
+        let invalid_types = &["user", "bot", "org", "Invalid", "", "Org"];
+        for invalid in invalid_types {
+            let err = UserType::from_github_str(invalid).unwrap_err();
+            assert!(
+                err.to_string().contains("invalid user type"),
+                "expected invalid user type error for {:?}, got: {}",
+                invalid,
+                err
+            );
+        }
+    }
 }