toshi-search / Toshi / 787

pending completion

Build # 787

Build Type

Pull #248

travis-ci

Committed by

web-flow

Commit Message

Bump tower-buffer from `db2f0ec` to `0e70f13`

Bumps [tower-buffer](https://github.com/tower-rs/tower) from `db2f0ec` to `0e70f13`.
- [Release notes](https://github.com/tower-rs/tower/releases)
- [Commits](https://github.com/tower-rs/tower/compare/db2f0ecfb...0e70f1320)

Signed-off-by: dependabot[bot] <support@dependabot.com>

Pull Request Pull Request #248: Bump tower-buffer from `db2f0ec` to `0e70f13`

Run Details

1068 of 1896 relevant lines covered (56.33%)

1.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.31

src/handlers/index.rs

use std::collections::HashMap;
use std::sync::{Arc, RwLock};

use serde::{Deserialize, Serialize};
use tantivy::schema::*;
use tantivy::Index;
use tower_web::*;

use crate::error::Error;
use crate::handle::IndexHandle;
use crate::handlers::CreatedResponse;
use crate::index::IndexCatalog;

#[derive(Extract, Deserialize)]
pub struct SchemaBody(Schema);

#[derive(Extract, Deserialize)]
pub struct DeleteDoc {
    pub options: Option<IndexOptions>,
    pub terms: HashMap<String, String>,
}

#[derive(Clone)]
pub struct IndexHandler {
    catalog: Arc<RwLock<IndexCatalog>>,
}

#[derive(Response, Deserialize)]
pub struct DocsAffected {
    pub docs_affected: u32,
}

#[derive(Extract, Deserialize)]
pub struct IndexOptions {
    #[serde(default)]
    pub commit: bool,
}

#[derive(Extract, Deserialize)]
pub struct AddDocument {
    pub options: Option<IndexOptions>,
    pub document: serde_json::Value,
}

impl IndexHandler {
    pub fn new(catalog: Arc<RwLock<IndexCatalog>>) -> Self {
        IndexHandler { catalog }
    }

    fn add_index(catalog: &Arc<RwLock<IndexCatalog>>, name: String, index: Index) -> Result<(), Error> {
        match catalog.write() {
            Ok(ref mut cat) => cat.add_index(name, index),
            Err(e) => Err(Error::IOError(e.to_string())),
        }
    }
}

impl_web! {
    impl IndexHandler {
        #[delete("/:index")]
        #[content_type("application/json")]
        pub fn delete(&self, body: DeleteDoc, index: String) -> Result<DocsAffected, Error> {
            if self.catalog.read().unwrap().exists(&index) {
                let index_lock = self.catalog.read().unwrap();
                let index_handle = index_lock.get_index(&index)?;
                index_handle.delete_term(body)
            } else {
                Err(Error::IOError("Failed to obtain index lock".into()))
            }
        }

        #[put("/:index")]
        #[content_type("application/json")]
        pub fn add(&self, body: AddDocument, index: String) -> Result<CreatedResponse, Error> {
            if let Ok(ref index_lock) = self.catalog.write() {
                if let Ok(ref index_handle) = index_lock.get_index(&index) {
                    index_handle.add_document(body)?;
                }
            }
            Ok(CreatedResponse)
        }

        #[put("/:index/_create")]
        #[content_type("application/json")]
        pub fn create(&self, body: SchemaBody, index: String) -> Result<CreatedResponse, Error> {
            let ip = self.catalog.read()?.base_path().clone();
            let new_index = IndexCatalog::create_from_managed(ip, &index, body.0)?;
            IndexHandler::add_index(&self.catalog, index.clone(), new_index).map(|_| CreatedResponse)
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::handlers::SearchHandler;
    use crate::index::tests::*;
    use tokio::prelude::*;

    use super::*;

    #[test]
    fn test_create_index() -> ::std::io::Result<()> {
        let shared_cat = create_test_catalog("test_index".into());
        let schema = r#"[
            { "name": "test_text", "type": "text", "options": { "indexing": { "record": "position", "tokenizer": "default" }, "stored": true } },
            { "name": "test_unindex", "type": "text", "options": { "indexing": { "record": "position", "tokenizer": "default" }, "stored": true } },
            { "name": "test_i64", "type": "i64", "options": { "indexed": true, "stored": true } },
            { "name": "test_u64", "type": "u64", "options": { "indexed": true, "stored": true } }
         ]"#;
        let handler = IndexHandler::new(Arc::clone(&shared_cat));
        let body: SchemaBody = serde_json::from_str(schema).unwrap();
        let req = handler.create(body, "new_index".into());
        assert_eq!(req.is_ok(), true);
        let search = SearchHandler::new(Arc::clone(&shared_cat));
        let docs = search.get_all_docs("new_index".into()).wait().unwrap();
        assert_eq!(docs.hits, 0);
        remove_dir_all::remove_dir_all("new_index")
    }

    #[test]
    fn test_doc_create() {
        let shared_cat = create_test_catalog("test_index".into());
        let body: AddDocument = serde_json::from_str(
            r#" {"options": {"commit": true}, "document": {"test_text": "Babbaboo!", "test_u64": 10, "test_i64": -10} }"#,
        )
        .unwrap();

        let handler = IndexHandler::new(Arc::clone(&shared_cat));
        let req = handler.add(body, "test_index".into());

        assert_eq!(req.is_ok(), true);
    }

    #[test]
    fn test_doc_delete() {
        let shared_cat = create_test_catalog("test_index".into());
        let handler = IndexHandler::new(Arc::clone(&shared_cat));
        let mut terms = HashMap::new();
        terms.insert("test_text".to_string(), "document".to_string());
        let delete = DeleteDoc {
            options: Some(IndexOptions { commit: true }),
            terms,
        };
        let req = handler.delete(delete, "test_index".into());
        assert_eq!(req.is_ok(), true);
        assert_eq!(req.unwrap().docs_affected, 3);
    }

    #[test]
    fn test_bad_json() {
        let shared_cat = create_test_catalog("test_index".into());
        let handler = IndexHandler::new(Arc::clone(&shared_cat));
        let bad_json: serde_json::Value = serde_json::Value::String("".into());
        let add_doc = AddDocument {
            document: bad_json,
            options: None,
        };
        let req = handler.add(add_doc, "test_index".into());
        assert_eq!(req.is_err(), true);
    }
}

1	use std::collections::HashMap;
2	use std::sync::{Arc, RwLock};
3
4	use serde::{Deserialize, Serialize};
5	use tantivy::schema::*;
6	use tantivy::Index;
7	use tower_web::*;
8
9	use crate::error::Error;
10	use crate::handle::IndexHandle;
11	use crate::handlers::CreatedResponse;
12	use crate::index::IndexCatalog;
13
14	#[derive(Extract, Deserialize)]	2✔
15	pub struct SchemaBody(Schema);
16
17	#[derive(Extract, Deserialize)]	2✔
18	pub struct DeleteDoc {
19	pub options: Option<IndexOptions>,
20	pub terms: HashMap<String, String>,
21	}
22
23	#[derive(Clone)]	×
24	pub struct IndexHandler {
25	catalog: Arc<RwLock<IndexCatalog>>,	×
26	}
27
28	#[derive(Response, Deserialize)]	×
29	pub struct DocsAffected {
30	pub docs_affected: u32,
31	}
32
33	#[derive(Extract, Deserialize)]	2✔
34	pub struct IndexOptions {
35	#[serde(default)]
36	pub commit: bool,
37	}
38
39	#[derive(Extract, Deserialize)]	2✔
40	pub struct AddDocument {
41	pub options: Option<IndexOptions>,
42	pub document: serde_json::Value,
43	}
44
45	impl IndexHandler {
46	pub fn new(catalog: Arc<RwLock<IndexCatalog>>) -> Self {	2✔
47	IndexHandler { catalog }	2✔
48	}	2✔
49
50	fn add_index(catalog: &Arc<RwLock<IndexCatalog>>, name: String, index: Index) -> Result<(), Error> {	2✔
51	match catalog.write() {	2✔
52	Ok(ref mut cat) => cat.add_index(name, index),	2✔
53	Err(e) => Err(Error::IOError(e.to_string())),	×
54	}	×
55	}	2✔
56	}
57
58	impl_web! {
59	impl IndexHandler {
60	#[delete("/:index")]
61	#[content_type("application/json")]
62	pub fn delete(&self, body: DeleteDoc, index: String) -> Result<DocsAffected, Error> {	2✔
63	if self.catalog.read().unwrap().exists(&index) {	2✔
64	let index_lock = self.catalog.read().unwrap();	2✔
65	let index_handle = index_lock.get_index(&index)?;	2✔
66	index_handle.delete_term(body)	2✔
67	} else {	2✔
68	Err(Error::IOError("Failed to obtain index lock".into()))	×
69	}
70	}	2✔
71
72	#[put("/:index")]
73	#[content_type("application/json")]
74	pub fn add(&self, body: AddDocument, index: String) -> Result<CreatedResponse, Error> {	2✔
75	if let Ok(ref index_lock) = self.catalog.write() {	2✔
76	if let Ok(ref index_handle) = index_lock.get_index(&index) {	2✔
77	index_handle.add_document(body)?;	2✔
78	}
79	}	2✔
80	Ok(CreatedResponse)	2✔
81	}	2✔
82
83	#[put("/:index/_create")]
84	#[content_type("application/json")]
85	pub fn create(&self, body: SchemaBody, index: String) -> Result<CreatedResponse, Error> {	2✔
86	let ip = self.catalog.read()?.base_path().clone();	2✔
87	let new_index = IndexCatalog::create_from_managed(ip, &index, body.0)?;	2✔
88	IndexHandler::add_index(&self.catalog, index.clone(), new_index).map(\|_\| CreatedResponse)	2✔
89	}	2✔
90	}
91	}
92
93	#[cfg(test)]
94	mod tests {
95	use crate::handlers::SearchHandler;
96	use crate::index::tests::*;
97	use tokio::prelude::*;
98
99	use super::*;
100
101	#[test]
102	fn test_create_index() -> ::std::io::Result<()> {	2✔
103	let shared_cat = create_test_catalog("test_index".into());	2✔
104	let schema = r#"[	2✔
105	{ "name": "test_text", "type": "text", "options": { "indexing": { "record": "position", "tokenizer": "default" }, "stored": true } },
106	{ "name": "test_unindex", "type": "text", "options": { "indexing": { "record": "position", "tokenizer": "default" }, "stored": true } },
107	{ "name": "test_i64", "type": "i64", "options": { "indexed": true, "stored": true } },
108	{ "name": "test_u64", "type": "u64", "options": { "indexed": true, "stored": true } }
109	]"#;
110	let handler = IndexHandler::new(Arc::clone(&shared_cat));	2✔
111	let body: SchemaBody = serde_json::from_str(schema).unwrap();	2✔
112	let req = handler.create(body, "new_index".into());	2✔
113	assert_eq!(req.is_ok(), true);	2✔
114	let search = SearchHandler::new(Arc::clone(&shared_cat));	2✔
115	let docs = search.get_all_docs("new_index".into()).wait().unwrap();	2✔
116	assert_eq!(docs.hits, 0);	2✔
117	remove_dir_all::remove_dir_all("new_index")	2✔
118	}	2✔
119
120	#[test]
121	fn test_doc_create() {	2✔
122	let shared_cat = create_test_catalog("test_index".into());	2✔
123	let body: AddDocument = serde_json::from_str(	2✔
124	r#" {"options": {"commit": true}, "document": {"test_text": "Babbaboo!", "test_u64": 10, "test_i64": -10} }"#,
125	)
126	.unwrap();	2✔
127
128	let handler = IndexHandler::new(Arc::clone(&shared_cat));	2✔
129	let req = handler.add(body, "test_index".into());	2✔
130
131	assert_eq!(req.is_ok(), true);	2✔
132	}	2✔
133
134	#[test]
135	fn test_doc_delete() {	2✔
136	let shared_cat = create_test_catalog("test_index".into());	2✔
137	let handler = IndexHandler::new(Arc::clone(&shared_cat));	2✔
138	let mut terms = HashMap::new();	2✔
139	terms.insert("test_text".to_string(), "document".to_string());	2✔
140	let delete = DeleteDoc {	2✔
141	options: Some(IndexOptions { commit: true }),	2✔
142	terms,	2✔
143	};
144	let req = handler.delete(delete, "test_index".into());	2✔
145	assert_eq!(req.is_ok(), true);	2✔
146	assert_eq!(req.unwrap().docs_affected, 3);	2✔
147	}	2✔
148
149	#[test]
150	fn test_bad_json() {	2✔
151	let shared_cat = create_test_catalog("test_index".into());	2✔
152	let handler = IndexHandler::new(Arc::clone(&shared_cat));	2✔
153	let bad_json: serde_json::Value = serde_json::Value::String("".into());	2✔
154	let add_doc = AddDocument {	2✔
155	document: bad_json,	2✔
156	options: None,	2✔
157	};
158	let req = handler.add(add_doc, "test_index".into());	2✔
159	assert_eq!(req.is_err(), true);	2✔
160	}	2✔
161	}

toshi-search / Toshi / 787

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous