dryice-bio 0.4.0

High-throughput transient container for read-like genomic records
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Temporary-file lifecycle tests.

use std::fs;

use dryice::{DryIceReader, DryIceWriter, SeqRecord, SeqRecordExt, TempDryIceFile};

#[test]
fn temp_file_round_trips_records_and_cleans_up_explicitly() {
    let temp = TempDryIceFile::new().expect("temp file should be created");
    let path = temp.path().to_path_buf();

    let records = vec![
        SeqRecord::new(b"r1".to_vec(), b"ACGT".to_vec(), b"!!!!".to_vec()).expect("valid record"),
        SeqRecord::new(b"r2".to_vec(), b"TGCA".to_vec(), b"####".to_vec()).expect("valid record"),
    ];

    {
        let file = temp.open().expect("temp file should open");
        let mut writer = DryIceWriter::builder().inner(file).build();
        for record in &records {
            writer
                .write_record(record)
                .expect("write_record should succeed");
        }
        writer.finish().expect("finish should succeed");
    }

    let read_back = {
        let file = temp.open().expect("temp file should open");
        let mut reader = DryIceReader::new(file).expect("reader should open");
        let mut read_back = Vec::new();
        while reader.next_record().expect("next_record should succeed") {
            read_back.push(
                reader
                    .to_seq_record()
                    .expect("to_seq_record should succeed"),
            );
        }
        read_back
    };

    assert_eq!(read_back.len(), records.len());
    for (expected, actual) in records.iter().zip(read_back.iter()) {
        assert_eq!(expected.name(), actual.name());
        assert_eq!(expected.sequence(), actual.sequence());
        assert_eq!(expected.quality(), actual.quality());
    }

    assert!(path.exists(), "temporary file should exist before cleanup");
    temp.cleanup().expect("cleanup should succeed");
    assert!(!path.exists(), "temporary file should be removed");
}

#[test]
fn temp_file_cleans_up_on_drop() {
    let path = {
        let temp = TempDryIceFile::new().expect("temp file should be created");
        let path = temp.path().to_path_buf();
        assert!(path.exists(), "temporary file should exist while owned");
        path
    };

    assert!(!path.exists(), "temporary file should be removed on drop");
}

#[test]
fn explicit_cleanup_treats_missing_file_as_success() {
    let temp = TempDryIceFile::new().expect("temp file should be created");
    let path = temp.path().to_path_buf();

    fs::remove_file(&path).expect("manual removal should succeed");
    temp.cleanup()
        .expect("cleanup should accept an already-missing temp file");
}

#[test]
fn persist_moves_file_and_disarms_cleanup() {
    let directory = tempfile::tempdir().expect("tempdir should be created");
    let destination = directory.path().join("kept.dryice");

    let persisted_path = {
        let mut temp =
            TempDryIceFile::new_in(directory.path()).expect("temp file should be created");
        let original_path = temp.path().to_path_buf();

        {
            let file = temp.open().expect("temp file should open");
            let writer = DryIceWriter::builder().inner(file).build();
            writer.finish().expect("finish should succeed");
        }

        let persisted_path = temp
            .persist(&destination)
            .expect("persist should move the file");
        assert_eq!(persisted_path, destination);
        assert!(!original_path.exists(), "persist should move the temp path");
        persisted_path
    };

    assert!(
        persisted_path.exists(),
        "persisted file should remain caller-owned"
    );
}

#[test]
fn persist_rejects_existing_destination() {
    let directory = tempfile::tempdir().expect("tempdir should be created");
    let destination = directory.path().join("existing.dryice");
    fs::write(&destination, b"already here").expect("destination fixture should be written");

    let mut temp = TempDryIceFile::new_in(directory.path()).expect("temp file should be created");
    let original_path = temp.path().to_path_buf();

    let error = temp
        .persist(&destination)
        .expect_err("persist should reject existing destinations");

    assert!(
        error
            .to_string()
            .contains("persist destination already exists"),
        "unexpected error: {error}"
    );
    assert!(
        original_path.exists(),
        "failed persist should leave the temp file for drop cleanup"
    );
}