geoblacklight 4.0.0.pre.rc3 → 4.1.0

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

@@ -1,278 +1,292 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::SolrDocument do
   let(:document) { SolrDocument.new(document_attributes) }
   let(:rights_field) { Settings.FIELDS.ACCESS_RIGHTS }
   let(:provider_field) { Settings.FIELDS.PROVIDER }
   let(:references_field) { Settings.FIELDS.REFERENCES }
-  describe '#available?' do
+  describe "#available?" do
     let(:document_attributes) { {} }
-    describe 'a public document' do
-      it 'alwayses be available' do
-        allow(document).to receive('same_institution?').and_return(false)
-        allow(document).to receive('public?').and_return(true)
+    describe "a public document" do
+      it "alwayses be available" do
+        allow(document).to receive("same_institution?").and_return(false)
+        allow(document).to receive("public?").and_return(true)
         expect(document.available?).to be_truthy
       end
     end
-    describe 'a restricted document' do
-      it 'onlies be available if from same institution' do
-        allow(document).to receive('same_institution?').and_return(true)
-        allow(document).to receive('public?').and_return(false)
+    describe "a restricted document" do
+      it "onlies be available if from same institution" do
+        allow(document).to receive("same_institution?").and_return(true)
+        allow(document).to receive("public?").and_return(false)
         expect(document.available?).to be_truthy
       end
     end
   end
-  describe '#public?' do
-    describe 'a public document' do
-      let(:document_attributes) { { rights_field => 'PUBLIC' } }
-      it 'is public' do
+  describe "#public?" do
+    describe "a public document" do
+      let(:document_attributes) { {rights_field => "PUBLIC"} }
+      it "is public" do
         expect(document.public?).to be_truthy
       end
     end
-    describe 'a restricted resource' do
-      let(:document_attributes) { { rights_field => 'RESTRICTED' } }
-      it 'does not be public' do
+    describe "a restricted resource" do
+      let(:document_attributes) { {rights_field => "RESTRICTED"} }
+      it "does not be public" do
         expect(document.public?).to be_falsey
       end
     end
-    describe 'without rights data' do
+    describe "without rights data" do
       let(:document_attributes) { {} }
-      it 'is not public' do
+      it "is not public" do
         expect(document.public?).to be_falsey
       end
     end
   end
-  describe '#restricted?' do
-    describe 'a restricted document' do
-      let(:document_attributes) { { rights_field => 'RESTRICTED' } }
-      it 'is restricted' do
+  describe "#restricted?" do
+    describe "a restricted document" do
+      let(:document_attributes) { {rights_field => "RESTRICTED"} }
+      it "is restricted" do
         expect(document.restricted?).to be_truthy
       end
     end
-    describe 'a non-restricted resource' do
-      let(:document_attributes) { { rights_field => 'PUBLIC' } }
-      it 'is not restricted' do
+    describe "a non-restricted resource" do
+      let(:document_attributes) { {rights_field => "PUBLIC"} }
+      it "is not restricted" do
         expect(document.restricted?).to be_falsey
       end
     end
-    describe 'without rights data' do
+    describe "without rights data" do
       let(:document_attributes) { {} }
-      it 'is restricted' do
+      it "is restricted" do
         expect(document.restricted?).to be_truthy
       end
     end
   end
-  describe '#downloadable?' do
-    describe 'available direct download' do
+  describe "#downloadable?" do
+    describe "available direct download" do
       let(:document_attributes) do
         {
-          rights_field => 'Public',
+          rights_field => "Public",
           references_field => {
-            'http://schema.org/downloadUrl' => 'http://example.com/direct/data.zip'
+            "http://schema.org/downloadUrl" => "http://example.com/direct/data.zip"
           }.to_json
         }
       end
-      it 'will be downloadable' do
+      it "will be downloadable" do
         expect(document.downloadable?).to be_truthy
       end
     end
   end
-  describe '#same_institution?' do
-    describe 'within the same institution' do
-      let(:document_attributes) { { provider_field => 'STANFORD' } }
-      it 'is true' do
-        allow(Settings).to receive('Institution').and_return('Stanford')
+  describe "#same_institution?" do
+    describe "within the same institution" do
+      let(:document_attributes) { {provider_field => "STANFORD"} }
+      it "is true" do
+        allow(Settings).to receive("Institution").and_return("Stanford")
         expect(document.same_institution?).to be_truthy
       end
