active-fedora 9.4.3 → 9.5.0

data/spec/unit/finder_methods_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe ActiveFedora::FinderMethods do
+  let(:object_class) do
+    Class.new do
+      def self.delegated_attributes
+        {}
+      end
+    end
+  end
+
+  let(:finder_class) do
+    this = self
+    Class.new do
+      include ActiveFedora::FinderMethods
+      @@klass = this.object_class
+      def initialize
+        @klass = @@klass
+      end
+    end
+  end
+
+  let(:finder) { finder_class.new }
+
+  describe "#condition_to_clauses" do
+    subject { finder.send(:condition_to_clauses, key, value) }
+    let(:key) { 'library_id' }
+
+    context "when value is nil" do
+      let(:value) { nil }
+      it { is_expected.to eq "-library_id:[* TO *]" }
+    end
+
+    context "when value is empty string" do
+      let(:value) { '' }
+      it { is_expected.to eq "-library_id:[* TO *]" }
+    end
+
+    context "when value is an id" do
+      let(:value) { 'one/two/three' }
+      it { is_expected.to eq "_query_:\"{!raw f=library_id}one/two/three\"" }
+    end
+
+    context "when value is an array" do
+      let(:value) { ['one', 'four'] }
+      it { is_expected.to eq "_query_:\"{!raw f=library_id}one\" AND " \
+                             "_query_:\"{!raw f=library_id}four\"" }
+    end
+  end
+end

data/spec/unit/fixity_service_spec.rb

@@ -24,20 +24,44 @@ describe ActiveFedora::FixityService do
   end
 
   describe "#check" do
-    before do
-      allow(service).to receive(:get_fixity_response_from_fedora).and_return(response)
-    end
+    before { allow(service).to receive(:get_fixity_response_from_fedora).and_return(response) }
     subject { service.check }
-    context "with a passing result" do
-      let(:response) do
-        instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "SUCCESS"^^<http://www.w3.org/2001/XMLSchema#string> .')
+    
+    context "with Fedora version >= 4.4.0" do
+      context "with a passing result" do
+        let(:response) do
+          instance_double("Response", body: '<subject> <http://www.loc.gov/premis/rdf/v1#hasEventOutcome> "SUCCESS"^^<http://www.w3.org/2001/XMLSchema#string> .')
+        end
+        it { is_expected.to be true }
+      end
+
+      context "with a failing result" do
+        let(:response) do
+          instance_double("Response", body: '<subject> <http://www.loc.gov/premis/rdf/v1#hasEventOutcome> "BAD_CHECKSUM"^^<http://www.w3.org/2001/XMLSchema#string> .')
+        end
+        it { is_expected.to be false }
+      end
+    end
+
+    context "with Fedora version < 4.4.0" do
+      context "with a passing result" do
+        let(:response) do
+          instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "SUCCESS"^^<http://www.w3.org/2001/XMLSchema#string> .')
+        end
+        it { is_expected.to be true }
+      end
+
+      context "with a failing result" do
+        let(:response) do
+          instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "BAD_CHECKSUM"^^<http://www.w3.org/2001/XMLSchema#string> .')
+        end
+        it { is_expected.to be false }
       end
-      it { is_expected.to be true }
     end
 
-    context "with a failing result" do
+    context "with a non-existent predicate" do
       let(:response) do
-        instance_double("Response", body: '<subject> <http://fedora.info/definitions/v4/repository#status> "BAD_CHECKSUM"^^<http://www.w3.org/2001/XMLSchema#string> .')
+        instance_double("Response", body: '<subject> <http://bogus.com/definitions/v1/bogusTerm#foo> "SUCCESS"^^<http://www.w3.org/2001/XMLSchema#string> .')
       end
       it { is_expected.to be false }
     end

data/spec/unit/query_spec.rb

@@ -7,9 +7,9 @@ describe ActiveFedora::Base do
       class Basic < ActiveFedora::Base
       end
     end
-    @model_query = "_query_:\"{!raw f=" + ActiveFedora::SolrQueryBuilder.solr_name("has_model", :symbol) + "}SpecModel::Basic" + "\""
-    @sort_query = ActiveFedora::SolrQueryBuilder.solr_name("system_create", :stored_sortable, type: :date) + ' asc'
   end
+  let(:sort_query) { ActiveFedora::SolrQueryBuilder.solr_name("system_create", :stored_sortable, type: :date) + ' asc' }
+  let(:model_query) { "_query_:\"{!raw f=has_model_ssim}SpecModel::Basic\"" }
 
   after(:all) do
     Object.send(:remove_const, :SpecModel)
