claude-dev-env 8.10.0 → 8.11.1

package/hooks/blocking/tdd_enforcer_parts/git_tracking.py

@@ -1,132 +0,0 @@
-"""Ask git about a candidate path: is it a restore, and does it carry a real edit.
-
-::
-
-    remove orders.py (git-tracked) -> Write orders.py  -> restore (allow)
-    Write brand_new.py (untracked, absent)             -> new code (gate)
-
-A full rewrite happens as remove-then-Write, so the file is absent on disk
-between the two steps. Restoring committed code is not new production code, so
-the gate exempts a Write whose target is absent yet tracked in git.
-
-``has_uncommitted_change_from_head`` answers a second, related question the
-content-hash store's first-sight check needs: whether a candidate test file
-already carries content HEAD does not have, so a `touch` on an already-clean,
-committed test cannot pass as a first sighting.
-"""
-
-import subprocess
-from pathlib import Path
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import (
-    GIT_DIFF_QUIET_FLAG,
-    GIT_DIFF_SUBCOMMAND,
-    GIT_DIFF_TIMEOUT_SECONDS,
-    GIT_EXECUTABLE_NAME,
-    GIT_HEAD_REVISION,
-    GIT_LS_FILES_SUBCOMMAND,
-    GIT_LS_FILES_TIMEOUT_SECONDS,
-    GIT_PATHSPEC_SEPARATOR,
-)
-
-from hooks_constants.subprocess_window import hidden_window_creation_flags
-
-
-def _git_ls_files_command(file_name: str) -> list[str]:
-    return [GIT_EXECUTABLE_NAME, GIT_LS_FILES_SUBCOMMAND, GIT_PATHSPEC_SEPARATOR, file_name]
-
-
-def _git_diff_quiet_against_head_command(file_name: str) -> list[str]:
-    return [
-        GIT_EXECUTABLE_NAME,
-        GIT_DIFF_SUBCOMMAND,
-        GIT_DIFF_QUIET_FLAG,
-        GIT_HEAD_REVISION,
-        GIT_PATHSPEC_SEPARATOR,
-        file_name,
-    ]
-
-
-def _git_tracks_path(path: Path) -> bool:
-    parent_directory = path.parent
-    if not parent_directory.is_dir():
-        return False
-    try:
-        completed = subprocess.run(
-            _git_ls_files_command(path.name),
-            cwd=str(parent_directory),
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=GIT_LS_FILES_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (OSError, subprocess.SubprocessError):
-        return False
-    return completed.returncode == 0 and bool(completed.stdout.strip())
-
-
-def _working_tree_differs_from_head(path: Path) -> bool:
-    """Compare the working tree to HEAD, not to the index.
-
-    A plain ``git diff`` (no revision argument) compares the working tree to
-    the index, so a file that was just ``git add``-ed reads as unchanged even
-    when it holds content HEAD never had. Naming ``HEAD`` folds the index and
-    the working tree into one comparison against the last commit, catching a
-    staged-but-uncommitted new file and a staged edit alike.
-    """
-    try:
-        completed = subprocess.run(
-            _git_diff_quiet_against_head_command(path.name),
-            cwd=str(path.parent),
-            capture_output=True,
-            text=True,
-            check=False,
-            timeout=GIT_DIFF_TIMEOUT_SECONDS,
-            creationflags=hidden_window_creation_flags(),
-        )
-    except (OSError, subprocess.SubprocessError):
-        return True
-    return completed.returncode != 0
-
-
-def is_absent_but_tracked(path: Path) -> bool:
-    """Return whether a write target is absent on disk yet tracked in git.
-
-    ::
-
-        path missing on disk + git ls-files finds it -> True  (restore)
-        path present, or git does not track it       -> False
-
-    Args:
-        path: The write target.
-
-    Returns:
-        True only when the path does not exist but git tracks it, marking the
-        write a restore of committed code rather than new production code.
-    """
-    if path.exists():
-        return False
-    return _git_tracks_path(path)
-
-
-def has_uncommitted_change_from_head(path: Path) -> bool:
-    """Return whether *path* carries content its git HEAD does not have.
-
-    ::
-
-        untracked file                -> True  (no HEAD entry to match)
-        tracked, working tree != HEAD -> True  (a real edit this session)
-        tracked, working tree == HEAD -> False (clean; a touch cannot pass)
-        git unavailable or errors     -> True  (cannot prove it is clean)
-
-    Args:
-        path: The candidate test file to check.
-
-    Returns:
-        True unless git can positively confirm the file is tracked and its
-        working-tree content matches HEAD exactly.
-    """
-    if not _git_tracks_path(path):
-        return True
-    return _working_tree_differs_from_head(path)

package/hooks/blocking/tdd_enforcer_parts/path_classification.py

@@ -1,119 +0,0 @@
-"""Path and payload classification for the TDD-enforcer gate.
-
-Decides which write targets the gate skips silently (docs, tests, files inside a
-``.claude`` tree) and pulls the written text out of a Write, Edit, or MultiEdit
-payload so the gate can inspect it.
-"""
-
-from tdd_enforcer_parts.config.tdd_enforcer_constants import (
-    ALL_DIRECTORY_SKIP_COMPONENTS,
-    ALL_DOTCLAUDE_PATH_SEGMENTS,
-    ALL_PRODUCTION_EXTENSIONS,
-    ALL_SKIP_EXTENSIONS,
-    ALL_SKIP_NAME_PATTERNS,
-    NEWLINE_JOIN_SEPARATOR,
-)
-
-
-def production_extensions() -> frozenset[str]:
-    """Return the source-file extensions the gate treats as production code."""
-    return ALL_PRODUCTION_EXTENSIONS
-
-
-def skip_extensions() -> frozenset[str]:
-    """Return the config and documentation extensions the gate skips."""
-    return ALL_SKIP_EXTENSIONS
-
-
-def _skip_patterns() -> frozenset[str]:
-    return ALL_SKIP_NAME_PATTERNS
-
-
-def _dotclaude_path_segments() -> frozenset[str]:
-    return ALL_DOTCLAUDE_PATH_SEGMENTS
-
-
-def _directory_skip_components() -> frozenset[str]:
-    return ALL_DIRECTORY_SKIP_COMPONENTS
-
-
-def _is_inside_dotclaude_segment(file_path_string: str) -> bool:
-    """Return whether any path segment is exactly a ``.claude`` directory.
-
-    Args:
-        file_path_string: The write target path, in either separator style.
-
-    Returns:
-        True when a ``.claude`` directory sits on the path, so the gate leaves
-        agent-config edits alone.
-    """
-    normalized_path = file_path_string.replace("\\", "/")
-    dotclaude_segments = _dotclaude_path_segments()
-    for each_segment in normalized_path.split("/"):
-        if each_segment and each_segment in dotclaude_segments:
-            return True
-    return False
-
-
-def _path_has_skip_directory_component(path_with_forward_slashes: str) -> bool:
-    all_components = [each_part for each_part in path_with_forward_slashes.split("/") if each_part]
-    directory_components = all_components[:-1]
-    skip_directory_components = _directory_skip_components()
-    return any(each in skip_directory_components for each in directory_components)
-
-
-def _skip_pattern_matches(pattern: str, name_lower: str, path_with_forward_slashes: str) -> bool:
-    if pattern.endswith("/"):
-        return pattern in path_with_forward_slashes
-    return pattern in name_lower
-
-
-def _name_or_path_matches_skip_pattern(name_lower: str, path_with_forward_slashes: str) -> bool:
-    for each_pattern in _skip_patterns():
-        if _skip_pattern_matches(each_pattern, name_lower, path_with_forward_slashes):
-            return True
-    return False
-
-
-def _matches_any_skip_pattern(name_lower: str, path_with_forward_slashes: str) -> bool:
-    """Return whether a path names a test, fixture, mock, or stub file.
-
-    Args:
-        name_lower: The lower-cased file name.
-        path_with_forward_slashes: The lower-cased path with forward slashes.
-
-    Returns:
-        True when a skip directory component or a skip name pattern matches.
-    """
-    if _path_has_skip_directory_component(path_with_forward_slashes):
-        return True
-    return _name_or_path_matches_skip_pattern(name_lower, path_with_forward_slashes)
-
-
-def _multiedit_new_strings(all_edits: list) -> list[str]:
-    all_new_strings: list[str] = []
-    for each_edit in all_edits:
-        if isinstance(each_edit, dict):
-            all_new_strings.append(each_edit.get("new_string", "") or "")
-    return all_new_strings
-
-
-def _extract_written_content(tool_name: str, tool_input: dict) -> str:
-    """Return the text a Write, Edit, or MultiEdit payload would introduce.
-
-    Args:
-        tool_name: The intercepted tool name.
-        tool_input: The intercepted tool's input payload.
-
-    Returns:
-        The written content for Write, the replacement for Edit, the joined
-        replacements for MultiEdit, or an empty string for any other tool.
-    """
-    if tool_name == "Write":
-        return tool_input.get("content", "") or ""
-    if tool_name == "Edit":
-        return tool_input.get("new_string", "") or ""
-    if tool_name == "MultiEdit":
-        all_edits = tool_input.get("edits", []) or []
-        return NEWLINE_JOIN_SEPARATOR.join(_multiedit_new_strings(all_edits))
-    return ""

package/hooks/blocking/tdd_enforcer_parts/tests/test_candidate_paths.py

@@ -1,31 +0,0 @@
-"""Behavioral tests for the candidate_paths parts module."""
-
-from pathlib import Path
-
-from tdd_enforcer_parts import candidate_paths
-
-
-def test_candidate_paths_offers_flat_stem_candidates_first(tmp_path: Path) -> None:
-    (tmp_path / ".git").mkdir()
-    all_candidates = candidate_paths.candidate_test_paths_for(tmp_path / "orders.py")
-    assert all_candidates[0] == tmp_path / "test_orders.py"
-    assert all_candidates[1] == tmp_path / "orders_test.py"
-
-
-def test_candidate_paths_returns_empty_for_unknown_extension(tmp_path: Path) -> None:
-    assert candidate_paths.candidate_test_paths_for(tmp_path / "data.rs") == []
-
-
-def test_candidate_paths_offers_javascript_test_siblings(tmp_path: Path) -> None:
-    all_candidates = candidate_paths.candidate_test_paths_for(tmp_path / "Button.tsx")
-    assert tmp_path / "Button.test.tsx" in all_candidates
-
-
-def test_ancestor_tests_directories_finds_sibling_tests(tmp_path: Path) -> None:
-    (tmp_path / ".git").mkdir()
-    package = tmp_path / "pkg"
-    package.mkdir()
-    (package / "tests").mkdir()
-    all_pairs = candidate_paths._ancestor_tests_directories(package)
-    all_tests_directories = [each_tests_directory for _, each_tests_directory in all_pairs]
-    assert package / "tests" in all_tests_directories

package/hooks/blocking/tdd_enforcer_parts/tests/test_content_hash_store.py

@@ -1,256 +0,0 @@
-"""Behavioral tests for the content_hash_store parts module.
-
-Covers the recorded-test-failure evidence path: a genuinely failing test
-command outranks a stale mtime, never satisfies a candidate it did not
-name, expires after the freshness window, and applies only while the
-candidate's content still matches what actually failed. Also covers the
-private decision helpers by name, so a rename keeps its own paired test.
-"""
-
-import json
-import os
-import time
-from pathlib import Path
-
-from tdd_enforcer_parts import content_hash_store
-
-
-def _write_fresh_test_file(directory: Path, content: str = "def test_fulfill(): pass\n") -> Path:
-    candidate = directory / "test_orders.py"
-    candidate.write_text(content)
-    return candidate
-
-
-def test_state_file_path_differs_by_repository_root(tmp_path: Path) -> None:
-    first_root_path = content_hash_store._state_file_path("session-a", str(tmp_path / "one"))
-    second_root_path = content_hash_store._state_file_path("session-a", str(tmp_path / "two"))
-    assert first_root_path != second_root_path
-
-
-def test_state_file_path_is_stable_for_the_same_inputs(tmp_path: Path) -> None:
-    first_lookup = content_hash_store._state_file_path("session-a", str(tmp_path))
-    second_lookup = content_hash_store._state_file_path("session-a", str(tmp_path))
-    assert first_lookup == second_lookup
-
-
-def test_first_sight_allows_and_stores_a_fresh_dirty_test(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-1", str(tmp_path), 600
-    )
-
-    assert is_allowed is True
-    state_file = content_hash_store._state_file_path("session-1", str(tmp_path))
-    state = json.loads(state_file.read_text())
-    assert content_hash_store._state_key_for(candidate) in state
-
-
-def test_first_sight_denies_when_test_evidence_is_missing(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path, content="orders = 'not a test'\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-2", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_first_sight_denies_when_test_file_is_stale(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], "session-3", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_second_sight_denies_a_touch_that_leaves_content_unchanged(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-4", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    candidate_key = content_hash_store._state_key_for(candidate)
-    state[candidate_key][content_hash_store.STORED_CHANGED_AT_KEY] -= 700
-    state_file.write_text(json.dumps(state))
-    candidate.touch()
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_second_sight_allows_when_content_actually_changed_after_the_window(
-    tmp_path: Path,
-) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-5", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    candidate_key = content_hash_store._state_key_for(candidate)
-    state[candidate_key][content_hash_store.STORED_CHANGED_AT_KEY] -= 700
-    state_file.write_text(json.dumps(state))
-    candidate.write_text("def test_fulfill(): assert True\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_second_sight_allows_a_repeat_write_within_the_window_untouched(
-    tmp_path: Path,
-) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-6", str(tmp_path)
-    assert content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_any_candidate_satisfying_the_gate_allows_the_write(tmp_path: Path) -> None:
-    stale_candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(stale_candidate, (stale_timestamp, stale_timestamp))
-    fresh_candidate = tmp_path / "orders_test.py"
-    fresh_candidate.write_text("def test_fulfill(): pass\n")
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [stale_candidate, fresh_candidate], "session-7", str(tmp_path), 600
-    )
-
-    assert is_allowed is True
-
-
-def test_denies_when_no_candidate_file_exists(tmp_path: Path) -> None:
-    missing_candidate = tmp_path / "test_missing.py"
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [missing_candidate], "session-8", str(tmp_path), 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_allows_a_stale_candidate(tmp_path: Path) -> None:
-    """RED-evidence: a genuinely recorded failure outranks a stale mtime."""
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-1", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py", 1, session_id, repository_root
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is True
-
-
-def test_recorded_failure_stores_the_command_and_exit_status(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    session_id, repository_root = "session-failure-2", str(tmp_path)
-
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py -q", 1, session_id, repository_root
-    )
-
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    state = json.loads(state_file.read_text())
-    entry = state[content_hash_store._state_key_for(candidate)]
-    assert entry[content_hash_store.STORED_FAILURE_COMMAND_KEY] == "pytest test_orders.py -q"
-    assert entry[content_hash_store.STORED_FAILURE_EXIT_STATUS_KEY] == 1
-
-
-def test_recorded_failure_does_not_satisfy_a_different_candidate(tmp_path: Path) -> None:
-    """Anti-bypass: a failure recorded for one test file must not unlock a sibling."""
-    failing_candidate = tmp_path / "test_bar.py"
-    failing_candidate.write_text("def test_bar(): pass\n")
-    unrelated_candidate = tmp_path / "test_foo.py"
-    unrelated_candidate.write_text("def test_foo(): pass\n")
-    stale_timestamp = time.time() - 700
-    os.utime(unrelated_candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-3", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [failing_candidate], "pytest test_bar.py", 1, session_id, repository_root
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [unrelated_candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_expires_after_the_freshness_window(tmp_path: Path) -> None:
-    candidate = _write_fresh_test_file(tmp_path)
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-    session_id, repository_root = "session-failure-4", str(tmp_path)
-    state_file = content_hash_store._state_file_path(session_id, repository_root)
-    candidate_key = content_hash_store._state_key_for(candidate)
-    stale_failed_at = time.time() - 700
-    state_file.write_text(
-        json.dumps(
-            {
-                candidate_key: {
-                    content_hash_store.STORED_FAILURE_HASH_KEY: content_hash_store._content_hash(
-                        candidate.read_text()
-                    ),
-                    content_hash_store.STORED_FAILED_AT_KEY: stale_failed_at,
-                }
-            }
-        )
-    )
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False
-
-
-def test_recorded_failure_does_not_apply_once_content_no_longer_matches(
-    tmp_path: Path,
-) -> None:
-    """Anti-bypass: editing the test after a recorded RED clears that RED as evidence.
-
-    A bare failure-only entry (no prior content-hash tracking) must not fall
-    through to the unconditional hash-differs allow either -- it still needs a
-    real qualifying first sight (fresh mtime plus a real git-visible edit).
-    """
-    candidate = tmp_path / "test_orders.py"
-    candidate.write_text("def test_fulfill(): pass\n")
-    session_id, repository_root = "session-failure-5", str(tmp_path)
-    content_hash_store.record_test_command_failure(
-        [candidate], "pytest test_orders.py", 1, session_id, repository_root
-    )
-    candidate.write_text("def test_fulfill(): assert True\n")
-    stale_timestamp = time.time() - 700
-    os.utime(candidate, (stale_timestamp, stale_timestamp))
-
-    is_allowed = content_hash_store.has_recorded_or_fresh_test(
-        [candidate], session_id, repository_root, 600
-    )
-
-    assert is_allowed is False

package/hooks/blocking/tdd_enforcer_parts/tests/test_decisions.py

@@ -1,46 +0,0 @@
-"""Behavioral tests for the decisions parts module."""
-
-import json
-from pathlib import Path
-
-import pytest
-from tdd_enforcer_parts import decisions
-
-
-def test_build_deny_reason_names_candidates_and_production_path() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")])
-    assert "orders.py" in reason
-    assert "test_orders.py" in reason
-    assert "propose" in reason.lower() or "enhancement" in reason.lower()
-
-
-def test_build_deny_reason_points_exemption_guidance_at_entry_hook() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [])
-    assert "tdd_enforcer.py" in reason
-    assert "decisions.py" not in reason
-
-
-def test_build_deny_reason_names_content_not_only_modification_time() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")])
-    assert "content" in reason.lower()
-
-
-def test_build_deny_reason_covers_first_sight_and_stale_hash_and_names_the_fix() -> None:
-    reason = decisions.build_deny_reason(Path("pkg/orders.py"), [Path("pkg/test_orders.py")]).lower()
-    assert "fresh" in reason
-    assert "change" in reason
-    assert "touch" in reason
-
-
-def test_emit_allow_writes_allow_decision(capsys: pytest.CaptureFixture[str]) -> None:
-    decisions.emit_allow()
-    parsed = json.loads(capsys.readouterr().out)
-    assert parsed["hookSpecificOutput"]["permissionDecision"] == "allow"
-
-
-def test_emit_deny_writes_deny_and_system_message(capsys: pytest.CaptureFixture[str]) -> None:
-    decisions.emit_deny("blocked because no fresh test")
-    parsed = json.loads(capsys.readouterr().out)
-    assert parsed["hookSpecificOutput"]["permissionDecision"] == "deny"
-    assert parsed["suppressOutput"] is True
-    assert isinstance(parsed["systemMessage"], str)

package/hooks/blocking/tdd_enforcer_parts/tests/test_freshness.py

@@ -1,28 +0,0 @@
-"""Behavioral tests for the freshness parts module."""
-
-import os
-import time
-from pathlib import Path
-
-from tdd_enforcer_parts import freshness
-
-
-def test_has_fresh_test_true_for_recent_test_file(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_x(): pass\n")
-    assert freshness.has_fresh_test([test_file], freshness._freshness_seconds()) is True
-
-
-def test_has_fresh_test_false_for_stale_test_file(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("def test_x(): pass\n")
-    window = freshness._freshness_seconds()
-    stale_timestamp = time.time() - window - 60
-    os.utime(test_file, (stale_timestamp, stale_timestamp))
-    assert freshness.has_fresh_test([test_file], window) is False
-
-
-def test_has_fresh_test_false_when_no_test_evidence(tmp_path: Path) -> None:
-    test_file = tmp_path / "test_orders.py"
-    test_file.write_text("x = 1\n")
-    assert freshness.has_fresh_test([test_file], freshness._freshness_seconds()) is False