-      it 'matches case inconsistencies' do
-        allow(Settings).to receive('Institution').and_return('StAnFord')
+      it "matches case inconsistencies" do
+        allow(Settings).to receive("Institution").and_return("StAnFord")
         expect(document.same_institution?).to be_truthy
       end
     end
-    describe 'within a different institution' do
-      let(:document_attributes) { { provider_field => 'MIT' } }
-      it 'is false' do
-        allow(Settings).to receive('Institution').and_return('Stanford')
+    describe "within a different institution" do
+      let(:document_attributes) { {provider_field => "MIT"} }
+      it "is false" do
+        allow(Settings).to receive("Institution").and_return("Stanford")
         expect(document.same_institution?).to be_falsey
       end
     end
   end
-  describe 'references' do
+  describe "references" do
     let(:document_attributes) { {} }
-    it 'generates a new references object' do
+    it "generates a new references object" do
       expect(document.references).to be_an Geoblacklight::References
     end
   end
-  describe 'download_types' do
+  describe "download_types" do
     let(:document_attributes) { {} }
-    it 'calls download_types' do
+    it "calls download_types" do
       expect_any_instance_of(Geoblacklight::References).to receive(:download_types)
       document.download_types
     end
   end
-  describe 'direct_download' do
+  describe "direct_download" do
     let(:document_attributes) { {} }
-    describe 'with a direct download' do
+    describe "with a direct download" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://schema.org/downloadUrl' => 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip'
+            "http://schema.org/downloadUrl" => "http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip"
           }.to_json
         }
       end
-      it 'returns a direct download hash' do
+      it "returns a direct download hash" do
         expect_any_instance_of(Geoblacklight::Reference).to receive(:to_hash)
         document.direct_download
       end
     end
-    it 'returns nil if no direct download' do
+    it "returns nil if no direct download" do
       expect_any_instance_of(Geoblacklight::Reference).not_to receive(:to_hash)
       expect(document.direct_download).to be_nil
     end
   end
-  describe 'hgl_download' do
-    describe 'with an hgl download' do
+  describe "hgl_download" do
+    describe "with an hgl download" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://schema.org/DownloadAction' => 'http://example.com/harvard'
+            "http://schema.org/DownloadAction" => "http://example.com/harvard"
           }.to_json
         }
       end
-      it 'returns an hgl download hash' do
-        expect(document.hgl_download[:hgl]).to eq('http://example.com/harvard')
+      it "returns an hgl download hash" do
+        expect(document.hgl_download[:hgl]).to eq("http://example.com/harvard")
       end
     end
-    describe 'without an hgl download' do
+    describe "without an hgl download" do
       let(:document_attributes) { {} }
-      it 'returns nil' do
+      it "returns nil" do
         expect(document.direct_download).to be_nil
       end
     end
   end
-  describe '#oembed' do
-    describe 'with an oembed url' do
+  describe "#oembed" do
+    describe "with an oembed url" do
       let(:document_attributes) do
         {
           references_field => {
-            'https://oembed.com' => 'http://example.com/oembed?url=oembec.com/id123'
+            "https://oembed.com" => "http://example.com/oembed?url=oembec.com/id123"
           }.to_json
         }
       end
-      it 'returns a url string' do
-        expect(document.oembed).to eq('http://example.com/oembed?url=oembec.com/id123')
+      it "returns a url string" do
+        expect(document.oembed).to eq("http://example.com/oembed?url=oembec.com/id123")
       end
     end
-    describe 'without an oembed url' do
+    describe "without an oembed url" do
       let(:document_attributes) { {} }
-      it 'returns nil' do
+      it "returns nil" do
         expect(document.oembed).to be_nil
       end
     end
   end
-  describe 'iiif_download' do
-    describe 'with a IIIF download' do
+  describe "iiif_download" do
+    describe "with a IIIF download" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://iiif.io/api/image' => 'https://example.edu/images/info.json'
+            "http://iiif.io/api/image" => "https://example.edu/images/info.json"
           }.to_json
         }
       end
-      it 'returns a IIIF download hash' do
-        expect(document.iiif_download[:iiif]).to eq('https://example.edu/images/info.json')
+      it "returns a IIIF download hash" do
+        expect(document.iiif_download[:iiif]).to eq("https://example.edu/images/info.json")
       end
     end
