rdf-spec 1.99.0 → 2.0.0.beta1

data/lib/rdf/spec/repository.rb

@@ -15,65 +15,105 @@ RSpec.shared_examples 'an RDF::Repository' do
     end
   end
 
-  let(:countable) { repository }
-  let(:enumerable) { repository }
-  let(:queryable) { repository }
   let(:mutable) { repository }
+  let(:dataset) { repository.supports?(:snapshots) ? repository.snapshot : repository }
+  subject { repository }
 
-  context "when counting statements" do
-    require 'rdf/spec/countable'
-    it_behaves_like 'an RDF::Countable'
+  context 'as dataset' do
+    require 'rdf/spec/dataset'
+    it_behaves_like 'an RDF::Dataset'
   end
 
-  context "when enumerating statements" do
-    require 'rdf/spec/enumerable'
-    it_behaves_like 'an RDF::Enumerable'
+  context 'as transactable' do
+    require 'rdf/spec/transactable'
+    let(:transactable) { repository }
+    it_behaves_like 'an RDF::Transactable'
   end
-
-  context "when querying statements" do
-    require 'rdf/spec/queryable'
-    it_behaves_like 'an RDF::Queryable'
-  end
-
-  # FIXME: This should be condition on the repository being mutable
+  
   context "when updating" do
     require 'rdf/spec/mutable'
 
-    before { mutable.clear }
-
+    before { mutable.clear if mutable.mutable? }
     it_behaves_like 'an RDF::Mutable'
+    
+    describe '#delete_insert' do
+      it 'updates transactionally' do
+        if mutable.mutable? && mutable.supports?(:atomic_writes)
+          expect(mutable).to receive(:commit_transaction).and_call_original
+          statement = RDF::Statement(:s, RDF::URI.new("urn:predicate:1"), :o)
+
+          mutable.delete_insert([statement], [statement])
+        end
+      end
+    end
   end
 
-  # FIXME: This should be condition on the repository being mutable
-  context "as a durable repository" do
-    require 'rdf/spec/durable'
+  describe "#transaction" do
+    it 'gives an immutable transaction' do
+      expect { subject.transaction { insert([]) } }.to raise_error TypeError
+    end
 
-    before :each do
-      repository.clear
-      @load_durable ||= lambda { repository }
+    it 'commits a successful transaction' do
+      statement = RDF::Statement(:s, RDF.type, :o)
+      expect(subject).to receive(:commit_transaction).and_call_original
+      
+      expect do
+        subject.transaction(mutable: true) { insert(statement) }
+      end.to change { subject.statements }.to include(statement)
     end
 
-    it_behaves_like 'an RDF::Durable'
-  end
-end
+    it 'rolls back a failed transaction' do
+      original_contents = subject.statements
+      expect(subject).to receive(:rollback_transaction).and_call_original
 
-##
-# @deprecated use `it_behaves_like "an RDF::Repository"` instead
-module RDF_Repository
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
+      expect do
+        subject.transaction(mutable: true) do
+          delete(*@statements)
+          raise 'my error'
+        end
+      end.to raise_error RuntimeError
 
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Repository` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Repository'`"
+      expect(subject.statements).to contain_exactly(*original_contents)
+    end
   end
 
-  describe 'examples for' do
-    include_examples 'an RDF::Repository' do
-      let(:repository) { @repository }
+  context "with snapshot support" do
+
+    describe '#snapshot' do
+      it 'is not implemented when #supports(:snapshots) is false' do
+        unless subject.supports?(:snapshots) 
+          expect { subject.snapshot }.to raise_error NotImplementedError
+        end
+      end
+    end
+
+    it 'returns a queryable #snapshot' do
+      if subject.supports? :snapshots
+        expect(subject.snapshot).to be_a RDF::Queryable
+        expect(mutable.snapshot).to be_a RDF::Dataset
+      end
+    end
+
+    it 'has repeatable read isolation or better' do
+      if repository.supports? :snapshots
+        good_isolation = [:repeatable_read, :snapshot, :serializable]
+        expect(good_isolation).to include repository.isolation_level
+      end
+    end
+
+    it 'gives an accurate snapshot' do
+      if subject.supports? :snapshots
+        snap = subject.snapshot
+        expect(snap.query([:s, :p, :o]))
+          .to contain_exactly(*subject.query([:s, :p, :o]))
+      end
+    end
 
-      before do
-        raise '@repository must be defined' unless defined?(repository)
+    it 'gives static snapshot' do
+      if subject.supports? :snapshots
+        snap = subject.snapshot
+        expect { subject.clear }
+          .not_to change { snap.query([:s, :p, :o]).to_a }
       end
     end
   end

data/lib/rdf/spec/transactable.rb

