geoblacklight 0.11.1 → 0.12.0

data/spec/lib/geoblacklight/geoblacklight_helper_behavior_spec.rb

@@ -2,8 +2,9 @@ require 'spec_helper'
 
 describe Geoblacklight::GeoblacklightHelperBehavior do
   let(:dummy_class) do
-    Class.new { include Geoblacklight::GeoblacklightHelperBehavior }.new
+    Class.new.extend(described_class)
   end
+
   describe '#wxs_identifier' do
     it 'calls defined presenter class' do
       expect(dummy_class).to receive(:presenter)

data/spec/lib/geoblacklight/item_viewer_spec.rb

@@ -4,7 +4,7 @@ describe Geoblacklight::ItemViewer do
   let(:document) { SolrDocument.new(document_attributes) }
   let(:document_attributes) { {} }
   let(:references) { document.references }
-  let(:item_viewer) { Geoblacklight::ItemViewer.new(references) }
+  let(:item_viewer) { described_class.new(references) }
   describe 'viewer_preference' do
     describe 'for no references' do
       it 'returns nil' do
@@ -12,26 +12,26 @@ describe Geoblacklight::ItemViewer do
       end
     end
     describe 'for wms reference' do
-      let(:document_attributes) {
+      let(:document_attributes) do
         {
           dct_references_s: {
             'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms',
             'http://iiif.io/api/image' => 'http://www.example.com/iiif'
           }.to_json
         }
-      }
+      end
       it 'wms if wms is present' do
         expect(item_viewer.viewer_preference).to eq wms: 'http://www.example.com/wms'
       end
     end
     describe 'for iiif only reference' do
-      let(:document_attributes) {
+      let(:document_attributes) do
         {
           dct_references_s: {
             'http://iiif.io/api/image' => 'http://www.example.com/iiif'
           }.to_json
         }
-      }
+      end
       it 'returns iiif' do
         expect(item_viewer.viewer_preference).to eq iiif: 'http://www.example.com/iiif'
       end

data/spec/lib/geoblacklight/metadata_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Geoblacklight::Metadata do
   let(:response) { double('response') }
   let(:get) { double('get') }
-  let(:opengeometadata) {
-    Geoblacklight::Metadata.new(
+  let(:opengeometadata) do
+    described_class.new(
       Geoblacklight::Reference.new(
         ['http://www.loc.gov/mods/v3', 'http://purl.stanford.edu/cg357zz0321.mods']
       )
     )
-  }
+  end
   describe '#retrieve_metadata' do
     it 'returns response from an endpoint url' do
       expect(response).to receive(:get).and_return(get)

data/spec/lib/geoblacklight/reference_spec.rb

@@ -2,10 +2,10 @@ require 'spec_helper'
 
 describe Geoblacklight::Reference do
   let(:typical_reference) do
-    Geoblacklight::Reference.new(['http://www.opengis.net/def/serviceType/ogc/wms', 'http://hgl.harvard.edu:8080/geoserver/wms'])
+    described_class.new(['http://www.opengis.net/def/serviceType/ogc/wms', 'http://hgl.harvard.edu:8080/geoserver/wms'])
   end
   let(:blank_reference) do
-    Geoblacklight::Reference.new([])
+    described_class.new([])
   end
   describe '#initialize' do
     it 'instance variable reference is set' do
@@ -28,7 +28,7 @@ describe Geoblacklight::Reference do
   end
   describe '#to_hash' do
     it 'creates a hash using type and endpoint' do
-      expect(typical_reference.to_hash).to eq :wms => 'http://hgl.harvard.edu:8080/geoserver/wms'
+      expect(typical_reference.to_hash).to eq wms: 'http://hgl.harvard.edu:8080/geoserver/wms'
     end
   end
 end

data/spec/lib/geoblacklight/references_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Geoblacklight::References do
-  let(:typical_ogp_shapefile) {
-    Geoblacklight::References.new(
+  let(:typical_ogp_shapefile) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'Shapefile',
         dct_references_s: {
@@ -11,17 +11,17 @@ describe Geoblacklight::References do
         }.to_json
       )
     )
-  }
-  let(:no_service_shapefile) {
-    Geoblacklight::References.new(
+  end
+  let(:no_service_shapefile) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'Shapefile',
         dct_references_s: {}.to_json
       )
     )