-    describe 'without a IIIF download' do
+    describe "without a IIIF download" do
       let(:document_attributes) { {} }
-      it 'returns nil' do
+      it "returns nil" do
         expect(document.iiif_download).to be_nil
       end
     end
   end
-  describe 'data_dictionary_download' do
-    describe 'with a data dictionary reference' do
+  describe "data_dictionary_download" do
+    describe "with a data dictionary reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://lccn.loc.gov/sh85035852' => 'https://example.edu/documentation/data_dictionary.zip'
+            "http://lccn.loc.gov/sh85035852" => "https://example.edu/documentation/data_dictionary.zip"
           }.to_json
         }
       end
-      it 'returns a data dictionary download hash' do
-        expect(document.data_dictionary_download[:data_dictionary]).to eq('https://example.edu/documentation/data_dictionary.zip')
+      it "returns a data dictionary download hash" do
+        expect(document.data_dictionary_download[:data_dictionary]).to eq("https://example.edu/documentation/data_dictionary.zip")
       end
     end
-    describe 'without a data dictionary download' do
+    describe "without a data dictionary download" do
       let(:document_attributes) { {} }
-      it 'returns nil' do
+      it "returns nil" do
         expect(document.data_dictionary_download).to be_nil
       end
     end
   end
-  describe 'item_viewer' do
+  describe "item_viewer" do
     let(:document_attributes) { {} }
-    it 'is a ItemViewer' do
+    it "is a ItemViewer" do
       expect(document.item_viewer).to be_an Geoblacklight::ItemViewer
     end
   end
-  describe 'viewer_protocol' do
-    describe 'with a wms reference' do
+  describe "viewer_protocol" do
+    describe "with a wms reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms'
+            "http://www.opengis.net/def/serviceType/ogc/wms" => "http://www.example.com/wms"
           }.to_json
         }
       end
-      it 'returns wms protocol' do
-        expect(document.viewer_protocol).to eq 'wms'
+      it "returns wms protocol" do
+        expect(document.viewer_protocol).to eq "wms"
       end
     end
     let(:document_attributes) { {} }
-    it 'returns leaflet protocol' do
-      expect(document.viewer_protocol).to eq 'map'
+    it "returns leaflet protocol" do
+      expect(document.viewer_protocol).to eq "map"
     end
   end
-  describe 'viewer_endpoint' do
-    describe 'with a wms reference' do
+  describe "viewer_endpoint" do
+    describe "with a wms reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms'
+            "http://www.opengis.net/def/serviceType/ogc/wms" => "http://www.example.com/wms"
           }.to_json
         }
       end
-      it 'returns wms endpoint' do
-        expect(document.viewer_endpoint).to eq 'http://www.example.com/wms'
+      it "returns wms endpoint" do
+        expect(document.viewer_endpoint).to eq "http://www.example.com/wms"
       end
     end
     let(:document_attributes) { {} }
-    it 'returns no endpoint' do
-      expect(document.viewer_endpoint).to eq ''
+    it "returns no endpoint" do
+      expect(document.viewer_endpoint).to eq ""
     end
   end
-  describe 'checked_endpoint' do
+  describe "checked_endpoint" do
     let(:document_attributes) { {} }
-    let(:reference) { Geoblacklight::Reference.new(['http://www.opengis.net/def/serviceType/ogc/wms', 'http://www.example.com/wms']) }
-    it 'returns endpoint if available' do
+    let(:reference) { Geoblacklight::Reference.new(["http://www.opengis.net/def/serviceType/ogc/wms", "http://www.example.com/wms"]) }
+    it "returns endpoint if available" do
       expect_any_instance_of(Geoblacklight::References).to receive(:wms).and_return(reference)
-      expect(document.checked_endpoint('wms')).to eq 'http://www.example.com/wms'
+      expect(document.checked_endpoint("wms")).to eq "http://www.example.com/wms"
     end
-    it 'return nil if not available' do
+    it "return nil if not available" do
       expect_any_instance_of(Geoblacklight::References).to receive(:wms).and_return(nil)
-      expect(document.checked_endpoint('wms')).to be_nil
+      expect(document.checked_endpoint("wms")).to be_nil
     end
   end
