active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/builder/has_and_belongs_to_many_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe ActiveFedora::Associations::Builder::HasAndBelongsToMany do
   describe "valid_options" do
     subject { ActiveFedora::Associations::Builder::HasAndBelongsToMany.valid_options }
-    it { is_expected.to eq [:class_name, :property, :before_add, :after_add, :before_remove, :after_remove, 
-                    :inverse_of, :solr_page_size, :autosave] }
+    it { should eq [:class_name, :predicate, :before_add, :after_add, :before_remove,
+                    :after_remove, :inverse_of, :solr_page_size, :autosave] }
   end
 end

data/spec/unit/callback_spec.rb

@@ -1,7 +1,12 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  before :all do
+  before :each do
+    begin 
+      ActiveFedora::Base.find('test:123').delete
+    rescue
+    end
+
     class CallbackStub < ActiveFedora::Base
       has_metadata :type=>ActiveFedora::SimpleDatastream, :name=>"someData" do |m|
         m.field "fubar", :string
@@ -25,31 +30,41 @@ describe ActiveFedora::Base do
       end
     end
   end
-  after :all do
+  after :each do
+    @cb.destroy if @cb && @cb.persisted?# this only is called if the test failed to run all the way through.
     Object.send(:remove_const, :CallbackStub)
   end
 
   it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
-    expect_any_instance_of(CallbackStub).to receive(:a_init)
-    expect_any_instance_of(CallbackStub).to receive :b_create
-    expect_any_instance_of(CallbackStub).to receive :a_create
-    expect_any_instance_of(CallbackStub).to receive(:b_save)
-    expect_any_instance_of(CallbackStub).to receive(:a_save)
-    cb = CallbackStub.new :pid => 'test:123'
-    cb.save
-end
- it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
-    expect_any_instance_of(CallbackStub).to receive(:a_init)
-    expect_any_instance_of(CallbackStub).to receive(:b_save)
-    expect_any_instance_of(CallbackStub).to receive(:a_save)
-    expect_any_instance_of(CallbackStub).to receive(:a_find)
-    expect_any_instance_of(CallbackStub).to receive(:b_update)
-    expect_any_instance_of(CallbackStub).to receive(:a_update)
-    expect_any_instance_of(CallbackStub).to receive(:do_stuff)
-
-    cb2 = CallbackStub.find('test:123')
-    cb2.save
-
-    cb2.destroy
+    allow_any_instance_of(CallbackStub).to receive(:a_init)
+    allow_any_instance_of(CallbackStub).to receive :b_create
+    allow_any_instance_of(CallbackStub).to receive :a_create
+    allow_any_instance_of(CallbackStub).to receive(:b_save)
+    allow_any_instance_of(CallbackStub).to receive(:a_save)
+    @cb = CallbackStub.new 'test:123'
+    @cb.save
+  end
+
+  it "Should have after_initialize, before_save,after_save, before_create, after_create, after_update, before_update, before_destroy" do
+    allow_any_instance_of(CallbackStub).to receive(:a_init)
+    allow_any_instance_of(CallbackStub).to receive(:b_create)
+    allow_any_instance_of(CallbackStub).to receive(:a_create)
+    allow_any_instance_of(CallbackStub).to receive(:b_save)
+    allow_any_instance_of(CallbackStub).to receive(:a_save)
+    @cb = CallbackStub.new 'test:123'
+    @cb.save
+    allow_any_instance_of(CallbackStub).to receive(:a_init)
+    allow_any_instance_of(CallbackStub).to receive(:b_save)
+    allow_any_instance_of(CallbackStub).to receive(:a_save)
+    allow_any_instance_of(CallbackStub).to receive(:a_find)
+    allow_any_instance_of(CallbackStub).to receive(:b_update)
+    allow_any_instance_of(CallbackStub).to receive(:a_update)
+    allow_any_instance_of(CallbackStub).to receive(:do_stuff)
+
+    @cb = CallbackStub.find('test:123')
+    @cb.save!
+
+    @cb.destroy
+
   end
 end

