active-fedora 8.2.1 → 8.2.2

data/spec/unit/datastream_spec.rb

@@ -8,37 +8,37 @@ describe ActiveFedora::Datastream do
     @test_datastream.content = "hi there"
   end
 
-  its(:metadata?) { should be_false}
+  its(:metadata?) { should be_falsey}
 
   it "should escape dots in  to_param" do
-    @test_datastream.stub(:dsid).and_return('foo.bar')
-    @test_datastream.to_param.should == 'foo%2ebar'
+    allow(@test_datastream).to receive(:dsid).and_return('foo.bar')
+    expect(@test_datastream.to_param).to eq('foo%2ebar')
   end
   
   it "should be inspectable" do
-    @test_datastream.inspect.should match /#<ActiveFedora::Datastream @pid=\"\" @dsid=\"abcd\" @controlGroup=\"M\" changed=\"true\" @mimeType=\"\" >/
+    expect(@test_datastream.inspect).to match /#<ActiveFedora::Datastream @pid=\"\" @dsid=\"abcd\" @controlGroup=\"M\" changed=\"true\" @mimeType=\"\" >/
   end
 
   it "should have mimeType accessors" do
     ds1 = ActiveFedora::Datastream.new
     ds1.mimeType = "text/foo"
-    ds1.mimeType.should == "text/foo"
+    expect(ds1.mimeType).to eq("text/foo")
     ds2 = ActiveFedora::Datastream.new
     ds2.mimeType = "text/bar"
-    ds2.mimeType.should == "text/bar"
+    expect(ds2.mimeType).to eq("text/bar")
   end
 
   describe "#generate_dsid" do
     subject {ActiveFedora::Datastream.new(@test_object.inner_object) }
     let(:digital_object) { double(datastreams: {})}
     it "should create an autoincrementing dsid" do
-      subject.send(:generate_dsid, digital_object, 'FOO').should == 'FOO1'
+      expect(subject.send(:generate_dsid, digital_object, 'FOO')).to eq('FOO1')
     end
 
     describe "when some datastreams exist" do
       let(:digital_object) { double(datastreams: {'FOO56' => double})}
       it "should start from the highest existing dsid" do
-        subject.send(:generate_dsid, digital_object, 'FOO').should == 'FOO57'
+        expect(subject.send(:generate_dsid, digital_object, 'FOO')).to eq('FOO57')
       end
     end
   end
@@ -71,13 +71,13 @@ describe ActiveFedora::Datastream do
       EOS
 
       mock_repo = Rubydora::Repository.new