@@ -19,28 +19,40 @@ describe ActiveFedora::Base do
     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
-        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")
-        mock_docs = [{"id" => "changeme:30"}, {"id" => "changeme:22"}]
+
+      it "queries solr for all objects with has_model_ssim of self.class" 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")
+        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(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"]
       end
     end
+
     describe "called without a specific class" do
       let(:relation) { ActiveFedora::Relation.new(ActiveFedora::Base) }
-      it "should specify a q parameter" do
-        expect(relation).to receive(:load_from_fedora).with("changeme:30", true).and_return("Fake Object1")
-        expect(relation).to receive(:load_from_fedora).with("changeme:22", true).and_return("Fake Object2")
+      it "specifies a q parameter" do
+        expect(relation).to receive(:load_from_fedora).with("changeme:30", true)
+          .and_return("Fake Object1")
+        expect(relation).to receive(:load_from_fedora).with("changeme:22", true)
+          .and_return("Fake Object2")
         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::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"]
       end
     end
   end
-  
+
   describe '#find' do
     describe "with :cast false" do
       describe "and an id is specified" do
@@ -66,12 +78,15 @@ describe ActiveFedora::Base do
     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_query) { "#{model_query} AND " \
+                           "_query_:\"{!raw f=foo}bar\" AND " \
+                           "_query_:\"{!raw f=baz}quix\" AND " \
+                           "_query_:\"{!raw f=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"}] }
 
-    it "should filter by the provided fields" do
+    it "filters 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")
 
@@ -80,42 +95,53 @@ describe ActiveFedora::Base do
       expect(SpecModel::Basic.where({:foo=>'bar', :baz=>['quix','quack']})).to eq ["Fake Object1", "Fake Object2"]
     end
 
-    it "should correctly query for empty strings" do
-      expect(SpecModel::Basic.where( :active_fedora_model_ssi => '').count).to eq 0
+    it "queries for empty strings" do
+      expect(SpecModel::Basic.where(active_fedora_model_ssi: '').count).to eq 0
     end
 
-    it 'should correctly query for empty arrays' do
-      expect(SpecModel::Basic.where( :active_fedora_model_ssi => []).count).to eq 0
+    it 'queries for empty arrays' 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 "adds 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"]
+      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(: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"}]
       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})
-
-      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'))
+      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 })
+
+      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(:expected_query) { "#{model_query} AND " \
+                             "_query_:\"{!raw f=foo}bar\" AND " \
+                             "_query_:\"{!raw f=baz}quix\" AND " \
+                             "_query_:\"{!raw f=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
@@ -132,8 +158,11 @@ describe ActiveFedora::Base do
   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(:expected_query) { "#{model_query} AND " \
+                             "_query_:\"{!raw f=foo}bar\" AND " \
+                             "_query_:\"{!raw f=baz}quix\" AND " \
+                             "_query_:\"{!raw f=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
@@ -147,22 +176,27 @@ describe ActiveFedora::Base do
   end
 
   describe '#count' 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)
+    let(:mock_result) { { 'response' => { 'numFound' => 7 } } }
+
+    it "returns a count" do
+      expect(ActiveFedora::SolrService).to receive(:query)
+        .with(model_query, rows: 0, raw: true)
+        .and_return(mock_result)
       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
+
+    it "allows conditions" do
+      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
     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 
+    it "counts without a class specified" do
+      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
     end
   end
 
@@ -200,37 +234,44 @@ describe ActiveFedora::Base do
         SpecModel::Basic.first != @c 
       end
     end
-    describe 'with one object' do 
-      it 'should equal the first object when there is only one' do
+    describe 'with one object' do
+      it 'equals the first object when there is only one' do
         a = SpecModel::Basic.create!
         SpecModel::Basic.first == SpecModel::Basic.last
       end
     end
   end
-  
+
   describe '#find_with_conditions' do
     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)
+      expect(ActiveFedora::SolrService).to receive(:query)
+        .with(expected_query, sort: [sort_query]).and_return(mock_result)
     end
 
     context "with a hash of conditions" do
-      let(:expected_query) { "#{@model_query} AND foo:bar AND baz:quix AND baz:quack" }
+      let(:expected_query) { "#{model_query} AND " \
+                             "_query_:\"{!raw f=foo}bar\" AND " \
+                             "_query_:\"{!raw f=baz}quix\" AND " \
+                             "_query_:\"{!raw f=baz}quack\"" }
       let(:conditions) { { foo: 'bar', baz: ['quix', 'quack'] } }
 
