tripod 0.2.3 → 0.3.0

data/spec/spec_helper.rb

@@ -6,11 +6,13 @@ $LOAD_PATH.unshift(MODELS)
 
 require 'tripod'
 require 'rspec'
+require 'webmock/rspec'
 
 RSpec.configure do |config|
   config.mock_with :rspec
 
   config.before(:each) do
+    WebMock.disable!
     # delete from all graphs.
     Tripod::SparqlClient::Update.update('
       # delete from default graph:
@@ -26,6 +28,7 @@ end
 Tripod.configure do |config|
   config.update_endpoint = 'http://127.0.0.1:3030/tripod-test/update'
   config.query_endpoint = 'http://127.0.0.1:3030/tripod-test/sparql'
+  config.data_endpoint = 'http://127.0.0.1:3030/tripod-test/data'
 end
 
 # Autoload every model for the test suite that sits in spec/app/models.

data/spec/tripod/criteria_execution_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+
+describe Tripod::Criteria do
+
+  let(:person_criteria) do
+    c = Tripod::Criteria.new(Person)
+  end
+
+  let(:resource_criteria) do
+    c = Tripod::Criteria.new(Resource)
+  end
+
+  let(:john) do
+    p = Person.new('http://john', 'http://people')
+    p.name = "John"
+    p
+  end
+
+  let(:barry) do
+    p = Person.new('http://barry', 'http://people')
+    p.name = "Barry"
+    p
+  end
+
+  describe "#build_select_query" do
+
+    context "for a class with an rdf_type" do
+      it "should return a SELECT query based with an rdf type restriction" do
+        person_criteria.send(:build_select_query).should == "SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri a <http://person> } }"
+      end
+
+      context "and extra restrictions" do
+        before { person_criteria.where("[pattern]") }
+
+        it "should return a SELECT query with the extra restriction and rdf type restriction" do
+          person_criteria.send(:build_select_query).should == "SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri a <http://person> . [pattern] } }"
+        end
+      end
+    end
+
+    context "for a class without an rdf_type" do
+      it "should return a SELECT query without an rdf_type restriction" do
+        resource_criteria.send(:build_select_query).should == "SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri ?p ?o } }"
+      end
+
+      context "and extra restrictions" do
+        before { resource_criteria.where("[pattern]") }
+
+        it "should return a SELECT query with the extra restrictions" do
+          resource_criteria.send(:build_select_query).should == "SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri ?p ?o . [pattern] } }"
+        end
+      end
+    end
+  end
+
+  describe "#resources" do
+
+    before do
+      john.save!
+      barry.save!
+    end
+
+    context "with no extra restrictions" do
+      it "should return a set of hydrated objects for the type" do
+        person_criteria.resources.should == [john, barry]
+      end
+    end
+
+    context "with extra restrictions" do
+
+      before { person_criteria.where("?uri <http://name> 'John'") }
+
+      it "should return a set of hydrated objects for the type and restrictions" do
+         person_criteria.resources.should == [john]
+      end
+    end
+
+  end
+
+  describe "#first" do
+
+    before do
+      john.save!
+      barry.save!
+    end
+
+    it "should return the first resource for the criteria" do
+      person_criteria.first.should == john
+    end
+
+    it "should call Query.select with the 'first sparql'" do
+      sparql = Tripod::SparqlQuery.new(person_criteria.send(:build_select_query)).as_first_query_str
+      Tripod::SparqlClient::Query.should_receive(:select).with(sparql).and_call_original
+      person_criteria.first
+    end
+  end
+
+  describe "#count" do
+
+    before do
+      john.save!
+      barry.save!
+    end
+
+    it "should return a set of hydrated objects for the criteria" do
+      person_criteria.count.should == 2
+      person_criteria.where("?uri <http://name> 'John'").count.should ==1
+    end
+
+    it "should call Query.select with the 'count sparql'" do
+      sparql = Tripod::SparqlQuery.new(person_criteria.send(:build_select_query)).as_count_query_str
+      Tripod::SparqlClient::Query.should_receive(:select).with(sparql).and_call_original
+      person_criteria.count
+    end
+
+  end
+
+end

data/spec/tripod/criteria_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+describe Tripod::Criteria do
+
+  let(:person_criteria) { Tripod::Criteria.new(Person) }
+
+  let(:resource_criteria) { Tripod::Criteria.new(Resource) }
+
+  describe "#initialize" do
+
+    it "should set the resource class accessor" do
+      person_criteria.resource_class.should == Person
+    end
+
+    it "should initialize the extra clauses to a blank array" do
+      person_criteria.extra_clauses.should == []
+    end
+
+    context "with rdf_type set on the class" do
+      it "should initialize the where clauses to include a type restriction" do
+        person_criteria.where_clauses.should == ["?uri a <http://person>"]
+      end
+    end
+
+    context "with no rdf_type set on the class" do
+      it "should initialize the where clauses to ?uri ?p ?o" do
+        resource_criteria.where_clauses.should == ["?uri ?p ?o"]
+      end
+    end
+  end
+
+  describe "#where" do
+
+    it "should add the sparql snippet to the where clauses" do
+      resource_criteria.where("blah")
+      resource_criteria.where_clauses.should == ["?uri ?p ?o", "blah"]
+    end
+
+    it "should return an instance of Criteria" do
+      resource_criteria.where("blah").class == Tripod::Criteria
+    end
+
+    it "should return an instance of Criteria with the where clauses added" do
+      resource_criteria.where("blah").where_clauses.should == ["?uri ?p ?o", "blah"]
+    end
+
+  end
+
+  describe "#extras" do
+
+    it "should add the sparql snippet to the extra clauses" do
+      resource_criteria.extras("bleh")
+      resource_criteria.extra_clauses.should == ["bleh"]
+    end
+
+    it "should return an instance of Criteria" do
+      resource_criteria.extras("bleh").class == Tripod::Criteria
+    end
+
+    it "should return an instance of Criteria with the extra clauses added" do
+      resource_criteria.extras("bleh").extra_clauses.should == ["bleh"]
+    end
+  end
+
+end

data/spec/tripod/finders_spec.rb

@@ -3,43 +3,25 @@ require "spec_helper"
 describe Tripod::Finders do
 
   let(:ric) do
-    @ric_uri = 'http://ric'
-    stmts = RDF::Graph.new
-
-    stmt = RDF::Statement.new
-    stmt.subject = RDF::URI.new(@ric_uri)
-    stmt.predicate = RDF::URI.new('http://name')
-    stmt.object = "ric"
-    stmts << stmt
-
-    stmt = RDF::Statement.new
-    stmt.subject = RDF::URI.new(@ric_uri)
-    stmt.predicate = RDF::URI.new('http://knows')
-    stmt.object = RDF::URI.new('http://bill')
-    stmts << stmt
-
-    r = Person.new(@ric_uri)
-    r.hydrate!(:graph => stmts)
-    r.save
+    r = Person.new('http://example.com/people/id/ric')
+    r.name = "ric"
+    r.knows = RDF::URI.new("http://bill")
     r
   end
 
   let(:bill) do
-    @bill_uri = 'http://bill'
-    stmts = RDF::Graph.new
-    stmt = RDF::Statement.new
-    stmt.subject = RDF::URI.new(@bill_uri)
-    stmt.predicate = RDF::URI.new('http://name')
-    stmt.object = "bill"
-    stmts << stmt
-    b = Person.new(@bill_uri)
-    b.hydrate!(:graph => stmts)
-    b.save
+    b = Person.new('http://example.com/people/id/bill')
+    b.name = "bill"
     b
   end
 
   describe '.find' do
 
+    before do
+      ric.save!
+      bill.save!
+    end
+
     context 'when record exists' do
       let(:person) { Person.find(ric.uri) }
 
@@ -65,39 +47,77 @@ describe Tripod::Finders do
       end
     end
 
-    context 'with a given graph URI' do
+    context 'with graph_uri supplied' do
+      it 'should use that graph to call new' do
+        ric # trigger the lazy load
+        Person.should_receive(:new).with(ric.uri, 'http://graphx').and_call_original
+        Person.find(ric.uri, "http://graphx")
+      end
+    end
+
+    context 'with no graph_uri supplied' do
+       it 'should look up the graph to call new' do
+        ric # trigger the lazy load
+        Person.should_receive(:new).with(ric.uri, Person._GRAPH_URI).and_call_original
+        Person.find(ric.uri, Person._GRAPH_URI)
+      end
+    end
+  end
 
+  describe ".all" do
+    it "should make and return a new criteria for the current class" do
+      Person.all.should == Tripod::Criteria.new(Person)
     end
   end
 
-  describe '.where' do
+  describe ".where" do
+
+    let(:criteria) { Person.where("[pattern]") }
 
+    it "should make and return a criteria for the current class" do
+      criteria.class.should == Tripod::Criteria
+    end
+
+    it "should apply the where clause" do
+      criteria.where_clauses.should include("[pattern]")
+    end
+
+  end
+
+  describe "count" do
     before do
-      # save these into the db
-      bill
-      ric
+      ric.save!
+      bill.save!
     end
 
-    it 'returns an array of resources which match those in the db' do
-      res = Person.where('SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri ?p ?o } }')
-      res.length.should == 2
-      res.first.should == ric
-      res.last.should == bill
+    it "should just call count on the all criteria" do
+      all_crit = Tripod::Criteria.new(Person)
+      Person.should_receive(:all).and_return(all_crit)
+      all_crit.should_receive(:count).and_call_original
+      Person.count
+    end
 
-      res.first.name.should == "ric"
-      res.first.knows.should == [RDF::URI.new("http://bill")]
+    it 'should return the count of all resources of this type' do
+      Person.count.should == 2
     end
+  end
 
-    it 'uses the uri and graph variables if supplied' do
-      res = Person.where('SELECT ?bob ?geoff WHERE { GRAPH ?geoff { ?bob ?p ?o } }', :uri_variable => 'bob', :graph_variable => 'geoff')
-      res.length.should == 2
+  describe "first" do
+    before do
+      ric.save!
+      bill.save!
     end
 
-    it "returns non-new records" do
-      res = Person.where('SELECT ?uri ?graph WHERE { GRAPH ?graph { ?uri ?p ?o } }')
-      res.first.new_record?.should be_false
+    it "should just call count on the all criteria" do
+      all_crit = Tripod::Criteria.new(Person)
+      Person.should_receive(:all).and_return(all_crit)
+      all_crit.should_receive(:first).and_call_original
+      Person.first
     end
 
+    it 'should return the first resources of this type' do
+      Person.first.should == ric
+    end
   end
 
 end

data/spec/tripod/resource_spec.rb

@@ -21,8 +21,10 @@ describe Tripod::Resource do
         person.graph_uri.should == RDF::URI.new('http://graph')
       end
 
-      it "sets the rdf type from the class" do
-        person.rdf_type.should == 'http://person'
+      context "with rdf_type specified at class level" do
+        it "sets the rdf type from the class" do
+          person.rdf_type.to_s.should == 'http://person'
+        end
       end
 
       it "initialises a repo" do

data/spec/tripod/sparql_client_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe Tripod::SparqlClient do
+  describe Data do
+    let(:data) { 'some-data-goes-here' }
+
+    describe "Data#append" do
+      it "should add the graph uri to the configured data endpoint" do
+        RestClient::Request.should_receive(:execute).with(hash_including(url: 'http://127.0.0.1:3030/tripod-test/data?graph=http://foo'))
+        Tripod::SparqlClient::Data.append('http://foo', data)
+      end
+
+      it "should send the data as the payload" do
+        RestClient::Request.should_receive(:execute).with(hash_including(payload: data))
+        Tripod::SparqlClient::Data.append('http://foo', data)
+      end
+
+      it "should HTTP POST the data" do
+        RestClient::Request.should_receive(:execute).with(hash_including(method: :post))
+        Tripod::SparqlClient::Data.append('http://foo', data)
+      end
+
+      context "which fails with a 400 error" do
+        before do
+          WebMock.enable!
+          stub_http_request(:post, 'http://127.0.0.1:3030/tripod-test/data?graph=http://foo').to_return(body: 'Error 400: Trousers missing', status: 400)
+        end
+
+        it "should raise a 'parse failed' exception" do
+          lambda { Tripod::SparqlClient::Data.append('http://foo', data) }.should raise_error(Tripod::Errors::BadDataRequest)
+        end
+
+        after do
+          WebMock.disable!
+        end
+      end
+    end
+
+    describe "Data#replace" do
+      it "should HTTP PUT the data" do
+        RestClient::Request.should_receive(:execute).with(hash_including(method: :put))
+        Tripod::SparqlClient::Data.replace('http://foo', data)
+      end
+    end
+  end
+end

data/spec/tripod/sparql_query_spec.rb

@@ -0,0 +1,133 @@
+require "spec_helper"
+
+describe Tripod::SparqlQuery do
+
+  describe '#initialize' do
+    context 'given a query without prefixes' do
+      it 'should assign the given query to the body attribute' do
+        q = Tripod::SparqlQuery.new('SELECT xyz')
+        q.body.should == 'SELECT xyz'
+      end
+    end
+
+    context 'given a query with prefixes' do
+      it 'should separate the query into prefixes and body' do
+        q = Tripod::SparqlQuery.new('PREFIX e: <http://example.com> SELECT xyz')
+        q.prefixes.should == 'PREFIX e: <http://example.com>'
+        q.body.should == 'SELECT xyz'
+      end
+    end
+  end
+
+  describe "#has_prefixes?" do
+
+    context "for a query with prefixes" do
+      it "should return true" do
+        q = Tripod::SparqlQuery.new('PREFIX e: <http://example.com> SELECT xyz')
+        q.has_prefixes?.should be_true
+      end
+    end
+
+    context "for a query without prefixes" do
+      it "should return false" do
+        q = Tripod::SparqlQuery.new('SELECT xyz')
+        q.has_prefixes?.should be_false
+      end
+    end
+
+  end
+
+  describe "#query_type" do
+
+    it 'should return :select given a SELECT query' do
+      q = Tripod::SparqlQuery.new('SELECT xyz')
+      q.query_type.should == :select
+    end
+
+    it 'should return :construct given a CONSTRUCT query' do
+      q = Tripod::SparqlQuery.new('CONSTRUCT <xyz>')
+      q.query_type.should == :construct
+    end
+
+    it 'should return :construct given a DESCRIBE query' do
+      q = Tripod::SparqlQuery.new('DESCRIBE <xyz>')
+      q.query_type.should == :describe
+    end
+
+    it 'should return :ask given an ASK query' do
+      q = Tripod::SparqlQuery.new('ASK <xyz>')
+      q.query_type.should == :ask
+    end
+
+    it "should return :unknown given an unknown type" do
+      q = Tripod::SparqlQuery.new('FOO <xyz>')
+      q.query_type.should == :unknown
+    end
+  end
+
+  describe '#extract_prefixes' do
+    it 'should return the prefixes and query body separately' do
+      q = Tripod::SparqlQuery.new('PREFIX e: <http://example.com> SELECT xyz')
+      p, b = q.extract_prefixes
+      p.should == 'PREFIX e: <http://example.com>'
+      b.should == 'SELECT xyz'
+    end
+  end
+
+  describe '#as_count_query_str' do
+    context "for non-selects" do
+      it "should throw an exception" do
+        lambda {
+          q = Tripod::SparqlQuery.new('ASK { ?s ?p ?o }')
+          q.as_count_query_str
+        }.should raise_error(Tripod::SparqlQueryError)
+      end
+    end
+
+    context "for selects" do
+      context 'without prefixes' do
+        it "should return a new SparqlQuery with the original query wrapped in a count" do
+          q = Tripod::SparqlQuery.new('SELECT ?s WHERE { ?s ?p ?o }')
+          q.as_count_query_str.should == 'SELECT COUNT(*) { SELECT ?s WHERE { ?s ?p ?o } }'
+        end
+      end
+
+      context 'with prefixes' do
+        it "should move the prefixes to the start" do
+          q = Tripod::SparqlQuery.new('PREFIX e: <http://example.com> SELECT ?s WHERE { ?s ?p ?o }')
+          q.as_count_query_str.should == 'PREFIX e: <http://example.com> SELECT COUNT(*) { SELECT ?s WHERE { ?s ?p ?o } }'
+        end
+      end
+    end
+  end
+
+  describe "#as_first_query_str" do
+    context "for non-selects" do
+      it "should throw an exception" do
+        lambda {
+          q = Tripod::SparqlQuery.new('ASK { ?s ?p ?o }')
+          q.as_first_query_str
+        }.should raise_error(Tripod::SparqlQueryError)
+      end
+    end
+
+    context "for selects" do
+      context 'without prefixes' do
+        it "should return a new SparqlQuery with the original query wrapped in a count" do
+          q = Tripod::SparqlQuery.new('SELECT ?s WHERE { ?s ?p ?o }')
+          q.as_first_query_str.should == 'SELECT * { SELECT ?s WHERE { ?s ?p ?o } } LIMIT 1'
+        end
+      end
+
+      context 'with prefixes' do
+        it "should move the prefixes to the start" do
+          q = Tripod::SparqlQuery.new('PREFIX e: <http://example.com> SELECT ?s WHERE { ?s ?p ?o }')
+          q.as_first_query_str.should == 'PREFIX e: <http://example.com> SELECT * { SELECT ?s WHERE { ?s ?p ?o } } LIMIT 1'
+        end
+      end
+
+    end
+
+  end
+
+end