working on tests

lib/src/sparql/eval.rs

@@ -138,7 +138,7 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
             } => {
                 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<S> {
                     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();
+                                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<S> {
                                             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,14 +948,23 @@ impl<'a, S: StoreConnection + 'a> SimpleEvaluator<S> {
                     _ => 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 {
+                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) => {
                     if let EncodedTerm::StringLiteral { value_id } =

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<BindingsIterator<'a>>)> {
-         Some(TwoServiceTest::handle_service) 
+         Some(ServiceTest::handle_service) 
       }
   }
 
-
-  impl TwoServiceTest {
+  impl ServiceTest {
     fn handle_service<'a>(_graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
       Err(format_err!("This is supposed to fail"))
     }
@@ -127,30 +126,60 @@ fn silent_service_test() {
   SELECT ?name ?mbox 
   WHERE
     { 
-      SERVICE <http://service1.org>
+      SERVICE SILENT <http://service1.org>
       { ?s foaf:name ?name
       }
       
-      SERVICE <http://service2.org>
-      { ?s foaf:mbox ?mbox
-      }
     }
   ORDER BY ?name
   "#.to_string();
   
-  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" .
-    "#.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::<Vec<_>>();
-  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);
+  println!("Collected: {:?}", collected);
+  assert_eq!(collected.len(), 0);
+}
+
+#[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<BindingsIterator<'a>>)> {
+         Some(ServiceTest::handle_service) 
+      }
+  }
+
+  impl ServiceTest {
+    fn handle_service<'a>(_graph_pattern: GraphPattern) -> Result<BindingsIterator<'a>> {
+      Err(format_err!("This is supposed to fail"))
+    }
+  }
+
+  let query = r#"
+  PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+  SELECT ?name
+  WHERE
+    { 
+      SERVICE <http://service1.org>
+      { ?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 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 {

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