active-fedora 8.7.0 → 9.0.0.beta1

data/spec/unit/persistence_spec.rb

@@ -1,30 +1,6 @@
 require 'spec_helper'
 
 describe ActiveFedora::Persistence do
-  context "internal methods" do
-    before :all do
-      class SpecNode
-        include ActiveFedora::Persistence
-      end
-    end
-    after :all do
-      Object.send(:remove_const, :SpecNode)
-    end
-
-    subject { SpecNode.new }
-
-    describe "#create_needs_index?" do
-      it "should be true" do
-        expect(subject.send(:create_needs_index?)).to be_truthy
-      end
-    end
-
-    describe "#update_needs_index?" do
-      it "should be true" do
-        expect(subject.send(:update_needs_index?)).to be_truthy
-      end
-    end
-  end
 
   describe "an unsaved object" do
     subject { ActiveFedora::Base.new }
@@ -33,6 +9,15 @@ describe ActiveFedora::Persistence do
     end
   end
 
+  describe ".create" do
+    context "when a block is provided" do
+      it "should pass the block to initialize" do
+        expect_any_instance_of(ActiveFedora::Base).to receive(:save)
+        expect { |b| ActiveFedora::Base.create(&b) }.to yield_with_args(an_instance_of ActiveFedora::Base)
+      end
+    end
+  end
+
   describe "a saved object" do
     subject { ActiveFedora::Base.create! }
     describe "that is deleted" do
@@ -47,48 +32,57 @@ describe ActiveFedora::Persistence do
 
   describe "destroy" do
     subject { ActiveFedora::Base.create! }
-    it "should not clear the pid" do
+    it "should not clear the id" do
       subject.destroy
-      expect(subject.pid).not_to be_nil
+      expect(subject.id).not_to be_nil
     end
   end
 
   describe "save" do
     subject { ActiveFedora::Base.new }
-    context "when called with option :update_index=>false" do
+
+    context "when called with option update_index: false" do
       context "on a new record" do
         it "should not update the index" do
-          expect(subject).to receive(:persist).with(false)
+          expect(subject).to_not receive(:update_index)
           subject.save(update_index: false)
         end
       end
+
       context "on a persisted record" do
         before do
           allow(subject).to receive(:new_record?) { false }
-          allow(subject.inner_object).to receive(:save) { true }
+          allow_any_instance_of(Ldp::Orm).to receive(:save) { true }
+          allow(subject).to receive(:update_modified_date)
         end
+
         it "should not update the index" do
-          expect(subject).to receive(:persist).with(false)
+          expect(subject).to_not receive(:update_index)
           subject.save(update_index: false)
-        end        
+        end
       end
     end
+
     context "when called with option :update_index=>true" do
       context "on create" do
         before { allow(subject).to receive(:create_needs_index?) { false } }
+
         it "should not override `create_needs_index?'" do
-          expect(subject).to receive(:persist).with(false)
+          expect(subject).to_not receive(:update_index)
           subject.save(update_index: true)
         end
       end
+
       context "on update" do
         before do
           allow(subject).to receive(:new_record?) { false }
-          allow(subject.inner_object).to receive(:save) { true }
+          allow_any_instance_of(Ldp::Orm).to receive(:save) { true }
           allow(subject).to receive(:update_needs_index?) { false }
+          allow(subject).to receive(:update_modified_date)
         end
+
         it "should not override `update_needs_index?'" do
-          expect(subject).to receive(:persist).with(false)
+          expect(subject).to_not receive(:update_index)
           subject.save(update_index: true)
         end
       end

data/spec/unit/predicates_spec.rb

@@ -3,16 +3,16 @@ require 'spec_helper'
 describe ActiveFedora::Predicates do
   describe "#short_predicate" do
     it 'should parse strings' do
-      expect(ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID')).to eq(:oai_item_id)
+      expect(ActiveFedora::Predicates.short_predicate('http://www.openarchives.org/OAI/2.0/itemID')).to eq :oai_item_id
     end
     it 'should parse uris' do
-      expect(ActiveFedora::Predicates.short_predicate(RDF::DC.creator)).to eq('dc_terms_creator')
-      expect(ActiveFedora::Predicates.short_predicate(RDF::SKOS.hasTopConcept)).to eq('2004_02_skos_core_has_top_concept')
+      expect(ActiveFedora::Predicates.short_predicate(RDF::DC.creator)).to eq 'dc_terms_creator'
+      expect(ActiveFedora::Predicates.short_predicate(RDF::SKOS.hasTopConcept)).to eq '2004_02_skos_core_has_top_concept'
     end
-    before(:all) do
+    before do
       @original_mapping = ActiveFedora::Predicates.predicate_config[:predicate_mapping]
     end
-    after(:all) do
+    after do
       ActiveFedora::Predicates.predicate_config[:predicate_mapping] = @original_mapping
     end
     it "should find predicates regardless of order loaded or shared namespace prefixes" do
@@ -21,14 +21,14 @@ describe ActiveFedora::Predicates do
         "http://example.org/zoo/wolves/"=>{:alpha => 'Manager'},
         "http://example.org/zoo/"=>{:keeper => 'Manager'}
         }
