kasabi 0.0.1 → 0.1.1

data/lib/kasabi/api/status.rb

@@ -0,0 +1,36 @@
+module Kasabi
+  
+  class Status < BaseClient
+    #Initialize the store 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(endpoint, options={})
+      super(endpoint, options)
+    end
+        
+    def get_status()
+      response = get(@endpoint)
+      validate_response(response)
+      return JSON.parse( response.content )        
+    end
+    
+    def status
+      return get_status()["status"]
+    end
+    
+    def storage_mode
+      return get_status()["storageMode"]
+    end
+    
+    def published?
+      return status() == "published"
+    end
+    
+    def writeable?
+      return storage_mode() == "read-write"
+    end
+    
+  end
+end

data/lib/kasabi/api/store.rb

@@ -0,0 +1,63 @@
+module Kasabi
+  
+  module Storage 
+    
+    class Client < Kasabi::BaseClient
+        
+      #Initialize the store 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(endpoint, options={})
+        super(endpoint, options)
+      end
+      
+      # Store the contents of a File (or any IO stream) in the store associated with this dataset
+      # The client does not support streaming submissions of data, so the stream will be fully read before data is submitted to the platform
+      # file:: an IO object  
+      # content_type:: mimetype of RDF serialization
+      def store_file(file, content_type="application/rdf+xml")      
+        data = file.read()
+        file.close()
+        return store_data(data, content_type)
+      end
+      
+      #Store triples contained in the provided string    
+      def store_data(data, content_type="application/rdf+xml")
+        response = post(endpoint, data, {"Content-Type" => content_type } )
+        if response.status != 202
+          raise "Unable to perform request. Status: #{response.status}. Message: #{response.content}"
+        end
+        return response.content               
+      end
+      
+      def store_uri(uri, content_type="application/rdf+xml")
+        response = post(endpoint, {"data_uri" => uri }, {"Content-Type" => content_type } )
+        if response.status != 202
+          raise "Unable to perform request. Status: #{response.status}. Message: #{response.content}"
+        end
+        return response.content               
+      end
+          
+      def apply_changeset(cs)
+        response = post(endpoint, cs, {"Content-Type" => "application/vnd.talis.changeset+xml"} )
+        if response.status != 202
+          raise "Unable to apply changeset. Status: #{response.status}. Message: #{response.content}"
+        end
+        return response.content      
+      end
+         
+      def applied?(update_uri)
+        response = get( update_uri, nil, {"Content-Type" => "application/json"} )
+        if response.status != 200
+            raise "Unable to determine update status. Status: #{response.status}. Message: #{response.content}"
+        end
+        json = JSON.parse(response.content)
+        return json["status"] && json["status"] == "applied"
+      end
+       
+    end
+  
+  end
+end

data/lib/kasabi/data/dataset.rb

