qubit-fs-testkit 0.9.2

Reusable provider contract checks for qubit-fs implementations
Documentation
// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Dispatches temporary-resource checks through the typed catalog.

use super::FileSystemCapability;
use super::FileSystemContractSuite;
use crate::ContractCheckId;
use crate::ContractCheckOutcome;

impl<'a> FileSystemContractSuite<'a> {
    /// Executes all synchronous temporary-resource checks in catalog order.
    ///
    /// # Returns
    ///
    /// `Ok(())` after every temporary-resource entry has been recorded.
    ///
    /// # Errors
    ///
    /// Returns the first failure reported while executing a temporary-resource
    /// entry.
    pub(super) fn check_temp_resources(&mut self) -> Result<(), crate::ContractFailure> {
        for id in [
            ContractCheckId::TempFile,
            ContractCheckId::TempDirectory,
            ContractCheckId::TempAtomic,
            ContractCheckId::TempRepeatedLifecycle,
        ] {
            self.check_temp_item(id)?;
        }
        Ok(())
    }

    /// Executes exactly one temporary-resource catalog entry.
    ///
    /// # Parameters
    ///
    /// * `id` - Catalog entry identifying the temporary-resource scenario.
    ///
    /// # Returns
    ///
    /// `Ok(())` after the selected entry has been recorded.
    ///
    /// # Errors
    ///
    /// Returns a failure if `id` is not a temporary-resource entry or its
    /// scenario fails.
    pub(super) fn check_temp_item(&mut self, id: ContractCheckId) -> Result<(), crate::ContractFailure> {
        self.context.begin_check(id);
        let file = self.capable(FileSystemCapability::TempFile);
        let directory = self.capable(FileSystemCapability::TempDirectory);
        let outcome = match id {
            ContractCheckId::TempFile => {
                self.execute_temp_file(id)?;
                if file {
                    ContractCheckOutcome::Passed
                } else {
                    ContractCheckOutcome::RejectedAsExpected
                }
            }
            ContractCheckId::TempDirectory => {
                self.execute_temp_directory(id)?;
                if directory {
                    ContractCheckOutcome::Passed
                } else {
                    ContractCheckOutcome::RejectedAsExpected
                }
            }
            ContractCheckId::TempAtomic | ContractCheckId::TempRepeatedLifecycle => {
                if file {
                    self.execute_temp_file(id)?;
                }
                if directory {
                    self.execute_temp_directory(id)?;
                }
                if !file && !directory {
                    ContractCheckOutcome::NotApplicable {
                        reason: "no temporary resource capability".to_owned(),
                    }
                } else if id == ContractCheckId::TempAtomic && !self.capable(FileSystemCapability::AtomicTempPersist) {
                    ContractCheckOutcome::RejectedAsExpected
                } else {
                    ContractCheckOutcome::Passed
                }
            }
            _ => {
                return Err(crate::ContractFailure::message_only("selected entry is not temporary lifecycle").at(id));
            }
        };
        let outcome = self
            .context
            .report()
            .checks()
            .iter()
            .find(|check| check.id() == id)
            .and_then(|check| match check.outcome() {
                ContractCheckOutcome::Unverified { reason } => {
                    Some(ContractCheckOutcome::Unverified { reason: reason.clone() })
                }
                _ => None,
            })
            .unwrap_or(outcome);
        self.context.record_check(
            id,
            crate::internal::check_catalog::specification(id).capability,
            outcome,
        );
        Ok(())
    }
}