rdf-spec 1.0.7 → 1.0.9

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|
-          r.should_not be_nil
+          expect(r).not_to  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 = mock("reader")
-            reader_mock.should_receive(:got_here)
-            @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
+            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_class.open("foo.#{sym}") do |r|
-              r.should be_a(RDF::Reader)
+              expect(r).to 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 = mock("reader")
-          reader_mock.should_receive(:got_here)
-          @reader_class.should_receive(:for).with(sym).and_return(@reader_class)
+          reader_mock = double("reader")
+          expect(reader_mock).to receive(:got_here)
+          expect(@reader_class).to receive(:for).with(sym).and_return(@reader_class)
           @reader_class.open("foo.#{sym}", :format => sym) do |r|
-            r.should be_a(RDF::Reader)
+            expect(r).to 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 = mock("reader")
-            reader_mock.should_receive(:got_here)
-            @reader_class.should_receive(:for).with(:file_name => "foo.#{sym}").and_return(@reader_class)
+            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_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
-              r.should be_a(RDF::Reader)
+              expect(r).to 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 = 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_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_class.open("foo", :content_type => content_type) do |r|
-              r.should be_a(RDF::Reader)
+              expect(r).to 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
-        @reader_class.for(other_format).should == @reader_class
+        expect(@reader_class.for(other_format)).to eq @reader_class
       end
     end
 
     describe ".new" do
       it "sets @input to StringIO given a string" do
-        reader_mock = mock("reader")
-        reader_mock.should_receive(:got_here)
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
         @reader_class.new("string") do |r|
           reader_mock.got_here
-          r.instance_variable_get(:@input).should be_a(StringIO)
+          expect(r.instance_variable_get(:@input)).to be_a(StringIO)
         end
       end
     
       it "sets @input to input given something other than a string" do
-        reader_mock = mock("reader")
-        reader_mock.should_receive(:got_here)
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
         file = StringIO.new("")
         @reader_class.new(file) do |r|
           reader_mock.got_here
-          r.instance_variable_get(:@input).should == file
+          expect(r.instance_variable_get(:@input)).to eq 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|
-            r.send(:validate?).should be_true
+            expect(r).to be_valid
           end
         rescue
-          $!.should be_a(RDF::ReaderError)  # An error is acceptable
+          expect($!).to be_a(RDF::ReaderError)  # An error is acceptable
         end
       end
     
       it "sets canonicalize given :canonicalize => true" do
-        reader_mock = mock("reader")
-        reader_mock.should_receive(:got_here)
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
         @reader_class.new("string", :canonicalize => true) do |r|
           reader_mock.got_here
-          r.send(:canonicalize?).should be_true
+          expect(r).to be_canonicalize
         end
       end
     
       it "sets intern given :intern => true" do
-        reader_mock = mock("reader")
-        reader_mock.should_receive(:got_here)
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
         @reader_class.new("string", :intern => true) do |r|
           reader_mock.got_here
-          r.send(:intern?).should be_true
+          expect(r).to be_intern
         end
       end
     
       it "sets prefixes given :prefixes => {}" do
-        reader_mock = mock("reader")
-        reader_mock.should_receive(:got_here)
+        reader_mock = double("reader")
+        expect(reader_mock).to receive(:got_here)
         @reader_class.new("string", :prefixes => {:a => "b"}) do |r|
           reader_mock.got_here
