NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

refactored tests

Browse Source
pull/11/head
Dustin Whitney 5 years ago
parent 9d83649a08
commit 5d8e63376b
4 changed files with 98 additions and 155 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 2
      lib/src/lib.rs
  2. 13
      lib/src/sparql/eval.rs
  3. 2
      lib/src/store/mod.rs
  4. 204
      lib/tests/service_test_cases.rs

2
lib/src/lib.rs
Unescape View File

@ -44,7 +44,7 @@ pub use failure::Error;
pub type Result<T> = ::std::result::Result<T, failure::Error>;
pub use crate::repository::Repository;
pub use crate::repository::RepositoryConnection;
pub use crate::store::MemoryRepository;
pub use crate::store::{MemoryRepository, MemoryRepositoryConnection};
#[cfg(feature = "rocksdb")]
pub use crate::store::RocksDbRepository;
pub use crate::syntax::DatasetSyntax;

13
lib/src/sparql/eval.rs
Unescape View File

@ -169,7 +169,8 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
)))) as EncodedTuplesIterator<'_>;
},
Some(pattern_fn) => {
let bindings = pattern_fn(graph_pattern.clone()).unwrap();
match pattern_fn(graph_pattern.clone()) {
Ok(bindings) => {
let encoded = self.encode_bindings(variables, bindings);
let collected = encoded.collect::<Vec<_>>();
Box::new(JoinIterator {
@ -178,6 +179,9 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
buffered_results: vec![],
})
},
Err(err) => return Box::new(once(Err(err))) as EncodedTuplesIterator<'_>
}
},
}
}
}
@ -1644,17 +1648,12 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
{
let mut encoder = self.dataset.encoder();
let (binding_variables, iter) = BindingsIterator::destruct(iter);
let mut combined_variables = variables.clone().to_vec();
let mut combined_variables = variables.to_vec();
for v in binding_variables.clone() {
if !combined_variables.contains(&v) {
combined_variables.resize(combined_variables.len() + 1, v);
}
}
println!("binding_variables: {:?}", binding_variables.clone());
println!("variables: {:?}", variables.clone());
println!("combined_variables: {:?}", combined_variables.clone());
println!("\n\n");
Box::new(iter.map(move |terms| {
let mut encoded_terms = vec![None; combined_variables.len()];
for (i, term_option) in terms?.into_iter().enumerate() {

2
lib/src/store/mod.rs
Unescape View File

@ -6,7 +6,7 @@ pub(crate) mod numeric_encoder;
mod rocksdb;
pub use crate::sparql::GraphPattern;
pub use crate::store::memory::MemoryRepository;
pub use crate::store::memory::{MemoryRepository, MemoryRepositoryConnection};
#[cfg(feature = "rocksdb")]
pub use crate::store::rocksdb::RocksDbRepository;

204
lib/tests/service_test_cases.rs
Unescape View File

@ -2,87 +2,24 @@ use rudf::model::*;
use rudf::{GraphSyntax, Repository, RepositoryConnection, MemoryRepository, Result};
use rudf::sparql::{BindingsIterator, GraphPattern, PreparedQuery, QueryOptions, QueryResult, ServiceHandler};
use failure::format_err;
use std::io::BufRead;
fn ex(id: String) -> Term {
Term::NamedNode(NamedNode::parse(format!("http://example.com/{}", &id)).unwrap())
}
fn foaf(id: String) -> Term {
Term::NamedNode(NamedNode::parse(format!("http://xmlns.com/foaf/0.1/{}", &id)).unwrap())
}
fn mailto(id: String) -> Term {
Term::NamedNode(NamedNode::parse(format!("mailto:{}", &id)).unwrap())
}
fn literal(str: String) -> Term {
Term::Literal(Literal::new_simple_literal(str))
}
/*
#[derive(Clone,Copy)]
struct SimpleServiceTest;
impl ServiceHandler for SimpleServiceTest {
fn handle<'a>(&'a self, named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result<BindingsIterator<'a>>)> {
Some(SimpleServiceTest::handle_service)
}
}
impl SimpleServiceTest {
fn handle_service<'a>(graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
let repository = MemoryRepository::default();
let mut connection = repository.connection().unwrap();
let file = b"<http://example.com/s> <http://example.com/p> <http://example.com/o> .";
connection.load_graph(file.as_ref(), GraphSyntax::NTriples, None, None).unwrap();
let prepared_query = connection.prepare_query_from_pattern(&graph_pattern, None).unwrap();
let result = prepared_query.exec(&Some(SimpleServiceTest)).unwrap();
match result {
QueryResult::Bindings(iterator) => {
let (variables, iter) = iterator.destruct();
let cloned_iter = iter.collect::<Vec<_>>().into_iter();
let new_iter = BindingsIterator::new(variables, Box::new(cloned_iter));
Ok(new_iter)
},
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
}
}
*/
#[test]
fn simple_service_test() {
struct TestServiceHandler;
impl ServiceHandler for TestServiceHandler {
fn handle<'a>(&'a self, named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result<BindingsIterator<'a>>)> {
fn handle<'a>(&'a self, _named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result<BindingsIterator<'a>>)> {
fn pattern_handler<'a>(graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
let repository = MemoryRepository::default();
let mut connection = repository.connection().unwrap();
let file = b"<http://example.com/s> <http://example.com/p> <http://example.com/o> .";
connection.load_graph(file.as_ref(), GraphSyntax::NTriples, None, None).unwrap();
let query_options = QueryOptions::default();
let prepared_query = connection.prepare_query_from_pattern(&graph_pattern, &query_options).unwrap();
let result = prepared_query.exec(&query_options).unwrap();
match result {
QueryResult::Bindings(iterator) => {
let (variables, iter) = iterator.destruct();
let cloned_iter = iter.collect::<Vec<_>>().into_iter();
let new_iter = BindingsIterator::new(variables, Box::new(cloned_iter));
Ok(new_iter)
},
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
let triples = b"<http://example.com/s> <http://example.com/p> <http://example.com/o> .".as_ref();
do_pattern(triples, graph_pattern, QueryOptions::default())
};
Some(pattern_handler)
}
}
let repository = MemoryRepository::default();
let connection = repository.connection().unwrap();
let query = r#"
SELECT ?s ?p ?o
WHERE
@ -91,24 +28,18 @@ fn simple_service_test() {
{ ?s ?p ?o
}
}
"#;
"#.to_string();
let query_options = QueryOptions::default().with_service_handler(Box::new(TestServiceHandler));
let prepared_query = connection.prepare_query(query, &query_options).unwrap();
let results = prepared_query.exec(&query_options).unwrap();
if let QueryResult::Bindings(results) = results {
let options = QueryOptions::default().with_service_handler(Box::new(TestServiceHandler));
let results = do_query(b"".as_ref(), query, options).unwrap();
let collected = results.into_values_iter().map(move |b| b.unwrap()).collect::<Vec<_>>();
let solution = vec![
vec![ Some(ex(String::from("s"))), Some(ex(String::from("p"))), Some(ex(String::from("o"))) ],
];
assert_eq!(collected, solution);
} else {
assert_eq!(true, false);
}
}
}
#[test]
@ -118,7 +49,6 @@ fn two_service_test() {
struct TwoServiceTest;
impl ServiceHandler for TwoServiceTest {
fn handle<'a>(&'a self, named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result<BindingsIterator<'a>>)> {
println!("Handler called for {:?}", named_node);
let service1 = NamedNode::parse("http://service1.org").unwrap();
let service2 = NamedNode::parse("http://service2.org").unwrap();
if named_node == service1 { Some(TwoServiceTest::handle_service1) }
@ -131,57 +61,23 @@ fn two_service_test() {
impl TwoServiceTest {
fn handle_service1<'a>(graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
let repository = MemoryRepository::default();
let mut connection = repository.connection().unwrap();
let file = br#"
let triples = br#"
<http://example.com/bob> <http://xmlns.com/foaf/0.1/name> "Bob" .
<http://example.com/alice> <http://xmlns.com/foaf/0.1/name> "Alice" .
"#;
connection.load_graph(file.as_ref(), GraphSyntax::NTriples, None, None).unwrap();
let query_options = QueryOptions::default().with_service_handler(Box::new(TwoServiceTest));
let prepared_query = connection.prepare_query_from_pattern(&graph_pattern, &query_options).unwrap();
let result = prepared_query.exec(&query_options).unwrap();
match result {
QueryResult::Bindings(iterator) => {
let (variables, iter) = iterator.destruct();
let cloned_iter = iter.collect::<Vec<_>>().into_iter();
let new_iter = BindingsIterator::new(variables, Box::new(cloned_iter));
Ok(new_iter)
},
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
"#.as_ref();
do_pattern(triples, graph_pattern, QueryOptions::default())
}
fn handle_service2<'a>(graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
let repository = MemoryRepository::default();
let mut connection = repository.connection().unwrap();
let file = br#"
let triples = br#"
<http://example.com/bob> <http://xmlns.com/foaf/0.1/mbox> <mailto:bob@example.com> .
<http://example.com/alice> <http://xmlns.com/foaf/0.1/mbox> <mailto:alice@example.com> .
"#;
connection.load_graph(file.as_ref(), GraphSyntax::NTriples, None, None).unwrap();
let query_options = QueryOptions::default().with_service_handler(Box::new(TwoServiceTest));
let prepared_query = connection.prepare_query_from_pattern(&graph_pattern, &query_options).unwrap();
let result = prepared_query.exec(&query_options).unwrap();
match result {
QueryResult::Bindings(iterator) => {
let (variables, iter) = iterator.destruct();
let cloned_iter = iter.collect::<Vec<_>>().into_iter();
let new_iter = BindingsIterator::new(variables, Box::new(cloned_iter));
Ok(new_iter)
},
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
"#.as_ref();
do_pattern(triples, graph_pattern, QueryOptions::default())
}
}
let repository = MemoryRepository::default();
let connection = repository.connection().unwrap();
let query = r#"
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
SELECT ?name ?mbox
@ -196,26 +92,74 @@ fn two_service_test() {
}
}
ORDER BY ?name
"#;
"#.to_string();
let query_options = QueryOptions::default().with_service_handler(Box::new(TwoServiceTest));
let prepared_query = connection.prepare_query(query, &query_options).unwrap();
let results = prepared_query.exec(&query_options).unwrap();
if let QueryResult::Bindings(results) = results {
let options = QueryOptions::default().with_service_handler(Box::new(TwoServiceTest));
let results = do_query(b"".as_ref(), query, options).unwrap();
let collected = results.into_values_iter().map(move |b| b.unwrap()).collect::<Vec<_>>();
for c in collected.clone() {
println!("{:?}", c);
}
println!("\n\n\n");
let solution = vec![
vec![ Some(literal("Alice".to_string())), Some(mailto("alice@example.com".to_string())) ],
vec![ Some(literal("Bob".to_string())), Some(mailto("bob@example.com".to_string())) ],
];
println!("Results: {:?}", collected);
assert_eq!(collected, solution);
} else {
assert_eq!(true, false);
}
fn ex(id: String) -> Term {
Term::NamedNode(NamedNode::parse(format!("http://example.com/{}", &id)).unwrap())
}
fn mailto(id: String) -> Term {
Term::NamedNode(NamedNode::parse(format!("mailto:{}", &id)).unwrap())
}
fn literal(str: String) -> Term {
Term::Literal(Literal::new_simple_literal(str))
}
fn make_repository(reader: impl BufRead) -> Result<MemoryRepository> {
let repository = MemoryRepository::default();
let mut connection = repository.connection()?;
connection.load_graph(reader, GraphSyntax::NTriples, None, None).unwrap();
Ok(repository)
}
fn query_repository<'a>(repository: MemoryRepository, query: String, options: QueryOptions<'a>) -> Result<BindingsIterator<'a>> {
let connection = repository.connection()?;
let prepared_query = connection.prepare_query(&query, &options)?;
let result = prepared_query.exec(&options)?;
match result {
QueryResult::Bindings(iterator) => {
let (varaibles, iter) = iterator.destruct();
let collected = iter.collect::<Vec<_>>();
Ok(BindingsIterator::new(varaibles, Box::new(collected.into_iter())))
},
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
}
//fn pattern_repository<'a>(repository: MemoryRepository, pattern: GraphPattern, options: QueryOptions<'a>) -> Result<Vec<Vec<Option<Term>>>> {
fn pattern_repository<'a>(repository: MemoryRepository, pattern: GraphPattern, options: QueryOptions<'a>) -> Result<BindingsIterator<'a>> {
let connection = repository.connection()?;
let prepared_query = connection.prepare_query_from_pattern(&pattern, &options)?;
let result = prepared_query.exec(&options)?;
match result {
QueryResult::Bindings(iterator) => {
let (varaibles, iter) = iterator.destruct();
let collected = iter.collect::<Vec<_>>();
Ok(BindingsIterator::new(varaibles, Box::new(collected.into_iter())))
}
_ => Err(format_err!("Excpected bindings but got another QueryResult"))
}
}
//fn do_query<'a>(reader: impl BufRead, query: String, options: QueryOptions<'a>) -> Result<Vec<Vec<Option<Term>>>> {
fn do_query<'a>(reader: impl BufRead, query: String, options: QueryOptions<'a>) -> Result<BindingsIterator<'a>> {
let repository = make_repository(reader)?;
query_repository(repository, query, options)
}
//fn do_pattern<'a>(reader: impl BufRead, pattern: GraphPattern, options: QueryOptions<'a>) -> Result<Vec<Vec<Option<Term>>>> {
fn do_pattern<'a>(reader: impl BufRead, pattern: GraphPattern, options: QueryOptions<'a>) -> Result<BindingsIterator<'a>> {
let repository = make_repository(reader)?;
pattern_repository(repository, pattern, options)
}

Write Preview
Loading…
Cancel
Save