geoblacklight 4.0.0 → 4.1.1

data/spec/lib/geoblacklight/wms_layer_spec.rb

@@ -1,62 +1,63 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::WmsLayer do
   let(:wms_layer) { described_class.new(params) }
-  let(:rails_4_params) { { 'URL' => 'http://www.example.com/', 'X' => '277' } }
+  let(:rails_4_params) { {"URL" => "http://www.example.com/", "X" => "277"} }
   let(:rails_5_params) { instance_double(ActionController::Parameters) }
 
   before do
-    allow(rails_5_params).to receive(:to_h).and_return('URL' => 'http://www.example.com/', 'X' => '277')
+    allow(rails_5_params).to receive(:to_h).and_return("URL" => "http://www.example.com/", "X" => "277")
   end
 
-  describe '#initialize' do
+  describe "#initialize" do
     let(:params) { rails_4_params }
 
-    it 'initializes as a WmsLayer object' do
+    it "initializes as a WmsLayer object" do
       expect(wms_layer).to be_an described_class
     end
   end
 
-  describe '#url' do
-    context 'when running on rails 4' do
+  describe "#url" do
+    context "when running on rails 4" do
       let(:params) { rails_4_params }
 
-      it 'returns the correct URL parameter' do
-        expect(wms_layer.url).to eq('http://www.example.com/')
+      it "returns the correct URL parameter" do
+        expect(wms_layer.url).to eq("http://www.example.com/")
       end
     end
 
-    context 'when running on rails 5' do
+    context "when running on rails 5" do
       let(:params) { rails_5_params }
 
-      it 'returns the correct URL parameter' do
-        expect(wms_layer.url).to eq('http://www.example.com/')
+      it "returns the correct URL parameter" do
+        expect(wms_layer.url).to eq("http://www.example.com/")
       end
     end
   end
 
-  describe '#search_params' do
-    context 'when running on rails 4' do
+  describe "#search_params" do
+    context "when running on rails 4" do
       let(:params) { rails_4_params }
 
-      it 'returns 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).not_to include 'URL' => 'http://www.example.com/'
+        expect(wms_layer.search_params).not_to include "URL" => "http://www.example.com/"
       end
     end
 
-    context 'when running on rails 5' do
+    context "when running on rails 5" do
       let(:params) { rails_5_params }
 
-      it 'returns 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).not_to include 'URL' => 'http://www.example.com/'
+        expect(wms_layer.search_params).not_to include "URL" => "http://www.example.com/"
       end
     end
   end
 
-  describe '#request_response' do
+  describe "#request_response" do
     subject(:wms_layer) { described_class.new(params) }
     let(:params) { rails_4_params }
     let(:connection) { instance_double(Faraday::Connection) }
@@ -66,34 +67,34 @@ describe Geoblacklight::WmsLayer do
       allow(Faraday).to receive(:new).and_return(connection)
     end
 
-    it 'returns a Faraday object' do
+    it "returns a Faraday object" do
       allow(connection).to receive(:get).and_return(response)
       expect(wms_layer.request_response).to eq(response)
     end
 
-    context 'when the HTTP connection fails' do
+    context "when the HTTP connection fails" do
       before do
-        allow(Geoblacklight.logger).to receive(:error).with('#<Faraday::ConnectionFailed wrapped=#<StandardError: test connection error>>')
-        allow(connection).to receive(:get).and_raise(Faraday::ConnectionFailed.new(StandardError.new('test connection error')))
+        allow(Geoblacklight.logger).to receive(:error).with("#<Faraday::ConnectionFailed wrapped=#<StandardError: test connection error>>")
+        allow(connection).to receive(:get).and_raise(Faraday::ConnectionFailed.new(StandardError.new("test connection error")))
       end
 
-      it 'logs the Faraday error' do
+      it "logs the Faraday error" do
         expect(Geoblacklight.logger).to receive(:error).exactly(3).times
         expect(wms_layer.request_response).to be_a Hash
