aro-core 1.0.0

Core domain layer for the Aro web framework
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

//! Pagination primitives for repository queries.

use serde::{Deserialize, Serialize};

/// A request for a specific page of results.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PageRequest {
    /// The 1-based page number.
    pub page: u64,
    /// The number of items per page.
    pub per_page: u64,
}

/// A page of results returned from a repository query.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Page<T> {
    /// The items in this page.
    pub items: Vec<T>,
    /// The total number of items across all pages.
    pub total: u64,
    /// The 1-based page number of this page.
    pub page: u64,
    /// The number of items per page.
    pub per_page: u64,
}

impl<T> Page<T> {
    /// Returns the total number of pages.
    pub fn total_pages(&self) -> u64 {
        if self.per_page == 0 {
            return 0;
        }
        self.total.div_ceil(self.per_page)
    }

    /// Returns `true` if there is a page after this one.
    pub fn has_next_page(&self) -> bool {
        self.page < self.total_pages()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn page_total_pages_exact_division() {
        let page: Page<i32> = Page {
            items: vec![1, 2],
            total: 10,
            page: 1,
            per_page: 5,
        };
        assert_eq!(page.total_pages(), 2);
    }

    #[test]
    fn page_total_pages_with_remainder() {
        let page: Page<i32> = Page {
            items: vec![1, 2, 3],
            total: 7,
            page: 1,
            per_page: 3,
        };
        assert_eq!(page.total_pages(), 3);
    }

    #[test]
    fn page_total_pages_zero_per_page() {
        let page: Page<i32> = Page {
            items: vec![],
            total: 10,
            page: 1,
            per_page: 0,
        };
        assert_eq!(page.total_pages(), 0);
    }

    #[test]
    fn page_total_pages_zero_total() {
        let page: Page<i32> = Page {
            items: vec![],
            total: 0,
            page: 1,
            per_page: 10,
        };
        assert_eq!(page.total_pages(), 0);
    }

    #[test]
    fn has_next_page_true() {
        let page: Page<i32> = Page {
            items: vec![1, 2],
            total: 10,
            page: 1,
            per_page: 5,
        };
        assert!(page.has_next_page());
    }

    #[test]
    fn has_next_page_false_on_last_page() {
        let page: Page<i32> = Page {
            items: vec![1],
            total: 10,
            page: 2,
            per_page: 5,
        };
        assert!(!page.has_next_page());
    }

    #[test]
    fn has_next_page_false_when_empty() {
        let page: Page<i32> = Page {
            items: vec![],
            total: 0,
            page: 1,
            per_page: 10,
        };
        assert!(!page.has_next_page());
    }

    #[test]
    fn page_request_construction() {
        let req = PageRequest {
            page: 2,
            per_page: 25,
        };
        assert_eq!(req.page, 2);
        assert_eq!(req.per_page, 25);
    }

    #[test]
    fn page_request_clone_and_eq() {
        let req = PageRequest {
            page: 1,
            per_page: 10,
        };
        let cloned = req.clone();
        assert_eq!(req, cloned);
    }
}