Updates for RSpec 3.0.

Author: gkellogg

lib/rdf/spec.rb

@@ -1,5 +1,6 @@
 require 'rdf'   # @see http://rubygems.org/gems/rdf
 require 'rspec' # @see http://rubygems.org/gems/rspec
+require 'rspec/its'
 
 module RDF
   ##

lib/rdf/spec/enumerable.rb

@@ -439,7 +439,7 @@ module RDF_Enumerable
         subject {@enumerable.enum_graph}
         it {should be_an_enumerator}
         it {should be_countable}
-        it "enumerates the same as #each_graph", :pending => "graph inclusion issue" do
+        it "enumerates the same as #each_graph" do
           expect(subject.to_a).to include(*@enumerable.each_graph.to_a) if @supports_context # expect with match problematic
         end
       end

lib/rdf/spec/mutable.rb

@@ -53,31 +53,27 @@ module RDF_Mutable
       end
 
       it "should accept a string filename argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
       end
 
       it "should accept an optional hash argument" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
       end
 
       it "should load statements" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.load RDF::Spec::TRIPLES_FILE
-          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
-          expect(subject).to have_subject(resource)
-        end
+        skip("mutability") unless subject.mutable?
+        subject.load RDF::Spec::TRIPLES_FILE
+        expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
+        expect(subject).to have_subject(resource)
       end
 
       it "should load statements with a context override" do
-        pending("mutability and contextuality", :unless => (subject.mutable? && @supports_context)) do
-          subject.load RDF::Spec::TRIPLES_FILE, :context => context
-          expect(subject).to have_context(context)
-          expect(subject.query(:context => context).size).to eq subject.size
-        end
+        skip("mutability and contextuality") unless (subject.mutable? && @supports_context)
+        subject.load RDF::Spec::TRIPLES_FILE, :context => context
+        expect(subject).to have_context(context)
+        expect(subject.query(:context => context).size).to eq subject.size
       end
     end
 
@@ -97,62 +93,57 @@ module RDF_Mutable
       end
 
       it "should not raise errors" do
-        pending("mutability", :unless => subject.mutable?) do
-          expect { subject.delete(@statements.first) }.not_to raise_error
-        end
+        skip("mutability") unless subject.mutable?
+        expect { subject.delete(@statements.first) }.not_to raise_error
       end
 
       it "should support deleting one statement at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(@statements.first)
-          expect(subject).not_to  have_statement(@statements.first)
-        end
+        skip("mutability") unless subject.mutable?
+        subject.delete(@statements.first)
+        expect(subject).not_to  have_statement(@statements.first)
       end
 
       it "should support deleting multiple statements at a time" do
-        pending("mutability", :unless => subject.mutable?) do
-          subject.delete(*@statements)
-          expect(subject.find { |s| subject.has_statement?(s) }).to be_false
-        end
+        skip("mutability") unless subject.mutable?
+        subject.delete(*@statements)
+        expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
       end
 
       it "should support wildcard deletions" do
-        pending("mutability", :unless => subject.mutable?) do
-          # nothing deleted
-          require 'digest/sha1'
-          count = subject.count
-          subject.delete([nil, nil, random = Digest::SHA1.hexdigest(File.read(__FILE__))])
-          expect(subject).not_to  be_empty
-          expect(subject.count).to eq count
-
-          # everything deleted
-          subject.delete([nil, nil, nil])
-          expect(subject).to be_empty
-        end
+        skip("mutability") unless subject.mutable?
+        # nothing deleted
+        require 'digest/sha1'
+        count = subject.count
+        subject.delete([nil, nil, Digest::SHA1.hexdigest(File.read(__FILE__))])
+        expect(subject).not_to  be_empty
+        expect(subject.count).to eq count
+
+        # everything deleted
+        subject.delete([nil, nil, nil])
+        expect(subject).to be_empty
       end
 
       it "should only delete statements when the context matches" do
-        pending("mutability", :unless => subject.mutable?) do
-          # Setup three statements identical except for context
-          count = subject.count + (@supports_context ? 3 : 1)
-          s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
-          s2 = s1.dup
-          s2.context = RDF::URI.new("urn:context:1")
-          s3 = s1.dup
-          s3.context = RDF::URI.new("urn:context:2")
-          subject.insert(s1)
-          subject.insert(s2)
-          subject.insert(s3)
-          expect(subject.count).to eq count
-
-          # Delete one by one
-          subject.delete(s1)
-          expect(subject.count).to eq count - (@supports_context ? 1 : 1)
-          subject.delete(s2)
-          expect(subject.count).to eq count - (@supports_context ? 2 : 1)
-          subject.delete(s3)
-          expect(subject.count).to eq count - (@supports_context ? 3 : 1)
-        end
+        skip("mutability") unless subject.mutable?
+        # Setup three statements identical except for context
+        count = subject.count + (@supports_context ? 3 : 1)
+        s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
+        s2 = s1.dup
+        s2.context = RDF::URI.new("urn:context:1")
+        s3 = s1.dup
+        s3.context = RDF::URI.new("urn:context:2")
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        expect(subject.count).to eq count
+
+        # Delete one by one
+        subject.delete(s1)
+        expect(subject.count).to eq count - (@supports_context ? 1 : 1)
+        subject.delete(s2)
+        expect(subject.count).to eq count - (@supports_context ? 2 : 1)
+        subject.delete(s3)
+        expect(subject.count).to eq count - (@supports_context ? 3 : 1)
       end
     end
   end

