active-fedora 8.7.0 → 9.0.0.beta1

data/spec/integration/om_datastream_spec.rb

@@ -1,168 +1,79 @@
 require 'spec_helper'
-require "solrizer"
 
 describe ActiveFedora::OmDatastream do
-  
-  describe "a new instance with an inline datastream" do
-    before(:all) do 
-      class ModsArticle3 < ActiveFedora::Base
-        # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata "descMetadata", type: Hydra::ModsArticleDatastream, control_group: 'X', autocreate: true
-      end
+  before(:all) do
+    class ModsArticle2 < ActiveFedora::Base
+      # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
+      has_metadata "descMetadata", type: Hydra::ModsArticleDatastream, autocreate: true
     end
+  end
 
-    after(:all) do
-      Object.send(:remove_const, :ModsArticle3)
-    end
+  after(:all) do
+    Object.send(:remove_const, :ModsArticle2)
+  end
 
-    before(:each) do
-      @obj = ModsArticle3.new
-      @obj.save
-      @obj.reload
-    end
+  let(:obj) { ModsArticle2.create.reload }
 
-    after(:each) do
-      @obj.destroy
-    end
+  after(:each) do
+    obj.destroy
+  end
 
-    it "should report being inline" do
-      expect(@obj.descMetadata).to be_inline
-    end
+  subject { obj.descMetadata }
 
+  describe "#changed?" do
     it "should not be changed when no fields have been set" do
-      expect(@obj.descMetadata).not_to be_changed
+      expect(subject).to_not be_content_changed
     end
     it "should be changed when a field has been set" do
-      @obj.descMetadata.title = 'Foobar'
-      expect(@obj.descMetadata).to be_changed
-    end
-    describe "#changed?" do
-      it "should not be changed if the new xml matches the old xml" do
-        @obj.descMetadata.content = @obj.descMetadata.content
-        expect(@obj.descMetadata).not_to be_changed
-      end
-
-      it "should not be changed if there are minor differences in whitespace" do
-        @obj.descMetadata.content = "<a><b>1</b></a>"
-        @obj.save
-        expect(@obj.descMetadata).not_to be_changed
-        @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        expect(@obj.descMetadata).not_to be_changed
-      end
-    end
-  end
-
-  describe "an instance that is a managed datastream" do
-    before(:all) do
-      class ModsArticle2 < ActiveFedora::Base
-        # Uses the Hydra MODS Article profile for tracking most of the descriptive metadata
-        has_metadata "descMetadata", type: Hydra::ModsArticleDatastream, autocreate: true
-      end
+      subject.title = 'Foobar'
+      expect(subject).to be_content_changed
     end
-
-    after(:all) do
-      Object.send(:remove_const, :ModsArticle2)
-    end
-
-    before(:each) do
-      @obj = ModsArticle2.new
-      @obj.save
-      @obj.reload
+    it "should not be changed if the new xml matches the old xml" do
+      subject.content = subject.content
+      expect(subject).to_not be_changed
     end
 
-    after(:each) do
-      @obj.destroy
+    it "should be changed if there are minor differences in whitespace" do
+      subject.content = "<a><b>1</b></a>"
+      obj.save
+      expect(subject).to_not be_changed
+      subject.content = "<a>\n<b>1</b>\n</a>"
+      expect(subject).to be_changed
     end
+  end
 
-    it "should not report being inline" do
-      expect(@obj.descMetadata).to be_managed
+  describe "empty datastream content" do
+    it "should not break when there is empty datastream content" do
+      subject.content = ""
+      obj.save
     end
+  end
 
-    describe "#changed?" do
-      it "should not be changed if the new xml matches the old xml" do
-        @obj.descMetadata.content = @obj.descMetadata.content
-        expect(@obj.descMetadata).not_to be_changed
-      end
-
-      it "should be changed if there are minor differences in whitespace" do
-        @obj.descMetadata.content = "<a><b>1</b></a>"
-        @obj.save
-        expect(@obj.descMetadata).not_to be_changed
-        @obj.descMetadata.content = "<a>\n<b>1</b>\n</a>"
-        expect(@obj.descMetadata).to be_changed
-      end
+  describe '.update_values' do
+    before do
+      subject.content = File.read(fixture('mods_articles/mods_article1.xml'))
+      obj.save
+      obj.reload
     end
 
