active-fedora 11.0.0.rc1 → 11.0.0.rc2

data/spec/unit/base_active_model_spec.rb

@@ -6,22 +6,22 @@ describe ActiveFedora::Base do
       property :fubar, predicate: ::RDF::URI('http://example.com/fubar'), multiple: false
       property :duck, predicate: ::RDF::URI('http://example.com/duck'), multiple: false
     end
-    subject { BarHistory.new }
+    subject(:history) { BarHistory.new }
 
     describe "attributes=" do
       it "sets attributes" do
-        subject.attributes = { fubar: "baz", duck: "Quack" }
-        expect(subject.fubar).to eq "baz"
-        expect(subject.duck).to eq "Quack"
+        history.attributes = { fubar: "baz", duck: "Quack" }
+        expect(history.fubar).to eq "baz"
+        expect(history.duck).to eq "Quack"
       end
     end
 
     describe "update_attributes" do
       it "sets attributes and save" do
-        subject.update_attributes(fubar: "baz", duck: "Quack")
-        subject.reload
-        expect(subject.fubar).to eq "baz"
-        expect(subject.duck).to eq "Quack"
+        history.update_attributes(fubar: "baz", duck: "Quack")
+        history.reload
+        expect(history.fubar).to eq "baz"
+        expect(history.duck).to eq "Quack"
       end
     end
   end

data/spec/unit/base_extra_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
+  subject(:object) { described_class.new }
   describe ".update_index" do
     before do
       mock_conn = double("SolrConnection")
@@ -13,20 +14,20 @@ describe ActiveFedora::Base do
     end
 
     it "makes the solr_document with to_solr and add it" do
-      expect(subject).to receive(:to_solr)
-      subject.update_index
+      expect(object).to receive(:to_solr)
+      object.update_index
     end
   end
 
   describe ".delete" do
     before do
-      allow(subject).to receive(:new_record?).and_return(false)
+      allow(object).to receive(:new_record?).and_return(false)
       allow(ActiveFedora.fedora.connection).to receive(:delete)
     end
 
     it "deletes object from repository and index" do
       expect(ActiveFedora::SolrService).to receive(:delete).with(nil)
-      subject.delete
+      object.delete
     end
   end
 

data/spec/unit/base_spec.rb

@@ -14,17 +14,17 @@ describe ActiveFedora::Base do
       Object.send(:remove_const, :FooHistory)
     end
 
-    subject { FooHistory.new(title: ["A good title"]) }
-    before { subject.id = 9 }
+    subject(:history) { FooHistory.new(title: ["A good title"]) }
+    before { history.id = 9 }
 
     it "is settable" do
-      expect(subject.id).to eq '9'
-      expect(subject.title).to eq ["A good title"]
+      expect(history.id).to eq '9'
+      expect(history.title).to eq ["A good title"]
     end
 
     it "is only settable once" do
-      expect { subject.id = 10 }.to raise_error "ID has already been set to 9"
-      expect(subject.id).to eq '9'
+      expect { history.id = 10 }.to raise_error "ID has already been set to 9"
+      expect(history.id).to eq '9'
     end
   end
 
@@ -39,14 +39,14 @@ describe ActiveFedora::Base do
       Object.send(:remove_const, :FooHistory)
     end
 
-    subject { FooHistory.new.type }
+    subject(:history) { FooHistory.new.type }
 
     it { is_expected.to eq [RDF::URI('http://example.com/foo')] }
 
     context "when type is called before propertes" do
-      subject { FooHistory.resource_class.reflect_on_property(:title) }
+      subject(:history) { FooHistory.resource_class.reflect_on_property(:title) }
       it "does not wipe out the properties" do
-        expect(subject).to be_kind_of ActiveTriples::NodeConfig
+        expect(history).to be_kind_of ActiveTriples::NodeConfig
       end
     end
   end

data/spec/unit/change_set_spec.rb

@@ -33,26 +33,26 @@ describe ActiveFedora::ChangeSet do
     let(:base) { Book.create }
 
     describe "#changes" do
-      subject { change_set.changes }
+      subject(:changes) { change_set.changes }
 
       it { is_expected.to be_kind_of Hash }
 
       it "has three elements" do
