pho 0.4.1 → 0.5

data/tests/tc_rdf_collection.rb

@@ -3,6 +3,8 @@ require 'pho'
 require 'test/unit'
 require 'mocha'
 
+#TODO factor out tests for AbstractFileManager
+#TODO alter so we're testing the non-deprecated version of the Class
 class RDFCollectionTest < Test::Unit::TestCase
 
   def setup()
@@ -56,6 +58,7 @@ class RDFCollectionTest < Test::Unit::TestCase
 
     success = collection.successes()
     success.sort!
+
     assert_equal(4, success.size)
     assert_equal("/tmp/0.rdf", success[0])    
     assert_equal("/tmp/1.rdf", success[1])

data/tests/{tc_rdf_json.rb → tc_resource_hash.rb}

@@ -5,7 +5,7 @@ require 'mocha'
 require 'rexml/document'
 require 'uri'
 
-class RDFJSONTest < Test::Unit::TestCase
+class ResourceHashTest < Test::Unit::TestCase
   SINGLE_TRIPLE_RESOURCE = <<-EOL
   {
     "http://www.example.org" : {
@@ -99,7 +99,7 @@ class RDFJSONTest < Test::Unit::TestCase
             
   def test_minus_with_iso_graphs()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
     assert_not_nil(difference)        
     assert_equal(0, difference.keys.length)
                 
@@ -107,7 +107,7 @@ class RDFJSONTest < Test::Unit::TestCase
     
   def test_minus_with_single_resource_value_change()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE2) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(SINGLE_TRIPLE_RESOURCE2) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "http://www.example.org/page",
@@ -115,7 +115,7 @@ class RDFJSONTest < Test::Unit::TestCase
 
     #reverse
           
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE2), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE2), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "http://www.example.org/other-page",
@@ -125,14 +125,14 @@ class RDFJSONTest < Test::Unit::TestCase
 
   def test_minus_with_single_literal_value_change()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL2) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL2) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "Title",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
 
     #reverse          
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL2), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL2), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "Other Title",
@@ -142,14 +142,14 @@ class RDFJSONTest < Test::Unit::TestCase
   
   def test_minus_with_different_typed_predicate_values()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_DIFF_TYPE) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_DIFF_TYPE) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "Title",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
 
     #reverse
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_DIFF_TYPE), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_DIFF_TYPE), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "http://www.example.com",
@@ -159,12 +159,12 @@ class RDFJSONTest < Test::Unit::TestCase
 
   def test_minus_with_different_size_graphs()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(TWO_TRIPLES) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_RESOURCE), JSON.parse(TWO_TRIPLES) )
     assert_not_nil(difference)    
     assert_equal(0, difference.keys.length)    
 
     #reverse
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(TWO_TRIPLES), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(TWO_TRIPLES), JSON.parse(SINGLE_TRIPLE_RESOURCE) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "Title",
@@ -174,12 +174,12 @@ class RDFJSONTest < Test::Unit::TestCase
 
   def test_minus_with_repeated_properties()
   
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(REPEATED_TRIPLES) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(REPEATED_TRIPLES) )
     assert_not_nil(difference)    
     assert_equal(0, difference.keys.length)    
 
     #reverse
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(REPEATED_TRIPLES), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(REPEATED_TRIPLES), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)    
     assert_equal( "Other Title",
@@ -189,22 +189,22 @@ class RDFJSONTest < Test::Unit::TestCase
   
   def test_minus_with_language_qualified_literals()
     
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(0, difference.keys.length)    
 
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
     assert_not_nil(difference)    
     assert_equal(0, difference.keys.length)
     
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "Title",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
 
     #reverse no lang and english
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "English",
@@ -212,7 +212,7 @@ class RDFJSONTest < Test::Unit::TestCase
     assert_equal( "en",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["lang"] )
 
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH), JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "English",
@@ -221,7 +221,7 @@ class RDFJSONTest < Test::Unit::TestCase
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["lang"] )
 
     #reverse no lang and english
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL_FRENCH), JSON.parse(SINGLE_TRIPLE_LITERAL_ENGLISH) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "French",
@@ -233,18 +233,18 @@ class RDFJSONTest < Test::Unit::TestCase
 
   def test_minus_with_typed_literals()
     
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
     assert_not_nil(difference)    
     assert_equal(0, difference.keys.length)
     
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TRIPLE_LITERAL), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "Title",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["value"] )
 
     #reverse no type and int
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TRIPLE_LITERAL) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TRIPLE_LITERAL) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "1",
@@ -252,7 +252,7 @@ class RDFJSONTest < Test::Unit::TestCase
     assert_equal( "http://www.w3.org/2001/XMLSchema#int",
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["datatype"] )
 
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_INT), JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "1",
@@ -261,7 +261,7 @@ class RDFJSONTest < Test::Unit::TestCase
       difference["http://www.example.org"]["http://www.example.org/ns/literal"][0]["datatype"] )
       
     #reverse float and int