-    describe "empty datastream content" do
-      it "should not break when there is empty datastream content" do
-        @obj.descMetadata.content = ""
-        @obj.save
-      end
+    it "should not be dirty after .update_values is saved" do
+      obj.descMetadata.update_values([{:name=>0},{:role=>0},:text] =>"Funder")
+      expect(obj.descMetadata).to be_changed
+      obj.save
+      expect(obj.descMetadata).to_not be_changed
+      expect(obj.descMetadata.term_values({:name=>0},{:role=>0},:text)).to eq ["Funder"]
     end
+  end
 
-    describe '.term_values' do
-      before do
-        @obj.descMetadata.content = File.read(fixture('mods_articles/mods_article1.xml'))
-        @obj.save
-        @obj.reload
-        @solr_obj = ActiveFedora::Base.load_instance_from_solr(@obj.pid)
-      end
-
-      it "should return the same values whether getting from solr or Fedora" do
-        expect(@solr_obj.datastreams["descMetadata"].term_values(:name,:role,:text)).to eq(["Creator","Contributor","Funder","Host"])
-        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text)).to eq(["Creator"])
-        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text)).to eq(["Contributor"])
-        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Creator"])
-        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text)).to eq(["Contributor"])
-        expect(@solr_obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text)).to eq([])
-        ar = @solr_obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        expect(ar.length).to eq(4)
-        expect(ar.include?("Creator")).to eq(true)
-        expect(ar.include?("Contributor")).to eq(true)
-        expect(ar.include?("Funder")).to eq(true)
-        expect(ar.include?("Host")).to eq(true)
-
-        expect(@obj.datastreams["descMetadata"].term_values(:name,:role,:text)).to eq(["Creator","Contributor","Funder","Host"])
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},:role,:text)).to eq(["Creator"])
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},:role,:text)).to eq(["Contributor"])
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Creator"])
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>0},:text)).to eq(["Contributor"])
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>1},{:role=>1},:text)).to eq([])
-        ar = @obj.datastreams["descMetadata"].term_values(:name,{:role=>0},:text)
-        expect(ar.length).to eq(4)
-        expect(ar.include?("Creator")).to eq(true)
-        expect(ar.include?("Contributor")).to eq(true)
-        expect(ar.include?("Funder")).to eq(true)
-        expect(ar.include?("Host")).to eq(true)
-      end
-    end
-    
-    describe '.update_values' do
-      before do
-        @obj.descMetadata.content = File.read(fixture('mods_articles/mods_article1.xml'))
-        @obj.save
-        @obj.reload
-      end
 
-      it "should not be dirty after .update_values is saved" do
-        @obj.datastreams["descMetadata"].update_values([{:name=>0},{:role=>0},:text] =>"Funder")
-        expect(@obj.datastreams["descMetadata"]).to be_changed
-        @obj.save
-        expect(@obj.datastreams["descMetadata"]).not_to be_changed
-        expect(@obj.datastreams["descMetadata"].term_values({:name=>0},{:role=>0},:text)).to eq(["Funder"])
-      end    
+  describe ".to_solr" do
+    before do
+      subject.journal.issue.publication_date = Date.parse('2012-11-02')
+      obj.save!
+      obj.reload
     end
-
-
-    describe ".to_solr" do
-      before do
-        @obj.descMetadata.journal.issue.publication_date = Date.parse('2012-11-02')
-        @obj.save!
-        @obj.reload
-      end
-      it "should solrize terms with :type=>'date' to *_dt solr terms" do
-        expect(@obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)]).to eq(['2012-11-02T00:00:00Z'])
-      end
+    it "should solrize terms with :type=>'date' to *_dt solr terms" do
+      expect(obj.to_solr[ActiveFedora::SolrService.solr_name('desc_metadata__journal_issue_publication_date', type: :date)]).to eq ['2012-11-02T00:00:00Z']
     end
   end
 end

data/spec/integration/rdf_nested_attributes_spec.rb

@@ -2,9 +2,11 @@ require 'spec_helper'
 
 describe "Nesting attribute behavior of RDFDatastream" do
   describe ".attributes=" do
+
     describe "complex properties" do
       before do
         class DummyMADS < RDF::Vocabulary("http://www.loc.gov/mads/rdf/v1#")
+  # TODO this test is order dependent. It expects to use the object created in the previous test
           # componentList and Types of components
           property :componentList
           property :Topic
@@ -27,7 +29,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
         class ComplexRDFDatastream < ActiveFedora::NtriplesRDFDatastream
           property :topic, predicate: DummyMADS.Topic, class_name: "Topic"
           property :personalName, predicate: DummyMADS.PersonalName, class_name: "PersonalName"
