rdf-spec 1.0.9 → 1.1.0.p1

data/lib/rdf/spec/readable.rb

@@ -9,8 +9,12 @@ module RDF_Readable
   end
 
   describe RDF::Readable do
-    subject {@readable}
-    it {should respond_to(:readable?)}
-    its(:readable?) {should == subject.readable?}
+    it "responds to #readable?" do
+      @readable.respond_to?(:readable?)
+    end
+  
+    it "implements #readable?" do
+      !!@readable.readable?.should == @readable.readable?
+    end
   end
 end

data/lib/rdf/spec/reader.rb

@@ -13,25 +13,25 @@ module RDF_Reader
     describe ".each" do
       it "yields each reader" do
         @reader_class.each do |r|
-          expect(r).not_to  be_nil
+          r.should_not be_nil
         end
       end
     end
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+        RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
       end
 
       it "yields reader given file_name" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
           f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
+            reader_mock = mock("reader")
+            reader_mock.should_receive(:got_here)
+            @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
             @reader_class.open("foo.#{sym}") do |r|
-              expect(r).to be_a(RDF::Reader)
+              r.should be_a(RDF::Reader)
               reader_mock.got_here
             end
           end
@@ -40,13 +40,13 @@ module RDF_Reader
 
       it "yields reader given symbol" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
           sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
-          reader_mock = double("reader")
-          expect(reader_mock).to receive(:got_here)
-          expect(@reader_class).to receive(:for).with(sym).and_return(@reader_class)
+          reader_mock = mock("reader")
+          reader_mock.should_receive(:got_here)
+          @reader_class.should_receive(:for).with(sym).and_return(@reader_class)
           @reader_class.open("foo.#{sym}", :format => sym) do |r|
-            expect(r).to be_a(RDF::Reader)
+            r.should be_a(RDF::Reader)
             reader_mock.got_here
           end
         end
@@ -54,13 +54,13 @@ module RDF_Reader
 
       it "yields reader given {:file_name => file_name}" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
           f.file_extensions.each_pair do |sym, content_type|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
+            reader_mock = mock("reader")
+            reader_mock.should_receive(:got_here)
+            @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
             @reader_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
-              expect(r).to be_a(RDF::Reader)
+              r.should be_a(RDF::Reader)
               reader_mock.got_here
             end
           end
@@ -69,13 +69,13 @@ module RDF_Reader
 
       it "yields reader given {:content_type => 'a/b'}" do
         @reader_class.format.each do |f|
-          RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+          RDF::Util::File.stub!(:open_file).and_yield(StringIO.new("foo"))
           f.content_types.each_pair do |content_type, formats|
-            reader_mock = double("reader")
-            expect(reader_mock).to receive(:got_here)
-            expect(@reader_class).to receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(@reader_class)
+            reader_mock = mock("reader")
+            reader_mock.should_receive(:got_here)
+            @reader_class.should_receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(@reader_class)
             @reader_class.open("foo", :content_type => content_type) do |r|
-              expect(r).to be_a(RDF::Reader)
+              r.should be_a(RDF::Reader)
               reader_mock.got_here
             end
           end
@@ -86,27 +86,27 @@ module RDF_Reader
     describe ".format" do
       it "returns itself even if given explicit format" do
         other_format = @reader_class == RDF::NTriples::Reader ? :nquads : :ntriples
-        expect(@reader_class.for(other_format)).to eq @reader_class
+        @reader_class.for(other_format).should == @reader_class
       end
     end
 
     describe ".new" do
       it "sets @input to StringIO given a string" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
+        reader_mock = mock("reader")
+        reader_mock.should_receive(:got_here)
         @reader_class.new("string") do |r|
           reader_mock.got_here
-          expect(r.instance_variable_get(:@input)).to be_a(StringIO)
+          r.instance_variable_get(:@input).should be_a(StringIO)
         end
       end
     
       it "sets @input to input given something other than a string" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
+        reader_mock = mock("reader")
+        reader_mock.should_receive(:got_here)
         file = StringIO.new("")
         @reader_class.new(file) do |r|
           reader_mock.got_here
-          expect(r.instance_variable_get(:@input)).to eq file
+          r.instance_variable_get(:@input).should == file
         end
       end
     
@@ -114,37 +114,37 @@ module RDF_Reader
         # Either set validate, or through error, due to invalid input (null input may be invalid)
         begin
           @reader_class.new("string", :validate => true) do |r|
-            expect(r).to be_valid
+            r.send(:validate?).should be_true
           end
         rescue
