rsolr 0.3.2

A Solr client for Rust.
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

use std::fmt::Debug;
use serde::{Deserialize};
use serde_json::Value;

/// The fields part of the facets.
#[derive(Clone, Debug, Deserialize)]
pub struct FacetFields {

    /// Deserialized value of facet_fields.
    #[serde(flatten)]
    pub fields: Value,
}

impl FacetFields {

    /// Get all value of a facet field.
    pub fn get_all_values_of(&self, field: &str) -> Option<Vec<&str>> {
        let mut array_iter = match self.fields[field].as_array() {
            Some(ar) => ar.iter(),
            None => return None
        };
        let mut all = vec![];

        while let Some(i) = array_iter.next()  {
            if i.is_string() {
               all.push(i.as_str().unwrap());
            }
        }
        Some(all)
    }

    /// Get the count of a specific field value.
    pub fn get_count(&self, field: &str, key: &str) -> Option<u64> {
        let mut array_iter = match self.fields[field].as_array() {
            Some(ar) => ar.iter(),
            None => return None
        };

        let mut actual = array_iter.next();
        while actual != None  {

            match actual.unwrap().as_str() {
                Some(str) => {
                    if str == key {
                        return array_iter.next().unwrap().as_u64()
                    }
                },
                None => ()
            }

            actual = array_iter.next();
        }
        None
    }
}

#[cfg(test)]
mod tests {
    use crate::facet_fields::FacetFields;

    #[test]
    fn get_custom_field_count() {
        let fields = serde_json::from_str(r#"{"field_value": ["val1", 123, "val2", 234] }"#).unwrap();
        let facet_fields = FacetFields { fields };

        assert_eq!(facet_fields.get_count("field_value","val2"), Some(234))
    }

    #[test]
    fn returns_none_if_no_field() {
        let fields = serde_json::from_str(r#"{"field_value": ["val1", 123, "val2", 234] }"#).unwrap();
        let facet_fields = FacetFields { fields };

        assert_eq!(facet_fields.get_count("not_existing","val1"), None);
    }

    #[test]
    fn returns_none_if_no_field_value() {
        let fields = serde_json::from_str(r#"{"field_value": ["val1", 123, "val2", 234] }"#).unwrap();
        let facet_fields = FacetFields { fields };

        assert_eq!(facet_fields.get_count("field_value", "not_existing"), None);
    }

    #[test]
    fn get_all_field_values() {
        let fields = serde_json::from_str(r#"{"field_value": ["val1", 123, "val2", 234] }"#).unwrap();
        let facet_fields = FacetFields { fields };

        let expected_values = vec!["val1", "val2"];

        assert_eq!(facet_fields.get_all_values_of("field_value"), Some(expected_values));
    }

    #[test]
    fn get_all_none_from_notexisting_field() {
        let fields = serde_json::from_str(r#"{"field_value": ["val1", 123, "val2", 234] }"#).unwrap();
        let facet_fields = FacetFields { fields };
        assert_eq!(facet_fields.get_all_values_of("field_value2342"), None);
    }

}