lib/rdf/spec/queryable.rb

@@ -188,11 +188,11 @@ module RDF_Queryable
               its(:count) {should == 2}
 
               it "has two solutions" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi1")}).to be_truthy
               end
 
               it "has xi2 as a solution" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xi2")}).to be_truthy
               end
             end
 
@@ -201,7 +201,7 @@ module RDF_Queryable
               its(:count) {should == 1}
 
               it "has xd1 as a solution" do
-                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_true
+                expect(subject.any? {|s| s.subject == RDF::URI("http://example.org/xd1")}).to be_truthy
               end
             end
           end
@@ -213,7 +213,7 @@ module RDF_Queryable
     # @see RDF::Queryable#query_execute
     describe "#query_execute" do
       it "defines a protected #query_execute method" do
-        expect(subject.class.protected_method_defined?(:query_execute)).to be_true
+        expect(subject.class.protected_method_defined?(:query_execute)).to be_truthy
       end
 
       context "when called" do
@@ -237,7 +237,7 @@ module RDF_Queryable
     # @see RDF::Queryable#query_pattern
     describe "#query_pattern" do
       it "defines a protected #query_pattern method" do
-        expect(subject.class.protected_method_defined?(:query_pattern)).to be_true
+        expect(subject.class.protected_method_defined?(:query_pattern)).to be_truthy
       end
 
       context "when called" do

lib/rdf/spec/reader.rb

@@ -22,7 +22,7 @@ module RDF_Reader
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub(:open_file).and_yield(StringIO.new(@reader_input))
+        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new(@reader_input))
       end
 
       it "yields reader given file_name" do

lib/rdf/spec/writable.rb

@@ -23,115 +23,102 @@ module RDF_Writable
 
     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
+        skip("writability") unless subject.writable?
+        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
 
       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
+        skip("writability") unless subject.writable?
+        graph = RDF::Graph.new << @statements
+        subject << graph
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       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
+        skip("writability") unless subject.writable?
+        enumerable = @statements.dup.extend(RDF::Enumerable)
+        subject << enumerable
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       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
+        skip("writability") unless subject.writable?
+        mock = double('mock')
+        allow(mock).to receive(:to_rdf).and_return(@statements)
+        subject << mock
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq count
       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
+        skip("writability") unless subject.writable?
+        subject << statement
+        expect(subject).to have_statement(statement)
+        expect(subject.count).to eq 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
+        skip("writability") unless subject.writable?
+        s = RDF::Statement.from([nil, nil, nil])
+        expect(s).not_to  be_valid
+        subject << s
+        expect(subject.count).to eq 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
+        skip("writability") unless subject.writable?
+        expect(subject).to respond_to(:insert)
       end
 
       it "should not raise errors" do
-        pending("writability", :unless => subject.writable?) do
-          expect { subject.insert(statement) }.not_to raise_error
-        end
+        skip("writability") unless subject.writable?
+        expect { subject.insert(statement) }.not_to raise_error
       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)
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(statement)
+        expect(subject).to have_statement(statement)
       end
 
       it "should support inserting multiple statements at a time" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(*@statements)
       end
 
       it "should insert statements successfully" do
-        pending("writability", :unless => subject.writable?) do
-          subject.insert(*@statements)
-          expect(subject.count).to eq count
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(*@statements)
+        expect(subject.count).to eq count
       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
-        end
+        skip("writability") unless subject.writable?
+        subject.insert(statement)
+        subject.insert(statement)
+        expect(subject.count).to eq 1
       end
 
       it "should treat statements with a different context as distinct" do
-        pending("writability", :unless => subject.writable?) do
-          s1 = statement.dup
-          s1.context = nil
-          s2 = statement.dup
-          s2.context = RDF::URI.new("urn:context:1")
-          s3 = statement.dup
-          s3.context = RDF::URI.new("urn:context:2")
-          subject.insert(s1)
-          subject.insert(s2)
-          subject.insert(s3)
-          # If contexts are not suported, all three are redundant
-          expect(subject.count).to eq (@supports_context ? 3 : 1)
-        end
+        skip("writability") unless subject.writable?
+        s1 = statement.dup
+        s1.context = nil
+        s2 = statement.dup
+        s2.context = RDF::URI.new("urn:context:1")
+        s3 = statement.dup
+        s3.context = RDF::URI.new("urn:context:2")
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        # If contexts are not suported, all three are redundant
+        expect(subject.count).to eq (@supports_context ? 3 : 1)
       end
     end
   end

lib/rdf/spec/writer.rb

@@ -31,7 +31,7 @@ module RDF_Writer
 
     describe ".open" do
       before(:each) do
-        RDF::Util::File.stub(:open_file).and_yield(StringIO.new("foo"))
+        allow(RDF::Util::File).to receive(:open_file).and_yield(StringIO.new("foo"))
         @dir = Dir.mktmpdir
         @basename = File.join(@dir, "foo")
       end