-          expect($!).to be_a(RDF::ReaderError)  # An error is acceptable
+          $!.should be_a(RDF::ReaderError)  # An error is acceptable
         end
       end
     
       it "sets canonicalize given :canonicalize => true" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
+        reader_mock = mock("reader")
+        reader_mock.should_receive(:got_here)
         @reader_class.new("string", :canonicalize => true) do |r|
           reader_mock.got_here
-          expect(r).to be_canonicalize
+          r.send(:canonicalize?).should be_true
         end
       end
     
       it "sets intern given :intern => true" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
+        reader_mock = mock("reader")
+        reader_mock.should_receive(:got_here)
         @reader_class.new("string", :intern => true) do |r|
           reader_mock.got_here
-          expect(r).to be_intern
+          r.send(:intern?).should be_true
         end
       end
     
       it "sets prefixes given :prefixes => {}" do
-        reader_mock = double("reader")
-        expect(reader_mock).to receive(:got_here)
+        reader_mock = mock("reader")
+        reader_mock.should_receive(:got_here)
         @reader_class.new("string", :prefixes => {:a => "b"}) do |r|
           reader_mock.got_here
-          expect(r.prefixes).to eq({:a => "b"})
+          r.prefixes.should == {:a => "b"}
         end
       end
     end
@@ -152,7 +152,7 @@ module RDF_Reader
     describe "#prefixes=" do
       it "sets prefixes from hash" do
         @reader.prefixes = {:a => "b"}
-        expect(@reader.prefixes).to eq({:a => "b"})
+        @reader.prefixes.should == {:a => "b"}
       end
     end
   
@@ -163,8 +163,8 @@ module RDF_Reader
         "foo"   => "bar",
       }.each_pair do |pfx, uri|
         it "sets prefix(#{pfx}) to #{uri}" do
-          expect(@reader.prefix(pfx, uri)).to eq uri
-          expect(@reader.prefix(pfx)).to eq uri
+          @reader.prefix(pfx, uri).should == uri
+          @reader.prefix(pfx).should == uri
         end
       end
     end

data/lib/rdf/spec/repository.rb

@@ -6,50 +6,61 @@ module RDF_Repository
 
   before :each do
     raise '+@repository+ must be defined in a before(:each) block' unless instance_variable_get('@repository')
-    @statements = RDF::Spec.quads
-    if @repository.empty? && @repository.writable?
-      @repository.insert(*@statements)
-    elsif @repository.empty?
-      raise "+@repository+ must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
-    end
-    @countable = @repository
+    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
+    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
     @enumerable = @repository
-    @queryable = @repository
-    @mutable = @repository
   end
 
   describe RDF::Repository do
-
     context "when counting statements" do
       require 'rdf/spec/countable'
+
+      before :each do
+        @countable = @repository
+        @countable.insert(*@statements)
+      end
+
       include RDF_Countable
     end
 
     context "when enumerating statements" do
       require 'rdf/spec/enumerable'
+
+      before :each do
+        @enumerable = @repository
+        @enumerable.insert(*@statements)
+      end
+
       include RDF_Enumerable
     end
 
     context "when querying statements" do
       require 'rdf/spec/queryable'
+
+      before :each do
+        @queryable = @repository
+        @subject   = RDF::URI.new('http://rubygems.org/gems/rdf')
+      end
+
       include RDF_Queryable
     end
 
-    # FIXME: This should be condition on the repository being mutable
     context "when updating" do
       require 'rdf/spec/mutable'
-      before(:each) do
-        @mutable.clear
+
+      before :each do
+        @mutable = @repository
+        @subject = RDF::URI.new('http://rubygems.org/gems/rdf')
+        @context = RDF::URI.new('http://example.org/context')
       end
+
       include RDF_Mutable
     end
 
-    # FIXME: This should be condition on the repository being mutable
     context "as a durable repository" do
       require 'rdf/spec/durable'
 
       before :each do
-        @repository.clear
         @load_durable ||= lambda { @repository }
       end
 

data/lib/rdf/spec/transaction.rb

@@ -1,62 +1,110 @@
 require 'rdf/spec'
 
-module RDF_Transaction
-  extend RSpec::SharedContext
+# Pass in an instance of RDF::Transaction as follows:
+#
+#   it_behaves_like "RDF_Transaction", RDF::Transaction
+shared_examples "RDF_Transaction" do |klass|
   include RDF::Spec::Matchers
 
-  before :each do
-    raise '+@transaction+ must be defined in a before(:each) block' unless instance_variable_get('@transaction')
-  end
-
   describe RDF::Transaction do