-        expect(wms_layer.request_response).to include(error: '#<Faraday::ConnectionFailed wrapped=#<StandardError: test connection error>>')
+        expect(wms_layer.request_response).to include(error: "#<Faraday::ConnectionFailed wrapped=#<StandardError: test connection error>>")
       end
     end
 
-    context 'when the HTTP connection times out' do
+    context "when the HTTP connection times out" do
       before do
-        allow(Geoblacklight.logger).to receive(:error).with('#<Faraday::TimeoutError #<Faraday::TimeoutError: timeout>>')
+        allow(Geoblacklight.logger).to receive(:error).with("#<Faraday::TimeoutError #<Faraday::TimeoutError: timeout>>")
         allow(connection).to receive(:get).and_raise(Faraday::TimeoutError)
       end
 
-      it 'logs the Faraday error' do
+      it "logs the Faraday error" do
         expect(Geoblacklight.logger).to receive(:error).exactly(3).times
         expect(wms_layer.request_response).to be_a Hash
-        expect(wms_layer.request_response).to include(error: '#<Faraday::TimeoutError #<Faraday::TimeoutError: timeout>>')
+        expect(wms_layer.request_response).to include(error: "#<Faraday::TimeoutError #<Faraday::TimeoutError: timeout>>")
       end
     end
   end

data/spec/models/concerns/geoblacklight/bbox_filter_field_spec.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Geoblacklight::BboxFilterField do
-  subject(:filter) { search_state.filter('bbox') }
+  subject(:filter) { search_state.filter("bbox") }
 
-  let(:bbox_value) { '140.143709 -65.487905 160.793791 86.107541' }
+  let(:bbox_value) { "140.143709 -65.487905 160.793791 86.107541" }
   let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config, controller) }
   let(:params) { {} }
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.add_facet_field 'bbox', filter_class: described_class
+      config.add_facet_field "bbox", filter_class: described_class
     end
   end
-  let(:facet_config) { blacklight_config.facet_fields['bbox'] }
+  let(:facet_config) { blacklight_config.facet_fields["bbox"] }
   let(:controller) { double }
 
-  describe '#add' do
-    context 'with a ordinary parameter' do
-      it 'adds the parameter to the facets' do
+  describe "#add" do
+    context "with a ordinary parameter" do
+      it "adds the parameter to the facets" do
         new_state = filter.add(bbox_value)
 
         expect(new_state.params).to include bbox: bbox_value
       end
     end
 
-    context 'with a bounding box' do
-      it 'adds the parameter to the bbox parameter' do
+    context "with a bounding box" do
+      it "adds the parameter to the bbox parameter" do
         new_state = filter.add(Geoblacklight::BoundingBox.from_rectangle(bbox_value))
 
         expect(new_state.params).to include bbox: bbox_value
@@ -34,61 +34,61 @@ RSpec.describe Geoblacklight::BboxFilterField do
     end
   end
 
-  context 'with some existing data' do
-    let(:params) { { bbox: bbox_value } }
+  context "with some existing data" do
+    let(:params) { {bbox: bbox_value} }
 
-    describe '#add' do
-      let(:bbox_replacement) { '100.143709 -70.487905 100.793791 96.107541' }
-      it 'replaces the existing range' do
+    describe "#add" do
+      let(:bbox_replacement) { "100.143709 -70.487905 100.793791 96.107541" }
+      it "replaces the existing range" do
         new_state = filter.add(Geoblacklight::BoundingBox.from_rectangle(bbox_replacement))
 
         expect(new_state.params).to include bbox: bbox_replacement
       end
     end
 
-    describe '#remove' do
-      it 'removes the existing bbox' do
+    describe "#remove" do
+      it "removes the existing bbox" do
         new_state = filter.remove(Geoblacklight::BoundingBox.from_rectangle(bbox_value))
 
         expect(new_state.params[:bbox]).to be_nil
       end
     end
 
