active-fedora 9.9.1 → 9.10.0.pre1

data/spec/unit/query_spec.rb

@@ -7,8 +7,8 @@ describe ActiveFedora::Base do
       end
     end
   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\"" }
+  let(:sort_query) { ActiveFedora.index_field_mapper.solr_name("system_create", :stored_sortable, type: :date) + ' asc' }
+  let(:model_query) { "_query_:\"{!field f=has_model_ssim}SpecModel::Basic\"" }
 
   after(:all) do
     Object.send(:remove_const, :SpecModel)
@@ -77,9 +77,9 @@ describe ActiveFedora::Base do
     let(:relation) { ActiveFedora::Relation.new(SpecModel::Basic) }
     let(:solr) { ActiveFedora::SolrService.instance.conn }
     let(:expected_query) { "#{model_query} AND " \
-                           "_query_:\"{!raw f=foo}bar\" AND " \
-                           "_query_:\"{!raw f=baz}quix\" AND " \
-                           "_query_:\"{!raw f=baz}quack\"" }
+                           "_query_:\"{!field f=foo}bar\" AND " \
+                           "_query_:\"{!field f=baz}quix\" AND " \
+                           "_query_:\"{!field 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" }] }
@@ -136,9 +136,9 @@ describe ActiveFedora::Base do
     describe "with conditions" do
       let(:solr) { ActiveFedora::SolrService.instance.conn }
       let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!raw f=foo}bar\" AND " \
-                             "_query_:\"{!raw f=baz}quix\" AND " \
-                             "_query_:\"{!raw f=baz}quack\"" }
+                             "_query_:\"{!field f=foo}bar\" AND " \
+                             "_query_:\"{!field f=baz}quix\" AND " \
+                             "_query_:\"{!field 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" }] }
 
@@ -153,13 +153,13 @@ describe ActiveFedora::Base do
     end
   end
 
-  describe '#find_in_batches' do
+  describe '#search_in_batches' do
     describe "with conditions hash" do
       let(:solr) { ActiveFedora::SolrService.instance.conn }
       let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!raw f=foo}bar\" AND " \
-                             "_query_:\"{!raw f=baz}quix\" AND " \
-                             "_query_:\"{!raw f=baz}quack\"" }
+                             "_query_:\"{!field f=foo}bar\" AND " \
+                             "_query_:\"{!field f=baz}quix\" AND " \
+                             "_query_:\"{!field f=baz}quack\"" }
       let(:expected_params) { { params: { sort: [sort_query], fl: 'id', q: expected_query, qt: 'standard' } } }
       let(:mock_docs) { double('docs') }
 
@@ -168,7 +168,7 @@ describe ActiveFedora::Base do
         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.search_in_batches({ foo: 'bar', baz: ['quix', 'quack'] }, batch_size: 1002, fl: 'id') { |group| yielded.run group }
       end
     end
   end
@@ -177,22 +177,22 @@ describe ActiveFedora::Base do
     let(:mock_result) { { 'response' => { 'numFound' => 7 } } }
 
     it "returns a count" do
-      expect(ActiveFedora::SolrService).to receive(:query)
-        .with(model_query, rows: 0, raw: true)
+      expect(ActiveFedora::SolrService).to receive(:get)
+        .with(model_query, rows: 0)
         .and_return(mock_result)
       expect(SpecModel::Basic.count).to eq 7
     end
 
     it "allows conditions" do
-      expect(ActiveFedora::SolrService).to receive(:query)
-        .with("#{model_query} AND (foo:bar)", rows: 0, raw: true)
+      expect(ActiveFedora::SolrService).to receive(:get)
+        .with("#{model_query} AND (foo:bar)", rows: 0)
         .and_return(mock_result)
       expect(SpecModel::Basic.count(conditions: 'foo:bar')).to eq 7
     end
 
     it "counts without a class specified" do
-      expect(ActiveFedora::SolrService).to receive(:query)
-        .with("(foo:bar)", rows: 0, raw: true)
+      expect(ActiveFedora::SolrService).to receive(:get)
+        .with("(foo:bar)", rows: 0)
         .and_return(mock_result)
       expect(described_class.count(conditions: 'foo:bar')).to eq 7
     end
@@ -240,10 +240,10 @@ describe ActiveFedora::Base do
     end
   end
 
-  describe '#find_with_conditions' do
+  describe '#search_with_conditions' do
     let(:mock_result) { double('Result') }
     let(:klass) { SpecModel::Basic }