-    #TODO
+    subject {klass.new(:context => RDF::URI("name"), :insert => RDF::Graph.new, :delete => RDF::Graph.new)}
+
     describe "#initialize" do
-      it "accepts a graph"
-      it "accepts a context"
-      it "accepts inserts"
-      it "accepts deletes"
-    end
-  
-    describe "#graph" do
-      it "is mutable"
+      subject {klass}
+      it "accepts a graph" do
+        g = mock("graph")
+        this = subject.new(:graph => g)
+        this.graph.should == g
+      end
+
+      it "accepts a context" do
+        c = mock("context")
+        this = subject.new(:graph => c)
+        this.graph.should == c
+        this.context.should == c
+
+        this = subject.new(:context => c)
+        this.graph.should == c
+        this.context.should == c
+      end
+
+      it "accepts inserts" do
+        g = mock("inserts")
+        this = subject.new(:insert => g)
+        this.inserts.should == g
+      end
+
+      it "accepts deletes" do
+        g = mock("deletes")
+        this = subject.new(:delete => g)
+        this.deletes.should == g
+      end
     end
-  
-    describe "#deletes" do
-      it "is mutable"
+
+    its(:deletes) {should be_a(RDF::Enumerable)}
+    its(:inserts) {should be_a(RDF::Enumerable)}
+    it {should be_mutable}
+    it {should_not be_readable}
+
+    it "does not respond to #load" do
+      lambda {subject.load("http://example/")}.should raise_error(NoMethodError)
     end
-  
-    describe "#inserts" do
-      it "is mutable"
+
+    it "does not respond to #update" do
+      lambda {subject.update(RDF::Statement.new)}.should raise_error(NoMethodError)
     end
-  
-    describe "#readable?" do
-      it "returns false" do
-        expect(@transaction.readable?).to be_false
-      end
+
+    it "does not respond to #clear" do
+      lambda {subject.clear}.should raise_error(NoMethodError)
     end
-  
+
     describe "#execute" do
-      it "deletes statements"
-      it "inserts statements"
-      it "calls before_execute"
-      it "calls after_execute"
-      it "returns self"
-      it "does not delete statements on failures"
-      it "does not insert statements on failures"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      let(:r) {mock("repository")}
+
+      it "deletes statements" do
+        r.should_receive(:delete).with(s)
+        r.should_not_receive(:insert)
+        subject.delete(s)
+        subject.execute(r)
+      end
+
+      it "inserts statements" do
+        r.should_not_receive(:delete)
+        r.should_receive(:insert).with(s)
+        subject.insert(s)
+        subject.execute(r)
+      end
+
+      it "calls before_execute" do
+        subject.should_receive(:before_execute).with(r, {})
+        subject.execute(r)
+      end
+
+      it "calls after_execute" do
+        subject.should_receive(:after_execute).with(r, {})
+        subject.execute(r)
+      end
+
+      it "returns self" do
+        subject.execute(r).should == subject
+      end
     end
   
     describe "#delete_statement" do
-      it "adds statement to #deletes"
-      it "does not remove statement from graph"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      it "adds statement to #deletes" do
+        subject.delete(s)
+        subject.deletes.to_a.should == [s]
+      end
     end
   
     describe "#insert_statement" do
-      it "adds statement to #inserts"
-      it "does not add statement to graph"
+      let(:s) {RDF::Statement.new(RDF::URI("s"), RDF::URI("p"), RDF::URI("o"))}
+      it "adds statement to #inserts" do
+        subject.insert(s)
+        subject.inserts.to_a.should == [s]
+      end
     end
-  
-    it "does not respond to #load"
-    it "does not respond to #update"
-    it "does not respond to #clear"
   end
 end

data/lib/rdf/spec/writable.rb

@@ -7,130 +7,117 @@ module RDF_Writable
   before :each do
     raise '+@writable+ must be defined in a before(:each) block' unless instance_variable_get('@writable')
 
-    @filename = RDF::Spec::TRIPLES_FILE
+    @filename = File.expand_path("../../../../etc/doap.nt", __FILE__)
     @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
 
     @supports_context = @writable.respond_to?(:supports?) && @writable.supports?(:context)
   end
 
   describe RDF::Writable do
-    subject {@writable}
-    let(:statement) {@statements.detect {|s| s.to_a.all? {|r| r.uri?}}}
-    let(:count) {@statements.size}
-
-    it {should respond_to(:writable?)}
-    its(:writable?) {should == !!subject.writable?}
+    it "responds to #writable?" do
+      @writable.respond_to?(:readable?)
+    end
   
