use crate::bucket::metadata_sys::{
ObjectLockConfigState, default_retention_from_object_lock_config, get_object_lock_config, get_object_lock_config_state,
};
use crate::bucket::object_lock::objectlock;
use crate::bucket::object_lock::types::{DefaultRetention, LegalHoldStatus, RetentionMode};
use crate::error::{Error, Result, StorageError};
use crate::object_api::{ObjectInfo, ObjectOptions};
use rustfs_filemeta::metadata_keys;
use std::sync::Arc;
use time::OffsetDateTime;
pub struct BucketObjectLockSys {}
impl BucketObjectLockSys {
#[allow(clippy::new_ret_no_self)]
pub async fn new() -> Arc<Self> {
Arc::new(Self {})
}
pub async fn get(bucket: &str) -> Option<DefaultRetention> {
if let Ok(object_lock_config) = get_object_lock_config(bucket).await {
return default_retention_from_object_lock_config(&object_lock_config.0);
}
None
}
}
pub(crate) fn ensure_recursive_force_delete_allowed_for_state(bucket: &str, state: &ObjectLockConfigState) -> Result<()> {
match state {
ObjectLockConfigState::ConfirmedAbsent => Ok(()),
ObjectLockConfigState::Configured { .. } => Err(StorageError::InvalidArgument(
bucket.to_string(),
String::new(),
"force-delete is forbidden on Object Locking enabled buckets".to_string(),
)),
ObjectLockConfigState::Fabricated => {
Err(Error::other(format!("bucket Object Lock metadata is not authoritative: {bucket}")))
}
}
}
pub fn is_retention_active(_mode: RetentionMode, retain_until_date: Option<OffsetDateTime>) -> bool {
if let Some(retain_until) = retain_until_date {
let now = objectlock::utc_now_ntp();
return retain_until.unix_timestamp() > now.unix_timestamp();
}
false
}
pub fn check_retention_for_modification(
user_defined: &std::collections::HashMap<String, String>,
new_mode: Option<RetentionMode>,
new_retain_until: Option<OffsetDateTime>,
bypass_governance: bool,
) -> Option<ObjectLockBlockReason> {
let retention = objectlock::get_object_retention_meta(user_defined);
let mode = retention.mode?;
if !is_retention_active(mode, retention.retain_until_date) {
return None;
}
let existing_retain_until = retention.retain_until_date;
let mode_changed = new_mode != Some(mode);
let is_shortening = match (&existing_retain_until, &new_retain_until) {
(Some(existing), Some(new)) => new < existing,
(Some(_), None) => true, _ => false,
};
match mode {
RetentionMode::Compliance => {
if mode_changed || is_shortening {
return Some(ObjectLockBlockReason::Retention {
mode,
retain_until: existing_retain_until,
});
}
None
}
RetentionMode::Governance => {
if (mode_changed || is_shortening) && !bypass_governance {
return Some(ObjectLockBlockReason::Retention {
mode,
retain_until: existing_retain_until,
});
}
None
}
}
}
pub fn add_years(dt: OffsetDateTime, years: i32) -> OffsetDateTime {
let target_year = dt.year() + years;
dt.replace_year(target_year)
.or_else(|_| {
dt.replace_day(28).and_then(|d| d.replace_year(target_year))
})
.unwrap_or(dt)
}
fn has_legal_hold(user_defined: &std::collections::HashMap<String, String>) -> bool {
objectlock::get_object_legalhold_meta(user_defined).is_on()
}
pub fn replication_write_may_pass_worm_gate(
state: &ObjectLockConfigState,
obj_info: &ObjectInfo,
opts: &ObjectOptions,
) -> Result<bool> {
if !opts.replication_request {
return Ok(false);
}
if obj_info.delete_marker {
return Ok(true);
}
let default_retention = default_retention_from_state(state)?;
if legal_hold_locks(obj_info)? && opts.replication_legalhold_timestamp.is_none() {
return Ok(false);
}
let retention_locked = active_retention(default_retention.as_ref(), obj_info)?.is_some();
Ok(!(retention_locked && opts.replication_retention_timestamp.is_none()))
}
pub fn replication_delete_may_bypass_governance(opts: &ObjectOptions) -> bool {
opts.replication_request && opts.version_id.is_some()
}
#[allow(dead_code, reason = "asserted by this file's tests (backlog#1823)")]
pub fn is_object_locked_by_metadata(user_defined: &std::collections::HashMap<String, String>, is_delete_marker: bool) -> bool {
if is_delete_marker {
return false;
}
if has_legal_hold(user_defined) {
return true;
}
let ret = objectlock::get_object_retention_meta(user_defined);
if let Some(mode) = ret.mode
&& is_retention_active(mode, ret.retain_until_date)
{
return true;
}
false
}
#[derive(Debug, Clone, PartialEq)]
pub enum ObjectLockBlockReason {
LegalHold,
Retention {
mode: RetentionMode,
retain_until: Option<OffsetDateTime>,
},
}
impl ObjectLockBlockReason {
pub fn error_message(&self) -> String {
match self {
ObjectLockBlockReason::LegalHold => {
"Object has a legal hold and cannot be deleted. Remove the legal hold first.".to_string()
}
ObjectLockBlockReason::Retention { mode, retain_until } => {
if let Some(until) = retain_until {
format!("Object is under {} retention and cannot be deleted until {}", mode, until)
} else {
format!("Object is under {} retention and cannot be deleted", mode)
}
}
}
}
}
fn check_retention_blocks_deletion(
mode: RetentionMode,
retain_until: Option<OffsetDateTime>,
bypass_governance: bool,
) -> Option<ObjectLockBlockReason> {
let can_bypass = mode == RetentionMode::Governance && bypass_governance;
if !can_bypass {
return Some(ObjectLockBlockReason::Retention { mode, retain_until });
}
None
}
pub(crate) fn check_object_lock_for_deletion_with_default_retention(
default_retention: Option<&DefaultRetention>,
obj_info: &ObjectInfo,
bypass_governance: bool,
) -> Result<Option<ObjectLockBlockReason>> {
if obj_info.delete_marker {
return Ok(None);
}
if legal_hold_locks(obj_info)? {
return Ok(Some(ObjectLockBlockReason::LegalHold));
}
if let Some((mode, retain_until)) = active_retention(default_retention, obj_info)?
&& let Some(reason) = check_retention_blocks_deletion(mode, Some(retain_until), bypass_governance)
{
return Ok(Some(reason));
}
Ok(None)
}
fn persisted_lock_value<'a>(obj_info: &'a ObjectInfo, key: &str) -> Option<&'a String> {
obj_info.user_defined.get(key).filter(|value| !value.is_empty())
}
fn legal_hold_locks(obj_info: &ObjectInfo) -> Result<bool> {
let Some(status) = persisted_lock_value(obj_info, metadata_keys::OBJECT_LOCK_LEGAL_HOLD) else {
return Ok(false);
};
match LegalHoldStatus::parse(status) {
Some(LegalHoldStatus::On) => Ok(true),
Some(LegalHoldStatus::Off) => Ok(false),
None => Err(Error::other("persisted object legal-hold metadata is invalid")),
}
}
fn active_retention(
default_retention: Option<&DefaultRetention>,
obj_info: &ObjectInfo,
) -> Result<Option<(RetentionMode, OffsetDateTime)>> {
let mode = persisted_lock_value(obj_info, metadata_keys::OBJECT_LOCK_MODE);
let retain_until = persisted_lock_value(obj_info, metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE);
match (mode, retain_until) {
(None, None) => {}
(Some(mode), Some(retain_until)) => {
let mode =
objectlock::parse_ret_mode(mode).ok_or_else(|| Error::other("persisted object retention mode is invalid"))?;
let retain_until = OffsetDateTime::parse(retain_until, &time::format_description::well_known::Iso8601::DEFAULT)
.map_err(|_| Error::other("persisted object retention date is invalid"))?;
return Ok(is_retention_active(mode, Some(retain_until)).then_some((mode, retain_until)));
}
_ => return Err(Error::other("persisted object retention metadata is incomplete")),
}
let Some(default_retention) = default_retention else {
return Ok(None);
};
let mod_time = obj_info
.mod_time
.ok_or_else(|| Error::other("persisted object modification time is missing"))?;
let now = objectlock::utc_now_ntp();
let retain_until = if let Some(days) = default_retention.days {
mod_time.saturating_add(time::Duration::days(i64::from(days)))
} else {
let years = default_retention
.years
.ok_or_else(|| Error::other("persisted bucket Object Lock retention period is invalid"))?;
add_years(mod_time, years)
};
Ok((retain_until.unix_timestamp() > now.unix_timestamp()).then_some((default_retention.mode, retain_until)))
}
fn default_retention_from_state(state: &ObjectLockConfigState) -> Result<Option<DefaultRetention>> {
match state {
ObjectLockConfigState::Configured { config, .. } => Ok(default_retention_from_object_lock_config(config)),
ObjectLockConfigState::ConfirmedAbsent => Ok(None),
ObjectLockConfigState::Fabricated => Err(Error::other("bucket Object Lock metadata is not authoritative")),
}
}
pub(crate) fn check_object_lock_for_deletion_with_state(
state: &ObjectLockConfigState,
obj_info: &ObjectInfo,
bypass_governance: bool,
) -> Result<Option<ObjectLockBlockReason>> {
check_object_lock_for_deletion_with_default_retention(
default_retention_from_state(state)?.as_ref(),
obj_info,
bypass_governance,
)
}
pub async fn check_object_lock_for_deletion(
bucket: &str,
obj_info: &ObjectInfo,
bypass_governance: bool,
) -> Option<ObjectLockBlockReason> {
match get_object_lock_config_state(bucket)
.await
.and_then(|state| check_object_lock_for_deletion_with_state(&state, obj_info, bypass_governance))
{
Ok(reason) => reason,
Err(_) => Some(ObjectLockBlockReason::LegalHold),
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::bucket::metadata_sys::configured_object_lock_state_for_tests;
use time::{Date, Month, PrimitiveDateTime, Time};
fn make_datetime(year: i32, month: u8, day: u8) -> OffsetDateTime {
let date = Date::from_calendar_date(year, Month::try_from(month).unwrap(), day).unwrap();
let time = Time::from_hms(0, 0, 0).unwrap();
PrimitiveDateTime::new(date, time).assume_utc()
}
fn default_retention(mode: RetentionMode) -> DefaultRetention {
DefaultRetention {
mode,
days: Some(30),
years: None,
}
}
#[test]
fn deletion_with_config_blocks_active_default_compliance_even_with_bypass() {
let retention = default_retention(RetentionMode::Compliance);
let obj_info = ObjectInfo {
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
let result = check_object_lock_for_deletion_with_default_retention(Some(&retention), &obj_info, true);
assert!(matches!(result, Ok(Some(ObjectLockBlockReason::Retention { .. }))));
}
#[test]
fn deletion_with_config_allows_active_default_governance_with_bypass() {
let retention = default_retention(RetentionMode::Governance);
let obj_info = ObjectInfo {
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
};
assert!(matches!(
check_object_lock_for_deletion_with_default_retention(Some(&retention), &obj_info, true),
Ok(None)
));
}
#[test]
fn deletion_with_default_retention_rejects_missing_object_mod_time() {
let retention = default_retention(RetentionMode::Compliance);
let err = check_object_lock_for_deletion_with_default_retention(Some(&retention), &ObjectInfo::default(), false)
.expect_err("default retention needs an authoritative object modification time");
assert!(err.to_string().contains("modification time"));
}
#[test]
fn deletion_with_confirmed_absence_still_blocks_explicit_compliance() {
let retain_until = OffsetDateTime::now_utc() + time::Duration::days(30);
let mut user_defined = std::collections::HashMap::new();
user_defined.insert("x-amz-object-lock-mode".to_string(), RetentionMode::COMPLIANCE.to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
retain_until
.format(&time::format_description::well_known::Rfc3339)
.expect("retain-until date should format"),
);
let obj_info = ObjectInfo {
user_defined: Arc::new(user_defined),
..Default::default()
};
let result = check_object_lock_for_deletion_with_default_retention(None, &obj_info, true);
assert!(matches!(result, Ok(Some(ObjectLockBlockReason::Retention { .. }))));
}
#[test]
fn deletion_with_fabricated_bucket_metadata_fails_closed() {
let err = check_object_lock_for_deletion_with_state(&ObjectLockConfigState::Fabricated, &ObjectInfo::default(), false)
.expect_err("non-authoritative Object Lock metadata must block deletion");
assert!(err.to_string().contains("not authoritative"));
}
#[test]
fn recursive_force_delete_with_fabricated_bucket_metadata_fails_closed() {
let err = ensure_recursive_force_delete_allowed_for_state("bucket", &ObjectLockConfigState::Fabricated)
.expect_err("non-authoritative Object Lock metadata must block recursive deletion");
assert!(err.to_string().contains("not authoritative"));
}
#[test]
fn deletion_rejects_incomplete_persisted_retention_metadata() {
let mut user_defined = std::collections::HashMap::new();
user_defined.insert(metadata_keys::OBJECT_LOCK_MODE.to_string(), RetentionMode::COMPLIANCE.to_string());
let obj_info = ObjectInfo {
user_defined: Arc::new(user_defined),
..Default::default()
};
let err = check_object_lock_for_deletion_with_default_retention(None, &obj_info, false)
.expect_err("mode without retain-until date must fail closed");
assert!(err.to_string().contains("incomplete"));
}
#[test]
fn deletion_rejects_each_malformed_persisted_retention_shape() {
let valid_date = (OffsetDateTime::now_utc() + time::Duration::days(30))
.format(&time::format_description::well_known::Rfc3339)
.expect("retain-until date should format");
let cases = [
("invalid mode", Some("INVALID"), Some(valid_date.as_str()), "retention mode"),
("invalid date", Some(RetentionMode::COMPLIANCE), Some("not-a-date"), "retention date"),
("date only", None, Some(valid_date.as_str()), "incomplete"),
];
for (case, mode, retain_until, expected) in cases {
let mut user_defined = std::collections::HashMap::new();
if let Some(mode) = mode {
user_defined.insert(metadata_keys::OBJECT_LOCK_MODE.to_string(), mode.to_string());
}
if let Some(retain_until) = retain_until {
user_defined.insert(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE.to_string(), retain_until.to_string());
}
let obj_info = ObjectInfo {
user_defined: Arc::new(user_defined),
..Default::default()
};
let err = check_object_lock_for_deletion_with_default_retention(None, &obj_info, false).expect_err(case);
assert!(err.to_string().contains(expected), "unexpected {case} error: {err}");
}
}
fn replication_opts(hold_ts: bool, retention_ts: bool) -> ObjectOptions {
ObjectOptions {
replication_request: true,
replication_legalhold_timestamp: hold_ts.then_some(OffsetDateTime::UNIX_EPOCH),
replication_retention_timestamp: retention_ts.then_some(OffsetDateTime::UNIX_EPOCH),
..Default::default()
}
}
fn lock_metadata(entries: &[&[(&str, &str)]]) -> std::collections::HashMap<String, String> {
entries
.iter()
.flat_map(|entries| entries.iter())
.map(|(key, value)| (key.to_string(), value.to_string()))
.collect()
}
fn lock_object_info(user_defined: std::collections::HashMap<String, String>) -> ObjectInfo {
ObjectInfo {
user_defined: Arc::new(user_defined),
mod_time: Some(OffsetDateTime::now_utc()),
..Default::default()
}
}
#[test]
fn replication_write_passes_worm_gate_only_with_every_locking_category_timestamp() {
let hold = [(metadata_keys::OBJECT_LOCK_LEGAL_HOLD, "ON")];
let retention = [
(metadata_keys::OBJECT_LOCK_MODE, "GOVERNANCE"),
(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE, "2099-01-01T00:00:00Z"),
];
let expired = [
(metadata_keys::OBJECT_LOCK_MODE, "COMPLIANCE"),
(metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE, "2000-01-01T00:00:00Z"),
];
let absent = ObjectLockConfigState::ConfirmedAbsent;
let passes = |state: &ObjectLockConfigState, entries: &[&[(&str, &str)]], opts: &ObjectOptions| {
replication_write_may_pass_worm_gate(state, &lock_object_info(lock_metadata(entries)), opts)
.expect("well-formed lock metadata must be judged")
};
assert!(passes(&absent, &[&hold, &retention], &replication_opts(true, true)));
assert!(!passes(&absent, &[&hold, &retention], &replication_opts(true, false)));
assert!(!passes(&absent, &[&hold, &retention], &replication_opts(false, true)));
assert!(passes(&absent, &[&hold], &replication_opts(true, false)));
assert!(!passes(&absent, &[&hold], &replication_opts(false, true)));
assert!(passes(&absent, &[&retention], &replication_opts(false, true)));
assert!(!passes(&absent, &[&retention], &replication_opts(true, false)));
assert!(passes(
&absent,
&[&expired, &[(metadata_keys::OBJECT_LOCK_LEGAL_HOLD, "OFF")]],
&replication_opts(false, false)
));
let local = ObjectOptions {
replication_request: false,
..replication_opts(true, true)
};
assert!(!passes(&absent, &[&hold], &local));
}
#[test]
fn replication_write_under_bucket_default_retention_requires_retention_timestamp() {
for mode in [RetentionMode::Compliance, RetentionMode::Governance] {
let state = configured_object_lock_state_for_tests(mode, 30);
let no_keys = lock_object_info(std::collections::HashMap::new());
assert!(
check_object_lock_for_deletion_with_state(&state, &no_keys, false)
.expect("default retention must be judged")
.is_some(),
"{mode}: the gate must report the default retention lock"
);
let tagging_only = ObjectOptions {
replication_request: true,
replication_tagging_timestamp: Some(OffsetDateTime::UNIX_EPOCH),
..Default::default()
};
assert!(
!replication_write_may_pass_worm_gate(&state, &no_keys, &tagging_only).expect("judged"),
"{mode}: a tagging-only replication write must not pass the default retention lock"
);
assert!(
replication_write_may_pass_worm_gate(&state, &no_keys, &replication_opts(false, true)).expect("judged"),
"{mode}: the retention source timestamp lets LWW judge the default retention"
);
let held = lock_object_info(lock_metadata(&[&[(metadata_keys::OBJECT_LOCK_LEGAL_HOLD, "ON")]]));
assert!(!replication_write_may_pass_worm_gate(&state, &held, &replication_opts(false, true)).expect("judged"));
assert!(!replication_write_may_pass_worm_gate(&state, &held, &replication_opts(true, false)).expect("judged"));
assert!(replication_write_may_pass_worm_gate(&state, &held, &replication_opts(true, true)).expect("judged"));
let expired_default = ObjectInfo {
mod_time: Some(make_datetime(2000, 1, 1)),
..lock_object_info(std::collections::HashMap::new())
};
assert!(replication_write_may_pass_worm_gate(&state, &expired_default, &tagging_only).expect("judged"));
let delete_marker = ObjectInfo {
delete_marker: true,
..lock_object_info(std::collections::HashMap::new())
};
assert!(replication_write_may_pass_worm_gate(&state, &delete_marker, &tagging_only).expect("judged"));
let cleared = lock_object_info(lock_metadata(&[&[(metadata_keys::OBJECT_LOCK_MODE, "")]]));
assert!(!replication_write_may_pass_worm_gate(&state, &cleared, &tagging_only).expect("judged"));
}
}
#[test]
fn replication_write_worm_gate_fails_closed_on_unverifiable_lock_state() {
let opts = replication_opts(true, true);
let err = replication_write_may_pass_worm_gate(
&ObjectLockConfigState::Fabricated,
&lock_object_info(std::collections::HashMap::new()),
&opts,
)
.expect_err("fabricated bucket lock metadata must not be judged");
assert!(err.to_string().contains("not authoritative"));
let malformed = lock_object_info(lock_metadata(&[&[(metadata_keys::OBJECT_LOCK_LEGAL_HOLD, "MAYBE")]]));
let err = replication_write_may_pass_worm_gate(&ObjectLockConfigState::ConfirmedAbsent, &malformed, &opts)
.expect_err("malformed legal hold must not be judged");
assert!(err.to_string().contains("legal-hold"));
let state = configured_object_lock_state_for_tests(RetentionMode::Compliance, 30);
let no_mod_time = ObjectInfo::default();
let err = replication_write_may_pass_worm_gate(&state, &no_mod_time, &opts)
.expect_err("default retention without a modification time must not be judged");
assert!(err.to_string().contains("modification time"));
}
#[test]
fn replication_delete_bypasses_governance_only_for_authorized_version_purges() {
let version_purge = ObjectOptions {
replication_request: true,
version_id: Some("6b6ffbc0-b0d3-4a86-8f6c-fe19163b8dcd".to_string()),
..Default::default()
};
assert!(replication_delete_may_bypass_governance(&version_purge));
let local_version_delete = ObjectOptions {
replication_request: false,
..version_purge.clone()
};
assert!(!replication_delete_may_bypass_governance(&local_version_delete));
let replicated_marker_creation = ObjectOptions {
version_id: None,
..version_purge
};
assert!(!replication_delete_may_bypass_governance(&replicated_marker_creation));
}
#[test]
fn deletion_treats_cleared_empty_lock_metadata_as_unlocked() {
let cases: [(&str, &[&str]); 3] = [
(
"cleared retention",
&[metadata_keys::OBJECT_LOCK_MODE, metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE],
),
("cleared legal hold", &[metadata_keys::OBJECT_LOCK_LEGAL_HOLD]),
(
"all cleared",
&[
metadata_keys::OBJECT_LOCK_MODE,
metadata_keys::OBJECT_LOCK_RETAIN_UNTIL_DATE,
metadata_keys::OBJECT_LOCK_LEGAL_HOLD,
],
),
];
for (case, keys) in cases {
let user_defined = keys.iter().map(|key| (key.to_string(), String::new())).collect();
let obj_info = ObjectInfo {
user_defined: Arc::new(user_defined),
..Default::default()
};
let result = check_object_lock_for_deletion_with_default_retention(None, &obj_info, false);
assert!(matches!(result, Ok(None)), "{case}: empty lock keys must read as unlocked: {result:?}");
}
}
#[test]
fn deletion_rejects_invalid_persisted_legal_hold_metadata() {
let mut user_defined = std::collections::HashMap::new();
user_defined.insert(metadata_keys::OBJECT_LOCK_LEGAL_HOLD.to_string(), "INVALID".to_string());
let obj_info = ObjectInfo {
user_defined: Arc::new(user_defined),
..Default::default()
};
let err = check_object_lock_for_deletion_with_default_retention(None, &obj_info, false)
.expect_err("invalid legal-hold value must fail closed");
assert!(err.to_string().contains("legal-hold"));
}
#[test]
fn test_add_years_normal() {
let dt = make_datetime(2024, 3, 15);
let result = add_years(dt, 1);
assert_eq!(result.year(), 2025);
assert_eq!(result.month(), Month::March);
assert_eq!(result.day(), 15);
}
#[test]
fn test_add_years_multiple() {
let dt = make_datetime(2024, 6, 1);
let result = add_years(dt, 5);
assert_eq!(result.year(), 2029);
assert_eq!(result.month(), Month::June);
assert_eq!(result.day(), 1);
}
#[test]
fn test_add_years_leap_year_to_leap_year() {
let dt = make_datetime(2024, 2, 29);
let result = add_years(dt, 4);
assert_eq!(result.year(), 2028);
assert_eq!(result.month(), Month::February);
assert_eq!(result.day(), 29);
}
#[test]
fn test_add_years_leap_year_to_non_leap_year() {
let dt = make_datetime(2024, 2, 29);
let result = add_years(dt, 1);
assert_eq!(result.year(), 2025);
assert_eq!(result.month(), Month::February);
assert_eq!(result.day(), 28);
}
#[test]
fn test_add_years_negative() {
let dt = make_datetime(2024, 3, 15);
let result = add_years(dt, -2);
assert_eq!(result.year(), 2022);
assert_eq!(result.month(), Month::March);
assert_eq!(result.day(), 15);
}
#[test]
fn test_add_years_zero() {
let dt = make_datetime(2024, 7, 4);
let result = add_years(dt, 0);
assert_eq!(result.year(), 2024);
assert_eq!(result.month(), Month::July);
assert_eq!(result.day(), 4);
}
#[test]
fn test_is_retention_active_no_date() {
assert!(!is_retention_active(RetentionMode::Compliance, None));
assert!(!is_retention_active(RetentionMode::Governance, None));
}
#[test]
fn test_is_retention_active_future_date() {
let future_date = OffsetDateTime::now_utc() + time::Duration::days(30);
assert!(is_retention_active(RetentionMode::Compliance, Some(future_date)));
assert!(is_retention_active(RetentionMode::Governance, Some(future_date)));
}
#[test]
fn test_is_retention_active_past_date() {
let past_date = OffsetDateTime::now_utc() - time::Duration::days(30);
assert!(!is_retention_active(RetentionMode::Compliance, Some(past_date)));
assert!(!is_retention_active(RetentionMode::Governance, Some(past_date)));
}
#[test]
fn test_check_retention_for_modification_no_existing_retention() {
let user_defined = std::collections::HashMap::new();
let new_retain = Some(OffsetDateTime::now_utc() + time::Duration::days(30));
assert!(check_retention_for_modification(&user_defined, None, new_retain, false).is_none());
}
#[test]
fn test_check_retention_for_modification_compliance_extend() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let new_retain = Some(existing_retain + time::Duration::days(30));
assert!(check_retention_for_modification(&user_defined, Some(RetentionMode::Compliance), new_retain, false).is_none());
}
#[test]
fn test_check_retention_for_modification_compliance_shorten() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(60);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let new_retain = Some(OffsetDateTime::now_utc() + time::Duration::days(30));
let result = check_retention_for_modification(&user_defined, Some(RetentionMode::Compliance), new_retain, false);
assert!(result.is_some());
assert!(matches!(result, Some(ObjectLockBlockReason::Retention { .. })));
}
#[test]
fn test_check_retention_for_modification_compliance_clear() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let result = check_retention_for_modification(&user_defined, None, None, false);
assert!(result.is_some());
}
#[test]
fn test_check_retention_for_modification_governance_shorten_without_bypass() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "GOVERNANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let new_retain = Some(OffsetDateTime::now_utc() + time::Duration::days(15));
let result = check_retention_for_modification(&user_defined, Some(RetentionMode::Governance), new_retain, false);
assert!(result.is_some());
}
#[test]
fn test_check_retention_for_modification_governance_extend_without_bypass() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "GOVERNANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let new_retain = Some(OffsetDateTime::now_utc() + time::Duration::days(60));
assert!(check_retention_for_modification(&user_defined, Some(RetentionMode::Governance), new_retain, false).is_none());
}
#[test]
fn test_check_retention_for_modification_governance_shorten_with_bypass() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "GOVERNANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let new_retain = Some(OffsetDateTime::now_utc() + time::Duration::days(15));
assert!(check_retention_for_modification(&user_defined, Some(RetentionMode::Governance), new_retain, true).is_none());
}
#[test]
fn test_check_retention_for_modification_governance_mode_change_without_bypass() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "GOVERNANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let result =
check_retention_for_modification(&user_defined, Some(RetentionMode::Compliance), Some(existing_retain), false);
assert!(result.is_some());
}
#[test]
fn test_check_retention_for_modification_governance_mode_change_with_bypass() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "GOVERNANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
assert!(
check_retention_for_modification(&user_defined, Some(RetentionMode::Compliance), Some(existing_retain), true)
.is_none()
);
}
#[test]
fn test_check_retention_for_modification_compliance_mode_change() {
let mut user_defined = std::collections::HashMap::new();
let existing_retain = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
existing_retain
.format(&time::format_description::well_known::Rfc3339)
.unwrap(),
);
let result =
check_retention_for_modification(&user_defined, Some(RetentionMode::Governance), Some(existing_retain), true);
assert!(result.is_some());
}
#[test]
fn test_is_object_locked_by_metadata_delete_marker() {
let user_defined = std::collections::HashMap::new();
assert!(!is_object_locked_by_metadata(&user_defined, true));
}
#[test]
fn test_is_object_locked_by_metadata_legal_hold_on() {
let mut user_defined = std::collections::HashMap::new();
user_defined.insert("x-amz-object-lock-legal-hold".to_string(), "ON".to_string());
assert!(is_object_locked_by_metadata(&user_defined, false));
}
#[test]
fn test_is_object_locked_by_metadata_legal_hold_off() {
let mut user_defined = std::collections::HashMap::new();
user_defined.insert("x-amz-object-lock-legal-hold".to_string(), "OFF".to_string());
assert!(!is_object_locked_by_metadata(&user_defined, false));
}
#[test]
fn test_is_object_locked_by_metadata_retention_active() {
let mut user_defined = std::collections::HashMap::new();
let future_date = OffsetDateTime::now_utc() + time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
future_date.format(&time::format_description::well_known::Rfc3339).unwrap(),
);
assert!(is_object_locked_by_metadata(&user_defined, false));
}
#[test]
fn test_is_object_locked_by_metadata_retention_expired() {
let mut user_defined = std::collections::HashMap::new();
let past_date = OffsetDateTime::now_utc() - time::Duration::days(30);
user_defined.insert("x-amz-object-lock-mode".to_string(), "COMPLIANCE".to_string());
user_defined.insert(
"x-amz-object-lock-retain-until-date".to_string(),
past_date.format(&time::format_description::well_known::Rfc3339).unwrap(),
);
assert!(!is_object_locked_by_metadata(&user_defined, false));
}
#[test]
fn test_is_object_locked_by_metadata_no_lock() {
let user_defined = std::collections::HashMap::new();
assert!(!is_object_locked_by_metadata(&user_defined, false));
}
}