-    subject { klass.find_with_conditions(conditions) }
+    subject { klass.search_with_conditions(conditions) }
 
     before do
       expect(ActiveFedora::SolrService).to receive(:query)
@@ -252,9 +252,9 @@ describe ActiveFedora::Base do
 
     context "with a hash of conditions" do
       let(:expected_query) { "#{model_query} AND " \
-                             "_query_:\"{!raw f=foo}bar\" AND " \
-                             "_query_:\"{!raw f=baz}quix\" AND " \
-                             "_query_:\"{!raw f=baz}quack\"" }
+                             "_query_:\"{!field f=foo}bar\" AND " \
+                             "_query_:\"{!field f=baz}quix\" AND " \
+                             "_query_:\"{!field f=baz}quack\"" }
       let(:conditions) { { foo: 'bar', baz: ['quix', 'quack'] } }
 
       it "makes a query to solr and returns the results" do
@@ -264,9 +264,9 @@ describe ActiveFedora::Base do
 
     context "with quotes in the params" do
       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\"" }
+                             "_query_:\"{!field f=foo}9\\\" Nails\" AND " \
+                             "_query_:\"{!field f=baz}7\\\" version\" AND " \
+                             "_query_:\"{!field f=baz}quack\"" }
       let(:conditions) { { foo: '9" Nails', baz: ['7" version', 'quack'] } }
 
       it "escapes quotes" do
@@ -279,7 +279,7 @@ describe ActiveFedora::Base do
 
       context "with a hash" do
         let(:conditions) { { baz: 'quack' } }
-        let(:expected_query) { "_query_:\"{!raw f=baz}quack\"" }
+        let(:expected_query) { "_query_:\"{!field f=baz}quack\"" }
         it "doesn't use the class if it's called on AF:Base " do
           expect(subject).to eq mock_result
         end

data/spec/unit/rdf/indexing_service_spec.rb

@@ -47,25 +47,25 @@ describe ActiveFedora::RDF::IndexingService do
   describe "#generate_solr_document" do
     subject { indexer.generate_solr_document(lambda { |key| "solr_rdf__#{key}" }) }
     it "returns the right fields" do
-      expect(subject.keys).to include(ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__related_url", type: :string),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", type: :string),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :sortable),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :facetable),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__created", :sortable, type: :date),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__created", :displayable),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__title", type: :string),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__title", :sortable),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", type: :string),
-                                      ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", :facetable))
+      expect(subject.keys).to include(ActiveFedora.index_field_mapper.solr_name("solr_rdf__related_url", type: :string),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", type: :string),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :sortable),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :facetable),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__created", :sortable, type: :date),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__created", :displayable),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__title", type: :string),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__title", :sortable),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", type: :string),
+                                      ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", :facetable))
     end
 
     it "returns the right values" do
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", type: :string)]).to eq ["Tacoma, WA", "Renton, WA"]
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__based_near", :facetable)]).to eq ["Tacoma, WA", "Renton, WA"]
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
-      expect(subject[ActiveFedora::SolrQueryBuilder.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__related_url", type: :string)]).to eq ["http://example.org/blogtastic/"]
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", type: :string)]).to eq ["Tacoma, WA", "Renton, WA"]
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__based_near", :facetable)]).to eq ["Tacoma, WA", "Renton, WA"]
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", type: :string)]).to eq ["Bob's Blogtastic Publishing"]
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :sortable)]).to eq "Bob's Blogtastic Publishing"
+      expect(subject[ActiveFedora.index_field_mapper.solr_name("solr_rdf__publisher", :facetable)]).to eq ["Bob's Blogtastic Publishing"]
     end
   end
 

data/spec/unit/scoping_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe ActiveFedora::Scoping::Default do
+  describe "when default_scope is overridden" do
+    before do
+      class Book < ActiveFedora::Base
+        property :published, predicate: ::RDF::Vocab::EBUCore.pubStatus do |index|
+          index.as :symbol
+        end
+
+        def self.default_scope
+          where published_ssim: 'true'
+        end
+      end
+
+      Book.destroy_all
+      Book.create!(published: [true])
+      Book.create!(published: [true])
+      Book.create!(published: [false])
+    end
+
+    after do
+      Object.send(:remove_const, :Book)
+    end
+
+    it "returns only the scoped records" do
+      expect(Book.all.size).to eq 2
+    end
+
+    it "returns all the records" do
+      Book.unscoped do
+        expect(Book.all.size).to eq 3
+      end
+    end
+  end
+
+  describe "when default_scope is called" do
+    before do
+      class Book < ActiveFedora::Base
+        property :published, predicate: ::RDF::Vocab::EBUCore.pubStatus do |index|
+          index.as :symbol
+        end
+
+        default_scope -> { where published_ssim: 'true' }
+      end
+
+      Book.destroy_all
+      Book.create!(published: [true])
+      Book.create!(published: [true])
+      Book.create!(published: [false])
+    end
+
+    after do
+      Object.send(:remove_const, :Book)
+    end
+
+    it "returns only the scoped records" do
+      expect(Book.all.size).to eq 2
+    end
+
+    it "returns all the records" do
+      Book.unscoped do
+        expect(Book.all.size).to eq 3
+      end
+    end
+  end
+end

