@ -3,7 +3,7 @@ use crate::files::*;
use crate ::manifest ::* ; use crate ::manifest ::* ;
use crate ::report ::dataset_diff ; use crate ::report ::dataset_diff ;
use crate ::vocab ::* ; use crate ::vocab ::* ;
use anyhow ::{ anyhow , Result } ; use anyhow ::{ anyhow , bail , Result } ;
use oxigraph ::model ::vocab ::* ; use oxigraph ::model ::vocab ::* ;
use oxigraph ::model ::* ; use oxigraph ::model ::* ;
use oxigraph ::sparql ::* ; use oxigraph ::sparql ::* ;
@ -73,32 +73,23 @@ fn evaluate_positive_syntax_test(test: &Test) -> Result<()> {
let query_file = test let query_file = test
. action . action
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test}" ) ) ? ;
match Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) { let query = Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) )
Err ( error ) = > Err ( anyhow ! ( "Not able to parse {} with error: {}" , test , error ) ) , . map_err ( | e | anyhow ! ( "Not able to parse {test} with error: {e}" ) ) ? ;
Ok ( query ) = > match Query ::parse ( & query . to_string ( ) , None ) { Query ::parse ( & query . to_string ( ) , None )
Ok ( _ ) = > Ok ( ( ) ) , . map_err ( | e | anyhow ! ( "Failure to deserialize \"{query}\" of {test} with error: {e}" ) ) ? ;
Err ( error ) = > Err ( anyhow ! ( Ok ( ( ) )
"Failure to deserialize \"{}\" of {} with error: {}" ,
query . to_string ( ) ,
test ,
error
) ) ,
} ,
}
} }
fn evaluate_negative_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_negative_syntax_test ( test : & Test ) -> Result < ( ) > {
let query_file = test let query_file = test
. action . action
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test}" ) ) ? ;
match Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) { match Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) {
Ok ( result ) = > Err ( anyhow ! ( Ok ( result ) = > {
"Oxigraph parses even if it should not {}. The output tree is: {}" , bail ! ( "Oxigraph parses even if it should not {test}. The output tree is: {result}" )
test , }
result
) ) ,
Err ( _ ) = > Ok ( ( ) ) , Err ( _ ) = > Ok ( ( ) ) ,
} }
} }
@ -109,7 +100,7 @@ fn evaluate_positive_json_result_syntax_test(test: &Test) -> Result<()> {
fn evaluate_negative_json_result_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_negative_json_result_syntax_test ( test : & Test ) -> Result < ( ) > {
if result_syntax_check ( test , QueryResultsFormat ::Json ) . is_ok ( ) { if result_syntax_check ( test , QueryResultsFormat ::Json ) . is_ok ( ) {
Err ( anyhow ! ( "Oxigraph parses even if it should not {}." , test ) ) bail ! ( "Oxigraph parses even if it should not {test }." )
} else { } else {
Ok ( ( ) ) Ok ( ( ) )
} }
@ -121,7 +112,7 @@ fn evaluate_positive_xml_result_syntax_test(test: &Test) -> Result<()> {
fn evaluate_negative_xml_result_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_negative_xml_result_syntax_test ( test : & Test ) -> Result < ( ) > {
if result_syntax_check ( test , QueryResultsFormat ::Xml ) . is_ok ( ) { if result_syntax_check ( test , QueryResultsFormat ::Xml ) . is_ok ( ) {
Err ( anyhow ! ( "Oxigraph parses even if it should not {}." , test ) ) bail ! ( "Oxigraph parses even if it should not {test }." )
} else { } else {
Ok ( ( ) ) Ok ( ( ) )
} }
@ -129,7 +120,7 @@ fn evaluate_negative_xml_result_syntax_test(test: &Test) -> Result<()> {
fn evaluate_negative_tsv_result_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_negative_tsv_result_syntax_test ( test : & Test ) -> Result < ( ) > {
if result_syntax_check ( test , QueryResultsFormat ::Tsv ) . is_ok ( ) { if result_syntax_check ( test , QueryResultsFormat ::Tsv ) . is_ok ( ) {
Err ( anyhow ! ( "Oxigraph parses even if it should not {}." , test ) ) bail ! ( "Oxigraph parses even if it should not {test }." )
} else { } else {
Ok ( ( ) ) Ok ( ( ) )
} }
@ -139,7 +130,7 @@ fn result_syntax_check(test: &Test, format: QueryResultsFormat) -> Result<()> {
let results_file = test let results_file = test
. action . action
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test }" ) ) ? ;
match QueryResults ::read ( Cursor ::new ( read_file_to_string ( results_file ) ? ) , format ) ? { match QueryResults ::read ( Cursor ::new ( read_file_to_string ( results_file ) ? ) , format ) ? {
QueryResults ::Solutions ( solutions ) = > { QueryResults ::Solutions ( solutions ) = > {
for s in solutions { for s in solutions {
@ -167,125 +158,83 @@ fn evaluate_evaluation_test(test: &Test) -> Result<()> {
let query_file = test let query_file = test
. query . query
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test }" ) ) ? ;
let options = QueryOptions ::default ( ) let options = QueryOptions ::default ( )
. with_service_handler ( StaticServiceHandler ::new ( & test . service_data ) ? ) ; . with_service_handler ( StaticServiceHandler ::new ( & test . service_data ) ? ) ;
match Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) { let query = Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) )
Err ( error ) = > Err ( anyhow ! ( . map_err ( | e | anyhow ! ( "Failure to parse query of {test} with error: {e}" ) ) ? ;
"Failure to parse query of {} with error: {}" ,
test , // We check parsing roundtrip
error Query ::parse ( & query . to_string ( ) , None )
) ) , . map_err ( | e | anyhow ! ( "Failure to deserialize \"{query}\" of {test} with error: {e}" ) ) ? ;
Ok ( query ) = > {
// We check parsing roundtrip
// FROM and FROM NAMED support. We make sure the data is in the store
if let Err ( error ) = Query ::parse ( & query . to_string ( ) , None ) { if ! query . dataset ( ) . is_default_dataset ( ) {
return Err ( anyhow ! ( for graph_name in query . dataset ( ) . default_graph_graphs ( ) . unwrap_or ( & [ ] ) {
"Failure to deserialize \"{}\" of {} with error: {}" , if let GraphName ::NamedNode ( graph_name ) = graph_name {
query . to_string ( ) , load_to_store ( graph_name . as_str ( ) , & store , graph_name . as_ref ( ) ) ? ;
test , } else {
error bail ! ( "Invalid FROM in query {query} for test {test}" ) ;
) ) ;
} }
}
// FROM and FROM NAMED support. We make sure the data is in the store
for graph_name in query . dataset ( ) . available_named_graphs ( ) . unwrap_or ( & [ ] ) {
if ! query . dataset ( ) . is_default_dataset ( ) { if let NamedOrBlankNode ::NamedNode ( graph_name ) = graph_name {
for graph_name in query . dataset ( ) . default_graph_graphs ( ) . unwrap_or ( & [ ] ) { load_to_store ( graph_name . as_str ( ) , & store , graph_name . as_ref ( ) ) ? ;
if let GraphName ::NamedNode ( graph_name ) = graph_name { } else {
load_to_store ( graph_name . as_str ( ) , & store , graph_name . as_ref ( ) ) ? ; bail ! ( "Invalid FROM NAMED in query {query} for test {test}" ) ;
} else {
return Err ( anyhow ! ( "Invalid FROM in query {} for test {}" , query , test ) ) ;
}
}
for graph_name in query . dataset ( ) . available_named_graphs ( ) . unwrap_or ( & [ ] ) {
if let NamedOrBlankNode ::NamedNode ( graph_name ) = graph_name {
load_to_store ( graph_name . as_str ( ) , & store , graph_name . as_ref ( ) ) ? ;
} else {
return Err ( anyhow ! (
"Invalid FROM NAMED in query {} for test {}" ,
query ,
test
) ) ;
}
}
} }
}
}
for with_query_optimizer in [ true , false ] { let expected_results = load_sparql_query_result ( test . result . as_ref ( ) . unwrap ( ) )
let mut options = options . clone ( ) ; . map_err ( | e | anyhow ! ( "Error constructing expected graph for {test}: {e}" ) ) ? ;
if ! with_query_optimizer { let with_order = if let StaticQueryResults ::Solutions { ordered , .. } = & expected_results {
options = options . without_optimizations ( ) ; * ordered
} } else {
match store . query_opt ( query . clone ( ) , options ) { false
Err ( error ) = > { } ;
return Err ( anyhow ! (
"Failure to execute query of {} with error: {}" , for with_query_optimizer in [ true , false ] {
test , let mut options = options . clone ( ) ;
error if ! with_query_optimizer {
) ) options = options . without_optimizations ( ) ;
} }
Ok ( actual_results ) = > { let actual_results = store
let expected_results = load_sparql_query_result ( . query_opt ( query . clone ( ) , options )
test . result . as_ref ( ) . unwrap ( ) , . map_err ( | e | anyhow ! ( "Failure to execute query of {test} with error: {e}" ) ) ? ;
) let actual_results = StaticQueryResults ::from_query_results ( actual_results , with_order ) ? ;
. map_err ( | e | {
anyhow ! ( "Error constructing expected graph for {}: {}" , test , e ) if ! are_query_results_isomorphic ( & expected_results , & actual_results ) {
} ) ? ; bail ! (
let with_order = if let StaticQueryResults ::Solutions { ordered , .. } = "Failure on {test}.\nExpected file:\n{expected_results}\nOutput file:\n{actual_results}\nParsed query:\n{}\nData:\n{store}\n" ,
& expected_results Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) . unwrap ( )
{ ) ;
* ordered
} else {
false
} ;
let actual_results =
StaticQueryResults ::from_query_results ( actual_results , with_order ) ? ;
if ! are_query_results_isomorphic ( & expected_results , & actual_results ) {
return Err ( anyhow ! ( "Failure on {}.\nExpected file:\n{}\nOutput file:\n{}\nParsed query:\n{}\nData:\n{}\n" ,
test ,
expected_results ,
actual_results ,
Query ::parse ( & read_file_to_string ( query_file ) ? , Some ( query_file ) ) . unwrap ( ) ,
store
) ) ;
}
}
}
}
Ok ( ( ) )
} }
} }
Ok ( ( ) )
} }
fn evaluate_positive_update_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_positive_update_syntax_test ( test : & Test ) -> Result < ( ) > {
let update_file = test let update_file = test
. action . action
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test}" ) ) ? ;
match Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) ) { let update = Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) )
Err ( error ) = > Err ( anyhow ! ( "Not able to parse {} with error: {}" , test , error ) ) , . map_err ( | e | anyhow ! ( "Not able to parse {test} with error: {e}" ) ) ? ;
Ok ( update ) = > match Update ::parse ( & update . to_string ( ) , None ) { Update ::parse ( & update . to_string ( ) , None )
Ok ( _ ) = > Ok ( ( ) ) , . map_err ( | e | anyhow ! ( "Failure to deserialize \"{update}\" of {test} with error: {e}" ) ) ? ;
Err ( error ) = > Err ( anyhow ! ( Ok ( ( ) )
"Failure to deserialize \"{}\" of {} with error: {}" ,
update . to_string ( ) ,
test ,
error
) ) ,
} ,
}
} }
fn evaluate_negative_update_syntax_test ( test : & Test ) -> Result < ( ) > { fn evaluate_negative_update_syntax_test ( test : & Test ) -> Result < ( ) > {
let update_file = test let update_file = test
. action . action
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test}" ) ) ? ;
match Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) ) { match Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) ) {
Ok ( result ) = > Err ( anyhow ! ( Ok ( result ) = > {
"Oxigraph parses even if it should not {}. The output tree is: {}" , bail ! ( "Oxigraph parses even if it should not {test}. The output tree is: {result}" )
test , }
result
) ) ,
Err ( _ ) = > Ok ( ( ) ) , Err ( _ ) = > Ok ( ( ) ) ,
} }
} }
@ -310,50 +259,29 @@ fn evaluate_update_evaluation_test(test: &Test) -> Result<()> {
let update_file = test let update_file = test
. update . update
. as_deref ( ) . as_deref ( )
. ok_or_else ( | | anyhow ! ( "No action found for test {}" , test ) ) ? ; . ok_or_else ( | | anyhow ! ( "No action found for test {test}" ) ) ? ;
match Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) ) { let update = Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) )
Err ( error ) = > Err ( anyhow ! ( . map_err ( | e | anyhow ! ( "Failure to parse update of {test} with error: {e}" ) ) ? ;
"Failure to parse update of {} with error: {}" ,
test , // We check parsing roundtrip
error Update ::parse ( & update . to_string ( ) , None )
) ) , . map_err ( | e | anyhow ! ( "Failure to deserialize \"{update}\" of {test} with error: {e}" ) ) ? ;
Ok ( update ) = > {
// We check parsing roundtrip
store
if let Err ( error ) = Update ::parse ( & update . to_string ( ) , None ) { . update ( update )
return Err ( anyhow ! ( . map_err ( | e | anyhow ! ( "Failure to execute update of {test} with error: {e}" ) ) ? ;
"Failure to deserialize \"{}\" of {} with error: {}" , let mut store_dataset : Dataset = store . iter ( ) . collect ::< Result < _ , _ > > ( ) ? ;
update . to_string ( ) , store_dataset . canonicalize ( ) ;
test , let mut result_store_dataset : Dataset = result_store . iter ( ) . collect ::< Result < _ , _ > > ( ) ? ;
error result_store_dataset . canonicalize ( ) ;
) ) ; if store_dataset = = result_store_dataset {
} Ok ( ( ) )
} else {
match store . update ( update ) { bail ! (
Err ( error ) = > Err ( anyhow ! ( "Failure on {test}.\nDiff:\n{}\nParsed update:\n{}\n" ,
"Failure to execute update of {} with error: {}" , dataset_diff ( & result_store_dataset , & store_dataset ) ,
test , Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) ) . unwrap ( ) ,
error )
) ) ,
Ok ( ( ) ) = > {
let mut store_dataset : Dataset = store . iter ( ) . collect ::< Result < _ , _ > > ( ) ? ;
store_dataset . canonicalize ( ) ;
let mut result_store_dataset : Dataset =
result_store . iter ( ) . collect ::< Result < _ , _ > > ( ) ? ;
result_store_dataset . canonicalize ( ) ;
if store_dataset = = result_store_dataset {
Ok ( ( ) )
} else {
Err ( anyhow ! (
"Failure on {}.\nDiff:\n{}\nParsed update:\n{}\n" ,
test ,
dataset_diff ( & result_store_dataset , & store_dataset ) ,
Update ::parse ( & read_file_to_string ( update_file ) ? , Some ( update_file ) )
. unwrap ( ) ,
) )
}
}
}
}
} }
} }
@ -624,7 +552,7 @@ impl StaticQueryResults {
if let TermRef ::Literal ( l ) = object { if let TermRef ::Literal ( l ) = object {
Ok ( Variable ::new_unchecked ( l . value ( ) ) ) Ok ( Variable ::new_unchecked ( l . value ( ) ) )
} else { } else {
Err ( anyhow ! ( "Invalid rs:resultVariable: {}" , object ) ) bail ! ( "Invalid rs:resultVariable: {object}" )
} }
} ) } )
. collect ::< Result < Vec < _ > > > ( ) ? ; . collect ::< Result < Vec < _ > > > ( ) ? ;
@ -650,10 +578,10 @@ impl StaticQueryResults {
value . into_owned ( ) , value . into_owned ( ) ,
) ) ) )
} else { } else {
Err ( anyhow ! ( "Invalid rs:binding: {}" , binding ) ) bail ! ( "Invalid rs:binding: {binding}" )
} }
} else { } else {
Err ( anyhow ! ( "Invalid rs:binding: {}" , object ) ) bail ! ( "Invalid rs:binding: {object}" )
} }
} ) } )
. collect ::< Result < Vec < _ > > > ( ) ? ; . collect ::< Result < Vec < _ > > > ( ) ? ;
@ -664,13 +592,13 @@ impl StaticQueryResults {
if let TermRef ::Literal ( l ) = object { if let TermRef ::Literal ( l ) = object {
Ok ( u64 ::from_str ( l . value ( ) ) ? ) Ok ( u64 ::from_str ( l . value ( ) ) ? )
} else { } else {
Err ( anyhow ! ( "Invalid rs:index: {}" , object ) ) bail ! ( "Invalid rs:index: {object}" )
} }
} ) } )
. transpose ( ) ? ; . transpose ( ) ? ;
Ok ( ( bindings , index ) ) Ok ( ( bindings , index ) )
} else { } else {
Err ( anyhow ! ( "Invalid rs:solution: {}" , object ) ) bail ! ( "Invalid rs:solution: {object}" )
} }
} ) } )
. collect ::< Result < Vec < _ > > > ( ) ? ; . collect ::< Result < Vec < _ > > > ( ) ? ;
Tpt
2 years ago
committed by