-          property :title, predicate: RDF::DC.title
+          property :title, predicate: ::RDF::DC.title
 
 
           accepts_nested_attributes_for :topic, :personalName
@@ -61,7 +63,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
         Object.send(:remove_const, :ComplexRDFDatastream)
         Object.send(:remove_const, :DummyMADS)
       end
-      subject { ComplexRDFDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
+      subject { ComplexRDFDatastream.new }
       let(:params) do
         { myResource:
           {
@@ -100,14 +102,14 @@ describe "Nesting attribute behavior of RDFDatastream" do
         subject { ComplexRDFDatastream::PersonalName.new(RDF::Graph.new) }
         it "should accept a hash" do
           subject.elementList_attributes =  [{ topicElement_attributes: {'0' => { elementValue:"Quantum Behavior" }, '1' => { elementValue:"Wave Function" }}}]
-          expect(subject.elementList.first[0].elementValue).to eq(["Quantum Behavior"])
-          expect(subject.elementList.first[1].elementValue).to eq(["Wave Function"])
+          expect(subject.elementList.first[0].elementValue).to eq ["Quantum Behavior"]
+          expect(subject.elementList.first[1].elementValue).to eq ["Wave Function"]
 
         end
         it "should accept an array" do
           subject.elementList_attributes =  [{ topicElement_attributes: [{ elementValue:"Quantum Behavior" }, { elementValue:"Wave Function" }]}]
-          expect(subject.elementList.first[0].elementValue).to eq(["Quantum Behavior"])
-          expect(subject.elementList.first[1].elementValue).to eq(["Wave Function"])
+          expect(subject.elementList.first[0].elementValue).to eq ["Quantum Behavior"]
+          expect(subject.elementList.first[1].elementValue).to eq ["Wave Function"]
         end
       end
 
@@ -118,10 +120,10 @@ describe "Nesting attribute behavior of RDFDatastream" do
         end
 
         it 'should have attributes' do
-          expect(subject.topic[0].elementList.first[0].elementValue).to eq(["Cosmology"])
-          expect(subject.topic[1].elementList.first[0].elementValue).to eq(["Quantum Behavior"])
-          expect(subject.personalName.first.elementList.first.fullNameElement).to eq(["Jefferson, Thomas"])
-          expect(subject.personalName.first.elementList.first.dateNameElement).to eq(["1743-1826"])
+          expect(subject.topic[0].elementList.first[0].elementValue).to eq ["Cosmology"]
+          expect(subject.topic[1].elementList.first[0].elementValue).to eq ["Quantum Behavior"]
+          expect(subject.personalName.first.elementList.first.fullNameElement).to eq ["Jefferson, Thomas"]
+          expect(subject.personalName.first.elementList.first.dateNameElement).to eq ["1743-1826"]
         end
         
         it 'should build nodes with ids' do
@@ -144,11 +146,11 @@ describe "Nesting attribute behavior of RDFDatastream" do
     describe "with an existing object" do
       before(:each) do
         class SpecDatastream < ActiveFedora::NtriplesRDFDatastream
-          property :parts, predicate: RDF::DC.hasPart, :class_name=>'Component'
+          property :parts, predicate: ::RDF::DC.hasPart, :class_name=>'Component'
           accepts_nested_attributes_for :parts, allow_destroy: true
 
           class Component < ActiveTriples::Resource
-            property :label, predicate: RDF::DC.title
+            property :label, predicate: ::RDF::DC.title
           end
         end
 
@@ -157,7 +159,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       after(:each) do
         Object.send(:remove_const, :SpecDatastream)
       end
-      subject { SpecDatastream.new(double('inner object', :pid=>'foo', :new_record? =>true), 'descMetadata') }
+      subject { SpecDatastream.new }
       before do
         subject.attributes = { parts_attributes: [
                                   {label: 'Alternator'},
@@ -171,7 +173,7 @@ describe "Nesting attribute behavior of RDFDatastream" do
       it "should update nested objects" do
         subject.parts_attributes= [{id: replace_object_id, label: "Universal Joint"}, {label:"Oil Pump"}, {id: remove_object_id, _destroy: '1', label: "bar1 uno"}]
 
-        expect(subject.parts.map{|p| p.label.first}).to eq(['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump'])
+        expect(subject.parts.map{|p| p.label.first}).to eq ['Alternator', 'Universal Joint', 'Transmission', 'Oil Pump']
 
       end
       it "create a new object when the id is provided" do

data/spec/integration/relation_delegation_spec.rb

@@ -22,7 +22,7 @@ describe ActiveFedora::Model do
     end
 
   end
-  
+
   after(:all) do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
@@ -33,16 +33,14 @@ describe ActiveFedora::Model do
     let!(:instance2){ ModelIntegrationSpec::Basic.create!(foo: ['Alpha'], bar: ['Peanuts'])}
     let!(:instance3){ ModelIntegrationSpec::Basic.create!(foo: ['Sigma'], bar: ['Peanuts'])}
 
-    after { ModelIntegrationSpec::Basic.delete_all }
-
     subject { ModelIntegrationSpec::Basic.where(bar: 'Peanuts') }
 
     it "should map" do
-      expect(subject.map(&:id)).to eq([instance2.id, instance3.id])
+      expect(subject.map(&:id)).to eq [instance2.id, instance3.id]
     end
 
     it "should collect" do
-      expect(subject.collect(&:id)).to eq([instance2.id, instance3.id])
+      expect(subject.collect(&:id)).to eq [instance2.id, instance3.id]
     end
 
     it "should have each" do
@@ -52,13 +50,13 @@ describe ActiveFedora::Model do
     end
 
     it "should have all?" do
-      expect(subject.all? { |t| t.foo == ['Alpha']}).to be_falsey
-      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be_truthy
+      expect(subject.all? { |t| t.foo == ['Alpha']}).to be false
+      expect(subject.all? { |t| t.bar == ['Peanuts']}).to be true
     end
 
     it "should have include?" do
-      expect(subject.include?(instance1)).to be_falsey
-      expect(subject.include?(instance2)).to be_truthy
+      expect(subject.include?(instance1)).to be false
+      expect(subject.include?(instance2)).to be true
     end
   end
 end

data/spec/integration/relation_spec.rb

@@ -2,21 +2,23 @@ require 'spec_helper'
 
 describe ActiveFedora::Base do
   before :all do
-    class Library < ActiveFedora::Base 
-      has_many :books, property: :has_member
+    class Library < ActiveFedora::Base
+      has_many :books, predicate: ActiveFedora::RDF::RelsExt.isPartOf
     end
     class Book < ActiveFedora::Base; end
   end
   after :all do
-    Library.delete_all
     Object.send(:remove_const, :Library)
     Object.send(:remove_const, :Book)
   end
 
-  subject { Library.all } 
-  its(:class) {is_expected.to eq ActiveFedora::Relation }
+  subject { Library.all }
 
-  before :all do
+  it "should be a relation" do
+    expect(subject.class).to be ActiveFedora::Relation
+  end
+
+  before :each do
     Library.create
     @library = Library.create
   end
@@ -32,7 +34,7 @@ describe ActiveFedora::Base do
       expect(subject).to be_loaded
     end
     it "shouldn't reload" do
-      expect_any_instance_of(ActiveFedora::Relation).not_to receive :find_each
+      expect_any_instance_of(ActiveFedora::Relation).to_not receive :find_each
       subject[0]
     end
   end

data/spec/integration/scoped_query_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe "scoped queries" do
 
-  before do 
+  before do
     module ModelIntegrationSpec
       class Basic < ActiveFedora::Base
         has_metadata "properties", type: ActiveFedora::SimpleDatastream do |m|
@@ -18,12 +18,12 @@ describe "scoped queries" do
           doc[ActiveFedora::SolrService.solr_name('foo', :sortable)] = doc[ActiveFedora::SolrService.solr_name('foo', type: :string)]
           doc
         end
-      
+
       end
     end
 
   end
-  
+
   after do
     Object.send(:remove_const, :ModelIntegrationSpec)
   end
@@ -35,30 +35,28 @@ describe "scoped queries" do
     after do
       test_instance.delete
     end
-    
+
     describe ".all" do
       it "should return an array of instances of the calling Class" do
         result = ModelIntegrationSpec::Basic.all.to_a
         expect(result).to be_instance_of(Array)
         # this test is meaningless if the array length is zero
-        expect(result.length).to be > 0
-        result.each do |obj|
-          expect(obj.class).to eq(ModelIntegrationSpec::Basic)
-        end
+        expect(result.length > 0).to be true
+        expect(result).to all( be_an ModelIntegrationSpec::Basic )
       end
     end
 
     describe ".first" do
       it "should return one instance of the calling class" do
-        expect(ModelIntegrationSpec::Basic.first).to eq(test_instance)
+        expect(ModelIntegrationSpec::Basic.first).to eq test_instance
       end
     end
   end
 
   describe "with multiple objects" do
-    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(foo: ['Beta'], bar: ['Chips']) }
-    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(foo: ['Alpha'], bar: ['Peanuts']) }
-    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(foo: ['Sigma'], bar: ['Peanuts']) }
+    let!(:test_instance1) { ModelIntegrationSpec::Basic.create!(foo: ['Beta'], bar: ['Chips'])}
+    let!(:test_instance2) { ModelIntegrationSpec::Basic.create!(foo: ['Alpha'], bar: ['Peanuts'])}
+    let!(:test_instance3) { ModelIntegrationSpec::Basic.create!(foo: ['Sigma'], bar: ['Peanuts'])}
 
     describe "when the objects are in fedora" do
       after do
@@ -66,34 +64,36 @@ describe "scoped queries" do
         test_instance2.delete
         test_instance3.delete
       end
+
       it "should query" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('foo', type: :string)=> 'Beta')).to eq([test_instance1])