data/spec/unit/change_set_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe ActiveFedora::ChangeSet do
+  let(:change_set) { described_class.new(base, base.resource, base.changed_attributes.keys) }
+  subject { change_set }
+
+  context "with an unchanged object" do
+    let(:base) { ActiveFedora::Base.new }
+
+    it { is_expected.to be_empty }
+  end
+
+  context "with a changed object" do
+    before do
+      class Library < ActiveFedora::Base
+      end
+
+      class Book < ActiveFedora::Base
+        belongs_to :library, predicate: ActiveFedora::RDF::RelsExt.hasConstituent
+        property :title, predicate: ::RDF::DC.title
+      end
+
+      base.library_id = 'foo'
+      base.title = ['bar']
+    end
+    after do
+      Object.send(:remove_const, :Library)
+      Object.send(:remove_const, :Book)
+    end
+
+    let(:base) { Book.create }
+
+
+    describe "#changes" do
+      subject { change_set.changes }
+
+      it { is_expected.to be_kind_of Hash }
+
+      it "should have two elements" do
+        expect(subject.size).to eq 2
+      end
+    end
+
+    it { is_expected.to_not be_empty }
+  end
+end

data/spec/unit/code_configurator_spec.rb

@@ -18,9 +18,9 @@ describe ActiveFedora::FileConfigurator do
       :fedora_config => { :url => 'http://codeconfig.example.edu/fedora/', :user => 'fedoraAdmin', :password => 'configurator', :cert_file => '/path/to/cert/file' },
       :solr_config => { :url => 'http://codeconfig.example.edu/solr/' },
       :predicate_config => { 
-        :default_namespace => 'info:fedora/fedora-system:def/relations-external#',
+        :default_namespace => 'http://fedora.info/definitions/v4/rels-ext#',
         :predicate_mapping => {
-          'info:fedora/fedora-system:def/relations-external#' => { :has_part => 'hasPart' } 
+          'http://fedora.info/definitions/v4/rels-ext#' => { :has_part => 'hasPart' } 
         }
       }
     }
@@ -43,9 +43,9 @@ describe ActiveFedora::FileConfigurator do
     expect(File).to receive(:read).never
     expect(File).to receive(:open).never
     ActiveFedora.init(@config_params)
-    expect(ActiveFedora.fedora_config.credentials).to eq(@config_params[:fedora_config])
-    expect(ActiveFedora.solr_config).to eq(@config_params[:solr_config])
-    expect(ActiveFedora::Predicates.predicate_mappings['info:fedora/fedora-system:def/relations-external#'].length).to eq(1)
+    expect(ActiveFedora.fedora_config.credentials).to eq @config_params[:fedora_config]
+    expect(ActiveFedora.solr_config).to eq @config_params[:solr_config]
+    expect(ActiveFedora::Predicates.predicate_mappings['http://fedora.info/definitions/v4/rels-ext#'].length).to eq 1
   end
   
 end

data/spec/unit/config_spec.rb

@@ -1,19 +1,14 @@
 require 'spec_helper'
 
 describe ActiveFedora::Config do