-    difference = Pho::RDF_JSON::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
+    difference = Pho::ResourceHash::SetAlgebra.minus( JSON.parse(SINGLE_TYPED_TRIPLE_FLOAT), JSON.parse(SINGLE_TYPED_TRIPLE_INT) )
     assert_not_nil(difference)    
     assert_equal(1, difference.keys.length)
     assert_equal( "2.5",

data/tests/tc_search.rb

@@ -45,7 +45,7 @@ class SearchTest < Test::Unit::TestCase
   def test_augment
      mc = mock()
      mc.expects(:set_auth)
-    mc.expects(:post).with("http://api.talis.com/stores/testing/services/augment", "data", nil)
+     mc.expects(:post).with("http://api.talis.com/stores/testing/services/augment", "data", anything)
      
     store = Pho::Store.new("http://api.talis.com/stores/testing", "user", "pass", mc)
     response = store.augment("data")    

data/tests/tc_sparql.rb

@@ -5,7 +5,7 @@ require 'mocha'
 
 class SparqlTest < Test::Unit::TestCase
   
-  def test_simple_sparql
+  def test_simple_store_sparql
   
     mc = mock()
     mc.expects(:set_auth)
@@ -29,7 +29,7 @@ class SparqlTest < Test::Unit::TestCase
     assert_equal("RESULTS", response.content)      
   end
     
-  def test_sparql_with_mimetype
+  def test_store_sparql_with_mimetype
   
     mc = mock()
     mc.expects(:set_auth)
@@ -41,7 +41,7 @@ class SparqlTest < Test::Unit::TestCase
     assert_equal("RESULTS", response.content)      
   end    
   
-  def test_sparql_ask
+  def test_store_sparql_ask
     mc = mock()
     mc.expects(:set_auth)
     mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"} ).returns(
@@ -52,7 +52,7 @@ class SparqlTest < Test::Unit::TestCase
     assert_equal("RESULTS", response.content)          
   end
   
-  def test_sparql_select
+  def test_store_sparql_select
     mc = mock()
     mc.expects(:set_auth)
     mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"} ).returns(
@@ -63,7 +63,7 @@ class SparqlTest < Test::Unit::TestCase
     assert_equal("RESULTS", response.content)          
   end  
   
-  def test_sparql_construct
+  def test_store_sparql_construct
     mc = mock()
     mc.expects(:set_auth)
     mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
@@ -74,7 +74,7 @@ class SparqlTest < Test::Unit::TestCase
     assert_equal("RESULTS", response.content)          
   end  
 
-  def test_sparql_describe
+  def test_store_sparql_describe
     mc = mock()
     mc.expects(:set_auth)
     mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
@@ -84,5 +84,130 @@ class SparqlTest < Test::Unit::TestCase
     response = store.sparql_describe("SPARQL")
     assert_equal("RESULTS", response.content)          
   end
+  
+  def test_get_store_sparql_client
+    store = Pho::Store.new("http://api.talis.com/stores/testing/", "user", "pass")
+    sparql_client = store.sparql_client()
+    assert_equal( true,  sparql_client.supports_rdf_json )    
+    assert_equal( true, sparql_client.supports_sparql_json )
+  end
+  
+  def test_simple_query
+    
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.query("SPARQL")
+        
+  end
+
+  def test_query_with_default_graph
+
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "default-graph-uri" => ["http://www.example.com"]}, {})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.add_default_graph("http://www.example.com")
+    sparql_client.query("SPARQL")
+        
+  end
+
+  def test_query_with_named_graph
+
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "named-graph-uri" => ["http://www.example.com"]}, {})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.add_named_graph("http://www.example.com")
+    sparql_client.query("SPARQL")
+        
+  end
+  
+  def test_query_with_both_graphs
+
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "named-graph-uri" => ["http://www.example.com"], "default-graph-uri" => ["http://www.example.org"]}, {})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.add_named_graph("http://www.example.com")
+    sparql_client.add_default_graph("http://www.example.org")
+    sparql_client.query("SPARQL")
+        
+  end
+            
+  def test_sparql_with_mimetype
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.query("SPARQL", "application/sparql-results+xml")
+     
+  end
+
+  def test_sparql_with_output_parameter
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "output" => "json"}, {})
+    
+    sparql_client = Pho::Sparql::SparqlClient.new("http://www.example.org/sparql", mc)
+    sparql_client.output_parameter_name="output"
+    sparql_client.query("SPARQL", "json")
+     
+  end
+      
+  def test_ask
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    
+    client = Pho::Sparql::SparqlClient.new("http://api.talis.com/stores/testing/services/sparql", mc)
+    response = client.ask("SPARQL")
+    assert_equal("RESULTS", response.content)          
+  end
+  
+  def test_store_sparql_select
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    
+    client = Pho::Sparql::SparqlClient.new("http://api.talis.com/stores/testing/services/sparql", mc)
+    response = client.select("SPARQL")
+    assert_equal("RESULTS", response.content)          
+  end  
+  
+  def test_construct
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    
+    client = Pho::Sparql::SparqlClient.new("http://api.talis.com/stores/testing/services/sparql", mc)
+    response = client.construct("SPARQL")
+    assert_equal("RESULTS", response.content)          
+  end  
+
+  def test_describe
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    
+    client = Pho::Sparql::SparqlClient.new("http://api.talis.com/stores/testing/services/sparql", mc)
+    response = client.describe("SPARQL")
+    assert_equal("RESULTS", response.content)          
+  end
+  
+  def test_multi_describe
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "DESCRIBE <http://www.example.org> <http://www.example.com>"}, 
+        {"Accept" => "application/rdf+xml"} ).returns( HTTP::Message.new_response("RESULTS"))
+
+    client = Pho::Sparql::SparqlClient.new("http://api.talis.com/stores/testing/services/sparql", mc)
+    uris = []
+    uris << "http://www.example.org"
+    uris << "http://www.example.com"
+    response = client.multi_describe(uris)
+    assert_equal("RESULTS", response.content)
+                            
+  end
       
 end