@@ -0,0 +1,90 @@
+module Kasabi
+  
+  class Dataset < Kasabi::BaseClient
+    
+    attr_reader :short_code
+    attr_reader :uri
+    
+    #Initialize the client to work with a specific dataset endpoint
+    #Dataset endpoints are available from api.kasabi.com/data/...
+    #
+    # The _options_ hash can contain the following values:
+    # * *:apikey*: required. apikey authorized to use the API
+    # * *:client*: HTTPClient object instance
+    def initialize(endpoint, options={})
+      super(endpoint, options)
+      uri = URI.parse(endpoint)
+      domain = uri.host.split(".")[0]
+      case domain
+        when "data"
+          @uri = endpoint
+          @endpoint = endpoint.gsub("http://data", "http://api")  
+        when "api"
+          @endpoint = endpoint
+          @uri = endpoint.gsub("http://api", "http://data")
+        else
+          #probably website, e.g. beta.kasabi or www.kasabi
+          @endpoint = "http://api.kasabi.com" + uri.path
+          @uri = "http://data.kasabi.com" + uri.path
+      end      
+    end
+    
+    #Read the metadata about this dataset from the live service
+    def metadata(allow_cached=true)
+      if @metadata
+        return @metadata
+      end
+      response = get(@uri, nil, 
+        {"Accept" => "application/json"})
+      validate_response(response)
+      @metadata = JSON.parse( response.content )
+      return @metadata
+    end
+    
+    PROPERTIES = {
+      :title => "http://purl.org/dc/terms/title",
+      :description => "http://purl.org/dc/terms/description",
+      :homepage => "http://xmlns.com/foaf/0.1/homepage",
+      :sparql_endpoint => "http://rdfs.org/ns/void#sparqlEndpoint",
+      :lookup_api => "http://rdfs.org/ns/void#uriLookupEndpoint",
+      :search_api => "http://labs.kasabi.com/ns/services#searchEndpoint",
+      :augmentation_api => "http://labs.kasabi.com/ns/services#augmentationEndpoint",
+      :reconciliation_api => "http://labs.kasabi.com/ns/services#reconciliationEndpoint",
+      :store_api => "http://labs.kasabi.com/ns/services#storeEndpoint",
+      :status_api => "http://labs.kasabi.com/ns/services#statusEndpoint",
+      :jobs_api => "http://labs.kasabi.com/ns/services#jobsEndpoint",
+      :attribution_api => "http://labs.kasabi.com/ns/services#attributionEndpoint"
+    }
+          
+    PROPERTIES.keys.each do |arg|
+      send :define_method, arg do
+        return property(PROPERTIES[arg])
+      end      
+    end
+
+    STANDARD_API_CLIENTS = {
+      :sparql_endpoint => Kasabi::Sparql::Client,
+      :lookup_api => Kasabi::Lookup::Client,
+      :search_api => Kasabi::Search::Client,
+      :augmentation_api => Kasabi::Augment::Client,
+      :reconciliation_api => Kasabi::Reconcile::Client,
+      :store_api => Kasabi::Storage::Client,
+      :status_api => Kasabi::Status,
+      :jobs_api => Kasabi::Jobs::Client,
+      :attribution_api => Kasabi::Attribution      
+    }
+
+    STANDARD_API_CLIENTS.keys.each do |arg|
+      send :define_method, "#{arg}_client" do
+        return STANDARD_API_CLIENTS[arg].method("new").call( self.method(arg).call(), self.client_options )
+      end      
+    end
+                                      
+    private
+    
+      def property(predicate)
+        metadata()
+        return @metadata[ @uri ][predicate][0]["value"]     
+      end
+  end
+end

data/tests/api/apollo-6.json

@@ -0,0 +1,74 @@
+{
+  "http://data.kasabi.com/dataset/nasa/spacecraft/1968-025A": {
+    "http://purl.org/net/schemas/space/discipline": [
+      {
+        "type": "uri",
+        "value": "http://data.kasabi.com/dataset/nasa/discipline/engineering"
+      }
+    ],
+    "http://xmlns.com/foaf/0.1/name": [
+      {
+        "type": "literal",
+        "value": "Apollo 6"
+      }
+    ],
+    "http://purl.org/net/schemas/space/internationalDesignator": [
+      {
+        "type": "literal",
+        "value": "1968-025A"
+      }
+    ],
+    "http://purl.org/net/schemas/space/alternateName": [
+      {
+        "type": "literal",
+        "value": "03170"
+      },
+      {
+        "type": "literal",
+        "value": "AS-502"
+      }
+    ],
+    "http://purl.org/dc/elements/1.1/description": [
+      {
+        "type": "literal",
+        "value": "The unmanned Saturn/Apollo 6 mission was designed as the final qualification of the Saturn V launch vehicle and Apollo spacecraft for manned Apollo missions. The spacecraft consisted of the three stage Saturn V, the Apollo Command and Service Module (CSM) and a boilerplate Lunar Module (LM). The primary objectives of the mission were to demonstrate structural and thermal integrity and compatibility of the launch vehicle and spacecraft, confirm launch loads and dynamic characteristics, and verify stage separations, propulsion, guidance and control, electrical systems, emergency detection system, and mission support facilities and operations, including Command Module recovery."
+      }
+    ],
+    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type": [
+      {
+        "type": "uri",
+        "value": "http://purl.org/net/schemas/space/Spacecraft"
+      }
+    ],
+    "http://xmlns.com/foaf/0.1/homepage": [
+      {
+        "type": "uri",
+        "value": "http://nssdc.gsfc.nasa.gov/database/MasterCatalog?sc=1968-025A"
+      }
+    ],
+    "http://purl.org/net/schemas/space/agency": [
+      {
+        "type": "literal",
+        "value": "United States"
+      }
+    ],
+    "http://xmlns.com/foaf/0.1/depiction": [
+      {
+        "type": "uri",
+        "value": "http://nssdc.gsfc.nasa.gov/image/spacecraft/apollo6_launch.jpg"
+      }
+    ],
+    "http://purl.org/net/schemas/space/mass": [
+      {
+        "type": "literal",
+        "value": "36806.0"
+      }
+    ],
+    "http://purl.org/net/schemas/space/launch": [
+      {
+        "type": "uri",
+        "value": "http://nasa.dataincubator.org/launch/1968-025"
+      }
+    ]
+  }
+}