-    describe '#values' do
-      it 'converts the parameters to a Geoblacklight::BoundingBox' do
+    describe "#values" do
+      it "converts the parameters to a Geoblacklight::BoundingBox" do
         expect(filter.values.first).to be_a(Geoblacklight::BoundingBox).and(have_attributes(to_param: bbox_value))
       end
     end
 
-    describe '#needs_normalization?' do
-      it 'returns false for the expected keyed representation of the bounding box' do
+    describe "#needs_normalization?" do
+      it "returns false for the expected keyed representation of the bounding box" do
         expect(filter.needs_normalization?(search_state.params)).to be false
       end
     end
 
-    context 'when array param represented by facebook as a Hash' do
+    context "when array param represented by facebook as a Hash" do
       let(:filter) { described_class.new(facet_config, search_state) }
-      let(:params) { { bbox: { '0' => bbox_value } } }
+      let(:params) { {bbox: {"0" => bbox_value}} }
 
-      describe '#normalize' do
-        it 'converts the parameters to a list' do
+      describe "#normalize" do
+        it "converts the parameters to a list" do
           expect(filter.normalize(search_state.params[:bbox])).to eql [bbox_value]
         end
       end
 
-      describe '#needs_normalization?' do
-        it 'returns true for the hash-as-array keyed representation of the bounding box' do
+      describe "#needs_normalization?" do
+        it "returns true for the hash-as-array keyed representation of the bounding box" do
           expect(filter.needs_normalization?(search_state.params[:bbox])).to be true
         end
       end
     end
   end
 
-  context 'with a malformed bbox' do
-    let(:params) { { bbox: 'totally-not-a-bbox' } }
+  context "with a malformed bbox" do
+    let(:params) { {bbox: "totally-not-a-bbox"} }
 
-    it 'excludes it from the values' do
-      filter = search_state.filter('bbox')
+    it "excludes it from the values" do
+      filter = search_state.filter("bbox")
 
       expect(filter.values).to be_empty
     end

data/spec/models/concerns/geoblacklight/bbox_filter_query_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Geoblacklight::BboxFilterQuery do
   # Subject
@@ -12,94 +12,94 @@ RSpec.describe Geoblacklight::BboxFilterQuery do
   let(:search_state) { Blacklight::SearchState.new(params.with_indifferent_access, blacklight_config) }
 
   let(:params) do
-    { bbox: '-180 -80 120 80' }
+    {bbox: "-180 -80 120 80"}
   end
 
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.add_facet_field 'bbox', filter_class: Geoblacklight::BboxFilterField
+      config.add_facet_field "bbox", filter_class: Geoblacklight::BboxFilterField
     end
   end
-  let(:facet_config) { blacklight_config.facet_fields['bbox'] }
+  let(:facet_config) { blacklight_config.facet_fields["bbox"] }
 
   # Filter
   let(:filter) { Geoblacklight::BboxFilterField.new(facet_config, search_state) }
 
-  describe '#initialize' do
-    it 'initializes as a BboxFilterQuery object' do
+  describe "#initialize" do
+    it "initializes as a BboxFilterQuery object" do
       expect(bbox_filter_query).to be_a described_class
     end
   end
 
-  describe '#envelope_bounds' do
-    it 'returns an BoundingBox envelope' do
-      expect(bbox_filter_query.envelope_bounds).to eq('ENVELOPE(-180, 120, 80, -80)')
+  describe "#envelope_bounds" do
+    it "returns an BoundingBox envelope" do
+      expect(bbox_filter_query.envelope_bounds).to eq("ENVELOPE(-180, 120, 80, -80)")
     end
   end
 
-  describe '#boost' do
-    context 'without an explicit boost' do
+  describe "#boost" do
+    context "without an explicit boost" do
       before do
         facet_config.within_boost = nil
       end
 
-      it 'returns an default boost value' do
-        expect(bbox_filter_query.boost).to eq('^10')
+      it "returns an default boost value" do
+        expect(bbox_filter_query.boost).to eq("^10")
       end
     end
 
