xsra 0.2.29

A performant and storage-efficient CLI tool to extract sequences from an SRA archive with support for FASTA, FASTQ, and BINSEQ outputs.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use assert_cmd::cargo;
use predicates::prelude::*;
use std::fs;
use tempfile::TempDir;

/// Integration tests for prefetch using CLI approach

#[test]
#[ignore = "requires network access"]
fn test_prefetch_multiple_accessions_https() {
    let temp_dir = TempDir::new().unwrap();
    let output_path = temp_dir.path();

    // Use same accessions as fixtures to save time
    let mut cmd = cargo::cargo_bin_cmd!("xsra");
    cmd.args(&[
        "prefetch",
        "SRR5150787", // Small variable-length SRA (~1.7MB)
        "SRR1574235", // Small fixed-length SRA (~17MB)
        "--output",
        output_path.to_str().unwrap(),
        "--provider",
        "https",
        "--retry-limit",
        "3",
    ]);

    let assert = cmd.assert();
    assert.success();

    // Verify both files were downloaded
    let files: Vec<_> = fs::read_dir(output_path)
        .unwrap()
        .filter_map(Result::ok)
        .collect();
    assert_eq!(
        files.len(),
        2,
        "Expected two files to be downloaded for two accessions"
    );

    // Verify both files are not empty
    for file in files {
        assert!(
            file.metadata().unwrap().len() > 0,
            "Downloaded file {:?} is empty",
            file.file_name()
        );
    }
}

#[test]
#[ignore = "requires network access"]
fn test_prefetch_invalid_accession_https() {
    let temp_dir = TempDir::new().unwrap();
    let output_path = temp_dir.path();

    let mut cmd = cargo::cargo_bin_cmd!("xsra");
    cmd.args(&[
        "prefetch",
        "INVALID_ACCESSION_12345",
        "--output",
        output_path.to_str().unwrap(),
        "--provider",
        "https",
        "--retry-limit",
        "1",
    ]);

    let assert = cmd.assert();
    assert.failure().stderr(
        predicate::str::contains("Unable to identify a download URL")
            .or(predicate::str::contains("API rate limit")),
    );
}

#[test]
#[ignore = "requires network access"]
fn test_prefetch_lite_vs_full_quality() {
    let temp_dir_lite = TempDir::new().unwrap();
    let output_path_lite = temp_dir_lite.path();

    // First, download lite version (prefer lite, allow fallback)
    let mut cmd_lite = cargo::cargo_bin_cmd!("xsra");
    cmd_lite.args(&[
        "prefetch",
        "SRR5150787", // Small variable SRA that should have lite version
        "--output",
        output_path_lite.to_str().unwrap(),
        "--provider",
        "https",
        "--retry-limit",
        "3",
        // Default is full_quality=false, lite_only=false (prefer lite with fallback)
    ]);

    let assert_lite = cmd_lite.assert();
    assert_lite.success();

    let lite_file_path = fs::read_dir(output_path_lite)
        .unwrap()
        .next()
        .unwrap()
        .unwrap()
        .path();
    let lite_size = fs::metadata(&lite_file_path).unwrap().len();

    // Then, download full version
    let temp_dir_full = TempDir::new().unwrap();
    let output_path_full = temp_dir_full.path();

    let mut cmd_full = cargo::cargo_bin_cmd!("xsra");
    cmd_full.args(&[
        "prefetch",
        "SRR5150787",
        "--output",
        output_path_full.to_str().unwrap(),
        "--provider",
        "https",
        "--retry-limit",
        "3",
        "--full-quality", // Request full quality version
    ]);

    let assert_full = cmd_full.assert();
    assert_full.success();

    let full_file_path = fs::read_dir(output_path_full)
        .unwrap()
        .next()
        .unwrap()
        .unwrap()
        .path();
    let full_size = fs::metadata(&full_file_path).unwrap().len();

    // Full should be larger than lite (if lite was actually downloaded)
    assert!(
        full_size >= lite_size,
        "Expected full quality file ({}) to be >= lite quality file ({})",
        full_size,
        lite_size
    );
}