-      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/Manager")).to eq(:keeper)
-      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/wolves/Manager")).to eq(:alpha)
-      expect(ActiveFedora::Predicates.short_predicate("http://example.org/Manager")).to eq(:ceo)
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/Manager")).to eq :keeper
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/zoo/wolves/Manager")).to eq :alpha
+      expect(ActiveFedora::Predicates.short_predicate("http://example.org/Manager")).to eq :ceo
     end
   end
   
   it 'should provide .default_predicate_namespace' do
-    expect(ActiveFedora::Predicates.default_predicate_namespace).to eq('info:fedora/fedora-system:def/relations-external#')
+    expect(ActiveFedora::Predicates.default_predicate_namespace).to eq 'http://fedora.info/definitions/v4/rels-ext#'
   end
  
   describe "#predicate_mappings" do 
@@ -37,8 +37,8 @@ describe ActiveFedora::Predicates do
       expect(ActiveFedora::Predicates.predicate_mappings).to be_kind_of Hash
     end
 
-    it "should provide mappings to the fedora ontology via the info:fedora/fedora-system:def/relations-external default namespace mapping" do
-      expect(ActiveFedora::Predicates.predicate_mappings.keys.include?(ActiveFedora::Predicates.default_predicate_namespace)).to be_truthy
+    it "should provide mappings to the fedora ontology via the http://fedora.info/definitions/v4/rels-ext# default namespace mapping" do
+      expect(ActiveFedora::Predicates.predicate_mappings.keys.include?(ActiveFedora::Predicates.default_predicate_namespace)).to be true
       expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace]).to be_kind_of Hash
     end
 
@@ -68,25 +68,25 @@ describe ActiveFedora::Predicates do
                             :has_model => "hasModel"]
       desired_mappings.each_pair do |k,v|
         expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace]).to have_key(k)
-        expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace][k]).to eq(v)
+        expect(ActiveFedora::Predicates.predicate_mappings[ActiveFedora::Predicates.default_predicate_namespace][k]).to eq v
       end
     end
   end
 
   it 'should provide #predicate_lookup that maps symbols to common RELS-EXT predicates' do
     expect(ActiveFedora::Predicates).to respond_to(:predicate_lookup)
-    expect(ActiveFedora::Predicates.predicate_lookup(:is_part_of)).to eq("isPartOf")
-    expect(ActiveFedora::Predicates.predicate_lookup(:is_member_of)).to eq("isMemberOf")
-    expect(ActiveFedora::Predicates.predicate_lookup("isPartOfCollection")).to eq("isPartOfCollection")
+    expect(ActiveFedora::Predicates.predicate_lookup(:is_part_of)).to eq "isPartOf"
+    expect(ActiveFedora::Predicates.predicate_lookup(:is_member_of)).to eq "isMemberOf"
+    expect(ActiveFedora::Predicates.predicate_lookup("isPartOfCollection")).to eq "isPartOfCollection"
     ActiveFedora::Predicates.predicate_config[:predicate_mapping].merge!({"some_namespace"=>{:has_foo=>"hasFOO"}})
-    expect(ActiveFedora::Predicates.find_predicate(:has_foo)).to eq(["hasFOO","some_namespace"])
-    expect(ActiveFedora::Predicates.predicate_lookup(:has_foo,"some_namespace")).to eq("hasFOO")
-    expect { ActiveFedora::Predicates.predicate_lookup(:has_foo) }.to raise_error ActiveFedora::UnregisteredPredicateError
+    expect(ActiveFedora::Predicates.find_predicate(:has_foo)).to eq ["hasFOO","some_namespace"]
+    expect(ActiveFedora::Predicates.predicate_lookup(:has_foo,"some_namespace")).to eq "hasFOO"
+    expect(lambda { ActiveFedora::Predicates.predicate_lookup(:has_foo) }).to raise_error ActiveFedora::UnregisteredPredicateError
   end
     
   context 'initialization' do
     before :each do
-      @old_predicate_config = ActiveFedora::Predicates.predicate_config
+      @old_predicate_config = Marshal.load(Marshal.dump(ActiveFedora::Predicates.predicate_config))
     end
     
     after :each do
