Skip to main content

rustfs_lifecycle/
core.rs

1// Copyright 2024 RustFS Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use rustfs_config::{DEFAULT_ILM_DAY_SECS, ENV_ILM_DEBUG_DAY_SECS, ENV_ILM_PROCESS_TIME, ENV_ILM_PROCESS_TIME_DEPRECATED};
16use rustfs_replication::{ReplicationStatusType, VersionPurgeStatusType};
17use s3s::dto::{
18    BucketLifecycleConfiguration, ExpirationStatus, LifecycleExpiration, LifecycleRule, LifecycleRuleFilter,
19    NoncurrentVersionTransition, ObjectLockConfiguration, ObjectLockEnabled, RestoreRequest, Transition,
20};
21use std::collections::{HashMap, HashSet};
22use std::sync::Arc;
23use time::macros::offset;
24use time::{self, Duration, OffsetDateTime};
25use tracing::{debug, warn};
26use uuid::Uuid;
27
28use crate::rule::{Filter, NoncurrentVersionTransitionOps, TransitionOps};
29
30pub const TRANSITION_COMPLETE: &str = "complete";
31pub const TRANSITION_PENDING: &str = "pending";
32const LOG_COMPONENT_ECSTORE: &str = "ecstore";
33const LOG_SUBSYSTEM_LIFECYCLE: &str = "lifecycle";
34const EVENT_LIFECYCLE_EXPIRY_COMPUTED: &str = "lifecycle_expiry_computed";
35const EVENT_LIFECYCLE_DEBUG_DAY_SECS: &str = "lifecycle_debug_day_secs";
36const EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED: &str = "lifecycle_noncurrent_expiry_skipped";
37const METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL: &str = "rustfs_lifecycle_invalid_mod_time_total";
38const ERR_LIFECYCLE_NO_RULE: &str = "Lifecycle configuration should have at least one rule";
39const ERR_LIFECYCLE_DUPLICATE_ID: &str = "Rule ID must be unique. Found same ID for more than one rule";
40const _ERR_XML_NOT_WELL_FORMED: &str =
41    "The XML you provided was not well-formed or did not validate against our published schema";
42const ERR_LIFECYCLE_BUCKET_LOCKED: &str =
43    "ExpiredObjectAllVersions element and DelMarkerExpiration action cannot be used on an object locked bucket";
44const ERR_LIFECYCLE_TOO_MANY_RULES: &str = "Lifecycle configuration should have at most 1000 rules";
45const ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS: &str = "'Days' for Expiration action must be a positive integer";
46const ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT: &str = "Expiration cannot specify both Days and Date";
47const ERR_LIFECYCLE_MULTIPLE_TRANSITIONS: &str = "Only one Transition action per lifecycle rule is supported";
48const ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS: &str =
49    "Only one NoncurrentVersionTransition action per lifecycle rule is supported";
50const ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS: &str =
51    "'NoncurrentDays' for NoncurrentVersionExpiration action must be a positive integer";
52const ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS: &str =
53    "'DaysAfterInitiation' for AbortIncompleteMultipartUpload action must be a positive integer";
54const ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT: &str = "Expiration.Date must be at midnight UTC";
55const ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER: &str =
56    "ExpiredObjectDeleteMarker cannot be specified with Days or Date";
57const ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS: &str =
58    "Days must be a positive integer and Date must not be specified inside Expiration with ExpiredObjectAllVersions";
59const ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS: &str = "Days must be a positive integer with DelMarkerExpiration";
60const ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG: &str = "Rule ID must be at most 255 characters";
61const ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY: &str = "Rule ID must not be empty";
62const ERR_LIFECYCLE_INVALID_RULE_STATUS: &str = "Rule status must be either Enabled or Disabled";
63const ERR_LIFECYCLE_DEL_MARKER_WITH_TAGS: &str = "Rule with DelMarkerExpiration cannot have tags based filtering";
64const ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS: &str =
65    "Rule with ExpiredObjectDeleteMarker cannot have tags based filtering";
66const ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION: &str = "Rule must have at least one of Expiration, Transition, NoncurrentVersionExpiration, NoncurrentVersionTransition, or DelMarkerExpiration";
67const ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT: &str = "Legacy Prefix and Filter cannot both be present in a lifecycle rule. Use Filter.Prefix instead of the top-level Prefix element.";
68const ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS: &str = "'NewerNoncurrentVersions' must be a non-negative integer";
69const ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES: &str = "Filter And must contain at least two predicates";
70const ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES: &str = "Filter has too many predicates";
71const ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY: &str = "Filter must not repeat a tag key";
72const ERR_LIFECYCLE_FILTER_INVALID_TAG: &str = "Tag key must be 1-128 characters and tag value must be at most 256 characters";
73const ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE: &str = "ObjectSizeGreaterThan and ObjectSizeLessThan must not be negative";
74const ERR_LIFECYCLE_FILTER_SIZE_RANGE: &str = "ObjectSizeGreaterThan must be smaller than ObjectSizeLessThan";
75/// Longest tag key S3 accepts.
76const MAX_TAG_KEY_LEN: usize = 128;
77/// Longest tag value S3 accepts.
78const MAX_TAG_VALUE_LEN: usize = 256;
79
80/// A validation failure that the S3 boundary must answer with `MalformedXML`
81/// rather than `InvalidArgument`: the document does not match the published
82/// schema shape (wrong number of `Filter` predicates, a one-member `And`).
83///
84/// Everything else stays [`std::io::ErrorKind::Other`], which the boundary
85/// already maps to `InvalidArgument`.
86pub const LIFECYCLE_MALFORMED_XML_ERROR_KIND: std::io::ErrorKind = std::io::ErrorKind::InvalidData;
87
88/// A persisted rule that could never have passed validation. Callers that can
89/// report an error surface it; evaluation itself stays fail-closed and takes
90/// no action for the rule.
91pub const LIFECYCLE_CORRUPT_RULE_ERROR_KIND: std::io::ErrorKind = std::io::ErrorKind::InvalidData;
92
93fn malformed_xml_error(message: &'static str) -> std::io::Error {
94    std::io::Error::new(LIFECYCLE_MALFORMED_XML_ERROR_KIND, message)
95}
96
97/// The retention count a rule keeps, or `None` when the persisted value is
98/// negative — a shape PUT validation rejects, so reaching it means the rule
99/// came from older persistence or an import.
100///
101/// A negative count must never be read as "retain everything": that is how an
102/// invalid configuration silently stopped deleting versions (backlog#2201).
103pub fn retained_noncurrent_versions(count: i32) -> Option<usize> {
104    usize::try_from(count).ok()
105}
106
107/// Does any rule carry a retention count that validation would have rejected?
108pub fn lifecycle_has_corrupt_retention_count(lc: &BucketLifecycleConfiguration) -> bool {
109    lc.rules.iter().any(rule_has_corrupt_retention_count)
110}
111
112fn rule_has_corrupt_retention_count(rule: &LifecycleRule) -> bool {
113    let expiration_count = rule
114        .noncurrent_version_expiration
115        .as_ref()
116        .and_then(|expiration| expiration.newer_noncurrent_versions);
117    let transition_counts = rule
118        .noncurrent_version_transitions
119        .iter()
120        .flatten()
121        .filter_map(|transition| transition.newer_noncurrent_versions);
122    expiration_count
123        .into_iter()
124        .chain(transition_counts)
125        .any(|count| retained_noncurrent_versions(count).is_none())
126}
127
128pub use rustfs_scanner_metrics::metrics::IlmAction;
129
130#[async_trait::async_trait]
131pub trait RuleValidate {
132    fn validate(&self) -> Result<(), std::io::Error>;
133}
134
135#[async_trait::async_trait]
136impl RuleValidate for LifecycleRule {
137    /*fn validate_id(&self) -> Result<()> {
138        if self.id.len() > 255 {
139            return errInvalidRuleID;
140        }
141        Ok(())
142    }
143
144    fn validate_status(&self) -> Result<()> {
145        if self.status.len() == 0 {
146            return ErrEmptyRuleStatus;
147        }
148
149        if self.status != Enabled && self.status != Disabled {
150            return ErrInvalidRuleStatus;
151        }
152        Ok(())
153    }
154
155    fn validate_expiration(&self) -> Result<()> {
156        self.expiration.validate();
157    }
158
159    fn validate_noncurrent_expiration(&self) -> Result<()> {
160        self.noncurrent_version_expiration.validate()
161    }
162
163    fn validate_prefix_and_filter(&self) -> Result<()> {
164        if !self.prefix.set && self.Filter.isempty() || self.prefix.set && !self.filter.isempty() {
165            return ErrXMLNotWellFormed;
166        }
167        if !self.prefix.set {
168            return self.filter.validate();
169        }
170        Ok(())
171    }
172
173    fn validate_transition(&self) -> Result<()> {
174        self.Transition.Validate()
175    }
176
177    fn validate_noncurrent_transition(&self) -> Result<()> {
178        self.NoncurrentVersionTransition.Validate()
179    }
180
181    fn get_prefix(&self) -> String {
182        if p := self.Prefix.String(); p != "" {
183          return p
184        }
185        if p := self.Filter.Prefix.String(); p != "" {
186          return p
187        }
188        if p := self.Filter.And.Prefix.String(); p != "" {
189          return p
190        }
191        "".to_string()
192    }*/
193
194    fn validate(&self) -> Result<(), std::io::Error> {
195        // S3 standard: Legacy Prefix and Filter cannot both be present.
196        // An empty prefix is treated as "not set" and is allowed with a Filter.
197        let has_legacy_prefix = self.prefix.as_deref().is_some_and(|p| !p.is_empty());
198        let has_filter = self.filter.is_some();
199        if has_legacy_prefix && has_filter {
200            return Err(std::io::Error::other(ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT));
201        }
202
203        if let Some(filter) = self.filter.as_ref() {
204            validate_lifecycle_filter(filter)?;
205        }
206
207        // A negative retention count was accepted and then read as "retain
208        // (almost) everything" during evaluation, so an HTTP-accepted rule
209        // silently stopped deleting versions (backlog#2201).
210        if rule_has_corrupt_retention_count(self) {
211            return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS));
212        }
213
214        // Rule with DelMarkerExpiration cannot have tags based filtering
215        let has_tag_filter = self
216            .filter
217            .as_ref()
218            .is_some_and(|f| f.tag.is_some() || f.and.as_ref().and_then(|a| a.tags.as_ref()).is_some());
219        if has_tag_filter && self.del_marker_expiration.is_some() {
220            return Err(std::io::Error::other(ERR_LIFECYCLE_DEL_MARKER_WITH_TAGS));
221        }
222        if has_tag_filter
223            && self
224                .expiration
225                .as_ref()
226                .is_some_and(|expiration| expiration.expired_object_delete_marker.is_some_and(|v| v))
227        {
228            return Err(std::io::Error::other(ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS));
229        }
230        if let Some(expiration) = &self.expiration
231            && expiration.expired_object_delete_marker.is_some()
232            && (expiration.days.is_some() || expiration.date.is_some())
233        {
234            return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER));
235        }
236        if self
237            .del_marker_expiration
238            .as_ref()
239            .is_some_and(|expiration| expiration.days.is_none_or(|days| days < 1))
240        {
241            return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS));
242        }
243        // Rule must have at least one action
244        let has_expiration = self.expiration.as_ref().is_some_and(|expiration| {
245            expiration.days.is_some() || expiration.date.is_some() || expiration.expired_object_delete_marker.is_some()
246        });
247        let has_transition = self.transitions.as_ref().is_some_and(|t| !t.is_empty());
248        // `NewerNoncurrentVersions` on its own is a MinIO extension, not an AWS
249        // form: it keeps the newest N noncurrent versions and expires the rest
250        // with no age condition. RustFS accepts it for MinIO compatibility, so
251        // it has to count as an action here — otherwise a count-only rule was
252        // rejected as actionless (backlog#2201).
253        let has_noncurrent_expiration = self.noncurrent_version_expiration.as_ref().is_some_and(|expiration| {
254            expiration.noncurrent_days.is_some() || expiration.newer_noncurrent_versions.is_some_and(|count| count > 0)
255        });
256        let has_noncurrent_transition = self
257            .noncurrent_version_transitions
258            .as_ref()
259            .and_then(|t| t.first())
260            .and_then(|t| t.storage_class.as_ref())
261            .is_some();
262        let has_abort_incomplete_multipart_upload = self.abort_incomplete_multipart_upload.is_some();
263        let has_del_marker_expiration = self
264            .del_marker_expiration
265            .as_ref()
266            .and_then(|d| d.days)
267            .is_some_and(|d| d > 0);
268        if !has_expiration
269            && !has_transition
270            && !has_noncurrent_expiration
271            && !has_noncurrent_transition
272            && !has_abort_incomplete_multipart_upload
273            && !has_del_marker_expiration
274        {
275            return Err(std::io::Error::other(ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION));
276        }
277        Ok(())
278    }
279}
280
281/// Structural validation for `LifecycleRuleFilter`.
282///
283/// The generated DTO is all-`Option`, so the S3 schema constraints have to be
284/// checked here: at most one top-level predicate, an `And` that actually
285/// combines at least two, no repeated tag key, tag key/value limits, and a
286/// coherent non-negative size range (backlog#2201).
287///
288/// A filter with no predicate at all stays valid: AWS documents an empty
289/// `Filter` as "applies to every object in the bucket", and rejecting it would
290/// break the most common way to write an unconditional rule.
291fn validate_lifecycle_filter(filter: &LifecycleRuleFilter) -> Result<(), std::io::Error> {
292    let top_level_predicates = usize::from(filter.prefix.is_some())
293        + usize::from(filter.tag.is_some())
294        + usize::from(filter.object_size_greater_than.is_some())
295        + usize::from(filter.object_size_less_than.is_some())
296        + usize::from(filter.and.is_some());
297    if top_level_predicates > 1 {
298        return Err(malformed_xml_error(ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES));
299    }
300
301    if let Some(tag) = filter.tag.as_ref() {
302        validate_lifecycle_tag(tag)?;
303    }
304
305    if let Some(and) = filter.and.as_ref() {
306        let tags = and.tags.as_deref().unwrap_or(&[]);
307        let and_predicates = usize::from(and.prefix.is_some())
308            + tags.len()
309            + usize::from(and.object_size_greater_than.is_some())
310            + usize::from(and.object_size_less_than.is_some());
311        if and_predicates < 2 {
312            return Err(malformed_xml_error(ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES));
313        }
314        let mut seen_keys = HashSet::with_capacity(tags.len());
315        for tag in tags {
316            validate_lifecycle_tag(tag)?;
317            let key = tag.key.as_deref().unwrap_or_default();
318            if !seen_keys.insert(key) {
319                return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY));
320            }
321        }
322        validate_lifecycle_size_bounds(and.object_size_greater_than, and.object_size_less_than)?;
323    }
324
325    validate_lifecycle_size_bounds(filter.object_size_greater_than, filter.object_size_less_than)?;
326
327    Ok(())
328}
329
330/// S3 requires a tag to carry a key and value; both are length-bounded.
331/// The DTO makes both optional, so incomplete tags have to be rejected here
332/// rather than silently matching nothing.
333fn validate_lifecycle_tag(tag: &s3s::dto::Tag) -> Result<(), std::io::Error> {
334    let key = tag.key.as_deref().unwrap_or_default();
335    let Some(value) = tag.value.as_deref() else {
336        return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_INVALID_TAG));
337    };
338    if key.is_empty() || key.chars().count() > MAX_TAG_KEY_LEN || value.chars().count() > MAX_TAG_VALUE_LEN {
339        return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_INVALID_TAG));
340    }
341    Ok(())
342}
343
344fn validate_lifecycle_size_bounds(greater_than: Option<i64>, less_than: Option<i64>) -> Result<(), std::io::Error> {
345    if greater_than.is_some_and(|size| size < 0) || less_than.is_some_and(|size| size < 0) {
346        return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE));
347    }
348    if let (Some(greater_than), Some(less_than)) = (greater_than, less_than)
349        && greater_than >= less_than
350    {
351        return Err(std::io::Error::other(ERR_LIFECYCLE_FILTER_SIZE_RANGE));
352    }
353    Ok(())
354}
355
356fn lifecycle_rule_prefix(rule: &LifecycleRule) -> Option<&str> {
357    // Prefer a non-empty legacy prefix; treat an empty legacy prefix as if it were not set
358    if let Some(p) = rule.prefix.as_deref()
359        && !p.is_empty()
360    {
361        return Some(p);
362    }
363
364    let filter = rule.filter.as_ref()?;
365
366    if let Some(p) = filter.prefix.as_deref() {
367        return Some(p);
368    }
369
370    filter.and.as_ref().and_then(|and| and.prefix.as_deref())
371}
372
373fn lifecycle_mod_time(obj: &ObjectOpts) -> Option<OffsetDateTime> {
374    let reason = match obj.mod_time {
375        None => "missing",
376        Some(mod_time) if mod_time < OffsetDateTime::UNIX_EPOCH => "before_unix_epoch",
377        Some(mod_time) if mod_time == OffsetDateTime::UNIX_EPOCH => "unix_epoch",
378        Some(mod_time) => return Some(mod_time),
379    };
380    metrics::counter!(
381        METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL,
382        "reason" => reason
383    )
384    .increment(1);
385    None
386}
387
388#[async_trait::async_trait]
389pub trait Lifecycle {
390    async fn has_transition(&self) -> bool;
391    fn has_expiry(&self) -> bool;
392    fn has_active_rules(&self, prefix: &str) -> bool;
393    async fn validate(&self, lr: &ObjectLockConfiguration) -> Result<(), std::io::Error>;
394    async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>>;
395    async fn eval(&self, obj: &ObjectOpts) -> Event;
396    async fn predict_expiration(&self, obj: &ObjectOpts) -> Event;
397    async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime, newer_noncurrent_versions: usize) -> Event;
398    //fn set_prediction_headers(&self, w: http.ResponseWriter, obj: ObjectOpts);
399    async fn noncurrent_versions_expiration_limit(self: Arc<Self>, obj: &ObjectOpts) -> Event;
400}
401
402#[async_trait::async_trait]
403impl Lifecycle for BucketLifecycleConfiguration {
404    async fn has_transition(&self) -> bool {
405        for rule in self.rules.iter() {
406            if rule.transitions.as_ref().is_some_and(|transitions| !transitions.is_empty()) {
407                return true;
408            }
409        }
410        false
411    }
412
413    fn has_expiry(&self) -> bool {
414        for rule in self.rules.iter() {
415            if rule.expiration.is_some() || rule.noncurrent_version_expiration.is_some() {
416                return true;
417            }
418        }
419        false
420    }
421
422    fn has_active_rules(&self, prefix: &str) -> bool {
423        if self.rules.is_empty() {
424            return false;
425        }
426        for rule in self.rules.iter() {
427            if rule.status.as_str() == ExpirationStatus::DISABLED {
428                continue;
429            }
430
431            let rule_prefix = lifecycle_rule_prefix(rule).unwrap_or("");
432            if !prefix.is_empty()
433                && !rule_prefix.is_empty()
434                && !prefix.starts_with(rule_prefix)
435                && !rule_prefix.starts_with(prefix)
436            {
437                continue;
438            }
439
440            if let Some(rule_noncurrent_version_expiration) = &rule.noncurrent_version_expiration {
441                if let Some(noncurrent_days) = rule_noncurrent_version_expiration.noncurrent_days
442                    && noncurrent_days >= 0
443                {
444                    return true;
445                }
446                // A positive count is an action on its own (the MinIO count-only
447                // form). Zero means "no count constraint" here, exactly as the
448                // batch limit path reads it, and a negative count is corrupt —
449                // neither makes the rule active (backlog#2201).
450                if let Some(newer_noncurrent_versions) = rule_noncurrent_version_expiration.newer_noncurrent_versions
451                    && newer_noncurrent_versions > 0
452                {
453                    return true;
454                }
455            }
456            if rule
457                .noncurrent_version_transitions
458                .as_ref()
459                .is_some_and(|transitions| !transitions.is_empty())
460            {
461                return true;
462            }
463            if rule
464                .del_marker_expiration
465                .as_ref()
466                .and_then(|expiration| expiration.days)
467                .is_some_and(|days| days > 0)
468            {
469                return true;
470            }
471            if let Some(rule_expiration) = &rule.expiration {
472                if let Some(date1) = rule_expiration.date.clone()
473                    && OffsetDateTime::from(date1).unix_timestamp() < OffsetDateTime::now_utc().unix_timestamp()
474                {
475                    return true;
476                }
477                if rule_expiration.date.is_some() {
478                    return true;
479                }
480                if rule_expiration.days.is_some() {
481                    return true;
482                }
483                if let Some(expired_object_delete_marker) = rule_expiration.expired_object_delete_marker
484                    && expired_object_delete_marker
485                {
486                    return true;
487                }
488            }
489            if let Some(rule_transition) = rule.transitions.as_ref().and_then(|transitions| transitions.first()) {
490                if let Some(date1) = rule_transition.date.clone()
491                    && OffsetDateTime::from(date1).unix_timestamp() < OffsetDateTime::now_utc().unix_timestamp()
492                {
493                    return true;
494                }
495                return true;
496            }
497        }
498        false
499    }
500
501    async fn validate(&self, lr: &ObjectLockConfiguration) -> Result<(), std::io::Error> {
502        if self.rules.len() > 1000 {
503            return Err(std::io::Error::other(ERR_LIFECYCLE_TOO_MANY_RULES));
504        }
505        if self.rules.is_empty() {
506            return Err(std::io::Error::other(ERR_LIFECYCLE_NO_RULE));
507        }
508
509        for r in &self.rules {
510            if r.status != ExpirationStatus::from_static(ExpirationStatus::ENABLED)
511                && r.status != ExpirationStatus::from_static(ExpirationStatus::DISABLED)
512            {
513                return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_STATUS));
514            }
515
516            if let Some(expiration) = &r.expiration {
517                if expiration.expired_object_all_versions.is_some()
518                    && (expiration.days.is_none_or(|days| days < 1) || expiration.date.is_some())
519                {
520                    return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS));
521                }
522                if expiration.days.is_some() && expiration.date.is_some() {
523                    return Err(std::io::Error::new(
524                        std::io::ErrorKind::InvalidInput,
525                        ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT,
526                    ));
527                }
528                if let Some(expiration_date) = &expiration.date {
529                    let date = OffsetDateTime::from(expiration_date.clone());
530                    if date.hour() != 0 || date.minute() != 0 || date.second() != 0 || date.nanosecond() != 0 {
531                        return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT));
532                    }
533                }
534                // S3 requires Expiration.Days to be a positive integer (>= 1). AWS and the
535                // ceph s3-tests `test_lifecycle_expiration_days0` case reject Days == 0 with
536                // InvalidArgument; only Date-based rules may omit Days entirely.
537                if let Some(days) = expiration.days
538                    && days < 1
539                {
540                    return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS));
541                }
542            }
543            // S3 requires NoncurrentVersionExpiration.NoncurrentDays to be a positive
544            // integer (>= 1); AWS rejects 0 with InvalidArgument.
545            if let Some(noncurrent_version_expiration) = &r.noncurrent_version_expiration
546                && let Some(noncurrent_days) = noncurrent_version_expiration.noncurrent_days
547                && noncurrent_days < 1
548            {
549                return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS));
550            }
551            // S3 requires AbortIncompleteMultipartUpload.DaysAfterInitiation to be present
552            // and a positive integer (>= 1); AWS rejects 0 (and a missing value) with
553            // InvalidArgument.
554            if let Some(abort_incomplete_multipart_upload) = &r.abort_incomplete_multipart_upload {
555                match abort_incomplete_multipart_upload.days_after_initiation {
556                    Some(days) if days >= 1 => {}
557                    _ => return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS)),
558                }
559            }
560            if let Some(transitions) = &r.transitions {
561                if transitions.len() > 1 {
562                    return Err(std::io::Error::new(std::io::ErrorKind::InvalidInput, ERR_LIFECYCLE_MULTIPLE_TRANSITIONS));
563                }
564                for transition in transitions {
565                    TransitionOps::validate(transition)?;
566                }
567            }
568            if let Some(noncurrent_transitions) = &r.noncurrent_version_transitions {
569                if noncurrent_transitions.len() > 1 {
570                    return Err(std::io::Error::new(
571                        std::io::ErrorKind::InvalidInput,
572                        ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS,
573                    ));
574                }
575                for transition in noncurrent_transitions {
576                    NoncurrentVersionTransitionOps::validate(transition)?;
577                }
578            }
579            if let Some(id) = &r.id {
580                if id.is_empty() {
581                    return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY));
582                }
583                if id.len() > 255 {
584                    return Err(std::io::Error::other(ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG));
585                }
586            }
587            r.validate()?;
588            if let Some(object_lock_enabled) = lr.object_lock_enabled.as_ref()
589                && object_lock_enabled.as_str() == ObjectLockEnabled::ENABLED
590            {
591                if let Some(expiration) = r.expiration.as_ref() {
592                    // Object Lock + ExpiredObjectAllVersions conflict (MinIO extension)
593                    if expiration.expired_object_all_versions.is_some_and(|v| v) {
594                        return Err(std::io::Error::other(ERR_LIFECYCLE_BUCKET_LOCKED));
595                    }
596                }
597                // Object Lock + DelMarkerExpiration conflict
598                if r.del_marker_expiration.is_some() {
599                    return Err(std::io::Error::other(ERR_LIFECYCLE_BUCKET_LOCKED));
600                }
601            }
602        }
603        for (i, _) in self.rules.iter().enumerate() {
604            if i == self.rules.len() - 1 {
605                break;
606            }
607            let other_rules = &self.rules[i + 1..];
608            for other_rule in other_rules {
609                if let (Some(id1), Some(id2)) = (&self.rules[i].id, &other_rule.id)
610                    && id1 == id2
611                {
612                    return Err(std::io::Error::other(ERR_LIFECYCLE_DUPLICATE_ID));
613                }
614            }
615        }
616        Ok(())
617    }
618
619    async fn filter_rules(&self, obj: &ObjectOpts) -> Option<Vec<LifecycleRule>> {
620        if obj.name.is_empty() {
621            return None;
622        }
623        let mut rules = Vec::<LifecycleRule>::new();
624        for rule in self.rules.iter() {
625            if rule.status.as_str() == ExpirationStatus::DISABLED {
626                continue;
627            }
628            if let Some(rule_prefix) = lifecycle_rule_prefix(rule)
629                && !obj.name.starts_with(rule_prefix)
630            {
631                continue;
632            }
633            if let Some(filter) = rule.filter.as_ref() {
634                if !<LifecycleRuleFilter as Filter>::test_tags(filter, &obj.user_tags) {
635                    continue;
636                }
637                if !obj.delete_marker
638                    && !<LifecycleRuleFilter as Filter>::by_size(filter, i64::try_from(obj.size).unwrap_or(i64::MAX))
639                {
640                    continue;
641                }
642            }
643            rules.push(rule.clone());
644        }
645        Some(rules)
646    }
647
648    async fn eval(&self, obj: &ObjectOpts) -> Event {
649        // A single-object lookup cannot prove how many newer historical versions
650        // survive. Count-dependent actions wait for the complete-group evaluator.
651        self.eval_inner(obj, OffsetDateTime::now_utc(), 0).await
652    }
653
654    async fn predict_expiration(&self, obj: &ObjectOpts) -> Event {
655        let Some(mod_time) = lifecycle_mod_time(obj) else {
656            return Event::default();
657        };
658
659        if obj.delete_marker || !obj.is_latest {
660            return Event::default();
661        }
662
663        let Some(lc_rules) = self.filter_rules(obj).await else {
664            return Event::default();
665        };
666
667        let mut event: Option<Event> = None;
668        for rule in lc_rules {
669            let Some(expiration) = rule.expiration else {
670                continue;
671            };
672            if expiration.expired_object_delete_marker.is_some_and(|v| v) {
673                continue;
674            }
675            let Some(due) = (match (&expiration.date, expiration.days) {
676                (Some(date), _) => Some(OffsetDateTime::from(date.clone())),
677                (None, Some(days)) => Some(expected_expiry_time(mod_time, days)),
678                _ => None,
679            }) else {
680                continue;
681            };
682
683            let predicted = Event {
684                action: IlmAction::DeleteAction,
685                rule_id: rule.id.clone().unwrap_or_default(),
686                due: Some(due),
687                noncurrent_days: 0,
688                newer_noncurrent_versions: 0,
689                storage_class: "".into(),
690            };
691            let predicted_due = predicted.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp();
692            let should_replace = event
693                .as_ref()
694                .is_none_or(|e| predicted_due < e.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp());
695            if should_replace {
696                event = Some(predicted);
697            }
698        }
699
700        event.unwrap_or_default()
701    }
702
703    async fn eval_inner(&self, obj: &ObjectOpts, now: OffsetDateTime, newer_noncurrent_versions: usize) -> Event {
704        let mut events = Vec::<Event>::new();
705        debug!(
706            "eval_inner: object={}, mod_time={:?}, successor_mod_time={:?}, now={:?}, is_latest={}, delete_marker={}",
707            obj.name, obj.mod_time, obj.successor_mod_time, now, obj.is_latest, obj.delete_marker
708        );
709
710        let Some(mod_time) = lifecycle_mod_time(obj) else {
711            return Event::default();
712        };
713
714        if let Some(event) = obj.restored_copy_expiry(now) {
715            events.push(event);
716        }
717
718        if let Some(ref lc_rules) = self.filter_rules(obj).await {
719            for rule in lc_rules.iter() {
720                // A retention count that PUT validation would have rejected can
721                // only come from older persistence or an import. Take no action
722                // for the rule instead of allowing another action on the same
723                // corrupt rule to delete or transition an object (backlog#2201).
724                if rule_has_corrupt_retention_count(rule) {
725                    debug!(
726                        event = EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED,
727                        component = LOG_COMPONENT_ECSTORE,
728                        subsystem = LOG_SUBSYSTEM_LIFECYCLE,
729                        object = %obj.name,
730                        rule_id = %rule.id.clone().unwrap_or_default(),
731                        reason = "corrupt_newer_noncurrent_versions",
732                        "Skipped lifecycle evaluation for a rule with an invalid retention count"
733                    );
734                    continue;
735                }
736
737                if obj.is_latest && obj.expired_object_deletemarker() {
738                    if let Some(expiration) = rule.expiration.as_ref()
739                        && expiration.expired_object_delete_marker.is_some_and(|v| v)
740                    {
741                        // Preserve explicit date/days scheduling when configured.
742                        // If only ExpiredObjectDeleteMarker=true is set, delete immediately.
743                        let due = expiration.next_due(obj).unwrap_or(now);
744                        if now.unix_timestamp() >= due.unix_timestamp() {
745                            events.push(Event {
746                                action: IlmAction::DeleteVersionAction,
747                                rule_id: rule.id.clone().unwrap_or_default(),
748                                due: Some(due),
749                                noncurrent_days: 0,
750                                newer_noncurrent_versions: 0,
751                                storage_class: "".into(),
752                            });
753                            // Stop after scheduling an expired delete-marker event.
754                            break;
755                        }
756                    }
757                    if let Some(days) = rule.expiration.as_ref().and_then(|expiration| expiration.days) {
758                        let due = expected_expiry_time(mod_time, days);
759                        if now.unix_timestamp() >= due.unix_timestamp() {
760                            events.push(Event {
761                                action: IlmAction::DeleteVersionAction,
762                                rule_id: rule.id.clone().unwrap_or_default(),
763                                due: Some(due),
764                                noncurrent_days: 0,
765                                newer_noncurrent_versions: 0,
766                                storage_class: "".into(),
767                            });
768                        }
769                    }
770                }
771
772                if obj.is_latest
773                    && obj.delete_marker
774                    && let Some(days) = rule.del_marker_expiration.as_ref().and_then(|expiration| expiration.days)
775                    && days > 0
776                {
777                    let due = expected_expiry_time(mod_time, days);
778                    if now.unix_timestamp() >= due.unix_timestamp() {
779                        events.push(Event {
780                            action: IlmAction::DelMarkerDeleteAllVersionsAction,
781                            rule_id: rule.id.clone().unwrap_or_default(),
782                            due: Some(due),
783                            noncurrent_days: 0,
784                            newer_noncurrent_versions: 0,
785                            storage_class: "".into(),
786                        });
787                    }
788                    continue;
789                }
790
791                if !obj.is_latest
792                    && let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration
793                    && (noncurrent_version_expiration.noncurrent_days.is_some()
794                        || noncurrent_version_expiration
795                            .newer_noncurrent_versions
796                            .is_some_and(|count| count > 0))
797                    && noncurrent_version_expiration
798                        .newer_noncurrent_versions
799                        .is_none_or(|retain| usize::try_from(retain).is_ok_and(|retain| newer_noncurrent_versions >= retain))
800                {
801                    // A count-only rule (MinIO extension) has no age condition:
802                    // every version past the retained count is due as soon as it
803                    // became noncurrent, i.e. zero days after the successor.
804                    let noncurrent_days = noncurrent_version_expiration.noncurrent_days.unwrap_or(0);
805                    if let Some(successor_mod_time) = obj.successor_mod_time {
806                        let expected_expiry = expected_expiry_time(successor_mod_time, noncurrent_days);
807                        if now.unix_timestamp() >= expected_expiry.unix_timestamp() {
808                            events.push(Event {
809                                action: IlmAction::DeleteVersionAction,
810                                rule_id: rule.id.clone().unwrap_or_default(),
811                                due: Some(expected_expiry),
812                                noncurrent_days: 0,
813                                newer_noncurrent_versions: 0,
814                                storage_class: "".into(),
815                            });
816                        }
817                    } else {
818                        debug!(
819                            event = EVENT_LIFECYCLE_NONCURRENT_EXPIRY_SKIPPED,
820                            component = LOG_COMPONENT_ECSTORE,
821                            subsystem = LOG_SUBSYSTEM_LIFECYCLE,
822                            object = %obj.name,
823                            reason = "missing_successor_mod_time",
824                            "Skipped noncurrent expiration for incomplete version chain"
825                        );
826                    }
827                }
828
829                if !obj.is_latest
830                    && let Some(noncurrent_version_transition) = rule
831                        .noncurrent_version_transitions
832                        .as_ref()
833                        .filter(|transitions| transitions.len() == 1)
834                        .and_then(|transitions| transitions.first())
835                    && noncurrent_version_transition
836                        .newer_noncurrent_versions
837                        .is_none_or(|retain| usize::try_from(retain).is_ok_and(|retain| newer_noncurrent_versions >= retain))
838                    && let Some(storage_class) = noncurrent_version_transition.storage_class.as_ref()
839                    && !storage_class.as_str().is_empty()
840                    && !obj.delete_marker
841                    && obj.transition_status != TRANSITION_COMPLETE
842                {
843                    let due = noncurrent_version_transition.next_due(obj);
844                    if let Some(due0) = due
845                        && (now.unix_timestamp() == 0 || now.unix_timestamp() > due0.unix_timestamp())
846                    {
847                        events.push(Event {
848                            action: IlmAction::TransitionVersionAction,
849                            rule_id: rule.id.clone().unwrap_or_default(),
850                            due,
851                            storage_class: storage_class.as_str().to_string(),
852                            ..Default::default()
853                        });
854                    }
855                }
856
857                debug!(
858                    "eval_inner: checking expiration condition - is_latest={}, delete_marker={}, version_id={:?}, condition_met={}",
859                    obj.is_latest,
860                    obj.delete_marker,
861                    obj.version_id,
862                    obj.is_latest && !obj.delete_marker
863                );
864                // Current-version expiration is selected by the authoritative
865                // latest flag. An explicit null version can also be historical.
866                if obj.is_latest && !obj.delete_marker {
867                    debug!("eval_inner: entering expiration check");
868                    if let Some(ref expiration) = rule.expiration {
869                        if let Some(ref date) = expiration.date {
870                            let date0 = OffsetDateTime::from(date.clone());
871                            if date0.unix_timestamp() != 0 && (now.unix_timestamp() >= date0.unix_timestamp()) {
872                                debug!("eval_inner: expiration by date - date0={:?}", date0);
873                                events.push(Event {
874                                    action: IlmAction::DeleteAction,
875                                    rule_id: rule.id.clone().unwrap_or_default(),
876                                    due: Some(date0),
877                                    noncurrent_days: 0,
878                                    newer_noncurrent_versions: 0,
879                                    storage_class: "".into(),
880                                });
881                            }
882                        } else if let Some(days) = expiration.days {
883                            let expected_expiry: OffsetDateTime = expected_expiry_time(mod_time, days);
884                            debug!(
885                                "eval_inner: expiration check - days={}, obj_time={:?}, expiry_time={:?}, now={:?}, should_expire={}",
886                                days,
887                                mod_time,
888                                expected_expiry,
889                                now,
890                                now.unix_timestamp() > expected_expiry.unix_timestamp()
891                            );
892                            if now.unix_timestamp() >= expected_expiry.unix_timestamp() {
893                                debug!("eval_inner: object should expire, adding DeleteAction");
894                                let mut event = Event {
895                                    action: IlmAction::DeleteAction,
896                                    rule_id: rule.id.clone().unwrap_or_default(),
897                                    due: Some(expected_expiry),
898                                    noncurrent_days: 0,
899                                    newer_noncurrent_versions: 0,
900                                    storage_class: "".into(),
901                                };
902                                // MinIO extension: ExpiredObjectAllVersions deletes all versions
903                                if rule
904                                    .expiration
905                                    .as_ref()
906                                    .and_then(|e| e.expired_object_all_versions)
907                                    .unwrap_or(false)
908                                {
909                                    event.action = IlmAction::DeleteAllVersionsAction;
910                                }
911                                events.push(event);
912                            }
913                        } else {
914                            debug!("eval_inner: expiration.days is None");
915                        }
916                    } else {
917                        debug!("eval_inner: rule.expiration is None");
918                    }
919
920                    if obj.transition_status != TRANSITION_COMPLETE
921                        && let Some(transition) = rule
922                            .transitions
923                            .as_ref()
924                            .filter(|transitions| transitions.len() == 1)
925                            .and_then(|transitions| transitions.first())
926                        && let Some(storage_class) = transition.storage_class.as_ref()
927                        && !storage_class.as_str().is_empty()
928                    {
929                        let due = transition.next_due(obj);
930                        if let Some(due0) = due
931                            && (now.unix_timestamp() == 0 || now.unix_timestamp() > due0.unix_timestamp())
932                        {
933                            events.push(Event {
934                                action: IlmAction::TransitionAction,
935                                rule_id: rule.id.clone().unwrap_or_default(),
936                                due,
937                                storage_class: storage_class.as_str().to_string(),
938                                noncurrent_days: 0,
939                                newer_noncurrent_versions: 0,
940                            });
941                        }
942                    }
943                }
944            }
945        }
946
947        if !events.is_empty() {
948            // Eligible expiration takes precedence over transition, even when a
949            // failed transition has an earlier deadline. Within each action class,
950            // prefer the earliest deadline using a deterministic total order.
951            let event = events
952                .iter()
953                .min_by_key(|event| {
954                    (
955                        ilm_action_priority_rank(&event.action),
956                        event.due.unwrap_or(OffsetDateTime::UNIX_EPOCH).unix_timestamp(),
957                    )
958                })
959                .cloned()
960                .unwrap_or_default();
961            return event;
962        }
963
964        Event::default()
965    }
966
967    async fn noncurrent_versions_expiration_limit(self: Arc<Self>, obj: &ObjectOpts) -> Event {
968        if let Some(filter_rules) = self.filter_rules(obj).await {
969            for rule in filter_rules.iter() {
970                if let Some(ref noncurrent_version_expiration) = rule.noncurrent_version_expiration {
971                    return if let Some(newer_noncurrent_versions) = noncurrent_version_expiration.newer_noncurrent_versions {
972                        // Zero means "no count constraint"; a negative count is
973                        // corrupt and must not be read as "retain everything"
974                        // (backlog#2201). Neither yields a limit event.
975                        let Some(retained) = retained_noncurrent_versions(newer_noncurrent_versions).filter(|c| *c > 0) else {
976                            continue;
977                        };
978                        Event {
979                            action: IlmAction::DeleteVersionAction,
980                            rule_id: rule.id.clone().unwrap_or_default(),
981                            noncurrent_days: u32::try_from(noncurrent_version_expiration.noncurrent_days.unwrap_or(0))
982                                .unwrap_or(u32::MAX),
983                            newer_noncurrent_versions: retained,
984                            due: Some(OffsetDateTime::UNIX_EPOCH),
985                            storage_class: "".into(),
986                        }
987                    } else {
988                        Event {
989                            action: IlmAction::DeleteVersionAction,
990                            rule_id: rule.id.clone().unwrap_or_default(),
991                            noncurrent_days: u32::try_from(noncurrent_version_expiration.noncurrent_days.unwrap_or(0))
992                                .unwrap_or(u32::MAX),
993                            newer_noncurrent_versions: 0,
994                            due: Some(OffsetDateTime::UNIX_EPOCH),
995                            storage_class: "".into(),
996                        }
997                    };
998                }
999            }
1000        }
1001        Event::default()
1002    }
1003}
1004
1005#[async_trait::async_trait]
1006pub trait LifecycleCalculate {
1007    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime>;
1008}
1009
1010#[async_trait::async_trait]
1011impl LifecycleCalculate for LifecycleExpiration {
1012    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1013        if !obj.is_latest || !obj.delete_marker {
1014            return None;
1015        }
1016        // Check date first (date-based expiration takes priority over days).
1017        // A zero unix timestamp means "not set" (default value) and is skipped.
1018        if let Some(ref date) = self.date {
1019            let expiry_date = OffsetDateTime::from(date.clone());
1020            if expiry_date.unix_timestamp() != 0 {
1021                return Some(expiry_date);
1022            }
1023        }
1024        match self.days {
1025            Some(days) => obj.mod_time.map(|mod_time| expected_expiry_time(mod_time, days)),
1026            None => None,
1027        }
1028    }
1029}
1030
1031#[async_trait::async_trait]
1032impl LifecycleCalculate for NoncurrentVersionTransition {
1033    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1034        if obj.is_latest || self.storage_class.is_none() {
1035            return None;
1036        }
1037        match self.noncurrent_days {
1038            Some(noncurrent_days) => {
1039                if let Some(successor_mod_time) = obj.successor_mod_time {
1040                    Some(expected_expiry_time(successor_mod_time, noncurrent_days))
1041                } else {
1042                    Some(expected_expiry_time(OffsetDateTime::now_utc(), noncurrent_days))
1043                }
1044            }
1045            None => obj.successor_mod_time,
1046        }
1047    }
1048}
1049
1050#[async_trait::async_trait]
1051impl LifecycleCalculate for Transition {
1052    fn next_due(&self, obj: &ObjectOpts) -> Option<OffsetDateTime> {
1053        if !obj.is_latest {
1054            return None;
1055        }
1056
1057        if let Some(date) = self.date.clone() {
1058            return Some(date.into());
1059        }
1060
1061        match (self.days, obj.mod_time) {
1062            (Some(days), Some(mod_time)) => Some(expected_expiry_time(mod_time, days)),
1063            (Some(_), None) => None,
1064            (None, mod_time) => mod_time,
1065        }
1066    }
1067}
1068
1069pub fn expected_expiry_time(mod_time: OffsetDateTime, days: i32) -> OffsetDateTime {
1070    if days == 0 {
1071        debug!(
1072            event = EVENT_LIFECYCLE_EXPIRY_COMPUTED,
1073            component = LOG_COMPONENT_ECSTORE,
1074            subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1075            days,
1076            result = "unix_epoch",
1077            "Computed immediate lifecycle expiry time"
1078        );
1079        return OffsetDateTime::UNIX_EPOCH; // Return epoch time to ensure immediate expiry
1080    }
1081    // One "day" is normally 86400 seconds; RUSTFS_ILM_DEBUG_DAY_SECS (test/debug
1082    // only) can shrink it so Days-based rules become testable in seconds. Unset =>
1083    // ilm_day_secs() == 86400, byte-identical to `Duration::days(days)`.
1084    let offset_secs = i64::from(days).saturating_mul(i64::from(ilm_day_secs()));
1085    let t = mod_time
1086        .to_offset(offset!(-0:00:00))
1087        .saturating_add(Duration::seconds(offset_secs));
1088
1089    // Round up to the next processing boundary per S3-compatible Days semantics.
1090    // Canonical key: RUSTFS_ILM_PROCESS_TIME; deprecated alias: _RUSTFS_ILM_PROCESS_TIME.
1091    // When RUSTFS_ILM_PROCESS_TIME is unset the boundary defaults to the (possibly
1092    // debug-accelerated) day length, so RUSTFS_ILM_DEBUG_DAY_SECS scales rounding too.
1093    // TODO(GA): Remove ENV_ILM_PROCESS_TIME_DEPRECATED compatibility during GA release.
1094    let process_interval_secs = ilm_process_interval_secs();
1095
1096    let boundary_nanos = i128::from(process_interval_secs) * 1_000_000_000;
1097    let timestamp_nanos = t.unix_timestamp_nanos();
1098    let remainder = timestamp_nanos.rem_euclid(boundary_nanos);
1099    let rounded_nanos = if remainder == 0 {
1100        timestamp_nanos
1101    } else {
1102        timestamp_nanos + (boundary_nanos - remainder)
1103    };
1104    OffsetDateTime::from_unix_timestamp_nanos(rounded_nanos).unwrap_or(t)
1105}
1106
1107fn ilm_process_interval_secs() -> u32 {
1108    // An explicit RUSTFS_ILM_PROCESS_TIME (or its deprecated alias) always wins.
1109    // Otherwise fall back to the lifecycle day length so the debug day-length
1110    // override rescales the rounding boundary consistently with the deadline.
1111    std::env::var(ENV_ILM_PROCESS_TIME)
1112        .ok()
1113        .or_else(|| std::env::var(ENV_ILM_PROCESS_TIME_DEPRECATED).ok())
1114        .and_then(|value| value.parse::<i32>().ok())
1115        .filter(|value| *value > 0)
1116        .and_then(|value| u32::try_from(value).ok())
1117        .unwrap_or_else(ilm_day_secs)
1118}
1119
1120/// Number of seconds treated as one lifecycle "day".
1121///
1122/// **TEST/DEBUG ONLY override.** Returns [`DEFAULT_ILM_DAY_SECS`] (86400) unless
1123/// the `RUSTFS_ILM_DEBUG_DAY_SECS` environment variable is set to a positive
1124/// integer, modeled on Ceph RGW's `rgw_lc_debug_interval`. When set, one
1125/// Days-based lifecycle "day" is compressed to that many seconds, making
1126/// expiration / transition / noncurrent Days rules exercisable in seconds.
1127///
1128/// A missing / zero / non-numeric value falls back to 86400, so with the
1129/// variable unset the behavior is byte-for-byte identical to production.
1130/// Enabling it emits a `WARN` because it accelerates data deletion and must
1131/// never be set in a production deployment. Only relative `Days` deadlines are
1132/// rescaled; absolute `Date`-based rules are unaffected.
1133///
1134/// In production the value is parsed once (via `OnceLock`) so there is no
1135/// per-object environment read on the scanner evaluation path. Under `#[cfg(test)]`
1136/// the environment is re-read on every call so `temp_env`-style tests remain
1137/// deterministic and cannot poison each other across a shared process.
1138fn ilm_day_secs() -> u32 {
1139    #[cfg(test)]
1140    {
1141        resolve_ilm_day_secs()
1142    }
1143    #[cfg(not(test))]
1144    {
1145        use std::sync::OnceLock;
1146        static CACHE: OnceLock<u32> = OnceLock::new();
1147        *CACHE.get_or_init(resolve_ilm_day_secs)
1148    }
1149}
1150
1151fn resolve_ilm_day_secs() -> u32 {
1152    match std::env::var(ENV_ILM_DEBUG_DAY_SECS) {
1153        Ok(raw) => parse_ilm_day_secs(&raw),
1154        Err(_) => DEFAULT_ILM_DAY_SECS,
1155    }
1156}
1157
1158/// Parse a `RUSTFS_ILM_DEBUG_DAY_SECS` value. Positive integers activate the
1159/// override (with a `WARN`); anything else warns and falls back to 86400.
1160fn parse_ilm_day_secs(raw: &str) -> u32 {
1161    match raw.trim().parse::<u32>() {
1162        Ok(secs) if secs > 0 => {
1163            warn!(
1164                event = EVENT_LIFECYCLE_DEBUG_DAY_SECS,
1165                component = LOG_COMPONENT_ECSTORE,
1166                subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1167                day_secs = secs,
1168                "RUSTFS_ILM_DEBUG_DAY_SECS is set: lifecycle Days are accelerated to {secs}s/day. \
1169                 TEST/DEBUG ONLY - this accelerates object deletion and must never be enabled in production."
1170            );
1171            secs
1172        }
1173        _ => {
1174            warn!(
1175                event = EVENT_LIFECYCLE_DEBUG_DAY_SECS,
1176                component = LOG_COMPONENT_ECSTORE,
1177                subsystem = LOG_SUBSYSTEM_LIFECYCLE,
1178                raw = raw,
1179                fallback_day_secs = DEFAULT_ILM_DAY_SECS,
1180                "Ignoring invalid RUSTFS_ILM_DEBUG_DAY_SECS value; falling back to 86400s/day."
1181            );
1182            DEFAULT_ILM_DAY_SECS
1183        }
1184    }
1185}
1186
1187pub async fn abort_incomplete_multipart_upload_due(
1188    lc: &BucketLifecycleConfiguration,
1189    obj: &ObjectOpts,
1190) -> Option<(OffsetDateTime, String)> {
1191    let initiated = obj.mod_time?;
1192    let rules = lc.filter_rules(obj).await?;
1193
1194    rules
1195        .into_iter()
1196        .filter_map(|rule| {
1197            let days = rule
1198                .abort_incomplete_multipart_upload
1199                .as_ref()?
1200                .days_after_initiation
1201                .filter(|days| *days >= 0)?;
1202            Some((expected_expiry_time(initiated, days), rule.id.unwrap_or_default()))
1203        })
1204        .min_by_key(|(due, _)| due.unix_timestamp_nanos())
1205}
1206
1207#[derive(Debug, Default)]
1208pub struct ObjectOpts {
1209    pub name: String,
1210    pub user_tags: String,
1211    pub mod_time: Option<OffsetDateTime>,
1212    pub size: usize,
1213    pub version_id: Option<Uuid>,
1214    pub is_latest: bool,
1215    pub delete_marker: bool,
1216    pub num_versions: usize,
1217    pub successor_mod_time: Option<OffsetDateTime>,
1218    pub transition_status: String,
1219    pub restore_ongoing: bool,
1220    pub restore_expires: Option<OffsetDateTime>,
1221    pub versioned: bool,
1222    pub version_suspended: bool,
1223    pub user_defined: HashMap<String, String>,
1224    pub version_purge_status: VersionPurgeStatusType,
1225    pub replication_status: ReplicationStatusType,
1226}
1227
1228impl ObjectOpts {
1229    pub fn expired_object_deletemarker(&self) -> bool {
1230        self.delete_marker && self.is_latest && self.num_versions == 1
1231    }
1232
1233    pub(crate) fn restored_copy_expiry(&self, now: OffsetDateTime) -> Option<Event> {
1234        let restore_expires = self.restore_expires?;
1235        // Restore metadata alone does not prove that a durable remote copy exists.
1236        if self.transition_status != TRANSITION_COMPLETE
1237            || restore_expires.unix_timestamp() == 0
1238            || now.unix_timestamp() <= restore_expires.unix_timestamp()
1239        {
1240            return None;
1241        }
1242        let action = if self.is_latest {
1243            IlmAction::DeleteRestoredAction
1244        } else {
1245            IlmAction::DeleteRestoredVersionAction
1246        };
1247        expiration_action_has_valid_target(action, self.version_id, self.is_latest, self.delete_marker).then(|| Event {
1248            action,
1249            due: Some(now),
1250            ..Default::default()
1251        })
1252    }
1253}
1254
1255/// Returns whether an expiry action has enough identity to target the object
1256/// it was evaluated against. A nil UUID is an explicit S3 null-version
1257/// identity; only an absent version ID is ambiguous for an exact-version
1258/// action.
1259pub fn expiration_action_has_valid_target(
1260    action: IlmAction,
1261    version_id: Option<Uuid>,
1262    is_latest: bool,
1263    delete_marker: bool,
1264) -> bool {
1265    match action {
1266        IlmAction::DeleteAction | IlmAction::DeleteRestoredAction => is_latest && !delete_marker,
1267        IlmAction::DeleteVersionAction => version_id.is_some() && (!is_latest || delete_marker),
1268        IlmAction::DeleteRestoredVersionAction => version_id.is_some() && !is_latest && !delete_marker,
1269        IlmAction::DeleteAllVersionsAction => is_latest && !delete_marker,
1270        IlmAction::DelMarkerDeleteAllVersionsAction => is_latest && delete_marker,
1271        _ => true,
1272    }
1273}
1274
1275/// Eligible logical expiration takes precedence over transition and restore-copy
1276/// cleanup. Deadlines break ties within an action class.
1277fn ilm_action_priority_rank(action: &IlmAction) -> u8 {
1278    match action {
1279        IlmAction::DeleteAllVersionsAction
1280        | IlmAction::DelMarkerDeleteAllVersionsAction
1281        | IlmAction::DeleteAction
1282        | IlmAction::DeleteVersionAction => 0,
1283        _ => 1,
1284    }
1285}
1286
1287#[derive(Debug, Clone)]
1288pub struct Event {
1289    pub action: IlmAction,
1290    pub rule_id: String,
1291    pub due: Option<OffsetDateTime>,
1292    pub noncurrent_days: u32,
1293    pub newer_noncurrent_versions: usize,
1294    pub storage_class: String,
1295}
1296
1297impl Default for Event {
1298    fn default() -> Self {
1299        Self {
1300            action: IlmAction::NoneAction,
1301            rule_id: "".into(),
1302            due: Some(OffsetDateTime::UNIX_EPOCH),
1303            noncurrent_days: 0,
1304            newer_noncurrent_versions: 0,
1305            storage_class: "".into(),
1306        }
1307    }
1308}
1309
1310pub use rustfs_storage_api::ExpirationOptions;
1311
1312#[derive(Debug, Clone)]
1313pub struct TransitionOptions {
1314    pub status: String,
1315    pub tier: String,
1316    pub etag: String,
1317    pub expected_data_dir: Option<Uuid>,
1318    pub expected_remote_name: String,
1319    pub expected_remote_version_id: String,
1320    pub restore_request: RestoreRequest,
1321    pub restore_expiry: OffsetDateTime,
1322    pub expire_restored: bool,
1323}
1324
1325impl Default for TransitionOptions {
1326    fn default() -> Self {
1327        Self {
1328            status: Default::default(),
1329            tier: Default::default(),
1330            etag: Default::default(),
1331            expected_data_dir: Default::default(),
1332            expected_remote_name: Default::default(),
1333            expected_remote_version_id: Default::default(),
1334            restore_request: Default::default(),
1335            restore_expiry: OffsetDateTime::now_utc(),
1336            expire_restored: Default::default(),
1337        }
1338    }
1339}
1340
1341#[cfg(test)]
1342mod tests {
1343    use super::*;
1344    use metrics_util::MetricKind;
1345    use metrics_util::debugging::{DebugValue, DebuggingRecorder};
1346    use s3s::dto::{
1347        LifecycleRuleAndOperator, LifecycleRuleFilter, NoncurrentVersionExpiration, NoncurrentVersionTransition,
1348        TransitionStorageClass,
1349    };
1350    use s3s::xml::{Deserialize as XmlDeserialize, SerializeContent as XmlSerializeContent};
1351    use serial_test::serial;
1352    use std::sync::Arc;
1353    use time::macros::datetime;
1354
1355    fn with_default_ilm_process_time(test: impl FnOnce()) {
1356        // Also neutralize the debug day-length override so these boundary tests
1357        // stay hermetic against an ambient RUSTFS_ILM_DEBUG_DAY_SECS.
1358        temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
1359            temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
1360                temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, test);
1361            });
1362        });
1363    }
1364
1365    fn enabled_rule(
1366        expiration: Option<LifecycleExpiration>,
1367        del_marker_expiration: Option<s3s::dto::DelMarkerExpiration>,
1368        id: Option<&str>,
1369    ) -> LifecycleRule {
1370        LifecycleRule {
1371            status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1372            expiration,
1373            abort_incomplete_multipart_upload: None,
1374            del_marker_expiration,
1375            filter: None,
1376            id: id.map(str::to_string),
1377            noncurrent_version_expiration: None,
1378            noncurrent_version_transitions: None,
1379            prefix: None,
1380            transitions: None,
1381        }
1382    }
1383
1384    #[test]
1385    fn eval_inner_reports_invalid_mod_time_without_expiring_object() {
1386        let lifecycle = BucketLifecycleConfiguration {
1387            expiry_updated_at: None,
1388            rules: vec![LifecycleRule {
1389                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1390                expiration: Some(LifecycleExpiration {
1391                    days: Some(1),
1392                    ..Default::default()
1393                }),
1394                abort_incomplete_multipart_upload: None,
1395                del_marker_expiration: None,
1396                filter: None,
1397                id: Some("expire-after-one-day".to_string()),
1398                noncurrent_version_expiration: None,
1399                noncurrent_version_transitions: None,
1400                prefix: None,
1401                transitions: None,
1402            }],
1403        };
1404        let recorder = DebuggingRecorder::new();
1405        let snapshotter = recorder.snapshotter();
1406        let runtime = tokio::runtime::Builder::new_current_thread()
1407            .build()
1408            .expect("current-thread runtime should build");
1409
1410        let actions = metrics::with_local_recorder(&recorder, || {
1411            runtime.block_on(async {
1412                let now = OffsetDateTime::from_unix_timestamp(10 * 86_400).expect("fixed timestamp should be valid");
1413                let mut opts = ObjectOpts {
1414                    name: "legacy-object".to_string(),
1415                    is_latest: true,
1416                    ..Default::default()
1417                };
1418                let mut actions = Vec::new();
1419                for mod_time in [
1420                    None,
1421                    Some(OffsetDateTime::UNIX_EPOCH),
1422                    Some(OffsetDateTime::UNIX_EPOCH - Duration::nanoseconds(1)),
1423                    Some(OffsetDateTime::UNIX_EPOCH + Duration::nanoseconds(1)),
1424                ] {
1425                    opts.mod_time = mod_time;
1426                    actions.push((
1427                        lifecycle.eval_inner(&opts, now, 0).await.action,
1428                        lifecycle.predict_expiration(&opts).await.action,
1429                    ));
1430                }
1431                actions
1432            })
1433        });
1434
1435        assert_eq!(
1436            actions,
1437            [
1438                (IlmAction::NoneAction, IlmAction::NoneAction),
1439                (IlmAction::NoneAction, IlmAction::NoneAction),
1440                (IlmAction::NoneAction, IlmAction::NoneAction),
1441                (IlmAction::DeleteAction, IlmAction::DeleteAction)
1442            ]
1443        );
1444
1445        let invalid_mod_time_metrics = snapshotter
1446            .snapshot()
1447            .into_vec()
1448            .into_iter()
1449            .filter_map(|(composite, _unit, _description, value)| {
1450                (composite.kind() == MetricKind::Counter && composite.key().name() == METRIC_LIFECYCLE_INVALID_MOD_TIME_TOTAL)
1451                    .then(|| {
1452                        let reason = composite
1453                            .key()
1454                            .labels()
1455                            .find(|label| label.key() == "reason")
1456                            .map(|label| label.value().to_string())
1457                            .expect("invalid mod_time metric should have a reason");
1458                        (reason, value)
1459                    })
1460            })
1461            .collect::<Vec<_>>();
1462        assert_eq!(invalid_mod_time_metrics.len(), 3);
1463        assert!(
1464            invalid_mod_time_metrics
1465                .iter()
1466                .all(|(_, value)| matches!(value, DebugValue::Counter(2)))
1467        );
1468        assert!(invalid_mod_time_metrics.iter().any(|(reason, _)| reason == "missing"));
1469        assert!(invalid_mod_time_metrics.iter().any(|(reason, _)| reason == "unix_epoch"));
1470        assert!(
1471            invalid_mod_time_metrics
1472                .iter()
1473                .any(|(reason, _)| reason == "before_unix_epoch")
1474        );
1475    }
1476
1477    #[tokio::test]
1478    async fn validate_rejects_zero_expiration_days() {
1479        // S3 compatibility: Expiration.Days must be a positive integer (>= 1). AWS and
1480        // the ceph s3-tests `test_lifecycle_expiration_days0` case reject Days == 0 with
1481        // InvalidArgument. The PutBucketLifecycleConfiguration path maps this io::Error
1482        // to s3_error!(InvalidArgument) (see execute_put_bucket_lifecycle_configuration).
1483        let lc = BucketLifecycleConfiguration {
1484            expiry_updated_at: None,
1485            rules: vec![LifecycleRule {
1486                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1487                expiration: Some(LifecycleExpiration {
1488                    days: Some(0),
1489                    ..Default::default()
1490                }),
1491                abort_incomplete_multipart_upload: None,
1492                del_marker_expiration: None,
1493                filter: None,
1494                id: None,
1495                noncurrent_version_expiration: None,
1496                noncurrent_version_transitions: None,
1497                prefix: None,
1498                transitions: None,
1499            }],
1500        };
1501
1502        let err = lc
1503            .validate(&ObjectLockConfiguration::default())
1504            .await
1505            .expect_err("zero-day expiration should be rejected");
1506
1507        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS);
1508    }
1509
1510    #[tokio::test]
1511    async fn validate_rejects_negative_expiration_days() {
1512        let lc = BucketLifecycleConfiguration {
1513            expiry_updated_at: None,
1514            rules: vec![LifecycleRule {
1515                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1516                expiration: Some(LifecycleExpiration {
1517                    days: Some(-1),
1518                    ..Default::default()
1519                }),
1520                abort_incomplete_multipart_upload: None,
1521                del_marker_expiration: None,
1522                filter: None,
1523                id: None,
1524                noncurrent_version_expiration: None,
1525                noncurrent_version_transitions: None,
1526                prefix: None,
1527                transitions: None,
1528            }],
1529        };
1530
1531        let err = lc
1532            .validate(&ObjectLockConfiguration::default())
1533            .await
1534            .expect_err("expected validation error");
1535
1536        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DAYS);
1537    }
1538
1539    #[tokio::test]
1540    async fn validate_accepts_positive_expiration_days() {
1541        let lc = BucketLifecycleConfiguration {
1542            expiry_updated_at: None,
1543            rules: vec![LifecycleRule {
1544                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1545                expiration: Some(LifecycleExpiration {
1546                    days: Some(30),
1547                    ..Default::default()
1548                }),
1549                abort_incomplete_multipart_upload: None,
1550                del_marker_expiration: None,
1551                filter: None,
1552                id: None,
1553                noncurrent_version_expiration: None,
1554                noncurrent_version_transitions: None,
1555                prefix: None,
1556                transitions: None,
1557            }],
1558        };
1559
1560        lc.validate(&ObjectLockConfiguration::default())
1561            .await
1562            .expect("expected validation to pass");
1563    }
1564
1565    #[tokio::test]
1566    async fn validate_accepts_one_day_boundary_values() {
1567        // Pin the exact >= 1 boundary: a value of 1 is the smallest legal positive
1568        // integer and must be accepted for every day-count field tightened for S3
1569        // compatibility. This catches an off-by-one that would reject Days == 1.
1570        let lc = BucketLifecycleConfiguration {
1571            expiry_updated_at: None,
1572            rules: vec![LifecycleRule {
1573                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1574                expiration: Some(LifecycleExpiration {
1575                    days: Some(1),
1576                    ..Default::default()
1577                }),
1578                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1579                    days_after_initiation: Some(1),
1580                }),
1581                del_marker_expiration: None,
1582                filter: None,
1583                id: Some("one-day-boundary".to_string()),
1584                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1585                    noncurrent_days: Some(1),
1586                    newer_noncurrent_versions: None,
1587                }),
1588                noncurrent_version_transitions: None,
1589                prefix: Some("boundary/".to_string()),
1590                transitions: None,
1591            }],
1592        };
1593
1594        lc.validate(&ObjectLockConfiguration::default())
1595            .await
1596            .expect("one-day boundary values should be accepted");
1597    }
1598
1599    #[tokio::test]
1600    async fn has_active_rules_accepts_zero_day_expiration() {
1601        let lc = BucketLifecycleConfiguration {
1602            expiry_updated_at: None,
1603            rules: vec![LifecycleRule {
1604                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1605                expiration: Some(LifecycleExpiration {
1606                    days: Some(0),
1607                    ..Default::default()
1608                }),
1609                abort_incomplete_multipart_upload: None,
1610                del_marker_expiration: None,
1611                filter: None,
1612                id: Some("zero-day-active".to_string()),
1613                noncurrent_version_expiration: None,
1614                noncurrent_version_transitions: None,
1615                prefix: Some("test/".to_string()),
1616                transitions: None,
1617            }],
1618        };
1619
1620        assert!(lc.has_active_rules("test/"));
1621    }
1622
1623    #[test]
1624    fn has_active_rules_requires_valid_del_marker_expiration_days() {
1625        let lifecycle = |days| BucketLifecycleConfiguration {
1626            expiry_updated_at: None,
1627            rules: vec![enabled_rule(None, Some(s3s::dto::DelMarkerExpiration { days }), None)],
1628        };
1629
1630        assert!(lifecycle(Some(1)).has_active_rules(""));
1631        assert!(!lifecycle(Some(0)).has_active_rules(""));
1632        assert!(!lifecycle(None).has_active_rules(""));
1633    }
1634
1635    #[tokio::test]
1636    async fn validate_rejects_zero_noncurrent_expiration_days() {
1637        // S3 compatibility: NoncurrentVersionExpiration.NoncurrentDays must be a positive
1638        // integer (>= 1); AWS rejects 0 with InvalidArgument.
1639        let lc = BucketLifecycleConfiguration {
1640            expiry_updated_at: None,
1641            rules: vec![LifecycleRule {
1642                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1643                expiration: None,
1644                abort_incomplete_multipart_upload: None,
1645                del_marker_expiration: None,
1646                filter: None,
1647                id: None,
1648                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1649                    noncurrent_days: Some(0),
1650                    newer_noncurrent_versions: None,
1651                }),
1652                noncurrent_version_transitions: None,
1653                prefix: None,
1654                transitions: None,
1655            }],
1656        };
1657
1658        let err = lc
1659            .validate(&ObjectLockConfiguration::default())
1660            .await
1661            .expect_err("zero-day noncurrent expiration should be rejected");
1662
1663        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS);
1664    }
1665
1666    #[tokio::test]
1667    async fn validate_rejects_negative_noncurrent_expiration_days() {
1668        let lc = BucketLifecycleConfiguration {
1669            expiry_updated_at: None,
1670            rules: vec![LifecycleRule {
1671                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1672                expiration: None,
1673                abort_incomplete_multipart_upload: None,
1674                del_marker_expiration: None,
1675                filter: None,
1676                id: None,
1677                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
1678                    noncurrent_days: Some(-1),
1679                    newer_noncurrent_versions: None,
1680                }),
1681                noncurrent_version_transitions: None,
1682                prefix: None,
1683                transitions: None,
1684            }],
1685        };
1686
1687        let err = lc
1688            .validate(&ObjectLockConfiguration::default())
1689            .await
1690            .expect_err("expected validation error");
1691
1692        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NONCURRENT_EXPIRATION_DAYS);
1693    }
1694
1695    #[tokio::test]
1696    async fn validate_accepts_abort_incomplete_multipart_upload_only_rule() {
1697        let lc = BucketLifecycleConfiguration {
1698            expiry_updated_at: None,
1699            rules: vec![LifecycleRule {
1700                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1701                expiration: None,
1702                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1703                    days_after_initiation: Some(2),
1704                }),
1705                del_marker_expiration: None,
1706                filter: None,
1707                id: Some("abort-only".to_string()),
1708                noncurrent_version_expiration: None,
1709                noncurrent_version_transitions: None,
1710                prefix: Some("test/".to_string()),
1711                transitions: None,
1712            }],
1713        };
1714
1715        lc.validate(&ObjectLockConfiguration::default())
1716            .await
1717            .expect("expected validation to pass");
1718    }
1719
1720    #[tokio::test]
1721    async fn validate_rejects_zero_abort_incomplete_multipart_upload_days() {
1722        // S3 compatibility: AbortIncompleteMultipartUpload.DaysAfterInitiation must be a
1723        // positive integer (>= 1); AWS rejects 0 with InvalidArgument.
1724        let lc = BucketLifecycleConfiguration {
1725            expiry_updated_at: None,
1726            rules: vec![LifecycleRule {
1727                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1728                expiration: None,
1729                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1730                    days_after_initiation: Some(0),
1731                }),
1732                del_marker_expiration: None,
1733                filter: None,
1734                id: Some("abort-zero".to_string()),
1735                noncurrent_version_expiration: None,
1736                noncurrent_version_transitions: None,
1737                prefix: Some("test/".to_string()),
1738                transitions: None,
1739            }],
1740        };
1741
1742        let err = lc
1743            .validate(&ObjectLockConfiguration::default())
1744            .await
1745            .expect_err("zero-day abort incomplete multipart upload should be rejected");
1746
1747        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1748    }
1749
1750    #[tokio::test]
1751    async fn validate_rejects_missing_abort_incomplete_multipart_upload_days() {
1752        let lc = BucketLifecycleConfiguration {
1753            expiry_updated_at: None,
1754            rules: vec![LifecycleRule {
1755                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1756                expiration: None,
1757                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1758                    days_after_initiation: None,
1759                }),
1760                del_marker_expiration: None,
1761                filter: None,
1762                id: Some("abort-missing".to_string()),
1763                noncurrent_version_expiration: None,
1764                noncurrent_version_transitions: None,
1765                prefix: Some("test/".to_string()),
1766                transitions: None,
1767            }],
1768        };
1769
1770        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1771
1772        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1773    }
1774
1775    #[tokio::test]
1776    async fn validate_rejects_negative_abort_incomplete_multipart_upload_days() {
1777        let lc = BucketLifecycleConfiguration {
1778            expiry_updated_at: None,
1779            rules: vec![LifecycleRule {
1780                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1781                expiration: None,
1782                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1783                    days_after_initiation: Some(-1),
1784                }),
1785                del_marker_expiration: None,
1786                filter: None,
1787                id: Some("abort-negative".to_string()),
1788                noncurrent_version_expiration: None,
1789                noncurrent_version_transitions: None,
1790                prefix: Some("test/".to_string()),
1791                transitions: None,
1792            }],
1793        };
1794
1795        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1796
1797        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_ABORT_INCOMPLETE_MPU_DAYS);
1798    }
1799
1800    #[tokio::test]
1801    #[serial]
1802    async fn abort_incomplete_multipart_upload_due_accepts_zero_days() {
1803        let initiated = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
1804        let lc = BucketLifecycleConfiguration {
1805            expiry_updated_at: None,
1806            rules: vec![LifecycleRule {
1807                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1808                expiration: None,
1809                abort_incomplete_multipart_upload: Some(s3s::dto::AbortIncompleteMultipartUpload {
1810                    days_after_initiation: Some(0),
1811                }),
1812                del_marker_expiration: None,
1813                filter: None,
1814                id: Some("abort-zero".to_string()),
1815                noncurrent_version_expiration: None,
1816                noncurrent_version_transitions: None,
1817                prefix: Some("test/".to_string()),
1818                transitions: None,
1819            }],
1820        };
1821        let opts = ObjectOpts {
1822            name: "test/object".to_string(),
1823            mod_time: Some(initiated),
1824            ..Default::default()
1825        };
1826
1827        let (due, rule_id) = abort_incomplete_multipart_upload_due(&lc, &opts)
1828            .await
1829            .expect("zero-day abort rule should be due");
1830
1831        assert_eq!(rule_id, "abort-zero");
1832        assert_eq!(due, OffsetDateTime::UNIX_EPOCH);
1833    }
1834
1835    #[tokio::test]
1836    async fn validate_rejects_non_midnight_expiration_date() {
1837        let lc = BucketLifecycleConfiguration {
1838            expiry_updated_at: None,
1839            rules: vec![LifecycleRule {
1840                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1841                expiration: Some(LifecycleExpiration {
1842                    date: Some(OffsetDateTime::from_unix_timestamp(20_000_101).unwrap().into()),
1843                    ..Default::default()
1844                }),
1845                abort_incomplete_multipart_upload: None,
1846                del_marker_expiration: None,
1847                filter: None,
1848                id: None,
1849                noncurrent_version_expiration: None,
1850                noncurrent_version_transitions: None,
1851                prefix: None,
1852                transitions: None,
1853            }],
1854        };
1855
1856        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1857
1858        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRATION_DATE_NOT_MIDNIGHT);
1859    }
1860
1861    #[tokio::test]
1862    #[serial]
1863    async fn predict_expiration_selects_closest_expiry_for_put_object() {
1864        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
1865        let lc = BucketLifecycleConfiguration {
1866            expiry_updated_at: None,
1867            rules: vec![
1868                LifecycleRule {
1869                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1870                    expiration: Some(LifecycleExpiration {
1871                        days: Some(30),
1872                        ..Default::default()
1873                    }),
1874                    abort_incomplete_multipart_upload: None,
1875                    del_marker_expiration: None,
1876                    filter: None,
1877                    id: Some("rule-days".to_string()),
1878                    noncurrent_version_expiration: None,
1879                    noncurrent_version_transitions: None,
1880                    prefix: None,
1881                    transitions: None,
1882                },
1883                LifecycleRule {
1884                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1885                    expiration: Some(LifecycleExpiration {
1886                        date: Some((base_time + Duration::days(1)).into()),
1887                        ..Default::default()
1888                    }),
1889                    abort_incomplete_multipart_upload: None,
1890                    del_marker_expiration: None,
1891                    filter: None,
1892                    id: Some("rule-date".to_string()),
1893                    noncurrent_version_expiration: None,
1894                    noncurrent_version_transitions: None,
1895                    prefix: None,
1896                    transitions: None,
1897                },
1898            ],
1899        };
1900        let opts = ObjectOpts {
1901            name: "obj".to_string(),
1902            mod_time: Some(base_time),
1903            is_latest: true,
1904            version_id: None,
1905            ..Default::default()
1906        };
1907
1908        let event = lc.predict_expiration(&opts).await;
1909        let expected = base_time + Duration::days(1);
1910
1911        assert_eq!(event.action, IlmAction::DeleteAction);
1912        assert_eq!(event.rule_id, "rule-date");
1913        assert_eq!(event.due, Some(expected));
1914    }
1915
1916    #[tokio::test]
1917    async fn validate_accepts_multiple_rules_without_ids() {
1918        let lc = BucketLifecycleConfiguration {
1919            expiry_updated_at: None,
1920            rules: vec![
1921                LifecycleRule {
1922                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1923                    expiration: Some(LifecycleExpiration {
1924                        days: Some(30),
1925                        ..Default::default()
1926                    }),
1927                    abort_incomplete_multipart_upload: None,
1928                    del_marker_expiration: None,
1929                    filter: None,
1930                    id: None,
1931                    noncurrent_version_expiration: None,
1932                    noncurrent_version_transitions: None,
1933                    prefix: None,
1934                    transitions: None,
1935                },
1936                LifecycleRule {
1937                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1938                    expiration: Some(LifecycleExpiration {
1939                        days: Some(31),
1940                        ..Default::default()
1941                    }),
1942                    abort_incomplete_multipart_upload: None,
1943                    del_marker_expiration: None,
1944                    filter: None,
1945                    id: None,
1946                    noncurrent_version_expiration: None,
1947                    noncurrent_version_transitions: None,
1948                    prefix: None,
1949                    transitions: None,
1950                },
1951            ],
1952        };
1953
1954        lc.validate(&ObjectLockConfiguration::default())
1955            .await
1956            .expect("expected validation to pass");
1957    }
1958
1959    #[tokio::test]
1960    async fn validate_rejects_rule_id_too_long() {
1961        let lc = BucketLifecycleConfiguration {
1962            expiry_updated_at: None,
1963            rules: vec![LifecycleRule {
1964                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1965                expiration: Some(LifecycleExpiration {
1966                    days: Some(30),
1967                    ..Default::default()
1968                }),
1969                abort_incomplete_multipart_upload: None,
1970                del_marker_expiration: None,
1971                filter: None,
1972                id: Some("a".repeat(256)),
1973                noncurrent_version_expiration: None,
1974                noncurrent_version_transitions: None,
1975                prefix: None,
1976                transitions: None,
1977            }],
1978        };
1979
1980        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
1981
1982        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_RULE_ID_TOO_LONG);
1983    }
1984
1985    #[tokio::test]
1986    async fn validate_rejects_duplicate_rule_ids() {
1987        let lc = BucketLifecycleConfiguration {
1988            expiry_updated_at: None,
1989            rules: vec![
1990                LifecycleRule {
1991                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
1992                    expiration: Some(LifecycleExpiration {
1993                        days: Some(1),
1994                        ..Default::default()
1995                    }),
1996                    abort_incomplete_multipart_upload: None,
1997                    del_marker_expiration: None,
1998                    filter: None,
1999                    id: Some("dup-rule".to_string()),
2000                    noncurrent_version_expiration: None,
2001                    noncurrent_version_transitions: None,
2002                    prefix: None,
2003                    transitions: None,
2004                },
2005                LifecycleRule {
2006                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2007                    expiration: Some(LifecycleExpiration {
2008                        days: Some(2),
2009                        ..Default::default()
2010                    }),
2011                    abort_incomplete_multipart_upload: None,
2012                    filter: None,
2013                    id: Some("dup-rule".to_string()),
2014                    noncurrent_version_expiration: None,
2015                    noncurrent_version_transitions: None,
2016                    prefix: None,
2017                    transitions: None,
2018                    del_marker_expiration: None,
2019                },
2020            ],
2021        };
2022
2023        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2024        assert_eq!(err.to_string(), ERR_LIFECYCLE_DUPLICATE_ID);
2025    }
2026
2027    #[tokio::test]
2028    async fn validate_rejects_transition_without_storage_class() {
2029        let lc = BucketLifecycleConfiguration {
2030            expiry_updated_at: None,
2031            rules: vec![LifecycleRule {
2032                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2033                expiration: None,
2034                abort_incomplete_multipart_upload: None,
2035                del_marker_expiration: None,
2036                filter: None,
2037                id: Some("transition-no-storage".to_string()),
2038                noncurrent_version_expiration: None,
2039                noncurrent_version_transitions: None,
2040                prefix: None,
2041                transitions: Some(vec![Transition {
2042                    days: Some(1),
2043                    date: None,
2044                    storage_class: None,
2045                }]),
2046            }],
2047        };
2048
2049        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2050
2051        assert_eq!(err.to_string(), "ERR_XML_NOT_WELL_FORMED");
2052    }
2053
2054    #[tokio::test]
2055    async fn validate_rejects_transition_without_date_or_days() {
2056        let lc = BucketLifecycleConfiguration {
2057            expiry_updated_at: None,
2058            rules: vec![LifecycleRule {
2059                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2060                expiration: None,
2061                abort_incomplete_multipart_upload: None,
2062                del_marker_expiration: None,
2063                filter: None,
2064                id: Some("transition-no-schedule".to_string()),
2065                noncurrent_version_expiration: None,
2066                noncurrent_version_transitions: None,
2067                prefix: None,
2068                transitions: Some(vec![Transition {
2069                    days: None,
2070                    date: None,
2071                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
2072                }]),
2073            }],
2074        };
2075
2076        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2077
2078        assert!(err.to_string().contains("Exactly one of Days"));
2079    }
2080
2081    #[tokio::test]
2082    async fn validate_rejects_noncurrent_transition_without_days() {
2083        let lc = BucketLifecycleConfiguration {
2084            expiry_updated_at: None,
2085            rules: vec![LifecycleRule {
2086                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2087                expiration: None,
2088                abort_incomplete_multipart_upload: None,
2089                del_marker_expiration: None,
2090                filter: None,
2091                id: Some("noncurrent-transition-no-days".to_string()),
2092                noncurrent_version_expiration: None,
2093                noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2094                    noncurrent_days: None,
2095                    newer_noncurrent_versions: None,
2096                    storage_class: Some(TransitionStorageClass::from_static("COLD")),
2097                }]),
2098                prefix: None,
2099                transitions: None,
2100            }],
2101        };
2102
2103        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2104
2105        assert!(err.to_string().contains("Exactly one of Days"));
2106    }
2107
2108    #[tokio::test]
2109    #[serial]
2110    async fn empty_transition_vectors_are_not_active_or_due() {
2111        let lc = BucketLifecycleConfiguration {
2112            expiry_updated_at: None,
2113            rules: vec![LifecycleRule {
2114                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2115                expiration: None,
2116                abort_incomplete_multipart_upload: None,
2117                del_marker_expiration: None,
2118                filter: None,
2119                id: Some("empty-transition".to_string()),
2120                noncurrent_version_expiration: None,
2121                noncurrent_version_transitions: Some(vec![]),
2122                prefix: None,
2123                transitions: Some(vec![]),
2124            }],
2125        };
2126        let opts = ObjectOpts {
2127            name: "obj".to_string(),
2128            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2129            is_latest: true,
2130            ..Default::default()
2131        };
2132
2133        assert!(!lc.has_transition().await);
2134        assert!(!lc.has_active_rules("obj"));
2135        assert_eq!(lc.eval_inner(&opts, OffsetDateTime::now_utc(), 0).await.action, IlmAction::NoneAction);
2136    }
2137
2138    #[tokio::test]
2139    #[serial]
2140    async fn eval_inner_expires_latest_object_after_days_due() {
2141        let base_time = datetime!(2025-01-15 10:30:45 UTC);
2142        let lc = BucketLifecycleConfiguration {
2143            expiry_updated_at: None,
2144            rules: vec![LifecycleRule {
2145                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2146                expiration: Some(LifecycleExpiration {
2147                    days: Some(1),
2148                    ..Default::default()
2149                }),
2150                abort_incomplete_multipart_upload: None,
2151                del_marker_expiration: None,
2152                filter: None,
2153                id: Some("expire-days".to_string()),
2154                noncurrent_version_expiration: None,
2155                noncurrent_version_transitions: None,
2156                prefix: None,
2157                transitions: None,
2158            }],
2159        };
2160
2161        let opts = ObjectOpts {
2162            name: "obj".to_string(),
2163            mod_time: Some(base_time),
2164            is_latest: true,
2165            ..Default::default()
2166        };
2167        let event = lc.eval_inner(&opts, datetime!(2025-01-17 00:00:00 UTC), 0).await;
2168
2169        assert_eq!(event.action, IlmAction::DeleteAction);
2170        assert_eq!(event.rule_id, "expire-days");
2171        assert_eq!(event.due, Some(datetime!(2025-01-17 00:00:00 UTC)));
2172    }
2173
2174    #[tokio::test]
2175    #[serial]
2176    async fn eval_inner_keeps_latest_object_before_days_due() {
2177        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2178        let lc = BucketLifecycleConfiguration {
2179            expiry_updated_at: None,
2180            rules: vec![LifecycleRule {
2181                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2182                expiration: Some(LifecycleExpiration {
2183                    days: Some(2),
2184                    ..Default::default()
2185                }),
2186                abort_incomplete_multipart_upload: None,
2187                del_marker_expiration: None,
2188                filter: None,
2189                id: Some("expire-days".to_string()),
2190                noncurrent_version_expiration: None,
2191                noncurrent_version_transitions: None,
2192                prefix: None,
2193                transitions: None,
2194            }],
2195        };
2196
2197        let opts = ObjectOpts {
2198            name: "obj".to_string(),
2199            mod_time: Some(base_time),
2200            is_latest: true,
2201            ..Default::default()
2202        };
2203        let event = lc.eval_inner(&opts, base_time + Duration::hours(12), 0).await;
2204
2205        assert_eq!(event.action, IlmAction::NoneAction);
2206    }
2207
2208    #[tokio::test]
2209    #[serial]
2210    async fn eval_inner_transitions_latest_object_after_days_due() {
2211        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2212        let lc = BucketLifecycleConfiguration {
2213            expiry_updated_at: None,
2214            rules: vec![LifecycleRule {
2215                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2216                expiration: None,
2217                abort_incomplete_multipart_upload: None,
2218                del_marker_expiration: None,
2219                filter: None,
2220                id: Some("transition-days".to_string()),
2221                noncurrent_version_expiration: None,
2222                noncurrent_version_transitions: None,
2223                prefix: None,
2224                transitions: Some(vec![Transition {
2225                    days: Some(1),
2226                    date: None,
2227                    storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2228                }]),
2229            }],
2230        };
2231
2232        let opts = ObjectOpts {
2233            name: "obj".to_string(),
2234            mod_time: Some(base_time),
2235            is_latest: true,
2236            transition_status: "".to_string(),
2237            ..Default::default()
2238        };
2239        let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2240
2241        assert_eq!(event.action, IlmAction::TransitionAction);
2242        assert_eq!(event.rule_id, "transition-days");
2243        assert_eq!(event.storage_class, "COLDTIER44");
2244    }
2245
2246    #[tokio::test]
2247    #[serial]
2248    async fn eval_inner_transitions_latest_object_after_date_due() {
2249        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2250        let transition_date = base_time - Duration::days(1);
2251        let lc = BucketLifecycleConfiguration {
2252            expiry_updated_at: None,
2253            rules: vec![LifecycleRule {
2254                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2255                expiration: None,
2256                abort_incomplete_multipart_upload: None,
2257                del_marker_expiration: None,
2258                filter: None,
2259                id: Some("transition-date".to_string()),
2260                noncurrent_version_expiration: None,
2261                noncurrent_version_transitions: None,
2262                prefix: None,
2263                transitions: Some(vec![Transition {
2264                    days: None,
2265                    date: Some(transition_date.into()),
2266                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
2267                }]),
2268            }],
2269        };
2270
2271        let opts = ObjectOpts {
2272            name: "obj".to_string(),
2273            mod_time: Some(base_time),
2274            is_latest: true,
2275            transition_status: "".to_string(),
2276            ..Default::default()
2277        };
2278        let event = lc.eval_inner(&opts, base_time + Duration::days(1), 0).await;
2279
2280        assert_eq!(event.action, IlmAction::TransitionAction);
2281        assert_eq!(event.rule_id, "transition-date");
2282        assert_eq!(event.storage_class, "WARM");
2283        assert_eq!(event.due, Some(transition_date));
2284    }
2285
2286    #[tokio::test]
2287    #[serial]
2288    async fn eval_inner_selects_earliest_due_among_multiple_past_due_events() {
2289        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2290        // Two enabled rules both yield a past-due DeleteAction and a third yields a
2291        // past-due TransitionAction. The rule with the shortest expiration (earliest
2292        // `due`) must win deterministically.
2293        let lc = BucketLifecycleConfiguration {
2294            expiry_updated_at: None,
2295            rules: vec![
2296                LifecycleRule {
2297                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2298                    expiration: Some(LifecycleExpiration {
2299                        days: Some(5),
2300                        ..Default::default()
2301                    }),
2302                    abort_incomplete_multipart_upload: None,
2303                    del_marker_expiration: None,
2304                    filter: None,
2305                    id: Some("delete-late".to_string()),
2306                    noncurrent_version_expiration: None,
2307                    noncurrent_version_transitions: None,
2308                    prefix: None,
2309                    transitions: None,
2310                },
2311                LifecycleRule {
2312                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2313                    expiration: Some(LifecycleExpiration {
2314                        days: Some(1),
2315                        ..Default::default()
2316                    }),
2317                    abort_incomplete_multipart_upload: None,
2318                    del_marker_expiration: None,
2319                    filter: None,
2320                    id: Some("delete-early".to_string()),
2321                    noncurrent_version_expiration: None,
2322                    noncurrent_version_transitions: None,
2323                    prefix: None,
2324                    transitions: None,
2325                },
2326                LifecycleRule {
2327                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2328                    expiration: None,
2329                    abort_incomplete_multipart_upload: None,
2330                    del_marker_expiration: None,
2331                    filter: None,
2332                    id: Some("transition-mid".to_string()),
2333                    noncurrent_version_expiration: None,
2334                    noncurrent_version_transitions: None,
2335                    prefix: None,
2336                    transitions: Some(vec![Transition {
2337                        days: Some(3),
2338                        date: None,
2339                        storage_class: Some(TransitionStorageClass::from_static("COLDTIER")),
2340                    }]),
2341                },
2342            ],
2343        };
2344
2345        let opts = ObjectOpts {
2346            name: "obj".to_string(),
2347            mod_time: Some(base_time),
2348            is_latest: true,
2349            transition_status: "".to_string(),
2350            ..Default::default()
2351        };
2352        let event = lc.eval_inner(&opts, base_time + Duration::days(10), 0).await;
2353
2354        assert_eq!(event.action, IlmAction::DeleteAction);
2355        assert_eq!(event.rule_id, "delete-early");
2356    }
2357
2358    #[tokio::test]
2359    #[serial]
2360    async fn eval_inner_does_not_panic_on_many_equal_due_events() {
2361        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2362        // Many enabled rules that all yield a DeleteAction with an identical `due`.
2363        // The previous hand-written comparator was not a strict weak ordering and
2364        // panicked on the repository toolchain; the total-order selection must not
2365        // panic and must return a deterministic winner (the first rule).
2366        let rules: Vec<LifecycleRule> = (0..25)
2367            .map(|i| LifecycleRule {
2368                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2369                expiration: Some(LifecycleExpiration {
2370                    days: Some(1),
2371                    ..Default::default()
2372                }),
2373                abort_incomplete_multipart_upload: None,
2374                del_marker_expiration: None,
2375                filter: None,
2376                id: Some(format!("rule-{i:02}")),
2377                noncurrent_version_expiration: None,
2378                noncurrent_version_transitions: None,
2379                prefix: None,
2380                transitions: None,
2381            })
2382            .collect();
2383        let lc = BucketLifecycleConfiguration {
2384            expiry_updated_at: None,
2385            rules,
2386        };
2387
2388        let opts = ObjectOpts {
2389            name: "obj".to_string(),
2390            mod_time: Some(base_time),
2391            is_latest: true,
2392            ..Default::default()
2393        };
2394        let event = lc.eval_inner(&opts, base_time + Duration::days(10), 0).await;
2395
2396        assert_eq!(event.action, IlmAction::DeleteAction);
2397        assert_eq!(event.rule_id, "rule-00");
2398    }
2399
2400    #[tokio::test]
2401    #[serial]
2402    async fn eval_inner_expires_noncurrent_version_after_due() {
2403        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2404        let lc = BucketLifecycleConfiguration {
2405            expiry_updated_at: None,
2406            rules: vec![LifecycleRule {
2407                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2408                expiration: None,
2409                abort_incomplete_multipart_upload: None,
2410                del_marker_expiration: None,
2411                filter: None,
2412                id: Some("noncurrent-expire".to_string()),
2413                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2414                    noncurrent_days: Some(1),
2415                    newer_noncurrent_versions: None,
2416                }),
2417                noncurrent_version_transitions: None,
2418                prefix: None,
2419                transitions: None,
2420            }],
2421        };
2422
2423        let opts = ObjectOpts {
2424            name: "obj".to_string(),
2425            mod_time: Some(base_time),
2426            successor_mod_time: Some(base_time),
2427            is_latest: false,
2428            version_id: Some(Uuid::new_v4()),
2429            ..Default::default()
2430        };
2431        let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2432
2433        assert_eq!(event.action, IlmAction::DeleteVersionAction);
2434        assert_eq!(event.rule_id, "noncurrent-expire");
2435        assert_eq!(event.due, Some(expected_expiry_time(base_time, 1)));
2436    }
2437
2438    #[tokio::test]
2439    #[serial]
2440    async fn eval_inner_skips_noncurrent_expiration_without_successor() {
2441        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("valid fixed test timestamp");
2442        let lc = BucketLifecycleConfiguration {
2443            expiry_updated_at: None,
2444            rules: vec![LifecycleRule {
2445                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2446                expiration: None,
2447                abort_incomplete_multipart_upload: None,
2448                del_marker_expiration: None,
2449                filter: None,
2450                id: Some("noncurrent-expire".to_string()),
2451                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2452                    noncurrent_days: Some(1),
2453                    newer_noncurrent_versions: None,
2454                }),
2455                noncurrent_version_transitions: None,
2456                prefix: None,
2457                transitions: None,
2458            }],
2459        };
2460
2461        let opts = ObjectOpts {
2462            name: "obj".to_string(),
2463            mod_time: Some(base_time),
2464            successor_mod_time: None,
2465            is_latest: false,
2466            version_id: Some(Uuid::new_v4()),
2467            ..Default::default()
2468        };
2469        let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2470
2471        assert_eq!(event.action, IlmAction::NoneAction);
2472    }
2473
2474    #[tokio::test]
2475    #[serial]
2476    async fn eval_inner_missing_successor_does_not_skip_noncurrent_transition() {
2477        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("valid fixed test timestamp");
2478        let lc = BucketLifecycleConfiguration {
2479            expiry_updated_at: None,
2480            rules: vec![LifecycleRule {
2481                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2482                expiration: None,
2483                abort_incomplete_multipart_upload: None,
2484                del_marker_expiration: None,
2485                filter: None,
2486                id: Some("noncurrent-expire-and-transition".to_string()),
2487                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2488                    noncurrent_days: Some(1),
2489                    newer_noncurrent_versions: None,
2490                }),
2491                noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2492                    noncurrent_days: Some(1),
2493                    newer_noncurrent_versions: None,
2494                    storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2495                }]),
2496                prefix: None,
2497                transitions: None,
2498            }],
2499        };
2500
2501        let opts = ObjectOpts {
2502            name: "obj".to_string(),
2503            mod_time: Some(base_time),
2504            successor_mod_time: None,
2505            is_latest: false,
2506            transition_status: "".to_string(),
2507            version_id: Some(Uuid::new_v4()),
2508            ..Default::default()
2509        };
2510        let event = lc.eval_inner(&opts, datetime!(2100-01-01 00:00:00 UTC), 0).await;
2511
2512        assert_eq!(event.action, IlmAction::TransitionVersionAction);
2513        assert_eq!(event.rule_id, "noncurrent-expire-and-transition");
2514        assert_eq!(event.storage_class, "COLDTIER44");
2515    }
2516
2517    #[tokio::test]
2518    #[serial]
2519    async fn eval_inner_noncurrent_expiration_one_day_respects_due_boundary() {
2520        let successor_time = datetime!(2025-06-15 12:00:00 UTC);
2521        let due = expected_expiry_time(successor_time, 1);
2522        let lc = BucketLifecycleConfiguration {
2523            expiry_updated_at: None,
2524            rules: vec![LifecycleRule {
2525                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2526                expiration: None,
2527                abort_incomplete_multipart_upload: None,
2528                del_marker_expiration: None,
2529                filter: None,
2530                id: Some("noncurrent-one-day".to_string()),
2531                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2532                    noncurrent_days: Some(1),
2533                    newer_noncurrent_versions: None,
2534                }),
2535                noncurrent_version_transitions: None,
2536                prefix: None,
2537                transitions: None,
2538            }],
2539        };
2540
2541        let opts = ObjectOpts {
2542            name: "obj".to_string(),
2543            mod_time: Some(successor_time - Duration::seconds(1)),
2544            successor_mod_time: Some(successor_time),
2545            is_latest: false,
2546            version_id: Some(Uuid::new_v4()),
2547            ..Default::default()
2548        };
2549
2550        let before_due = lc.eval_inner(&opts, due - Duration::seconds(1), 0).await;
2551        let at_due = lc.eval_inner(&opts, due, 0).await;
2552
2553        assert_eq!(before_due.action, IlmAction::NoneAction);
2554        assert_eq!(at_due.action, IlmAction::DeleteVersionAction);
2555        assert_eq!(at_due.rule_id, "noncurrent-one-day");
2556        assert_eq!(at_due.due, Some(due));
2557    }
2558
2559    #[tokio::test]
2560    #[serial]
2561    async fn eval_inner_expires_noncurrent_version_immediately_when_zero_days() {
2562        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2563        let lc = BucketLifecycleConfiguration {
2564            expiry_updated_at: None,
2565            rules: vec![LifecycleRule {
2566                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2567                expiration: None,
2568                abort_incomplete_multipart_upload: None,
2569                del_marker_expiration: None,
2570                filter: None,
2571                id: Some("noncurrent-expire-immediate".to_string()),
2572                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2573                    noncurrent_days: Some(0),
2574                    newer_noncurrent_versions: None,
2575                }),
2576                noncurrent_version_transitions: None,
2577                prefix: None,
2578                transitions: None,
2579            }],
2580        };
2581
2582        let opts = ObjectOpts {
2583            name: "obj".to_string(),
2584            mod_time: Some(base_time),
2585            successor_mod_time: Some(base_time),
2586            is_latest: false,
2587            version_id: Some(Uuid::new_v4()),
2588            ..Default::default()
2589        };
2590        let event = lc.eval_inner(&opts, base_time, 0).await;
2591
2592        assert_eq!(event.action, IlmAction::DeleteVersionAction);
2593        assert_eq!(event.rule_id, "noncurrent-expire-immediate");
2594        assert_eq!(event.due, Some(expected_expiry_time(base_time, 0)));
2595    }
2596
2597    #[tokio::test]
2598    #[serial]
2599    async fn eval_inner_transitions_noncurrent_version_after_due() {
2600        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2601        let lc = BucketLifecycleConfiguration {
2602            expiry_updated_at: None,
2603            rules: vec![LifecycleRule {
2604                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2605                expiration: None,
2606                abort_incomplete_multipart_upload: None,
2607                del_marker_expiration: None,
2608                filter: None,
2609                id: Some("noncurrent-transition".to_string()),
2610                noncurrent_version_expiration: None,
2611                noncurrent_version_transitions: Some(vec![NoncurrentVersionTransition {
2612                    noncurrent_days: Some(1),
2613                    newer_noncurrent_versions: None,
2614                    storage_class: Some(TransitionStorageClass::from_static("COLDTIER44")),
2615                }]),
2616                prefix: None,
2617                transitions: None,
2618            }],
2619        };
2620
2621        let opts = ObjectOpts {
2622            name: "obj".to_string(),
2623            mod_time: Some(base_time),
2624            successor_mod_time: Some(base_time),
2625            is_latest: false,
2626            transition_status: "".to_string(),
2627            version_id: Some(Uuid::new_v4()),
2628            ..Default::default()
2629        };
2630        let event = lc.eval_inner(&opts, base_time + Duration::days(2), 0).await;
2631
2632        assert_eq!(event.action, IlmAction::TransitionVersionAction);
2633        assert_eq!(event.rule_id, "noncurrent-transition");
2634        assert_eq!(event.storage_class, "COLDTIER44");
2635    }
2636
2637    #[tokio::test]
2638    async fn noncurrent_versions_expiration_limit_returns_configured_limits() {
2639        let lc = Arc::new(BucketLifecycleConfiguration {
2640            expiry_updated_at: None,
2641            rules: vec![LifecycleRule {
2642                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2643                expiration: None,
2644                abort_incomplete_multipart_upload: None,
2645                del_marker_expiration: None,
2646                filter: None,
2647                id: Some("noncurrent-limit".to_string()),
2648                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2649                    noncurrent_days: Some(7),
2650                    newer_noncurrent_versions: Some(3),
2651                }),
2652                noncurrent_version_transitions: None,
2653                prefix: None,
2654                transitions: None,
2655            }],
2656        });
2657
2658        let opts = ObjectOpts {
2659            name: "obj".to_string(),
2660            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2661            is_latest: false,
2662            version_id: Some(Uuid::new_v4()),
2663            ..Default::default()
2664        };
2665        let event = lc.noncurrent_versions_expiration_limit(&opts).await;
2666
2667        assert_eq!(event.action, IlmAction::DeleteVersionAction);
2668        assert_eq!(event.rule_id, "noncurrent-limit");
2669        assert_eq!(event.noncurrent_days, 7);
2670        assert_eq!(event.newer_noncurrent_versions, 3);
2671    }
2672
2673    #[tokio::test]
2674    #[serial]
2675    async fn evaluator_honors_newer_noncurrent_versions_retention_count() {
2676        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2677        let lc = Arc::new(BucketLifecycleConfiguration {
2678            expiry_updated_at: None,
2679            rules: vec![LifecycleRule {
2680                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2681                expiration: None,
2682                abort_incomplete_multipart_upload: None,
2683                del_marker_expiration: None,
2684                filter: None,
2685                id: Some("retain-two-noncurrent".to_string()),
2686                noncurrent_version_expiration: Some(s3s::dto::NoncurrentVersionExpiration {
2687                    noncurrent_days: Some(1),
2688                    newer_noncurrent_versions: Some(2),
2689                }),
2690                noncurrent_version_transitions: None,
2691                prefix: None,
2692                transitions: None,
2693            }],
2694        });
2695        let mut objs = vec![ObjectOpts {
2696            name: "obj".to_string(),
2697            mod_time: Some(base_time + Duration::days(4)),
2698            successor_mod_time: None,
2699            is_latest: true,
2700            version_id: Some(Uuid::new_v4()),
2701            num_versions: 5,
2702            ..Default::default()
2703        }];
2704        for days_ago in (0..4).rev() {
2705            objs.push(ObjectOpts {
2706                name: "obj".to_string(),
2707                mod_time: Some(base_time + Duration::days(days_ago)),
2708                successor_mod_time: Some(base_time + Duration::days(days_ago + 1)),
2709                is_latest: false,
2710                version_id: Some(Uuid::new_v4()),
2711                num_versions: 5,
2712                ..Default::default()
2713            });
2714        }
2715
2716        let events = crate::evaluator::Evaluator::new(lc)
2717            .eval(&objs)
2718            .await
2719            .expect("version group should evaluate");
2720
2721        assert_eq!(events[1].action, IlmAction::NoneAction);
2722        assert_eq!(events[2].action, IlmAction::NoneAction);
2723        assert_eq!(events[3].action, IlmAction::DeleteVersionAction);
2724        assert_eq!(events[4].action, IlmAction::DeleteVersionAction);
2725    }
2726
2727    #[tokio::test]
2728    async fn validate_rejects_invalid_status_case_sensitive() {
2729        let lc = BucketLifecycleConfiguration {
2730            expiry_updated_at: None,
2731            rules: vec![LifecycleRule {
2732                status: ExpirationStatus::from_static("enabled"),
2733                expiration: Some(LifecycleExpiration {
2734                    days: Some(30),
2735                    ..Default::default()
2736                }),
2737                abort_incomplete_multipart_upload: None,
2738                del_marker_expiration: None,
2739                filter: None,
2740                id: None,
2741                noncurrent_version_expiration: None,
2742                noncurrent_version_transitions: None,
2743                prefix: None,
2744                transitions: None,
2745            }],
2746        };
2747
2748        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
2749
2750        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_RULE_STATUS);
2751    }
2752
2753    #[tokio::test]
2754    async fn filter_rules_respects_filter_prefix() {
2755        let filter = LifecycleRuleFilter {
2756            prefix: Some("prefix".to_string()),
2757            ..Default::default()
2758        };
2759        let lc = BucketLifecycleConfiguration {
2760            expiry_updated_at: None,
2761            rules: vec![LifecycleRule {
2762                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2763                expiration: Some(LifecycleExpiration {
2764                    days: Some(30),
2765                    ..Default::default()
2766                }),
2767                abort_incomplete_multipart_upload: None,
2768                filter: Some(filter),
2769                id: Some("rule".to_string()),
2770                noncurrent_version_expiration: None,
2771                noncurrent_version_transitions: None,
2772                prefix: None,
2773                transitions: None,
2774                del_marker_expiration: None,
2775            }],
2776        };
2777
2778        let match_obj = ObjectOpts {
2779            name: "prefix/file".to_string(),
2780            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2781            is_latest: true,
2782            ..Default::default()
2783        };
2784        let matched = lc.filter_rules(&match_obj).await.unwrap();
2785        assert_eq!(matched.len(), 1);
2786
2787        let non_match_obj = ObjectOpts {
2788            name: "other/file".to_string(),
2789            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2790            is_latest: true,
2791            ..Default::default()
2792        };
2793        let not_matched = lc.filter_rules(&non_match_obj).await.unwrap();
2794        assert_eq!(not_matched.len(), 0);
2795    }
2796
2797    #[tokio::test]
2798    async fn filter_rules_respects_filter_and_prefix() {
2799        let and = s3s::dto::LifecycleRuleAndOperator {
2800            prefix: Some("prefix".to_string()),
2801            ..Default::default()
2802        };
2803        let filter = LifecycleRuleFilter {
2804            and: Some(and),
2805            ..Default::default()
2806        };
2807
2808        let lc = BucketLifecycleConfiguration {
2809            expiry_updated_at: None,
2810            rules: vec![LifecycleRule {
2811                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2812                expiration: Some(LifecycleExpiration {
2813                    days: Some(30),
2814                    ..Default::default()
2815                }),
2816                abort_incomplete_multipart_upload: None,
2817                filter: Some(filter),
2818                id: Some("rule-and-prefix".to_string()),
2819                noncurrent_version_expiration: None,
2820                noncurrent_version_transitions: None,
2821                prefix: None,
2822                transitions: None,
2823                del_marker_expiration: None,
2824            }],
2825        };
2826
2827        let match_obj = ObjectOpts {
2828            name: "prefix/file".to_string(),
2829            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2830            is_latest: true,
2831            ..Default::default()
2832        };
2833        let matched = lc.filter_rules(&match_obj).await.unwrap();
2834        assert_eq!(matched.len(), 1);
2835
2836        let non_match_obj = ObjectOpts {
2837            name: "other/file".to_string(),
2838            mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2839            is_latest: true,
2840            ..Default::default()
2841        };
2842        let not_matched = lc.filter_rules(&non_match_obj).await.unwrap();
2843        assert_eq!(not_matched.len(), 0);
2844    }
2845
2846    #[tokio::test]
2847    async fn filter_rules_respects_filter_tag() {
2848        let filter = LifecycleRuleFilter {
2849            tag: Some(s3s::dto::Tag {
2850                key: Some("env".to_string()),
2851                value: Some("prod".to_string()),
2852            }),
2853            ..Default::default()
2854        };
2855        let lc = BucketLifecycleConfiguration {
2856            expiry_updated_at: None,
2857            rules: vec![LifecycleRule {
2858                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2859                expiration: Some(LifecycleExpiration {
2860                    days: Some(30),
2861                    ..Default::default()
2862                }),
2863                abort_incomplete_multipart_upload: None,
2864                filter: Some(filter),
2865                id: Some("rule-tag".to_string()),
2866                noncurrent_version_expiration: None,
2867                noncurrent_version_transitions: None,
2868                prefix: None,
2869                transitions: None,
2870                del_marker_expiration: None,
2871            }],
2872        };
2873
2874        let matched = lc
2875            .filter_rules(&ObjectOpts {
2876                name: "obj".to_string(),
2877                user_tags: "env=prod&team=storage".to_string(),
2878                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2879                is_latest: true,
2880                ..Default::default()
2881            })
2882            .await
2883            .unwrap();
2884        assert_eq!(matched.len(), 1);
2885
2886        let not_matched = lc
2887            .filter_rules(&ObjectOpts {
2888                name: "obj".to_string(),
2889                user_tags: "env=dev&team=storage".to_string(),
2890                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2891                is_latest: true,
2892                ..Default::default()
2893            })
2894            .await
2895            .unwrap();
2896        assert_eq!(not_matched.len(), 0);
2897    }
2898
2899    #[tokio::test]
2900    async fn filter_rules_respects_filter_and_tags() {
2901        let filter = LifecycleRuleFilter {
2902            and: Some(s3s::dto::LifecycleRuleAndOperator {
2903                tags: Some(vec![
2904                    s3s::dto::Tag {
2905                        key: Some("env".to_string()),
2906                        value: Some("prod".to_string()),
2907                    },
2908                    s3s::dto::Tag {
2909                        key: Some("team".to_string()),
2910                        value: Some("storage".to_string()),
2911                    },
2912                ]),
2913                ..Default::default()
2914            }),
2915            ..Default::default()
2916        };
2917
2918        let lc = BucketLifecycleConfiguration {
2919            expiry_updated_at: None,
2920            rules: vec![LifecycleRule {
2921                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2922                expiration: Some(LifecycleExpiration {
2923                    days: Some(30),
2924                    ..Default::default()
2925                }),
2926                abort_incomplete_multipart_upload: None,
2927                filter: Some(filter),
2928                id: Some("rule-and-tags".to_string()),
2929                noncurrent_version_expiration: None,
2930                noncurrent_version_transitions: None,
2931                prefix: None,
2932                transitions: None,
2933                del_marker_expiration: None,
2934            }],
2935        };
2936
2937        let matched = lc
2938            .filter_rules(&ObjectOpts {
2939                name: "obj".to_string(),
2940                user_tags: "env=prod&team=storage".to_string(),
2941                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2942                is_latest: true,
2943                ..Default::default()
2944            })
2945            .await
2946            .unwrap();
2947        assert_eq!(matched.len(), 1);
2948
2949        let not_matched = lc
2950            .filter_rules(&ObjectOpts {
2951                name: "obj".to_string(),
2952                user_tags: "env=prod&team=platform".to_string(),
2953                mod_time: Some(OffsetDateTime::from_unix_timestamp(1_000_000).unwrap()),
2954                is_latest: true,
2955                ..Default::default()
2956            })
2957            .await
2958            .unwrap();
2959        assert_eq!(not_matched.len(), 0);
2960    }
2961
2962    #[tokio::test]
2963    #[serial]
2964    async fn expired_object_delete_marker_ignores_marker_with_noncurrent_versions_present() {
2965        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
2966        let lc = BucketLifecycleConfiguration {
2967            expiry_updated_at: None,
2968            rules: vec![LifecycleRule {
2969                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
2970                expiration: Some(LifecycleExpiration {
2971                    expired_object_delete_marker: Some(true),
2972                    ..Default::default()
2973                }),
2974                abort_incomplete_multipart_upload: None,
2975                filter: None,
2976                id: Some("rule-expired-del-marker".to_string()),
2977                noncurrent_version_expiration: None,
2978                noncurrent_version_transitions: None,
2979                prefix: None,
2980                transitions: None,
2981                del_marker_expiration: None,
2982            }],
2983        };
2984
2985        let opts = ObjectOpts {
2986            name: "obj".to_string(),
2987            mod_time: Some(base_time),
2988            is_latest: true,
2989            delete_marker: true,
2990            num_versions: 2,
2991            version_id: Some(Uuid::new_v4()),
2992            ..Default::default()
2993        };
2994
2995        let now = base_time + Duration::days(2);
2996        let event = lc.eval_inner(&opts, now, 0).await;
2997        assert_eq!(event.action, IlmAction::NoneAction);
2998        assert_eq!(event.due, Some(OffsetDateTime::UNIX_EPOCH));
2999    }
3000
3001    #[tokio::test]
3002    async fn expired_object_delete_marker_ignores_unknown_version_count() {
3003        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3004        let lc = BucketLifecycleConfiguration {
3005            expiry_updated_at: None,
3006            rules: vec![LifecycleRule {
3007                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3008                expiration: Some(LifecycleExpiration {
3009                    expired_object_delete_marker: Some(true),
3010                    ..Default::default()
3011                }),
3012                abort_incomplete_multipart_upload: None,
3013                filter: None,
3014                id: Some("rule-expired-del-marker".to_string()),
3015                noncurrent_version_expiration: None,
3016                noncurrent_version_transitions: None,
3017                prefix: None,
3018                transitions: None,
3019                del_marker_expiration: None,
3020            }],
3021        };
3022
3023        let opts = ObjectOpts {
3024            name: "obj".to_string(),
3025            mod_time: Some(base_time),
3026            is_latest: true,
3027            delete_marker: true,
3028            num_versions: 0,
3029            version_id: Some(Uuid::new_v4()),
3030            ..Default::default()
3031        };
3032
3033        let now = base_time + Duration::days(2);
3034        let event = lc.eval_inner(&opts, now, 0).await;
3035        assert_eq!(event.action, IlmAction::NoneAction);
3036        assert_eq!(event.due, Some(OffsetDateTime::UNIX_EPOCH));
3037    }
3038
3039    #[tokio::test]
3040    #[serial]
3041    async fn expired_object_delete_marker_deletes_only_delete_marker_immediately() {
3042        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3043        let lc = BucketLifecycleConfiguration {
3044            expiry_updated_at: None,
3045            rules: vec![LifecycleRule {
3046                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3047                expiration: Some(LifecycleExpiration {
3048                    expired_object_delete_marker: Some(true),
3049                    ..Default::default()
3050                }),
3051                abort_incomplete_multipart_upload: None,
3052                filter: None,
3053                id: Some("rule-expired-del-marker".to_string()),
3054                noncurrent_version_expiration: None,
3055                noncurrent_version_transitions: None,
3056                prefix: None,
3057                transitions: None,
3058                del_marker_expiration: None,
3059            }],
3060        };
3061
3062        let opts = ObjectOpts {
3063            name: "obj".to_string(),
3064            mod_time: Some(base_time),
3065            is_latest: true,
3066            delete_marker: true,
3067            num_versions: 1,
3068            version_id: Some(Uuid::new_v4()),
3069            ..Default::default()
3070        };
3071
3072        let now = base_time + Duration::days(2);
3073        let event = lc.eval_inner(&opts, now, 0).await;
3074
3075        assert_eq!(event.action, IlmAction::DeleteVersionAction);
3076        assert_eq!(event.due, Some(now));
3077    }
3078
3079    #[tokio::test]
3080    async fn expired_object_delete_marker_without_date_or_days_deletes_immediately() {
3081        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3082        let lc = BucketLifecycleConfiguration {
3083            expiry_updated_at: None,
3084            rules: vec![LifecycleRule {
3085                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3086                expiration: Some(LifecycleExpiration {
3087                    expired_object_delete_marker: Some(true),
3088                    ..Default::default()
3089                }),
3090                abort_incomplete_multipart_upload: None,
3091                filter: None,
3092                id: Some("rule-expired-del-marker-immediate".to_string()),
3093                noncurrent_version_expiration: None,
3094                noncurrent_version_transitions: None,
3095                prefix: None,
3096                transitions: None,
3097                del_marker_expiration: None,
3098            }],
3099        };
3100
3101        let opts = ObjectOpts {
3102            name: "obj".to_string(),
3103            mod_time: Some(base_time),
3104            is_latest: true,
3105            delete_marker: true,
3106            num_versions: 1,
3107            version_id: Some(Uuid::new_v4()),
3108            ..Default::default()
3109        };
3110
3111        let now = base_time + Duration::days(2);
3112        let event = lc.eval_inner(&opts, now, 0).await;
3113        assert_eq!(event.action, IlmAction::DeleteVersionAction);
3114        assert_eq!(event.due, Some(now));
3115    }
3116
3117    #[tokio::test]
3118    #[serial]
3119    async fn expiration_days_deletes_only_expired_delete_marker_when_due() {
3120        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3121        let lc = BucketLifecycleConfiguration {
3122            expiry_updated_at: None,
3123            rules: vec![LifecycleRule {
3124                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3125                expiration: Some(LifecycleExpiration {
3126                    days: Some(3),
3127                    ..Default::default()
3128                }),
3129                abort_incomplete_multipart_upload: None,
3130                filter: None,
3131                id: Some("rule-expiration-days".to_string()),
3132                noncurrent_version_expiration: None,
3133                noncurrent_version_transitions: None,
3134                prefix: None,
3135                transitions: None,
3136                del_marker_expiration: None,
3137            }],
3138        };
3139        let only_delete_marker = ObjectOpts {
3140            name: "obj".to_string(),
3141            mod_time: Some(base_time),
3142            is_latest: true,
3143            delete_marker: true,
3144            num_versions: 1,
3145            version_id: Some(Uuid::new_v4()),
3146            ..Default::default()
3147        };
3148        let due = expected_expiry_time(base_time, 3);
3149
3150        let before_due = lc.eval_inner(&only_delete_marker, due - Duration::seconds(1), 0).await;
3151        assert_eq!(before_due.action, IlmAction::NoneAction);
3152
3153        let at_due = lc.eval_inner(&only_delete_marker, due, 0).await;
3154        assert_eq!(at_due.action, IlmAction::DeleteVersionAction);
3155        assert_eq!(at_due.rule_id, "rule-expiration-days");
3156        assert_eq!(at_due.due, Some(due));
3157
3158        let marker_with_older_version = ObjectOpts {
3159            num_versions: 2,
3160            ..only_delete_marker
3161        };
3162        let not_expired = lc
3163            .eval_inner(&marker_with_older_version, base_time + Duration::days(4), 0)
3164            .await;
3165        assert_eq!(not_expired.action, IlmAction::NoneAction);
3166    }
3167
3168    #[tokio::test]
3169    #[serial]
3170    async fn expiration_days_uses_earliest_due_rule_for_expired_delete_marker() {
3171        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
3172        let make_rule = |id: &str, days| LifecycleRule {
3173            status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3174            expiration: Some(LifecycleExpiration {
3175                days: Some(days),
3176                ..Default::default()
3177            }),
3178            abort_incomplete_multipart_upload: None,
3179            filter: None,
3180            id: Some(id.to_string()),
3181            noncurrent_version_expiration: None,
3182            noncurrent_version_transitions: None,
3183            prefix: None,
3184            transitions: None,
3185            del_marker_expiration: None,
3186        };
3187        let lc = BucketLifecycleConfiguration {
3188            expiry_updated_at: None,
3189            rules: vec![make_rule("rule-30-days", 30), make_rule("rule-3-days", 3)],
3190        };
3191        let opts = ObjectOpts {
3192            name: "obj".to_string(),
3193            mod_time: Some(base_time),
3194            is_latest: true,
3195            delete_marker: true,
3196            num_versions: 1,
3197            version_id: Some(Uuid::new_v4()),
3198            ..Default::default()
3199        };
3200
3201        let event = lc.eval_inner(&opts, base_time + Duration::days(31), 0).await;
3202
3203        assert_eq!(event.action, IlmAction::DeleteVersionAction);
3204        assert_eq!(event.rule_id, "rule-3-days");
3205        assert_eq!(event.due, Some(expected_expiry_time(base_time, 3)));
3206    }
3207
3208    #[tokio::test]
3209    async fn validate_rejects_expired_object_delete_marker_with_date() {
3210        let future_date = OffsetDateTime::from_unix_timestamp(86_400 * 10).expect("valid midnight UTC test timestamp");
3211        let lc = BucketLifecycleConfiguration {
3212            expiry_updated_at: None,
3213            rules: vec![LifecycleRule {
3214                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3215                expiration: Some(LifecycleExpiration {
3216                    date: Some(future_date.into()),
3217                    expired_object_delete_marker: Some(true),
3218                    ..Default::default()
3219                }),
3220                abort_incomplete_multipart_upload: None,
3221                filter: None,
3222                id: Some("rule-date-del-marker".to_string()),
3223                noncurrent_version_expiration: None,
3224                noncurrent_version_transitions: None,
3225                prefix: None,
3226                transitions: None,
3227                del_marker_expiration: None,
3228            }],
3229        };
3230
3231        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3232
3233        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3234    }
3235
3236    #[tokio::test]
3237    async fn validate_rejects_expired_object_delete_marker_with_days() {
3238        let lc = BucketLifecycleConfiguration {
3239            expiry_updated_at: None,
3240            rules: vec![LifecycleRule {
3241                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3242                expiration: Some(LifecycleExpiration {
3243                    days: Some(1),
3244                    expired_object_delete_marker: Some(true),
3245                    ..Default::default()
3246                }),
3247                abort_incomplete_multipart_upload: None,
3248                filter: None,
3249                id: Some("rule-days-del-marker".to_string()),
3250                noncurrent_version_expiration: None,
3251                noncurrent_version_transitions: None,
3252                prefix: None,
3253                transitions: None,
3254                del_marker_expiration: None,
3255            }],
3256        };
3257
3258        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3259
3260        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3261    }
3262
3263    #[tokio::test]
3264    async fn validate_rejects_false_expired_object_delete_marker_with_date() {
3265        let date = OffsetDateTime::from_unix_timestamp(86_400 * 10).expect("valid midnight UTC test timestamp");
3266        let lc = BucketLifecycleConfiguration {
3267            expiry_updated_at: None,
3268            rules: vec![LifecycleRule {
3269                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3270                expiration: Some(LifecycleExpiration {
3271                    date: Some(date.into()),
3272                    expired_object_delete_marker: Some(false),
3273                    ..Default::default()
3274                }),
3275                abort_incomplete_multipart_upload: None,
3276                filter: None,
3277                id: Some("rule-date-false-del-marker".to_string()),
3278                noncurrent_version_expiration: None,
3279                noncurrent_version_transitions: None,
3280                prefix: None,
3281                transitions: None,
3282                del_marker_expiration: None,
3283            }],
3284        };
3285
3286        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3287
3288        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3289    }
3290
3291    #[tokio::test]
3292    async fn validate_rejects_false_expired_object_delete_marker_with_days() {
3293        let lc = BucketLifecycleConfiguration {
3294            expiry_updated_at: None,
3295            rules: vec![LifecycleRule {
3296                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3297                expiration: Some(LifecycleExpiration {
3298                    days: Some(1),
3299                    expired_object_delete_marker: Some(false),
3300                    ..Default::default()
3301                }),
3302                abort_incomplete_multipart_upload: None,
3303                filter: None,
3304                id: Some("rule-days-false-del-marker".to_string()),
3305                noncurrent_version_expiration: None,
3306                noncurrent_version_transitions: None,
3307                prefix: None,
3308                transitions: None,
3309                del_marker_expiration: None,
3310            }],
3311        };
3312
3313        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3314
3315        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_DELETE_MARKER);
3316    }
3317
3318    #[tokio::test]
3319    async fn validate_rejects_expired_object_delete_marker_with_tag_filter() {
3320        let lc = BucketLifecycleConfiguration {
3321            expiry_updated_at: None,
3322            rules: vec![LifecycleRule {
3323                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3324                expiration: Some(LifecycleExpiration {
3325                    expired_object_delete_marker: Some(true),
3326                    ..Default::default()
3327                }),
3328                abort_incomplete_multipart_upload: None,
3329                filter: Some(LifecycleRuleFilter {
3330                    tag: Some(s3s::dto::Tag {
3331                        key: Some("env".to_string()),
3332                        value: Some("prod".to_string()),
3333                    }),
3334                    ..Default::default()
3335                }),
3336                id: Some("rule-tag-del-marker".to_string()),
3337                noncurrent_version_expiration: None,
3338                noncurrent_version_transitions: None,
3339                prefix: None,
3340                transitions: None,
3341                del_marker_expiration: None,
3342            }],
3343        };
3344
3345        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3346
3347        assert_eq!(err.to_string(), ERR_LIFECYCLE_EXPIRED_OBJECT_DELETE_MARKER_WITH_TAGS);
3348    }
3349
3350    // --- TASK-002 tests: Object Lock + ExpiredObjectDeleteMarker compatibility ---
3351
3352    #[tokio::test]
3353    async fn validate_allows_expired_object_delete_marker_on_locked_bucket() {
3354        let lc = BucketLifecycleConfiguration {
3355            expiry_updated_at: None,
3356            rules: vec![LifecycleRule {
3357                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3358                expiration: Some(LifecycleExpiration {
3359                    expired_object_delete_marker: Some(true),
3360                    ..Default::default()
3361                }),
3362                abort_incomplete_multipart_upload: None,
3363                del_marker_expiration: None,
3364                filter: None,
3365                id: Some("test-rule".to_string()),
3366                noncurrent_version_expiration: None,
3367                noncurrent_version_transitions: None,
3368                prefix: None,
3369                transitions: None,
3370            }],
3371        };
3372
3373        let locked_config = ObjectLockConfiguration {
3374            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3375            ..Default::default()
3376        };
3377
3378        lc.validate(&locked_config)
3379            .await
3380            .expect("expected validation to pass for ExpiredObjectDeleteMarker on locked bucket");
3381    }
3382
3383    #[tokio::test]
3384    async fn validate_allows_expired_object_delete_marker_on_unlocked_bucket() {
3385        let lc = BucketLifecycleConfiguration {
3386            expiry_updated_at: None,
3387            rules: vec![LifecycleRule {
3388                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3389                expiration: Some(LifecycleExpiration {
3390                    expired_object_delete_marker: Some(true),
3391                    ..Default::default()
3392                }),
3393                abort_incomplete_multipart_upload: None,
3394                del_marker_expiration: None,
3395                filter: None,
3396                id: Some("test-rule".to_string()),
3397                noncurrent_version_expiration: None,
3398                noncurrent_version_transitions: None,
3399                prefix: None,
3400                transitions: None,
3401            }],
3402        };
3403
3404        // Default ObjectLockConfiguration (no lock enabled) should pass
3405        lc.validate(&ObjectLockConfiguration::default())
3406            .await
3407            .expect("expected validation to pass on unlocked bucket");
3408    }
3409
3410    #[tokio::test]
3411    async fn validate_allows_non_delete_marker_expiration_on_locked_bucket() {
3412        let lc = BucketLifecycleConfiguration {
3413            expiry_updated_at: None,
3414            rules: vec![LifecycleRule {
3415                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3416                expiration: Some(LifecycleExpiration {
3417                    days: Some(30),
3418                    ..Default::default()
3419                }),
3420                abort_incomplete_multipart_upload: None,
3421                del_marker_expiration: None,
3422                filter: None,
3423                id: Some("test-rule".to_string()),
3424                noncurrent_version_expiration: None,
3425                noncurrent_version_transitions: None,
3426                prefix: None,
3427                transitions: None,
3428            }],
3429        };
3430
3431        let locked_config = ObjectLockConfiguration {
3432            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3433            ..Default::default()
3434        };
3435
3436        // Days-based expiration (not DeleteMarker) should be allowed on locked bucket
3437        lc.validate(&locked_config)
3438            .await
3439            .expect("expected days-based expiration to pass on locked bucket");
3440    }
3441
3442    #[tokio::test]
3443    async fn validate_rejects_del_marker_expiration_on_locked_bucket() {
3444        let lc = BucketLifecycleConfiguration {
3445            expiry_updated_at: None,
3446            rules: vec![LifecycleRule {
3447                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3448                expiration: Some(LifecycleExpiration {
3449                    days: Some(30),
3450                    ..Default::default()
3451                }),
3452                abort_incomplete_multipart_upload: None,
3453                del_marker_expiration: Some(s3s::dto::DelMarkerExpiration { days: Some(1) }),
3454                filter: None,
3455                id: Some("test-rule".to_string()),
3456                noncurrent_version_expiration: None,
3457                noncurrent_version_transitions: None,
3458                prefix: None,
3459                transitions: None,
3460            }],
3461        };
3462
3463        let locked_config = ObjectLockConfiguration {
3464            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
3465            ..Default::default()
3466        };
3467
3468        let err = lc.validate(&locked_config).await.unwrap_err();
3469        assert_eq!(err.to_string(), ERR_LIFECYCLE_BUCKET_LOCKED);
3470    }
3471
3472    #[tokio::test]
3473    async fn validate_rejects_invalid_del_marker_expiration_days_even_with_another_action() {
3474        for days in [None, Some(0), Some(-1)] {
3475            let lc = BucketLifecycleConfiguration {
3476                expiry_updated_at: None,
3477                rules: vec![LifecycleRule {
3478                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3479                    expiration: Some(LifecycleExpiration {
3480                        days: Some(30),
3481                        ..Default::default()
3482                    }),
3483                    abort_incomplete_multipart_upload: None,
3484                    del_marker_expiration: Some(s3s::dto::DelMarkerExpiration { days }),
3485                    filter: None,
3486                    id: Some("test-rule".to_string()),
3487                    noncurrent_version_expiration: None,
3488                    noncurrent_version_transitions: None,
3489                    prefix: None,
3490                    transitions: None,
3491                }],
3492            };
3493
3494            let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3495            assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_DEL_MARKER_EXPIRATION_DAYS);
3496        }
3497    }
3498
3499    #[tokio::test]
3500    #[serial]
3501    async fn del_marker_expiration_deletes_marker_and_older_versions_when_due() {
3502        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("fixed timestamp should be valid");
3503        let lc = BucketLifecycleConfiguration {
3504            expiry_updated_at: None,
3505            rules: vec![enabled_rule(
3506                None,
3507                Some(s3s::dto::DelMarkerExpiration { days: Some(3) }),
3508                Some("delete-marker-history"),
3509            )],
3510        };
3511        let marker_with_history = ObjectOpts {
3512            name: "obj".to_string(),
3513            mod_time: Some(base_time),
3514            is_latest: true,
3515            delete_marker: true,
3516            num_versions: 3,
3517            version_id: Some(Uuid::new_v4()),
3518            ..Default::default()
3519        };
3520        let due = expected_expiry_time(base_time, 3);
3521
3522        let before_due = lc.eval_inner(&marker_with_history, due - Duration::seconds(1), 0).await;
3523        assert_eq!(before_due.action, IlmAction::NoneAction);
3524
3525        let at_due = lc.eval_inner(&marker_with_history, due, 0).await;
3526        assert_eq!(at_due.action, IlmAction::DelMarkerDeleteAllVersionsAction);
3527        assert_eq!(at_due.rule_id, "delete-marker-history");
3528        assert_eq!(at_due.due, Some(due));
3529
3530        let current_data = ObjectOpts {
3531            delete_marker: false,
3532            ..marker_with_history
3533        };
3534        assert_eq!(lc.eval_inner(&current_data, due, 0).await.action, IlmAction::NoneAction);
3535    }
3536
3537    // --- TASK-003 tests: Round up to next UTC processing boundary ---
3538
3539    #[test]
3540    #[serial]
3541    fn expected_expiry_time_rounds_up_to_next_midnight_utc() {
3542        with_default_ilm_process_time(|| {
3543            // Object created at 2025-01-15T10:30:45Z, expire in 30 days
3544            let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3545            let result = expected_expiry_time(mod_time, 30);
3546
3547            // Should round up to the next midnight: 2025-02-15T00:00:00Z
3548            assert_eq!(result.hour(), 0);
3549            assert_eq!(result.minute(), 0);
3550            assert_eq!(result.second(), 0);
3551            assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3552        });
3553    }
3554
3555    #[test]
3556    #[serial]
3557    fn expected_expiry_time_immediate_expiry_returns_epoch() {
3558        with_default_ilm_process_time(|| {
3559            let mod_time = datetime!(2025-06-01 12:00:00 UTC);
3560            let result = expected_expiry_time(mod_time, 0);
3561            assert_eq!(result, OffsetDateTime::UNIX_EPOCH);
3562        });
3563    }
3564
3565    #[test]
3566    #[serial]
3567    fn expected_expiry_time_preserves_exact_midnight_boundary() {
3568        with_default_ilm_process_time(|| {
3569            let mod_time = datetime!(2025-03-01 00:00:00 UTC);
3570            let result = expected_expiry_time(mod_time, 1);
3571            assert_eq!(result, datetime!(2025-03-02 00:00:00 UTC));
3572        });
3573    }
3574
3575    #[test]
3576    #[serial]
3577    fn expected_expiry_time_rounds_end_of_day_to_following_midnight() {
3578        with_default_ilm_process_time(|| {
3579            let mod_time = datetime!(2025-06-15 23:59:59 UTC);
3580            let result = expected_expiry_time(mod_time, 1);
3581            assert_eq!(result, datetime!(2025-06-17 00:00:00 UTC));
3582        });
3583    }
3584
3585    #[test]
3586    #[serial]
3587    fn expected_expiry_time_uses_canonical_process_time_boundary() {
3588        let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3589
3590        temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("3600"), || {
3591            temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3592                let result = expected_expiry_time(mod_time, 1);
3593                assert_eq!(result, datetime!(2025-01-16 11:00:00 UTC));
3594            });
3595        });
3596    }
3597
3598    #[test]
3599    #[serial]
3600    fn expected_expiry_time_uses_deprecated_process_time_alias() {
3601        let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3602
3603        temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
3604            temp_env::with_var(ENV_ILM_PROCESS_TIME_DEPRECATED, Some("3600"), || {
3605                let result = expected_expiry_time(mod_time, 1);
3606                assert_eq!(result, datetime!(2025-01-16 11:00:00 UTC));
3607            });
3608        });
3609    }
3610
3611    #[test]
3612    #[serial]
3613    fn expected_expiry_time_uses_default_boundary_when_process_time_is_zero_or_invalid() {
3614        let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3615
3616        temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("0"), || {
3617            temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3618                let result = expected_expiry_time(mod_time, 30);
3619                assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3620            });
3621        });
3622
3623        temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("not-a-number"), || {
3624            temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3625                let result = expected_expiry_time(mod_time, 30);
3626                assert_eq!(result, datetime!(2025-02-15 00:00:00 UTC));
3627            });
3628        });
3629    }
3630
3631    // --- ilm-5 tests: RUSTFS_ILM_DEBUG_DAY_SECS time-acceleration switch ---
3632
3633    // (a) Default path (env unset) is byte-identical: one day == 86400s.
3634    #[test]
3635    #[serial]
3636    fn ilm_day_secs_defaults_to_86400_when_unset() {
3637        temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
3638            assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3639            assert_eq!(ilm_day_secs(), 86400);
3640        });
3641    }
3642
3643    // (b) Pure parse: positive integers activate the override.
3644    #[test]
3645    fn parse_ilm_day_secs_accepts_positive_values() {
3646        assert_eq!(parse_ilm_day_secs("1"), 1);
3647        assert_eq!(parse_ilm_day_secs("2"), 2);
3648        assert_eq!(parse_ilm_day_secs("  10 "), 10);
3649        assert_eq!(parse_ilm_day_secs("3600"), 3600);
3650    }
3651
3652    // (c) Pure parse: invalid / zero / negative fall back to 86400.
3653    #[test]
3654    fn parse_ilm_day_secs_rejects_invalid_and_zero() {
3655        assert_eq!(parse_ilm_day_secs("0"), DEFAULT_ILM_DAY_SECS);
3656        assert_eq!(parse_ilm_day_secs("-5"), DEFAULT_ILM_DAY_SECS);
3657        assert_eq!(parse_ilm_day_secs("not-a-number"), DEFAULT_ILM_DAY_SECS);
3658        assert_eq!(parse_ilm_day_secs(""), DEFAULT_ILM_DAY_SECS);
3659        assert_eq!(parse_ilm_day_secs("1.5"), DEFAULT_ILM_DAY_SECS);
3660    }
3661
3662    // (b) End-to-end env read scales the day length.
3663    #[test]
3664    #[serial]
3665    fn ilm_day_secs_scales_when_env_set() {
3666        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("2"), || {
3667            assert_eq!(ilm_day_secs(), 2);
3668        });
3669    }
3670
3671    // (c) Invalid env value falls back to 86400.
3672    #[test]
3673    #[serial]
3674    fn ilm_day_secs_falls_back_on_invalid_env() {
3675        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("bogus"), || {
3676            assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3677        });
3678        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("0"), || {
3679            assert_eq!(ilm_day_secs(), DEFAULT_ILM_DAY_SECS);
3680        });
3681    }
3682
3683    // Deadline math scales: with a 1s day and PROCESS_TIME unset, a Days=1 rule is
3684    // due 1s after mod_time (rounded up to the next 1s boundary => same instant).
3685    #[test]
3686    #[serial]
3687    fn expected_expiry_time_scales_with_debug_day_secs() {
3688        let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3689        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("1"), || {
3690            temp_env::with_var_unset(ENV_ILM_PROCESS_TIME, || {
3691                temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3692                    // 1 "day" == 1s; boundary also defaults to 1s so no extra rounding.
3693                    assert_eq!(expected_expiry_time(mod_time, 1), mod_time + Duration::seconds(1));
3694                    assert_eq!(expected_expiry_time(mod_time, 5), mod_time + Duration::seconds(5));
3695                });
3696            });
3697        });
3698    }
3699
3700    // days == 0 still yields the immediate-expiry sentinel regardless of the switch.
3701    #[test]
3702    #[serial]
3703    fn expected_expiry_time_zero_days_ignores_debug_day_secs() {
3704        let mod_time = datetime!(2025-06-01 12:00:00 UTC);
3705        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("2"), || {
3706            assert_eq!(expected_expiry_time(mod_time, 0), OffsetDateTime::UNIX_EPOCH);
3707        });
3708    }
3709
3710    // (③) Interaction with an explicit RUSTFS_ILM_PROCESS_TIME: the deadline offset
3711    // uses the accelerated day length, but the rounding boundary honors PROCESS_TIME.
3712    #[test]
3713    #[serial]
3714    fn expected_expiry_time_debug_day_secs_respects_explicit_process_time() {
3715        let mod_time = datetime!(2025-01-15 10:30:00 UTC);
3716        // day == 10s, but round up to the next 60s (PROCESS_TIME) boundary.
3717        temp_env::with_var(ENV_ILM_DEBUG_DAY_SECS, Some("10"), || {
3718            temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("60"), || {
3719                temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3720                    // mod_time + 30s = 10:30:30, rounded up to next minute => 10:31:00.
3721                    let result = expected_expiry_time(mod_time, 3);
3722                    assert_eq!(result, datetime!(2025-01-15 10:31:00 UTC));
3723                });
3724            });
3725        });
3726    }
3727
3728    // (③) With the switch unset, an explicit PROCESS_TIME behaves exactly as before.
3729    #[test]
3730    #[serial]
3731    fn expected_expiry_time_unset_debug_day_secs_matches_legacy_process_time() {
3732        let mod_time = datetime!(2025-01-15 10:30:45 UTC);
3733        temp_env::with_var_unset(ENV_ILM_DEBUG_DAY_SECS, || {
3734            temp_env::with_var(ENV_ILM_PROCESS_TIME, Some("3600"), || {
3735                temp_env::with_var_unset(ENV_ILM_PROCESS_TIME_DEPRECATED, || {
3736                    assert_eq!(expected_expiry_time(mod_time, 1), datetime!(2025-01-16 11:00:00 UTC));
3737                });
3738            });
3739        });
3740    }
3741
3742    /// Run an async body inside a synchronous `temp_env` scope so the overridden
3743    /// environment stays set across every `.await`. Uses a fresh current-thread
3744    /// runtime (no outer runtime => `block_on` is safe) and keeps these tests off
3745    /// the optional `async_closure` temp-env feature.
3746    fn block_on_with_env<F: std::future::Future>(vars: &[(&str, Option<&str>)], fut_fn: impl FnOnce() -> F) -> F::Output {
3747        temp_env::with_vars(vars, || {
3748            let rt = tokio::runtime::Builder::new_current_thread()
3749                .enable_all()
3750                .build()
3751                .expect("build runtime");
3752            rt.block_on(fut_fn())
3753        })
3754    }
3755
3756    // The abort-incomplete-multipart deadline path also scales through the switch.
3757    #[test]
3758    #[serial]
3759    fn abort_incomplete_multipart_due_scales_with_debug_day_secs() {
3760        use s3s::dto::AbortIncompleteMultipartUpload;
3761        let initiated = datetime!(2025-01-15 10:30:45 UTC);
3762        let lc = BucketLifecycleConfiguration {
3763            expiry_updated_at: None,
3764            rules: vec![LifecycleRule {
3765                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3766                expiration: None,
3767                abort_incomplete_multipart_upload: Some(AbortIncompleteMultipartUpload {
3768                    days_after_initiation: Some(3),
3769                }),
3770                del_marker_expiration: None,
3771                filter: None,
3772                id: Some("abort-mpu".to_string()),
3773                noncurrent_version_expiration: None,
3774                noncurrent_version_transitions: None,
3775                prefix: None,
3776                transitions: None,
3777            }],
3778        };
3779        let opts = ObjectOpts {
3780            name: "obj".to_string(),
3781            mod_time: Some(initiated),
3782            is_latest: true,
3783            ..Default::default()
3784        };
3785
3786        block_on_with_env(
3787            &[
3788                (ENV_ILM_DEBUG_DAY_SECS, Some("1")),
3789                (ENV_ILM_PROCESS_TIME, None),
3790                (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
3791            ],
3792            || async {
3793                let (due, id) = abort_incomplete_multipart_upload_due(&lc, &opts).await.expect("due");
3794                assert_eq!(due, initiated + Duration::seconds(3));
3795                assert_eq!(id, "abort-mpu");
3796            },
3797        );
3798    }
3799
3800    // (⑤ evaluator seam) A Days=1 rule fires under RUSTFS_ILM_DEBUG_DAY_SECS=1 once
3801    // `now` advances a few seconds past a mod_time only ~seconds in the past.
3802    #[test]
3803    #[serial]
3804    fn eval_inner_expires_days_one_rule_under_debug_day_secs() {
3805        let lc = BucketLifecycleConfiguration {
3806            expiry_updated_at: None,
3807            rules: vec![LifecycleRule {
3808                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3809                expiration: Some(LifecycleExpiration {
3810                    days: Some(1),
3811                    ..Default::default()
3812                }),
3813                abort_incomplete_multipart_upload: None,
3814                del_marker_expiration: None,
3815                filter: None,
3816                id: Some("expire-days".to_string()),
3817                noncurrent_version_expiration: None,
3818                noncurrent_version_transitions: None,
3819                prefix: None,
3820                transitions: None,
3821            }],
3822        };
3823
3824        let mod_time = datetime!(2025-01-15 10:30:00 UTC);
3825        let opts = ObjectOpts {
3826            name: "obj".to_string(),
3827            mod_time: Some(mod_time),
3828            is_latest: true,
3829            ..Default::default()
3830        };
3831
3832        block_on_with_env(
3833            &[
3834                (ENV_ILM_DEBUG_DAY_SECS, Some("1")),
3835                (ENV_ILM_PROCESS_TIME, None),
3836                (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
3837            ],
3838            || async {
3839                // Only 2s after mod_time: with a real day this would NOT be due, but a
3840                // 1s day makes the Days=1 deadline (mod_time + 1s) already in the past.
3841                let now = mod_time + Duration::seconds(2);
3842                let event = lc.eval_inner(&opts, now, 0).await;
3843                assert_eq!(event.action, IlmAction::DeleteAction);
3844                assert_eq!(event.rule_id, "expire-days");
3845                assert_eq!(event.due, Some(mod_time + Duration::seconds(1)));
3846            },
3847        );
3848    }
3849
3850    // Absolute Date-based rules must NOT scale with the switch (regression guard).
3851    #[test]
3852    #[serial]
3853    fn eval_inner_date_rule_ignores_debug_day_secs() {
3854        let expiry_date = datetime!(2025-06-01 00:00:00 UTC);
3855        let lc = BucketLifecycleConfiguration {
3856            expiry_updated_at: None,
3857            rules: vec![LifecycleRule {
3858                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3859                expiration: Some(LifecycleExpiration {
3860                    date: Some(expiry_date.into()),
3861                    ..Default::default()
3862                }),
3863                abort_incomplete_multipart_upload: None,
3864                del_marker_expiration: None,
3865                filter: None,
3866                id: Some("expire-date".to_string()),
3867                noncurrent_version_expiration: None,
3868                noncurrent_version_transitions: None,
3869                prefix: None,
3870                transitions: None,
3871            }],
3872        };
3873        let opts = ObjectOpts {
3874            name: "obj".to_string(),
3875            mod_time: Some(datetime!(2025-01-15 10:30:00 UTC)),
3876            is_latest: true,
3877            ..Default::default()
3878        };
3879
3880        block_on_with_env(&[(ENV_ILM_DEBUG_DAY_SECS, Some("1"))], || async {
3881            // A few seconds after mod_time; the absolute June date is still far away.
3882            let now = datetime!(2025-01-15 10:30:05 UTC);
3883            let event = lc.eval_inner(&opts, now, 0).await;
3884            assert_eq!(event.action, IlmAction::NoneAction);
3885        });
3886    }
3887
3888    // --- TASK-007 tests: Legacy Prefix/Filter conflict ---
3889
3890    #[tokio::test]
3891    async fn validate_rejects_prefix_and_filter_both_present() {
3892        let lc = BucketLifecycleConfiguration {
3893            expiry_updated_at: None,
3894            rules: vec![LifecycleRule {
3895                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3896                expiration: Some(LifecycleExpiration {
3897                    days: Some(30),
3898                    ..Default::default()
3899                }),
3900                abort_incomplete_multipart_upload: None,
3901                del_marker_expiration: None,
3902                filter: Some(LifecycleRuleFilter {
3903                    prefix: Some("logs/".to_string()),
3904                    ..Default::default()
3905                }),
3906                id: Some("test-rule".to_string()),
3907                noncurrent_version_expiration: None,
3908                noncurrent_version_transitions: None,
3909                prefix: Some("archive/".to_string()),
3910                transitions: None,
3911            }],
3912        };
3913
3914        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
3915        assert_eq!(err.to_string(), ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT);
3916    }
3917
3918    #[tokio::test]
3919    async fn validate_allows_prefix_without_filter() {
3920        let lc = BucketLifecycleConfiguration {
3921            expiry_updated_at: None,
3922            rules: vec![LifecycleRule {
3923                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3924                expiration: Some(LifecycleExpiration {
3925                    days: Some(30),
3926                    ..Default::default()
3927                }),
3928                abort_incomplete_multipart_upload: None,
3929                del_marker_expiration: None,
3930                filter: None,
3931                id: Some("test-rule".to_string()),
3932                noncurrent_version_expiration: None,
3933                noncurrent_version_transitions: None,
3934                prefix: Some("logs/".to_string()),
3935                transitions: None,
3936            }],
3937        };
3938
3939        lc.validate(&ObjectLockConfiguration::default())
3940            .await
3941            .expect("prefix without filter should be valid");
3942    }
3943
3944    #[tokio::test]
3945    async fn validate_allows_filter_without_prefix() {
3946        let lc = BucketLifecycleConfiguration {
3947            expiry_updated_at: None,
3948            rules: vec![LifecycleRule {
3949                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3950                expiration: Some(LifecycleExpiration {
3951                    days: Some(30),
3952                    ..Default::default()
3953                }),
3954                abort_incomplete_multipart_upload: None,
3955                del_marker_expiration: None,
3956                filter: Some(LifecycleRuleFilter {
3957                    prefix: Some("logs/".to_string()),
3958                    ..Default::default()
3959                }),
3960                id: Some("test-rule".to_string()),
3961                noncurrent_version_expiration: None,
3962                noncurrent_version_transitions: None,
3963                prefix: None,
3964                transitions: None,
3965            }],
3966        };
3967
3968        lc.validate(&ObjectLockConfiguration::default())
3969            .await
3970            .expect("filter without prefix should be valid");
3971    }
3972
3973    #[tokio::test]
3974    async fn validate_allows_empty_prefix_with_filter() {
3975        // Empty prefix should be treated as "not set"
3976        let lc = BucketLifecycleConfiguration {
3977            expiry_updated_at: None,
3978            rules: vec![LifecycleRule {
3979                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
3980                expiration: Some(LifecycleExpiration {
3981                    days: Some(30),
3982                    ..Default::default()
3983                }),
3984                abort_incomplete_multipart_upload: None,
3985                del_marker_expiration: None,
3986                filter: Some(LifecycleRuleFilter {
3987                    prefix: Some("logs/".to_string()),
3988                    ..Default::default()
3989                }),
3990                id: Some("test-rule".to_string()),
3991                noncurrent_version_expiration: None,
3992                noncurrent_version_transitions: None,
3993                prefix: Some("".to_string()), // empty = not set
3994                transitions: None,
3995            }],
3996        };
3997
3998        lc.validate(&ObjectLockConfiguration::default())
3999            .await
4000            .expect("empty prefix with filter should be valid");
4001    }
4002
4003    #[tokio::test]
4004    async fn validate_rejects_empty_rule_id() {
4005        let lc = BucketLifecycleConfiguration {
4006            expiry_updated_at: None,
4007            rules: vec![LifecycleRule {
4008                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4009                expiration: Some(LifecycleExpiration {
4010                    days: Some(30),
4011                    ..Default::default()
4012                }),
4013                abort_incomplete_multipart_upload: None,
4014                del_marker_expiration: None,
4015                filter: None,
4016                id: Some(String::new()),
4017                noncurrent_version_expiration: None,
4018                noncurrent_version_transitions: None,
4019                prefix: None,
4020                transitions: None,
4021            }],
4022        };
4023
4024        let error = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4025        assert_eq!(error.to_string(), ERR_LIFECYCLE_INVALID_RULE_ID_EMPTY);
4026    }
4027
4028    // --- TASK-004 tests: ExpiredObjectAllVersions ---
4029
4030    #[tokio::test]
4031    async fn validate_rejects_expired_object_all_versions_on_locked_bucket() {
4032        let lc = BucketLifecycleConfiguration {
4033            expiry_updated_at: None,
4034            rules: vec![LifecycleRule {
4035                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4036                expiration: Some(LifecycleExpiration {
4037                    days: Some(30),
4038                    expired_object_all_versions: Some(true),
4039                    ..Default::default()
4040                }),
4041                abort_incomplete_multipart_upload: None,
4042                del_marker_expiration: None,
4043                filter: None,
4044                id: Some("all-versions-rule".to_string()),
4045                noncurrent_version_expiration: None,
4046                noncurrent_version_transitions: None,
4047                prefix: None,
4048                transitions: None,
4049            }],
4050        };
4051
4052        let locked_config = ObjectLockConfiguration {
4053            object_lock_enabled: Some(ObjectLockEnabled::from_static(ObjectLockEnabled::ENABLED)),
4054            ..Default::default()
4055        };
4056
4057        let err = lc.validate(&locked_config).await.unwrap_err();
4058        assert_eq!(err.to_string(), ERR_LIFECYCLE_BUCKET_LOCKED);
4059    }
4060
4061    #[tokio::test]
4062    async fn validate_allows_expired_object_all_versions_on_unlocked_bucket() {
4063        let lc = BucketLifecycleConfiguration {
4064            expiry_updated_at: None,
4065            rules: vec![LifecycleRule {
4066                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4067                expiration: Some(LifecycleExpiration {
4068                    days: Some(30),
4069                    expired_object_all_versions: Some(true),
4070                    ..Default::default()
4071                }),
4072                abort_incomplete_multipart_upload: None,
4073                del_marker_expiration: None,
4074                filter: None,
4075                id: Some("all-versions-rule".to_string()),
4076                noncurrent_version_expiration: None,
4077                noncurrent_version_transitions: None,
4078                prefix: None,
4079                transitions: None,
4080            }],
4081        };
4082
4083        lc.validate(&ObjectLockConfiguration::default())
4084            .await
4085            .expect("ExpiredObjectAllVersions should be allowed on unlocked bucket");
4086    }
4087
4088    #[tokio::test]
4089    async fn validate_rejects_expired_object_all_versions_without_days_or_with_date() {
4090        let expiration_date = datetime!(2025-01-01 00:00:00 UTC);
4091        let invalid_expirations = [
4092            LifecycleExpiration {
4093                expired_object_all_versions: Some(true),
4094                ..Default::default()
4095            },
4096            LifecycleExpiration {
4097                date: Some(expiration_date.into()),
4098                days: Some(1),
4099                expired_object_all_versions: Some(true),
4100                ..Default::default()
4101            },
4102        ];
4103
4104        for expiration in invalid_expirations {
4105            let lc = BucketLifecycleConfiguration {
4106                expiry_updated_at: None,
4107                rules: vec![enabled_rule(Some(expiration), None, None)],
4108            };
4109
4110            let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4111            assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS);
4112        }
4113    }
4114
4115    #[tokio::test]
4116    async fn validate_rejects_false_expired_object_all_versions_with_date() {
4117        let lc = BucketLifecycleConfiguration {
4118            expiry_updated_at: None,
4119            rules: vec![enabled_rule(
4120                Some(LifecycleExpiration {
4121                    date: Some(datetime!(2025-01-01 00:00:00 UTC).into()),
4122                    expired_object_all_versions: Some(false),
4123                    ..Default::default()
4124                }),
4125                None,
4126                None,
4127            )],
4128        };
4129
4130        let err = lc.validate(&ObjectLockConfiguration::default()).await.unwrap_err();
4131        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_EXPIRED_OBJECT_ALL_VERSIONS);
4132    }
4133
4134    #[tokio::test]
4135    #[serial]
4136    async fn eval_inner_triggers_delete_all_versions_when_expired_object_all_versions_set() {
4137        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
4138        let lc = BucketLifecycleConfiguration {
4139            expiry_updated_at: None,
4140            rules: vec![LifecycleRule {
4141                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4142                expiration: Some(LifecycleExpiration {
4143                    days: Some(1),
4144                    expired_object_all_versions: Some(true),
4145                    ..Default::default()
4146                }),
4147                abort_incomplete_multipart_upload: None,
4148                del_marker_expiration: None,
4149                filter: None,
4150                id: Some("all-versions-rule".to_string()),
4151                noncurrent_version_expiration: None,
4152                noncurrent_version_transitions: None,
4153                prefix: None,
4154                transitions: None,
4155            }],
4156        };
4157
4158        let opts = ObjectOpts {
4159            name: "obj".to_string(),
4160            mod_time: Some(base_time),
4161            is_latest: true,
4162            version_id: None,
4163            ..Default::default()
4164        };
4165
4166        // now is after the expiry time
4167        let now = base_time + Duration::days(2);
4168        let event = lc.eval_inner(&opts, now, 0).await;
4169        assert_eq!(event.action, IlmAction::DeleteAllVersionsAction);
4170        assert_eq!(event.rule_id, "all-versions-rule");
4171    }
4172
4173    #[tokio::test]
4174    #[serial]
4175    async fn expired_object_all_versions_does_not_apply_to_current_delete_marker() {
4176        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).expect("fixed timestamp should be valid");
4177        let lc = BucketLifecycleConfiguration {
4178            expiry_updated_at: None,
4179            rules: vec![enabled_rule(
4180                Some(LifecycleExpiration {
4181                    days: Some(1),
4182                    expired_object_all_versions: Some(true),
4183                    ..Default::default()
4184                }),
4185                None,
4186                Some("all-versions-rule"),
4187            )],
4188        };
4189        let marker_with_history = ObjectOpts {
4190            name: "obj".to_string(),
4191            mod_time: Some(base_time),
4192            is_latest: true,
4193            delete_marker: true,
4194            num_versions: 2,
4195            version_id: Some(Uuid::new_v4()),
4196            ..Default::default()
4197        };
4198
4199        let event = lc.eval_inner(&marker_with_history, base_time + Duration::days(2), 0).await;
4200        assert_eq!(event.action, IlmAction::NoneAction);
4201    }
4202
4203    #[tokio::test]
4204    #[serial]
4205    async fn eval_inner_uses_delete_action_when_all_versions_not_set() {
4206        let base_time = OffsetDateTime::from_unix_timestamp(1_000_000).unwrap();
4207        let lc = BucketLifecycleConfiguration {
4208            expiry_updated_at: None,
4209            rules: vec![LifecycleRule {
4210                status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4211                expiration: Some(LifecycleExpiration {
4212                    days: Some(1),
4213                    expired_object_all_versions: None, // not set
4214                    ..Default::default()
4215                }),
4216                abort_incomplete_multipart_upload: None,
4217                del_marker_expiration: None,
4218                filter: None,
4219                id: Some("normal-rule".to_string()),
4220                noncurrent_version_expiration: None,
4221                noncurrent_version_transitions: None,
4222                prefix: None,
4223                transitions: None,
4224            }],
4225        };
4226
4227        let opts = ObjectOpts {
4228            name: "obj".to_string(),
4229            mod_time: Some(base_time),
4230            is_latest: true,
4231            version_id: None,
4232            ..Default::default()
4233        };
4234
4235        let now = base_time + Duration::days(2);
4236        let event = lc.eval_inner(&opts, now, 0).await;
4237        // Without ExpiredObjectAllVersions, should use normal DeleteAction
4238        assert_eq!(event.action, IlmAction::DeleteAction);
4239    }
4240
4241    #[tokio::test]
4242    async fn current_expiration_requires_latest_even_for_null_version_identity() {
4243        let base_time = datetime!(2025-01-01 00:00:00 UTC);
4244        let lc = BucketLifecycleConfiguration {
4245            expiry_updated_at: None,
4246            rules: vec![enabled_rule(
4247                Some(LifecycleExpiration {
4248                    days: Some(1),
4249                    ..Default::default()
4250                }),
4251                None,
4252                Some("expire-current"),
4253            )],
4254        };
4255        let now = base_time + Duration::days(2);
4256
4257        let unversioned_current = ObjectOpts {
4258            name: "object".to_string(),
4259            mod_time: Some(base_time),
4260            is_latest: true,
4261            version_id: None,
4262            ..Default::default()
4263        };
4264        assert_eq!(
4265            lc.eval_inner(&unversioned_current, now, 0).await.action,
4266            IlmAction::DeleteAction,
4267            "a truly unversioned current object must remain eligible"
4268        );
4269        assert_eq!(lc.predict_expiration(&unversioned_current).await.action, IlmAction::DeleteAction);
4270        assert!(expiration_action_has_valid_target(
4271            IlmAction::DeleteAction,
4272            unversioned_current.version_id,
4273            unversioned_current.is_latest,
4274            unversioned_current.delete_marker,
4275        ));
4276        assert!(!expiration_action_has_valid_target(
4277            IlmAction::DeleteVersionAction,
4278            unversioned_current.version_id,
4279            unversioned_current.is_latest,
4280            unversioned_current.delete_marker,
4281        ));
4282
4283        let historical_null = ObjectOpts {
4284            name: "object".to_string(),
4285            mod_time: Some(base_time),
4286            version_id: Some(Uuid::nil()),
4287            is_latest: false,
4288            versioned: true,
4289            ..Default::default()
4290        };
4291        assert_eq!(
4292            lc.eval_inner(&historical_null, now, 0).await.action,
4293            IlmAction::NoneAction,
4294            "an explicit null identity does not make a historical version current"
4295        );
4296        assert_eq!(lc.predict_expiration(&historical_null).await.action, IlmAction::NoneAction);
4297        assert!(!expiration_action_has_valid_target(
4298            IlmAction::DeleteAction,
4299            historical_null.version_id,
4300            historical_null.is_latest,
4301            historical_null.delete_marker,
4302        ));
4303        assert!(expiration_action_has_valid_target(
4304            IlmAction::DeleteVersionAction,
4305            historical_null.version_id,
4306            historical_null.is_latest,
4307            historical_null.delete_marker,
4308        ));
4309    }
4310
4311    /// backlog#1148 ilm-8: once a restored copy's expiry passes, the evaluator
4312    /// must emit `DeleteRestoredAction` for the current version (and the
4313    /// `...Version` variant for a noncurrent one) so the scanner removes only
4314    /// the local restored copy. The restore branch fires independently of any
4315    /// configured rules.
4316    #[tokio::test]
4317    async fn eval_inner_emits_delete_restored_action_when_restore_expired() {
4318        let lc = BucketLifecycleConfiguration {
4319            expiry_updated_at: None,
4320            rules: vec![],
4321        };
4322        let now = datetime!(2025-06-01 12:00:00 UTC);
4323
4324        let current = ObjectOpts {
4325            name: "docs/report.bin".to_string(),
4326            mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4327            is_latest: true,
4328            transition_status: TRANSITION_COMPLETE.to_string(),
4329            restore_expires: Some(now - Duration::hours(1)),
4330            ..Default::default()
4331        };
4332        let event = lc.eval_inner(&current, now, 0).await;
4333        assert_eq!(event.action, IlmAction::DeleteRestoredAction);
4334
4335        let noncurrent = ObjectOpts {
4336            name: "docs/report.bin".to_string(),
4337            mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4338            is_latest: false,
4339            version_id: Some(Uuid::from_u128(9)),
4340            successor_mod_time: Some(datetime!(2025-05-02 00:00:00 UTC)),
4341            transition_status: TRANSITION_COMPLETE.to_string(),
4342            restore_expires: Some(now - Duration::hours(1)),
4343            ..Default::default()
4344        };
4345        let event = lc.eval_inner(&noncurrent, now, 0).await;
4346        assert_eq!(event.action, IlmAction::DeleteRestoredVersionAction);
4347    }
4348
4349    /// A restored copy whose expiry is still in the future must not be
4350    /// scheduled for cleanup.
4351    #[tokio::test]
4352    async fn eval_inner_keeps_unexpired_restore_copy() {
4353        let lc = BucketLifecycleConfiguration {
4354            expiry_updated_at: None,
4355            rules: vec![],
4356        };
4357        let now = datetime!(2025-06-01 12:00:00 UTC);
4358
4359        let current = ObjectOpts {
4360            name: "docs/report.bin".to_string(),
4361            mod_time: Some(datetime!(2025-05-01 00:00:00 UTC)),
4362            is_latest: true,
4363            transition_status: TRANSITION_COMPLETE.to_string(),
4364            restore_expires: Some(now + Duration::hours(1)),
4365            ..Default::default()
4366        };
4367        let event = lc.eval_inner(&current, now, 0).await;
4368        assert_eq!(event.action, IlmAction::NoneAction);
4369    }
4370
4371    // ---- backlog#2201: retention-count and Filter invariants -----------------
4372
4373    fn rule_with_noncurrent_expiration(expiration: NoncurrentVersionExpiration) -> LifecycleRule {
4374        LifecycleRule {
4375            status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4376            expiration: None,
4377            abort_incomplete_multipart_upload: None,
4378            del_marker_expiration: None,
4379            filter: None,
4380            id: Some("noncurrent".to_string()),
4381            noncurrent_version_expiration: Some(expiration),
4382            noncurrent_version_transitions: None,
4383            prefix: None,
4384            transitions: None,
4385        }
4386    }
4387
4388    fn rule_with_filter(filter: LifecycleRuleFilter) -> LifecycleRule {
4389        LifecycleRule {
4390            status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
4391            expiration: Some(LifecycleExpiration {
4392                days: Some(1),
4393                ..Default::default()
4394            }),
4395            abort_incomplete_multipart_upload: None,
4396            del_marker_expiration: None,
4397            filter: Some(filter),
4398            id: Some("filtered".to_string()),
4399            noncurrent_version_expiration: None,
4400            noncurrent_version_transitions: None,
4401            prefix: None,
4402            transitions: None,
4403        }
4404    }
4405
4406    fn config_with_rules(rules: Vec<LifecycleRule>) -> BucketLifecycleConfiguration {
4407        BucketLifecycleConfiguration {
4408            expiry_updated_at: None,
4409            rules,
4410        }
4411    }
4412
4413    fn tag(key: &str, value: &str) -> s3s::dto::Tag {
4414        s3s::dto::Tag {
4415            key: Some(key.to_string()),
4416            value: Some(value.to_string()),
4417        }
4418    }
4419
4420    #[tokio::test]
4421    async fn validate_rejects_negative_newer_noncurrent_versions() {
4422        // A negative retention count used to be accepted and then read as
4423        // usize::MAX during evaluation, so the rule silently stopped deleting
4424        // versions (backlog#2201).
4425        let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4426            noncurrent_days: Some(30),
4427            newer_noncurrent_versions: Some(-1),
4428        })]);
4429
4430        let err = lc
4431            .validate(&ObjectLockConfiguration::default())
4432            .await
4433            .expect_err("a negative retention count must be rejected");
4434
4435        assert_eq!(err.to_string(), ERR_LIFECYCLE_INVALID_NEWER_NONCURRENT_VERSIONS);
4436        assert_ne!(err.kind(), LIFECYCLE_MALFORMED_XML_ERROR_KIND, "value errors stay InvalidArgument");
4437    }
4438
4439    #[tokio::test]
4440    async fn validate_rejects_negative_newer_noncurrent_versions_on_transition() {
4441        let mut rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4442            noncurrent_days: Some(30),
4443            newer_noncurrent_versions: None,
4444        });
4445        rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4446            newer_noncurrent_versions: Some(-3),
4447            noncurrent_days: Some(1),
4448            storage_class: Some(TransitionStorageClass::from_static(TransitionStorageClass::GLACIER)),
4449        }]);
4450
4451        // The transition validator already refuses a negative count, and it runs
4452        // first, so this pins the rejection rather than the message. The gap
4453        // this PR closes is the expiration side, which had no such check.
4454        config_with_rules(vec![rule])
4455            .validate(&ObjectLockConfiguration::default())
4456            .await
4457            .expect_err("a negative retention count on a transition must be rejected");
4458    }
4459
4460    #[tokio::test]
4461    async fn validate_rejects_empty_expiration_action() {
4462        let mut rule = rule_with_filter(LifecycleRuleFilter::default());
4463        rule.expiration = Some(LifecycleExpiration::default());
4464
4465        let err = config_with_rules(vec![rule])
4466            .validate(&ObjectLockConfiguration::default())
4467            .await
4468            .expect_err("an empty Expiration object must not count as an action");
4469
4470        assert_eq!(err.to_string(), ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION);
4471    }
4472
4473    #[tokio::test]
4474    async fn zero_newer_noncurrent_versions_means_no_count_constraint() {
4475        // Zero carries no constraint, matching how the batch limit path has
4476        // always read it. Alongside an age condition the rule is valid; on its
4477        // own it says nothing, so the rule has no action.
4478        config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4479            noncurrent_days: Some(30),
4480            newer_noncurrent_versions: Some(0),
4481        })])
4482        .validate(&ObjectLockConfiguration::default())
4483        .await
4484        .expect("zero count alongside NoncurrentDays is valid");
4485
4486        let err = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4487            noncurrent_days: None,
4488            newer_noncurrent_versions: Some(0),
4489        })])
4490        .validate(&ObjectLockConfiguration::default())
4491        .await
4492        .expect_err("a zero count on its own is not an action");
4493        assert_eq!(err.to_string(), ERR_LIFECYCLE_RULE_MUST_HAVE_ACTION);
4494    }
4495
4496    #[tokio::test]
4497    async fn validate_accepts_count_only_noncurrent_expiration() {
4498        // MinIO extension: NewerNoncurrentVersions with no NoncurrentDays. It
4499        // used to be rejected as an actionless rule (backlog#2201).
4500        let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4501            noncurrent_days: None,
4502            newer_noncurrent_versions: Some(2),
4503        })]);
4504
4505        lc.validate(&ObjectLockConfiguration::default())
4506            .await
4507            .expect("a count-only noncurrent expiration rule is accepted");
4508    }
4509
4510    #[tokio::test]
4511    async fn eval_inner_expires_versions_beyond_count_only_retention() {
4512        // Count-only rules have no age condition: everything past the retained
4513        // count is due as soon as it became noncurrent.
4514        let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4515            noncurrent_days: None,
4516            newer_noncurrent_versions: Some(2),
4517        })]);
4518        let opts = ObjectOpts {
4519            name: "obj".to_string(),
4520            mod_time: Some(datetime!(2025-01-15 10:30:45 UTC)),
4521            successor_mod_time: Some(datetime!(2025-01-15 10:30:45 UTC)),
4522            is_latest: false,
4523            num_versions: 5,
4524            ..Default::default()
4525        };
4526
4527        // Rank 2 is the third-newest noncurrent version: past a retention of 2.
4528        let expired = lc.eval_inner(&opts, datetime!(2025-01-15 10:30:46 UTC), 2).await;
4529        assert_eq!(expired.action, IlmAction::DeleteVersionAction);
4530        assert_eq!(expired.rule_id, "noncurrent");
4531
4532        // Rank 1 is still within the retained count.
4533        let retained = lc.eval_inner(&opts, datetime!(2025-01-15 10:30:46 UTC), 1).await;
4534        assert_eq!(retained.action, IlmAction::NoneAction);
4535    }
4536
4537    #[tokio::test]
4538    #[serial]
4539    async fn eval_inner_keeps_age_condition_when_count_and_days_are_set() {
4540        // With both set, the count gates which versions are candidates and the
4541        // age condition still decides when they are due.
4542        with_default_ilm_process_time(|| {});
4543        let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4544            noncurrent_days: Some(10),
4545            newer_noncurrent_versions: Some(1),
4546        })]);
4547        let opts = ObjectOpts {
4548            name: "obj".to_string(),
4549            mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4550            successor_mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4551            is_latest: false,
4552            num_versions: 3,
4553            ..Default::default()
4554        };
4555
4556        let too_young = lc.eval_inner(&opts, datetime!(2025-01-05 00:00:00 UTC), 2).await;
4557        assert_eq!(too_young.action, IlmAction::NoneAction, "the age condition still applies");
4558
4559        let due = lc.eval_inner(&opts, datetime!(2025-01-20 00:00:00 UTC), 2).await;
4560        assert_eq!(due.action, IlmAction::DeleteVersionAction);
4561    }
4562
4563    #[tokio::test]
4564    async fn eval_inner_takes_no_action_for_a_corrupt_retention_count() {
4565        // Reachable only from older persistence or an import; it must not be
4566        // read as "retain everything", and it must not delete either.
4567        let lc = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4568            noncurrent_days: Some(1),
4569            newer_noncurrent_versions: Some(-1),
4570        })]);
4571        let opts = ObjectOpts {
4572            name: "obj".to_string(),
4573            mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4574            successor_mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4575            is_latest: false,
4576            num_versions: 3,
4577            ..Default::default()
4578        };
4579
4580        let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 2).await;
4581
4582        assert_eq!(event.action, IlmAction::NoneAction);
4583    }
4584
4585    #[tokio::test]
4586    async fn eval_inner_does_not_expire_latest_object_for_a_corrupt_retention_rule() {
4587        let mut rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4588            noncurrent_days: Some(1),
4589            newer_noncurrent_versions: Some(-1),
4590        });
4591        rule.expiration = Some(LifecycleExpiration {
4592            days: Some(1),
4593            ..Default::default()
4594        });
4595        let lc = config_with_rules(vec![rule]);
4596        let opts = ObjectOpts {
4597            name: "obj".to_string(),
4598            mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4599            is_latest: true,
4600            ..Default::default()
4601        };
4602
4603        let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 0).await;
4604
4605        assert_eq!(event.action, IlmAction::NoneAction);
4606    }
4607
4608    #[tokio::test]
4609    async fn eval_inner_does_not_delete_latest_marker_for_a_corrupt_retention_rule() {
4610        let mut expired_marker_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4611            noncurrent_days: Some(1),
4612            newer_noncurrent_versions: Some(-1),
4613        });
4614        expired_marker_rule.expiration = Some(LifecycleExpiration {
4615            expired_object_delete_marker: Some(true),
4616            ..Default::default()
4617        });
4618
4619        let mut aged_marker_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4620            noncurrent_days: Some(1),
4621            newer_noncurrent_versions: Some(-1),
4622        });
4623        aged_marker_rule.del_marker_expiration = Some(s3s::dto::DelMarkerExpiration { days: Some(1) });
4624
4625        for rule in [expired_marker_rule, aged_marker_rule] {
4626            let lc = config_with_rules(vec![rule]);
4627            let opts = ObjectOpts {
4628                name: "obj".to_string(),
4629                mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4630                version_id: Some(Uuid::new_v4()),
4631                is_latest: true,
4632                delete_marker: true,
4633                num_versions: 1,
4634                ..Default::default()
4635            };
4636
4637            let event = lc.eval_inner(&opts, datetime!(2025-06-01 00:00:00 UTC), 0).await;
4638
4639            assert_eq!(event.action, IlmAction::NoneAction);
4640        }
4641    }
4642
4643    #[test]
4644    fn corrupt_retention_count_is_detected_on_either_action() {
4645        let mut transition_rule = rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4646            noncurrent_days: Some(1),
4647            newer_noncurrent_versions: Some(0),
4648        });
4649        transition_rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4650            newer_noncurrent_versions: Some(-1),
4651            noncurrent_days: Some(1),
4652            storage_class: Some(TransitionStorageClass::from_static(TransitionStorageClass::GLACIER)),
4653        }]);
4654
4655        assert!(lifecycle_has_corrupt_retention_count(&config_with_rules(vec![
4656            rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4657                noncurrent_days: Some(1),
4658                newer_noncurrent_versions: Some(-1),
4659            })
4660        ])));
4661        assert!(lifecycle_has_corrupt_retention_count(&config_with_rules(vec![transition_rule])));
4662        assert!(!lifecycle_has_corrupt_retention_count(&config_with_rules(vec![
4663            rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4664                noncurrent_days: Some(1),
4665                newer_noncurrent_versions: Some(3),
4666            })
4667        ])));
4668    }
4669
4670    #[test]
4671    fn count_only_rules_are_active_only_for_a_positive_count() {
4672        let positive = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4673            noncurrent_days: None,
4674            newer_noncurrent_versions: Some(2),
4675        })]);
4676        assert!(positive.has_active_rules(""));
4677
4678        let corrupt = config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4679            noncurrent_days: None,
4680            newer_noncurrent_versions: Some(-1),
4681        })]);
4682        assert!(!corrupt.has_active_rules(""), "a corrupt retention count must not make a rule active");
4683    }
4684
4685    #[tokio::test]
4686    async fn noncurrent_versions_expiration_limit_ignores_a_corrupt_count() {
4687        // The batch path must not read a negative count as "retain everything".
4688        let lc = Arc::new(config_with_rules(vec![rule_with_noncurrent_expiration(NoncurrentVersionExpiration {
4689            noncurrent_days: Some(1),
4690            newer_noncurrent_versions: Some(-1),
4691        })]));
4692        let opts = ObjectOpts {
4693            name: "obj".to_string(),
4694            mod_time: Some(datetime!(2025-01-01 00:00:00 UTC)),
4695            is_latest: false,
4696            ..Default::default()
4697        };
4698
4699        let event = lc.noncurrent_versions_expiration_limit(&opts).await;
4700
4701        assert_eq!(event.action, IlmAction::NoneAction);
4702        assert_eq!(event.newer_noncurrent_versions, 0);
4703    }
4704
4705    #[tokio::test]
4706    async fn validate_covers_filter_invariants() {
4707        struct Case {
4708            name: &'static str,
4709            filter: LifecycleRuleFilter,
4710            expected: Option<(&'static str, std::io::ErrorKind)>,
4711        }
4712
4713        let cases = vec![
4714            Case {
4715                // AWS documents an empty Filter as "every object in the bucket".
4716                name: "empty filter applies to all objects",
4717                filter: LifecycleRuleFilter::default(),
4718                expected: None,
4719            },
4720            Case {
4721                name: "single prefix predicate",
4722                filter: LifecycleRuleFilter {
4723                    prefix: Some("logs/".to_string()),
4724                    ..Default::default()
4725                },
4726                expected: None,
4727            },
4728            Case {
4729                name: "two top-level predicates",
4730                filter: LifecycleRuleFilter {
4731                    prefix: Some("logs/".to_string()),
4732                    tag: Some(tag("env", "prod")),
4733                    ..Default::default()
4734                },
4735                expected: Some((ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4736            },
4737            Case {
4738                name: "prefix alongside And",
4739                filter: LifecycleRuleFilter {
4740                    prefix: Some("logs/".to_string()),
4741                    and: Some(LifecycleRuleAndOperator {
4742                        prefix: Some("logs/".to_string()),
4743                        tags: Some(vec![tag("env", "prod")]),
4744                        ..Default::default()
4745                    }),
4746                    ..Default::default()
4747                },
4748                expected: Some((ERR_LIFECYCLE_FILTER_TOO_MANY_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4749            },
4750            Case {
4751                name: "And with a single member",
4752                filter: LifecycleRuleFilter {
4753                    and: Some(LifecycleRuleAndOperator {
4754                        prefix: Some("logs/".to_string()),
4755                        ..Default::default()
4756                    }),
4757                    ..Default::default()
4758                },
4759                expected: Some((ERR_LIFECYCLE_FILTER_AND_TOO_FEW_PREDICATES, LIFECYCLE_MALFORMED_XML_ERROR_KIND)),
4760            },
4761            Case {
4762                name: "And with two members",
4763                filter: LifecycleRuleFilter {
4764                    and: Some(LifecycleRuleAndOperator {
4765                        prefix: Some("logs/".to_string()),
4766                        tags: Some(vec![tag("env", "prod")]),
4767                        ..Default::default()
4768                    }),
4769                    ..Default::default()
4770                },
4771                expected: None,
4772            },
4773            Case {
4774                name: "And with two tags",
4775                filter: LifecycleRuleFilter {
4776                    and: Some(LifecycleRuleAndOperator {
4777                        tags: Some(vec![tag("env", "prod"), tag("team", "storage")]),
4778                        ..Default::default()
4779                    }),
4780                    ..Default::default()
4781                },
4782                expected: None,
4783            },
4784            Case {
4785                name: "And repeating a tag key",
4786                filter: LifecycleRuleFilter {
4787                    and: Some(LifecycleRuleAndOperator {
4788                        tags: Some(vec![tag("env", "prod"), tag("env", "dev")]),
4789                        ..Default::default()
4790                    }),
4791                    ..Default::default()
4792                },
4793                expected: Some((ERR_LIFECYCLE_FILTER_DUPLICATE_TAG_KEY, std::io::ErrorKind::Other)),
4794            },
4795            Case {
4796                name: "empty tag key",
4797                filter: LifecycleRuleFilter {
4798                    tag: Some(tag("", "prod")),
4799                    ..Default::default()
4800                },
4801                expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4802            },
4803            Case {
4804                name: "missing tag key",
4805                filter: LifecycleRuleFilter {
4806                    tag: Some(s3s::dto::Tag {
4807                        key: None,
4808                        value: Some("prod".to_string()),
4809                    }),
4810                    ..Default::default()
4811                },
4812                expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4813            },
4814            Case {
4815                name: "missing tag value",
4816                filter: LifecycleRuleFilter {
4817                    tag: Some(s3s::dto::Tag {
4818                        key: Some("env".to_string()),
4819                        value: None,
4820                    }),
4821                    ..Default::default()
4822                },
4823                expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4824            },
4825            Case {
4826                name: "empty tag value",
4827                filter: LifecycleRuleFilter {
4828                    tag: Some(tag("env", "")),
4829                    ..Default::default()
4830                },
4831                expected: None,
4832            },
4833            Case {
4834                name: "tag key at the limit",
4835                filter: LifecycleRuleFilter {
4836                    tag: Some(tag(&"k".repeat(MAX_TAG_KEY_LEN), "prod")),
4837                    ..Default::default()
4838                },
4839                expected: None,
4840            },
4841            Case {
4842                name: "tag key past the limit",
4843                filter: LifecycleRuleFilter {
4844                    tag: Some(tag(&"k".repeat(MAX_TAG_KEY_LEN + 1), "prod")),
4845                    ..Default::default()
4846                },
4847                expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4848            },
4849            Case {
4850                name: "tag value past the limit",
4851                filter: LifecycleRuleFilter {
4852                    tag: Some(tag("env", &"v".repeat(MAX_TAG_VALUE_LEN + 1))),
4853                    ..Default::default()
4854                },
4855                expected: Some((ERR_LIFECYCLE_FILTER_INVALID_TAG, std::io::ErrorKind::Other)),
4856            },
4857            Case {
4858                name: "negative ObjectSizeGreaterThan",
4859                filter: LifecycleRuleFilter {
4860                    object_size_greater_than: Some(-1),
4861                    ..Default::default()
4862                },
4863                expected: Some((ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE, std::io::ErrorKind::Other)),
4864            },
4865            Case {
4866                name: "negative ObjectSizeLessThan",
4867                filter: LifecycleRuleFilter {
4868                    object_size_less_than: Some(-5),
4869                    ..Default::default()
4870                },
4871                expected: Some((ERR_LIFECYCLE_FILTER_NEGATIVE_SIZE, std::io::ErrorKind::Other)),
4872            },
4873            Case {
4874                name: "inverted size range inside And",
4875                filter: LifecycleRuleFilter {
4876                    and: Some(LifecycleRuleAndOperator {
4877                        object_size_greater_than: Some(100),
4878                        object_size_less_than: Some(100),
4879                        ..Default::default()
4880                    }),
4881                    ..Default::default()
4882                },
4883                expected: Some((ERR_LIFECYCLE_FILTER_SIZE_RANGE, std::io::ErrorKind::Other)),
4884            },
4885            Case {
4886                name: "valid size range inside And",
4887                filter: LifecycleRuleFilter {
4888                    and: Some(LifecycleRuleAndOperator {
4889                        object_size_greater_than: Some(1),
4890                        object_size_less_than: Some(2),
4891                        ..Default::default()
4892                    }),
4893                    ..Default::default()
4894                },
4895                expected: None,
4896            },
4897        ];
4898
4899        for case in cases {
4900            let result = config_with_rules(vec![rule_with_filter(case.filter)])
4901                .validate(&ObjectLockConfiguration::default())
4902                .await;
4903            match (case.expected, result) {
4904                (None, Ok(())) => {}
4905                (None, Err(err)) => panic!("{}: expected acceptance, got {err}", case.name),
4906                (Some((message, _)), Ok(())) => panic!("{}: expected rejection with {message}", case.name),
4907                (Some((message, kind)), Err(err)) => {
4908                    assert_eq!(err.to_string(), message, "{}", case.name);
4909                    assert_eq!(err.kind(), kind, "{}: wrong S3 error category", case.name);
4910                }
4911            }
4912        }
4913    }
4914
4915    #[tokio::test]
4916    async fn validate_keeps_legacy_prefix_and_filter_mutually_exclusive() {
4917        let mut rule = rule_with_filter(LifecycleRuleFilter {
4918            prefix: Some("logs/".to_string()),
4919            ..Default::default()
4920        });
4921        rule.prefix = Some("legacy/".to_string());
4922
4923        let err = config_with_rules(vec![rule])
4924            .validate(&ObjectLockConfiguration::default())
4925            .await
4926            .expect_err("legacy Prefix and Filter cannot both be present");
4927
4928        assert_eq!(err.to_string(), ERR_LIFECYCLE_PREFIX_FILTER_CONFLICT);
4929    }
4930
4931    #[test]
4932    fn count_only_rule_round_trips_through_xml() {
4933        // The MinIO count-only form has to survive the wire codec, or the rule
4934        // this PR now accepts could not be persisted and read back.
4935        let xml = br#"<LifecycleConfiguration><Rule><ID>count-only</ID><Status>Enabled</Status><Filter></Filter><NoncurrentVersionExpiration><NewerNoncurrentVersions>2</NewerNoncurrentVersions></NoncurrentVersionExpiration></Rule></LifecycleConfiguration>"#;
4936        let mut deserializer = s3s::xml::Deserializer::new(xml);
4937        let parsed =
4938            <BucketLifecycleConfiguration as XmlDeserialize>::deserialize(&mut deserializer).expect("count-only XML parses");
4939
4940        let expiration = parsed.rules[0]
4941            .noncurrent_version_expiration
4942            .as_ref()
4943            .expect("noncurrent expiration is present");
4944        assert_eq!(expiration.newer_noncurrent_versions, Some(2));
4945        assert_eq!(expiration.noncurrent_days, None);
4946
4947        let mut buf = Vec::new();
4948        let mut serializer = s3s::xml::Serializer::new(&mut buf);
4949        XmlSerializeContent::serialize_content(&parsed, &mut serializer).expect("count-only config serializes");
4950        let serialized = String::from_utf8(buf).expect("serialized XML is UTF-8");
4951        assert!(
4952            serialized.contains("<NewerNoncurrentVersions>2</NewerNoncurrentVersions>"),
4953            "retention count survives the round trip: {serialized}"
4954        );
4955        assert!(
4956            !serialized.contains("<NoncurrentDays>"),
4957            "a count-only rule must not gain an age condition: {serialized}"
4958        );
4959    }
4960
4961    mod adversarial_regressions {
4962        use super::*;
4963        use s3s::dto::NoncurrentVersionExpiration;
4964
4965        fn run(test: impl std::future::Future<Output = ()>) {
4966            with_default_ilm_process_time(|| {
4967                tokio::runtime::Builder::new_current_thread()
4968                    .build()
4969                    .expect("lifecycle regression runtime should build")
4970                    .block_on(test);
4971            });
4972        }
4973
4974        fn noncurrent_object() -> ObjectOpts {
4975            ObjectOpts {
4976                name: "logs/object".to_string(),
4977                mod_time: Some(datetime!(2020-01-01 00:00:00 UTC)),
4978                successor_mod_time: Some(datetime!(2020-01-02 00:00:00 UTC)),
4979                version_id: Some(Uuid::from_u128(1)),
4980                size: 1024 * 1024,
4981                ..Default::default()
4982            }
4983        }
4984
4985        #[test]
4986        #[serial]
4987        fn noncurrent_transition_retains_the_requested_newer_versions() {
4988            run(async {
4989                let mut rule = enabled_rule(None, None, Some("retain-two-hot-versions"));
4990                rule.filter = Some(LifecycleRuleFilter::default());
4991                rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
4992                    noncurrent_days: Some(1),
4993                    newer_noncurrent_versions: Some(2),
4994                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
4995                }]);
4996                let lc = Arc::new(BucketLifecycleConfiguration {
4997                    rules: vec![rule],
4998                    expiry_updated_at: None,
4999                });
5000                lc.validate(&ObjectLockConfiguration::default())
5001                    .await
5002                    .expect("valid noncurrent transition policy");
5003                let objects = (0..4)
5004                    .map(|index| ObjectOpts {
5005                        mod_time: Some(datetime!(2020-01-05 00:00:00 UTC) - Duration::days(index)),
5006                        successor_mod_time: (index > 0).then_some(datetime!(2020-01-06 00:00:00 UTC) - Duration::days(index)),
5007                        version_id: Some(Uuid::from_u128(u128::try_from(index + 1).expect("small version index"))),
5008                        is_latest: index == 0,
5009                        num_versions: 4,
5010                        ..noncurrent_object()
5011                    })
5012                    .collect::<Vec<_>>();
5013                let actions = crate::Evaluator::new(lc)
5014                    .eval(&objects)
5015                    .await
5016                    .expect("complete version chain should evaluate")
5017                    .into_iter()
5018                    .map(|event| event.action)
5019                    .collect::<Vec<_>>();
5020                assert_eq!(
5021                    actions,
5022                    [
5023                        IlmAction::NoneAction,
5024                        IlmAction::NoneAction,
5025                        IlmAction::NoneAction,
5026                        IlmAction::TransitionVersionAction
5027                    ],
5028                    "the two newest noncurrent versions must remain in their current storage class"
5029                );
5030            });
5031        }
5032
5033        #[test]
5034        #[serial]
5035        fn noncurrent_transition_checks_count_age_and_single_object_context() {
5036            run(async {
5037                let mut rule = enabled_rule(None, None, Some("retain-two"));
5038                rule.filter = Some(LifecycleRuleFilter::default());
5039                rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5040                    noncurrent_days: Some(3),
5041                    newer_noncurrent_versions: Some(2),
5042                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
5043                }]);
5044                let mut lc = BucketLifecycleConfiguration {
5045                    rules: vec![rule],
5046                    expiry_updated_at: None,
5047                };
5048                lc.validate(&ObjectLockConfiguration::default())
5049                    .await
5050                    .expect("valid counted transition");
5051                let object = noncurrent_object();
5052                let now = datetime!(2020-01-10 00:00:00 UTC);
5053                for (newer, expected) in [
5054                    (0, IlmAction::NoneAction),
5055                    (1, IlmAction::NoneAction),
5056                    (2, IlmAction::TransitionVersionAction),
5057                    (3, IlmAction::TransitionVersionAction),
5058                ] {
5059                    assert_eq!(lc.eval_inner(&object, now, newer).await.action, expected, "newer count: {newer}");
5060                }
5061                assert_eq!(
5062                    lc.eval_inner(&object, datetime!(2020-01-04 00:00:00 UTC), 2).await.action,
5063                    IlmAction::NoneAction,
5064                    "the retention count does not replace the age condition"
5065                );
5066                assert_eq!(
5067                    lc.eval(&object).await.action,
5068                    IlmAction::NoneAction,
5069                    "a single-object lookup must not assume a complete version history"
5070                );
5071                for retain in [None, Some(0), Some(-1), Some(i32::MAX)] {
5072                    lc.rules[0]
5073                        .noncurrent_version_transitions
5074                        .as_mut()
5075                        .expect("transition exists")[0]
5076                        .newer_noncurrent_versions = retain;
5077                    let expected = if matches!(retain, None | Some(0)) {
5078                        IlmAction::TransitionVersionAction
5079                    } else {
5080                        IlmAction::NoneAction
5081                    };
5082                    assert_eq!(lc.eval_inner(&object, now, 2).await.action, expected, "retention: {retain:?}");
5083                }
5084            });
5085        }
5086
5087        #[test]
5088        #[serial]
5089        fn noncurrent_expiration_and_transition_have_independent_retention_counts() {
5090            run(async {
5091                let mut rule = enabled_rule(None, None, Some("independent-counts"));
5092                rule.filter = Some(LifecycleRuleFilter::default());
5093                rule.noncurrent_version_expiration = Some(NoncurrentVersionExpiration {
5094                    noncurrent_days: Some(90),
5095                    newer_noncurrent_versions: Some(4),
5096                });
5097                rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5098                    noncurrent_days: Some(30),
5099                    newer_noncurrent_versions: Some(2),
5100                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
5101                }]);
5102                let lc = BucketLifecycleConfiguration {
5103                    rules: vec![rule],
5104                    expiry_updated_at: None,
5105                };
5106                lc.validate(&ObjectLockConfiguration::default())
5107                    .await
5108                    .expect("valid independent retention limits");
5109                let object = noncurrent_object();
5110                let now = datetime!(2020-05-01 00:00:00 UTC);
5111                for (newer, expected) in [
5112                    (1, IlmAction::NoneAction),
5113                    (2, IlmAction::TransitionVersionAction),
5114                    (3, IlmAction::TransitionVersionAction),
5115                    (4, IlmAction::DeleteVersionAction),
5116                ] {
5117                    assert_eq!(lc.eval_inner(&object, now, newer).await.action, expected, "newer count: {newer}");
5118                }
5119            });
5120        }
5121
5122        #[test]
5123        #[serial]
5124        fn expiration_retention_does_not_skip_an_independent_transition() {
5125            run(async {
5126                let mut rule = enabled_rule(None, None, Some("transition-then-expire"));
5127                rule.filter = Some(LifecycleRuleFilter::default());
5128                rule.noncurrent_version_transitions = Some(vec![NoncurrentVersionTransition {
5129                    noncurrent_days: Some(1),
5130                    newer_noncurrent_versions: None,
5131                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
5132                }]);
5133                let mut lc = BucketLifecycleConfiguration {
5134                    rules: vec![rule],
5135                    expiry_updated_at: None,
5136                };
5137                let object = noncurrent_object();
5138                let now = datetime!(2020-01-10 00:00:00 UTC);
5139                let transition_only = lc.eval_inner(&object, now, 0).await;
5140                assert_eq!(transition_only.action, IlmAction::TransitionVersionAction);
5141
5142                lc.rules[0].noncurrent_version_expiration = Some(NoncurrentVersionExpiration {
5143                    noncurrent_days: Some(90),
5144                    newer_noncurrent_versions: Some(2),
5145                });
5146                lc.validate(&ObjectLockConfiguration::default())
5147                    .await
5148                    .expect("valid combined policy");
5149                let combined = lc.eval_inner(&object, now, 0).await;
5150                assert_eq!(combined.action, transition_only.action, "retention limits expiration, not transition");
5151                assert_eq!(combined.storage_class, transition_only.storage_class);
5152            });
5153        }
5154
5155        #[test]
5156        #[serial]
5157        fn current_transition_rejects_multiple_stages_in_any_order() {
5158            run(async {
5159                let mut rule = enabled_rule(None, None, Some("two-current-transitions"));
5160                rule.transitions = Some(vec![
5161                    Transition {
5162                        date: Some(datetime!(2020-03-01 00:00:00 UTC).into()),
5163                        days: None,
5164                        storage_class: Some(TransitionStorageClass::from_static("COLD")),
5165                    },
5166                    Transition {
5167                        date: Some(datetime!(2020-01-03 00:00:00 UTC).into()),
5168                        days: None,
5169                        storage_class: Some(TransitionStorageClass::from_static("WARM")),
5170                    },
5171                ]);
5172                let mut lc = BucketLifecycleConfiguration {
5173                    rules: vec![rule],
5174                    expiry_updated_at: None,
5175                };
5176                let object = ObjectOpts {
5177                    is_latest: true,
5178                    ..noncurrent_object()
5179                };
5180                let now = datetime!(2020-01-10 00:00:00 UTC);
5181                for status in [ExpirationStatus::ENABLED, ExpirationStatus::DISABLED] {
5182                    lc.rules[0].status = ExpirationStatus::from_static(status);
5183                    for _ in 0..2 {
5184                        let err = lc
5185                            .validate(&ObjectLockConfiguration::default())
5186                            .await
5187                            .expect_err("multiple transition stages must be rejected");
5188                        assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5189                        assert_eq!(err.to_string(), ERR_LIFECYCLE_MULTIPLE_TRANSITIONS);
5190                        assert_eq!(
5191                            lc.eval_inner(&object, now, 0).await.action,
5192                            IlmAction::NoneAction,
5193                            "legacy multi-stage configurations must not silently execute their first stage"
5194                        );
5195                        lc.rules[0]
5196                            .transitions
5197                            .as_mut()
5198                            .expect("transition array is present")
5199                            .reverse();
5200                    }
5201                }
5202                lc.rules[0]
5203                    .transitions
5204                    .as_mut()
5205                    .expect("transition array is present")
5206                    .remove(0);
5207                lc.rules[0].status = ExpirationStatus::from_static(ExpirationStatus::ENABLED);
5208                lc.validate(&ObjectLockConfiguration::default())
5209                    .await
5210                    .expect("one stage is supported");
5211                let event = lc.eval_inner(&object, now, 0).await;
5212                assert_eq!(event.action, IlmAction::TransitionAction);
5213                assert_eq!(event.storage_class, "WARM");
5214            });
5215        }
5216
5217        #[test]
5218        #[serial]
5219        fn noncurrent_transition_rejects_multiple_stages_in_any_order() {
5220            run(async {
5221                let mut rule = enabled_rule(None, None, Some("two-noncurrent-transitions"));
5222                rule.noncurrent_version_transitions = Some(vec![
5223                    NoncurrentVersionTransition {
5224                        noncurrent_days: Some(30),
5225                        newer_noncurrent_versions: None,
5226                        storage_class: Some(TransitionStorageClass::from_static("COLD")),
5227                    },
5228                    NoncurrentVersionTransition {
5229                        noncurrent_days: Some(1),
5230                        newer_noncurrent_versions: None,
5231                        storage_class: Some(TransitionStorageClass::from_static("WARM")),
5232                    },
5233                ]);
5234                let mut lc = BucketLifecycleConfiguration {
5235                    rules: vec![rule],
5236                    expiry_updated_at: None,
5237                };
5238                let object = noncurrent_object();
5239                let now = datetime!(2020-01-10 00:00:00 UTC);
5240                for status in [ExpirationStatus::ENABLED, ExpirationStatus::DISABLED] {
5241                    lc.rules[0].status = ExpirationStatus::from_static(status);
5242                    for _ in 0..2 {
5243                        let err = lc
5244                            .validate(&ObjectLockConfiguration::default())
5245                            .await
5246                            .expect_err("multiple noncurrent transition stages must be rejected");
5247                        assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5248                        assert_eq!(err.to_string(), ERR_LIFECYCLE_MULTIPLE_NONCURRENT_TRANSITIONS);
5249                        assert_eq!(
5250                            lc.eval_inner(&object, now, 0).await.action,
5251                            IlmAction::NoneAction,
5252                            "legacy multi-stage configurations must not silently execute their first stage"
5253                        );
5254                        lc.rules[0]
5255                            .noncurrent_version_transitions
5256                            .as_mut()
5257                            .expect("transition array is present")
5258                            .reverse();
5259                    }
5260                }
5261                lc.rules[0]
5262                    .noncurrent_version_transitions
5263                    .as_mut()
5264                    .expect("transition array is present")
5265                    .remove(0);
5266                lc.rules[0].status = ExpirationStatus::from_static(ExpirationStatus::ENABLED);
5267                lc.validate(&ObjectLockConfiguration::default())
5268                    .await
5269                    .expect("one stage is supported");
5270                let event = lc.eval_inner(&object, now, 0).await;
5271                assert_eq!(event.action, IlmAction::TransitionVersionAction);
5272                assert_eq!(event.storage_class, "WARM");
5273            });
5274        }
5275
5276        #[test]
5277        #[serial]
5278        fn expiration_rejects_simultaneous_days_and_date() {
5279            run(async {
5280                let mut lc = BucketLifecycleConfiguration {
5281                    rules: vec![enabled_rule(
5282                        Some(LifecycleExpiration {
5283                            days: Some(1),
5284                            ..Default::default()
5285                        }),
5286                        None,
5287                        Some("ambiguous-expiry"),
5288                    )],
5289                    expiry_updated_at: None,
5290                };
5291                lc.validate(&ObjectLockConfiguration::default())
5292                    .await
5293                    .expect("a single Days expiration is valid");
5294                lc.rules[0].expiration.as_mut().expect("expiration is present").date =
5295                    Some(datetime!(2099-01-01 00:00:00 UTC).into());
5296                let err = lc
5297                    .validate(&ObjectLockConfiguration::default())
5298                    .await
5299                    .expect_err("Days and Date are mutually exclusive; accepting both silently overrides Days");
5300                assert_eq!(err.kind(), std::io::ErrorKind::InvalidInput);
5301                assert_eq!(err.to_string(), ERR_LIFECYCLE_EXPIRATION_DAYS_DATE_CONFLICT);
5302            });
5303        }
5304
5305        #[test]
5306        #[serial]
5307        fn overdue_transition_does_not_starve_permanent_expiration() {
5308            run(async {
5309                let mut rule = enabled_rule(
5310                    Some(LifecycleExpiration {
5311                        days: Some(90),
5312                        ..Default::default()
5313                    }),
5314                    None,
5315                    Some("archive-then-delete"),
5316                );
5317                rule.transitions = Some(vec![Transition {
5318                    days: Some(30),
5319                    date: None,
5320                    storage_class: Some(TransitionStorageClass::from_static("WARM")),
5321                }]);
5322                let lc = BucketLifecycleConfiguration {
5323                    rules: vec![rule],
5324                    expiry_updated_at: None,
5325                };
5326                lc.validate(&ObjectLockConfiguration::default())
5327                    .await
5328                    .expect("valid transition and expiration policy");
5329                let object = ObjectOpts {
5330                    is_latest: true,
5331                    version_id: None,
5332                    transition_status: TRANSITION_PENDING.to_string(),
5333                    ..noncurrent_object()
5334                };
5335                let before_expiration = lc.eval_inner(&object, datetime!(2020-02-15 00:00:00 UTC), 0).await;
5336                assert_eq!(before_expiration.action, IlmAction::TransitionAction);
5337                let overdue = lc.eval_inner(&object, datetime!(2020-05-01 00:00:00 UTC), 0).await;
5338                assert_eq!(
5339                    overdue.action,
5340                    IlmAction::DeleteAction,
5341                    "an unavailable tier must not prevent permanent expiration indefinitely"
5342                );
5343            });
5344        }
5345    }
5346
5347    /// Property-based tests for the rule evaluator (backlog#1148 ilm-14,
5348    /// follow-up to backlog#1030 / rustfs#4455).
5349    ///
5350    /// backlog#1030 found that the old hand-written winner comparator was not a
5351    /// strict weak ordering and could panic — proof that enumerated cases do
5352    /// not cover the space of colliding events. These properties pin, over
5353    /// randomized rule sets and object states:
5354    ///
5355    /// * `eval_inner` never panics and is deterministic for a fixed input;
5356    /// * the winning event matches an independently recomputed candidate set:
5357    ///   eligible expiration wins over transition, then earliest `due` wins (the
5358    ///   `min_by_key` selection that replaced the rustfs#4455 comparator);
5359    /// * `expected_expiry_time` is monotonically non-decreasing in `days` and
5360    ///   always lands on the processing boundary, both at production defaults
5361    ///   and under an explicit `RUSTFS_ILM_PROCESS_TIME`.
5362    ///
5363    /// Case counts are tuned so the whole module runs in seconds inside the
5364    /// default CI test job.
5365    mod proptests {
5366        use super::*;
5367        use proptest::prelude::*;
5368        use s3s::dto::{NoncurrentVersionExpiration, Tag};
5369        use serial_test::serial;
5370
5371        const DAY_SECS: i64 = 86400;
5372
5373        /// Fixed positive anchor so generated instants stay in a realistic
5374        /// range; strategies explore offsets around it.
5375        fn base() -> OffsetDateTime {
5376            datetime!(2025-01-01 00:00:00 UTC)
5377        }
5378
5379        fn ts(offset_secs: i64) -> OffsetDateTime {
5380            base() + Duration::seconds(offset_secs)
5381        }
5382
5383        /// Pin the day length and processing boundary to production defaults
5384        /// for the duration of `f`. `temp_env` also serializes environment
5385        /// access against the other env-sensitive tests in this file.
5386        fn with_production_time_env<T>(f: impl FnOnce() -> T) -> T {
5387            temp_env::with_vars(
5388                [
5389                    (ENV_ILM_DEBUG_DAY_SECS, None::<&str>),
5390                    (ENV_ILM_PROCESS_TIME, None),
5391                    (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
5392                ],
5393                f,
5394            )
5395        }
5396
5397        fn arb_opt_time(window_secs: i64) -> impl Strategy<Value = Option<OffsetDateTime>> {
5398            prop_oneof![
5399                2 => Just(None),
5400                1 => Just(Some(OffsetDateTime::UNIX_EPOCH)),
5401                5 => (-window_secs..window_secs).prop_map(|s| Some(ts(s))),
5402            ]
5403        }
5404
5405        fn arb_object_name() -> impl Strategy<Value = String> {
5406            prop_oneof![
5407                1 => Just(String::new()),
5408                3 => Just("docs/report.txt".to_string()),
5409                2 => Just("logs/app.log".to_string()),
5410                1 => "[a-z]{1,12}",
5411            ]
5412        }
5413
5414        fn arb_user_tags() -> impl Strategy<Value = String> {
5415            prop_oneof![
5416                Just(String::new()),
5417                Just("env=prod".to_string()),
5418                Just("env=prod&team=storage".to_string()),
5419                Just("team=storage".to_string()),
5420            ]
5421        }
5422
5423        fn arb_transition_status() -> impl Strategy<Value = String> {
5424            prop_oneof![
5425                Just(String::new()),
5426                Just(TRANSITION_PENDING.to_string()),
5427                Just(TRANSITION_COMPLETE.to_string()),
5428            ]
5429        }
5430
5431        prop_compose! {
5432            fn arb_object_identity()(
5433                name in arb_object_name(),
5434                user_tags in arb_user_tags(),
5435                mod_time in arb_opt_time(4 * DAY_SECS),
5436                size in prop_oneof![Just(0usize), (1usize..1_048_576), Just(usize::MAX >> 1)],
5437                version_id in prop_oneof![Just(None), Just(Some(Uuid::nil())), Just(Some(Uuid::from_u128(7)))],
5438                is_latest in any::<bool>(),
5439                delete_marker in any::<bool>(),
5440            ) -> (String, String, Option<OffsetDateTime>, usize, Option<Uuid>, bool, bool) {
5441                (name, user_tags, mod_time, size, version_id, is_latest, delete_marker)
5442            }
5443        }
5444
5445        prop_compose! {
5446            /// Random object state across the version-chain dimensions: chain
5447            /// position (`is_latest` / `num_versions` / `successor_mod_time`),
5448            /// delete markers, suspension, and transition status.
5449            fn arb_object_opts()(
5450                (name, user_tags, mod_time, size, version_id, is_latest, delete_marker) in arb_object_identity(),
5451                num_versions in 0usize..4,
5452                successor_mod_time in arb_opt_time(4 * DAY_SECS),
5453                transition_status in arb_transition_status(),
5454                restore_ongoing in any::<bool>(),
5455                restore_expires in arb_opt_time(2 * DAY_SECS),
5456                versioned in any::<bool>(),
5457                version_suspended in any::<bool>(),
5458            ) -> ObjectOpts {
5459                ObjectOpts {
5460                    name,
5461                    user_tags,
5462                    mod_time,
5463                    size,
5464                    version_id,
5465                    is_latest,
5466                    delete_marker,
5467                    num_versions,
5468                    successor_mod_time,
5469                    transition_status,
5470                    restore_ongoing,
5471                    restore_expires,
5472                    versioned,
5473                    version_suspended,
5474                    ..Default::default()
5475                }
5476            }
5477        }
5478
5479        fn arb_prefix() -> impl Strategy<Value = Option<String>> {
5480            prop_oneof![
5481                3 => Just(None),
5482                1 => Just(Some(String::new())),
5483                2 => Just(Some("docs/".to_string())),
5484                1 => Just(Some("logs/".to_string())),
5485            ]
5486        }
5487
5488        fn arb_filter() -> impl Strategy<Value = Option<LifecycleRuleFilter>> {
5489            prop_oneof![
5490                4 => Just(None),
5491                1 => Just(Some(LifecycleRuleFilter {
5492                    prefix: Some("docs/".to_string()),
5493                    ..Default::default()
5494                })),
5495                1 => Just(Some(LifecycleRuleFilter {
5496                    tag: Some(Tag {
5497                        key: Some("env".to_string()),
5498                        value: Some("prod".to_string()),
5499                    }),
5500                    ..Default::default()
5501                })),
5502                1 => (0i64..2048).prop_map(|gt| Some(LifecycleRuleFilter {
5503                    object_size_greater_than: Some(gt),
5504                    ..Default::default()
5505                })),
5506            ]
5507        }
5508
5509        prop_compose! {
5510            fn arb_expiration()(
5511                date_off in prop::option::of(-2 * DAY_SECS..2 * DAY_SECS),
5512                days in prop::option::of(0i32..4),
5513                delete_marker_flag in prop::option::of(any::<bool>()),
5514                all_versions in prop::option::of(any::<bool>()),
5515            ) -> LifecycleExpiration {
5516                LifecycleExpiration {
5517                    date: date_off.map(|s| ts(s).into()),
5518                    days,
5519                    expired_object_delete_marker: delete_marker_flag,
5520                    expired_object_all_versions: all_versions,
5521                }
5522            }
5523        }
5524
5525        prop_compose! {
5526            fn arb_transition()(
5527                date_off in prop::option::of(-2 * DAY_SECS..2 * DAY_SECS),
5528                days in prop::option::of(0i32..4),
5529                storage_class in prop_oneof![
5530                    Just(None),
5531                    Just(Some(TransitionStorageClass::from_static(""))),
5532                    Just(Some(TransitionStorageClass::from_static("COLD"))),
5533                ],
5534            ) -> Transition {
5535                Transition {
5536                    date: date_off.map(|s| ts(s).into()),
5537                    days,
5538                    storage_class,
5539                }
5540            }
5541        }
5542
5543        prop_compose! {
5544            /// Fully random rule across every dimension the evaluator reads:
5545            /// Days/Date expiration and transition, prefix, tag/size filters,
5546            /// noncurrent actions, delete-marker actions, AllVersions.
5547            fn arb_rule()(
5548                enabled in prop::bool::weighted(0.8),
5549                id in prop::option::of("[a-z]{1,6}"),
5550                prefix in arb_prefix(),
5551                filter in arb_filter(),
5552                expiration in prop::option::of(arb_expiration()),
5553                transitions in prop::option::of(prop::collection::vec(arb_transition(), 0..2)),
5554                nc_exp in prop::option::of((prop::option::of(0i32..4), prop::option::of(0i32..3))),
5555                nc_tr in prop::option::of((prop::option::of(0i32..4), any::<bool>())),
5556                dme_days in prop::option::of(0i32..3),
5557                abort_days in prop::option::of(0i32..3),
5558            ) -> LifecycleRule {
5559                LifecycleRule {
5560                    status: if enabled {
5561                        ExpirationStatus::from_static(ExpirationStatus::ENABLED)
5562                    } else {
5563                        ExpirationStatus::from_static(ExpirationStatus::DISABLED)
5564                    },
5565                    id,
5566                    prefix,
5567                    filter,
5568                    expiration,
5569                    transitions,
5570                    noncurrent_version_expiration: nc_exp.map(|(noncurrent_days, newer_noncurrent_versions)| {
5571                        NoncurrentVersionExpiration {
5572                            noncurrent_days,
5573                            newer_noncurrent_versions,
5574                        }
5575                    }),
5576                    noncurrent_version_transitions: nc_tr.map(|(noncurrent_days, has_sc)| {
5577                        vec![NoncurrentVersionTransition {
5578                            noncurrent_days,
5579                            newer_noncurrent_versions: None,
5580                            storage_class: has_sc.then(|| TransitionStorageClass::from_static("COLD")),
5581                        }]
5582                    }),
5583                    del_marker_expiration: dme_days.map(|days| s3s::dto::DelMarkerExpiration { days: Some(days) }),
5584                    abort_incomplete_multipart_upload: abort_days.map(|days| {
5585                        s3s::dto::AbortIncompleteMultipartUpload {
5586                            days_after_initiation: Some(days),
5587                        }
5588                    }),
5589                }
5590            }
5591        }
5592
5593        proptest! {
5594            #![proptest_config(ProptestConfig::with_cases(96))]
5595
5596            /// `eval_inner` must never panic on any rule/object/now
5597            /// combination, and must be deterministic: the same input
5598            /// evaluated twice yields an identical event.
5599            #[test]
5600            #[serial]
5601            fn eval_inner_never_panics_and_is_deterministic(
5602                rules in prop::collection::vec(arb_rule(), 0..4),
5603                obj in arb_object_opts(),
5604                now_off in (-4 * DAY_SECS)..(8 * DAY_SECS),
5605                newer_noncurrent in 0usize..4,
5606            ) {
5607                let lc = BucketLifecycleConfiguration {
5608                    expiry_updated_at: None,
5609                    rules,
5610                };
5611                let now = ts(now_off);
5612                let (first, second) = block_on_with_env(&[], || async {
5613                    let first = lc.eval_inner(&obj, now, newer_noncurrent).await;
5614                    let second = lc.eval_inner(&obj, now, newer_noncurrent).await;
5615                    (first, second)
5616                });
5617                prop_assert_eq!(first.action, second.action);
5618                prop_assert_eq!(&first.rule_id, &second.rule_id);
5619                prop_assert_eq!(first.due, second.due);
5620                prop_assert_eq!(&first.storage_class, &second.storage_class);
5621            }
5622        }
5623
5624        /// One oracle candidate: `(due unix timestamp, action rank)` with rank
5625        /// 0 for delete-class actions and 1 otherwise.
5626        type Candidate = (i64, u8);
5627
5628        /// Independent re-statement of the delete-class rank. Deliberately NOT
5629        /// `ilm_action_priority_rank`: the winner assertion classifies the
5630        /// actual event with this copy, so a regression in the production rank
5631        /// function cannot silently re-rank both sides of the comparison.
5632        fn oracle_rank(action: &IlmAction) -> u8 {
5633            match action {
5634                IlmAction::DeleteAllVersionsAction
5635                | IlmAction::DelMarkerDeleteAllVersionsAction
5636                | IlmAction::DeleteAction
5637                | IlmAction::DeleteVersionAction => 0,
5638                _ => 1,
5639            }
5640        }
5641
5642        /// Independently recompute the eligible event set `eval_inner` should
5643        /// consider for a live current version under `selection`-shaped rules
5644        /// (expiration and first-transition only, no filters): expiration
5645        /// fires when `now >= due`, transition when `now > due` and the object
5646        /// has not already transitioned. Eligible expiration wins over transition;
5647        /// the earliest deadline wins within the selected action class.
5648        fn oracle_candidates(lc: &BucketLifecycleConfiguration, obj: &ObjectOpts, now: OffsetDateTime) -> Vec<Candidate> {
5649            let mod_time = obj.mod_time.expect("selection strategy always sets mod_time");
5650            let mut candidates = Vec::new();
5651            for rule in &lc.rules {
5652                if let Some(expiration) = &rule.expiration {
5653                    // Mirrors the eval branches: a Date-based expiry needs a
5654                    // non-zero date and fires when `now >= date`; a Days-based
5655                    // expiry fires when `now >= expected_expiry_time`.
5656                    if let Some(date) = &expiration.date {
5657                        let due = OffsetDateTime::from(date.clone());
5658                        if due.unix_timestamp() != 0 && now.unix_timestamp() >= due.unix_timestamp() {
5659                            candidates.push((due.unix_timestamp(), 0));
5660                        }
5661                    } else if let Some(days) = expiration.days {
5662                        let due = expected_expiry_time(mod_time, days);
5663                        if now.unix_timestamp() >= due.unix_timestamp() {
5664                            candidates.push((due.unix_timestamp(), 0));
5665                        }
5666                    }
5667                }
5668                if obj.transition_status != TRANSITION_COMPLETE
5669                    && let Some(transition) = rule.transitions.as_ref().and_then(|transitions| transitions.first())
5670                    && transition.storage_class.as_ref().is_some_and(|sc| !sc.as_str().is_empty())
5671                {
5672                    let due = if let Some(date) = &transition.date {
5673                        Some(OffsetDateTime::from(date.clone()))
5674                    } else {
5675                        transition.days.map(|days| expected_expiry_time(mod_time, days))
5676                    };
5677                    if let Some(due) = due
5678                        && now.unix_timestamp() > due.unix_timestamp()
5679                    {
5680                        candidates.push((due.unix_timestamp(), 1));
5681                    }
5682                }
5683            }
5684            candidates
5685        }
5686
5687        prop_compose! {
5688            /// Rules restricted to the shapes the selection oracle models:
5689            /// enabled, unfiltered, with exactly one of Date/Days per action so
5690            /// the Date-over-Days precedence inside one action never applies.
5691            fn arb_selection_rule()(
5692                kind in 0u8..3,
5693                exp_by_date in any::<bool>(),
5694                exp_date_off in (-2 * DAY_SECS)..(2 * DAY_SECS),
5695                exp_days in 0i32..4,
5696                all_versions in any::<bool>(),
5697                tr_by_date in any::<bool>(),
5698                tr_date_off in (-2 * DAY_SECS)..(2 * DAY_SECS),
5699                tr_days in 0i32..4,
5700                id in "[a-z]{1,6}",
5701            ) -> LifecycleRule {
5702                let expiration = (kind != 1).then(|| LifecycleExpiration {
5703                    date: exp_by_date.then(|| ts(exp_date_off).into()),
5704                    days: (!exp_by_date).then_some(exp_days),
5705                    expired_object_delete_marker: None,
5706                    expired_object_all_versions: all_versions.then_some(true),
5707                });
5708                let transitions = (kind != 0).then(|| {
5709                    vec![Transition {
5710                        date: tr_by_date.then(|| ts(tr_date_off).into()),
5711                        days: (!tr_by_date).then_some(tr_days),
5712                        storage_class: Some(TransitionStorageClass::from_static("COLD")),
5713                    }]
5714                });
5715                LifecycleRule {
5716                    status: ExpirationStatus::from_static(ExpirationStatus::ENABLED),
5717                    id: Some(id),
5718                    prefix: None,
5719                    filter: None,
5720                    expiration,
5721                    transitions,
5722                    noncurrent_version_expiration: None,
5723                    noncurrent_version_transitions: None,
5724                    del_marker_expiration: None,
5725                    abort_incomplete_multipart_upload: None,
5726                }
5727            }
5728        }
5729
5730        proptest! {
5731            #![proptest_config(ProptestConfig::with_cases(128))]
5732
5733            /// Differential test of winner selection (the rustfs#4455 fix):
5734            /// for a live current version under randomized expiration and
5735            /// transition rules, `eval_inner`'s winner must carry the
5736            /// earliest expiration from the independently recomputed candidate
5737            /// set, or the earliest transition when no expiration is eligible,
5738            /// and must be `NoneAction` exactly when that set is empty.
5739            #[test]
5740            #[serial]
5741            fn eval_inner_winner_matches_selection_oracle(
5742                rules in prop::collection::vec(arb_selection_rule(), 0..5),
5743                mod_off in 0i64..(2 * DAY_SECS),
5744                now_off in (-DAY_SECS)..(6 * DAY_SECS),
5745                already_transitioned in any::<bool>(),
5746            ) {
5747                let lc = BucketLifecycleConfiguration {
5748                    expiry_updated_at: None,
5749                    rules,
5750                };
5751                let obj = ObjectOpts {
5752                    name: "docs/report.txt".to_string(),
5753                    mod_time: Some(ts(mod_off)),
5754                    is_latest: true,
5755                    transition_status: if already_transitioned {
5756                        TRANSITION_COMPLETE.to_string()
5757                    } else {
5758                        String::new()
5759                    },
5760                    ..Default::default()
5761                };
5762                let now = ts(now_off);
5763
5764                // Oracle and evaluator must observe the same (pinned) time env.
5765                let (event, expected) = with_production_time_env(|| {
5766                    let candidates = oracle_candidates(&lc, &obj, now);
5767                    let expected = candidates
5768                        .iter()
5769                        .filter(|(_, rank)| *rank == 0)
5770                        .min()
5771                        .copied()
5772                        .or_else(|| candidates.into_iter().min());
5773                    let rt = tokio::runtime::Builder::new_current_thread()
5774                        .enable_all()
5775                        .build()
5776                        .expect("build runtime");
5777                    let event = rt.block_on(lc.eval_inner(&obj, now, 0));
5778                    (event, expected)
5779                });
5780
5781                match expected {
5782                    None => prop_assert_eq!(event.action, IlmAction::NoneAction),
5783                    Some((due_ts, rank)) => {
5784                        prop_assert_ne!(event.action, IlmAction::NoneAction);
5785                        let actual_due = event.due.expect("winning event carries a due").unix_timestamp();
5786                        prop_assert_eq!(actual_due, due_ts);
5787                        prop_assert_eq!(oracle_rank(&event.action), rank);
5788                    }
5789                }
5790            }
5791        }
5792
5793        proptest! {
5794            #![proptest_config(ProptestConfig::with_cases(256))]
5795
5796            /// At production defaults `expected_expiry_time` is monotonically
5797            /// non-decreasing in `days` (days == 0 maps to UNIX_EPOCH, below
5798            /// any post-1970 deadline).
5799            #[test]
5800            #[serial]
5801            fn expected_expiry_time_is_monotonic_in_days(
5802                mod_off in 0i64..(3650 * DAY_SECS),
5803                d1 in 0i32..2000,
5804                d2 in 0i32..2000,
5805            ) {
5806                let (lo, hi) = if d1 <= d2 { (d1, d2) } else { (d2, d1) };
5807                let mod_time = ts(mod_off);
5808                let (e_lo, e_hi) = with_production_time_env(|| {
5809                    (expected_expiry_time(mod_time, lo), expected_expiry_time(mod_time, hi))
5810                });
5811                prop_assert!(
5812                    e_lo <= e_hi,
5813                    "expected_expiry_time not monotonic: days={} -> {:?}, days={} -> {:?}",
5814                    lo, e_lo, hi, e_hi
5815                );
5816            }
5817
5818            /// At production defaults every Days-based deadline is rounded up
5819            /// to the next whole-day boundary: the result is day-aligned, not
5820            /// before `mod_time + days`, and less than one boundary beyond it.
5821            #[test]
5822            #[serial]
5823            fn expected_expiry_time_lands_on_default_day_boundary(
5824                mod_off in 0i64..(3650 * DAY_SECS),
5825                days in 1i32..2000,
5826            ) {
5827                let mod_time = ts(mod_off);
5828                let result = with_production_time_env(|| expected_expiry_time(mod_time, days));
5829                let boundary_nanos = i128::from(DAY_SECS) * 1_000_000_000;
5830                prop_assert_eq!(result.unix_timestamp_nanos().rem_euclid(boundary_nanos), 0);
5831                let raw = mod_time + Duration::seconds(i64::from(days) * DAY_SECS);
5832                prop_assert!(result >= raw);
5833                prop_assert!(result - raw < Duration::seconds(DAY_SECS));
5834            }
5835
5836            /// With an explicit `RUSTFS_ILM_PROCESS_TIME`, deadlines round up
5837            /// to that boundary instead: aligned to it, never early, and less
5838            /// than one boundary late.
5839            #[test]
5840            #[serial]
5841            fn expected_expiry_time_lands_on_explicit_process_boundary(
5842                mod_off in 0i64..(365 * DAY_SECS),
5843                days in 1i32..400,
5844                boundary in 1u32..7200,
5845            ) {
5846                let mod_time = ts(mod_off);
5847                let boundary_str = boundary.to_string();
5848                let result = temp_env::with_vars(
5849                    [
5850                        (ENV_ILM_DEBUG_DAY_SECS, None::<&str>),
5851                        (ENV_ILM_PROCESS_TIME, Some(boundary_str.as_str())),
5852                        (ENV_ILM_PROCESS_TIME_DEPRECATED, None),
5853                    ],
5854                    || expected_expiry_time(mod_time, days),
5855                );
5856                let boundary_nanos = i128::from(boundary) * 1_000_000_000;
5857                prop_assert_eq!(result.unix_timestamp_nanos().rem_euclid(boundary_nanos), 0);
5858                let raw = mod_time + Duration::seconds(i64::from(days) * DAY_SECS);
5859                prop_assert!(result >= raw);
5860                prop_assert!(result - raw < Duration::seconds(i64::from(boundary)));
5861            }
5862        }
5863    }
5864}