kasabi 0.0.1 → 0.1.1

data/tests/api/tc_status.rb

@@ -0,0 +1,82 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+
+class StatusTest < Test::Unit::TestCase
+  
+  STATUS = <<-EOL 
+{
+  "status": "published",
+  "storageMode": "read-write"
+}
+EOL
+
+  STATUS_READ_ONLY = <<-EOL 
+{
+  "status": "draft",
+  "storageMode": "read-only"
+}
+EOL
+
+  def test_get
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/status", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( STATUS ))
+      
+    client = Kasabi::Status.new("http://api.kasabi.com/api/test-data/status", 
+      :apikey=>"test-key", :client=>mc)
+      
+    status = client.get_status
+    assert_not_nil(status)
+    assert_equal("published", status["status"])
+    assert_equal("read-write", status["storageMode"])
+    
+  end
+  
+  def test_writeable
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/status", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( STATUS ))
+      
+    client = Kasabi::Status.new("http://api.kasabi.com/api/test-data/status", 
+      :apikey=>"test-key", :client=>mc)
+      
+    assert_equal(true, client.writeable?)  
+    
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/status", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( STATUS_READ_ONLY ))
+      
+    client = Kasabi::Status.new("http://api.kasabi.com/api/test-data/status", 
+      :apikey=>"test-key", :client=>mc)
+
+    assert_equal(false, client.writeable?)            
+  end
+  
+  def test_published
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/status", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( STATUS ))
+      
+    client = Kasabi::Status.new("http://api.kasabi.com/api/test-data/status", 
+      :apikey=>"test-key", :client=>mc)
+      
+    assert_equal(true, client.published?)  
+    
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/status", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( STATUS_READ_ONLY ))
+      
+    client = Kasabi::Status.new("http://api.kasabi.com/api/test-data/status", 
+      :apikey=>"test-key", :client=>mc)
+
+    assert_equal(false, client.published?)            
+    
+  end
+end

data/tests/api/tc_store.rb

@@ -0,0 +1,75 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+
+class StoreTest < Test::Unit::TestCase
+  
+  def test_store_data
+     resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/changes/1")
+     resp.status = 202
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/store", 
+       "data", {"Content-Type" => "application/rdf+xml", "X_KASABI_APIKEY" => "test"} ).returns( resp )
+     dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+     id = dataset.store_data("data")
+     assert_equal("http://api.kasabi.com/dataset/test-data/changes/1", id)
+  end
+
+  def test_store_data_as_turtle
+     resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/changes/1")
+     resp.status = 202    
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/store", 
+       "data", {"Content-Type" => "text/turtle", "X_KASABI_APIKEY" => "test"} ).returns( resp )
+     dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+     id = dataset.store_data("data", "text/turtle")
+     assert_equal("http://api.kasabi.com/dataset/test-data/changes/1", id)
+  end
+
+  def test_apply_changeset
+     resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/changes/1")
+     resp.status = 202
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/store", 
+       "data", {"Content-Type" => "application/vnd.talis.changeset+xml", "X_KASABI_APIKEY" => "test"} ).returns( resp )
+     dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+     id = dataset.apply_changeset("data")
+     assert_equal("http://api.kasabi.com/dataset/test-data/changes/1", id)
+  end
+    
+  def test_store_file
+     resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/changes/1")
+     resp.status = 202
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/store", 
+       "data", {"Content-Type" => "application/rdf+xml", "X_KASABI_APIKEY" => "test"} ).returns( resp )
+     io = StringIO.new("data")
+         
+     dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+     id = dataset.store_file(io)
+     assert_equal("http://api.kasabi.com/dataset/test-data/changes/1", id)
+     assert_equal(true, io.closed?)
+  end  
+
+  def test_store_uri
+     resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/changes/1")
+     resp.status = 202
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/store", 
+       {"data_uri" => "http://www.example.org"}, {"Content-Type" => "application/rdf+xml", "X_KASABI_APIKEY" => "test"} ).returns( resp )
+     dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+     id = dataset.store_uri("http://www.example.org")
+     assert_equal("http://api.kasabi.com/dataset/test-data/changes/1", id)
+  end
+  
+  def test_applied?
+    resp = HTTP::Message.new_response("{ \"status\": \"applied\" }")
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/dataset/test-data/changes/1", nil, 
+      {"Content-Type" => "application/json", "X_KASABI_APIKEY" => "test"}).returns(resp)
+    dataset = Kasabi::Storage::Client.new("http://api.kasabi.com/dataset/test-data/store", { :apikey => "test", :client => mc })
+    assert_equal(true, dataset.applied?("http://api.kasabi.com/dataset/test-data/changes/1"))
+  end  
+    
+end

