use qubit_fs::error::FsErrorKind;
use qubit_fs::error::FsOperation;
use qubit_fs::error::OpenFailureStage;
use qubit_fs::metadata::AchievedAtomicity;
use qubit_fs::metadata::AtomicityRequirement;
use qubit_fs::metadata::FileSystemCapability;
use qubit_fs::path::Path;
use qubit_fs::path::PathSemantics;
use qubit_fs::path::RelativePath;
use qubit_fs::temp::PersistFailureState;
use qubit_fs::temp::PersistOptions;
use qubit_fs::temp::TempOptions;
use qubit_fs::temp::TempResourceState;
use crate::ContractCheckId;
use crate::ContractFailure;
use crate::ContractTempFailure;
use crate::FileSystemContractSuite;
use crate::FixtureSupport;
use crate::internal::verify_condition;
impl FileSystemContractSuite<'_> {
pub(super) fn execute_temp_directory(&mut self, id: ContractCheckId) -> Result<(), ContractFailure> {
let filesystem = self.fixture.file_system();
let mut options = TempOptions::default();
let basic = id == ContractCheckId::TempDirectory;
if basic && self.capable(FileSystemCapability::TempDirectory) {
let incompatible = match self.context.properties().info().path_semantics() {
PathSemantics::Hierarchical => Path::parse_literal("/temp-invalid-parent"),
_ => Path::parse("/temp-invalid-parent"),
}
.expect("invalid-parent probe path is a valid constant");
let error = match filesystem
.create_temp_directory(TempOptions::default().with_parent(Some(incompatible.clone())))
{
Err(error) => error,
Ok(resource) => {
return Err(ContractFailure::with_owned_source(
"invalid temporary parent succeeded",
ContractTempFailure::new(
ContractFailure::message_only("invalid temporary parent was accepted"),
resource,
),
)
.at(id));
}
};
if error.recovery().is_some()
|| error.stage() != OpenFailureStage::Preflight
|| error.error().kind() != FsErrorKind::InvalidPath
|| error.error().operation() != FsOperation::CreateTemp
|| error.error().path() != Some(&incompatible)
{
return Err(ContractFailure::with_owned_source("temporary parent validation differs", error).at(id));
}
if self.capable(FileSystemCapability::CreateDirectory) {
let relative = self.context.relative_name("temp-directory-parent");
let parent = self.fixture.seed_empty_directory(&relative).map_err(|error| {
ContractFailure::with_source("temporary parent preparation failed", error).at(id)
})?;
let FixtureSupport::Supported(parent) = parent else {
return Err(ContractFailure::message_only(
"temporary parent needs independent fixture preparation",
)
.at(id));
};
self.context.record_created(parent.clone());
options = options.with_parent(Some(parent));
}
options = options
.with_prefix("contract-directory-".to_owned())
.with_suffix(".tmp".to_owned());
}
let requested_parent = options.parent().cloned();
let mut temporary = match filesystem.create_temp_directory(options) {
Ok(resource) => resource,
Err(error) if !self.capable(FileSystemCapability::TempDirectory) => {
if error.recovery().is_some()
|| error.stage() != OpenFailureStage::Preflight
|| error.error().kind() != FsErrorKind::UnsupportedCapability
|| error.error().operation() != FsOperation::CreateTemp
|| error.error().required_capability() != Some(FileSystemCapability::TempDirectory)
{
return Err(
ContractFailure::with_owned_source("temporary creation rejection differs", error).at(id),
);
}
return Ok(());
}
Err(error) => {
return Err(ContractFailure::with_owned_source("temporary resource creation failed", error).at(id));
}
};
let source = temporary.path().clone();
self.context.record_created(source.clone());
verify_condition(
self.capable(FileSystemCapability::TempDirectory),
id,
"unavailable temporary creation succeeded",
)?;
if basic {
if let Some(parent) = requested_parent {
verify_condition(
source
.as_str()
.starts_with(&format!("{}/", parent.as_str().trim_end_matches('/'))),
id,
"temporary resource ignored requested parent",
)?;
}
verify_condition(
source
.file_name()
.is_some_and(|name| name.starts_with("contract-directory-") && name.ends_with(".tmp")),
id,
"temp/directory: requested prefix or suffix was ignored",
)?;
if let Err(error) = temporary.cleanup() {
return Err(ContractFailure::with_owned_source(
"temporary cleanup failed",
ContractTempFailure::new(error, temporary),
)
.at(id));
}
let after = self
.fixture
.exists_out_of_band(&source)
.map_err(|error| ContractFailure::with_source("temporary cleanup observation failed", error).at(id))?;
verify_condition(
matches!(after, FixtureSupport::Supported(false)),
id,
"temp/directory: cleanup retained source",
)?;
temporary = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("temporary keep preparation failed", error).at(id)
})?;
self.context.record_created(temporary.path().clone());
}
let mut content_supported = self.prepare_temp_directory_contents(temporary.path(), id, false)?;
if id != ContractCheckId::TempAtomic {
let kept_source = temporary.path().clone();
let kept = match temporary.keep() {
Ok(outcome) => outcome,
Err(error) => {
return Err(ContractFailure::with_owned_source(
"temporary keep failed",
ContractTempFailure::new(error, temporary),
)
.at(id));
}
};
self.context.record_created(kept.target().clone());
verify_condition(
temporary.state() == TempResourceState::Kept && kept.target() != &kept_source,
id,
"temporary keep state or publication identity differs",
)?;
for (path, expected) in [(&kept_source, false), (kept.target(), true)] {
let observed = self
.fixture
.exists_out_of_band(path)
.map_err(|error| ContractFailure::with_source("temporary keep observation failed", error).at(id))?;
verify_condition(
matches!(observed, FixtureSupport::Supported(actual) if actual == expected),
id,
"temporary keep publication differs",
)?;
}
if content_supported {
content_supported = self.verify_temp_directory_contents(kept.target(), id, false)?;
}
if id == ContractCheckId::TempRepeatedLifecycle {
let failure = match temporary.keep() {
Err(failure) => failure,
Ok(_) => {
return Err(
ContractFailure::message_only("temp/repeated-lifecycle: second keep succeeded").at(id),
);
}
};
if failure.error().kind() != FsErrorKind::InvalidState
|| failure.state() != PersistFailureState::PublishedSourceReleased
|| failure.publication_target() != Some(kept.target())
{
return Err(ContractFailure::with_owned_source(
"temp/repeated-lifecycle: publication facts lost",
ContractTempFailure::new(failure, temporary),
)
.at(id));
}
let error = match temporary.cleanup() {
Err(error) => error,
Ok(_) => {
return Err(
ContractFailure::message_only("temp/repeated-lifecycle: kept target reclaimed").at(id),
);
}
};
if error.kind() != FsErrorKind::InvalidState {
return Err(ContractFailure::with_owned_source(
"repeated cleanup rejection differs",
ContractTempFailure::new(error, temporary),
)
.at(id));
}
verify_condition(temporary.state() == TempResourceState::Kept, id, "kept state changed")?;
let after = self.fixture.exists_out_of_band(kept.target()).map_err(|error| {
ContractFailure::with_source("repeated keep publication observation failed", error).at(id)
})?;
verify_condition(
matches!(after, FixtureSupport::Supported(true)),
id,
"kept publication disappeared",
)?;
if content_supported {
self.verify_temp_directory_contents(kept.target(), id, false)?;
}
let mut cleaned = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("repeated cleanup preparation failed", error).at(id)
})?;
let cleaned_source = cleaned.path().clone();
self.context.record_created(cleaned_source.clone());
if let Err(error) = cleaned.cleanup() {
return Err(ContractFailure::with_owned_source(
"initial cleanup failed",
ContractTempFailure::new(error, cleaned),
)
.at(id));
}
let after = self.fixture.exists_out_of_band(&cleaned_source).map_err(|error| {
ContractFailure::with_source("repeated cleanup observation failed", error).at(id)
})?;
verify_condition(
matches!(after, FixtureSupport::Supported(false)),
id,
"cleanup retained temporary source",
)?;
let error = match cleaned.cleanup() {
Err(error) => error,
Ok(_) => {
return Err(
ContractFailure::message_only("temp/repeated-lifecycle: cleaned resource reused").at(id),
);
}
};
if error.kind() != FsErrorKind::InvalidState || cleaned.state() != TempResourceState::Cleaned {
return Err(ContractFailure::with_owned_source(
"repeated cleanup state differs",
ContractTempFailure::new(error, cleaned),
)
.at(id));
}
let mut first = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("interleaved temporary preparation failed", error).at(id)
})?;
self.context.record_created(first.path().clone());
let mut second = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("interleaved temporary preparation failed", error).at(id)
})?;
let second_path = second.path().clone();
self.context.record_created(second_path.clone());
let sentinel = second_path
.join(&RelativePath::parse("nested/sentinel").expect("constant temporary sentinel path"));
match self
.fixture
.write_file_out_of_band(&sentinel, b"directory B sentinel")
.map_err(|error| {
ContractFailure::with_source("interleaved temporary sentinel setup failed", error).at(id)
})? {
FixtureSupport::Supported(()) => {}
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(
id,
"fixture write_file_out_of_band hook is unsupported",
);
return Ok(());
}
}
if let Err(error) = first.cleanup() {
return Err(ContractFailure::with_owned_source(
"interleaved temporary cleanup failed",
ContractTempFailure::new(error, first),
)
.at(id));
}
for path in [&second_path, &sentinel] {
let observed = self.fixture.exists_out_of_band(path).map_err(|error| {
ContractFailure::with_source("interleaved temporary observation failed", error).at(id)
})?;
match observed {
FixtureSupport::Supported(true) => {}
FixtureSupport::Supported(false) => verify_condition(
false,
id,
"temp/repeated-lifecycle: live directory or sentinel disappeared after cleanup",
)?,
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(
id,
"fixture exists_out_of_band hook is unsupported",
);
return Ok(());
}
}
}
match self.fixture.read_file(&sentinel).map_err(|error| {
ContractFailure::with_source("interleaved temporary sentinel observation failed", error).at(id)
})? {
FixtureSupport::Supported(actual) => verify_condition(
actual.as_slice() == b"directory B sentinel",
id,
"temp/repeated-lifecycle: live directory sentinel changed after cleanup",
)?,
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(id, "fixture read_file hook is unsupported");
return Ok(());
}
}
let mut third = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("interleaved temporary preparation failed", error).at(id)
})?;
self.context.record_created(third.path().clone());
verify_condition(
third.path() != &second_path,
id,
"temp/repeated-lifecycle: live directory path was reused",
)?;
match self.fixture.read_file(&sentinel).map_err(|error| {
ContractFailure::with_source("interleaved temporary sentinel observation failed", error).at(id)
})? {
FixtureSupport::Supported(actual) => verify_condition(
actual.as_slice() == b"directory B sentinel",
id,
"temp/repeated-lifecycle: live directory sentinel changed after creating another resource",
)?,
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(id, "fixture read_file hook is unsupported");
return Ok(());
}
}
if let Err(error) = second.cleanup() {
return Err(ContractFailure::with_owned_source(
"interleaved temporary cleanup failed",
ContractTempFailure::new(error, second),
)
.at(id));
}
if let Err(error) = third.cleanup() {
return Err(ContractFailure::with_owned_source(
"interleaved temporary cleanup failed",
ContractTempFailure::new(error, third),
)
.at(id));
}
return Ok(());
}
temporary = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("temporary persistence preparation failed", error).at(id)
})?;
self.context.record_created(temporary.path().clone());
content_supported = self.prepare_temp_directory_contents(temporary.path(), id, false)?;
}
let source = temporary.path().clone();
let target = self
.fixture
.path(&self.context.relative_name("persisted-directory"))
.map_err(|error| {
ContractFailure::with_source("temporary publication target preparation failed", error).at(id)
})?;
self.context.record_created(target.clone());
let atomic = id == ContractCheckId::TempAtomic;
let options = PersistOptions::default().with_atomicity(if atomic {
AtomicityRequirement::Required
} else {
AtomicityRequirement::Preferred
});
let publication = temporary.persist(&target, options);
if atomic && !self.capable(FileSystemCapability::AtomicTempPersist) {
let failure = match publication {
Err(failure) => failure,
Ok(_) => {
return Err(ContractFailure::message_only("unsupported atomic persistence succeeded").at(id));
}
};
let error = failure.error();
if error.kind() != FsErrorKind::RequirementNotMet
|| error.operation() != FsOperation::PersistTemp
|| error.path() != Some(&source)
|| error.target() != Some(&target)
|| error.required_capability() != Some(FileSystemCapability::AtomicTempPersist)
|| error.provider() != Some(self.context.properties().info().provider_id())
|| failure.state() != PersistFailureState::NotPublished
{
return Err(ContractFailure::with_owned_source(
"atomic persistence rejection differs",
ContractTempFailure::new(failure, temporary),
)
.at(id));
}
let before = self.fixture.exists_out_of_band(&source).map_err(|error| {
ContractFailure::with_source("atomic rejection source observation failed", error).at(id)
})?;
verify_condition(
matches!(before, FixtureSupport::Supported(true)),
id,
"atomic preflight removed source",
)?;
verify_condition(
temporary.state() == TempResourceState::Owned,
id,
"atomic preflight changed resource ownership",
)?;
let target_after = self.fixture.exists_out_of_band(&target).map_err(|error| {
ContractFailure::with_source("atomic rejection target observation failed", error).at(id)
})?;
verify_condition(
matches!(target_after, FixtureSupport::Supported(false)),
id,
"atomic preflight published a target",
)?;
if let Err(error) = temporary.cleanup() {
return Err(ContractFailure::with_owned_source(
"atomic rejection cleanup failed",
ContractTempFailure::new(error, temporary),
)
.at(id));
}
let after = self.fixture.exists_out_of_band(&source).map_err(|error| {
ContractFailure::with_source("atomic rejection cleanup observation failed", error).at(id)
})?;
verify_condition(
matches!(after, FixtureSupport::Supported(false)),
id,
"atomic rejection cleanup retained source",
)?;
return Ok(());
}
let outcome = match publication {
Ok(outcome) => outcome,
Err(error) => {
return Err(ContractFailure::with_owned_source(
"temp/atomic: persistence failed",
ContractTempFailure::new(error, temporary),
)
.at(id));
}
};
verify_condition(outcome.target() == &target, id, "temporary persist target mismatch")?;
if atomic {
verify_condition(
outcome.atomicity() == AchievedAtomicity::Atomic,
id,
"temp/atomic: non-atomic publication",
)?;
}
for (path, expected) in [(&source, false), (&target, true)] {
let observed = self
.fixture
.exists_out_of_band(path)
.map_err(|error| ContractFailure::with_source("temporary persist observation failed", error).at(id))?;
verify_condition(
matches!(observed, FixtureSupport::Supported(actual) if actual == expected),
id,
"temporary persistence source release or target publication differs",
)?;
}
if content_supported {
self.verify_temp_directory_contents(outcome.target(), id, false)?;
}
if basic {
let relative = self.context.relative_name("temp-overwritten-directory");
let prepared = self.fixture.seed_empty_directory(&relative).map_err(|error| {
ContractFailure::with_source("temporary overwrite target preparation failed", error).at(id)
})?;
let FixtureSupport::Supported(target) = prepared else {
return Err(ContractFailure::message_only(
"temporary directory overwrite needs independent target preparation",
)
.at(id));
};
self.context.record_created(target.clone());
let mut replacement = filesystem
.create_temp_directory(TempOptions::default())
.map_err(|error| {
ContractFailure::with_owned_source("temporary overwrite preparation failed", error).at(id)
})?;
let source = replacement.path().clone();
self.context.record_created(source.clone());
let replacement_contents = self.prepare_temp_directory_contents(&source, id, false)?;
let outcome = match replacement.persist(
&target,
PersistOptions::default()
.with_overwrite(true)
.with_atomicity(AtomicityRequirement::Preferred),
) {
Ok(outcome) => outcome,
Err(error) => {
return Err(ContractFailure::with_owned_source(
"temporary directory overwrite failed",
ContractTempFailure::new(error, replacement),
)
.at(id));
}
};
verify_condition(outcome.target() == &target, id, "temporary overwrite target differs")?;
for (path, expected) in [(&source, false), (&target, true)] {
let observed = self.fixture.exists_out_of_band(path).map_err(|error| {
ContractFailure::with_source("temporary overwrite observation failed", error).at(id)
})?;
verify_condition(
matches!(observed, FixtureSupport::Supported(actual) if actual == expected),
id,
"temporary overwrite did not release source and publish target",
)?;
}
if replacement_contents {
self.verify_temp_directory_contents(outcome.target(), id, false)?;
}
}
Ok(())
}
fn prepare_temp_directory_contents(
&mut self,
root: &Path,
id: ContractCheckId,
old: bool,
) -> Result<bool, ContractFailure> {
const DIRECT: &[u8] = b"old-direct";
const NESTED: &[u8] = b"old-nested";
const NEW_DIRECT: &[u8] = b"temp-direct";
const NEW_NESTED: &[u8] = b"temp-nested";
let entries = if old {
[("payload", DIRECT), ("nested/payload", NESTED)]
} else {
[("payload", NEW_DIRECT), ("nested/payload", NEW_NESTED)]
};
let paths = entries.map(|(relative, bytes)| {
let relative = RelativePath::parse(relative).expect("constant temporary child path");
(root.join(&relative), bytes)
});
for (path, bytes) in &paths {
match self.fixture.write_file_out_of_band(path, bytes).map_err(|error| {
ContractFailure::with_source("temporary directory content preparation failed", error).at(id)
})? {
FixtureSupport::Supported(()) => {}
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(
id,
"fixture write_file_out_of_band hook is unsupported",
);
return Ok(false);
}
}
}
for (path, bytes) in &paths {
if matches!(
self.fixture.exists_out_of_band(path).map_err(|error| {
ContractFailure::with_source("temporary directory setup existence check failed", error).at(id)
})?,
FixtureSupport::Supported(false)
) {
verify_condition(false, id, "temporary directory child disappeared during setup")?;
}
match self.fixture.read_file(path).map_err(|error| {
ContractFailure::with_source("temporary directory setup observation failed", error).at(id)
})? {
FixtureSupport::Supported(actual) => {
verify_condition(actual == *bytes, id, "temporary directory setup bytes differ")?;
}
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(id, "fixture read_file hook is unsupported");
return Ok(false);
}
}
}
Ok(true)
}
fn verify_temp_directory_contents(
&mut self,
root: &Path,
id: ContractCheckId,
old: bool,
) -> Result<bool, ContractFailure> {
const DIRECT: &[u8] = b"old-direct";
const NESTED: &[u8] = b"old-nested";
const NEW_DIRECT: &[u8] = b"temp-direct";
const NEW_NESTED: &[u8] = b"temp-nested";
let entries = if old {
[("payload", DIRECT), ("nested/payload", NESTED)]
} else {
[("payload", NEW_DIRECT), ("nested/payload", NEW_NESTED)]
};
for (relative, bytes) in entries {
let relative = RelativePath::parse(relative).expect("constant temporary child path");
let path = root.join(&relative);
if matches!(
self.fixture.exists_out_of_band(&path).map_err(|error| {
ContractFailure::with_source("temporary directory content existence check failed", error).at(id)
})?,
FixtureSupport::Supported(false)
) {
verify_condition(false, id, "temporary directory publication dropped a child")?;
}
match self.fixture.read_file(&path).map_err(|error| {
ContractFailure::with_source("temporary directory content observation failed", error).at(id)
})? {
FixtureSupport::Supported(actual) => {
verify_condition(actual == bytes, id, "temporary directory publication changed contents")?;
}
FixtureSupport::Unsupported => {
self.record_temp_directory_content_unverified(
id,
"fixture read_file hook is unsupported after publication",
);
return Ok(false);
}
}
}
Ok(true)
}
fn record_temp_directory_content_unverified(&mut self, id: ContractCheckId, reason: &str) {
self.context.record_check(
id,
crate::internal::check_catalog::specification(id).capability,
crate::ContractCheckOutcome::Unverified {
reason: reason.to_owned(),
},
);
}
}