-    context 'with an explicit boost' do
+    context "with an explicit boost" do
       before do
         facet_config.within_boost = 99
       end
 
-      it 'applies boost based on configured Settings.BBOX_WITHIN_BOOST' do
-        expect(bbox_filter_query.boost).to eq('^99')
+      it "applies boost based on configured Settings.BBOX_WITHIN_BOOST" do
+        expect(bbox_filter_query.boost).to eq("^99")
       end
     end
   end
 
-  describe '#relevancy_boost' do
-    it 'returns a relevancy_boost' do
-      expect(bbox_filter_query.relevancy_boost[:bq].to_s).to include('IsWithin')
+  describe "#relevancy_boost" do
+    it "returns a relevancy_boost" do
+      expect(bbox_filter_query.relevancy_boost[:bq].to_s).to include("IsWithin")
     end
 
-    context 'with overlap boost' do
+    context "with overlap boost" do
       before do
         facet_config.overlap_boost = 2
       end
 
-      it 'applies overlapRatio when Settings.OVERLAP_RATIO_BOOST is configured' do
-        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('$overlap^2')
+      it "applies overlapRatio when Settings.OVERLAP_RATIO_BOOST is configured" do
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include("$overlap^2")
       end
     end
 
-    context 'without an overlap boost' do
+    context "without an overlap boost" do
       before do
         facet_config.overlap_boost = nil
       end
 
-      it 'does not apply overlapRatio when Settings.OVERLAP_RATIO_BOOST not configured' do
+      it "does not apply overlapRatio when Settings.OVERLAP_RATIO_BOOST not configured" do
         expect(bbox_filter_query.relevancy_boost).not_to have_key(:overlap)
       end
     end
 
-    context 'when local boost parameter is present' do
+    context "when local boost parameter is present" do
       before do
-        solr_params[:bf] = ['local_boost^5']
+        solr_params[:bf] = ["local_boost^5"]
         facet_config.overlap_boost = 2
       end
 
-      it 'appends overlap and includes the local boost' do
-        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('$overlap^2')
-        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include('local_boost^5')
+      it "appends overlap and includes the local boost" do
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include("$overlap^2")
+        expect(bbox_filter_query.relevancy_boost[:bf].to_s).to include("local_boost^5")
       end
     end
   end
 
-  describe '#intersects_filter' do
-    it 'returns an Intersects query' do
-      expect(bbox_filter_query.intersects_filter).to include('Intersects')
+  describe "#intersects_filter" do
+    it "returns an Intersects query" do
+      expect(bbox_filter_query.intersects_filter).to include("Intersects")
     end
   end
 end

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

@@ -1,42 +1,43 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
+
+class MyDocument
+  extend Blacklight::Solr::Document
+  include Geoblacklight::SolrDocument::Carto
+end
 
 describe Geoblacklight::SolrDocument::Carto do
   let(:document) { MyDocument.new }
   let(:geojson_download) { instance_double(Geoblacklight::GeojsonDownload) }
 
   before do
-    class MyDocument
-      extend Blacklight::Solr::Document
-      include Geoblacklight::SolrDocument::Carto
-    end
-
     allow(Geoblacklight::GeojsonDownload).to receive(:new).and_return(geojson_download)
   end
 
-  describe '#carto_reference' do
-    it 'returns nil for restricted documents' do
+  describe "#carto_reference" do
+    it "returns nil for restricted documents" do
       expect(document).to receive(:public?).and_return(false)
       expect(document.carto_reference).to be_nil
     end
-    it 'returns nil for no download_types' do
+    it "returns nil for no download_types" do
       expect(document).to receive(:public?).and_return(true)
       expect(document).to receive(:download_types).and_return(nil)
       expect(document.carto_reference).to be_nil
     end
-    it 'returns nil with no :geojson download type' do
+    it "returns nil with no :geojson download type" do
       expect(document).to receive(:public?).and_return(true)
-      expect(document).to receive(:download_types).and_return(geotiff: 'geotiff')
+      expect(document).to receive(:download_types).and_return(geotiff: "geotiff")
       expect(document.carto_reference).to be_nil
     end
