Skip to main content

rustfs_replication/
mrf.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 byteorder::{ByteOrder, LittleEndian};
16use std::fmt;
17
18use crate::{Result, ResyncStateError};
19
20pub use crate::filemeta::{MrfOpKind, MrfReplicateEntry};
21
22pub const MRF_META_FORMAT: u16 = 1;
23pub const MRF_META_VERSION: u16 = 1;
24
25const MRF_ENVELOPE_MAGIC: [u8; 4] = *b"MRFE";
26const MRF_ENVELOPE_HEADER_LEN: usize = 24;
27pub const MRF_ENVELOPE_FORMAT: u16 = 1;
28pub const MRF_ENVELOPE_VERSION: u16 = 1;
29
30const CAPABILITY_OPERATION_KIND: u64 = 1 << 0;
31const CAPABILITY_TARGET_ARNS: u64 = 1 << 1;
32const CAPABILITY_FORCE_DELETE: u64 = 1 << 2;
33const CAPABILITY_DELETE_MARKER_MTIME: u64 = 1 << 3;
34// Per-ARN target-assigned delete-marker version ids on purge intents (backlog#2290).
35const CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS: u64 = 1 << 4;
36const MRF_KNOWN_CAPABILITIES: u64 = CAPABILITY_OPERATION_KIND
37    | CAPABILITY_TARGET_ARNS
38    | CAPABILITY_FORCE_DELETE
39    | CAPABILITY_DELETE_MARKER_MTIME
40    | CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS;
41
42#[derive(Debug, Clone, Copy, PartialEq, Eq)]
43pub enum MrfCapability {
44    OperationKind,
45    TargetArns,
46    ForceDelete,
47    DeleteMarkerMtime,
48    TargetDeleteMarkerVersionIds,
49}
50
51impl MrfCapability {
52    const fn bit(self) -> u64 {
53        match self {
54            Self::OperationKind => CAPABILITY_OPERATION_KIND,
55            Self::TargetArns => CAPABILITY_TARGET_ARNS,
56            Self::ForceDelete => CAPABILITY_FORCE_DELETE,
57            Self::DeleteMarkerMtime => CAPABILITY_DELETE_MARKER_MTIME,
58            Self::TargetDeleteMarkerVersionIds => CAPABILITY_TARGET_DELETE_MARKER_VERSION_IDS,
59        }
60    }
61}
62
63#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
64pub struct MrfCapabilities(u64);
65
66impl MrfCapabilities {
67    pub const fn current() -> Self {
68        Self(MRF_KNOWN_CAPABILITIES)
69    }
70
71    pub const fn empty() -> Self {
72        Self(0)
73    }
74
75    pub const fn with(capability: MrfCapability) -> Self {
76        Self(capability.bit())
77    }
78
79    pub const fn bits(self) -> u64 {
80        self.0
81    }
82
83    pub const fn contains(self, capability: MrfCapability) -> bool {
84        self.0 & capability.bit() != 0
85    }
86
87    pub const fn supports(self, required: Self) -> bool {
88        self.0 & required.0 == required.0
89    }
90
91    pub fn from_bits(bits: u64) -> std::result::Result<Self, MrfEnvelopeError> {
92        let unknown = bits & !MRF_KNOWN_CAPABILITIES;
93        if unknown != 0 {
94            return Err(MrfEnvelopeError::UnknownCapabilities { bits: unknown });
95        }
96        Ok(Self(bits))
97    }
98}
99
100#[derive(Debug, Clone, Copy, PartialEq, Eq)]
101pub struct MrfProtocolCapabilities {
102    version: u16,
103    min_reader_version: u16,
104    capabilities: MrfCapabilities,
105}
106
107impl MrfProtocolCapabilities {
108    pub const fn new(version: u16, min_reader_version: u16, capabilities: MrfCapabilities) -> Self {
109        Self {
110            version,
111            min_reader_version,
112            capabilities,
113        }
114    }
115
116    pub const fn current() -> Self {
117        Self {
118            version: MRF_ENVELOPE_VERSION,
119            min_reader_version: MRF_ENVELOPE_VERSION,
120            capabilities: MrfCapabilities::current(),
121        }
122    }
123
124    pub const fn version(self) -> u16 {
125        self.version
126    }
127
128    pub const fn min_reader_version(self) -> u16 {
129        self.min_reader_version
130    }
131
132    pub const fn capabilities(self) -> MrfCapabilities {
133        self.capabilities
134    }
135
136    pub fn negotiate(self, peer: Self) -> std::result::Result<Self, MrfEnvelopeError> {
137        MrfCapabilities::from_bits(self.capabilities.bits())?;
138        MrfCapabilities::from_bits(peer.capabilities.bits())?;
139        if self.min_reader_version > self.version {
140            return Err(MrfEnvelopeError::InvalidVersionRange {
141                version: self.version,
142                min_reader_version: self.min_reader_version,
143            });
144        }
145        if peer.min_reader_version > peer.version {
146            return Err(MrfEnvelopeError::InvalidVersionRange {
147                version: peer.version,
148                min_reader_version: peer.min_reader_version,
149            });
150        }
151        if self.version < MRF_ENVELOPE_VERSION {
152            return Err(MrfEnvelopeError::UnsupportedVersion { version: self.version });
153        }
154        if peer.version < MRF_ENVELOPE_VERSION {
155            return Err(MrfEnvelopeError::UnsupportedVersion { version: peer.version });
156        }
157        if peer.min_reader_version > self.version {
158            return Err(MrfEnvelopeError::RollbackFenced {
159                min_reader_version: peer.min_reader_version,
160                supported_version: self.version,
161            });
162        }
163        if self.min_reader_version > peer.version {
164            return Err(MrfEnvelopeError::RollbackFenced {
165                min_reader_version: self.min_reader_version,
166                supported_version: peer.version,
167            });
168        }
169        Ok(Self {
170            version: self.version.min(peer.version),
171            min_reader_version: self.min_reader_version.max(peer.min_reader_version),
172            capabilities: MrfCapabilities(self.capabilities.bits() & peer.capabilities.bits()),
173        })
174    }
175}
176
177#[derive(Debug, Clone, PartialEq, Eq)]
178pub struct MrfEnvelope {
179    protocol: MrfProtocolCapabilities,
180    payload: Vec<u8>,
181}
182
183impl MrfEnvelope {
184    pub fn new(protocol: MrfProtocolCapabilities, payload: Vec<u8>) -> std::result::Result<Self, MrfEnvelopeError> {
185        if protocol.version != MRF_ENVELOPE_VERSION {
186            return Err(MrfEnvelopeError::UnsupportedVersion {
187                version: protocol.version,
188            });
189        }
190        if protocol.min_reader_version > protocol.version {
191            return Err(MrfEnvelopeError::InvalidVersionRange {
192                version: protocol.version,
193                min_reader_version: protocol.min_reader_version,
194            });
195        }
196        MrfCapabilities::from_bits(protocol.capabilities.bits())?;
197        Ok(Self { protocol, payload })
198    }
199
200    pub const fn protocol(&self) -> MrfProtocolCapabilities {
201        self.protocol
202    }
203
204    pub fn payload(&self) -> &[u8] {
205        &self.payload
206    }
207
208    pub fn encode(&self) -> std::result::Result<Vec<u8>, MrfEnvelopeError> {
209        let payload_len: u32 = self.payload.len().try_into().map_err(|_| MrfEnvelopeError::PayloadTooLarge)?;
210        let mut data = Vec::with_capacity(MRF_ENVELOPE_HEADER_LEN + self.payload.len());
211        data.extend_from_slice(&MRF_ENVELOPE_MAGIC);
212        data.extend_from_slice(&MRF_ENVELOPE_FORMAT.to_le_bytes());
213        data.extend_from_slice(&self.protocol.version.to_le_bytes());
214        data.extend_from_slice(&self.protocol.min_reader_version.to_le_bytes());
215        data.extend_from_slice(&0u16.to_le_bytes());
216        data.extend_from_slice(&self.protocol.capabilities.bits().to_le_bytes());
217        data.extend_from_slice(&payload_len.to_le_bytes());
218        data.extend_from_slice(&self.payload);
219        Ok(data)
220    }
221
222    pub fn decode(data: &[u8], supported: MrfProtocolCapabilities) -> std::result::Result<Self, MrfEnvelopeError> {
223        if data.len() < MRF_ENVELOPE_HEADER_LEN {
224            return Err(MrfEnvelopeError::Truncated);
225        }
226        if data[..4] != MRF_ENVELOPE_MAGIC {
227            return Err(MrfEnvelopeError::InvalidMagic);
228        }
229        let format = LittleEndian::read_u16(&data[4..6]);
230        if format != MRF_ENVELOPE_FORMAT {
231            return Err(MrfEnvelopeError::UnsupportedFormat { format });
232        }
233        let version = LittleEndian::read_u16(&data[6..8]);
234        if version < MRF_ENVELOPE_VERSION {
235            return Err(MrfEnvelopeError::UnsupportedVersion { version });
236        }
237        let min_reader_version = LittleEndian::read_u16(&data[8..10]);
238        if min_reader_version > supported.version {
239            return Err(MrfEnvelopeError::RollbackFenced {
240                min_reader_version,
241                supported_version: supported.version,
242            });
243        }
244        if min_reader_version > version {
245            return Err(MrfEnvelopeError::InvalidVersionRange {
246                version,
247                min_reader_version,
248            });
249        }
250        let reserved = LittleEndian::read_u16(&data[10..12]);
251        if reserved != 0 {
252            return Err(MrfEnvelopeError::ReservedHeaderBits { bits: reserved });
253        }
254        let capabilities = MrfCapabilities::from_bits(LittleEndian::read_u64(&data[12..20]))?;
255        if !supported.capabilities.supports(capabilities) {
256            return Err(MrfEnvelopeError::MissingCapabilities {
257                required: capabilities.bits(),
258                available: supported.capabilities.bits(),
259            });
260        }
261        let payload_len = LittleEndian::read_u32(&data[20..24]);
262        let actual_len = data.len() - MRF_ENVELOPE_HEADER_LEN;
263        if usize::try_from(payload_len).map_err(|_| MrfEnvelopeError::PayloadTooLarge)? != actual_len {
264            return Err(MrfEnvelopeError::PayloadLengthMismatch {
265                declared: payload_len,
266                actual: actual_len,
267            });
268        }
269        Ok(Self {
270            protocol: MrfProtocolCapabilities {
271                version,
272                min_reader_version,
273                capabilities,
274            },
275            payload: data[MRF_ENVELOPE_HEADER_LEN..].to_vec(),
276        })
277    }
278}
279
280#[derive(Debug, Clone, PartialEq, Eq)]
281pub enum MrfEnvelopeError {
282    Truncated,
283    InvalidMagic,
284    UnsupportedFormat {
285        format: u16,
286    },
287    UnsupportedVersion {
288        version: u16,
289    },
290    InvalidVersionRange {
291        version: u16,
292        min_reader_version: u16,
293    },
294    RollbackFenced {
295        min_reader_version: u16,
296        supported_version: u16,
297    },
298    ReservedHeaderBits {
299        bits: u16,
300    },
301    UnknownCapabilities {
302        bits: u64,
303    },
304    MissingCapabilities {
305        required: u64,
306        available: u64,
307    },
308    PayloadLengthMismatch {
309        declared: u32,
310        actual: usize,
311    },
312    PayloadTooLarge,
313}
314
315impl fmt::Display for MrfEnvelopeError {
316    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
317        match self {
318            Self::Truncated => write!(f, "truncated MRF envelope"),
319            Self::InvalidMagic => write!(f, "invalid MRF envelope magic"),
320            Self::UnsupportedFormat { format } => write!(f, "unsupported MRF envelope format {format}"),
321            Self::UnsupportedVersion { version } => write!(f, "unsupported MRF envelope version {version}"),
322            Self::InvalidVersionRange {
323                version,
324                min_reader_version,
325            } => {
326                write!(f, "invalid MRF version range: version {version}, minimum reader {min_reader_version}")
327            }
328            Self::RollbackFenced {
329                min_reader_version,
330                supported_version,
331            } => write!(
332                f,
333                "MRF rollback fenced: reader version {supported_version} is below required {min_reader_version}"
334            ),
335            Self::ReservedHeaderBits { bits } => write!(f, "reserved MRF envelope header bits are set: 0x{bits:04x}"),
336            Self::UnknownCapabilities { bits } => write!(f, "unknown MRF capability bits 0x{bits:016x}"),
337            Self::MissingCapabilities { required, available } => {
338                write!(f, "MRF capabilities 0x{available:016x} do not satisfy required 0x{required:016x}")
339            }
340            Self::PayloadLengthMismatch { declared, actual } => {
341                write!(f, "MRF payload length is {actual}, expected {declared}")
342            }
343            Self::PayloadTooLarge => write!(f, "MRF payload exceeds the envelope length limit"),
344        }
345    }
346}
347
348impl std::error::Error for MrfEnvelopeError {}
349
350pub const MRF_V2_NAMESPACE: &str = "config/replication-v2";
351pub const MRF_V2_FILE: &str = "config/replication-v2/mrf.bin";
352pub const MRF_V2_FORMAT: u16 = 2;
353pub const MRF_V2_VERSION: u16 = 2;
354
355const MRF_V2_MAGIC: [u8; 4] = *b"MRF2";
356const MRF_V2_HEADER_LEN: usize = 24;
357const MRF_V2_KNOWN_CAPABILITIES: u64 = 0b1111;
358
359#[derive(Debug, Clone, PartialEq, Eq)]
360pub enum MrfV2Error {
361    InvalidMagic,
362    Truncated,
363    UnsupportedNamespace { namespace: String },
364    UnsupportedFormat { format: u16 },
365    UnsupportedVersion { version: u16 },
366    InvalidVersionRange { version: u16, min_reader_version: u16 },
367    RollbackFenced { min_reader_version: u16, reader_version: u16 },
368    ReservedHeaderBits { bits: u16 },
369    UnknownCapabilities { bits: u64 },
370    MissingCapabilities { required: u64, available: u64 },
371    PayloadLengthMismatch { declared: u32, actual: usize },
372    WriterEnabled,
373}
374
375impl std::fmt::Display for MrfV2Error {
376    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
377        match self {
378            Self::InvalidMagic => write!(f, "invalid MRF v2 magic"),
379            Self::Truncated => write!(f, "truncated MRF v2 envelope"),
380            Self::UnsupportedNamespace { namespace } => write!(f, "unsupported MRF v2 namespace {namespace}"),
381            Self::UnsupportedFormat { format } => write!(f, "unsupported MRF v2 format {format}"),
382            Self::UnsupportedVersion { version } => write!(f, "unsupported MRF v2 version {version}"),
383            Self::InvalidVersionRange {
384                version,
385                min_reader_version,
386            } => {
387                write!(f, "invalid MRF v2 version range: version {version}, minimum reader {min_reader_version}")
388            }
389            Self::RollbackFenced {
390                min_reader_version,
391                reader_version,
392            } => write!(
393                f,
394                "MRF v2 rollback fenced: reader version {reader_version} is below required {min_reader_version}"
395            ),
396            Self::ReservedHeaderBits { bits } => write!(f, "reserved MRF v2 header bits are set: 0x{bits:04x}"),
397            Self::UnknownCapabilities { bits } => write!(f, "unknown MRF v2 capability bits 0x{bits:016x}"),
398            Self::MissingCapabilities { required, available } => {
399                write!(f, "MRF v2 capabilities 0x{available:016x} do not satisfy required 0x{required:016x}")
400            }
401            Self::PayloadLengthMismatch { declared, actual } => {
402                write!(f, "MRF v2 payload is {actual} bytes, expected {declared}")
403            }
404            Self::WriterEnabled => write!(f, "MRF v2 writer must remain dormant"),
405        }
406    }
407}
408
409impl std::error::Error for MrfV2Error {}
410
411#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
412pub struct MrfV2Capabilities(u64);
413
414impl MrfV2Capabilities {
415    pub const fn current() -> Self {
416        Self(MRF_V2_KNOWN_CAPABILITIES)
417    }
418
419    pub const fn empty() -> Self {
420        Self(0)
421    }
422
423    pub const fn bits(self) -> u64 {
424        self.0
425    }
426
427    pub fn from_bits(bits: u64) -> std::result::Result<Self, MrfV2Error> {
428        let unknown = bits & !MRF_V2_KNOWN_CAPABILITIES;
429        if unknown != 0 {
430            return Err(MrfV2Error::UnknownCapabilities { bits: unknown });
431        }
432        Ok(Self(bits))
433    }
434
435    pub const fn supports(self, required: Self) -> bool {
436        self.0 & required.0 == required.0
437    }
438}
439
440#[derive(Debug, Clone, Copy, PartialEq, Eq)]
441pub struct MrfV2Readiness {
442    reader_version: u16,
443    capabilities: MrfV2Capabilities,
444    writer_enabled: bool,
445}
446
447impl MrfV2Readiness {
448    pub const fn dormant() -> Self {
449        Self {
450            reader_version: MRF_V2_VERSION,
451            capabilities: MrfV2Capabilities::current(),
452            writer_enabled: false,
453        }
454    }
455
456    pub const fn new(reader_version: u16, capabilities: MrfV2Capabilities, writer_enabled: bool) -> Self {
457        Self {
458            reader_version,
459            capabilities,
460            writer_enabled,
461        }
462    }
463
464    pub const fn writer_enabled(self) -> bool {
465        self.writer_enabled
466    }
467
468    pub fn reader(self) -> std::result::Result<MrfV2Reader, MrfV2Error> {
469        if self.writer_enabled {
470            return Err(MrfV2Error::WriterEnabled);
471        }
472        if self.reader_version != MRF_V2_VERSION {
473            return Err(MrfV2Error::UnsupportedVersion {
474                version: self.reader_version,
475            });
476        }
477        MrfV2Capabilities::from_bits(self.capabilities.bits())?;
478        Ok(MrfV2Reader { readiness: self })
479    }
480}
481
482#[derive(Debug, Clone, Copy, PartialEq, Eq)]
483pub struct MrfV2Reader {
484    readiness: MrfV2Readiness,
485}
486
487impl MrfV2Reader {
488    pub fn read(self, namespace: &str, data: &[u8]) -> std::result::Result<MrfV2Envelope, MrfV2Error> {
489        if namespace != MRF_V2_NAMESPACE {
490            return Err(MrfV2Error::UnsupportedNamespace {
491                namespace: namespace.to_string(),
492            });
493        }
494        if data.len() < MRF_V2_HEADER_LEN {
495            return Err(MrfV2Error::Truncated);
496        }
497        if data[..4] != MRF_V2_MAGIC {
498            return Err(MrfV2Error::InvalidMagic);
499        }
500        let format = LittleEndian::read_u16(&data[4..6]);
501        if format != MRF_V2_FORMAT {
502            return Err(MrfV2Error::UnsupportedFormat { format });
503        }
504        let version = LittleEndian::read_u16(&data[6..8]);
505        if version != MRF_V2_VERSION || version != self.readiness.reader_version {
506            return Err(MrfV2Error::UnsupportedVersion { version });
507        }
508        let min_reader_version = LittleEndian::read_u16(&data[8..10]);
509        if min_reader_version > self.readiness.reader_version {
510            return Err(MrfV2Error::RollbackFenced {
511                min_reader_version,
512                reader_version: self.readiness.reader_version,
513            });
514        }
515        if min_reader_version > version {
516            return Err(MrfV2Error::InvalidVersionRange {
517                version,
518                min_reader_version,
519            });
520        }
521        let reserved = LittleEndian::read_u16(&data[10..12]);
522        if reserved != 0 {
523            return Err(MrfV2Error::ReservedHeaderBits { bits: reserved });
524        }
525        let capabilities = MrfV2Capabilities::from_bits(LittleEndian::read_u64(&data[12..20]))?;
526        if !self.readiness.capabilities.supports(capabilities) {
527            return Err(MrfV2Error::MissingCapabilities {
528                required: capabilities.bits(),
529                available: self.readiness.capabilities.bits(),
530            });
531        }
532        let payload_len = LittleEndian::read_u32(&data[20..24]);
533        let actual = data.len() - MRF_V2_HEADER_LEN;
534        if usize::try_from(payload_len).map_err(|_| MrfV2Error::PayloadLengthMismatch {
535            declared: payload_len,
536            actual,
537        })? != actual
538        {
539            return Err(MrfV2Error::PayloadLengthMismatch {
540                declared: payload_len,
541                actual,
542            });
543        }
544        Ok(MrfV2Envelope {
545            version,
546            min_reader_version,
547            capabilities,
548            payload: data[MRF_V2_HEADER_LEN..].to_vec(),
549        })
550    }
551}
552
553#[derive(Debug, Clone, PartialEq, Eq)]
554pub struct MrfV2Envelope {
555    version: u16,
556    min_reader_version: u16,
557    capabilities: MrfV2Capabilities,
558    payload: Vec<u8>,
559}
560
561impl MrfV2Envelope {
562    pub const fn version(&self) -> u16 {
563        self.version
564    }
565
566    pub const fn min_reader_version(&self) -> u16 {
567        self.min_reader_version
568    }
569
570    pub const fn capabilities(&self) -> MrfV2Capabilities {
571        self.capabilities
572    }
573
574    pub fn payload(&self) -> &[u8] {
575        &self.payload
576    }
577}
578pub fn encode_mrf_file(entries: &[MrfReplicateEntry]) -> Result<Vec<u8>> {
579    let payload = rmp_serde::to_vec_named(entries).map_err(|e| ResyncStateError::Other(e.to_string()))?;
580    let mut data = Vec::with_capacity(4 + payload.len());
581    let mut fmt = [0u8; 2];
582    LittleEndian::write_u16(&mut fmt, MRF_META_FORMAT);
583    data.extend_from_slice(&fmt);
584    let mut ver = [0u8; 2];
585    LittleEndian::write_u16(&mut ver, MRF_META_VERSION);
586    data.extend_from_slice(&ver);
587    data.extend_from_slice(&payload);
588    Ok(data)
589}
590
591pub fn decode_mrf_file(data: &[u8]) -> Result<Vec<MrfReplicateEntry>> {
592    if data.len() <= 4 {
593        return Err(ResyncStateError::CorruptedFormat);
594    }
595    let mut fmt = [0u8; 2];
596    fmt.copy_from_slice(&data[0..2]);
597    if LittleEndian::read_u16(&fmt) != MRF_META_FORMAT {
598        return Err(ResyncStateError::CorruptedFormat);
599    }
600    let mut ver = [0u8; 2];
601    ver.copy_from_slice(&data[2..4]);
602    if LittleEndian::read_u16(&ver) != MRF_META_VERSION {
603        return Err(ResyncStateError::CorruptedFormat);
604    }
605    rmp_serde::from_slice(&data[4..]).map_err(|e| ResyncStateError::Other(e.to_string()))
606}
607
608#[cfg(test)]
609mod tests {
610    use super::*;
611    use std::collections::HashMap;
612    use uuid::Uuid;
613
614    // Capability word 31 = OperationKind | TargetArns | ForceDelete | DeleteMarkerMtime |
615    // TargetDeleteMarkerVersionIds (backlog#2290).
616    const ENVELOPE_FIXTURE: &[u8] = &[
617        b'M', b'R', b'F', b'E', 1, 0, 1, 0, 1, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
618    ];
619
620    // The envelope a binary from before backlog#2290 writes: same header, capability word 15.
621    const PRE_TARGET_MARKER_IDS_ENVELOPE_FIXTURE: &[u8] = &[
622        b'M', b'R', b'F', b'E', 1, 0, 1, 0, 1, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
623    ];
624
625    #[test]
626    fn mrf_file_round_trips_object_metadata_and_delete_entries() {
627        let obj_vid = Uuid::new_v4();
628        let del_vid = Uuid::new_v4();
629        let entries = vec![
630            MrfReplicateEntry {
631                bucket: "bucket-a".to_string(),
632                object: "metadata-a".to_string(),
633                version_id: Some(obj_vid),
634                retry_count: 1,
635                size: 1024,
636                op: MrfOpKind::Metadata,
637                force_delete_id: None,
638                force_delete_generation: None,
639                force_delete_local_commit: false,
640                force_delete: false,
641                delete_marker_version_id: None,
642                delete_marker: false,
643                delete_marker_mtime: None,
644                target_delete_marker_version_ids: HashMap::new(),
645                target_delete_marker_version_ids_corrupt: false,
646                target_arns: vec!["arn:target-a".to_string()],
647            },
648            MrfReplicateEntry {
649                bucket: "bucket-a".to_string(),
650                object: "object-a".to_string(),
651                version_id: Some(obj_vid),
652                retry_count: 2,
653                size: 1024,
654                op: MrfOpKind::Object,
655                force_delete_id: None,
656                force_delete_generation: None,
657                force_delete_local_commit: false,
658                force_delete: false,
659                delete_marker_version_id: None,
660                delete_marker: false,
661                delete_marker_mtime: None,
662                target_delete_marker_version_ids: HashMap::new(),
663                target_delete_marker_version_ids_corrupt: false,
664                target_arns: vec!["arn:target-a".to_string(), "arn:target-b".to_string()],
665            },
666            MrfReplicateEntry {
667                bucket: "bucket-a".to_string(),
668                object: "delete-a".to_string(),
669                version_id: None,
670                retry_count: 0,
671                size: 0,
672                op: MrfOpKind::Delete,
673                force_delete_id: None,
674                force_delete_generation: None,
675                force_delete_local_commit: false,
676                force_delete: true,
677                delete_marker_version_id: Some(del_vid),
678                delete_marker: true,
679                delete_marker_mtime: Some(1_705_312_200_123_456_789),
680                target_delete_marker_version_ids: HashMap::from([
681                    ("arn:target-a".to_string(), "remote-marker-a".to_string()),
682                    ("arn:target-b".to_string(), "remote-marker-b".to_string()),
683                ]),
684                target_delete_marker_version_ids_corrupt: false,
685                target_arns: vec!["arn:target-a".to_string()],
686            },
687        ];
688
689        let encoded = encode_mrf_file(&entries).expect("mrf file should encode");
690        let decoded = decode_mrf_file(&encoded).expect("mrf file should decode");
691
692        assert_eq!(decoded.len(), 3);
693        assert_eq!(decoded[0].version_id, Some(obj_vid));
694        assert_eq!(decoded[0].op, MrfOpKind::Metadata);
695        assert_eq!(decoded[0].target_arns, vec!["arn:target-a".to_string()]);
696        assert_eq!(decoded[0].delete_marker_mtime, None);
697        assert!(!decoded[0].force_delete);
698        assert_eq!(decoded[1].op, MrfOpKind::Object);
699        assert!(!decoded[1].force_delete);
700        assert_eq!(decoded[1].target_arns, vec!["arn:target-a".to_string(), "arn:target-b".to_string()]);
701        assert_eq!(decoded[1].delete_marker_mtime, None);
702        assert_eq!(decoded[2].delete_marker_version_id, Some(del_vid));
703        assert_eq!(decoded[2].op, MrfOpKind::Delete);
704        assert!(decoded[2].force_delete);
705        assert_eq!(decoded[2].target_arns, vec!["arn:target-a".to_string()]);
706        assert!(decoded[2].delete_marker);
707        assert_eq!(
708            decoded[2].delete_marker_mtime,
709            Some(1_705_312_200_123_456_789),
710            "delete-marker mtime must survive the MRF disk round-trip"
711        );
712        assert!(decoded[0].target_delete_marker_version_ids.is_empty());
713        assert!(decoded[1].target_delete_marker_version_ids.is_empty());
714        assert_eq!(
715            decoded[2].target_delete_marker_version_ids,
716            HashMap::from([
717                ("arn:target-a".to_string(), "remote-marker-a".to_string()),
718                ("arn:target-b".to_string(), "remote-marker-b".to_string()),
719            ]),
720            "target-assigned marker version ids must survive the MRF disk round-trip (backlog#2290)"
721        );
722        assert!(!decoded[2].target_delete_marker_version_ids_corrupt);
723    }
724
725    /// backlog#2290: the corrupt flag rides the same journal round trip, and an
726    /// entry that carries neither field encodes exactly as it did before the
727    /// field existed (both keys are skipped when empty/false).
728    #[test]
729    fn mrf_file_round_trips_target_marker_ids_corrupt_flag_and_skips_empty_keys() {
730        let corrupt = MrfReplicateEntry {
731            bucket: "bucket-a".to_string(),
732            object: "delete-a".to_string(),
733            op: MrfOpKind::Delete,
734            delete_marker: true,
735            delete_marker_version_id: Some(Uuid::new_v4()),
736            target_delete_marker_version_ids_corrupt: true,
737            target_arns: vec!["arn:target-a".to_string()],
738            ..Default::default()
739        };
740        let decoded = decode_mrf_file(&encode_mrf_file(std::slice::from_ref(&corrupt)).expect("mrf file should encode"))
741            .expect("mrf file should decode");
742        assert_eq!(decoded, vec![corrupt]);
743        assert!(decoded[0].target_delete_marker_version_ids_corrupt);
744
745        let plain = MrfReplicateEntry {
746            bucket: "bucket-a".to_string(),
747            object: "delete-a".to_string(),
748            op: MrfOpKind::Delete,
749            delete_marker: true,
750            target_arns: vec!["arn:target-a".to_string()],
751            ..Default::default()
752        };
753        let encoded = encode_mrf_file(std::slice::from_ref(&plain)).expect("mrf file should encode");
754        let payload = String::from_utf8_lossy(&encoded);
755        assert!(
756            !payload.contains("targetDeleteMarkerVersionIDs"),
757            "an entry without recorded ids must not grow the new keys: {payload}"
758        );
759        assert_eq!(decode_mrf_file(&encoded).expect("mrf file should decode"), vec![plain]);
760    }
761
762    #[test]
763    fn mrf_legacy_file_without_op_decodes_as_object() {
764        let mut payload = Vec::new();
765        rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
766        rmp::encode::write_map_len(&mut payload, 4).expect("map len should encode");
767        rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
768        rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
769        rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
770        rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
771        rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
772        rmp::encode::write_i32(&mut payload, 2).expect("retry value should encode");
773        rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
774        rmp::encode::write_i64(&mut payload, 100).expect("size value should encode");
775
776        let mut data = Vec::with_capacity(4 + payload.len());
777        data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
778        data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
779        data.extend_from_slice(&payload);
780
781        let decoded = decode_mrf_file(&data).expect("legacy mrf file should decode");
782
783        assert_eq!(decoded.len(), 1);
784        assert_eq!(decoded[0].bucket, "old-bucket");
785        assert_eq!(decoded[0].object, "old-key");
786        assert_eq!(decoded[0].retry_count, 2);
787        assert_eq!(decoded[0].size, 100);
788        assert_eq!(decoded[0].op, MrfOpKind::Object);
789        assert!(decoded[0].target_arns.is_empty());
790        assert!(!decoded[0].force_delete);
791        // Old files lack the deleteMarkerMtime key; it must default to None so replay keeps the
792        // pre-#867 fallback to the current time.
793        assert_eq!(decoded[0].delete_marker_mtime, None);
794        // Old files also lack the target marker id keys; they must default to an empty map
795        // and a clear corrupt flag so replay keeps the pre-#2290 source-id fallback.
796        assert!(decoded[0].target_delete_marker_version_ids.is_empty());
797        assert!(!decoded[0].target_delete_marker_version_ids_corrupt);
798    }
799
800    /// backlog#2290: a delete-marker entry written by a binary that predates the
801    /// `targetDeleteMarkerVersionIDs` key decodes with an empty map and a clear
802    /// corrupt flag — the exact shape replay handled before the field existed.
803    #[test]
804    fn mrf_pre_target_marker_ids_delete_entry_decodes_with_empty_map() {
805        let marker_version_id = Uuid::new_v4();
806        let mut payload = Vec::new();
807        rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
808        rmp::encode::write_map_len(&mut payload, 9).expect("map len should encode");
809        rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
810        rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
811        rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
812        rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
813        rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
814        rmp::encode::write_i32(&mut payload, 0).expect("retry value should encode");
815        rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
816        rmp::encode::write_i64(&mut payload, 0).expect("size value should encode");
817        rmp::encode::write_str(&mut payload, "op").expect("op key should encode");
818        rmp::encode::write_str(&mut payload, "delete").expect("op value should encode");
819        rmp::encode::write_str(&mut payload, "forceDelete").expect("forceDelete key should encode");
820        rmp::encode::write_bool(&mut payload, false).expect("forceDelete value should encode");
821        rmp::encode::write_str(&mut payload, "deleteMarkerVersionID").expect("marker id key should encode");
822        // Uuid serializes as a 16-byte bin in the MessagePack journal.
823        rmp::encode::write_bin(&mut payload, marker_version_id.as_bytes()).expect("marker id value should encode");
824        rmp::encode::write_str(&mut payload, "deleteMarker").expect("deleteMarker key should encode");
825        rmp::encode::write_bool(&mut payload, true).expect("deleteMarker value should encode");
826        rmp::encode::write_str(&mut payload, "targetARNs").expect("targetARNs key should encode");
827        rmp::encode::write_array_len(&mut payload, 1).expect("targetARNs len should encode");
828        rmp::encode::write_str(&mut payload, "arn:target-a").expect("targetARNs value should encode");
829
830        let mut data = Vec::with_capacity(4 + payload.len());
831        data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
832        data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
833        data.extend_from_slice(&payload);
834
835        let decoded = decode_mrf_file(&data).expect("pre-#2290 delete-marker entry should decode");
836
837        assert_eq!(decoded.len(), 1);
838        assert_eq!(decoded[0].op, MrfOpKind::Delete);
839        assert!(decoded[0].delete_marker);
840        assert_eq!(decoded[0].delete_marker_version_id, Some(marker_version_id));
841        assert_eq!(decoded[0].target_arns, vec!["arn:target-a".to_string()]);
842        assert!(decoded[0].target_delete_marker_version_ids.is_empty());
843        assert!(!decoded[0].target_delete_marker_version_ids_corrupt);
844    }
845
846    /// backlog#2290: the new field is fenced by its own capability bit exactly
847    /// like the earlier optional fields — a reader without the bit refuses an
848    /// envelope that advertises it, while the current reader still accepts the
849    /// pre-#2290 envelope.
850    #[test]
851    fn envelope_target_marker_ids_capability_is_fenced_and_backward_compatible() {
852        assert!(MrfCapabilities::current().contains(MrfCapability::TargetDeleteMarkerVersionIds));
853        assert_eq!(MrfCapabilities::with(MrfCapability::TargetDeleteMarkerVersionIds).bits(), 1 << 4);
854
855        // Old envelope, current reader: accepted, and the negotiated set lacks the new bit.
856        let legacy = MrfEnvelope::decode(PRE_TARGET_MARKER_IDS_ENVELOPE_FIXTURE, MrfProtocolCapabilities::current())
857            .expect("pre-#2290 envelope should decode");
858        assert_eq!(legacy.protocol().capabilities().bits(), 15);
859        assert!(
860            !legacy
861                .protocol()
862                .capabilities()
863                .contains(MrfCapability::TargetDeleteMarkerVersionIds)
864        );
865        assert_eq!(legacy.payload(), &[1, 2, 3]);
866
867        // Current envelope, reader that only knows the pre-#2290 bits: refused.
868        let pre_2290_reader = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::from_bits(15).expect("known bits"));
869        assert_eq!(
870            MrfEnvelope::decode(ENVELOPE_FIXTURE, pre_2290_reader),
871            Err(MrfEnvelopeError::MissingCapabilities {
872                required: 31,
873                available: 15,
874            })
875        );
876
877        // Negotiation with such a peer drops the bit instead of failing.
878        let negotiated = MrfProtocolCapabilities::current()
879            .negotiate(pre_2290_reader)
880            .expect("negotiation with a pre-#2290 peer should succeed");
881        assert!(
882            !negotiated
883                .capabilities()
884                .contains(MrfCapability::TargetDeleteMarkerVersionIds)
885        );
886        assert!(negotiated.capabilities().contains(MrfCapability::DeleteMarkerMtime));
887    }
888
889    #[test]
890    fn mrf_file_defaults_missing_force_delete_to_false() {
891        let mut payload = Vec::new();
892        rmp::encode::write_array_len(&mut payload, 1).expect("array len should encode");
893        rmp::encode::write_map_len(&mut payload, 5).expect("map len should encode");
894        rmp::encode::write_str(&mut payload, "bucket").expect("bucket key should encode");
895        rmp::encode::write_str(&mut payload, "old-bucket").expect("bucket value should encode");
896        rmp::encode::write_str(&mut payload, "object").expect("object key should encode");
897        rmp::encode::write_str(&mut payload, "old-key").expect("object value should encode");
898        rmp::encode::write_str(&mut payload, "retryCount").expect("retry key should encode");
899        rmp::encode::write_i32(&mut payload, 1).expect("retry value should encode");
900        rmp::encode::write_str(&mut payload, "size").expect("size key should encode");
901        rmp::encode::write_i64(&mut payload, 0).expect("size value should encode");
902        rmp::encode::write_str(&mut payload, "op").expect("op key should encode");
903        rmp::encode::write_str(&mut payload, "delete").expect("op value should encode");
904
905        let mut data = Vec::with_capacity(4 + payload.len());
906        data.extend_from_slice(&MRF_META_FORMAT.to_le_bytes());
907        data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
908        data.extend_from_slice(&payload);
909
910        let decoded = decode_mrf_file(&data).expect("MRF payload should decode");
911
912        assert_eq!(decoded[0].op, MrfOpKind::Delete);
913        assert!(!decoded[0].force_delete);
914    }
915
916    #[test]
917    fn mrf_file_rejects_invalid_header() {
918        let mut data = Vec::new();
919        data.extend_from_slice(&2u16.to_le_bytes());
920        data.extend_from_slice(&MRF_META_VERSION.to_le_bytes());
921        data.push(0x90);
922
923        assert!(matches!(decode_mrf_file(&data), Err(ResyncStateError::CorruptedFormat)));
924    }
925
926    #[test]
927    fn envelope_fixture_is_stable_and_round_trips() {
928        let envelope =
929            MrfEnvelope::new(MrfProtocolCapabilities::current(), vec![1, 2, 3]).expect("current MRF envelope should be valid");
930        assert_eq!(envelope.encode().expect("envelope should encode"), ENVELOPE_FIXTURE);
931        let decoded = MrfEnvelope::decode(ENVELOPE_FIXTURE, MrfProtocolCapabilities::current()).expect("fixture should decode");
932        assert_eq!(decoded.protocol(), MrfProtocolCapabilities::current());
933        assert_eq!(decoded.payload(), &[1, 2, 3]);
934    }
935
936    #[test]
937    fn envelope_accepts_a_forward_compatible_writer_version() {
938        let mut version = ENVELOPE_FIXTURE.to_vec();
939        version[6..8].copy_from_slice(&2u16.to_le_bytes());
940        let decoded =
941            MrfEnvelope::decode(&version, MrfProtocolCapabilities::current()).expect("compatible v2 envelope should decode");
942        assert_eq!(decoded.protocol().version(), 2);
943        assert_eq!(decoded.protocol().min_reader_version(), 1);
944
945        let mut fenced = version;
946        fenced[8..10].copy_from_slice(&2u16.to_le_bytes());
947        assert_eq!(
948            MrfEnvelope::decode(&fenced, MrfProtocolCapabilities::current()),
949            Err(MrfEnvelopeError::RollbackFenced {
950                min_reader_version: 2,
951                supported_version: 1,
952            })
953        );
954    }
955
956    #[test]
957    fn envelope_rejects_unknown_capability_bits() {
958        let mut capabilities = ENVELOPE_FIXTURE.to_vec();
959        capabilities[12..20].copy_from_slice(&(1u64 << 63).to_le_bytes());
960
961        assert_eq!(
962            MrfEnvelope::decode(&capabilities, MrfProtocolCapabilities::current()),
963            Err(MrfEnvelopeError::UnknownCapabilities { bits: 1u64 << 63 })
964        );
965
966        let mut reserved = ENVELOPE_FIXTURE.to_vec();
967        reserved[10..12].copy_from_slice(&1u16.to_le_bytes());
968        assert_eq!(
969            MrfEnvelope::decode(&reserved, MrfProtocolCapabilities::current()),
970            Err(MrfEnvelopeError::ReservedHeaderBits { bits: 1 })
971        );
972
973        let mut legacy = ENVELOPE_FIXTURE.to_vec();
974        legacy[6..8].copy_from_slice(&0u16.to_le_bytes());
975        assert_eq!(
976            MrfEnvelope::decode(&legacy, MrfProtocolCapabilities::current()),
977            Err(MrfEnvelopeError::UnsupportedVersion { version: 0 })
978        );
979    }
980
981    #[test]
982    fn envelope_rejects_rollback_and_missing_capabilities() {
983        let mut rollback = ENVELOPE_FIXTURE.to_vec();
984        rollback[8..10].copy_from_slice(&2u16.to_le_bytes());
985        assert_eq!(
986            MrfEnvelope::decode(&rollback, MrfProtocolCapabilities::current()),
987            Err(MrfEnvelopeError::RollbackFenced {
988                min_reader_version: 2,
989                supported_version: 1,
990            })
991        );
992
993        let required = MrfCapabilities::with(MrfCapability::TargetArns);
994        let envelope =
995            MrfEnvelope::new(MrfProtocolCapabilities::new(1, 1, required), Vec::new()).expect("known capability should be valid");
996        let encoded = envelope.encode().expect("envelope should encode");
997        assert_eq!(
998            MrfEnvelope::decode(&encoded, MrfProtocolCapabilities::new(1, 1, MrfCapabilities::empty())),
999            Err(MrfEnvelopeError::MissingCapabilities {
1000                required: required.bits(),
1001                available: 0,
1002            })
1003        );
1004    }
1005
1006    #[test]
1007    fn protocol_negotiation_fences_rollback() {
1008        let current = MrfProtocolCapabilities::current();
1009        let rollback = MrfProtocolCapabilities::new(1, 2, MrfCapabilities::current());
1010        assert_eq!(
1011            current.negotiate(rollback),
1012            Err(MrfEnvelopeError::InvalidVersionRange {
1013                version: 1,
1014                min_reader_version: 2,
1015            })
1016        );
1017    }
1018
1019    #[test]
1020    fn protocol_negotiation_rejects_invalid_local_version_range() {
1021        let invalid = MrfProtocolCapabilities::new(1, 2, MrfCapabilities::current());
1022        assert_eq!(
1023            invalid.negotiate(MrfProtocolCapabilities::current()),
1024            Err(MrfEnvelopeError::InvalidVersionRange {
1025                version: 1,
1026                min_reader_version: 2,
1027            })
1028        );
1029    }
1030
1031    #[test]
1032    fn protocol_negotiation_intersects_capabilities() {
1033        let local = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::with(MrfCapability::TargetArns));
1034        let peer = MrfProtocolCapabilities::new(1, 1, MrfCapabilities::with(MrfCapability::ForceDelete));
1035        let negotiated = local.negotiate(peer).expect("same-version peers should negotiate");
1036        assert_eq!(negotiated.capabilities(), MrfCapabilities::empty());
1037    }
1038
1039    #[test]
1040    fn protocol_negotiation_accepts_a_forward_compatible_peer() {
1041        let reader = MrfProtocolCapabilities::current();
1042        let writer = MrfProtocolCapabilities::new(2, 1, MrfCapabilities::current());
1043        let negotiated = reader
1044            .negotiate(writer)
1045            .expect("v1 reader should negotiate with a compatible v2 writer");
1046        assert_eq!(negotiated.version(), 1);
1047        assert_eq!(negotiated.min_reader_version(), 1);
1048    }
1049
1050    #[test]
1051    fn v1_file_contract_and_v2_namespace_remain_separate() {
1052        assert_eq!(encode_mrf_file(&[]).expect("v1 empty file should encode"), vec![1, 0, 1, 0, 0x90]);
1053        assert_eq!(MRF_V2_FILE, "config/replication-v2/mrf.bin");
1054        assert_ne!(MRF_V2_FILE, "config/replication/mrf.bin");
1055    }
1056
1057    #[test]
1058    fn dormant_v2_reader_accepts_stable_fixture() {
1059        let fixture = [
1060            b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1061        ];
1062        let readiness = MrfV2Readiness::dormant();
1063        assert!(!readiness.writer_enabled());
1064        let envelope = readiness
1065            .reader()
1066            .expect("dormant readiness should expose the reader")
1067            .read(MRF_V2_NAMESPACE, &fixture)
1068            .expect("v2 fixture should decode");
1069        assert_eq!(envelope.version(), MRF_V2_VERSION);
1070        assert_eq!(envelope.min_reader_version(), MRF_V2_VERSION);
1071        assert_eq!(envelope.capabilities(), MrfV2Capabilities::current());
1072        assert_eq!(envelope.payload(), &[1, 2, 3]);
1073    }
1074
1075    #[test]
1076    fn v2_reader_rejects_wrong_namespace_version_capability_and_rollback() {
1077        let fixture = [
1078            b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1079        ];
1080        let reader = MrfV2Readiness::dormant().reader().expect("dormant reader should initialize");
1081        assert!(matches!(
1082            reader.read("config/replication/mrf.bin", &fixture),
1083            Err(MrfV2Error::UnsupportedNamespace { .. })
1084        ));
1085
1086        let mut version = fixture;
1087        version[6..8].copy_from_slice(&1u16.to_le_bytes());
1088        assert_eq!(
1089            reader.read(MRF_V2_NAMESPACE, &version),
1090            Err(MrfV2Error::UnsupportedVersion { version: 1 })
1091        );
1092
1093        let mut capabilities = fixture;
1094        capabilities[12..20].copy_from_slice(&(1u64 << 63).to_le_bytes());
1095        assert_eq!(
1096            reader.read(MRF_V2_NAMESPACE, &capabilities),
1097            Err(MrfV2Error::UnknownCapabilities { bits: 1u64 << 63 })
1098        );
1099
1100        let mut rollback = fixture;
1101        rollback[8..10].copy_from_slice(&3u16.to_le_bytes());
1102        assert_eq!(
1103            reader.read(MRF_V2_NAMESPACE, &rollback),
1104            Err(MrfV2Error::RollbackFenced {
1105                min_reader_version: 3,
1106                reader_version: 2,
1107            })
1108        );
1109    }
1110
1111    #[test]
1112    fn v2_readiness_rejects_writer_enablement_and_missing_capabilities() {
1113        assert_eq!(
1114            MrfV2Readiness::new(2, MrfV2Capabilities::current(), true).reader(),
1115            Err(MrfV2Error::WriterEnabled)
1116        );
1117
1118        let fixture = [
1119            b'M', b'R', b'F', b'2', 2, 0, 2, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 2, 3,
1120        ];
1121        let reader = MrfV2Readiness::new(2, MrfV2Capabilities::empty(), false)
1122            .reader()
1123            .expect("readiness with valid empty capabilities should initialize");
1124        assert_eq!(
1125            reader.read(MRF_V2_NAMESPACE, &fixture),
1126            Err(MrfV2Error::MissingCapabilities {
1127                required: 1,
1128                available: 0,
1129            })
1130        );
1131    }
1132}