data/tests/api/tc_attribution.rb

@@ -0,0 +1,31 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+
+class AttributionTest < Test::Unit::TestCase
+  
+  ATTRIBUTION = <<-EOL 
+{
+ "name": "name",
+ "homepage": "homepage",
+ "source": "source",
+ "logo": "logo"
+}
+EOL
+
+  def test_get
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-data/attribution", 
+      nil, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( ATTRIBUTION ))
+      
+    client = Kasabi::Attribution.new("http://api.kasabi.com/api/test-data/attribution", 
+      :apikey=>"test-key", :client=>mc)
+      
+    attribution = client.get_attribution
+    assert_not_nil(attribution)
+    
+  end
+  
+end

data/tests/api/tc_augment.rb

@@ -7,7 +7,8 @@ class AugmentTest < Test::Unit::TestCase
   
   def test_augment_uri
     mc = mock()
-    mc.expects(:get).with("http://api.kasabi.com/api/test-augment-api", {:apikey=>"test-key", "data-uri" => "http://www.example.org/index.rss"}).returns( 
+    mc.expects(:get).with("http://api.kasabi.com/api/test-augment-api", {"data-uri" => "http://www.example.org/index.rss"}, 
+    {"X_KASABI_APIKEY" => "test-key"}).returns( 
     HTTP::Message.new_response("OK") )
       
     client = Kasabi::Augment::Client.new( "http://api.kasabi.com/api/test-augment-api", :apikey=>"test-key", :client=>mc) 
@@ -17,11 +18,12 @@ class AugmentTest < Test::Unit::TestCase
   
   def test_augment
      mc = mock()
-     mc.expects(:post).with("http://api.kasabi.com/api/test-augment-api?apikey=test-key", "data", anything).returns( 
+     mc.expects(:post).with("http://api.kasabi.com/api/test-augment-api", "data", 
+       {"Content-Type" => "application/rss+xml", "X_KASABI_APIKEY" => "test-key"}).returns( 
     HTTP::Message.new_response("OK") )
      
-    client = Kasabi::Augment::Client.new( "http://api.kasabi.com/api/test-augment-api", :apikey=>"test-key", :client=>mc) 
-    response = client.augment("data")    
+    client = Kasabi::Augment::Client.new( "http://api.kasabi.com/api/test-augment-api", {:apikey=>"test-key", :client=>mc}) 
+    response = client.augment("data")
     assert_equal("OK", response)
   end
   

data/tests/api/tc_facet.rb

@@ -67,7 +67,7 @@ EOL
     def test_query
       mc = mock()
       mc.expects(:get).with("http://api.kasabi.com/api/test-facet-api/facet", 
-        {:query => "austen", :fields => "title,author,publisher", :apikey => "test-key"}, nil).returns(
+        {:query => "austen", :fields => "title,author,publisher"}, {"X_KASABI_APIKEY" => "test-key"}).returns(
         HTTP::Message.new_response(RESULTS) )
       
       client = Kasabi::Search::Client.new("http://api.kasabi.com/api/test-facet-api", :apikey => "test-key", :client=>mc)

data/tests/api/tc_jobs.rb

@@ -0,0 +1,23 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+
+class JobsTest < Test::Unit::TestCase
+  
+  def test_reset
+    resp = HTTP::Message.new_response("http://api.kasabi.com/dataset/test-data/jobs/abc")
+    resp.status = 202
+    mc = mock()
+    mc.expects(:post).with("http://api.kasabi.com/dataset/test-data/jobs", 
+    {:jobType=>"reset", :startTime=>"2011-06-05-15:35:30Z"}, 
+      {"Content-Type" => "application/x-www-form-urlencoded", "X_KASABI_APIKEY" => "test"} ).returns( 
+        resp )
+        
+    dataset = Kasabi::Jobs::Client.new("http://api.kasabi.com/dataset/test-data/jobs", 
+      { :apikey => "test", :client => mc })
+    id = dataset.submit_job("reset", "2011-06-05-15:35:30Z")
+    assert_equal("http://api.kasabi.com/dataset/test-data/jobs/abc", id)    
+  end
+  
+end

data/tests/api/tc_lookup.rb

@@ -5,17 +5,22 @@ require 'mocha'
 
 class LookupTest < Test::Unit::TestCase
 
+  def setup
+    @json = File.read(File.join(File.dirname(__FILE__), "apollo-6.json"))
+  end
+  
   def test_describe_with_json    
     mc = mock()
     mc.expects(:get).with("http://api.kasabi.com/api/test-lookup", 
-      {:apikey=>"test-key", :about => "http://www.example.org", :output=>"json"} ).returns(
-    HTTP::Message.new_response("{}"))
+      {:about => "http://www.example.org", :output=>"json"}, {"X_KASABI_APIKEY" => "test-key"} ).returns(
+    HTTP::Message.new_response( @json ))
       
     client = Kasabi::Lookup::Client.new("http://api.kasabi.com/api/test-lookup", 
       :apikey=>"test-key", :client=>mc)
       
-    response = client.lookup("http://www.example.org")
-    assert_not_nil( response )
+    graph = client.lookup("http://www.example.org")
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )
   end
     
 end