data/tests/data/dataset.json

@@ -0,0 +1,65 @@
+{
+  "http://data.kasabi.com/dataset/test-data": {
+    "http://rdfs.org/ns/void#exampleResource": [
+      {
+        "value": "http://api.kasabi.com/dataset/test-data/person/1",
+        "type": "uri"
+      }
+    ],
+    "http://purl.org/dc/terms/title": [
+      {
+        "value": "Test Data",
+        "type": "literal"
+      }
+    ],
+    "http://purl.org/dc/terms/description": [
+      {
+        "value": "The Test Data dataset",
+        "type": "literal"
+      }
+    ],
+    "http://rdfs.org/ns/void#sparqlEndpoint": [
+      {
+        "value": "http://api.kasabi.com/api/test-sparql",
+        "type": "uri"
+      }
+    ],
+    "http://rdfs.org/ns/void#uriLookupEndpoint": [
+      {
+        "value": "http://api.kasabi.com/api/test-lookup",
+        "type": "uri"
+      }
+    ],
+    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type": [
+      {
+        "value": "http://rdfs.org/ns/void#Dataset",
+        "type": "uri"
+      }
+    ],
+    "http://xmlns.com/foaf/0.1/homepage": [
+      {
+        "value": "http://ldodds.kasabi.com/dataset/test-data",
+        "type": "uri"
+      }
+    ],
+    "http://labs.kasabi.com/ns/services#searchEndpoint": [
+      {
+        "value": "http://api.kasabi.com/api/test-search",
+        "type": "uri"
+      }
+    ],
+    "http://labs.kasabi.com/ns/services#reconciliationEndpoint": [
+      {
+        "value": "http://api.kasabi.com/api/test-recon",
+        "type": "uri"
+      }
+    ],
+    "http://labs.kasabi.com/ns/services#augmentationEndpoint": [
+      {
+        "value": "http://api.kasabi.com/api/test-augment",
+        "type": "uri"
+      }
+    ]    
+    
+  }
+}

data/tests/data/tc_dataset.rb

