From 75c786b35092793e6e25eec7f6341dee13926a32 Mon Sep 17 00:00:00 2001 From: Dustin Whitney Date: Wed, 16 Oct 2019 17:12:20 -0400 Subject: [PATCH] working on tests --- lib/src/sparql/eval.rs | 50 +++++++++++++++++------ lib/tests/service_test_cases.rs | 71 +++++++++++++++++++++++---------- lib/tests/sparql_test_cases.rs | 4 +- 3 files changed, 89 insertions(+), 36 deletions(-) diff --git a/lib/src/sparql/eval.rs b/lib/src/sparql/eval.rs index b85a2386..c20b7c1b 100644 --- a/lib/src/sparql/eval.rs +++ b/lib/src/sparql/eval.rs @@ -138,7 +138,7 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator { } => { match &options.service_handler { None => if *silent { - return Box::new(vec![].into_iter()); + return Box::new(empty()); } else { return Box::new(once(Err(format_err!( "No handler was supplied to resolve the given service" @@ -147,21 +147,30 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator { Some(handler) => { let pattern_option = match get_pattern_value(service_name, &[]) { None => if *silent { - return Box::new(vec![].into_iter()); + return Box::new(empty()); } else { return Box::new(once(Err(format_err!( "The handler supplied was unable to evaluate the given service" )))) as EncodedTuplesIterator<'_>; }, Some(term) => { - let named_node = self.dataset.decode_named_node(term).unwrap(); - handler.handle(named_node) + match self.dataset.decode_named_node(term) { + Err(err) => if *silent { + return Box::new(empty()); + } else { + return Box::new(once(Err(err))) as EncodedTuplesIterator<'_>; + }, + Ok(named_node) => { + println!("named_node: {:?}", named_node); + handler.handle(named_node) + } + + } }, }; - match pattern_option { None => if *silent { - return Box::new(vec![].into_iter()); + return Box::new(empty()); } else { return Box::new(once(Err(format_err!( "The handler supplied was unable to produce any result set on the given service" @@ -178,7 +187,13 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator { buffered_results: vec![], }) }, - Err(err) => return Box::new(once(Err(err))) as EncodedTuplesIterator<'_> + Err(err) => { + if *silent { + return Box::new(empty()); + } else { + return Box::new(once(Err(err))) as EncodedTuplesIterator<'_> + } + } } }, } @@ -933,13 +948,22 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator { _ => None, }?; let iri = self.dataset.get_str(iri_id).ok()??; - let base_iri = options.base_iri.map(|base_iri| Iri::parse(base_iri)); - if let Some(Ok(base_iri)) = base_iri { - self.build_named_node(&base_iri.resolve(&iri).ok()?.into_inner()) - } else { - Iri::parse(iri).ok()?; - Some(EncodedTerm::NamedNode { iri_id }) + match options.base_iri { + None => { + Iri::parse(iri).ok()?; + Some(EncodedTerm::NamedNode { iri_id }) + }, + Some(str_iri) => { + match Iri::parse(str_iri) { + Ok(base_iri) => self.build_named_node(&base_iri.resolve(&iri).ok()?.into_inner()), + _ => { + Iri::parse(iri).ok()?; + Some(EncodedTerm::NamedNode { iri_id }) + } + } + } } + } PlanExpression::BNode(id) => match id { Some(id) => { diff --git a/lib/tests/service_test_cases.rs b/lib/tests/service_test_cases.rs index 3016a013..9f02b34f 100644 --- a/lib/tests/service_test_cases.rs +++ b/lib/tests/service_test_cases.rs @@ -105,18 +105,17 @@ fn two_service_test() { } #[test] -fn silent_service_test() { +fn silent_service_empty_set_test() { #[derive(Clone,Copy)] - struct TwoServiceTest; - impl ServiceHandler for TwoServiceTest { + struct ServiceTest; + impl ServiceHandler for ServiceTest { fn handle<'a>(&'a self, _named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result>)> { - Some(TwoServiceTest::handle_service) + Some(ServiceTest::handle_service) } } - - impl TwoServiceTest { + impl ServiceTest { fn handle_service<'a>(_graph_pattern: GraphPattern) -> Result> { Err(format_err!("This is supposed to fail")) } @@ -127,30 +126,60 @@ fn silent_service_test() { SELECT ?name ?mbox WHERE { - SERVICE + SERVICE SILENT { ?s foaf:name ?name } + + } + ORDER BY ?name + "#.to_string(); + + let triples = b"".as_ref(); + let options = QueryOptions::default().with_service_handler(Box::new(ServiceTest)); + let results = do_query(triples, query, options).unwrap(); + let collected = results.into_values_iter().map(move |b| b.unwrap()).collect::>(); + println!("Collected: {:?}", collected); + assert_eq!(collected.len(), 0); +} - SERVICE - { ?s foaf:mbox ?mbox +#[test] +fn non_silent_service_test() { + + #[derive(Clone,Copy)] + struct ServiceTest; + impl ServiceHandler for ServiceTest { + fn handle<'a>(&'a self, _named_node: NamedNode) -> Option<(fn(GraphPattern) -> Result>)> { + Some(ServiceTest::handle_service) + } + } + + impl ServiceTest { + fn handle_service<'a>(_graph_pattern: GraphPattern) -> Result> { + Err(format_err!("This is supposed to fail")) + } + } + + let query = r#" + PREFIX foaf: + SELECT ?name + WHERE + { + SERVICE + { ?s foaf:name ?name } + } ORDER BY ?name "#.to_string(); - let triples = br#" - "Bob" . - "Alice" . - "#.as_ref(); - - let options = QueryOptions::default().with_service_handler(Box::new(TwoServiceTest)); + let triples = b"".as_ref(); + let options = QueryOptions::default().with_service_handler(Box::new(ServiceTest)); let results = do_query(triples, query, options).unwrap(); - let collected = results.into_values_iter().map(move |b| b.unwrap()).collect::>(); - 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())) ], - ]; - assert_eq!(collected, solution); + let result = results.into_values_iter().next(); + match result { + Some(Err(_)) => assert_eq!(true, true), + _ => assert_eq!(true, false, "This should have been an error since the service fails"), + } } fn ex(id: String) -> Term { diff --git a/lib/tests/sparql_test_cases.rs b/lib/tests/sparql_test_cases.rs index 5555df9e..7da57ec3 100644 --- a/lib/tests/sparql_test_cases.rs +++ b/lib/tests/sparql_test_cases.rs @@ -158,13 +158,13 @@ fn sparql_w3c_query_evaluation_testsuite() -> Result<()> { } match repository .connection()? - .prepare_query(&read_file_to_string(&test.query)?, None) + .prepare_query(&read_file_to_string(&test.query)?, Some(&test.query)) { Err(error) => Err(format_err!( "Failure to parse query of {} with error: {}", test, error )), - Ok(query) => match query.exec(&QueryOptions::default()) { + Ok(query) => match query.exec(&QueryOptions::default().with_base_iri(&test.query)) { Err(error) => Err(format_err!( "Failure to execute query of {} with error: {}", test, error