@@ -94,36 +94,36 @@ describe ActiveFedora::Predicates do
     end
     
     it 'should allow explicit initialization of predicates' do
-      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq(["isPartOf", "info:fedora/fedora-system:def/relations-external#"])
+      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq ["isPartOf", "http://fedora.info/definitions/v4/rels-ext#"]
       ActiveFedora::Predicates.predicate_config = {
         :default_namespace => 'http://example.com/foo',
         :predicate_mapping => {
           'http://example.com/foo' => { :has_bar => 'hasBAR' }
         }
       }
-      expect(ActiveFedora::Predicates.find_predicate(:has_bar)).to eq(["hasBAR", "http://example.com/foo"])
-      expect { ActiveFedora::Predicates.find_predicate(:is_part_of) }.to raise_error ActiveFedora::UnregisteredPredicateError
+      expect(ActiveFedora::Predicates.find_predicate(:has_bar)).to eq ["hasBAR", "http://example.com/foo"]
+      expect(lambda { ActiveFedora::Predicates.find_predicate(:is_part_of) }).to raise_error ActiveFedora::UnregisteredPredicateError
     end
     
     it 'should ensure that the configuration has the correct keys' do
-      expect { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }.to raise_error TypeError
+      expect(lambda { ActiveFedora::Predicates.predicate_config = { :foo => 'invalid!' } }).to raise_error TypeError
     end
 
     it "should allow adding predicates without wiping out existing predicates" do
       ActiveFedora::Predicates.set_predicates({
                                                   "http://projecthydra.org/ns/relations#"=>{has_profile:"hasProfile"},
-                                                  "info:fedora/fedora-system:def/relations-external#"=>{
+                                                  "http://fedora.info/definitions/v4/rels-ext#"=>{
                                                       references:"references",
                                                       has_derivation: "cameFrom"
                                                   },
                                               })
       # New & Modified Predicates
-      expect(ActiveFedora::Predicates.find_predicate(:has_profile)).to eq(["hasProfile", "http://projecthydra.org/ns/relations#"])
-      expect(ActiveFedora::Predicates.find_predicate(:references)).to eq(["references", "info:fedora/fedora-system:def/relations-external#"])
-      expect(ActiveFedora::Predicates.find_predicate(:has_derivation)).to eq(["cameFrom", "info:fedora/fedora-system:def/relations-external#"])
+      expect(ActiveFedora::Predicates.find_predicate(:has_profile)).to eq ["hasProfile", "http://projecthydra.org/ns/relations#"]
+      expect(ActiveFedora::Predicates.find_predicate(:references)).to eq ["references", "http://fedora.info/definitions/v4/rels-ext#"]
+      expect(ActiveFedora::Predicates.find_predicate(:has_derivation)).to eq ["cameFrom", "http://fedora.info/definitions/v4/rels-ext#"]
       # Pre-Existing predicates should be unharmed
-      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq(["isPartOf", "info:fedora/fedora-system:def/relations-external#"])
-      expect(ActiveFedora::Predicates.find_predicate(:is_governed_by)).to eq(["isGovernedBy", "http://projecthydra.org/ns/relations#"])
+      expect(ActiveFedora::Predicates.find_predicate(:is_part_of)).to eq ["isPartOf", "http://fedora.info/definitions/v4/rels-ext#"]
+      expect(ActiveFedora::Predicates.find_predicate(:is_governed_by)).to eq ["isGovernedBy", "http://projecthydra.org/ns/relations#"]
     end
 
   end

data/spec/unit/property_spec.rb

@@ -5,7 +5,7 @@ require 'active_fedora/model'
 
 describe ActiveFedora::Property do
   
-  before(:all) do
+  before(:each) do
     @test_property = ActiveFedora::Property.new(double("model_stub"),"file_name", :string)
   end
   
@@ -19,8 +19,6 @@ describe ActiveFedora::Property do
 
   
   it 'should provide .instance_variable_name' do
-    #ActiveFedora::Property.should respond_to(:instance_variable_name)
-    
     expect(@test_property).to respond_to(:instance_variable_name)
   end
 

data/spec/unit/qualified_dublin_core_datastream_spec.rb

@@ -8,9 +8,8 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
     require File.join( File.dirname(__FILE__), "..", "samples","oral_history_sample_model" )
     @dc_terms = []
   end
-  
-  before(:each) do
-    @sample_xml =  "<dc xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:dcterms='http://purl.org/dc/terms/'>
+
+  let(:sample_xml) do "<dc xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance' xmlns:dcterms='http://purl.org/dc/terms/'>
           <dcterms:type xsi:type='DCMITYPE'>sound</dcterms:type>
           <dcterms:medium>medium</dcterms:medium>
           <dcterms:rights>rights</dcterms:rights>
@@ -37,60 +36,54 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
           <dcterms:description>desc</dcterms:description>
           <dcterms:date>datestr</dcterms:date>
         </dc>"
-     @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(@sample_xml )
-
   end
-  it "from_xml should parse everything correctly" do
-    expect(@test_ds.ng_xml).to be_equivalent_to @sample_xml
+  before do
+     @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new
+     @test_ds.content = sample_xml
   end
 
   it "should create the right number of fields" do
-    expect(ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size).to eq(54)
+    expect(ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS.size).to eq 54
   end
 
   it "should have unmodifiable constants" do
-    expect {ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS<<:foo}.to raise_error((TypeError if RUBY_VERSION < "1.9.0") || RuntimeError, /can't modify frozen array/i)
-
+    expect { ActiveFedora::QualifiedDublinCoreDatastream::DCTERMS<<:foo }.to raise_error(RuntimeError, /can't modify frozen array/i)
   end
 
   it "should default dc elements to :multiple=>true" do
     @test_ds.fields.values.each do |s|
-      expect(s.has_key?(:multiple)).to eq(true)
+      expect(s.has_key?(:multiple)).to be true
     end
   end
-  
-  after(:each) do
-  end
-  
+
   describe '#new' do
     it 'should provide #new' do
       expect(ActiveFedora::QualifiedDublinCoreDatastream).to respond_to(:new)
     end
-    
-    
-    describe "model methods" do 
+
+
+    describe "model methods" do
 
       DC_ELEMENTS.each do |el|
         it "should respond to getters and setters for #{el} element" do
           pending if el == :type
           value = "Hey #{el}"
-          @test_ds.send("#{el.to_s}=", value) 
-          expect(@test_ds.send(el).first).to eq(value)  #Looking at first because creator has 2 nodes
+          @test_ds.send("#{el.to_s}=", value)
+          expect(@test_ds.send(el).first).to eq value  #Looking at first because creator has 2 nodes
         end
       end
     end
   end
-  
+
   describe '.to_xml' do
     it 'should output the fields hash as Qualified Dublin Core XML' do
-      #@test_ds.should_receive(:new?).and_return(true).twice
       sample_xml = "<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><dcterms:title>title1</dcterms:title><dcterms:publisher>publisher1</dcterms:publisher><dcterms:creator>creator1</dcterms:creator><dcterms:creator>creator2</dcterms:creator></dc>"
-      @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new(nil, 'qdc' )
+      @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new
 
       @test_ds.field :publisher
       @test_ds.field :creator
       @test_ds.field :title
-      
+
       @test_ds.publisher= ["publisher1"]
       @test_ds.creator= ["creator1", "creator2"]
       @test_ds.title= ["title1"]
@@ -107,28 +100,30 @@ describe ActiveFedora::QualifiedDublinCoreDatastream do
 
   describe "#to_solr" do
     it "should have title" do
-      @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new(nil, 'qdc' )
+      @test_ds = ActiveFedora::QualifiedDublinCoreDatastream.new
       @test_ds.title = "War and Peace"
       solr = @test_ds.to_solr
-      expect(solr[ActiveFedora::SolrService.solr_name('title', type: :string)]).to eq("War and Peace")
+      expect(solr[ActiveFedora::SolrService.solr_name('title', type: :string)]).to eq "War and Peace"
     end
 
   end
 
   describe 'custom fields' do
+    subject { ActiveFedora::QualifiedDublinCoreDatastream.new }
     it 'should grab the term' do
       sample_xml = "<dc xmlns:dcterms='http://purl.org/dc/terms/' xmlns:xsi='http://www.w3.org/2001/XMLSchema-instance'><dcterms:cust>custom</dcterms:cust></dc>"
-      test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(sample_xml )
-      test_ds.field :cust
-      expect(test_ds.cust).to eq(['custom'])
+      subject.content = sample_xml
+      subject.field :cust
+      expect(subject.cust).to eq ['custom']
     end
   end
 
   describe "#field should accept :path option" do
+    subject { ActiveFedora::QualifiedDublinCoreDatastream.new }
     it "should be able to map :dc_type to the path 'type'" do
-      test_ds = ActiveFedora::QualifiedDublinCoreDatastream.from_xml(@sample_xml)
-      test_ds.field :dc_type, :string, path: "type", multiple: true
-      expect(test_ds.dc_type).to eq(['sound'])
+      subject.content = sample_xml
+      subject.field :dc_type, :string, path: "type", multiple: true
+      expect(subject.dc_type).to eq ['sound']
     end
   end
 

data/spec/unit/query_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
 describe ActiveFedora::Base do
-  
+
   before(:all) do
     module SpecModel
       class Basic < ActiveFedora::Base
       end
     end
-    @model_query = "_query_:\"{!raw f=" + ActiveFedora::SolrService.solr_name("has_model", :symbol) + "}info:fedora/afmodel:SpecModel_Basic" + "\""
+    @model_query = "_query_:\"{!raw f=" + ActiveFedora::SolrService.solr_name("has_model", :symbol) + "}SpecModel::Basic" + "\""
     @sort_query = ActiveFedora::SolrService.solr_name("system_create", :stored_sortable, type: :date) + ' asc'
   end
-  
+
   after(:all) do
     Object.send(:remove_const, :SpecModel)
   end
 
   describe ":all" do
-    before { allow(ActiveFedora::Base).to receive_messages(:relation => relation) }
+    before { allow(ActiveFedora::Base).to receive(:relation).and_return(relation) }
     describe "called on a concrete class" do
       let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
       it "should query solr for all objects with :has_model_s of self.class" do
@@ -25,7 +25,7 @@ describe ActiveFedora::Base do
         mock_docs = [{"id" => "changeme:30"}, {"id" => "changeme:22"}]
         expect(mock_docs).to receive(:has_next?).and_return(false)
         expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
-        expect(SpecModel::Basic.all).to eq(["Fake Object1", "Fake Object2"])
+        expect(SpecModel::Basic.all).to eq ["Fake Object1", "Fake Object2"]
       end
     end
     describe "called without a specific class" do
@@ -36,153 +36,112 @@ describe ActiveFedora::Base do
         mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
         expect(mock_docs).to receive(:has_next?).and_return(false)
         expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>'*:*', :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
-        expect(ActiveFedora::Base.all).to eq(["Fake Object1", "Fake Object2"])
+        expect(ActiveFedora::Base.all).to eq ["Fake Object1", "Fake Object2"]
       end
     end
   end
   
   describe '#find' do
     describe "with :cast false" do
-      describe "and a pid is specified" do
-        it "should use SpecModel::Basic.allocate.init_with_object to instantiate an object" do
-          allow_any_instance_of(SpecModel::Basic).to receive(:init_with_object).and_return(SpecModel::Basic.new )
-          expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double("inner obj", :'new?'=>false))
-          expect(SpecModel::Basic.find("_PID_", cast: false)).to be_a SpecModel::Basic
-        end
+      describe "and an id is specified" do
         it "should raise an exception if it is not found" do
-          allow_any_instance_of(Rubydora::Fc3Service).to receive(:object).and_raise(RestClient::ResourceNotFound)
-          expect(SpecModel::Basic).to receive(:connection_for_pid).with("_PID_")
-          expect {SpecModel::Basic.find("_PID_")}.to raise_error ActiveFedora::ObjectNotFoundError
+          expect { SpecModel::Basic.find("_ID_") }.to raise_error ActiveFedora::ObjectNotFoundError
         end
       end
     end
-    describe "with default :cast of true" do
-      it "should use SpecModel::Basic.allocate.init_with_object to instantiate an object" do
-        allow_any_instance_of(SpecModel::Basic).to receive(:init_with_object).and_return(double("Model", :adapt_to_cmodel=>SpecModel::Basic.new ))
-        expect(ActiveFedora::DigitalObject).to receive(:find).and_return(double("inner obj", :'new?'=>false))
-        SpecModel::Basic.find("_PID_")
+    describe "using an options hash" do
+      before do
+        Deprecation.default_deprecation_behavior = :raise
+      end
+      it "should be deprecated" do
+        expect { SpecModel::Basic.find(id: "_ID_") }.to raise_error RuntimeError
       end
     end
+  end
 
-    describe "with conditions" do
-      before do
-        allow(ActiveFedora::Base).to receive_messages(:relation => relation)
-        allow(relation).to receive_messages(clone: relation)
-      end
-      let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
-      it "should filter by the provided fields" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+  describe "#where" do
+    before do
+      allow(ActiveFedora::Base).to receive(:relation).and_return(relation)
+      allow(relation).to receive(:clone).and_return(relation)
+    end
+    let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
+    let(:solr) { ActiveFedora::SolrService.instance.conn }
+    let(:expected_query) { "#{@model_query} AND foo:bar AND baz:quix AND baz:quack" }
+    let(:expected_params) { { params: { sort: [@sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
+    let(:expected_sort_params) { { params: { sort: ["title_t desc"], fl: 'id', q: expected_query, qt: 'standard' } } }
+    let(:mock_docs) { [{"id" => "changeme:30"},{"id" => "changeme:22"}] }
 
-        mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] &&
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:bar") &&
-            hash[:params][:q].split(" AND ").include?("baz:quix") &&
-            hash[:params][:q].split(" AND ").include?("baz:quack")
-        }.and_return('response'=>{'docs'=>mock_docs})
-        expect(SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']})).to eq(["Fake Object1", "Fake Object2"])
-      end
+    it "should filter by the provided fields" do
+      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
+      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
 
-      it "should correctly query for empty strings" do
-        expect(SpecModel::Basic.find( :active_fedora_model_ssi => '').count).to eq(0)
-      end
+      expect(mock_docs).to receive(:has_next?).and_return(false)
+      expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_params).and_return('response'=>{'docs'=>mock_docs})
+      expect(SpecModel::Basic.where({:foo=>'bar', :baz=>['quix','quack']})).to eq ["Fake Object1", "Fake Object2"]
+    end
 
-      it 'should correctly query for empty arrays' do
-        expect(SpecModel::Basic.find( :active_fedora_model_ssi => []).count).to eq(0)
-      end
+    it "should correctly query for empty strings" do
+      expect(SpecModel::Basic.where( :active_fedora_model_ssi => '').count).to eq 0
+    end
 
-      it "should add options" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+    it 'should correctly query for empty arrays' do
+      expect(SpecModel::Basic.where( :active_fedora_model_ssi => []).count).to eq 0
+    end
 
-        mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
-        expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:sort] == [@sort_query] &&
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:bar") &&
-            hash[:params][:q].split(" AND ").include?("baz:quix") &&
-            hash[:params][:q].split(" AND ").include?("baz:quack")
-        }.and_return('response'=>{'docs'=>mock_docs})
-        expect(SpecModel::Basic.find({:foo=>'bar', :baz=>['quix','quack']}, :sort=>'title_t desc')).to eq(["Fake Object1", "Fake Object2"])
-      end
+    it "should add options" do
+      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return("Fake Object1")
+      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return("Fake Object2")
+
+      expect(mock_docs).to receive(:has_next?).and_return(false)
+      expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_sort_params).and_return('response'=>{'docs'=>mock_docs})
+      expect(SpecModel::Basic.where(:foo=>'bar', :baz=>['quix','quack']).order('title_t desc')).to eq ["Fake Object1", "Fake Object2"]
     end
   end
 
 
   describe '#find_each' do
-    before { allow(ActiveFedora::Base).to receive_messages(:relation => relation) }
+    before { allow(ActiveFedora::Base).to receive(:relation).and_return(relation) }
     let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
     it "should query solr for all objects with :active_fedora_model_s of self.class" do
-      mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
+      mock_docs = [{"id" => "changeme-30"},{"id" => "changeme-22"}]
       expect(mock_docs).to receive(:has_next?).and_return(false)
       expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate).with(1, 1000, 'select', :params=>{:q=>@model_query, :qt => 'standard', :sort => [@sort_query], :fl=> 'id', }).and_return('response'=>{'docs'=>mock_docs})