-        expect(subject.size).to eq 3
+        expect(changes.size).to eq 3
       end
       it "does not include URIs from other objects" do
         base.resource << RDF::Statement.new(RDF::URI("http://wrong.com"), RDF::Vocab::DC.title, "bad")
         base.title = nil
-        expect(subject[RDF::Vocab::DC.title].to_a).to eq []
+        expect(changes[RDF::Vocab::DC.title].to_a).to eq []
       end
       it "includes hash URIs" do
         # This is useful as an alternative to blank nodes.
         hash_uri = RDF::URI(base.uri.to_s + "#test")
         base.resource << RDF::Statement.new(hash_uri, RDF::Vocab::DC.title, "good")
         base.title = [RDF::URI(hash_uri)]
-        expect(subject[RDF::Vocab::DC.title].to_a).not_to eq []
+        expect(changes[RDF::Vocab::DC.title].to_a).not_to eq []
         # Include the title reference and the title for the hash URI
-        expect(subject[RDF::Vocab::DC.title].to_a.length).to eq 2
+        expect(changes[RDF::Vocab::DC.title].to_a.length).to eq 2
       end
     end
 

data/spec/unit/core_spec.rb

@@ -12,7 +12,7 @@ describe ActiveFedora::Base do
   end
 
   let(:library) { Library.create }
-  subject { Book.new(library: library, title: "War and Peace", publisher: "Random House") }
+  subject(:book) { Book.new(library: library, title: "War and Peace", publisher: "Random House") }
 
   after do
     Object.send(:remove_const, :Book)
@@ -20,61 +20,61 @@ describe ActiveFedora::Base do
   end
 
   it "asserts a content model" do
-    expect(subject.has_model).to eq ['Book']
+    expect(book.has_model).to eq ['Book']
   end
 
   describe "initialize with a block" do
-    subject { Book.new { |b| b.title = "The Sun also Rises" } }
+    subject(:book) { Book.new { |b| b.title = "The Sun also Rises" } }
 
     it "has set the title" do
-      expect(subject.title).to eq "The Sun also Rises"
+      expect(book.title).to eq "The Sun also Rises"
     end
   end
 
   describe "#freeze" do
-    before { subject.freeze }
+    before { book.freeze }
 
     it "is frozen" do
-      expect(subject).to be_frozen
+      expect(book).to be_frozen
     end
 
     it "makes the associations immutable" do
       expect {
-        subject.library_id = Library.create!.id
+        book.library_id = Library.create!.id
       }.to raise_error RuntimeError, "can't modify frozen Book"
-      expect(subject.library_id).to eq library.id
+      expect(book.library_id).to eq library.id
     end
 
     describe "when the association is set via an id" do
-      subject { Book.new(library_id: library.id) }
+      subject(:book) { Book.new(library_id: library.id) }
       it "is able to load the association" do
-        expect(subject.library).to eq library
+        expect(book.library).to eq library
       end
     end
 
     it "makes the properties immutable" do
       expect {
-        subject.publisher = "HEY"
+        book.publisher = "HEY"
       }.to raise_error TypeError
-      expect(subject.publisher).to eq "Random House"
+      expect(book.publisher).to eq "Random House"
     end
   end
 
   describe "an object that hasn't loaded the associations" do
-    before { subject.save! }
+    before { book.save! }
 
     it "accesses associations" do
-      f = Book.find(subject.id)
+      f = Book.find(book.id)
       f.freeze
       expect(f.library_id).to_not be_nil
     end
   end
 
   describe "#translate_id_to_uri" do
-    subject { described_class.translate_id_to_uri }
+    subject(:uri) { described_class.translate_id_to_uri }
     context "when it's not set" do
       it "is a FedoraIdTranslator" do
-        expect(subject).to eq ActiveFedora::Core::FedoraIdTranslator
+        expect(uri).to eq ActiveFedora::Core::FedoraIdTranslator
       end
     end
     context "when it's set to nil" do
@@ -82,16 +82,16 @@ describe ActiveFedora::Base do
         described_class.translate_id_to_uri = nil
       end
       it "is a FedoraIdTranslator" do
-        expect(subject).to eq ActiveFedora::Core::FedoraIdTranslator
+        expect(uri).to eq ActiveFedora::Core::FedoraIdTranslator
       end
     end
   end
 
   describe "#translate_uri_to_id" do