-      @test_object.inner_object.stub(:repository).and_return(mock_repo)
-      mock_repo.api.should_receive(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return(ds_profile)
-      @test_datastream.size.should == 9999
+      allow(@test_object.inner_object).to receive(:repository).and_return(mock_repo)
+      expect(mock_repo.api).to receive(:datastream).with(:dsid => 'abcd', :pid => @test_object.pid).and_return(ds_profile)
+      expect(@test_datastream.size).to eq(9999)
     end
 
     it "should default to an empty string if ds has not been saved" do
-      @test_datastream.size.should be_nil
+      expect(@test_datastream.size).to be_nil
     end
   end
 end

data/spec/unit/datastreams_spec.rb

@@ -12,15 +12,15 @@ describe ActiveFedora::Datastreams do
     end
 
     it "should have a ds_specs entry" do
-      FooHistory.ds_specs.should have_key('dsid')
+      expect(FooHistory.ds_specs).to have_key('dsid')
     end
 
     it "should have reasonable defaults" do
-      FooHistory.ds_specs['dsid'].should include(:autocreate => false)
+      expect(FooHistory.ds_specs['dsid']).to include(:autocreate => false)
     end
 
     it "should let you override defaults" do
-      FooHistory.ds_specs['complex_ds'].should include(:versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z')
+      expect(FooHistory.ds_specs['complex_ds']).to include(:versionable => true, :autocreate => true, :type => 'Z', :label => 'My Label', :control_group => 'Z')
     end
 
     it "should raise an error if you don't give a type" do
@@ -43,8 +43,8 @@ describe ActiveFedora::Datastreams do
     end
 
     it "should have reasonable defaults" do
-      FooHistory.ds_specs['dsid'].should include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
-      FooHistory.ds_specs['another'].should include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
+      expect(FooHistory.ds_specs['dsid']).to include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
+      expect(FooHistory.ds_specs['another']).to include(:type => ActiveFedora::Datastream, :label => 'File Datastream', :control_group => 'M')
     end
   end
 
@@ -53,9 +53,9 @@ describe ActiveFedora::Datastreams do
       m1 = double()
       m2 = double()
 
-      m1.should_receive(:serialize!)
-      m2.should_receive(:serialize!)
-       subject.stub(:datastreams => { :m1 => m1, :m2 => m2})
+      expect(m1).to receive(:serialize!)
+      expect(m2).to receive(:serialize!)
+       allow(subject).to receive_messages(:datastreams => { :m1 => m1, :m2 => m2})
        subject.serialize_datastreams
     end
   end
@@ -65,62 +65,62 @@ describe ActiveFedora::Datastreams do
       
       mock_specs = {'e' => { :disseminator => 'xyz' }}
       mock_ds = double(:controlGroup => 'E')
-      ActiveFedora::Base.stub(:ds_specs => mock_specs)
-      ActiveFedora.stub(:config_for_environment => { :url => 'http://localhost'})
-      subject.stub(:pid => 'test:1', :datastreams => {'e' => mock_ds})
-      mock_ds.should_receive(:dsLocation=).with("http://localhost/objects/test:1/methods/xyz")
+      allow(ActiveFedora::Base).to receive_messages(:ds_specs => mock_specs)
+      allow(ActiveFedora).to receive_messages(:config_for_environment => { :url => 'http://localhost'})
+      allow(subject).to receive_messages(:pid => 'test:1', :datastreams => {'e' => mock_ds})
+      expect(mock_ds).to receive(:dsLocation=).with("http://localhost/objects/test:1/methods/xyz")
       subject.add_disseminator_location_to_datastreams
     end
   end
 
   describe ".name_for_dsid" do
     it "should use the name" do
-      ActiveFedora::Base.send(:name_for_dsid, 'abc').should == 'abc'
+      expect(ActiveFedora::Base.send(:name_for_dsid, 'abc')).to eq('abc')
     end
 
     it "should use the name" do
-      ActiveFedora::Base.send(:name_for_dsid, 'ARCHIVAL_XML').should == 'ARCHIVAL_XML'
+      expect(ActiveFedora::Base.send(:name_for_dsid, 'ARCHIVAL_XML')).to eq('ARCHIVAL_XML')
     end
 
     it "should use the name" do
-      ActiveFedora::Base.send(:name_for_dsid, 'descMetadata').should == 'descMetadata'
+      expect(ActiveFedora::Base.send(:name_for_dsid, 'descMetadata')).to eq('descMetadata')
     end
 
     it "should hash-erize underscores" do
-      ActiveFedora::Base.send(:name_for_dsid, 'a-b').should == 'a_b'
+      expect(ActiveFedora::Base.send(:name_for_dsid, 'a-b')).to eq('a_b')
     end
   end
  
   describe "#datastreams" do
     it "should return the datastream hash proxy" do
-      subject.stub(:load_datastreams)
-      subject.datastreams.should be_a_kind_of(ActiveFedora::DatastreamHash)
+      allow(subject).to receive(:load_datastreams)
+      expect(subject.datastreams).to be_a_kind_of(ActiveFedora::DatastreamHash)
     end
     
     it "should round-trip to/from YAML" do
-      YAML.load(subject.datastreams.to_yaml).inspect.should == subject.datastreams.inspect
+      expect(YAML.load(subject.datastreams.to_yaml).inspect).to eq(subject.datastreams.inspect)
     end
   end
 
   describe "#configure_datastream" do
     it "should look up the ds_spec" do
       mock_dsspec = { :type => nil }
-      subject.stub(:ds_specs => {'abc' => mock_dsspec})
+      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
       subject.configure_datastream(double(:dsid => 'abc'))
     end
 
     it "should be ok if there is no ds spec" do
       mock_dsspec = double()
-      subject.stub(:ds_specs => {})
+      allow(subject).to receive_messages(:ds_specs => {})
       subject.configure_datastream(double(:dsid => 'abc'))
     end
 
     it "should configure RelsExtDatastream" do
       mock_dsspec = { :type => ActiveFedora::RelsExtDatastream }
-      subject.stub(:ds_specs => {'abc' => mock_dsspec})
+      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
 
       ds = double(:dsid => 'abc')
-      ds.should_receive(:model=).with(subject)
+      expect(ds).to receive(:model=).with(subject)
 
       subject.configure_datastream(ds)
     end
@@ -129,7 +129,7 @@ describe ActiveFedora::Datastreams do
       ds = double(:dsid => 'abc')
       @count = 0
       mock_dsspec = { :block => lambda { |x| @count += 1 } }
-      subject.stub(:ds_specs => {'abc' => mock_dsspec})
+      allow(subject).to receive_messages(:ds_specs => {'abc' => mock_dsspec})
 
 
       expect {
@@ -140,7 +140,7 @@ describe ActiveFedora::Datastreams do
 
   describe "#datastream_from_spec" do
     it "should fetch the rubydora datastream" do
-      subject.inner_object.should_receive(:datastream_object_for).with('dsid', {}, {})
+      expect(subject.inner_object).to receive(:datastream_object_for).with('dsid', {}, {})
       subject.datastream_from_spec({}, 'dsid')
     end
   end
@@ -149,12 +149,12 @@ describe ActiveFedora::Datastreams do
     it "should add the datastream to the object" do
       ds = double(:dsid => 'Abc')
       subject.add_datastream(ds)
-      subject.datastreams['Abc'].should == ds
+      expect(subject.datastreams['Abc']).to eq(ds)
     end
 
     it "should mint a dsid" do
       ds = ActiveFedora::Datastream.new(subject.inner_object)
-      subject.add_datastream(ds).should == 'DS1'
+      expect(subject.add_datastream(ds)).to eq('DS1')
     end
   end
 
@@ -165,24 +165,24 @@ describe ActiveFedora::Datastreams do
       ds3 = double(:metadata? => true)
       relsextds = ActiveFedora::RelsExtDatastream.new
       file_ds = double(:metadata? => false)
-      subject.stub(:datastreams => {:a => ds1, :b => ds2, :c => ds3, :d => relsextds, :e => file_ds})
-      subject.metadata_streams.should include(ds1, ds2, ds3)
-      subject.metadata_streams.should_not include(relsextds)
-      subject.metadata_streams.should_not include(file_ds)
+      allow(subject).to receive_messages(:datastreams => {:a => ds1, :b => ds2, :c => ds3, :d => relsextds, :e => file_ds})
+      expect(subject.metadata_streams).to include(ds1, ds2, ds3)
+      expect(subject.metadata_streams).not_to include(relsextds)
+      expect(subject.metadata_streams).not_to include(file_ds)
     end
   end
 
   describe "#relsext" do
     it "should be the RELS-EXT datastream" do
       m = double
-      subject.stub(:datastreams => { 'RELS-EXT' => m})
-      subject.rels_ext.should == m
+      allow(subject).to receive_messages(:datastreams => { 'RELS-EXT' => m})
+      expect(subject.rels_ext).to eq(m)
     end
 
     it "should make one up otherwise" do
-      subject.stub(:datastreams => {})
+      allow(subject).to receive_messages(:datastreams => {})
 
-      subject.rels_ext.should be_a_kind_of(ActiveFedora::RelsExtDatastream)
+      expect(subject.rels_ext).to be_a_kind_of(ActiveFedora::RelsExtDatastream)
     end
   end
 
@@ -193,7 +193,7 @@ describe ActiveFedora::Datastreams do
   describe "#create_datastream" do
     it "should mint a DSID" do
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {})
-      ds.dsid.should == 'DS1'
+      expect(ds.dsid).to eq('DS1')
     end
 
     it "should raise an argument error if the supplied dsid is nonsense" do
@@ -203,19 +203,19 @@ describe ActiveFedora::Datastreams do
     it "should try to get a mime type from the blob" do
       mock_file = double(:content_type => 'x-application/asdf')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      ds.mimeType.should == 'x-application/asdf'
+      expect(ds.mimeType).to eq('x-application/asdf')
     end
 
     it "should provide a default mime type" do
       mock_file = double()
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      ds.mimeType.should == 'application/octet-stream'
+      expect(ds.mimeType).to eq('application/octet-stream')
     end
 
     it "should use the filename as a default label" do
       mock_file = double(:path => '/asdf/fdsa')
       ds = subject.create_datastream(ActiveFedora::Datastream, nil, {:blob => mock_file})
-      ds.dsLabel.should == 'fdsa'
+      expect(ds.dsLabel).to eq('fdsa')
     end
 
     it "should not set content for controlGroup 'E'" do

data/spec/unit/file_configurator_spec.rb

@@ -23,7 +23,7 @@ describe ActiveFedora::FileConfigurator do
       subject.reset!
     end
     it "should be an empty hash" do
-      subject.config_options.should == {}
+      expect(subject.config_options).to eq({})
     end
   end
 
@@ -32,7 +32,7 @@ describe ActiveFedora::FileConfigurator do
       subject.reset!
     end
     it "should trigger configuration to load" do
-      subject.should_receive(:load_fedora_config)
+      expect(subject).to receive(:load_fedora_config)
       subject.fedora_config
     end 
   end
@@ -41,7 +41,7 @@ describe ActiveFedora::FileConfigurator do
       subject.reset!
     end
     it "should trigger configuration to load" do
-      subject.should_receive(:load_solr_config)
+      expect(subject).to receive(:load_solr_config)
       subject.solr_config
     end 
   end
@@ -49,13 +49,13 @@ describe ActiveFedora::FileConfigurator do
   describe "#reset!" do
     before { subject.reset! }
     it "should clear @fedora_config" do
-      subject.instance_variable_get(:@fedora_config).should == {} 
+      expect(subject.instance_variable_get(:@fedora_config)).to eq({}) 
     end
     it "should clear @solr_config" do
-      subject.instance_variable_get(:@solr_config).should == {} 
+      expect(subject.instance_variable_get(:@solr_config)).to eq({}) 
     end
     it "should clear @config_options" do
-      subject.instance_variable_get(:@config_options).should == {}
+      expect(subject.instance_variable_get(:@config_options)).to eq({})
     end
   end
 
@@ -63,87 +63,87 @@ describe ActiveFedora::FileConfigurator do
     
     describe "get_config_path(:fedora)" do
       it "should use the config_options[:config_path] if it exists" do
-        subject.should_receive(:config_options).and_return({:fedora_config_path => "/path/to/fedora.yml"})
-        File.should_receive(:file?).with("/path/to/fedora.yml").and_return(true)
-        subject.get_config_path(:fedora).should eql("/path/to/fedora.yml")
+        expect(subject).to receive(:config_options).and_return({:fedora_config_path => "/path/to/fedora.yml"})
+        expect(File).to receive(:file?).with("/path/to/fedora.yml").and_return(true)
+        expect(subject.get_config_path(:fedora)).to eql("/path/to/fedora.yml")
       end
 
       it "should look in Rails.root/config/fedora.yml if it exists and no fedora_config_path passed in" do
-        subject.should_receive(:config_options).and_return({})
+        expect(subject).to receive(:config_options).and_return({})
         stub_rails(:root => "/rails/root")
-        File.should_receive(:file?).with("/rails/root/config/fedora.yml").and_return(true)
-        subject.get_config_path(:fedora).should eql("/rails/root/config/fedora.yml")
+        expect(File).to receive(:file?).with("/rails/root/config/fedora.yml").and_return(true)
+        expect(subject.get_config_path(:fedora)).to eql("/rails/root/config/fedora.yml")
         unstub_rails
       end
 
       it "should look in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
-        subject.should_receive(:config_options).and_return({})
-        Dir.stub(:getwd => "/current/working/directory")
-        File.should_receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(true)
-        subject.get_config_path(:fedora).should eql("/current/working/directory/config/fedora.yml")
+        expect(subject).to receive(:config_options).and_return({})
+        allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+        expect(File).to receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(true)
+        expect(subject.get_config_path(:fedora)).to eql("/current/working/directory/config/fedora.yml")
       end
 
       it "should return default fedora.yml that ships with active-fedora if none of the above" do
-        subject.should_receive(:config_options).and_return({})
-        Dir.should_receive(:getwd).and_return("/current/working/directory")
-        File.should_receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(false)
-        File.should_receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml'))).and_return(true)
+        expect(subject).to receive(:config_options).and_return({})
+        expect(Dir).to receive(:getwd).and_return("/current/working/directory")
+        expect(File).to receive(:file?).with("/current/working/directory/config/fedora.yml").and_return(false)
+        expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml'))).and_return(true)
         expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.")
-        subject.get_config_path(:fedora).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml')))
+        expect(subject.get_config_path(:fedora)).to eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','fedora.yml')))
       end
     end
 
     describe "get_config_path(:predicate_mappings)" do
       it "should use the config_options[:config_path] if it exists" do
-        subject.should_receive(:config_options).and_return({:predicate_mappings_config_path => "/path/to/predicate_mappings.yml"})
-        File.should_receive(:file?).with("/path/to/predicate_mappings.yml").and_return(true)
-        subject.get_config_path(:predicate_mappings).should eql("/path/to/predicate_mappings.yml")
+        expect(subject).to receive(:config_options).and_return({:predicate_mappings_config_path => "/path/to/predicate_mappings.yml"})
+        expect(File).to receive(:file?).with("/path/to/predicate_mappings.yml").and_return(true)
+        expect(subject.get_config_path(:predicate_mappings)).to eql("/path/to/predicate_mappings.yml")
       end
 
       it "should look in Rails.root/config/predicate_mappings.yml if it exists and no predicate_mappings_config_path passed in" do
-        subject.should_receive(:config_options).and_return({})
+        expect(subject).to receive(:config_options).and_return({})
         stub_rails(:root => "/rails/root")
-        File.should_receive(:file?).with("/rails/root/config/predicate_mappings.yml").and_return(true)
-        subject.get_config_path(:predicate_mappings).should eql("/rails/root/config/predicate_mappings.yml")
+        expect(File).to receive(:file?).with("/rails/root/config/predicate_mappings.yml").and_return(true)
+        expect(subject.get_config_path(:predicate_mappings)).to eql("/rails/root/config/predicate_mappings.yml")
         unstub_rails
       end
 
       it "should look in ./config/predicate_mappings.yml if neither rails.root nor :predicate_mappings_config_path are set" do
-        subject.should_receive(:config_options).and_return({})
-        Dir.stub(:getwd => "/current/working/directory")
-        File.should_receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(true)
-        subject.get_config_path(:predicate_mappings).should eql("/current/working/directory/config/predicate_mappings.yml")
+        expect(subject).to receive(:config_options).and_return({})
+        allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+        expect(File).to receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(true)
+        expect(subject.get_config_path(:predicate_mappings)).to eql("/current/working/directory/config/predicate_mappings.yml")
       end
 
       it "should return default predicate_mappings.yml that ships with active-fedora if none of the above" do
-        subject.should_receive(:config_options).and_return({})
-        Dir.should_receive(:getwd).and_return("/current/working/directory")
-        File.should_receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(false)
-        File.should_receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','predicate_mappings.yml'))).and_return(true)
+        expect(subject).to receive(:config_options).and_return({})
+        expect(Dir).to receive(:getwd).and_return("/current/working/directory")
+        expect(File).to receive(:file?).with("/current/working/directory/config/predicate_mappings.yml").and_return(false)
+        expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','predicate_mappings.yml'))).and_return(true)
         expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default predicate_mappings.yml that comes with active-fedora.  If you want to override this, pass the path to predicate_mappings.yml to ActiveFedora - ie. ActiveFedora.init(:predicate_mappings_config_path => '/path/to/predicate_mappings.yml') - or set Rails.root and put predicate_mappings.yml into \#{Rails.root}/config.")
-        subject.get_config_path(:predicate_mappings).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','predicate_mappings.yml')))
+        expect(subject.get_config_path(:predicate_mappings)).to eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','predicate_mappings.yml')))
       end
     end
 
     describe "get_config_path(:solr)" do
       it "should return the solr_config_path if set in config_options hash" do
-        subject.stub(:config_options => {:solr_config_path => "/path/to/solr.yml"})
-        File.should_receive(:file?).with("/path/to/solr.yml").and_return(true)
-        subject.get_config_path(:solr).should eql("/path/to/solr.yml")
+        allow(subject).to receive_messages(:config_options => {:solr_config_path => "/path/to/solr.yml"})
+        expect(File).to receive(:file?).with("/path/to/solr.yml").and_return(true)
+        expect(subject.get_config_path(:solr)).to eql("/path/to/solr.yml")
       end
       
       it "should return the solr.yml file in the same directory as the fedora.yml if it exists" do
-        subject.should_receive(:path).and_return("/path/to/fedora/config/fedora.yml")
-        File.should_receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(true)
-        subject.get_config_path(:solr).should eql("/path/to/fedora/config/solr.yml")
+        expect(subject).to receive(:path).and_return("/path/to/fedora/config/fedora.yml")
+        expect(File).to receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(true)
+        expect(subject.get_config_path(:solr)).to eql("/path/to/fedora/config/solr.yml")
       end
       
       context "no solr.yml in same directory as fedora.yml and fedora.yml does not contain solr url" do
 
         before :each do
-          subject.stub(:config_options => {})
-          subject.should_receive(:path).and_return("/path/to/fedora/config/fedora.yml")
-          File.should_receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(false)
+          allow(subject).to receive_messages(:config_options => {})
+          expect(subject).to receive(:path).and_return("/path/to/fedora/config/fedora.yml")
+          expect(File).to receive(:file?).with("/path/to/fedora/config/solr.yml").and_return(false)
         end
         after :each do
           unstub_rails
@@ -151,22 +151,22 @@ describe ActiveFedora::FileConfigurator do
 
         it "should not raise an error if there is not a solr.yml in the same directory as the fedora.yml and the fedora.yml has a solr url defined and look in rails.root" do
           stub_rails(:root=>"/rails/root")
-          File.should_receive(:file?).with("/rails/root/config/solr.yml").and_return(true)
-          subject.get_config_path(:solr).should eql("/rails/root/config/solr.yml")
+          expect(File).to receive(:file?).with("/rails/root/config/solr.yml").and_return(true)
+          expect(subject.get_config_path(:solr)).to eql("/rails/root/config/solr.yml")
         end
 
         it "should look in ./config/solr.yml if no rails root" do
-          Dir.stub(:getwd => "/current/working/directory")
-          File.should_receive(:file?).with("/current/working/directory/config/solr.yml").and_return(true)
-          subject.get_config_path(:solr).should eql("/current/working/directory/config/solr.yml")
+          allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+          expect(File).to receive(:file?).with("/current/working/directory/config/solr.yml").and_return(true)
+          expect(subject.get_config_path(:solr)).to eql("/current/working/directory/config/solr.yml")
         end
 
         it "should return the default solr.yml file that ships with active-fedora if no other option is set" do
-          Dir.stub(:getwd => "/current/working/directory")
-          File.should_receive(:file?).with("/current/working/directory/config/solr.yml").and_return(false)
-          File.should_receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml'))).and_return(true)
+          allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+          expect(File).to receive(:file?).with("/current/working/directory/config/solr.yml").and_return(false)
+          expect(File).to receive(:file?).with(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml'))).and_return(true)
           expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default solr.yml that comes with active-fedora.  If you want to override this, pass the path to solr.yml to ActiveFedora - ie. ActiveFedora.init(:solr_config_path => '/path/to/solr.yml') - or set Rails.root and put solr.yml into \#{Rails.root}/config.")
-          subject.get_config_path(:solr).should eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml')))
+          expect(subject.get_config_path(:solr)).to eql(File.expand_path(File.join(File.dirname("__FILE__"),'config','solr.yml')))
         end
       end
 
@@ -177,30 +177,30 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in fedora_config_path" do
-        subject.stub(:load_solrizer_config)
-        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        subject.should_receive(:load_solr_config)
-        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
-        subject.load_fedora_config.should == {:url=>"http://myfedora:8080"}
-        subject.fedora_config.should == {:url=>"http://myfedora:8080"}
+        allow(subject).to receive(:load_solrizer_config)
+        expect(subject).to receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(subject).to receive(:load_solr_config)
+        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n url: http://devfedora:8983\ntest:\n  url: http://myfedora:8080")
+        expect(subject.load_fedora_config).to eq({:url=>"http://myfedora:8080"})
+        expect(subject.fedora_config).to eq({:url=>"http://myfedora:8080"})
       end
 
       it "should allow sharding" do
-        subject.stub(:load_solrizer_config)
-        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        subject.should_receive(:load_solr_config)
-        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
-        subject.load_fedora_config.should == [{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}]
-        subject.fedora_config.should == [{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}]
+        allow(subject).to receive(:load_solrizer_config)
+        expect(subject).to receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(subject).to receive(:load_solr_config)
+        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:8983\ntest:\n- url: http://myfedora:8080\n- url: http://myfedora:8081")
+        expect(subject.load_fedora_config).to eq([{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}])
+        expect(subject.fedora_config).to eq([{:url=>"http://myfedora:8080"}, {:url=>"http://myfedora:8081"}])
       end
 
       it "should parse the file using ERb" do
-        subject.stub(:load_solrizer_config)
-        subject.should_receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        subject.should_receive(:load_solr_config)
-        IO.should_receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
-        subject.load_fedora_config.should == {:url=>"http://myfedora:8081"}
-        subject.fedora_config.should == {:url=>"http://myfedora:8081"}
+        allow(subject).to receive(:load_solrizer_config)
+        expect(subject).to receive(:get_config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(subject).to receive(:load_solr_config)
+        expect(IO).to receive(:read).with("/path/to/fedora.yml").and_return("development:\n  url: http://devfedora:<%= 8983 %>\ntest:\n  url: http://myfedora:<%= 8081 %>")
+        expect(subject.load_fedora_config).to eq({:url=>"http://myfedora:8081"})
+        expect(subject.fedora_config).to eq({:url=>"http://myfedora:8081"})
       end
     end
 
@@ -209,21 +209,21 @@ describe ActiveFedora::FileConfigurator do
         subject.reset!
       end
       it "should load the file specified in solr_config_path" do
-        subject.stub(:load_solrizer_config)
-        subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
-        subject.should_receive(:load_fedora_config)
-        IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
-        subject.load_solr_config.should == {:url=>"http://mysolr:8080"}
-        subject.solr_config.should == {:url=>"http://mysolr:8080"}
+        allow(subject).to receive(:load_solrizer_config)
+        expect(subject).to receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
+        expect(subject).to receive(:load_fedora_config)
+        expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:8983\ntest:\n  default:\n    url: http://mysolr:8080")
+        expect(subject.load_solr_config).to eq({:url=>"http://mysolr:8080"})
+        expect(subject.solr_config).to eq({:url=>"http://mysolr:8080"})
       end
 
       it "should parse the file using ERb" do
-        subject.stub(:load_solrizer_config)
-        subject.should_receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
-        subject.should_receive(:load_fedora_config)
-        IO.should_receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
-        subject.load_solr_config.should == {:url=>"http://mysolr:8081"}
-        subject.solr_config.should == {:url=>"http://mysolr:8081"}
+        allow(subject).to receive(:load_solrizer_config)
+        expect(subject).to receive(:get_config_path).with(:solr).and_return("/path/to/solr.yml")
+        expect(subject).to receive(:load_fedora_config)
+        expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("development:\n  default:\n    url: http://devsolr:<%= 8983 %>\ntest:\n  default:\n    url: http://mysolr:<%= 8081 %>")
+        expect(subject.load_solr_config).to eq({:url=>"http://mysolr:8081"})
+        expect(subject.solr_config).to eq({:url=>"http://mysolr:8081"})
       end
     end
 
@@ -233,9 +233,9 @@ describe ActiveFedora::FileConfigurator do
           subject.instance_variable_set :@config_loaded, nil
         end
         it "should load the fedora and solr configs" do
-          subject.config_loaded?.should be_false
+          expect(subject.config_loaded?).to be_falsey
           subject.load_configs
-          subject.config_loaded?.should be_true
+          expect(subject.config_loaded?).to be_truthy
         end
       end
       describe "when config is loaded" do
@@ -243,24 +243,24 @@ describe ActiveFedora::FileConfigurator do
           subject.instance_variable_set :@config_loaded, true
         end
         it "should load the fedora and solr configs" do
-          subject.should_receive(:load_config).never
-          subject.config_loaded?.should be_true
+          expect(subject).to receive(:load_config).never
+          expect(subject.config_loaded?).to be_truthy
           subject.load_configs
-          subject.config_loaded?.should be_true
+          expect(subject.config_loaded?).to be_truthy
         end
       end
     end
 
     describe "check_fedora_path_for_solr" do
       it "should find the solr.yml file and return it if it exists" do
-        subject.should_receive(:path).and_return("/path/to/fedora/fedora.yml")
-        File.should_receive(:file?).with("/path/to/fedora/solr.yml").and_return(true)
-        subject.check_fedora_path_for_solr.should == "/path/to/fedora/solr.yml"
+        expect(subject).to receive(:path).and_return("/path/to/fedora/fedora.yml")
+        expect(File).to receive(:file?).with("/path/to/fedora/solr.yml").and_return(true)
+        expect(subject.check_fedora_path_for_solr).to eq("/path/to/fedora/solr.yml")
       end
       it "should return nil if the solr.yml file is not there" do
-        subject.should_receive(:path).and_return("/path/to/fedora/fedora.yml")
-        File.should_receive(:file?).with("/path/to/fedora/solr.yml").and_return(false)
-        subject.check_fedora_path_for_solr.should be_nil
+        expect(subject).to receive(:path).and_return("/path/to/fedora/fedora.yml")
+        expect(File).to receive(:file?).with("/path/to/fedora/solr.yml").and_return(false)
+        expect(subject.check_fedora_path_for_solr).to be_nil
       end
     end
   end
@@ -280,29 +280,29 @@ describe ActiveFedora::FileConfigurator do
   
     it "can tell its config paths" do
       subject.init
-      subject.should respond_to(:solr_config_path)
+      expect(subject).to respond_to(:solr_config_path)
     end
     it "loads a config from the current working directory as a second choice" do
-      subject.stub(:load_solrizer_config)
-      Dir.stub(:getwd).and_return(@fake_rails_root)
+      allow(subject).to receive(:load_solrizer_config)
+      allow(Dir).to receive(:getwd).and_return(@fake_rails_root)
       subject.init
-      subject.get_config_path(:fedora).should eql("#{@fake_rails_root}/config/fedora.yml")
-      subject.solr_config_path.should eql("#{@fake_rails_root}/config/solr.yml")
+      expect(subject.get_config_path(:fedora)).to eql("#{@fake_rails_root}/config/fedora.yml")
+      expect(subject.solr_config_path).to eql("#{@fake_rails_root}/config/solr.yml")
     end
     it "loads the config that ships with this gem as a last choice" do
-      Dir.stub(:getwd).and_return("/fake/path")
-      subject.stub(:load_solrizer_config)
+      allow(Dir).to receive(:getwd).and_return("/fake/path")
+      allow(subject).to receive(:load_solrizer_config)
       expect(ActiveFedora::Base.logger).to receive(:warn).with("Using the default fedora.yml that comes with active-fedora.  If you want to override this, pass the path to fedora.yml to ActiveFedora - ie. ActiveFedora.init(:fedora_config_path => '/path/to/fedora.yml') - or set Rails.root and put fedora.yml into \#{Rails.root}/config.").exactly(3).times
       subject.init
       expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
-      subject.get_config_path(:fedora).should eql(expected_config+'/fedora.yml')
-      subject.solr_config_path.should eql(expected_config+'/solr.yml')
+      expect(subject.get_config_path(:fedora)).to eql(expected_config+'/fedora.yml')
+      expect(subject.solr_config_path).to eql(expected_config+'/solr.yml')
     end
     it "raises an error if you pass in a string" do
-      lambda{ subject.init("#{@fake_rails_root}/config/fake_fedora.yml") }.should raise_exception(ArgumentError)
+      expect{ subject.init("#{@fake_rails_root}/config/fake_fedora.yml") }.to raise_exception(ArgumentError)
     end
     it "raises an error if you pass in a non-existant config file" do
-      lambda{ subject.init(:fedora_config_path=>"really_fake_fedora.yml") }.should raise_exception(ActiveFedora::ConfigurationError)
+      expect{ subject.init(:fedora_config_path=>"really_fake_fedora.yml") }.to raise_exception(ActiveFedora::ConfigurationError)
     end
     
     describe "within Rails" do
@@ -315,16 +315,16 @@ describe ActiveFedora::FileConfigurator do
       end
       
       it "loads a config from Rails.root as a first choice" do
-        subject.stub(:load_solrizer_config)
+        allow(subject).to receive(:load_solrizer_config)
         subject.init
-        subject.get_config_path(:fedora).should eql("#{Rails.root}/config/fedora.yml")
-        subject.solr_config_path.should eql("#{Rails.root}/config/solr.yml")
+        expect(subject.get_config_path(:fedora)).to eql("#{Rails.root}/config/fedora.yml")
+        expect(subject.solr_config_path).to eql("#{Rails.root}/config/solr.yml")
       end
       
       it "can tell what environment it is set to run in" do
         stub_rails(:env=>"development")
         subject.init
-        ActiveFedora.environment.should eql("development")
+        expect(ActiveFedora.environment).to eql("development")
       end
       
     end
@@ -334,7 +334,7 @@ describe ActiveFedora::FileConfigurator do
   
   describe ".build_predicate_config_path" do
     it "should return the path to the default config/predicate_mappings.yml if no valid path is given" do
-      subject.send(:build_predicate_config_path).should == default_predicate_mapping_file
+      expect(subject.send(:build_predicate_config_path)).to eq(default_predicate_mapping_file)
     end
   end
 
@@ -343,29 +343,29 @@ describe ActiveFedora::FileConfigurator do
       subject.instance_variable_set :@config_loaded, nil
     end
     it "should return the default mapping if it has not been initialized" do
-      subject.predicate_config().should == Psych.load(File.read(default_predicate_mapping_file))
+      expect(subject.predicate_config()).to eq(Psych.load(File.read(default_predicate_mapping_file)))
     end
   end
 
   describe ".valid_predicate_mapping" do
     it "should return true if the predicate mapping has the appropriate keys and value types" do
-      subject.send(:valid_predicate_mapping?,default_predicate_mapping_file).should be_true
+      expect(subject.send(:valid_predicate_mapping?,default_predicate_mapping_file)).to be_truthy
     end
     it "should return false if the mapping is missing the :default_namespace" do
       mock_yaml({:default_namespace0=>"my_namespace",:predicate_mapping=>{:key0=>"value0", :key1=>"value1"}},"/path/to/predicate_mappings.yml")
-      subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml").should be_false
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
     end
     it "should return false if the :default_namespace is not a string" do
       mock_yaml({:default_namespace=>{:foo=>"bar"}, :predicate_mapping=>{:key0=>"value0", :key1=>"value1"}},"/path/to/predicate_mappings.yml")
-      subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml").should be_false
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
     end
     it "should return false if the :predicate_mappings key is missing" do
       mock_yaml({:default_namespace=>"a string"},"/path/to/predicate_mappings.yml")
-      subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml").should be_false
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
     end
     it "should return false if the :predicate_mappings key is not a hash" do
       mock_yaml({:default_namespace=>"a string",:predicate_mapping=>"another string"},"/path/to/predicate_mappings.yml")
-      subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml").should be_false
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
     end
 
   end