Merge pull request #56 from ruby-rdf/feature/graph-transaction

Feature/graph transaction

Author: gkellogg

lib/rdf/spec/repository.rb

@@ -23,6 +23,12 @@
     require 'rdf/spec/dataset'
     it_behaves_like 'an RDF::Dataset'
   end
+
+  context 'as transactable' do
+    require 'rdf/spec/transactable'
+    let(:transactable) { repository }
+    it_behaves_like 'an RDF::Transactable'
+  end
 
   context "when updating" do
     require 'rdf/spec/mutable'

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

lib/rdf/spec/transaction.rb

@@ -2,7 +2,7 @@
 
 # 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
 
@@ -40,6 +40,17 @@
     it 'allows mutability' do
       expect(klass.new(repository, mutable: true)).to be_mutable
     end
+
+    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 'defaults graph_name to nil' do
+      expect(klass.new(repository).graph_name).to be_nil
+    end
   end
 
   it "does not respond to #load" do
@@ -68,7 +79,7 @@
     let(:st) { RDF::Statement(:s, RDF::URI('p'), 'o') }
 
     it 'adds to deletes' do
-      subject.repository.insert(st)
+      repository.insert(st)
 
       expect do 
         subject.delete(st)
@@ -78,7 +89,7 @@
 
     it 'adds multiple to deletes' do
       sts = [st] << RDF::Statement(:x, RDF::URI('y'), 'z')
-      subject.repository.insert(*sts)
+      repository.insert(*sts)
 
       expect do
         subject.delete(*sts)
@@ -89,13 +100,55 @@
     it 'adds enumerable to deletes' do
       sts = [st] << RDF::Statement(:x, RDF::URI('y'), 'z')
       sts.extend(RDF::Enumerable)
-      subject.repository.insert(sts)
+      repository.insert(sts)
 
       expect do
         subject.delete(sts)
         subject.execute
       end.to change { subject.repository.empty? }.from(false).to(true)
     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
+        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 'retains existing graph names' do
+        st.graph_name = RDF::URI('g')
+        repository.insert(st)
+        
+        expect do 
+          subject.delete(st)
+          subject.execute
+        end.to change { subject.repository.statements }.to be_empty
+      end
+
+      it 'retains existing default graph name' do
+        st.graph_name = false
+
+        repository.insert(st)
+        
+        expect do 
+          subject.delete(st)
+          subject.execute
+        end.to change { subject.repository.statements }.to be_empty
+      end
+    end
   end
 
   describe "#insert" do
@@ -129,11 +182,51 @@
       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 'retains existing graph names' do
+        st.graph_name = RDF::URI('g')
+        
+        expect do 
+          subject.insert(st)
+          subject.execute
+        end.to change { subject.repository.statements }
+
+        expect(subject.repository).to have_statement(st)
+      end
+
+      it 'retains existing default graph name' do
+        st.graph_name = false
+        
+        expect do 
+          subject.insert(st)
+          subject.execute
+        end.to change { subject.repository.statements }
+
+        expect(subject.repository).to have_statement(st)
+      end
+    end
   end
 
   describe '#execute' do
-    # @todo: test isolation semantics!
-
+    let(:st) { RDF::Statement(:s, RDF::URI('p'), 'o') }
+      
     context 'after rollback' do
       before { subject.rollback }
 
@@ -142,6 +235,74 @@
           .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 '#rollback' do