-    subject { described_class.translate_uri_to_id }
+    subject(:uri) { described_class.translate_uri_to_id }
     context "when it's not set" do
       it "is a FedoraUriTranslator" do
-        expect(subject).to eq ActiveFedora::Core::FedoraUriTranslator
+        expect(uri).to eq ActiveFedora::Core::FedoraUriTranslator
       end
     end
     context "when it's set to nil" do
@@ -99,14 +99,14 @@ describe ActiveFedora::Base do
         described_class.translate_uri_to_id = nil
       end
       it "is a FedoraIdTranslator" do
-        expect(subject).to eq ActiveFedora::Core::FedoraUriTranslator
+        expect(uri).to eq ActiveFedora::Core::FedoraUriTranslator
       end
     end
   end
 
   describe "id_to_uri" do
     let(:id) { '123456w' }
-    subject { described_class.id_to_uri(id) }
+    subject(:uri) { described_class.id_to_uri(id) }
 
     context "with no custom proc is set" do
       it { should eq "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/123456w" }
@@ -114,7 +114,7 @@ describe ActiveFedora::Base do
         allow(described_class).to receive(:translate_id_to_uri).and_call_original
         allow(ActiveFedora::Core::FedoraIdTranslator).to receive(:call).and_call_original
 
-        subject
+        uri
 
         expect(ActiveFedora::Core::FedoraIdTranslator).to have_received(:call).with(id)
       end
@@ -132,21 +132,21 @@ describe ActiveFedora::Base do
     context "with an empty base path" do
       it "produces a valid URI" do
         allow(ActiveFedora.fedora).to receive(:base_path).and_return("/")
-        expect(subject).to eq("#{ActiveFedora.fedora.host}/#{id}")
+        expect(uri).to eq("#{ActiveFedora.fedora.host}/#{id}")
       end
     end
 
     context "with a really empty base path" do
       it "produces a valid URI" do
         allow(ActiveFedora.fedora).to receive(:base_path).and_return("")
-        expect(subject).to eq("#{ActiveFedora.fedora.host}/#{id}")
+        expect(uri).to eq("#{ActiveFedora.fedora.host}/#{id}")
       end
     end
   end
 
   describe "uri_to_id" do
     let(:uri) { "#{ActiveFedora.fedora.host}#{ActiveFedora.fedora.base_path}/foo/123456w" }
-    subject { described_class.uri_to_id(uri) }
+    subject(:uri_id) { described_class.uri_to_id(uri) }
 
     context "with no custom proc is set" do
       it { should eq 'foo/123456w' }
@@ -154,7 +154,7 @@ describe ActiveFedora::Base do
         allow(described_class).to receive(:translate_uri_to_id).and_call_original
         allow(ActiveFedora::Core::FedoraUriTranslator).to receive(:call).and_call_original
 
-        subject
+        uri_id
 
         expect(ActiveFedora::Core::FedoraUriTranslator).to have_received(:call).with(uri)
       end

data/spec/unit/default_model_mapper_spec.rb

@@ -5,7 +5,7 @@ describe ActiveFedora::DefaultModelMapper do
   let(:classifier_instance) { double }
   let(:solr_field) { 'solr_field' }
   let(:predicate) { 'info:predicate' }
-  subject { described_class.new classifier_class: classifier, solr_field: solr_field, predicate: predicate }
+  subject(:mapper) { described_class.new classifier_class: classifier, solr_field: solr_field, predicate: predicate }
 
   describe '#classifier' do
     context 'with a solr document' do
@@ -16,7 +16,7 @@ describe ActiveFedora::DefaultModelMapper do
       end
 
       it 'creates a classifier from the solr field data' do
-        expect(subject.classifier(solr_document)).to eq classifier_instance
+        expect(mapper.classifier(solr_document)).to eq classifier_instance
       end
     end
 
@@ -32,7 +32,7 @@ describe ActiveFedora::DefaultModelMapper do
       end
 
       it 'creates a classifier from the resource model predicate' do
-        expect(subject.classifier(resource)).to eq classifier_instance
+        expect(mapper.classifier(resource)).to eq classifier_instance
       end
     end
   end