@@ -0,0 +1,43 @@
+require 'rdf/spec'
+
+RSpec.shared_examples 'an RDF::Transactable' do
+  include RDF::Spec::Matchers
+
+  let(:statements) { RDF::Spec.quads }
+
+  before do
+    raise '`transactable` must be set with `let(:transactable)`' unless
+      defined? transactable
+  end
+
+  subject { transactable }
+
+  describe "#transaction" do
+    it 'gives an immutable transaction' do
+      expect { subject.transaction { insert([]) } }.to raise_error TypeError
+    end
+
+    it 'commits a successful transaction' do
+      statement = RDF::Statement(:s, RDF.type, :o)
+      expect(subject).to receive(:commit_transaction).and_call_original
+      
+      expect do
+        subject.transaction(mutable: true) { insert(statement) }
+      end.to change { subject.statements }.to include(statement)
+    end
+
+    it 'rolls back a failed transaction' do
+      original_contents = subject.statements
+      expect(subject).to receive(:rollback_transaction).and_call_original
+
+      expect do
+        subject.transaction(mutable: true) do
+          delete(*@statements)
+          raise 'my error'
+        end
+      end.to raise_error RuntimeError
+
+      expect(subject.statements).to contain_exactly(*original_contents)
+    end
+  end
+end

data/lib/rdf/spec/transaction.rb

@@ -2,118 +2,341 @@ require 'rdf/spec'
 
 # Pass in an instance of RDF::Transaction as follows:
 #
-#   it_behaves_like "RDF::Transaction", RDF::Transaction
+#   it_behaves_like "an RDF::Transaction", RDF::Transaction
 shared_examples "an RDF::Transaction" do |klass|
   include RDF::Spec::Matchers
 
-  subject {klass.new(graph_name: RDF::URI("name"), inser: RDF::Graph.new, delete: RDF::Graph.new)}
+  before do
+    raise 'repository must be set with `let(:repository)' unless 
+      defined? repository
+  end
 
-  describe "#initialize" do
-    subject {klass}
-    it "accepts a graph" do
-      g = double("graph")
-      this = subject.new(graph: g)
-      expect(this.graph).to eq g
+  subject { klass.new(repository, mutable: true) }
+
+  it { is_expected.to be_readable }
+  it { is_expected.to be_queryable }
+
+  context "when querying statements" do
+    require 'rdf/spec/queryable'
+    let(:queryable) do
+      repository.insert(*RDF::Spec.quads)
+      klass.new(repository)
+    end
+    it_behaves_like 'an RDF::Queryable'
+
+    context 'with a graph_name' do
+      let(:queryable) do
+        graph_name = RDF::URI('http://example.com/g')
+        graph = RDF::Graph.new(graph_name: graph_name, data: repository)
+        graph.insert(*RDF::Spec.quads)
+        klass.new(repository, graph_name: graph_name)
+      end
+      it_behaves_like 'an RDF::Queryable'
+    end
+
+    context 'with a false graph_name' do
+      let(:queryable) do
+        graph = RDF::Graph.new(data: repository)
+        graph.insert(*RDF::Spec.quads)
+        graph_name = false
+        klass.new(repository, graph_name: graph_name)
+      end
+      it_behaves_like 'an RDF::Queryable'
     end
+  end
 
-    it "accepts a context", unless: RDF::VERSION.to_s >= "1.99" do
-      c = double("context")
-      this = subject.new(graph: c)
-      expect(this.graph).to eq c
-      expect(this.context).to eq c
+  describe "#initialize" do
+    it 'accepts a repository' do
+      repo = double('repository')
+      allow(repo).to receive_messages(:supports? => false)
 
-      this = subject.new(context: c)
-      expect(this.graph).to eq c
-      expect(this.context).to eq c
+      expect(klass.new(repo).repository).to eq repo
     end
 
-    it "accepts a graph_name", if: RDF::VERSION.to_s >= "1.99" do
-      c = double("graph_name")
-      this = subject.new(graph: c)
-      expect(this.graph).to eq c
-      expect(this.graph_name).to eq c
+    it 'defaults immutable (read only)' do
+      expect(klass.new(repository).mutable?).to be false
+    end
 
-      this = subject.new(graph_name: c)
-      expect(this.graph).to eq c
-      expect(this.graph_name).to eq c
+    it 'allows mutability' do
+      expect(klass.new(repository, mutable: true)).to be_mutable
     end
 
-    it "accepts inserts" do
-      g = double("inserts")
-      this = subject.new(insert: g)
-      expect(this.inserts).to eq g
+    it 'accepts a graph_name' do
+      graph_uri = RDF::URI('http://example.com/graph_1')
+      
+      expect(klass.new(repository, graph_name: graph_uri).graph_name)
+        .to eq graph_uri
     end
 