data/tests/api/tc_reconcile.rb

@@ -87,7 +87,7 @@ class ClientTest < Test::Unit::TestCase
     
     mc = mock();
     mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile", 
-        {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+        {"query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }, {"X_KASABI_APIKEY" => "test-key"}
       ).returns( HTTP::Message.new_response("{}") )
           
     reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
@@ -108,7 +108,7 @@ class ClientTest < Test::Unit::TestCase
       
     mc = mock();
     mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile", 
-    {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+    {"query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }, {"X_KASABI_APIKEY" => "test-key"}
       ).returns( HTTP::Message.new_response( resp.to_json ) )
           
     reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
@@ -131,7 +131,8 @@ class ClientTest < Test::Unit::TestCase
       
     mc = mock();
     mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile", 
-        {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+        {"query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }, 
+          {"X_KASABI_APIKEY" => "test-key"}
       ).returns( HTTP::Message.new_response( resp.to_json ) )
           
     reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
@@ -161,7 +162,7 @@ class ClientTest < Test::Unit::TestCase
     mc = mock();
     expected_query = { "q0" => { :query => "test", :limit => 3, :type_strict => :any} }
     mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile", 
-    {:apikey=>"test-key", "queries" => expected_query.to_json }
+    {"queries" => expected_query.to_json }, {"X_KASABI_APIKEY" => "test-key"}
       ).returns( HTTP::Message.new_response( resp.to_json ) )
           
     reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)

data/tests/api/tc_search.rb

@@ -7,7 +7,7 @@ class SearchTest < Test::Unit::TestCase
   
   def test_simple_search
     mc = mock()
-    mc.expects(:get).with("http://api.kasabi.com/api/test-search/search", {:apikey=>"test-key", :query => "lunar", :output=>"json"}).returns(
+    mc.expects(:get).with("http://api.kasabi.com/api/test-search/search", {:query => "lunar", :output=>"json"}, {"X_KASABI_APIKEY" => "test-key"}).returns(
       HTTP::Message.new_response("{}") )
     
     client = Kasabi::Search::Client.new("http://api.kasabi.com/api/test-search", :apikey=>"test-key", :client=>mc)
@@ -18,7 +18,7 @@ class SearchTest < Test::Unit::TestCase
   def test_parameter_search
     mc = mock()
     mc.expects(:get).with("http://api.kasabi.com/api/test-search/search", 
-      {:apikey=>"test-key", :query => "lunar", :max => "50", :offset => "10", :output=>"json"}).returns(
+      {:query => "lunar", :max => "50", :offset => "10", :output=>"json"}, {"X_KASABI_APIKEY" => "test-key"}).returns(
     HTTP::Message.new_response("{}") )
     
     

data/tests/api/tc_sparql.rb

@@ -4,174 +4,373 @@ require 'test/unit'
 require 'mocha'
 
 class SparqlTest < 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
   
-  def test_simple_query
+  CONSTRUCT_QUERY = <<-EOL
+CONSTRUCT { ?s ?p ?o. } WHERE { ?s ?p ?o. } 
+  EOL
     
-    mc = mock()
-    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {})
+  RESULTS = <<-EOL
+  {  
+   "head": {  "vars": [ "name" ]  } ,  
     
-    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", 
-    {:client => mc})
-    sparql_client.query("SPARQL")
-        
-  end
-
-  def test_query_with_default_graph
+   "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
 
-    mc = mock()
-    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "default-graph-uri" => ["http://www.example.com"]}, {})
+  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" ]  } ,  
     