data/spec/unit/fedora_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe ActiveFedora::Fedora do
-  subject { described_class.new(config) }
+  subject(:fedora) { described_class.new(config) }
   describe "#authorized_connection" do
     describe "with SSL options" do
       let(:config) {
@@ -12,7 +12,7 @@ describe ActiveFedora::Fedora do
       }
       specify {
         expect(Faraday).to receive(:new).with("https://example.com", ssl: { ca_path: '/path/to/certs' }).and_call_original
-        subject.authorized_connection
+        fedora.authorized_connection
       }
     end
   end

data/spec/unit/file_configurator_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'config_helper'
 
 describe ActiveFedora::FileConfigurator do
-  subject { ActiveFedora.configurator }
+  subject(:configurator) { ActiveFedora.configurator }
 
   after :all do
     unstub_rails
@@ -19,95 +19,95 @@ describe ActiveFedora::FileConfigurator do
 
   describe "#config_options" do
     before do
-      subject.reset!
+      configurator.reset!
     end
     it "is an empty hash" do
-      expect(subject.config_options).to eq({})
+      expect(configurator.config_options).to eq({})
     end
   end
 
   describe "#fedora_config" do
     before do
-      subject.reset!
+      configurator.reset!
     end
     it "triggers configuration to load" do
-      expect(subject).to receive(:load_fedora_config)
-      subject.fedora_config
+      expect(configurator).to receive(:load_fedora_config)
+      configurator.fedora_config
     end
   end
   describe "#solr_config" do
     before do
-      subject.reset!
+      configurator.reset!
     end
     it "triggers configuration to load" do
-      expect(subject).to receive(:load_solr_config)
-      subject.solr_config
+      expect(configurator).to receive(:load_solr_config)
+      configurator.solr_config
     end
   end
 
   describe "#reset!" do
-    before { subject.reset! }
+    before { configurator.reset! }
     it "clears @fedora_config" do
-      expect(subject.instance_variable_get(:@fedora_config)).to eq({})
+      expect(configurator.instance_variable_get(:@fedora_config)).to eq({})
     end
     it "clears @solr_config" do
-      expect(subject.instance_variable_get(:@solr_config)).to eq({})
+      expect(configurator.instance_variable_get(:@solr_config)).to eq({})
     end
     it "clears @config_options" do
-      expect(subject.instance_variable_get(:@config_options)).to eq({})
+      expect(configurator.instance_variable_get(:@config_options)).to eq({})
     end
   end
 
   describe "initialization methods" do
     describe "config_path(:fedora)" do
       it "uses the config_options[:config_path] if it exists" do
-        expect(subject).to receive(:config_options).and_return(fedora_config_path: "/path/to/fedora.yml")
+        expect(configurator).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.config_path(:fedora)).to eql("/path/to/fedora.yml")
+        expect(configurator.config_path(:fedora)).to eql("/path/to/fedora.yml")
       end
 
       it "looks in Rails.root/config/fedora.yml if it exists and no fedora_config_path passed in" do
-        expect(subject).to receive(:config_options).and_return({})
+        expect(configurator).to receive(:config_options).and_return({})
         stub_rails(root: "/rails/root")
         expect(File).to receive(:file?).with("/rails/root/config/fedora.yml").and_return(true)
-        expect(subject.config_path(:fedora)).to eql("/rails/root/config/fedora.yml")
+        expect(configurator.config_path(:fedora)).to eql("/rails/root/config/fedora.yml")
         unstub_rails
       end
 
       it "looks in ./config/fedora.yml if neither rails.root nor :fedora_config_path are set" do
-        expect(subject).to receive(:config_options).and_return({})
+        expect(configurator).to receive(:config_options).and_return({})
         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.config_path(:fedora)).to eql("/current/working/directory/config/fedora.yml")
+        expect(configurator.config_path(:fedora)).to eql("/current/working/directory/config/fedora.yml")
       end
 
       it "returns default fedora.yml that ships with active-fedora if none of the above" do
-        expect(subject).to receive(:config_options).and_return({})
+        expect(configurator).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.")
-        expect(subject.config_path(:fedora)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'fedora.yml')))
+        expect(configurator.config_path(:fedora)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'fedora.yml')))
       end
     end
 
     describe "config_path(:solr)" do
       it "returns the solr_config_path if set in config_options hash" do