-        expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq([test_instance1])
+        field = ActiveFedora::SolrService.solr_name('foo', type: :string)
+        expect(ModelIntegrationSpec::Basic.where(field => 'Beta')).to eq [test_instance1]
+        expect(ModelIntegrationSpec::Basic.where('foo' => 'Beta')).to eq [test_instance1]
       end
       it "should order" do
-        expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq([test_instance2, test_instance1, test_instance3])
+        expect(ModelIntegrationSpec::Basic.order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc')).to eq [test_instance2, test_instance1, test_instance3]
       end
       it "should limit" do
-        expect(ModelIntegrationSpec::Basic.limit(1)).to eq([test_instance1])
+        expect(ModelIntegrationSpec::Basic.limit(1)).to eq [test_instance1]
       end
       it "should offset" do
-        expect(ModelIntegrationSpec::Basic.offset(1)).to eq([test_instance2, test_instance3])
+        expect(ModelIntegrationSpec::Basic.offset(1)).to eq [test_instance2, test_instance3]
       end
 
       it "should chain queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq([test_instance2])
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').order(ActiveFedora::SolrService.solr_name('foo', :sortable) + ' asc').limit(1)).to eq [test_instance2]
       end
 
       it "should wrap string conditions with parentheses" do
-        expect(ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values).to eq(["(foo:bar OR bar:baz)"])
+        expect(ModelIntegrationSpec::Basic.where("foo:bar OR bar:baz").where_values).to eq ["(foo:bar OR bar:baz)"]
       end
 
       it "should chain where queries" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values).to eq(["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"])
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').where("#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar").where_values).to eq ["#{ActiveFedora::SolrService.solr_name('bar', type: :string)}:Peanuts", "(#{ActiveFedora::SolrService.solr_name('foo', type: :string)}:bar)"]
       end
 
       it "should chain count" do