-  describe 'method_missing' do
+  describe "method_missing" do
     let(:document_attributes) { {} }
-    it 'calls checked_endpoint with parsed method name if matches' do
-      expect(document).to receive(:checked_endpoint).with('wms').and_return(nil)
+    it "calls checked_endpoint with parsed method name if matches" do
+      expect(document).to receive(:checked_endpoint).with("wms").and_return(nil)
       expect(document.wms_url).to be_nil
     end
-    it 'raises no method error' do
+    it "raises no method error" do
       expect { document.wms_urlz }.to raise_error NoMethodError
     end
   end
+  describe "#respond_to_missing?" do
+    let(:document_attributes) { {} }
+    context "with a valid method" do
+      it "returns true" do
+        expect(document.respond_to?(:wms_url)).to be true
+      end
+    end
+    context "with a invalid method" do
+      it "returns true" do
+        expect(document.respond_to?(:wms_urlz)).to be false
+      end
+    end
+  end
 end

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

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::SuppressedRecordsSearchBehavior do
   subject(:searcher) { search_builder.with(user_params) }
 
   let(:user_params) { {} }
-  let(:solr_params) { { q: 'water' } }
+  let(:solr_params) { {q: "water"} }
   let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
   let(:context) { CatalogController.new }
   let(:search_builder_class) do
@@ -16,14 +17,14 @@ describe Geoblacklight::SuppressedRecordsSearchBehavior do
   end
   let(:search_builder) { search_builder_class.new(context) }
 
-  describe '#hide_suppressed_records' do
-    it 'hides/filters suppressed records' do
-      expect(searcher.hide_suppressed_records(solr_params)).to include('-gbl_suppressed_b: true')
+  describe "#hide_suppressed_records" do
+    it "hides/filters suppressed records" do
+      expect(searcher.hide_suppressed_records(solr_params)).to include("-gbl_suppressed_b: true")
     end
   end
 
-  context 'when document action call like CatalogController#web_services' do
-    it 'does not hide/filter suppressed records' do
+  context "when document action call like CatalogController#web_services" do
+    it "does not hide/filter suppressed records" do
       solr_params[:q] = "{!lucene}#{Settings.FIELDS.ID}:"
       expect(searcher.hide_suppressed_records(solr_params)).to be_nil
     end

data/spec/presenters/geoblacklight/bbox_item_presenter_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'spec_helper'
+require "spec_helper"
 
 RSpec.describe Geoblacklight::BboxItemPresenter, type: :presenter do
   subject(:presenter) do
@@ -9,27 +9,27 @@ RSpec.describe Geoblacklight::BboxItemPresenter, type: :presenter do
 
   let(:facet_item) { instance_double(Blacklight::Solr::Response::Facets::FacetItem) }
   let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: true) }
-  let(:facet_config) { Blacklight::Configuration::FacetField.new(key: 'key') }
+  let(:facet_config) { Blacklight::Configuration::FacetField.new(key: "key") }
   let(:facet_field) { instance_double(Blacklight::Solr::Response::Facets::FacetField) }
   let(:view_context) { controller.view_context }
   let(:search_state) { instance_double(Blacklight::SearchState, filter: filter_field) }
   let(:controller) { CatalogController.new }
 
-  describe '#label' do
-    context 'with a single value' do
-      let(:facet_item) { 'blah' }
+  describe "#label" do
+    context "with a single value" do
+      let(:facet_item) { "blah" }
 
-      it 'uses the normal logic for item values' do
-        expect(presenter.label).to eq 'blah'
+      it "uses the normal logic for item values" do
+        expect(presenter.label).to eq "blah"
       end
     end
 
-    context 'with a bbox' do
+    context "with a bbox" do
       let(:facet_item) { Geoblacklight::BoundingBox.new(-160, -80, 120, 70) }
 
-      it 'translates the bbox into some nice, human-readable html' do
+      it "translates the bbox into some nice, human-readable html" do
         expect(Capybara.string(presenter.label))
-          .to have_text('-160 -80 120 70')
+          .to have_text("-160 -80 120 70")
       end
     end
   end

data/spec/routing/catalog_routing_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-describe 'Catalog Routes', type: :routing do
+require "spec_helper"
+
+describe "Catalog Routes", type: :routing do
   # Test paths for custom routes
   it "maps { :controller => 'catalog', :action => 'opensearch', :format => 'xml' } to /catalog/opensearch.xml" do