@@ -0,0 +1,59 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+
+class DatasetTest < Test::Unit::TestCase
+ 
+  def setup
+    @metadata = File.read(File.join(File.dirname(__FILE__), "dataset.json"))
+  end
+  
+  def test_constructor
+    dataset = Kasabi::Dataset.new("http://api.kasabi.com/dataset/test-data", { :apikey => "test" })
+    assert_equal("http://api.kasabi.com/dataset/test-data", dataset.endpoint)
+    assert_equal("http://data.kasabi.com/dataset/test-data", dataset.uri)
+
+    dataset = Kasabi::Dataset.new("http://data.kasabi.com/dataset/test-data", { :apikey => "test" })
+    assert_equal("http://api.kasabi.com/dataset/test-data", dataset.endpoint)
+    assert_equal("http://data.kasabi.com/dataset/test-data", dataset.uri)
+
+    dataset = Kasabi::Dataset.new("http://www.kasabi.com/dataset/test-data", { :apikey => "test" })
+    assert_equal("http://api.kasabi.com/dataset/test-data", dataset.endpoint)
+    assert_equal("http://data.kasabi.com/dataset/test-data", dataset.uri)
+      
+  end
+  
+  def test_read_metadata    
+    mc = mock()
+    mc.expects(:get).with("http://data.kasabi.com/dataset/test-data", nil, {"Accept" => "application/json", "X_KASABI_APIKEY" => "test"} ).returns(
+    HTTP::Message.new_response( @metadata ))
+    
+    dataset = Kasabi::Dataset.new("http://api.kasabi.com/dataset/test-data", { :apikey => "test", :client => mc })
+    metadata = dataset.metadata
+    assert_not_nil(metadata)    
+  end
+  
+  def test_read_properties
+    mc = mock()
+    mc.expects(:get).with("http://data.kasabi.com/dataset/test-data", 
+    nil, {"Accept" => "application/json", "X_KASABI_APIKEY" => "test"} ).returns(
+    HTTP::Message.new_response( @metadata ))
+    
+    dataset = Kasabi::Dataset.new("http://api.kasabi.com/dataset/test-data", { :apikey => "test", :client => mc })
+    assert_equal("Test Data", dataset.title)
+    assert_equal("The Test Data dataset", dataset.description)
+    assert_equal("http://ldodds.kasabi.com/dataset/test-data", dataset.homepage)
+    assert_equal("http://api.kasabi.com/api/test-sparql", dataset.sparql_endpoint)
+    assert_equal("http://api.kasabi.com/api/test-lookup", dataset.lookup_api)
+    assert_equal("http://api.kasabi.com/api/test-search", dataset.search_api)
+    assert_equal("http://api.kasabi.com/api/test-recon", dataset.reconciliation_api)
+    assert_equal("http://api.kasabi.com/api/test-augment", dataset.augmentation_api)
+    
+    assert_equal("http://api.kasabi.com/api/test-sparql", dataset.sparql_endpoint_client.endpoint)
+    assert_equal("http://api.kasabi.com/api/test-lookup", dataset.lookup_api_client.endpoint)
+    assert_equal("http://api.kasabi.com/api/test-search", dataset.search_api_client.endpoint)
+    
+  end
+    
+end

data/tests/ts_kasabi.rb

@@ -6,4 +6,6 @@ require 'api/tc_sparql.rb'
 require 'api/tc_facet.rb'
 require 'api/tc_search.rb'
 require 'api/tc_augment.rb'
-require 'api/tc_reconcile.rb'
+require 'api/tc_reconcile.rb'
+
+require 'data/tc_dataset.rb'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kasabi
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 25
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - Leigh Dodds
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-13 00:00:00 +00:00
+date: 2011-08-22 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -108,22 +108,32 @@ files:
 - README.md
 - Rakefile
 - CHANGES
+- tests/api/tc_jobs.rb
+- tests/api/tc_store.rb
+- tests/api/apollo-6.json
 - tests/api/tc_sparql.rb
 - tests/api/tc_augment.rb
 - tests/api/tc_reconcile.rb
+- tests/api/tc_status.rb
 - tests/api/tc_facet.rb
-- tests/api/tc_sparqlhelper.rb
 - tests/api/tc_lookup.rb
+- tests/api/tc_attribution.rb
 - tests/api/tc_search.rb
+- tests/data/dataset.json
+- tests/data/tc_dataset.rb
 - tests/ts_kasabi.rb
-- lib/kasabi/dataset/dataset.rb
+- lib/kasabi/api/status.rb
 - lib/kasabi/api/sparql.rb
 - lib/kasabi/api/lookup.rb
 - lib/kasabi/api/reconcile.rb
+- lib/kasabi/api/attribution.rb
+- lib/kasabi/api/jobs.rb
+- lib/kasabi/api/store.rb
 - lib/kasabi/api/augment.rb
 - lib/kasabi/api/facet.rb
 - lib/kasabi/api/base_client.rb
 - lib/kasabi/api/search.rb
+- lib/kasabi/data/dataset.rb
 - lib/kasabi.rb
 has_rdoc: true
 homepage: http://github.com/kasabi/kasabi.rb

data/lib/kasabi/dataset/dataset.rb