-  describe "with a single fedora instance" do
-    conf = Psych.load(File.read('spec/fixtures/rails_root/config/fedora.yml'))['test']
-    subject { ActiveFedora::Config.new(conf) }
-    its(:credentials) { should == {:url => 'http://testhost.com:8983/fedora', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'}}
-    it { is_expected.not_to be_sharded }
-  end
-  describe "with several fedora shards" do
-    conf = Psych.load(File.read('spec/fixtures/sharded_fedora.yml'))['test']
-    subject { ActiveFedora::Config.new(conf) }
-    its(:credentials) { should == [{:url => 'http://127.0.0.1:8983/fedora1', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'},
-                              {:url => 'http://127.0.0.1:8983/fedora2', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'},
-                              {:url => 'http://127.0.0.1:8983/fedora3', :user=> 'fedoraAdmin', :password=> 'fedoraAdmin'}]}
-    it { is_expected.to be_sharded }
-  end
+  context "with a single fedora instance" do
+    let(:yaml) { Psych.load(File.read('spec/fixtures/rails_root/config/fedora.yml'))['test'] }
+    let(:conf) { ActiveFedora::Config.new(yaml) }
 
+    describe "#credentials" do
+      subject { conf.credentials }
+      it { should eq(url: 'http://testhost.com:8983/fedora', user: 'fedoraAdmin', password: 'fedoraAdmin') }
+    end
+
+  end
 end

data/spec/unit/core_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 describe ActiveFedora::Base do
   before do
     class MyDatastream < ActiveFedora::NtriplesRDFDatastream
-      property :publisher, :predicate => RDF::DC.publisher
+      property :publisher, predicate: ::RDF::DC.publisher
     end
     class Library < ActiveFedora::Base
     end
     class Book < ActiveFedora::Base
-      belongs_to :library, property: :has_constituent
+      belongs_to :library, predicate: ActiveFedora::RDF::RelsExt.hasConstituent
       has_metadata "foo", type: ActiveFedora::SimpleDatastream do |m|
         m.field "title", :string
       end
@@ -16,15 +16,30 @@ describe ActiveFedora::Base do
       has_attributes :title, datastream: 'foo' # Om backed property
       has_attributes :publisher, datastream: 'bar' # RDF backed property
     end
-    subject.library = library
   end
+
   let (:library) { Library.create }
-  subject {Book.new(library: library, title: "War and Peace", publisher: "Random House")}
-  after do 
+  subject { Book.new(library: library, title: "War and Peace", publisher: "Random House") }
+
+  after do
     Object.send(:remove_const, :Book)
     Object.send(:remove_const, :Library)
+    Object.send(:remove_const, :MyDatastream)
+  end
+
+  it "should assert a content model" do
+    expect(subject.has_model).to eq ['Book']
   end
 
+  describe "initialize with a block" do
+    subject { Book.new { |b| b.title= "The Sun also Rises" } }
+
+    it "should have set the title" do
+      expect(subject.title).to eq "The Sun also Rises"
+    end
+  end
+
+
   describe "#freeze" do
     before { subject.freeze }
 
@@ -34,9 +49,9 @@ describe ActiveFedora::Base do
 
     it "should make the associations immutable" do
       expect {
-        subject.library_id = Library.create!.pid
+        subject.library_id = Library.create!.id
       }.to raise_error RuntimeError, "can't modify frozen Book"
-      expect(subject.library_id).to eq library.pid
+      expect(subject.library_id).to eq library.id
     end
 
     describe "when the association is set via an id" do
@@ -68,8 +83,44 @@ describe ActiveFedora::Base do
     it "should access associations" do
       f = Book.find(subject.id)
       f.freeze
-      expect(f.library_id).not_to be_nil
+      expect(f.library_id).to_not be_nil
+
+    end
+  end
+
+  describe "id_to_uri" do
+    let(:id) { '123456w' }
+    subject { ActiveFedora::Base.id_to_uri(id) }
+
+    context "with no custom proc is set" do
+      it { should eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/123456w" }
+    end
+
+    context "when custom proc is set" do
+      before do
+        ActiveFedora::Base.translate_id_to_uri = lambda { |id| "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/foo/#{id}" }
+      end
+      after { ActiveFedora::Base.translate_id_to_uri = nil }
+
+      it { should eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/foo/123456w" }
+    end
+  end
+
+  describe "uri_to_id" do
+    let(:uri) { "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/foo/123456w" }
+    subject { ActiveFedora::Base.uri_to_id(uri) }
+
+    context "with no custom proc is set" do
+      it { should eq 'foo/123456w' }
+    end
+
+    context "when custom proc is set" do
+      before do
+        ActiveFedora::Base.translate_uri_to_id = lambda { |uri| uri.to_s.split('/')[-1] }
+      end
+      after { ActiveFedora::Base.translate_uri_to_id = nil }
 
+      it { should eq '123456w' }
     end
   end
 end

data/spec/unit/file_configurator_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 require 'config_helper'
 
 describe ActiveFedora::FileConfigurator do
-  
+
   subject {ActiveFedora.configurator }
-  
+
   after :all do
     unstub_rails
     # Restore to default fedora configs
@@ -15,7 +15,7 @@ describe ActiveFedora::FileConfigurator do
     it "should trigger configuration reset (to empty defaults)" do
       expect_any_instance_of(ActiveFedora::FileConfigurator).to receive(:reset!)
       ActiveFedora::FileConfigurator.new
-    end 
+    end
   end
 
   describe "#config_options" do
@@ -34,7 +34,7 @@ describe ActiveFedora::FileConfigurator do
     it "should trigger configuration to load" do
       expect(subject).to receive(:load_fedora_config)
       subject.fedora_config
-    end 
+    end
   end
   describe "#solr_config" do
     before do
@@ -43,16 +43,16 @@ describe ActiveFedora::FileConfigurator do
     it "should trigger configuration to load" do
       expect(subject).to receive(:load_solr_config)
       subject.solr_config
-    end 
+    end
   end
 
   describe "#reset!" do
     before { subject.reset! }
     it "should clear @fedora_config" do
-      expect(subject.instance_variable_get(:@fedora_config)).to eq({}) 
+      expect(subject.instance_variable_get(:@fedora_config)).to eq({})
     end
     it "should clear @solr_config" do
-      expect(subject.instance_variable_get(:@solr_config)).to eq({}) 
+      expect(subject.instance_variable_get(:@solr_config)).to eq({})
     end
     it "should clear @config_options" do
       expect(subject.instance_variable_get(:@config_options)).to eq({})
@@ -60,7 +60,7 @@ describe ActiveFedora::FileConfigurator do
   end
 
   describe "initialization methods" do
-    
+
     describe "get_config_path(:fedora)" do
       it "should use the config_options[:config_path] if it exists" do
         expect(subject).to receive(:config_options).and_return({:fedora_config_path => "/path/to/fedora.yml"})
@@ -78,7 +78,7 @@ describe ActiveFedora::FileConfigurator do
 
       it "should look in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
         expect(subject).to receive(:config_options).and_return({})
-        allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+        allow(Dir).to receive(:getwd).and_return("/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
@@ -110,7 +110,7 @@ describe ActiveFedora::FileConfigurator do
 
       it "should look in ./config/predicate_mappings.yml if neither rails.root nor :predicate_mappings_config_path are set" do
         expect(subject).to receive(:config_options).and_return({})
-        allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+        allow(Dir).to receive(:getwd).and_return("/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
@@ -127,21 +127,21 @@ describe ActiveFedora::FileConfigurator do
 
     describe "get_config_path(:solr)" do
       it "should return the solr_config_path if set in config_options hash" do
-        allow(subject).to receive_messages(:config_options => {:solr_config_path => "/path/to/solr.yml"})
+        allow(subject).to receive(:config_options).and_return(: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
         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
-          allow(subject).to receive_messages(:config_options => {})
+          allow(subject).to receive(:config_options).and_return({})
           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
@@ -156,13 +156,13 @@ describe ActiveFedora::FileConfigurator do
         end
 
         it "should look in ./config/solr.yml if no rails root" do
-          allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+          allow(Dir).to receive(:getwd).and_return("/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
-          allow(Dir).to receive_messages(:getwd => "/current/working/directory")
+          allow(Dir).to receive(:getwd).and_return("/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.")
@@ -181,8 +181,8 @@ describe ActiveFedora::FileConfigurator do
         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"})
+        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
@@ -190,8 +190,8 @@ describe ActiveFedora::FileConfigurator do
         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"}])
+        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
@@ -199,8 +199,8 @@ describe ActiveFedora::FileConfigurator do
         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"})
+        expect(subject.load_fedora_config).to eq(:url=>"http://myfedora:8081")
+        expect(subject.fedora_config).to eq(:url=>"http://myfedora:8081")
       end
     end
 
@@ -213,8 +213,8 @@ describe ActiveFedora::FileConfigurator do
         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"})
+        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
@@ -222,8 +222,8 @@ describe ActiveFedora::FileConfigurator do
         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"})
+        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
-          expect(subject.config_loaded?).to be_falsey
+          expect(subject).to_not be_config_loaded
           subject.load_configs
-          expect(subject.config_loaded?).to be_truthy
+          expect(subject).to be_config_loaded
         end
       end
       describe "when config is loaded" do
@@ -244,9 +244,9 @@ describe ActiveFedora::FileConfigurator do
         end
         it "should load the fedora and solr configs" do
           expect(subject).to receive(:load_config).never
-          expect(subject.config_loaded?).to be_truthy
+          expect(subject).to be_config_loaded
           subject.load_configs
-          expect(subject.config_loaded?).to be_truthy
+          expect(subject).to be_config_loaded
         end
       end
     end
@@ -255,7 +255,7 @@ describe ActiveFedora::FileConfigurator do
       it "should find the solr.yml file and return it if it exists" do
         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")
+        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
         expect(subject).to receive(:path).and_return("/path/to/fedora/fedora.yml")
@@ -264,24 +264,25 @@ describe ActiveFedora::FileConfigurator do
       end
     end
   end
-  
+
   describe "setting the environment and loading configuration" do
-    
+
     before(:all) do
       @fake_rails_root = File.expand_path(File.dirname(__FILE__) + '/../fixtures/rails_root')
     end
 
-    
+
     after(:all) do
       config_file = File.join(File.dirname(__FILE__), "..", "..", "config", "fedora.yml")
       environment = "test"
       ActiveFedora.init(:environment=>environment, :fedora_config_path=>config_file)
     end
-  
+
     it "can tell its config paths" do
       subject.init
       expect(subject).to respond_to(:solr_config_path)
     end
+
     it "loads a config from the current working directory as a second choice" do
       allow(subject).to receive(:load_solrizer_config)
       allow(Dir).to receive(:getwd).and_return(@fake_rails_root)
@@ -289,6 +290,7 @@ describe ActiveFedora::FileConfigurator do
       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
       allow(Dir).to receive(:getwd).and_return("/fake/path")
       allow(subject).to receive(:load_solrizer_config)
@@ -299,42 +301,42 @@ describe ActiveFedora::FileConfigurator do
       expect(subject.solr_config_path).to eql(expected_config+'/solr.yml')
     end
     it "raises an error if you pass in a string" do
-      expect{ subject.init("#{@fake_rails_root}/config/fake_fedora.yml") }.to raise_exception(ArgumentError)
+      expect(lambda{ 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
-      expect{ subject.init(:fedora_config_path=>"really_fake_fedora.yml") }.to raise_exception(ActiveFedora::ConfigurationError)
+      expect(lambda{ subject.init(:fedora_config_path=>"really_fake_fedora.yml") }).to raise_exception(ActiveFedora::ConfigurationError)
     end
-    
+
     describe "within Rails" do
-      before(:all) do        
+      before do
         stub_rails(:root=>File.dirname(__FILE__) + '/../fixtures/rails_root')
       end
 
-      after(:all) do
+      after do
         unstub_rails
       end
-      
+
       it "loads a config from Rails.root as a first choice" do
         allow(subject).to receive(:load_solrizer_config)
         subject.init
         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
         expect(ActiveFedora.environment).to eql("development")
       end
-      
+
     end
   end
-  
+
   ##########################
-  
+
   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
-      expect(subject.send(:build_predicate_config_path)).to eq(default_predicate_mapping_file)
+      expect(subject.send(:build_predicate_config_path)).to eq default_predicate_mapping_file
     end
   end
 
@@ -343,29 +345,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
-      expect(subject.predicate_config()).to eq(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
-      expect(subject.send(:valid_predicate_mapping?,default_predicate_mapping_file)).to be_truthy
+      expect(subject.send(:valid_predicate_mapping?, default_predicate_mapping_file)).to be true
     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")
-      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
+      mock_yaml({:default_namespace0=>"my_namespace", :predicate_mapping=>{:key0=>"value0", :key1=>"value1"}},"/path/to/predicate_mappings.yml")
+      expect(subject.send(:valid_predicate_mapping?, "/path/to/predicate_mappings.yml")).to be false
     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")
-      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be false
     end
     it "should return false if the :predicate_mappings key is missing" do
       mock_yaml({:default_namespace=>"a string"},"/path/to/predicate_mappings.yml")
-      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be false
     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")
-      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be_falsey
+      expect(subject.send(:valid_predicate_mapping?,"/path/to/predicate_mappings.yml")).to be false
     end
 
   end