-    expect(get: '/catalog/opensearch.xml').to route_to(controller: 'catalog', action: 'opensearch', format: 'xml')
+    expect(get: "/catalog/opensearch.xml").to route_to(controller: "catalog", action: "opensearch", format: "xml")
   end
 end

data/spec/spec_helper.rb

@@ -1,64 +1,65 @@
 # frozen_string_literal: true
-ENV['RAILS_ENV'] ||= 'test'
 
-require 'simplecov'
+ENV["RAILS_ENV"] ||= "test"
+
+require "simplecov"
 SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter
 
-if ENV.fetch('CIRCLE_ARTIFACTS', false)
-  dir = File.join(ENV.fetch('CIRCLE_ARTIFACTS'), 'coverage')
+if ENV.fetch("CIRCLE_ARTIFACTS", false)
+  dir = File.join(ENV.fetch("CIRCLE_ARTIFACTS"), "coverage")
   SimpleCov.coverage_dir(dir)
 end
 
-SimpleCov.start 'rails' do
-  add_filter 'lib/generators/geoblacklight/install_generator.rb'
-  add_filter 'lib/geoblacklight/version.rb'
-  add_filter 'lib/generators'
-  add_filter 'lib/tasks/geoblacklight.rake'
-  add_filter '/spec'
-  add_filter '.internal_test_app/'
+SimpleCov.start "rails" do
+  add_filter "lib/generators/geoblacklight/install_generator.rb"
+  add_filter "lib/geoblacklight/version.rb"
+  add_filter "lib/generators"
+  add_filter "lib/tasks/geoblacklight.rake"
+  add_filter "/spec"
+  add_filter ".internal_test_app/"
   minimum_coverage 100
 end
 
-require 'factory_bot'
-require 'database_cleaner'
+require "factory_bot"
+require "database_cleaner"
 
-require 'engine_cart'
+require "engine_cart"
 EngineCart.load_application!
 
-require 'rails-controller-testing' if Rails::VERSION::MAJOR >= 5
-require 'rspec/rails'
-require 'capybara/rspec'
-require 'selenium-webdriver'
-require 'webdrivers'
+require "rails-controller-testing" if Rails::VERSION::MAJOR >= 5
+require "rspec/rails"
+require "capybara/rspec"
+require "selenium-webdriver"
+require "webdrivers"
 
 # Setup webmock for specific tests
-require 'webmock/rspec'
+require "webmock/rspec"
 WebMock.allow_net_connect!(net_http_connect_on_start: true)
 
 Capybara.register_driver(:headless_chrome) do |app|
   Capybara::Selenium::Driver.load_selenium
   browser_options = ::Selenium::WebDriver::Chrome::Options.new.tap do |opts|
-    opts.args << '--headless'
-    opts.args << '--disable-gpu'
-    opts.args << '--window-size=1280,1024'
+    opts.args << "--headless"
+    opts.args << "--disable-gpu"
+    opts.args << "--window-size=1280,1024"
   end
   http_client = Selenium::WebDriver::Remote::Http::Default.new
   http_client.read_timeout = 120
   http_client.open_timeout = 120
   Capybara::Selenium::Driver.new(app,
-                                 browser: :chrome,
-                                 http_client: http_client,
-                                 capabilities: [browser_options])
+    browser: :chrome,
+    http_client: http_client,
+    capabilities: [browser_options])
 end
 
 Capybara.javascript_driver = :headless_chrome
 Capybara.default_max_wait_time = 120
 
-require 'geoblacklight'
+require "geoblacklight"
 
-Dir['./spec/support/**/*.rb'].sort.each { |f| require f }
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
 
-FactoryBot.definition_file_paths = [File.expand_path('../factories', __FILE__)]
+FactoryBot.definition_file_paths = [File.expand_path("../factories", __FILE__)]
 FactoryBot.find_definitions
 
 RSpec.configure do |config|
@@ -66,10 +67,10 @@ RSpec.configure do |config|
 
   config.before do
     DatabaseCleaner.strategy = if Capybara.current_driver == :rack_test
-                                 :transaction
-                               else
-                                 :truncation
-                               end
+      :transaction
+    else
+      :truncation
+    end
     DatabaseCleaner.start
   end