data/spec/unit/simple_datastream_spec.rb

@@ -54,8 +54,8 @@ describe ActiveFedora::SimpleDatastream do
   describe "#to_solr" do
     it "has title" do
       solr = @test_ds.to_solr
-      expect(solr[ActiveFedora::SolrQueryBuilder.solr_name('publisher', type: :string)]).to eq "publisher1"
-      expect(solr[ActiveFedora::SolrQueryBuilder.solr_name('creation_date', type: :date)]).to eq "2012-01-15"
+      expect(solr[ActiveFedora.index_field_mapper.solr_name('publisher', type: :string)]).to eq "publisher1"
+      expect(solr[ActiveFedora.index_field_mapper.solr_name('creation_date', type: :date)]).to eq "2012-01-15"
     end
   end
 

data/spec/unit/solr_config_options_spec.rb

@@ -12,52 +12,49 @@ describe ActiveFedora do
     @test_object = ActiveFedora::Base.new
   end
 
-  describe "SOLR_DOCUMENT_ID" do
-    before(:all) do
-      SOLR_DOCUMENT_ID = "MY_SAMPLE_ID".freeze
-    end
-    after(:all) do
-      SOLR_DOCUMENT_ID = "id".freeze
+  describe ".id_field" do
+    let(:field) { "MY_SAMPLE_ID".freeze }
+    before do
+      allow(described_class).to receive(:id_field).and_return(field)
     end
+
     it "is used by ActiveFedora::Base.to_solr" do
       allow(@test_object).to receive(:id).and_return('changeme:123')
-      SOLR_DOCUMENT_ID = "MY_SAMPLE_ID".freeze
-      expect(@test_object.to_solr[SOLR_DOCUMENT_ID.to_sym]).to eq 'changeme:123'
+      expect(@test_object.to_solr[field.to_sym]).to eq 'changeme:123'
       expect(@test_object.to_solr[:id]).to be_nil
     end
 
-    it "is used by ActiveFedora::Base#find_with_conditions" do
+    it "is used by ActiveFedora::Base#search_with_conditions" do
       mock_response = double("SolrResponse")
       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"])