-    it "accepts deletes" do
-      g = double("deletes")
-      this = subject.new(delete: g)
-      expect(this.deletes).to eq g
+    it 'defaults graph_name to nil' do
+      expect(klass.new(repository).graph_name).to be_nil
     end
   end
 
-  its(:deletes) {is_expected.to be_a(RDF::Enumerable)}
-  its(:inserts) {is_expected.to be_a(RDF::Enumerable)}
-  it {is_expected.to be_mutable}
-  it {is_expected.to_not be_readable}
-
   it "does not respond to #load" do
-    expect {subject.load("http://example/")}.to raise_error(NoMethodError)
+    expect { subject.load("http://example/") }.to raise_error(NoMethodError)
   end
 
   it "does not respond to #update" do
-    expect {subject.update(RDF::Statement.new)}.to raise_error(NoMethodError)
+    expect { subject.update(RDF::Statement.new) }.to raise_error(NoMethodError)
   end
 
   it "does not respond to #clear" do
-    expect {subject.clear}.to raise_error(NoMethodError)
+    expect { subject.clear }.to raise_error(NoMethodError)
   end
 
-  describe "#execute" do
-    let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
-    let(:r) {double("repository")}
+  describe '#changes' do
+    it 'is a changeset' do
+      expect(subject.changes).to be_a RDF::Changeset
+    end
 
-    it "deletes statements" do
-      expect(r).to receive(:delete).with(s)
-      expect(r).not_to receive(:insert)
-      subject.delete(s)
-      subject.execute(r)
+    it 'is initially empty' do
+      expect(subject.changes).to be_empty
     end
+  end
 
-    it "inserts statements" do
-      expect(r).not_to receive(:delete)
-      expect(r).to receive(:insert).with(s)
-      subject.insert(s)
-      subject.execute(r)
+  describe "#delete" do
+    let(:st) { RDF::Statement(:s, RDF::URI('http://example.com/p'), 'o') }
+    
+    it 'adds to deletes' do
+      repository.insert(st)
+
+      expect do 
+        subject.delete(st)
+        subject.execute
+      end.to change { subject.repository.empty? }.from(false).to(true)
     end
 
-    it "calls before_execute" do
-      is_expected.to receive(:before_execute).with(r, {})
-      subject.execute(r)
+    it 'adds multiple to deletes' do
+      sts = [st] << RDF::Statement(:x, RDF::URI('http://example.com/y'), 'z')
+      repository.insert(*sts)
+
+      expect do
+        subject.delete(*sts)
+        subject.execute
+      end.to change { subject.repository.empty? }.from(false).to(true)
     end
 
-    it "calls after_execute" do
-      is_expected.to receive(:after_execute).with(r, {})
-      subject.execute(r)
+    it 'adds enumerable to deletes' do
+      sts = [st] << RDF::Statement(:x, RDF::URI('http://example.com/y'), 'z')
+      sts.extend(RDF::Enumerable)
+      repository.insert(sts)
+
+      expect do
+        subject.delete(sts)
+        subject.execute
+      end.to change { subject.repository.empty? }.from(false).to(true)
     end
 
-    it "returns self" do
-      expect(subject.execute(r)).to eq subject
+    context 'with a graph_name' do
+      subject { klass.new(repository, mutable: true, graph_name: graph_uri) }
+      
+      let(:graph_uri) { RDF::URI('http://example.com/graph_1') }
+      
+      it 'adds the graph_name to statements' do
+        repository.insert(st)
+        with_name = st.dup
+        with_name.graph_name = graph_uri
+        repository.insert(with_name)
+
+        expect do 
+          subject.delete(st)
+          subject.execute
+        end.to change { subject.repository.statements }
+
+        expect(subject.repository).not_to have_statement(with_name)
+        expect(subject.repository).to have_statement(st)
+      end
+
+      it 'overwrites existing graph names' do
+        st.graph_name = RDF::URI('http://example.com/g')
+        repository.insert(st)
+        
+        expect do 
+          subject.delete(st)
+          subject.execute
+        end.not_to change { subject.repository.statements }
+      end
+
+      it 'overwrites existing default graph name' do
+        st.graph_name = false
+
+        repository.insert(st)
+        
+        expect do 
+          subject.delete(st)
+          subject.execute
+        end.not_to change { subject.repository.statements }
+      end
     end
   end
 