data/tests/tc_sparql_helper.rb

@@ -0,0 +1,214 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'pho'
+require 'test/unit'
+require 'mocha'
+
+class SparqlHelperTest < Test::Unit::TestCase
+  
+  SELECT_QUERY = <<-EOL
+  SELECT ?name WHERE { ?s rdfs:label ?name. }
+  EOL
+
+  ASK_QUERY = <<-EOL
+  ASK WHERE { ?s rdfs:label "Something". }
+  EOL
+      
+  DESCRIBE_QUERY = <<-EOL
+  DESCRIBE <http://www.example.org>
+  EOL
+  
+  CONSTRUCT_QUERY = <<-EOL
+  CONSTRUCT { ?s ?p ?o. } WHERE { ?s ?p ?o. } 
+  EOL
+  
+  RESULTS = <<-EOL
+  {  
+   "head": {  "vars": [ "name" ]  } ,  
+    
+   "results": {    
+        "bindings": [     
+            {  "name": { "type": "literal" , "value": "Apollo 11 Command and Service Module (CSM)" }
+            } ,     
+           {   "name": { "type": "literal" , "value": "Apollo 11 SIVB" }
+           } ,      
+           {   "name": { "type": "literal" , "value": "Apollo 11 Lunar Module / EASEP" }
+           }    
+        ]  
+    }
+  }  
+  EOL
+  
+  ASK_RESULTS = <<-EOL
+  {    
+    "head": {},
+    "boolean": "true"
+  }
+  EOL
+
+  RDF_JSON_RESULTS = <<-EOL
+  {
+    "http://www.example.org" : {
+      "http://www.example.org/ns/resource" : [ { "value" : "http://www.example.org/page", "type" : "uri" } ]
+    }
+  }
+  EOL
+      
+  RDF_JSON = <<-EOL
+  {  
+   "head": {  "vars": [ "name" ]  } ,  
+    
+   "results": {    
+        "bindings": [     
+            {  "name": { "type": "literal" , "value": "Apollo 11 Command and Service Module (CSM)" },
+               "uri": { "type": "uri" , "value": "http://nasa.dataincubator.org/spacecraft/12345" },
+               "mass": { "type": "literal" , "value": "5000.5", "datatype" : "http://www.w3.org/2001/XMLSchema#float" }
+            } ,     
+           {   "name": { "type": "literal" , "value": "Apollo 11 SIVB" },
+               "uri": { "type": "uri" , "value": "http://nasa.dataincubator.org/spacecraft/12345" }
+           }    
+        ]  
+    }
+  }  
+  EOL
+    
+  def test_apply_initial_bindings
+      query = "SELECT ?p ?o WHERE { ?s ?p ?o }"
+      values = { "s" => "<http://www.example.org>" }
+        
+      bound = Pho::Sparql::SparqlHelper.apply_initial_bindings(query, values)
+      assert_not_nil(bound)
+      assert_equal( "SELECT ?p ?o WHERE { <http://www.example.org> ?p ?o }", bound )   
+  end
+
+  def test_apply_initial_bindings_with_dollars
+      query = "SELECT $p $o WHERE { $s $p $o }"
+      values = { "s" => "<http://www.example.org>" }
+        
+      bound = Pho::Sparql::SparqlHelper.apply_initial_bindings(query, values)
+      assert_not_nil(bound)
+      assert_equal( "SELECT $p $o WHERE { <http://www.example.org> $p $o }", bound )   
+  end
+  
+  def test_apply_initial_bindings_with_literal
+      query = "SELECT ?s WHERE { ?s ?p ?o }"
+      values = { "o" => "'some value'" }
+        
+      bound = Pho::Sparql::SparqlHelper.apply_initial_bindings(query, values)
+      assert_not_nil(bound)
+      assert_equal( "SELECT ?s WHERE { ?s ?p 'some value' }", bound )   
+  end   
+
+  def test_select
+      mc = mock()
+      mc.expects(:select).with(SELECT_QUERY, Pho::Sparql::SPARQL_RESULTS_JSON).returns(
+        HTTP::Message.new_response(RESULTS) )
+      json = Pho::Sparql::SparqlHelper.select(SELECT_QUERY, mc)
+      assert_not_nil(json)
+      assert_equal("name", json["head"]["vars"][0])       
+  end
+
+  def test_failed_select
+      mc = mock()
+      resp = HTTP::Message.new_response("Error")
+      resp.status = 500
+      mc.expects(:select).with(SELECT_QUERY, Pho::Sparql::SPARQL_RESULTS_JSON).returns( resp )
+      assert_raises RuntimeError do
+        json = Pho::Sparql::SparqlHelper.select(SELECT_QUERY, mc)
+      end
+  end
+  
+  def test_ask
+      mc = mock()
+      mc.expects(:select).with(ASK_QUERY, Pho::Sparql::SPARQL_RESULTS_JSON).returns(
+        HTTP::Message.new_response(ASK_RESULTS) )
+      assert_equal( true,  Pho::Sparql::SparqlHelper.ask(ASK_QUERY, mc) )       
+  end
+
+  def test_select_values
+      mc = mock()
+      mc.expects(:select).with(SELECT_QUERY, Pho::Sparql::SPARQL_RESULTS_JSON).returns(
+        HTTP::Message.new_response(RESULTS) )
+      results = Pho::Sparql::SparqlHelper.select_values(SELECT_QUERY, mc)
+      assert_not_nil( results )
+      assert_equal( 3, results.length )
+  end        
+
+  def test_select_single_value
+      mc = mock()
+      mc.expects(:select).with(SELECT_QUERY, Pho::Sparql::SPARQL_RESULTS_JSON).returns(
+        HTTP::Message.new_response(RESULTS) )
+      result = Pho::Sparql::SparqlHelper.select_single_value(SELECT_QUERY, mc)
+      assert_equal( "Apollo 11 Command and Service Module (CSM)", result  )
+  end        
+
+  def test_describe_to_resource_hash
+      mc = mock()
+      mc.expects(:describe).with(DESCRIBE_QUERY, "application/json").returns( HTTP::Message.new_response(RDF_JSON_RESULTS) )
+      result = Pho::Sparql::SparqlHelper.describe_to_resource_hash(DESCRIBE_QUERY, mc)
+      assert_not_nil(result)
+      assert_not_nil(result["http://www.example.org"])         
+  end
+
+  def test_failed_describe
+      mc = mock()
+      resp = HTTP::Message.new_response("Error")
+      resp.status = 500
+      mc.expects(:describe).with(DESCRIBE_QUERY, "application/json").returns( resp )
+      assert_raises RuntimeError do
+        Pho::Sparql::SparqlHelper.describe_to_resource_hash(DESCRIBE_QUERY, mc)
+      end
+  end
+      
+  def test_construct_to_resource_hash
+      mc = mock()
+      mc.expects(:construct).with(CONSTRUCT_QUERY, "application/json").returns( HTTP::Message.new_response(RDF_JSON_RESULTS) )
+      result = Pho::Sparql::SparqlHelper.construct_to_resource_hash(CONSTRUCT_QUERY, mc)
+      assert_not_nil(result)
+      assert_not_nil(result["http://www.example.org"])         
+  end  
+  
+  def test_failed_construct
+      mc = mock()
+      resp = HTTP::Message.new_response("Error")
+      resp.status = 500
+      mc.expects(:construct).with(CONSTRUCT_QUERY, "application/json").returns( resp )
+      assert_raises RuntimeError do
+        Pho::Sparql::SparqlHelper.construct_to_resource_hash(CONSTRUCT_QUERY, mc)
+      end
+  end
+  
+  def test_multi_describe
+      uris = []
+      uris << "http://www.example.org"
+      uris << "http://www.example.com"         
+      mc = mock()
+      mc.expects(:multi_describe).with(uris, "application/json").returns( 
+        HTTP::Message.new_response(RDF_JSON_RESULTS) )
+        
+      result = Pho::Sparql::SparqlHelper.multi_describe(uris, mc)
+      assert_not_nil(result)
+      assert_not_nil(result["http://www.example.org"])         
+  end
+     
+  def test_binding_to_hash
+      json = JSON.parse(RDF_JSON)
+      binding = json["results"]["bindings"][0]
+      
+      hash = Pho::Sparql::SparqlHelper.result_to_query_binding(binding)
+      assert_equal(3, hash.size)
+      assert_equal("\"Apollo 11 Command and Service Module (CSM)\"", hash["name"])
+      assert_equal("<http://nasa.dataincubator.org/spacecraft/12345>", hash["uri"])
+      assert_equal("\"5000.5\"^^http://www.w3.org/2001/XMLSchema#float", hash["mass"])        
+  end
+  
+  def test_results_to_bindings
+      json = JSON.parse(RDF_JSON)           
+      bindings = Pho::Sparql::SparqlHelper.results_to_query_bindings(json)
+      assert_equal(2, bindings.size)
+      hash = bindings[0]
+      assert_equal("\"Apollo 11 Command and Service Module (CSM)\"", hash["name"])
+      assert_equal("<http://nasa.dataincubator.org/spacecraft/12345>", hash["uri"])
+      assert_equal("\"5000.5\"^^http://www.w3.org/2001/XMLSchema#float", hash["mass"])        
+  end    
+  
+end