-        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq(2) 
+        expect(ModelIntegrationSpec::Basic.where(ActiveFedora::SolrService.solr_name('bar', type: :string) => 'Peanuts').count).to eq 2
       end
 
       it "calling first should not affect the relation's ability to get all results later" do
@@ -113,19 +113,19 @@ describe "scoped queries" do
     end
 
     describe "when one of the objects in solr isn't in fedora" do
-      let!(:pid) { test_instance2.pid }
-      before { test_instance2.inner_object.delete }
+      let!(:id) { test_instance2.id }
+      before { Ldp::Resource::RdfSource.new(ActiveFedora.fedora.connection, test_instance2.uri).delete }
       after do
         ActiveFedora::SolrService.instance.conn.tap do |conn|
-          conn.delete_by_query "id:\"#{pid}\""
+          conn.delete_by_query "id:\"#{id}\""
           conn.commit
         end
         test_instance1.delete
         test_instance3.delete
       end
       it "should log an error" do
-        expect(ActiveFedora::Base.logger).to receive(:error).with("Although #{pid} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
-        expect(ModelIntegrationSpec::Basic.all).to eq([test_instance1, test_instance3])
+        expect(ActiveFedora::Base.logger).to receive(:error).with("Although #{id} was found in Solr, it doesn't seem to exist in Fedora. The index is out of synch.")
+        expect(ModelIntegrationSpec::Basic.all).to eq [test_instance1, test_instance3]
       end
     end
   end