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