-      
-      expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-      expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
-      yielded = double("yielded method")
-      expect(yielded).to receive(:run).twice { |obj| obj.class == SpecModel::Basic}
-      SpecModel::Basic.find_each(){|obj| yielded.run(obj) }
+
+      allow(relation).to receive(:load_from_fedora).with("changeme-30", nil).and_return(SpecModel::Basic.new('changeme-30'))
+      allow(relation).to receive(:load_from_fedora).with("changeme-22", nil).and_return(SpecModel::Basic.new('changeme-22'))
+      SpecModel::Basic.find_each(){ |obj| obj.class == SpecModel::Basic }
     end
+
     describe "with conditions" do
+      let(:solr) { ActiveFedora::SolrService.instance.conn }
+      let(:expected_query) { "#{@model_query} AND foo:bar AND baz:quix AND baz:quack" }
+      let(:expected_params) { { params: { sort: [@sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
+      let(:mock_docs) { [{"id" => "changeme-30"}, {"id" => "changeme-22"}] }
+
       it "should filter by the provided fields" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:30'))
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", nil).and_return(SpecModel::Basic.new(:pid=>'changeme:22'))
+        expect(relation).to receive(:load_from_fedora).with("changeme-30", nil).and_return(SpecModel::Basic.new('changeme-30'))
+        expect(relation).to receive(:load_from_fedora).with("changeme-22", nil).and_return(SpecModel::Basic.new('changeme-22'))
 
-        mock_docs = [{"id" => "changeme:30"},{"id" => "changeme:22"}]
         expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
-            page == 1 &&
-            rows == 1000 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] && 
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:bar") &&
-            hash[:params][:q].split(" AND ").include?("baz:quix") &&
-            hash[:params][:q].split(" AND ").include?("baz:quack")
-        }.and_return('response'=>{'docs'=>mock_docs})
-        yielded = double("yielded method")
-        expect(yielded).to receive(:run).twice { |obj| obj.class == SpecModel::Basic}
-        SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| yielded.run(obj) }
+        expect(solr).to receive(:paginate).with(1, 1000, 'select', expected_params).and_return('response'=>{'docs'=>mock_docs})
+        SpecModel::Basic.find_each({:foo=>'bar', :baz=>['quix','quack']}){|obj| obj.class == SpecModel::Basic }
       end
     end
   end
 
   describe '#find_in_batches' do
     describe "with conditions hash" do
+      let(:solr) { ActiveFedora::SolrService.instance.conn }
+      let(:expected_query) { "#{@model_query} AND foo:bar AND baz:quix AND baz:quack" }
+      let(:expected_params) { { params: { sort: [@sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
+      let(:mock_docs) { double('docs') }
+
       it "should filter by the provided fields" do
-        mock_docs = double('docs')
         expect(mock_docs).to receive(:has_next?).and_return(false)
-        expect(ActiveFedora::SolrService.instance.conn).to receive(:paginate) { |page, rows, method, hash|
-            page == 1 &&
-            rows == 1002 &&
-            method == 'select' &&
-            hash[:params] &&
-            hash[:params][:sort] == [@sort_query] && 
-            hash[:params][:fl] == 'id' && 
-            hash[:params][:q].split(" AND ").include?(@model_query) &&
-            hash[:params][:q].split(" AND ").include?("foo:bar") &&
-            hash[:params][:q].split(" AND ").include?("baz:quix") &&
-            hash[:params][:q].split(" AND ").include?("baz:quack")
-        }.and_return('response'=>{'docs'=>mock_docs})
+        expect(solr).to receive(:paginate).with(1, 1002, 'select', expected_params).and_return('response'=>{'docs'=>mock_docs})
         yielded = double("yielded method")
         expect(yielded).to receive(:run).with(mock_docs)
-        SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}) {|group| yielded.run group }
+        SpecModel::Basic.find_in_batches({:foo=>'bar', :baz=>['quix','quack']}, {:batch_size=>1002, :fl=>'id'}){|group| yielded.run group }
       end
     end
   end
@@ -192,30 +151,30 @@ describe ActiveFedora::Base do
     it "should return a count" do
       mock_result = {'response'=>{'numFound'=>7}}
       expect(ActiveFedora::SolrService).to receive(:query).with(@model_query, :rows=>0, :raw=>true).and_return(mock_result)
-      expect(SpecModel::Basic.count).to eq(7)
+      expect(SpecModel::Basic.count).to eq 7
     end
     it "should allow conditions" do
       mock_result = {'response'=>{'numFound'=>7}}
       expect(ActiveFedora::SolrService).to receive(:query).with("#{@model_query} AND (foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
-      expect(SpecModel::Basic.count(:conditions=>'foo:bar')).to eq(7)
+      expect(SpecModel::Basic.count(:conditions=>'foo:bar')).to eq 7
     end
 
     it "should count without a class specified" do
       mock_result = {'response'=>{'numFound'=>7}}
       expect(ActiveFedora::SolrService).to receive(:query).with("(foo:bar)", :rows=>0, :raw=>true).and_return(mock_result)
-      expect(ActiveFedora::Base.count(:conditions=>'foo:bar')).to eq(7) 
+      expect(ActiveFedora::Base.count(:conditions=>'foo:bar')).to eq 7 
     end
   end
 
   describe '#last' do
     describe 'with multiple objects' do
-      before(:all) do
+      before(:each) do
         (@a, @b, @c) = 3.times {SpecModel::Basic.create!}
       end
       it 'should return one object' do
         SpecModel::Basic.class == SpecModel::Basic
       end
-      it 'should return the last object sorted by pid' do
+      it 'should return the last object sorted by id' do
         SpecModel::Basic.last == @c
         SpecModel::Basic.last != @a 
       end
@@ -230,13 +189,13 @@ describe ActiveFedora::Base do
 
   describe '#first' do
     describe 'with multiple objects' do
-      before(:all) do
+      before(:each) do
         (@a, @b, @c) = 3.times {SpecModel::Basic.create!}
       end
       it 'should return one object' do
         SpecModel::Basic.class == SpecModel::Basic
       end
-      it 'should return the last object sorted by pid' do
+      it 'should return the last object sorted by id' do
         SpecModel::Basic.first == @a
         SpecModel::Basic.first != @c 
       end
@@ -250,48 +209,56 @@ describe ActiveFedora::Base do
   end
   
   describe '#find_with_conditions' do
-    it "should make a query to solr and return the results" do
-      mock_result = double('Result')
-           expect(ActiveFedora::SolrService).to receive(:query) { |args|
-            q = args.first if args.is_a? Array
-            q ||= args
-            q.split(" AND ").include?(@model_query) &&
-            q.split(" AND ").include?("foo:bar") &&
-            q.split(" AND ").include?("baz:quix") &&
-            q.split(" AND ").include?("baz:quack")
-        }.and_return(mock_result)
-      expect(SpecModel::Basic.find_with_conditions(:foo=>'bar', :baz=>['quix','quack'])).to eq(mock_result)
+    let(:mock_result) { double('Result') }
+    let(:klass) { SpecModel::Basic }
+    subject { klass.find_with_conditions(conditions) }
+
+    before do
+      expect(ActiveFedora::SolrService).to receive(:query).with(expected_query, sort: [@sort_query]).and_return(mock_result)
     end
 
-    it "should escape quotes" do
-      mock_result = double('Result')
-      expect(ActiveFedora::SolrService).to receive(:query) { |args|
-          q = args.first if args.is_a? Array
-          q ||= args
-          q.split(" AND ").include?(@model_query) &&
-          q.split(" AND ").include?(@model_query) &&
-          q.split(" AND ").include?('foo:9\\"\\ Nails') &&
-          q.split(" AND ").include?('baz:7\\"\\ version') &&
-          q.split(" AND ").include?('baz:quack')
-        }.and_return(mock_result)
-      expect(SpecModel::Basic.find_with_conditions(:foo=>'9" Nails', :baz=>['7" version','quack'])).to eq(mock_result)
+    context "with a hash of conditions" do
+      let(:expected_query) { "#{@model_query} AND foo:bar AND baz:quix AND baz:quack" }
+      let(:conditions) { { foo: 'bar', baz: ['quix', 'quack'] } }
+
+      it "should make a query to solr and return the results" do
+        expect(subject).to eq mock_result
+      end
     end
 
-    it "shouldn't use the class if it's called on AF:Base " do
-      mock_result = double('Result')
-      expect(ActiveFedora::SolrService).to receive(:query).with('baz:quack', {:sort => [@sort_query]}).and_return(mock_result)
-      expect(ActiveFedora::Base.find_with_conditions(:baz=>'quack')).to eq(mock_result)
+    context "with quotes in the params" do
+      let(:expected_query) { "#{@model_query} AND foo:9\\\"\\ Nails AND baz:7\\\"\\ version AND baz:quack" }
+      let(:conditions) { { foo: '9" Nails', baz: ['7" version', 'quack']} }
+
+      it "should escape quotes" do
+        expect(subject).to eq mock_result
+      end
     end
-    it "should use the query string if it's provided and wrap it in parentheses" do
-      mock_result = double('Result')
-      expect(ActiveFedora::SolrService).to receive(:query).with('(chunky:monkey)', {:sort => [@sort_query]}).and_return(mock_result)
-      expect(ActiveFedora::Base.find_with_conditions('chunky:monkey')).to eq(mock_result)
+
+    context "called on AF::Base" do
+      let(:klass) { ActiveFedora::Base }
+
+      context "with a hash" do
+        let(:conditions) { {:baz=>'quack'} }
+        let(:expected_query) { 'baz:quack' }
+        it "shouldn't use the class if it's called on AF:Base " do
+          expect(subject).to eq mock_result
+        end
+      end
+
+      context "called with a string" do
+        let(:conditions) { 'chunky:monkey' }
+        let(:expected_query) { '(chunky:monkey)' }
+        it "should use the query string if it's provided and wrap it in parentheses" do
+          expect(subject).to eq mock_result
+        end
+      end
     end
   end
 
   describe "#load_from_fedora" do
     let(:relation) { ActiveFedora::Relation.new(ActiveFedora::Base) }
-    before { @obj = SpecModel::Basic.create(pid: "test:123") }
+    before { @obj = SpecModel::Basic.create(id: "test:123") }
     after { @obj.destroy }
     it "should cast when klass == ActiveFedora::Base and cast argument is nil" do
       expect(relation.send(:load_from_fedora, "test:123", nil)).to be_a SpecModel::Basic