+    it "implements #writable?" do
+      !!@writable.writable?.should == @writable.writable?
+    end
+
     describe "#<<" do
       it "inserts a reader" do
-        pending("writability", :unless => subject.writable?) do
-          reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
-          subject << reader
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+        @writable << reader
+        @writable.should have_statement(@statements.first)
+        @writable.count.should == @statements.size
       end
 
       it "inserts a graph" do
-        pending("writability", :unless => subject.writable?) do
-          graph = RDF::Graph.new << @statements
-          subject << graph
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        graph = RDF::Graph.new << @statements
+        @writable << graph
+        @writable.should have_statement(@statements.first)
+        @writable.count.should == @statements.size
       end
 
       it "inserts an enumerable" do
-        pending("writability", :unless => subject.writable?) do
-          enumerable = @statements.dup.extend(RDF::Enumerable)
-          subject << enumerable
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        enumerable = @statements.dup.extend(RDF::Enumerable)
+        @writable << enumerable
+        @writable.should have_statement(@statements.first)
+        @writable.count.should == @statements.size
       end
 
       it "inserts data responding to #to_rdf" do
-        pending("writability", :unless => subject.writable?) do
-          mock = double('mock')
-          mock.stub(:to_rdf).and_return(@statements)
-          subject << mock
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq count
-        end
+        mock = double('mock')
+        mock.stub(:to_rdf).and_return(@statements)
+        @writable << mock
+        @writable.should have_statement(@statements.first)
+        @writable.count.should == @statements.size
       end
 
       it "inserts a statement" do
-        pending("writability", :unless => subject.writable?) do
-          subject << statement
-          expect(subject).to have_statement(statement)
-          expect(subject.count).to eq 1
-        end
+        @writable << @statements.first
+        @writable.should have_statement(@statements.first)
+        @writable.count.should == 1
       end
 
       it "inserts an invalid statement" do
-        pending("writability", :unless => subject.writable?) do
-          s = RDF::Statement.from([nil, nil, nil])
-          expect(s).not_to  be_valid
-          subject << s
-          expect(subject.count).to eq 1
-        end
+        s = RDF::Statement.from([nil, nil, nil])
+        s.should_not be_valid
+        @writable << s
+        @writable.count.should == 1
       end
     end
 
     context "when inserting statements" do
       it "should support #insert" do
-        pending("writability", :unless => subject.writable?) do
-          expect(subject).to respond_to(:insert)
-        end
+        @writable.should respond_to(:insert)
       end
 
       it "should not raise errors" do
-        pending("writability", :unless => subject.writable?) do
-          expect { subject.insert(statement) }.not_to raise_error
+        if @writable.writable?
+          lambda { @writable.insert(@statements.first) }.should_not raise_error
         end
       end
 
       it "should support inserting one statement at a time" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(statement)
-          expect(subject).to have_statement(statement)
+        if @writable.writable?
+          @writable.insert(@statements.first)
+          @writable.should have_statement(@statements.first)
         end
       end
 
       it "should support inserting multiple statements at a time" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
+        if @writable.writable?
+          @writable.insert(*@statements)
         end
       end
 
       it "should insert statements successfully" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
-          expect(subject.count).to eq count
+        if @writable.writable?
+          @writable.insert(*@statements)
+          @writable.count.should == @statements.size
         end
       end
 
       it "should not insert a statement twice" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(statement)
-          subject.insert(statement)
-          expect(subject.count).to eq 1
+        if @writable.writable?
+          @writable.insert(@statements.first)
+          @writable.insert(@statements.first)
+          @writable.count.should == 1
         end
       end
 
       it "should treat statements with a different context as distinct" do
-        pending("writability", :unless => subject.writable?) do
-          s1 = statement.dup
+        if @writable.writable?
+          s1 = @statements.first.dup
           s1.context = nil
-          s2 = statement.dup
+          s2 = @statements.first.dup
           s2.context = RDF::URI.new("urn:context:1")
-          s3 = statement.dup
+          s3 = @statements.first.dup
           s3.context = RDF::URI.new("urn:context:2")
-          subject.insert(s1)
-          subject.insert(s2)
-          subject.insert(s3)
+          @writable.insert(s1)
+          @writable.insert(s2)
+          @writable.insert(s3)
           # If contexts are not suported, all three are redundant
-          expect(subject.count).to eq (@supports_context ? 3 : 1)
+          @writable.count.should == (@supports_context ? 3 : 1)
         end
       end
     end