-    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
-    sparql_client.add_default_graph("http://www.example.com")
-    sparql_client.query("SPARQL")
-        
+   "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 setup
+    @json = File.read(File.join(File.dirname(__FILE__), "apollo-6.json"))
   end
-
-  def test_query_with_named_graph
-
+    
+  def test_simple_query    
     mc = mock()
-    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "named-graph-uri" => ["http://www.example.com"]}, {})
+    mc.expects(:get).with("http://www.example.org/sparql", 
+      {"query" => "SPARQL"}, 
+      {"X_KASABI_APIKEY" => "test-key"}).returns( 
+        HTTP::Message.new_response("RESULTS") )
     
-    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
-    sparql_client.add_named_graph("http://www.example.com")
-    sparql_client.query("SPARQL")
-        
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", 
+    {:apikey => "test-key", :client => mc})
+    response = sparql_client.query("SPARQL")
+    assert_equal("RESULTS", response)
   end
-  
-  def test_query_with_both_graphs
 
+  def test_query_with_error    
     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"]}, {})
+    resp = HTTP::Message.new_response("Error")
+    resp.status = 500    
+    mc.expects(:get).with("http://www.example.org/sparql", 
+      {"query" => SELECT_QUERY}, 
+      {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"}).returns( resp )
     
-    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => 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
+    client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", 
+      {:apikey => "test-key", :client => mc})
+    assert_raises RuntimeError do
+      client.select(SELECT_QUERY)
+    end
+
+  end    
+  def test_query_with_mimetype
     mc = mock()
-    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"})
+    mc.expects(:get).with("http://www.example.org/sparql", 
+      {"query" => "SPARQL"}, 
+        {"X_KASABI_APIKEY" => "test-key", "Accept" => "application/sparql-results+xml"}).returns(
+          HTTP::Message.new_response("RESULTS"))
     
-    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
-    sparql_client.query("SPARQL", "application/sparql-results+xml")
-     
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc, :apikey=>"test-key"})
+    response = sparql_client.query("SPARQL", "application/sparql-results+xml")
+    assert_equal("RESULTS", response)     
   end
          
   def test_ask
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+json"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "ASK"}, 
+        {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response("{ \"boolean\": \"true\" }"))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.ask("SPARQL")
-    assert_equal("RESULTS", response.content)          
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    response = client.ask("ASK")
+    assert_equal(true, response)          
   end
-  
-  def test_store_sparql_select
+
+  def test_exists
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+json"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "ASK { <http://www.example.org> ?p ?o }"}, 
+        {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response("{ \"boolean\": \"true\" }"))
+    
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    response = client.exists?("http://www.example.org")
+    assert_equal(true, response)          
+  end
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+  def test_select
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "SPARQL"}, 
+        {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response("{}"))
+    
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
     response = client.select("SPARQL")
-    assert_equal("RESULTS", response.content)          
+    assert_not_nil(response)          
   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"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "SPARQL"}, 