@@ -1,21 +0,0 @@
-module Kasabi
-  
-  class Dataset
-    
-    attr_reader :uri
-    attr_reader :client
-    attr_reader :apikey
-    
-    #Initialize the client to work with a specific endpoint
-    #
-    # The _options_ hash can contain the following values:
-    # * *:apikey*: required. apikey authorized to use the API
-    # * *:client*: HTTPClient object instance
-    def initialize(uri, options={})
-      @uri = uri        
-      @client = options[:client] || HTTPClient.new()
-      @apikey = options[:apikey] || nil                    
-    end
-    
-  end
-end

data/tests/api/tc_sparqlhelper.rb

@@ -1,262 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
-require 'kasabi'
-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
-  
-  RESULTS_NO_BINDING = <<-EOL
-  {  
-   "head": {  "vars": [ "name" ]  } ,  
-    
-   "results": {    
-        "bindings": [     
-           { } ,     
-           {   "name": { "type": "literal" , "value": "Apollo 11 SIVB" }
-           }   
-        ]  
-    }
-  }  
-  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 = Kasabi::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 = Kasabi::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 = Kasabi::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, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(RESULTS) )
-      json = Kasabi::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, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns( resp )
-      assert_raises RuntimeError do
-        json = Kasabi::Sparql::SparqlHelper.select(SELECT_QUERY, mc)
-      end
-  end
-  
-  def test_ask
-      mc = mock()
-      mc.expects(:select).with(ASK_QUERY, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(ASK_RESULTS) )
-      assert_equal( true,  Kasabi::Sparql::SparqlHelper.ask(ASK_QUERY, mc) )       
-  end
-
-  def test_select_values
-      mc = mock()
-      mc.expects(:select).with(SELECT_QUERY, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(RESULTS) )
-      results = Kasabi::Sparql::SparqlHelper.select_values(SELECT_QUERY, mc)
-      assert_not_nil( results )
-      assert_equal( 3, results.length )
-  end        
-
-  def test_select_values_with_empty_binding
-      mc = mock()
-      mc.expects(:select).with(SELECT_QUERY, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(RESULTS_NO_BINDING) )
-      results = Kasabi::Sparql::SparqlHelper.select_values(SELECT_QUERY, mc)
-      assert_not_nil( results )
-      assert_equal( 1 , results.length )
-  end
-    
-  def test_select_single_value
-      mc = mock()
-      mc.expects(:select).with(SELECT_QUERY, Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(RESULTS) )
-      result = Kasabi::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 = Kasabi::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
-        Kasabi::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 = Kasabi::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
-        Kasabi::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 = Kasabi::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 = Kasabi::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 = Kasabi::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    
-
-  def test_describe_uri
-      mc = mock()
-      mc.expects(:describe_uri).with("http://www.example.org", "application/json", :cbd).returns( HTTP::Message.new_response(RDF_JSON_RESULTS) )
-      result = Kasabi::Sparql::SparqlHelper.describe_uri("http://www.example.org", mc)
-      assert_not_nil(result)
-      assert_not_nil(result["http://www.example.org"])         
-  end  
-
-  def test_describe_uri_with_type
-      mc = mock()
-      mc.expects(:describe_uri).with("http://www.example.org", "application/json", :slcbd).returns( HTTP::Message.new_response(RDF_JSON_RESULTS) )
-      result = Kasabi::Sparql::SparqlHelper.describe_uri("http://www.example.org", mc, :slcbd)
-      assert_not_nil(result)
-      assert_not_nil(result["http://www.example.org"])         
-  end        
-
-  def test_exists
-      mc = mock()
-      mc.expects(:select).with("ASK { <http://www.example.org> ?p ?o }", Kasabi::Sparql::SPARQL_RESULTS_JSON).returns(
-        HTTP::Message.new_response(ASK_RESULTS) )  
-      result = Kasabi::Sparql::SparqlHelper.exists("http://www.example.org", mc)
-      assert_equal( true, result )
-      
-  end
-  
-end