rsxiv 0.4.3

Tools for working with arXiv and the arXiv API
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

use super::*;
use crate::ArticleId;
use chrono::{DateTime, FixedOffset};
use std::borrow::Cow;

#[test]
fn test_malfored_query() {
    use serde::Deserialize;

    use std::collections::BTreeMap;

    #[derive(Debug, Clone, PartialEq, Deserialize)]
    pub struct Entry<'r> {
        pub authors: Vec<AuthorName>,
        pub comment: Option<&'r str>,
    }

    let contents = include_str!("../response/tests/query_missing_id.xml").as_bytes();

    let response = Response::<Vec<Entry>>::from_xml(contents).unwrap();
    assert_eq!(response.entries.len(), 1);
    assert!(response.entries[0].comment.is_some());

    let response = Response::<BTreeMap<ArticleId, Entry>>::from_xml(contents).unwrap();
    assert_eq!(
        response
            .entries
            .get(&ArticleId::parse("2201.13452v1").unwrap())
            .unwrap()
            .authors[0]
            .to_string(),
        "Hong-Ming Yin"
    );
}

#[test]
fn test_query_de() {
    use serde::Deserialize;

    /// Typed representation of a single entry in the arXiv API response.
    #[derive(Debug, Clone, PartialEq, Deserialize)]
    pub struct Entry<'r> {
        /// The arXiv identifier of the entry.
        pub id: ArticleId,
        /// The date that the retrieved version of the article was submitted.
        pub updated: DateTime<FixedOffset>,
        /// The date that version 1 was submitted.
        pub published: DateTime<FixedOffset>,
        /// The title of the article.
        #[serde(borrow)]
        pub title: Cow<'r, str>,
        /// The article abstract.
        #[serde(borrow)]
        pub summary: Cow<'r, str>,
        /// The article authors.
        pub authors: Vec<Author<'r>>,
        /// A url for the resolved DOI to an external resource.
        #[serde(borrow)]
        pub doi: Option<Cow<'r, str>>,
        /// The author comment.
        #[serde(borrow)]
        pub comment: Option<Cow<'r, str>>,
        /// A journal reference.
        #[serde(borrow)]
        pub journal_ref: Option<Cow<'r, str>>,
        /// The primary arXiv or ACM or MSC category for an article.
        #[serde(borrow)]
        pub primary_category: Cow<'r, str>,
        /// The arXiv or ACM or MSC category for an article.
        #[serde(borrow)]
        pub categories: Vec<Cow<'r, str>>,
        extra: Option<String>,
    }

    /// An article author.
    #[derive(Debug, Clone, PartialEq, Deserialize)]
    pub struct Author<'r> {
        /// The name of the author.
        pub name: AuthorName,
        /// The affiliation of the author.
        #[serde(borrow)]
        pub affiliation: Option<Cow<'r, str>>,
    }

    let contents = include_str!("../response/tests/query.xml").as_bytes();
    let response = Response::<Vec<Entry>>::from_xml(contents).unwrap();
    assert_eq!(
        Ok(response.updated),
        chrono::DateTime::parse_from_rfc3339("2025-11-11T18:29:40+00:00")
    );
    assert_eq!(response.pagination.total_results, 7432,);
    assert_eq!(response.pagination.start_index, 0);
    assert_eq!(response.pagination.items_per_page, 10);
    assert_eq!(
        Ok(response.entries[0].id),
        crate::id::ArticleId::parse("nucl-ex/0408020v1")
    );
    assert_eq!(response.entries.len(), 10);
    assert_eq!(
        response.entries[9].authors[0].name,
        AuthorName {
            firstnames: "U. D.".to_owned(),
            keyname: "Jentschura".to_owned(),
            suffix: String::new()
        }
    );

    assert_eq!(response.entries[8].primary_category, "physics.plasm-ph");
    assert_eq!(
        response.entries[8].comment.as_ref().unwrap(),
        "11 pages, 19 figures"
    );
    assert_eq!(response.entries[8].journal_ref, None);
    assert_eq!(response.entries[8].authors.len(), 3);

    assert_eq!(response.entries[9].authors[0].affiliation, None);
    assert_eq!(
        response.entries[9].doi.as_ref().unwrap(),
        "10.1103/PhysRevA.88.062514"
    );

    assert_eq!(response.entries[9].categories[2], "nucl-th");
    assert_eq!(
        response.entries[9].published,
        chrono::DateTime::parse_from_rfc3339("2014-01-15T16:58:15Z").unwrap()
    );

    let contents = include_str!("../response/tests/query_empty.xml").as_bytes();
    let response = Response::<Vec<Entry>>::from_xml(contents).unwrap();
    assert_eq!(
        Ok(response.updated),
        chrono::DateTime::parse_from_rfc3339("2025-11-11T18:34:08+00:00")
    );
    assert!(response.entries.is_empty());
}