-          r.prefixes.should == {:a => "b"}
+          expect(r.prefixes).to eq({: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"}
-        @reader.prefixes.should == {:a => "b"}
+        expect(@reader.prefixes).to eq({: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
-          @reader.prefix(pfx, uri).should == uri
-          @reader.prefix(pfx).should == uri
+          expect(@reader.prefix(pfx, uri)).to eq uri
+          expect(@reader.prefix(pfx)).to eq uri
         end
       end
     end

data/lib/rdf/spec/transaction.rb

@@ -31,7 +31,7 @@ module RDF_Transaction
   
     describe "#readable?" do
       it "returns false" do
-        @transaction.readable?.should be_false
+        expect(@transaction.readable?).to be_false
       end
     end
   

data/lib/rdf/spec/writable.rb

@@ -26,8 +26,8 @@ module RDF_Writable
         pending("writability", :unless => subject.writable?) do
           reader = RDF::NTriples::Reader.new(File.open(@filename)).to_a
           subject << reader
-          subject.should have_statement(statement)
-          subject.count.should == count
+          expect(subject).to have_statement(statement)
+          expect(subject.count).to eq count
         end
       end
 
@@ -35,8 +35,8 @@ module RDF_Writable
         pending("writability", :unless => subject.writable?) do
           graph = RDF::Graph.new << @statements
           subject << graph
-          subject.should have_statement(statement)
-          subject.count.should == count
+          expect(subject).to have_statement(statement)
+          expect(subject.count).to eq count
         end
       end
 
@@ -44,8 +44,8 @@ module RDF_Writable
         pending("writability", :unless => subject.writable?) do
           enumerable = @statements.dup.extend(RDF::Enumerable)
           subject << enumerable
-          subject.should have_statement(statement)
-          subject.count.should == count
+          expect(subject).to have_statement(statement)
+          expect(subject.count).to eq count
         end
       end
 
@@ -54,25 +54,25 @@ module RDF_Writable
           mock = double('mock')
           mock.stub(:to_rdf).and_return(@statements)
           subject << mock
-          subject.should have_statement(statement)
-          subject.count.should == count
+          expect(subject).to have_statement(statement)
+          expect(subject.count).to eq count
         end
       end
 
       it "inserts a statement" do
         pending("writability", :unless => subject.writable?) do
           subject << statement
-          subject.should have_statement(statement)
-          subject.count.should == 1
+          expect(subject).to have_statement(statement)
+          expect(subject.count).to eq 1
         end
       end
 
       it "inserts an invalid statement" do
         pending("writability", :unless => subject.writable?) do
           s = RDF::Statement.from([nil, nil, nil])
-          s.should_not be_valid
+          expect(s).not_to  be_valid
           subject << s
-          subject.count.should == 1
+          expect(subject.count).to eq 1
         end
       end
     end
@@ -80,20 +80,20 @@ module RDF_Writable
     context "when inserting statements" do
       it "should support #insert" do
         pending("writability", :unless => subject.writable?) do
-          subject.should respond_to(:insert)
+          expect(subject).to respond_to(:insert)
         end
       end
 
       it "should not raise errors" do
         pending("writability", :unless => subject.writable?) do
-          lambda { subject.insert(statement) }.should_not raise_error
+          expect { subject.insert(statement) }.not_to raise_error
         end
       end
 
       it "should support inserting one statement at a time" do
         pending("writability", :unless => subject.writable?) do
           subject.insert(statement)
-          subject.should have_statement(statement)
+          expect(subject).to have_statement(statement)
         end
       end
 
@@ -106,7 +106,7 @@ module RDF_Writable
       it "should insert statements successfully" do
         pending("writability", :unless => subject.writable?) do
           subject.insert(*@statements)
-          subject.count.should == count
+          expect(subject.count).to eq count
         end
       end
 
@@ -114,7 +114,7 @@ module RDF_Writable
         pending("writability", :unless => subject.writable?) do
           subject.insert(statement)
           subject.insert(statement)
-          subject.count.should == 1
+          expect(subject.count).to eq 1
         end
       end
 
@@ -130,7 +130,7 @@ module RDF_Writable
           subject.insert(s2)
           subject.insert(s3)
           # If contexts are not suported, all three are redundant
-          subject.count.should == (@supports_context ? 3 : 1)
+          expect(subject.count).to eq (@supports_context ? 3 : 1)
         end
       end
     end

data/lib/rdf/spec/writer.rb

@@ -15,23 +15,23 @@ module RDF_Writer
     describe ".each" do
       it "yields each writer" do
         @writer_class.each do |r|
-          r.should_not be_nil
+          expect(r).not_to be_nil
         end
       end
     end
   
     describe ".buffer" do
       it "calls .new with buffer and other arguments" do
-        @writer_class.should_receive(:new)
+        expect(@writer_class).to receive(:new)
         @writer_class.buffer do |r|
-          r.should be_a(@writer_class)
+          expect(r).to be_a(@writer_class)
         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"))
         @dir = Dir.mktmpdir
         @basename = File.join(@dir, "foo")
       end
@@ -43,11 +43,11 @@ module RDF_Writer
       it "yields writer given file_name" do
         @writer_class.format.each do |f|
           f.file_extensions.each_pair do |sym, content_type|
-            writer_mock = mock("writer")
-            writer_mock.should_receive(:got_here)
-            @writer_class.should_receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
+            writer_mock = double("writer")
+            expect(writer_mock).to receive(:got_here)
+            expect(@writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
             @writer_class.open("#{@basename}.#{sym}") do |r|
-              r.should be_a(RDF::Writer)
+              expect(r).to be_a(RDF::Writer)
               writer_mock.got_here
             end
           end
@@ -57,11 +57,11 @@ module RDF_Writer
       it "yields writer given symbol" do
         @writer_class.format.each do |f|
           sym = f.to_sym  # Like RDF::NTriples::Format => :ntriples
-          writer_mock = mock("writer")
-          writer_mock.should_receive(:got_here)
-          @writer_class.should_receive(:for).with(sym).and_return(@writer_class)
+          writer_mock = double("writer")
+          expect(writer_mock).to receive(:got_here)
+          expect(@writer_class).to receive(:for).with(sym).and_return(@writer_class)
           @writer_class.open("#{@basename}.#{sym}", :format => sym) do |r|
-            r.should be_a(RDF::Writer)
+            expect(r).to be_a(RDF::Writer)
             writer_mock.got_here
           end
         end
@@ -70,11 +70,11 @@ module RDF_Writer
       it "yields writer given {:file_name => file_name}" do
         @writer_class.format.each do |f|
           f.file_extensions.each_pair do |sym, content_type|
-            writer_mock = mock("writer")
-            writer_mock.should_receive(:got_here)
-            @writer_class.should_receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
+            writer_mock = double("writer")
+            expect(writer_mock).to receive(:got_here)
+            expect(@writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(@writer_class)
             @writer_class.open("#{@basename}.#{sym}", :file_name => "#{@basename}.#{sym}") do |r|
-              r.should be_a(RDF::Writer)
+              expect(r).to be_a(RDF::Writer)
               writer_mock.got_here
             end
           end
@@ -84,11 +84,11 @@ module RDF_Writer
       it "yields writer given {:content_type => 'a/b'}" do
         @writer_class.format.each do |f|
           f.content_types.each_pair do |content_type, formats|
-            writer_mock = mock("writer")
-            writer_mock.should_receive(:got_here)
-            @writer_class.should_receive(:for).with(:content_type => content_type, :file_name => @basename).and_return(@writer_class)
+            writer_mock = double("writer")
+            expect(writer_mock).to receive(:got_here)
+            expect(@writer_class).to receive(:for).with(:content_type => content_type, :file_name => @basename).and_return(@writer_class)
             @writer_class.open(@basename, :content_type => content_type) do |r|
-              r.should be_a(RDF::Writer)
+              expect(r).to be_a(RDF::Writer)
               writer_mock.got_here
             end
           end
@@ -99,45 +99,44 @@ module RDF_Writer
     describe ".format" do
       it "returns itself even if given explicit format" do
         other_format = @writer_class == RDF::NTriples::Writer ? :nquads : :ntriples
-        @writer_class.for(other_format).should == @writer_class
+        expect(@writer_class.for(other_format)).to eq @writer_class
       end
     end
 
     describe ".new" do
       it "sets @output to $stdout by default" do
-        writer_mock = mock("writer")
-        writer_mock.should_receive(:got_here)
+        writer_mock = double("writer")
+        expect(writer_mock).to receive(:got_here)
         save, $stdout = $stdout, StringIO.new
 
         @writer_class.new do |r|
           writer_mock.got_here
-          r.instance_variable_get(:@output).should == $stdout
+          expect(r.instance_variable_get(:@output)).to eq $stdout
         end
         $stdout = save
       end
     
       it "sets @output to file given something other than a string" do
-        writer_mock = mock("writer")
-        writer_mock.should_receive(:got_here)
+        writer_mock = double("writer")
+        expect(writer_mock).to receive(:got_here)
         file = StringIO.new
-        file.should_receive(:write).any_number_of_times
         @writer_class.new(file) do |r|
           writer_mock.got_here
-          r.instance_variable_get(:@output).should == file
+          expect(r.instance_variable_get(:@output)).to eq file
         end
       end
     
       it "sets prefixes given :prefixes => {}" do
-        writer_mock = mock("writer")
-        writer_mock.should_receive(:got_here)
+        writer_mock = double("writer")
+        expect(writer_mock).to receive(:got_here)
         @writer_class.new(StringIO.new, :prefixes => {:a => "b"}) do |r|
           writer_mock.got_here
-          r.prefixes.should == {:a => "b"}
+          expect(r.prefixes).to eq({:a => "b"})
         end
       end
     
       #it "calls #write_prologue" do
-      #  writer_mock = mock("writer")
+      #  writer_mock = double("writer")
       #  writer_mock.should_receive(:got_here)
       #  @writer_class.any_instance.should_receive(:write_prologue)
       #  @writer_class.new(StringIO.new) do |r|
@@ -146,7 +145,7 @@ module RDF_Writer
       #end
       #
       #it "calls #write_epilogue" do
-      #  writer_mock = mock("writer")
+      #  writer_mock = double("writer")
       #  writer_mock.should_receive(:got_here)
       #  @writer_class.any_instance.should_receive(:write_epilogue)
       #  @writer_class.new(StringIO.new) do |r|
@@ -158,7 +157,7 @@ module RDF_Writer
     describe "#prefixes=" do
       it "sets prefixes from hash" do
         @writer.prefixes = {:a => "b"}
-        @writer.prefixes.should == {:a => "b"}
+        expect(@writer.prefixes).to eq({:a => "b"})
       end
     end
   
@@ -169,8 +168,8 @@ module RDF_Writer
         "foo"   => "bar",
       }.each_pair do |pfx, uri|
         it "sets prefix(#{pfx}) to #{uri}" do
-          @writer.prefix(pfx, uri).should == uri
-          @writer.prefix(pfx).should == uri
+          expect(@writer.prefix(pfx, uri)).to eq uri
+          expect(@writer.prefix(pfx)).to eq uri
         end
       end
     end