-  }
-  let(:typical_ogp_geotiff) {
-    Geoblacklight::References.new(
+  end
+  let(:typical_ogp_geotiff) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'GeoTIFF',
         dct_references_s: {
@@ -30,9 +30,9 @@ describe Geoblacklight::References do
         }.to_json
       )
     )
-  }
-  let(:typical_arcgrid) {
-    Geoblacklight::References.new(
+  end
+  let(:typical_arcgrid) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'ArcGRID',
         dct_references_s: {
@@ -41,9 +41,9 @@ describe Geoblacklight::References do
         }.to_json
       )
     )
-  }
-  let(:complex_shapefile) {
-    Geoblacklight::References.new(
+  end
+  let(:complex_shapefile) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'Shapefile',
         dct_references_s: {
@@ -56,17 +56,17 @@ describe Geoblacklight::References do
         }.to_json
       )
     )
-  }
-  let(:direct_download_only) {
-    Geoblacklight::References.new(
+  end
+  let(:direct_download_only) do
+    described_class.new(
       dc_format_s: 'GeoTIFF',
       dct_references_s: {
         'http://schema.org/downloadUrl' => 'http://example.com/layer-id-geotiff.tiff'
       }.to_json
     )
-  }
-  let(:simple_iiif_image) {
-    Geoblacklight::References.new(
+  end
+  let(:simple_iiif_image) do
+    described_class.new(
       SolrDocument.new(
         dc_format_s: 'Raster',
         dct_references_s: {
@@ -75,12 +75,12 @@ describe Geoblacklight::References do
         }.to_json
       )
     )
-  }
-  let(:custom_fields) {
-    Geoblacklight::References.new(
+  end
+  let(:custom_fields) do
+    described_class.new(
       SolrDocument.new, :new_ref_field
     )
-  }
+  end
   describe '#initialize' do
     it 'parses dct_references_s to @refs' do
       expect(typical_ogp_shapefile.instance_variable_get(:@refs)).to be_an Array
@@ -96,51 +96,51 @@ describe Geoblacklight::References do
     end
   end
   describe 'format' do
-    it 'should return format' do
+    it 'returns format' do
       expect(complex_shapefile.format).to eq 'Shapefile'
       expect(direct_download_only.format).to eq 'GeoTIFF'
     end
   end
   describe 'refs' do
-    it 'should be enumberable references' do
+    it 'is enumberable references' do
       complex_shapefile.refs.each do |reference|
         expect(reference).to be_an Geoblacklight::Reference
       end
     end
   end
   describe 'direct_download' do
-    it 'should return the direct download link' do
+    it 'returns the direct download link' do
       download = complex_shapefile.download
       expect(download).to be_an Geoblacklight::Reference
       expect(download.endpoint).to eq('http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip')
       expect(direct_download_only.download.endpoint).to eq 'http://example.com/layer-id-geotiff.tiff'
     end
-    it 'should not return if download not available' do
+    it 'does not return if download not available' do
       expect(typical_ogp_shapefile.download).to be_nil
     end
   end
   describe 'preferred_download' do
-    it 'should return the direct download if available' do
+    it 'returns the direct download if available' do
       expect(complex_shapefile.preferred_download[:file_download][:download]).to eq 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip'
       expect(direct_download_only.preferred_download[:file_download][:download]).to eq 'http://example.com/layer-id-geotiff.tiff'
     end
-    it 'should return nil if there is no direct download' do
+    it 'returns nil if there is no direct download' do
       expect(typical_ogp_shapefile.preferred_download).to be_nil
     end
-    it 'should return nil if there is no direct download' do
+    it 'returns nil if there is no direct download' do
       expect(typical_ogp_geotiff.preferred_download).to be_nil
     end
   end
   describe 'download_types' do
-    it 'should return available downloads by format' do
+    it 'returns available downloads by format' do
       types = complex_shapefile.download_types
       expect(types.first[1]).to eq wfs: 'http://hgl.harvard.edu:8080/geoserver/wfs'
       expect(types.count).to eq 3
       expect(direct_download_only.download_types).to be_nil
     end
-    it 'should only return available downloads if no direct is present' do
+    it 'onlies return available downloads if no direct is present' do
       types = typical_ogp_shapefile.download_types
-      expect(types.first[1]).to eq wfs: "http://hgl.harvard.edu:8080/geoserver/wfs"
+      expect(types.first[1]).to eq wfs: 'http://hgl.harvard.edu:8080/geoserver/wfs'
       expect(types.count).to eq 3
     end
   end

data/spec/lib/geoblacklight/search_builder_spec.rb

@@ -11,31 +11,23 @@ describe Geoblacklight::SearchBuilder do
   subject { search_builder.with(user_params) }
 
   describe '#initialize' do
-    it 'should have add_spatial_params in processor chain once' do
-      correct_processor_chain = [:default_solr_parameters,
-                                 :add_query_to_solr,
-                                 :add_facet_fq_to_solr,
-                                 :add_facetting_to_solr,
-                                 :add_solr_fields_to_query,
-                                 :add_paging_to_solr,
-                                 :add_sorting_to_solr,
-                                 :add_group_config_to_solr,
-                                 :add_range_limit_params,
-                                 :add_spatial_params]
+    it 'has add_spatial_params in processor chain once' do
       expect(subject.processor_chain).to include :add_spatial_params
-      expect(subject.processor_chain).to match_array correct_processor_chain
+      expect(subject.processor_chain
+        .count { |x| x == :add_spatial_params }).to eq 1
       new_search = described_class.new(subject.processor_chain, context)
       expect(new_search.processor_chain).to include :add_spatial_params
-      expect(new_search.processor_chain).to match_array correct_processor_chain
+      expect(subject.processor_chain
+        .count { |x| x == :add_spatial_params }).to eq 1
     end
   end
 
   describe '#add_spatial_params' do
-    it 'should return the solr_params when no bbox is given' do
+    it 'returns the solr_params when no bbox is given' do
       expect(subject.add_spatial_params(solr_params)).to eq solr_params
     end
 
-    it 'should return a spatial search if bbox is given' do
+    it 'returns a spatial search if bbox is given' do
       params = { bbox: '-180 -80 120 80' }
       subject.with(params)
       expect(subject.add_spatial_params(solr_params)[:fq].to_s).to include('Intersects')

data/spec/lib/geoblacklight/view_helper_override_spec.rb

@@ -5,32 +5,32 @@ describe Geoblacklight::ViewHelperOverride do
     attr_accessor :params
   end
 
-  before(:each) do
-    @fake_controller = GeoblacklightControllerTestClass.new
-    @fake_controller.extend(Geoblacklight::ViewHelperOverride)
+  let(:fake_controller) do
+    GeoblacklightControllerTestClass.new
+      .extend(described_class)
   end
 
   describe 'spatial_parameters?' do
-    it 'should not have spatial parameters' do
-      @fake_controller.params = {}
-      expect(@fake_controller.spatial_parameters?).to be_falsey
+    it 'does not have spatial parameters' do
+      fake_controller.params = {}
+      expect(fake_controller.spatial_parameters?).to be_falsey
     end
-    it 'should have spatial parameters' do
-      @fake_controller.params = { bbox: '123'}
-      expect(@fake_controller.spatial_parameters?).to be_truthy
+    it 'has spatial parameters' do
+      fake_controller.params = { bbox: '123' }
+      expect(fake_controller.spatial_parameters?).to be_truthy
     end
   end
   describe 'render_search_to_s_bbox' do
     it 'returns an empty string for no bbox' do
-      @fake_controller.params = {}
-      expect(@fake_controller.render_search_to_s_bbox(@fake_controller.params)).to eq ''
+      fake_controller.params = {}
+      expect(fake_controller.render_search_to_s_bbox(fake_controller.params)).to eq ''
     end
     it 'returns render_search_to_s_element when bbox is present' do
-      @fake_controller.params = { bbox: '123'}
+      fake_controller.params = { bbox: '123' }
       params = { 'bbox' => '123' }
-      expect(@fake_controller).to receive(:render_search_to_s_element)
-      expect(@fake_controller).to receive(:render_filter_value)
-      @fake_controller.render_search_to_s_bbox(params)
+      expect(fake_controller).to receive(:render_search_to_s_element)
+      expect(fake_controller).to receive(:render_filter_value)
+      fake_controller.render_search_to_s_bbox(params)
     end
   end
 end

data/spec/lib/geoblacklight/wms_layer/feature_info_response_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 describe Geoblacklight::FeatureInfoResponse do
-  let(:response) { Geoblacklight::FeatureInfoResponse.new(OpenStruct.new(body: '<html><body><table><th>Header1</th><th>Header2</th><td>value1</td><td>value2</td></body></html>', headers: {'content-type' => 'all good'})) }
-  let(:error_response) { Geoblacklight::FeatureInfoResponse.new({error: 'bad stuff'}) }
-  let(:content_response) { Geoblacklight::FeatureInfoResponse.new(OpenStruct.new(headers: { 'content-type' => 'text/xml' })) }
+  let(:response) { described_class.new(OpenStruct.new(body: '<html><body><table><th>Header1</th><th>Header2</th><td>value1</td><td>value2</td></body></html>', headers: { 'content-type' => 'all good' })) }
+  let(:error_response) { described_class.new(error: 'bad stuff') }
+  let(:content_response) { described_class.new(OpenStruct.new(headers: { 'content-type' => 'text/xml' })) }
 
   describe '#initialize' do
-    it 'should initialize as a FeatureInfoResponse type' do
-      expect(response).to be_an Geoblacklight::FeatureInfoResponse
+    it 'initializes as a FeatureInfoResponse type' do
+      expect(response).to be_an described_class
     end
   end
 
@@ -24,19 +24,19 @@ describe Geoblacklight::FeatureInfoResponse do
   end
 
   describe '#format' do
-    it 'should return a formated response' do
+    it 'returns a formated response' do
       expect(response.format).to_not be_nil
       expect(response.format[:values].length).to eq 2
-      expect(response.format[:values][0]).to eq ["Header1", "value1"]
-      expect(response.format[:values][1]).to eq ["Header2", "value2"]
+      expect(response.format[:values][0]).to eq %w(Header1 value1)
+      expect(response.format[:values][1]).to eq %w(Header2 value2)
     end
   end
 
   describe '#check' do
-    it 'should return a formated response if no errors' do
+    it 'returns a formated response if no errors' do
       expect(response.check).to eq response.format
     end
-    it 'should return the unformated response if there are errors' do
+    it 'returns the unformated response if there are errors' do
       expect(error_response.check).to eq error_response.instance_variable_get('@response')
     end
   end

data/spec/lib/geoblacklight/wms_layer_spec.rb

@@ -2,32 +2,32 @@ require 'spec_helper'
 
 describe Geoblacklight::WmsLayer do
   let(:params) { { 'URL' => 'http://www.example.com/', 'X' => '277' } }
-  let(:wms_layer) { Geoblacklight::WmsLayer.new(params) }
+  let(:wms_layer) { described_class.new(params) }
   describe '#initialize' do
-    it 'should initialize as a WmsLayer object' do
-      expect(wms_layer).to be_an Geoblacklight::WmsLayer
+    it 'initializes as a WmsLayer object' do
+      expect(wms_layer).to be_an described_class
     end
   end
 
   describe '#url' do
-    it 'should return only URL parameter' do
+    it 'returns only URL parameter' do
       expect(wms_layer.url).to eq 'http://www.example.com/'
     end
   end
 
   describe '#search_params' do
-    it 'should return all params except URL plus default params' do
+    it 'returns all params except URL plus default params' do
       expect(wms_layer.search_params.length).to eq 8
       expect(wms_layer.search_params).to_not include 'URL' => 'http://www.example.com'
     end
   end
 
   describe '#request_response' do
-    it 'should return a Faraday object' do
+    it 'returns a Faraday object' do
       faraday = double('faraday')
       allow(faraday).to receive(:get)
       expect(Faraday).to receive(:new).and_return(faraday)
-      Geoblacklight::WmsLayer.new(params)
+      described_class.new(params)
     end
   end
 end

data/spec/{lib → models/concerns}/geoblacklight/solr_document/finder_spec.rb

@@ -14,8 +14,8 @@ describe Geoblacklight::SolrDocument::Finder do
     end
   end
   describe '#index' do
-    it 'creates and returns a Blacklight::SolrRepository' do
-      expect(subject.index).to be_an Blacklight::SolrRepository
+    it 'creates and returns a Blacklight::Solr::Repository' do
+      expect(subject.index).to be_an Blacklight::Solr::Repository
     end
   end
 end

data/spec/models/concerns/geoblacklight/solr_document/inspection_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Geoblacklight::SolrDocument::Inspection do
+  let(:subject) { SolrDocument.new }
+  describe '#inspectable?' do
+    it 'returns true for wms viewer protocol' do
+      expect(subject).to receive(:viewer_protocol).and_return('wms')
+      expect(subject.inspectable?).to be_truthy
+    end
+
+    it 'returns false for iiif viewer protocol' do
+      expect(subject).to receive(:viewer_protocol).and_return('iiif')
+      expect(subject.inspectable?).to be_falsy
+    end
+  end
+end