-    it 'Creates and returns a GeojsonDownload url' do
+    it "Creates and returns a GeojsonDownload url" do
       expect(document).to receive(:public?).and_return(true)
       expect(document).to receive(:download_types)
-        .and_return(geojson: { 'stuff' => 'stuff' })
+        .and_return(geojson: {"stuff" => "stuff"})
       expect(geojson_download)
         .to receive(:url_with_params)
-        .and_return('http://www.example.com/geojsonDownload')
-      expect(document.carto_reference).to eq 'http://www.example.com/geojsonDownload'
+        .and_return("http://www.example.com/geojsonDownload")
+      expect(document.carto_reference).to eq "http://www.example.com/geojsonDownload"
     end
   end
 end

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

@@ -1,14 +1,15 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::SolrDocument::Citation do
-  describe '#geoblacklight_citation' do
-    let(:fixture) { JSON.parse(read_fixture('solr_documents/restricted-line.json')) }
+  describe "#geoblacklight_citation" do
+    let(:fixture) { JSON.parse(read_fixture("solr_documents/restricted-line.json")) }
     let(:document) { SolrDocument.new(fixture) }
 
-    it 'creates a citation' do
-      expect(document.geoblacklight_citation('http://example.com'))
-        .to eq 'United States. National Oceanic and Atmospheric Administration. Circuit Rider Productions. (2002). 10 Meter Contours: Russian River Basin, California. [Shapefile]. Circuit Rider Productions. Retrieved from http://example.com'
+    it "creates a citation" do
+      expect(document.geoblacklight_citation("http://example.com"))
+        .to eq "United States. National Oceanic and Atmospheric Administration. Circuit Rider Productions. (2002). 10 Meter Contours: Russian River Basin, California. [Shapefile]. Circuit Rider Productions. Retrieved from http://example.com"
     end
   end
 end

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

@@ -1,40 +1,39 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
+
+class MyDocument
+  extend Blacklight::Solr::Document
+  include Geoblacklight::SolrDocument::Finder
+end
 
 describe Geoblacklight::SolrDocument::Finder do
   let(:document_klass) { MyDocument }
 
-  before do
-    class MyDocument
-      extend Blacklight::Solr::Document
-      include Geoblacklight::SolrDocument::Finder
-    end
-  end
-
-  describe '#find' do
-    let(:documents) { ['first', 'second'] }
+  describe "#find" do
+    let(:documents) { ["first", "second"] }
     let(:response) { instance_double(Blacklight::Solr::Response) }
 
     before do
       allow(response).to receive(:documents).and_return(documents)
-      allow_any_instance_of(Blacklight::Solr::Repository).to receive(:find).with('search param').and_return(response)
+      allow_any_instance_of(Blacklight::Solr::Repository).to receive(:find).with("search param").and_return(response)
     end
 
-    it 'calls index and returns first document' do
-      expect(document_klass.find('search param')).to eq 'first'
+    it "calls index and returns first document" do
+      expect(document_klass.find("search param")).to eq "first"
     end
   end
 
-  describe '#index' do
-    it 'creates and returns a Blacklight::Solr::Repository' do
+  describe "#index" do
+    it "creates and returns a Blacklight::Solr::Repository" do
       expect(document_klass.index).to be_a Blacklight::Solr::Repository
     end
   end
 
-  describe '.blacklight_solr' do
+  describe ".blacklight_solr" do
     let(:document) { document_klass.new }
 
-    it 'accesses the connection to the Solr index' do
+    it "accesses the connection to the Solr index" do
       expect(document.blacklight_solr).to be_a RSolr::Client
     end
   end

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

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::SolrDocument::Inspection do
   subject { SolrDocument.new }
 
-  describe '#inspectable?' do
-    it 'returns true for wms viewer protocol' do
-      expect(subject).to receive(:viewer_protocol).and_return('wms')
+  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')
+    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