+        {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response( @json ))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.construct("SPARQL")
-    assert_equal("RESULTS", response.content)          
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.construct("SPARQL")
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   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"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "SPARQL"}, 
+        {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe("SPARQL")
-    assert_equal("RESULTS", response.content)          
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe("SPARQL")
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   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"))
+        {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns( 
+          HTTP::Message.new_response(@json))
 
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
     uris = []
     uris << "http://www.example.org"
     uris << "http://www.example.com"
-    response = client.multi_describe(uris)
-    assert_equal("RESULTS", response.content)
-                            
+    graph = client.multi_describe(uris)
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   end
  
   def test_describe_uri
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "DESCRIBE <http://www.example.org>"}, {"Accept" => "application/rdf+xml"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "DESCRIBE <http://www.example.org>"},
+        {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe_uri("http://www.example.org")
-    assert_equal("RESULTS", response.content)
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe_uri("http://www.example.org")
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   end
 
   def test_describe_uri_using_cbd
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "DESCRIBE <http://www.example.org>"}, {"Accept" => "application/rdf+xml"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => "DESCRIBE <http://www.example.org>"}, 
+        {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :cbd)
-    assert_equal("RESULTS", response.content)
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe_uri("http://www.example.org", :cbd)
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   end
 
   def test_describe_uri_using_lcbd
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      anything, 
+      {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+        HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :lcbd)
-    assert_equal("RESULTS", response.content)
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe_uri("http://www.example.org", :lcbd)
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
+
   end  
 
   def test_describe_uri_using_scbd
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      anything, 
+      {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+        HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :scbd)
-    assert_equal("RESULTS", response.content)
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe_uri("http://www.example.org", :scbd)
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
   end  
           
   def test_describe_uri_using_slcbd
     mc = mock()
-    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
-      HTTP::Message.new_response("RESULTS"))
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      anything, 
+      {"Accept" => "application/json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+        HTTP::Message.new_response(@json))
     
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
-    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :slcbd)
-    assert_equal("RESULTS", response.content)
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    graph = client.describe_uri("http://www.example.org", :slcbd)
+    assert_not_nil( graph )
+    assert_equal(12, graph.count )          
+
   end  
 
   def test_describe_uri_using_unknown
     mc = mock()
         
-    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", 
+      {"X_KASABI_APIKEY" => "test-key", :client => mc})
+        
     assert_raises RuntimeError do
-        response = client.describe_uri("http://www.example.org", "application/rdf+xml", :unknown)
+        response = client.describe_uri("http://www.example.org", :unknown)
     end
     
   end  
+   
+  def test_apply_initial_bindings
+      query = "SELECT ?p ?o WHERE { ?s ?p ?o }"
+      values = { "s" => "<http://www.example.org>" }
+        
+      bound = Kasabi::Sparql::Client.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::Client.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::Client.apply_initial_bindings(query, values)
+      assert_not_nil(bound)
+      assert_equal( "SELECT ?s WHERE { ?s ?p 'some value' }", bound )   
+  end   
+  
+  def test_binding_to_hash
+      json = JSON.parse(RDF_JSON)
+      binding = json["results"]["bindings"][0]
+      
+      hash = Kasabi::Sparql::Client.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::Client.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_select_values
+      mc = mock()
+      mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+        {"query" => SELECT_QUERY}, 
+          {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+            HTTP::Message.new_response(RESULTS))
+      
+      client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+      results = client.select_values(SELECT_QUERY)
+      assert_not_nil( results )
+      assert_equal( 3, results.length )          
+  end        
+  
+  def test_select_values_with_empty_binding
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => SELECT_QUERY}, 
+        {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response(RESULTS_NO_BINDING))
+    
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    results = client.select_values(SELECT_QUERY)
+    assert_not_nil( results )
+    assert_equal( 1, results.length )          
+  end
+    
+  def test_select_single_value
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", 
+      {"query" => SELECT_QUERY}, 
+        {"Accept" => "application/sparql-results+json", "X_KASABI_APIKEY" => "test-key"} ).returns(
+          HTTP::Message.new_response(RESULTS))
     
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc, :apikey=>"test-key"})
+    result = client.select_single_value(SELECT_QUERY)
+    assert_equal( "Apollo 11 Command and Service Module (CSM)", result  )
+  end        
+   
 end