-        allow(subject).to receive(:config_options).and_return(solr_config_path: "/path/to/solr.yml")
+        allow(configurator).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.config_path(:solr)).to eql("/path/to/solr.yml")
+        expect(configurator.config_path(:solr)).to eql("/path/to/solr.yml")
       end
 
       it "returns 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(configurator).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.config_path(:solr)).to eql("/path/to/fedora/config/solr.yml")
+        expect(configurator.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(:config_options).and_return({})
-          expect(subject).to receive(:path).and_return("/path/to/fedora/config/fedora.yml")
+          allow(configurator).to receive(:config_options).and_return({})
+          expect(configurator).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
@@ -117,13 +117,13 @@ describe ActiveFedora::FileConfigurator do
         it "does 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")
           expect(File).to receive(:file?).with("/rails/root/config/solr.yml").and_return(true)
-          expect(subject.config_path(:solr)).to eql("/rails/root/config/solr.yml")
+          expect(configurator.config_path(:solr)).to eql("/rails/root/config/solr.yml")
         end
 
         it "looks in ./config/solr.yml if no rails root" do
           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.config_path(:solr)).to eql("/current/working/directory/config/solr.yml")
+          expect(configurator.config_path(:solr)).to eql("/current/working/directory/config/solr.yml")
         end
 
         it "returns the default solr.yml file that ships with active-fedora if no other option is set" do
@@ -131,109 +131,109 @@ describe ActiveFedora::FileConfigurator do
           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.")
-          expect(subject.config_path(:solr)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'solr.yml')))
+          expect(configurator.config_path(:solr)).to eql(File.expand_path(File.join(File.dirname("__FILE__"), 'config', 'solr.yml')))
         end
       end
     end
 
     describe "load_fedora_config" do
       before(:each) do