+        .with("_query_:\"{!field f=has_model_ssim}SolrSpecModel::Basic\" AND " \
+              "_query_:\"{!field f=#{field}}changeme:30\"",
+              sort: ["#{described_class.index_field_mapper.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.search_with_conditions(id: "changeme:30")).to equal(mock_response)
     end
   end
 
-  describe "ENABLE_SOLR_UPDATES" do
-    before(:all) do
-      ENABLE_SOLR_UPDATES = false
-    end
-    after(:all) do
-      ENABLE_SOLR_UPDATES = true
-    end
+  describe ".enable_solr_updates?" do
+    context 'with .enable_solr_updates? disabled' do
+      before do
+        allow(described_class).to receive(:enable_solr_updates?).and_return(false)
+      end
 
-    it "prevents Base.save from calling update_index if false" do
-      dirty_ds = ActiveFedora::SimpleDatastream.new
-      @test_object.attached_files['ds1'] = dirty_ds
-      allow(@test_object).to receive(:datastreams).and_return(ds1: dirty_ds)
-      expect(@test_object).to receive(:update_index).never
-      expect(@test_object).to receive(:refresh)
-      @test_object.save
-    end
-    it "prevents Base.delete from deleting the corresponding Solr document if false" do
-      expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(@test_object.id).never
-      expect(@test_object).to receive(:delete)
-      @test_object.delete
+      it "prevents Base.save from calling update_index if false" do
+        dirty_ds = ActiveFedora::SimpleDatastream.new
+        @test_object.attached_files['ds1'] = dirty_ds
+        allow(@test_object).to receive(:datastreams).and_return(ds1: dirty_ds)
+        expect(@test_object).to receive(:update_index).never
+        expect(@test_object).to receive(:refresh)
+        @test_object.save
+      end
+      it "prevents Base.delete from deleting the corresponding Solr document if false" do
+        expect(ActiveFedora::SolrService.instance.conn).to receive(:delete).with(@test_object.id).never
+        expect(@test_object).to receive(:delete)
+        @test_object.delete
+      end
     end
   end
 end

data/spec/unit/solr_hit_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe ActiveFedora::SolrHit do
+  before(:all) do
+    class AudioRecord < ActiveFedora::Base
+      attr_accessor :id
+      def self.connection_for_id(_id)
+      end
+    end
+  end
+
+  subject { described_class.new "id" => "my:_ID1_", ActiveFedora.index_field_mapper.solr_name("has_model", :symbol) => ["AudioRecord"] }
+
+  describe "#reify" do
+    it "uses .find to instantiate objects" do
+      expect(AudioRecord).to receive(:find).with("my:_ID1_", cast: true)
+      subject.reify
+    end
+  end
+
+  describe "#id" do
+    it "extracts the id from the solr hit" do
+      expect(subject.id).to eq "my:_ID1_"
+    end
+  end
+
+  describe "#rdf_uri" do
+    it "provides an RDF URI for the solr hit" do
+      expect(subject.rdf_uri).to eq ::RDF::URI.new(ActiveFedora::Base.id_to_uri("my:_ID1_"))
+    end
+  end
+
+  describe "#model" do
+    it "selects the appropriate model for the solr result" do
+      expect(subject.model).to eq AudioRecord
+    end
+  end
+
+  describe "#models" do
+    it "provides all the relevant models for the solr result" do
+      expect(subject.models).to match_array [AudioRecord]
+    end
+  end
+
+  describe "#model?" do
+    it 'is true if the object has the given model' do
+      expect(subject.model?(AudioRecord)).to eq true
+    end
+
+    it 'is true if the object has an ancestor of the given model' do
+      expect(subject.model?(ActiveFedora::Base)).to eq true
+    end
+
+    it 'is false if the given model is not in the ancestor tree for the models' do
+      expect(subject.model?(String)).to eq false
+    end
+  end
+end

data/spec/unit/solr_query_builder_spec.rb

@@ -3,7 +3,15 @@ require 'spec_helper'
 describe ActiveFedora::SolrQueryBuilder do
   describe "raw_query" do
     it "generates a raw query clause" do
-      expect(described_class.raw_query('id', "my:_ID1_")).to eq '_query_:"{!raw f=id}my:_ID1_"'
+      Deprecation.silence(described_class) do
+        expect(described_class.raw_query('id', "my:_ID1_")).to eq '_query_:"{!raw f=id}my:_ID1_"'
+      end
+    end
+  end
+
+  describe "construct_query" do
+    it "generates a query clause" do
+      expect(described_class.construct_query('id' => "my:_ID1_")).to eq '_query_:"{!field f=id}my:_ID1_"'
     end
   end
 

data/spec/unit/solr_service_spec.rb

@@ -48,13 +48,13 @@ describe ActiveFedora::SolrService do
     end
   end
 
-  describe ".query" do
+  describe "#get" do
     it "calls solr" do
       mock_conn = double("Connection")
       stub_result = double("Result")
       expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
       allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.query('querytext', raw: true)).to eq stub_result
+      expect(described_class.get('querytext')).to eq stub_result
     end
     it "uses select_path" do
       mock_conn = double("Connection")
@@ -62,9 +62,25 @@ describe ActiveFedora::SolrService do
       expect(mock_conn).to receive(:get).with('select_test', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
       expect(described_class).to receive(:select_path).and_return('select_test')
       allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
-      expect(described_class.query('querytext', raw: true)).to eq stub_result
+      expect(described_class.get('querytext')).to eq stub_result
     end
   end
+
+  describe "#query" do
+    let(:doc) { { 'id' => 'x' } }
+    let(:docs) { [doc] }
+
+    it "wraps the solr response documents in Solr hits" do
+      mock_conn = double("Connection")
+      stub_result = { 'response' => { 'docs' => docs } }
+      expect(mock_conn).to receive(:get).with('select', params: { q: 'querytext', qt: 'standard' }).and_return(stub_result)
+      allow(described_class).to receive(:instance).and_return(double("instance", conn: mock_conn))
+      result = described_class.query('querytext')
+      expect(result.size).to eq 1
+      expect(result.first.id).to eq 'x'
+    end
+  end
+
   describe ".count" do
     it "returns a count of matching records" do
       mock_conn = double("Connection")