geoblacklight 4.0.0.pre.rc3 → 4.1.0

data/spec/lib/geoblacklight/download/geojson_download_spec.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::GeojsonDownload do
-  let(:document) { SolrDocument.new(Settings.FIELDS.ID => 'test', solr_wfs_url: 'http://www.example.com/wfs', Settings.FIELDS.WXS_IDENTIFIER => 'stanford-test', Settings.FIELDS.GEOMETRY => 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:document) { SolrDocument.new(Settings.FIELDS.ID => "test", :solr_wfs_url => "http://www.example.com/wfs", Settings.FIELDS.WXS_IDENTIFIER => "stanford-test", Settings.FIELDS.GEOMETRY => "ENVELOPE(-180, 180, 90, -90)") }
   let(:download) { described_class.new(document) }
-  describe '#initialize' do
-    it 'initializes as a GeojsonDownload object with specific options' do
+  describe "#initialize" do
+    it "initializes as a GeojsonDownload object with specific options" do
       expect(download).to be_an described_class
       options = download.instance_variable_get(:@options)
-      expect(options[:content_type]).to eq 'application/json'
-      expect(options[:request_params][:typeName]).to eq 'stanford-test'
+      expect(options[:content_type]).to eq "application/json"
+      expect(options[:request_params][:typeName]).to eq "stanford-test"
     end
-    it 'merges custom options' do
+    it "merges custom options" do
       download = described_class.new(document, timeout: 33)
       options = download.instance_variable_get(:@options)
       expect(options[:timeout]).to eq 33

data/spec/lib/geoblacklight/download/geotiff_download_spec.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::GeotiffDownload do
-  let(:document) { SolrDocument.new(Settings.FIELDS.ID => 'test', Settings.FIELDS.WXS_IDENTIFIER => 'stanford-test', Settings.FIELDS.GEOMETRY => 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:document) { SolrDocument.new(Settings.FIELDS.ID => "test", Settings.FIELDS.WXS_IDENTIFIER => "stanford-test", Settings.FIELDS.GEOMETRY => "ENVELOPE(-180, 180, 90, -90)") }
   let(:download) { described_class.new(document) }
-  describe '#initialize' do
-    it 'initializes as a GeotiffDownload object with specific options' do
+  describe "#initialize" do
+    it "initializes as a GeotiffDownload object with specific options" do
       expect(download).to be_an described_class
       options = download.instance_variable_get(:@options)
-      expect(options[:content_type]).to eq 'image/geotiff'
-      expect(options[:request_params][:layers]).to eq 'stanford-test'
+      expect(options[:content_type]).to eq "image/geotiff"
+      expect(options[:request_params][:layers]).to eq "stanford-test"
       expect(options[:reflect]).to be_truthy
     end
-    it 'merges custom options' do
+    it "merges custom options" do
       download = described_class.new(document, timeout: 33)
       options = download.instance_variable_get(:@options)
       expect(options[:timeout]).to eq 33

data/spec/lib/geoblacklight/download/hgl_download_spec.rb

@@ -1,36 +1,37 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::HglDownload do
   subject(:download) { described_class.new(document, options) }
 
-  let(:document) { SolrDocument.new(Settings.FIELDS.ID => 'test', Settings.FIELDS.WXS_IDENTIFIER => 'cite:harvard-test') }
-  let(:options) { 'foo@example.com' }
+  let(:document) { SolrDocument.new(Settings.FIELDS.ID => "test", Settings.FIELDS.WXS_IDENTIFIER => "cite:harvard-test") }
+  let(:options) { "foo@example.com" }
 
-  describe '#initialize' do
-    it 'initializes as an HglDownload object with specific options' do
+  describe "#initialize" do
+    it "initializes as an HglDownload object with specific options" do
       expect(download).to be_an described_class
       options = download.instance_variable_get(:@options)
-      expect(options[:request_params]['LayerName']).to eq 'harvard-test'
-      expect(options[:request_params]['UserEmail']).to eq 'foo@example.com'
+      expect(options[:request_params]["LayerName"]).to eq "harvard-test"
+      expect(options[:request_params]["UserEmail"]).to eq "foo@example.com"
     end
-    it 'merges custom options' do
-      download = described_class.new(document, 'foo@example.com', timeout: 33)
+    it "merges custom options" do
+      download = described_class.new(document, "foo@example.com", timeout: 33)
       options = download.instance_variable_get(:@options)
       expect(options[:timeout]).to eq 33
     end
   end
 
-  describe '#get' do
+  describe "#get" do
     let(:references_field) { Settings.FIELDS.REFERENCES }
     let(:references_values) do
       {
-        '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"
       }
     end
     let(:options) do
       {
-        service_type: 'wms',
+        :service_type => "wms",
         references_field => references_values.to_json
       }
     end
@@ -40,8 +41,8 @@ describe Geoblacklight::HglDownload do
     let(:faraday_request_options) { OpenStruct.new(timeout: nil, open_timeout: nil) }
     let(:reference) { instance_double(Geoblacklight::Reference) }
     # Methods cannot be stubbed which are automatically generated from Hash keys
-    let(:references) { double('references') }
-    let(:endpoint) { 'http://www.example.com/wms' }
+    let(:references) { double("references") }
+    let(:endpoint) { "http://www.example.com/wms" }
 
     before do
       allow(reference).to receive(:endpoint).and_return(endpoint)
@@ -51,7 +52,7 @@ describe Geoblacklight::HglDownload do
       allow(faraday_request).to receive(:options).and_return(faraday_request_options)
     end
 
-    it 'downloads the file and generates a message for the client' do
+    it "downloads the file and generates a message for the client" do
       allow(faraday_connection).to receive(:get).and_yield(faraday_request).and_return(faraday_response)
       allow(Faraday).to receive(:new).with(url: endpoint).and_return(faraday_connection)
 

data/spec/lib/geoblacklight/download/kmz_download_spec.rb

@@ -1,18 +1,19 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::KmzDownload do
-  let(:document) { SolrDocument.new(Settings.FIELDS.ID => 'test', solr_wfs_url: 'http://www.example.com/wfs', Settings.FIELDS.WXS_IDENTIFIER => 'stanford-test', Settings.FIELDS.GEOMETRY => 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:document) { SolrDocument.new(Settings.FIELDS.ID => "test", :solr_wfs_url => "http://www.example.com/wfs", Settings.FIELDS.WXS_IDENTIFIER => "stanford-test", Settings.FIELDS.GEOMETRY => "ENVELOPE(-180, 180, 90, -90)") }
   let(:download) { described_class.new(document) }
-  describe '#initialize' do
-    it 'initializes as a KmzDownload object with specific options' do
+  describe "#initialize" do
+    it "initializes as a KmzDownload object with specific options" do
       expect(download).to be_an described_class
       options = download.instance_variable_get(:@options)
-      expect(options[:content_type]).to eq 'application/vnd.google-earth.kmz'
-      expect(options[:request_params][:layers]).to eq 'stanford-test'
-      expect(options[:request_params][:bbox]).to eq '-180.0, -90.0, 180.0, 90.0'
+      expect(options[:content_type]).to eq "application/vnd.google-earth.kmz"
+      expect(options[:request_params][:layers]).to eq "stanford-test"
+      expect(options[:request_params][:bbox]).to eq "-180.0, -90.0, 180.0, 90.0"
     end
-    it 'merges custom options' do
+    it "merges custom options" do
       download = described_class.new(document, timeout: 33)
       options = download.instance_variable_get(:@options)
       expect(options[:timeout]).to eq 33

data/spec/lib/geoblacklight/download/shapefile_download_spec.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::ShapefileDownload do
-  let(:document) { SolrDocument.new(Settings.FIELDS.ID => 'test', solr_wfs_url: 'http://www.example.com/wfs', Settings.FIELDS.WXS_IDENTIFIER => 'stanford-test', Settings.FIELDS.GEOMETRY => 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:document) { SolrDocument.new(Settings.FIELDS.ID => "test", :solr_wfs_url => "http://www.example.com/wfs", Settings.FIELDS.WXS_IDENTIFIER => "stanford-test", Settings.FIELDS.GEOMETRY => "ENVELOPE(-180, 180, 90, -90)") }
   let(:download) { described_class.new(document) }
-  describe '#initialize' do
-    it 'initializes as a ShapefileDownload object with specific options' do
+  describe "#initialize" do
+    it "initializes as a ShapefileDownload object with specific options" do
       expect(download).to be_an described_class
       options = download.instance_variable_get(:@options)
-      expect(options[:content_type]).to eq 'application/zip'
-      expect(options[:request_params][:typeName]).to eq 'stanford-test'
+      expect(options[:content_type]).to eq "application/zip"
+      expect(options[:request_params][:typeName]).to eq "stanford-test"
     end
-    it 'merges custom options' do
+    it "merges custom options" do
       download = described_class.new(document, timeout: 33)
       options = download.instance_variable_get(:@options)
       expect(options[:timeout]).to eq 33

data/spec/lib/geoblacklight/download_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::Download do
   subject(:download) { described_class.new(document, options) }
@@ -7,78 +8,78 @@ describe Geoblacklight::Download do
   let(:faraday_connection) { instance_double(Faraday::Connection) }
   let(:faraday_response) { instance_double(Faraday::Response) }
   let(:references_field) { Settings.FIELDS.REFERENCES }
-  let(:document) { SolrDocument.new("#{Settings.FIELDS.ID}": 'test', references_field => { 'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms' }.to_json) }
-  let(:options) { { type: 'shapefile', extension: 'zip', service_type: 'wms', content_type: 'application/zip' } }
+  let(:document) { SolrDocument.new(:"#{Settings.FIELDS.ID}" => "test", references_field => {"http://www.opengis.net/def/serviceType/ogc/wms" => "http://www.example.com/wms"}.to_json) }
+  let(:options) { {type: "shapefile", extension: "zip", service_type: "wms", content_type: "application/zip"} }
 
-  describe '#initialize' do
-    it 'initializes as a Download object' do
+  describe "#initialize" do
+    it "initializes as a Download object" do
       expect(download).to be_a described_class
     end
   end
 
-  describe '#downloadable?' do
+  describe "#downloadable?" do
     before do
       allow(document).to receive(:downloadable?).and_return(true)
     end
-    it 'determines whether or not the resource can be downloaded' do
+    it "determines whether or not the resource can be downloaded" do
       expect(download.downloadable?).to be true
     end
   end
 
-  describe '#file_name' do
-    it 'gives the file name with path and extension' do
-      expect(download.file_name).to eq 'test-shapefile.zip'
+  describe "#file_name" do
+    it "gives the file name with path and extension" do
+      expect(download.file_name).to eq "test-shapefile.zip"
     end
   end
-  describe '#file_path' do
-    it 'returns the path with name and extension' do
-      expect(download.class.file_path).to eq Rails.root.join('tmp', 'cache', 'downloads')
+  describe "#file_path" do
+    it "returns the path with name and extension" do
+      expect(download.class.file_path).to eq Rails.root.join("tmp", "cache", "downloads")
     end
-    it 'is configurable' do
-      expect(Settings).to receive(:DOWNLOAD_PATH).and_return('configured/path')
-      expect(download.class.file_path).to eq 'configured/path'
+    it "is configurable" do
+      expect(Settings).to receive(:DOWNLOAD_PATH).and_return("configured/path")
+      expect(download.class.file_path).to eq "configured/path"
     end
   end
-  describe '#download_exists?' do
-    it 'returns false if file does not exist' do
+  describe "#download_exists?" do
+    it "returns false if file does not exist" do
       expect(File).to receive(:file?).and_return(false)
       expect(download.download_exists?).to be_falsey
     end
-    it 'returns true if file does not exist' do
+    it "returns true if file does not exist" do
       expect(File).to receive(:file?).and_return(true)
       expect(download.download_exists?).to be_truthy
     end
   end
-  describe '#get' do
+  describe "#get" do
     before do
       allow(File).to receive(:file?).and_return(true)
     end
 
-    it 'returns filename if download exists' do
+    it "returns filename if download exists" do
       expect(download.get).to eq download.file_name
     end
 
-    context 'when the file has not already been downloaded' do
+    context "when the file has not already been downloaded" do
       let(:connection) { instance_double(Faraday::Connection) }
       let(:response) { instance_double(Faraday::Response) }
 
       before do
         allow(File).to receive(:file?).and_return(false)
-        allow(connection).to receive(:get).and_return(object: 'file')
+        allow(connection).to receive(:get).and_return(object: "file")
         allow(Faraday).to receive(:new).and_return(connection)
       end
 
-      it 'calls create_download_file if it does not exist' do
-        allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", 'wb').and_return('')
+      it "calls create_download_file if it does not exist" do
+        allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", "wb").and_return("")
         allow(File).to receive(:rename)
 
-        expect(download.get).to eq 'test-shapefile.zip'
+        expect(download.get).to eq "test-shapefile.zip"
       end
     end
   end
-  describe '#create_download_file' do
+  describe "#create_download_file" do
     let(:file) { instance_double(File) }
-    let(:shapefile) { OpenStruct.new(headers: { 'content-type' => 'application/zip' }) }
+    let(:shapefile) { OpenStruct.new(headers: {"content-type" => "application/zip"}) }
     let(:connection) { instance_double(Faraday::Connection) }
     let(:response) { instance_double(Faraday::Response) }
 
@@ -88,43 +89,43 @@ describe Geoblacklight::Download do
       allow(connection).to receive(:get).and_return(shapefile)
     end
 
-    it 'creates the file, write it, and then rename from tmp if everything is ok' do
-      allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", 'wb').and_yield(file).and_return('')
+    it "creates the file, write it, and then rename from tmp if everything is ok" do
+      allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", "wb").and_yield(file).and_return("")
       allow(File).to receive(:rename)
 
       expect(download.create_download_file).to eq download.file_name
     end
 
-    context 'when the file received is not of the type requested' do
-      let(:bad_file) { OpenStruct.new(headers: { 'content-type' => 'bad/file' }) }
+    context "when the file received is not of the type requested" do
+      let(:bad_file) { OpenStruct.new(headers: {"content-type" => "bad/file"}) }
 
       before do
         allow(connection).to receive(:get).and_return(bad_file)
       end
 
-      it 'creates the file in fs and delete it if the content headers are not correct' do
+      it "creates the file in fs and delete it if the content headers are not correct" do
         allow(File).to receive(:delete).with("#{download.file_path_and_name}.tmp").and_return(nil)
 
-        expect { download.create_download_file }.to raise_error(Geoblacklight::Exceptions::ExternalDownloadFailed, 'Wrong download type')
+        expect { download.create_download_file }.to raise_error(Geoblacklight::Exceptions::ExternalDownloadFailed, "Wrong download type")
       end
     end
 
-    context 'when the MIME type has more information encoded' do
-      let(:geojson) { OpenStruct.new(headers: { 'content-type' => 'application/json;charset=utf-8' }) }
+    context "when the MIME type has more information encoded" do
+      let(:geojson) { OpenStruct.new(headers: {"content-type" => "application/json;charset=utf-8"}) }
 
       before do
         allow(connection).to receive(:get).and_return(geojson)
       end
 
-      it 'accepts response MIME type that is more complex than requested' do
-        allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", 'wb').and_return('')
+      it "accepts response MIME type that is more complex than requested" do
+        allow(File).to receive(:open).with("#{download.file_path_and_name}.tmp", "wb").and_return("")
         allow(File).to receive(:rename)
 
         expect(download.create_download_file).to eq download.file_name
       end
     end
   end
-  describe '#initiate_download' do
+  describe "#initiate_download" do
     let(:faraday_request) { instance_double(Faraday::Request) }
     let(:faraday_request_options) { OpenStruct.new(timeout: nil, open_timeout: nil) }
 
@@ -133,46 +134,46 @@ describe Geoblacklight::Download do
       allow(faraday_request).to receive(:options).and_return(faraday_request_options)
     end
 
-    it 'request download from server' do
+    it "request download from server" do
       allow(faraday_connection).to receive(:get).and_yield(faraday_request).and_return(faraday_response)
-      allow(Faraday).to receive(:new).with(url: 'http://www.example.com/wms').and_return(faraday_connection)
+      allow(Faraday).to receive(:new).with(url: "http://www.example.com/wms").and_return(faraday_connection)
 
       expect(download.initiate_download).to eq faraday_response
     end
 
-    it 'raises Geoblacklight::Exceptions::ExternalDownloadFailed with a connection failure' do
-      expect(faraday_connection).to receive(:url_prefix).and_return 'http://www.example.com/wms'
-      expect(faraday_connection).to receive(:get).and_raise(Faraday::ConnectionFailed.new('Failed'))
-      expect(Faraday).to receive(:new).with(url: 'http://www.example.com/wms').and_return(faraday_connection)
+    it "raises Geoblacklight::Exceptions::ExternalDownloadFailed with a connection failure" do
+      expect(faraday_connection).to receive(:url_prefix).and_return "http://www.example.com/wms"
+      expect(faraday_connection).to receive(:get).and_raise(Faraday::ConnectionFailed.new("Failed"))
+      expect(Faraday).to receive(:new).with(url: "http://www.example.com/wms").and_return(faraday_connection)
       expect { download.initiate_download }.to raise_error(Geoblacklight::Exceptions::ExternalDownloadFailed)
     end
 
-    it 'raises Geoblacklight::Exceptions::ExternalDownloadFailed with a connection timout' do
-      expect(faraday_connection).to receive(:url_prefix).and_return 'http://www.example.com/wms'
+    it "raises Geoblacklight::Exceptions::ExternalDownloadFailed with a connection timout" do
+      expect(faraday_connection).to receive(:url_prefix).and_return "http://www.example.com/wms"
       expect(faraday_connection).to receive(:get).and_raise(Faraday::TimeoutError)
-      expect(Faraday).to receive(:new).with(url: 'http://www.example.com/wms').and_return(faraday_connection)
+      expect(Faraday).to receive(:new).with(url: "http://www.example.com/wms").and_return(faraday_connection)
       expect { download.initiate_download }.to raise_error(Geoblacklight::Exceptions::ExternalDownloadFailed)
     end
   end
-  describe '#url_with_params' do
+  describe "#url_with_params" do
     let(:options) do
       {
-        service_type: 'wms',
+        service_type: "wms",
         request_params: {
-          service: 'wfs',
-          version: '2.0.0',
-          request: 'GetFeature',
-          srsName: 'EPSG:4326',
-          outputformat: 'SHAPE-ZIP',
-          typeName: ''
+          service: "wfs",
+          version: "2.0.0",
+          request: "GetFeature",
+          srsName: "EPSG:4326",
+          outputformat: "SHAPE-ZIP",
+          typeName: ""
         }
       }
     end
 
-    it 'creates a download url with params' do
-      expect(download.url_with_params).to eq 'http://www.example.com/wms/?ser' \
-                                             'vice=wfs&version=2.0.0&request=GetFeature&srsName=EPSG%3A4326&output' \
-                                             'format=SHAPE-ZIP&typeName='
+    it "creates a download url with params" do
+      expect(download.url_with_params).to eq "http://www.example.com/wms/?ser" \
+                                             "vice=wfs&version=2.0.0&request=GetFeature&srsName=EPSG%3A4326&output" \
+                                             "format=SHAPE-ZIP&typeName="
     end
   end
 end

data/spec/lib/geoblacklight/geometry_spec.rb

@@ -1,58 +1,59 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::Geometry do
-  let(:wkt_geom) { 'MULTIPOLYGON(((-180 81.66, -180 -12.93, -168.35 -12.93, -168.35 81.66, -180 81.66)), ((180 81.66, 25 81.66, 25 -12.93, 180 -12.93, 180 81.66)))' }
-  let(:envelope_geom) { 'ENVELOPE(25, -168.35, 81.66, -12.93)' }
-  let(:invalid_geom) { 'INVALID' }
-  let(:non_polygon_geom) { 'ENVELOPE(130, 130, 33, 33)' }
+  let(:wkt_geom) { "MULTIPOLYGON(((-180 81.66, -180 -12.93, -168.35 -12.93, -168.35 81.66, -180 81.66)), ((180 81.66, 25 81.66, 25 -12.93, 180 -12.93, 180 81.66)))" }
+  let(:envelope_geom) { "ENVELOPE(25, -168.35, 81.66, -12.93)" }
+  let(:invalid_geom) { "INVALID" }
+  let(:non_polygon_geom) { "ENVELOPE(130, 130, 33, 33)" }
 
-  describe '#geojson' do
-    context 'with standard WKT geometry' do
-      it 'returns geojson' do
-        expect(described_class.new(wkt_geom).geojson).to include('MultiPolygon', 'coordinates', '[[[[-180.0,81.66]')
+  describe "#geojson" do
+    context "with standard WKT geometry" do
+      it "returns geojson" do
+        expect(described_class.new(wkt_geom).geojson).to include("MultiPolygon", "coordinates", "[[[[-180.0,81.66]")
       end
     end
 
-    context 'with envelope syntax geometry' do
-      it 'returns geojson' do
-        expect(described_class.new(envelope_geom).geojson).to include('Polygon', 'coordinates', '[[[25.0,81.66]')
+    context "with envelope syntax geometry" do
+      it "returns geojson" do
+        expect(described_class.new(envelope_geom).geojson).to include("Polygon", "coordinates", "[[[25.0,81.66]")
       end
     end
 
-    context 'with an invalid geometry' do
-      it 'returns a default GeoJSON extent' do
-        expect(described_class.new(invalid_geom).geojson).to include('coordinates', '-180.0,90.0')
+    context "with an invalid geometry" do
+      it "returns a default GeoJSON extent" do
+        expect(described_class.new(invalid_geom).geojson).to include("coordinates", "-180.0,90.0")
       end
     end
 
-    context 'with a non-polygon geometry' do
+    context "with a non-polygon geometry" do
       before do
         allow(RGeo::GeoJSON).to receive(:encode).and_raise(RGeo::Error::InvalidGeometry)
       end
 
-      it 'returns a default GeoJSON extent' do
-        expect(described_class.new(non_polygon_geom).geojson).to include('coordinates', '-180.0,90.0')
+      it "returns a default GeoJSON extent" do
+        expect(described_class.new(non_polygon_geom).geojson).to include("coordinates", "-180.0,90.0")
       end
     end
   end
 
-  describe '#bounding_box' do
-    context 'with standard WKT geometry' do
-      it 'returns a bounding_box' do
-        expect(described_class.new(wkt_geom).bounding_box).to eq '-180.0, -12.93, 180.0, 81.66'
+  describe "#bounding_box" do
+    context "with standard WKT geometry" do
+      it "returns a bounding_box" do
+        expect(described_class.new(wkt_geom).bounding_box).to eq "-180.0, -12.93, 180.0, 81.66"
       end
     end
 
-    context 'with envelope syntax geometry' do
-      it 'returns a bounding_box' do
-        expect(described_class.new(envelope_geom).bounding_box).to eq '-168.35, -12.93, 25.0, 81.66'
+    context "with envelope syntax geometry" do
+      it "returns a bounding_box" do
+        expect(described_class.new(envelope_geom).bounding_box).to eq "-168.35, -12.93, 25.0, 81.66"
       end
     end
 
-    context 'with an invalid geometry' do
-      it 'returns a default GeoJSON extent' do
-        expect(described_class.new(invalid_geom).bounding_box).to include('coordinates', '-180.0,90.0')
+    context "with an invalid geometry" do
+      it "returns a default GeoJSON extent" do
+        expect(described_class.new(invalid_geom).bounding_box).to include("coordinates", "-180.0,90.0")
       end
     end
   end

data/spec/lib/geoblacklight/item_viewer_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::ItemViewer do
   let(:document) { SolrDocument.new(document_attributes) }
@@ -7,70 +8,70 @@ describe Geoblacklight::ItemViewer do
   let(:references) { document.references }
   let(:references_field) { Settings.FIELDS.REFERENCES }
   let(:item_viewer) { described_class.new(references) }
-  describe 'viewer_preference' do
-    describe 'for no references' do
-      it 'returns nil' do
+  describe "viewer_preference" do
+    describe "for no references" do
+      it "returns nil" do
         expect(item_viewer.viewer_preference).to be_nil
       end
     end
-    describe 'for wms reference' do
+    describe "for wms reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms',
-            'http://iiif.io/api/image' => 'http://www.example.com/iiif'
+            "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'
+      it "wms if wms is present" do
+        expect(item_viewer.viewer_preference).to eq wms: "http://www.example.com/wms"
       end
     end
-    describe 'for tms reference' do
+    describe "for tms reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'https://wiki.osgeo.org/wiki/Tile_Map_Service_Specification' => 'http://www.example.com/tms'
+            "https://wiki.osgeo.org/wiki/Tile_Map_Service_Specification" => "http://www.example.com/tms"
           }.to_json
         }
       end
-      it 'tms if tms is present' do
-        expect(item_viewer.viewer_preference).to eq tms: 'http://www.example.com/tms'
+      it "tms if tms is present" do
+        expect(item_viewer.viewer_preference).to eq tms: "http://www.example.com/tms"
       end
     end
-    describe 'for iiif only reference' do
+    describe "for iiif only reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'http://iiif.io/api/image' => 'http://www.example.com/iiif'
+            "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'
+      it "returns iiif" do
+        expect(item_viewer.viewer_preference).to eq iiif: "http://www.example.com/iiif"
       end
     end
-    describe 'for tiled map layer reference' do
+    describe "for tiled map layer reference" do
       let(:document_attributes) do
         {
           references_field => {
-            'urn:x-esri:serviceType:ArcGIS#TiledMapLayer' => 'http://www.example.com/MapServer'
+            "urn:x-esri:serviceType:ArcGIS#TiledMapLayer" => "http://www.example.com/MapServer"
           }.to_json
         }
       end
-      it 'returns mapservice' do
-        expect(item_viewer.viewer_preference).to eq tiled_map_layer: 'http://www.example.com/MapServer'
+      it "returns mapservice" do
+        expect(item_viewer.viewer_preference).to eq tiled_map_layer: "http://www.example.com/MapServer"
       end
     end
-    context 'index map' do
+    context "index map" do
       let(:document_attributes) do
         {
           references_field => {
-            'https://openindexmaps.org' => 'http://www.example.com/index_map'
+            "https://openindexmaps.org" => "http://www.example.com/index_map"
           }.to_json
         }
       end
-      it { expect(item_viewer.viewer_preference).to eq index_map: 'http://www.example.com/index_map' }
+      it { expect(item_viewer.viewer_preference).to eq index_map: "http://www.example.com/index_map" }
     end
   end
 end