-        subject.reset!
+        configurator.reset!
       end
       it "loads the file specified in fedora_config_path" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(subject).to receive(:load_solr_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(configurator).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(configurator.load_fedora_config).to eq(url: "http://myfedora:8080")
+        expect(configurator.fedora_config).to eq(url: "http://myfedora:8080")
       end
 
       it "allows sharding" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(subject).to receive(:load_solr_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(configurator).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(configurator.load_fedora_config).to eq [{ url: "http://myfedora:8080" }, { url: "http://myfedora:8081" }]
+        expect(configurator.fedora_config).to eq [{ url: "http://myfedora:8080" }, { url: "http://myfedora:8081" }]
       end
 
       it "parses the file using ERb" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
-        expect(subject).to receive(:load_solr_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:fedora).and_return("/path/to/fedora.yml")
+        expect(configurator).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(configurator.load_fedora_config).to eq(url: "http://myfedora:8081")
+        expect(configurator.fedora_config).to eq(url: "http://myfedora:8081")
       end
     end
 
     describe "load_solr_config" do
       before(:each) do
-        subject.reset!
+        configurator.reset!
       end
       it "loads the file specified in solr_config_path" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(subject).to receive(:load_fedora_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
+        expect(configurator).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(configurator.load_solr_config).to eq(url: "http://mysolr:8080")
+        expect(configurator.solr_config).to eq(url: "http://mysolr:8080")
       end
 
       it "parses the file using ERb" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(subject).to receive(:load_fedora_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
+        expect(configurator).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(configurator.load_solr_config).to eq(url: "http://mysolr:8081")
+        expect(configurator.solr_config).to eq(url: "http://mysolr:8081")
       end
 
       it "includes update_path and select_path in solr_config" do
-        allow(subject).to receive(:load_solrizer_config)
-        expect(subject).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
-        expect(subject).to receive(:load_fedora_config)
+        allow(configurator).to receive(:load_solrizer_config)
+        expect(configurator).to receive(:config_path).with(:solr).and_return("/path/to/solr.yml")
+        expect(configurator).to receive(:load_fedora_config)
         expect(IO).to receive(:read).with("/path/to/solr.yml").and_return("test:\n  url: http://mysolr:8080\n  update_path: update_test\n  select_path: select_test\n")
-        expect(subject.solr_config[:update_path]).to eq('update_test')
-        expect(subject.solr_config[:select_path]).to eq('select_test')
+        expect(configurator.solr_config[:update_path]).to eq('update_test')
+        expect(configurator.solr_config[:select_path]).to eq('select_test')
       end
     end
 
     describe "load_configs" do
       describe "when config is not loaded" do
         before do
-          subject.instance_variable_set :@config_loaded, nil
+          configurator.instance_variable_set :@config_loaded, nil
         end
         it "loads the fedora and solr configs" do
-          expect(subject).to_not be_config_loaded
-          subject.load_configs
-          expect(subject).to be_config_loaded
+          expect(configurator).to_not be_config_loaded
+          configurator.load_configs
+          expect(configurator).to be_config_loaded
         end
       end
       describe "when config is loaded" do
         before do
-          subject.instance_variable_set :@config_loaded, true
+          configurator.instance_variable_set :@config_loaded, true
         end
         it "loads the fedora and solr configs" do
-          expect(subject).to receive(:load_config).never
-          expect(subject).to be_config_loaded
-          subject.load_configs
-          expect(subject).to be_config_loaded
+          expect(configurator).to receive(:load_config).never
+          expect(configurator).to be_config_loaded
+          configurator.load_configs
+          expect(configurator).to be_config_loaded
         end
       end
     end
 
     describe "check_fedora_path_for_solr" do
       it "finds the solr.yml file and return it if it exists" do
-        expect(subject).to receive(:path).and_return("/path/to/fedora/fedora.yml")
+        expect(configurator).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(configurator.check_fedora_path_for_solr).to eq "/path/to/fedora/solr.yml"
       end
       it "returns nil if the solr.yml file is not there" do
-        expect(subject).to receive(:path).and_return("/path/to/fedora/fedora.yml")
+        expect(configurator).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
+        expect(configurator.check_fedora_path_for_solr).to be_nil
       end
     end
   end
@@ -250,32 +250,32 @@ describe ActiveFedora::FileConfigurator do
     end
 
     it "can tell its config paths" do
-      subject.init
-      expect(subject).to respond_to(:solr_config_path)
+      configurator.init
+      expect(configurator).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(configurator).to receive(:load_solrizer_config)
       allow(Dir).to receive(:getwd).and_return(@fake_rails_root)
-      subject.init
-      expect(subject.config_path(:fedora)).to eql("#{@fake_rails_root}/config/fedora.yml")
-      expect(subject.solr_config_path).to eql("#{@fake_rails_root}/config/solr.yml")
+      configurator.init
+      expect(configurator.config_path(:fedora)).to eql("#{@fake_rails_root}/config/fedora.yml")
+      expect(configurator.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)
+      allow(configurator).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
+      configurator.init
       expected_config = File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "config"))
-      expect(subject.config_path(:fedora)).to eql(expected_config + '/fedora.yml')
-      expect(subject.solr_config_path).to eql(expected_config + '/solr.yml')
+      expect(configurator.config_path(:fedora)).to eql(expected_config + '/fedora.yml')
+      expect(configurator.solr_config_path).to eql(expected_config + '/solr.yml')
     end
     it "raises an error if you pass in a string" do
-      expect(lambda { subject.init("#{@fake_rails_root}/config/fake_fedora.yml") }).to raise_exception(ArgumentError)
+      expect(lambda { configurator.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(lambda { subject.init(fedora_config_path: "really_fake_fedora.yml") }).to raise_exception(ActiveFedora::ConfigurationError)
+      expect(lambda { configurator.init(fedora_config_path: "really_fake_fedora.yml") }).to raise_exception(ActiveFedora::ConfigurationError)
     end
 
     describe "within Rails" do
@@ -288,15 +288,15 @@ describe ActiveFedora::FileConfigurator do
       end
 
       it "loads a config from Rails.root as a first choice" do
-        allow(subject).to receive(:load_solrizer_config)
-        subject.init
-        expect(subject.config_path(:fedora)).to eql("#{Rails.root}/config/fedora.yml")
-        expect(subject.solr_config_path).to eql("#{Rails.root}/config/solr.yml")
+        allow(configurator).to receive(:load_solrizer_config)
+        configurator.init
+        expect(configurator.config_path(:fedora)).to eql("#{Rails.root}/config/fedora.yml")
+        expect(configurator.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
+        configurator.init
         expect(ActiveFedora.environment).to eql("development")
       end
     end