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
use crate::{Headers, RowResult, RowStream};
#[derive(Debug, PartialEq)]
pub enum BuildError {
EmptyIterator,
FailedHeader,
}
#[derive(Debug)]
pub struct MockStream<I> {
iter: I,
headers: Headers,
}
impl<I> MockStream<I>
where
I: Iterator<Item = RowResult>,
{
pub fn new(iter: I, headers: Headers) -> MockStream<I> {
MockStream {
iter,
headers,
}
}
pub fn from_rows(mut iter: I) -> Result<MockStream<I>, BuildError> {
match iter.next() {
Some(Ok(row)) => Ok(MockStream::new(iter, row.into())),
Some(Err(_)) => Err(BuildError::FailedHeader),
None => Err(BuildError::EmptyIterator),
}
}
}
pub struct IntoIter<I> {
iter: I,
}
impl<I> Iterator for IntoIter<I>
where
I: Iterator<Item = RowResult>,
{
type Item = RowResult;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next()
}
}
impl<I> IntoIterator for MockStream<I>
where
I: Iterator<Item = RowResult>,
{
type Item = RowResult;
type IntoIter = IntoIter<I>;
fn into_iter(self) -> Self::IntoIter {
IntoIter { iter: self.iter }
}
}
impl<I> RowStream for MockStream<I>
where
MockStream<I>: IntoIterator<Item = RowResult>,
{
fn headers(&self) -> &Headers {
&self.headers
}
}
#[cfg(test)]
mod tests {
use crate::Row;
use super::{MockStream, RowStream};
#[test]
fn test_mock_stream() {
let m = MockStream::from_rows(
vec![
Ok(Row::from(vec!["id", "num"])),
Ok(Row::from(vec!["1", "40"])),
Ok(Row::from(vec!["2", "39"])),
]
.into_iter(),
)
.unwrap();
assert_eq!(
*m.headers(),
Row::from(vec!["id", "num"]).into()
);
let mut m = m.into_iter();
assert_eq!(m.next().unwrap().unwrap(), Row::from(vec!["1", "40"]));
assert_eq!(m.next().unwrap().unwrap(), Row::from(vec!["2", "39"]));
}
}