-  describe "#delete_statement" do
-    let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
-    it "adds statement to #deletes" do
-      subject.delete(s)
-      expect(subject.deletes.to_a).to eq [s]
+  describe "#insert" do
+    let(:st) { RDF::Statement(:s, RDF::URI('http://example.com/p'), 'o') }
+    
+    it 'adds to inserts' do
+      expect do
+        subject.insert(st)
+        subject.execute
+      end.to change { subject.repository.statements }
+              .to contain_exactly(st)
+    end
+
+    it 'adds multiple to inserts' do
+      sts = [st] << RDF::Statement(:x, RDF::URI('http://example.com/y'), 'z')
+      
+      expect do
+        subject.insert(*sts)
+        subject.execute
+      end.to change { subject.repository.statements }
+              .to contain_exactly(*sts)
+    end
+
+    it 'adds enumerable to inserts' do
+      sts = [st] << RDF::Statement(:x, RDF::URI('http://example.com/y'), 'z')
+      sts.extend(RDF::Enumerable)
+
+      expect do
+        subject.insert(sts)
+        subject.execute
+      end.to change { subject.repository.statements }
+              .to contain_exactly(*sts)
+    end
+
+    context 'with a graph_name' do
+      subject { klass.new(repository, mutable: true, graph_name: graph_uri) }
+      
+      let(:graph_uri) { RDF::URI('http://example.com/graph_1') }
+      
+      it 'adds the graph_name to statements' do
+        with_name = st.dup
+        with_name.graph_name = graph_uri
+
+        expect do 
+          subject.insert(st)
+          subject.execute
+        end.to change { subject.repository }
+
+        expect(subject.repository).to have_statement(with_name)
+      end
+
+      it 'overwrites existing graph names' do
+        st.graph_name = RDF::URI('http://example.com/g')
+        with_name = st.dup
+        with_name.graph_name = graph_uri
+
+        expect do 
+          subject.insert(st)
+          subject.execute
+        end.to change { subject.repository.statements }
+
+        expect(subject.repository).not_to have_statement(st)
+        expect(subject.repository).to have_statement(with_name)
+      end
+
+      it 'overwrites existing default graph name' do
+        st.graph_name = false
+        with_name = st.dup
+        with_name.graph_name = graph_uri
+
+        expect do
+          subject.insert(st)
+          subject.execute
+        end.to change { subject.repository.statements }
+        
+        expect(subject.repository).not_to have_statement(st)
+        expect(subject.repository).to have_statement(with_name)
+      end
+    end
+  end
+
+  describe '#execute' do
+    let(:st) { RDF::Statement(:s, RDF::URI('http://example.com/p'), 'o') }
+      
+    context 'after rollback' do
+      before { subject.rollback }
+
+      it 'does not execute' do
+        expect { subject.execute }
+          .to raise_error RDF::Transaction::TransactionError
+      end
+    end
+
+    context 'when :read_committed' do
+      it 'does not read uncommitted statements' do
+        unless subject.isolation_level == :read_uncommitted
+          read_tx = klass.new(repository, mutable: true)
+          subject.insert(st)
+          
+          expect(read_tx.statements).not_to include(st)
+        end
+      end
+
+      it 'reads committed statements' do
+        if subject.isolation_level == :read_committed
+          read_tx = klass.new(repository)
+          subject.insert(st)
+          subject.execute
+          
+          expect(read_tx.statements).to include(st)
+        end
+      end
+    end
+
+    context 'when :repeatable_read' do
+      it 'does not read committed statements already read' do
+        if subject.isolation_level == :repeatable_read || 
+           subject.isolation_level == :snapshot        || 
+           subject.isolation_level == :serializable
+          read_tx = klass.new(repository)
+          subject.insert(st)
+          subject.execute
+
+          expect(read_tx.statements).not_to include(st)
+        end
+      end
+    end
+
+    context 'when :snapshot' do
+      it 'does not read committed statements' do
+        if subject.isolation_level == :snapshot     ||
+           subject.isolation_level == :serializable
+          read_tx = klass.new(repository)
+          subject.insert(st)
+          subject.execute
+
+          expect(read_tx.statements).not_to include(st)
+        end
+      end
+
+      it 'reads current transaction state' do
+        if subject.isolation_level == :snapshot     ||
+           subject.isolation_level == :serializable
+          subject.insert(st)
+          expect(subject.statements).to include(st)
+        end
+      end
+    end
+
+    context 'when :serializable' do
+      it 'raises an error if conflicting changes are present' do
+        if subject.isolation_level == :serializable
+          subject.insert(st)
+          repository.insert(st)
+          
+          expect { subject.execute }
+            .to raise_error RDF::Transaction::TransactionError
+        end
+      end
     end
   end
 
-  describe "#insert_statement" do
-    let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
-    it "adds statement to #inserts" do
-      subject.insert(s)
-      expect(subject.inserts.to_a).to eq [s]
+  describe '#rollback' do
+    before { subject.insert(st); subject.delete(st) }
+    let(:st) { RDF::Statement(:s, RDF::URI('http://example.com/p'), 'o') }
+
+    it 'empties changes when available' do
+      expect { subject.rollback }.to change { subject.changes }.to be_empty
     end
   end
 end