-      it "should make a query to solr and return the results" do
+      it "makes a query to solr and returns the results" do
         expect(subject).to eq mock_result
       end
     end
 
     context "with quotes in the params" do
-      let(:expected_query) { "#{@model_query} AND foo:9\\\"\\ Nails AND baz:7\\\"\\ version AND baz:quack" }
+      let(:expected_query) { "#{model_query} AND " \
+                             "_query_:\"{!raw f=foo}9\\\" Nails\" AND " \
+                             "_query_:\"{!raw f=baz}7\\\" version\" AND " \
+                             "_query_:\"{!raw f=baz}quack\"" }
       let(:conditions) { { foo: '9" Nails', baz: ['7" version', 'quack']} }
 
-      it "should escape quotes" do
+      it "escapes quotes" do
         expect(subject).to eq mock_result
       end
     end
@@ -240,8 +281,8 @@ describe ActiveFedora::Base do
 
       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
+        let(:expected_query) { "_query_:\"{!raw f=baz}quack\"" }
+        it "doesn't use the class if it's called on AF:Base " do
           expect(subject).to eq mock_result
         end
       end
@@ -249,7 +290,7 @@ describe ActiveFedora::Base do
       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
+        it "uses the query string if it's provided and wrap it in parentheses" do
           expect(subject).to eq mock_result
         end
       end

data/spec/unit/solr_config_options_spec.rb

@@ -27,11 +27,15 @@ describe ActiveFedora do
       expect(@test_object.to_solr[:id]).to be_nil
     end
 
-    it "should be used by ActiveFedora::Base#find_with_conditions" do
+    it "is used by ActiveFedora::Base#find_with_conditions" do
       mock_response = double("SolrResponse")
-      expect(ActiveFedora::SolrService).to receive(:query).with("_query_:\"{!raw f=#{ActiveFedora::SolrQueryBuilder.solr_name("has_model", :symbol)}}SolrSpecModel::Basic\" AND " + SOLR_DOCUMENT_ID + ':changeme\\:30', {:sort => ["#{ActiveFedora::SolrQueryBuilder.solr_name("system_create", :stored_sortable, type: :date)} asc"]}).and_return(mock_response)
+      expect(ActiveFedora::SolrService).to receive(:query)
+        .with("_query_:\"{!raw f=has_model_ssim}SolrSpecModel::Basic\" AND " \
+              "_query_:\"{!raw f=MY_SAMPLE_ID}changeme:30\"",
+              sort: ["#{ActiveFedora::SolrQueryBuilder.solr_name("system_create", :stored_sortable, type: :date)} asc"])
+        .and_return(mock_response)
 
-      expect(SolrSpecModel::Basic.find_with_conditions(:id=>"changeme:30")).to equal(mock_response)
+      expect(SolrSpecModel::Basic.find_with_conditions(id: "changeme:30")).to equal(mock_response)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active-fedora
 version: !ruby/object:Gem::Version
-  version: 9.4.3
+  version: 9.5.0
 platform: ruby
 authors:
 - Matt Zumwalt
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-30 00:00:00.000000000 Z
+date: 2015-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rsolr
@@ -284,6 +284,7 @@ files:
 - gemfiles/rails4.2.gemfile
 - lib/active-fedora.rb
 - lib/active_fedora.rb
+- lib/active_fedora/association_hash.rb
 - lib/active_fedora/association_relation.rb
 - lib/active_fedora/associations.rb
 - lib/active_fedora/associations/association.rb
@@ -480,6 +481,7 @@ files:
 - spec/integration/clean_connection_spec.rb
 - spec/integration/collection_association_spec.rb
 - spec/integration/complex_rdf_datastream_spec.rb
+- spec/integration/contains_association_spec.rb
 - spec/integration/datastream_rdf_nested_attributes_spec.rb
 - spec/integration/delete_all_spec.rb
 - spec/integration/direct_container_spec.rb
@@ -542,6 +544,7 @@ files:
 - spec/unit/file_path_builder_spec.rb
 - spec/unit/file_spec.rb
 - spec/unit/files_hash_spec.rb
+- spec/unit/finder_methods_spec.rb
 - spec/unit/fixity_service_spec.rb
 - spec/unit/forbidden_attributes_protection_spec.rb
 - spec/unit/has_and_belongs_to_many_association_spec.rb