geoblacklight 4.0.0.pre.rc3 → 4.1.0

data/spec/helpers/geoblacklight_helper_spec.rb

@@ -1,261 +1,262 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe GeoblacklightHelper, type: :helper do
   include BlacklightHelper
   include ActionView::Helpers::UrlHelper
   include ActionView::Helpers::TranslationHelper
 
-  describe '#geoblacklight_icon' do
-    it 'supports in use cases' do
+  describe "#geoblacklight_icon" do
+    it "supports in use cases" do
       {
-        'Paper map' => 'paper-map',
-        'Michigan State' => 'michigan-state',
-        'CD ROM' => 'cd-rom',
-        'Lewis & Clark' => 'lewis-clark'
+        "Paper map" => "paper-map",
+        "Michigan State" => "michigan-state",
+        "CD ROM" => "cd-rom",
+        "Lewis & Clark" => "lewis-clark"
       }.each_key do |key|
         html = Capybara.string(geoblacklight_icon(key))
         expect(html).to have_xpath "//*[local-name() = 'svg']"
       end
     end
-    it 'handles nil values' do
+    it "handles nil values" do
       html = Capybara.string(geoblacklight_icon(nil))
-      expect(html).to have_css '.icon-missing'
+      expect(html).to have_css ".icon-missing"
     end
   end
 
-  describe '#proper_case_format' do
-    it 'returns a properly cased format' do
-      expect(proper_case_format('GEOJSON')).to eq 'GeoJSON'
+  describe "#proper_case_format" do
+    it "returns a properly cased format" do
+      expect(proper_case_format("GEOJSON")).to eq "GeoJSON"
     end
   end
 
-  describe '#download_text' do
-    it 'returns download text concatenated with proper case format' do
-      expect(download_text('GEOJSON')).to eq 'Original GeoJSON'
+  describe "#download_text" do
+    it "returns download text concatenated with proper case format" do
+      expect(download_text("GEOJSON")).to eq "Original GeoJSON"
     end
   end
 
-  describe '#download_text' do
-    it 'returns download text concatenated with proper case format' do
-      expect(download_text('GEOJSON')).to eq 'Original GeoJSON'
+  describe "#download_text" do
+    it "returns download text concatenated with proper case format" do
+      expect(download_text("GEOJSON")).to eq "Original GeoJSON"
     end
   end
 
-  describe '#download_link_file' do
-    let(:label) { 'Test Link Text' }
-    let(:id) { 'test-id' }
-    let(:url) { 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip' }
+  describe "#download_link_file" do
+    let(:label) { "Test Link Text" }
+    let(:id) { "test-id" }
+    let(:url) { "http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip" }
 
-    it 'generates a link to download the original file' do
+    it "generates a link to download the original file" do
       expect(download_link_file(label, id, url)).to eq '<a contentUrl="http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip" data-download="trigger" data-download-type="direct" data-download-id="test-id" href="http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip">Test Link Text</a>'
     end
   end
 
-  describe '#download_link_hgl' do
-    let(:text) { 'Test Link Text' }
+  describe "#download_link_hgl" do
+    let(:text) { "Test Link Text" }
     let(:document) { instance_double(SolrDocument) }
 
     before do
-      allow(document).to receive(:id).and_return('test-id')
-      allow(document).to receive(:to_s).and_return('test-id')
+      allow(document).to receive(:id).and_return("test-id")
+      allow(document).to receive(:to_s).and_return("test-id")
     end
 
-    it 'generates a link to the HGL route' do
+    it "generates a link to the HGL route" do
       expect(download_link_hgl(text, document)).to eq '<a data-blacklight-modal="trigger" data-download="trigger" data-download-type="harvard-hgl" data-download-id="test-id" href="/download/hgl/test-id">Test Link Text</a>'
     end
   end
 
-  describe '#download_link_iiif' do
+  describe "#download_link_iiif" do
     let(:references_field) { Settings.FIELDS.REFERENCES }
     let(:document_attributes) do
       {
         references_field => {
-          'http://iiif.io/api/image' => 'https://example.edu/image/info.json'
+          "http://iiif.io/api/image" => "https://example.edu/image/info.json"
         }.to_json
       }
     end
     let(:document) { SolrDocument.new(document_attributes) }
 
     before do
-      allow_any_instance_of(Geoblacklight::Reference).to receive(:to_hash).and_return(iiif: 'https://example.edu/image/info.json')
+      allow_any_instance_of(Geoblacklight::Reference).to receive(:to_hash).and_return(iiif: "https://example.edu/image/info.json")
     end
 
-    it 'generates a link to download the JPG file from the IIIF server' do
+    it "generates a link to download the JPG file from the IIIF server" do
       assign(:document, document)
       expect(helper.download_link_iiif).to eq '<a contentUrl="https://example.edu/image/full/full/0/default.jpg" data-download="trigger" href="https://example.edu/image/full/full/0/default.jpg">Original JPG</a>'
     end
   end
 
-  describe '#download_link_generated' do
-    let(:download_type) { 'SHAPEFILE' }
+  describe "#download_link_generated" do
+    let(:download_type) { "SHAPEFILE" }
     let(:document) { instance_double(SolrDocument) }
 
     before do
-      allow(document).to receive(:id).and_return('test-id')
-      allow(document).to receive(:to_s).and_return('test-id')
+      allow(document).to receive(:id).and_return("test-id")
+      allow(document).to receive(:to_s).and_return("test-id")
     end
 
-    it 'generates a link to download the JPG file from the IIIF server' do
+    it "generates a link to download the JPG file from the IIIF server" do
       # Stub I18n to ensure the link can be customized via `export_` labels.
       allow(helper).to receive(:t).and_call_original
-      allow(helper).to receive(:t).with('geoblacklight.download.export_shapefile_link').and_return('Shapefile Export Customization')
+      allow(helper).to receive(:t).with("geoblacklight.download.export_shapefile_link").and_return("Shapefile Export Customization")
       expect(helper.download_link_generated(download_type, document)).to eq '<a data-download-path="/download/test-id?type=SHAPEFILE" data-download="trigger" data-download-type="SHAPEFILE" data-download-id="test-id" href="">Export Shapefile Export Customization</a>'
     end
   end
 
-  describe '#geoblacklight_basemap' do
+  describe "#geoblacklight_basemap" do
     let(:blacklight_config) { double }
-    it 'without configuration' do
+    it "without configuration" do
       expect(blacklight_config).to receive(:basemap_provider).and_return(nil)
-      expect(geoblacklight_basemap).to eq 'positron'
+      expect(geoblacklight_basemap).to eq "positron"
     end
-    it 'with custom configuration' do
-      expect(blacklight_config).to receive(:basemap_provider).and_return('positron')
-      expect(geoblacklight_basemap).to eq 'positron'
+    it "with custom configuration" do
+      expect(blacklight_config).to receive(:basemap_provider).and_return("positron")
+      expect(geoblacklight_basemap).to eq "positron"
     end
   end
 
-  describe '#iiif_jpg_url' do
+  describe "#iiif_jpg_url" do
     let(:document) { SolrDocument.new(document_attributes) }
     let(:references_field) { Settings.FIELDS.REFERENCES }
     let(:document_attributes) do
       {
         references_field => {
-          'http://iiif.io/api/image' => 'https://example.edu/image/info.json'
+          "http://iiif.io/api/image" => "https://example.edu/image/info.json"
         }.to_json
       }
     end
 
-    it 'returns JPG download URL when given URL to a IIIF info.json' do
+    it "returns JPG download URL when given URL to a IIIF info.json" do
       assign(:document, document)
-      expect(helper.iiif_jpg_url).to eq 'https://example.edu/image/full/full/0/default.jpg'
+      expect(helper.iiif_jpg_url).to eq "https://example.edu/image/full/full/0/default.jpg"
     end
   end
 
-  describe '#snippit' do
+  describe "#snippit" do
     let(:document) { SolrDocument.new(document_attributes) }
     let(:references_field) { Settings.FIELDS.REFERENCES }
-    context 'as a String' do
+    context "as a String" do
       let(:document_attributes) do
         {
-          value: 'This is a really long string that should get truncated when it gets rendered' \
-                 'in the index view to give a brief description of the contents of a particular document' \
-                 'indexed into Solr'
+          value: "This is a really long string that should get truncated when it gets rendered" \
+                 "in the index view to give a brief description of the contents of a particular document" \
+                 "indexed into Solr"
         }
       end
-      it 'truncates longer strings to 150 characters' do
+      it "truncates longer strings to 150 characters" do
         expect(helper.snippit(document).length).to eq 150
       end
-      it 'truncated string ends with ...' do
-        expect(helper.snippit(document)[-3..-1]).to eq '...'
+      it "truncated string ends with ..." do
+        expect(helper.snippit(document)[-3..]).to eq "..."
       end
     end
-    context 'as an Array' do
+    context "as an Array" do
       let(:document_attributes) do
         {
-          value: ['This is a really long string that should get truncated when it gets rendered' \
-                  'in the index view to give a brief description of the contents of a particular document' \
-                  'indexed into Solr']
+          value: ["This is a really long string that should get truncated when it gets rendered" \
+                  "in the index view to give a brief description of the contents of a particular document" \
+                  "indexed into Solr"]
         }
       end
-      it 'truncates longer strings to 150 characters' do
+      it "truncates longer strings to 150 characters" do
         expect(helper.snippit(document).length).to eq 150
       end
-      it 'truncated string ends with ...' do
-        expect(helper.snippit(document)[-3..-1]).to eq '...'
+      it "truncated string ends with ..." do
+        expect(helper.snippit(document)[-3..]).to eq "..."
       end
     end
-    context 'as a multivalued Array' do
+    context "as a multivalued Array" do
       let(:document_attributes) do
         {
           value: %w[short description]
         }
       end
-      it 'uses both values' do
-        expect(helper.snippit(document)).to eq 'short description'
+      it "uses both values" do
+        expect(helper.snippit(document)).to eq "short description"
       end
-      it 'does not truncate' do
-        expect(helper.snippit(document)[-3..-1]).not_to eq '...'
+      it "does not truncate" do
+        expect(helper.snippit(document)[-3..]).not_to eq "..."
       end
     end
   end
 
-  describe '#render_web_services' do
-    let(:reference) { instance_double(Geoblacklight::Reference, type: 'wms') }
-    it 'with a reference to a defined partial' do
+  describe "#render_web_services" do
+    let(:reference) { instance_double(Geoblacklight::Reference, type: "wms") }
+    it "with a reference to a defined partial" do
       expect(helper).to receive(:render)
-        .with(partial: 'web_services_wms', locals: { reference: reference })
+        .with(partial: "web_services_wms", locals: {reference: reference})
       helper.render_web_services(reference)
     end
-    context 'when the partial is missing' do
-      let(:reference) { instance_double(Geoblacklight::Reference, type: 'iiif') }
+    context "when the partial is missing" do
+      let(:reference) { instance_double(Geoblacklight::Reference, type: "iiif") }
 
-      it 'with a reference to a missing partial' do
+      it "with a reference to a missing partial" do
         expect(helper).to receive(:render)
-          .with(partial: 'web_services_iiif', locals: { reference: reference })
-          .and_raise ActionView::MissingTemplate.new({}, '', '', '', '')
+          .with(partial: "web_services_iiif", locals: {reference: reference})
+          .and_raise ActionView::MissingTemplate.new({}, "", "", "", "")
         expect(helper).to receive(:render)
-          .with(partial: 'web_services_default', locals: { reference: reference })
+          .with(partial: "web_services_default", locals: {reference: reference})
         helper.render_web_services(reference)
       end
     end
   end
 
-  describe '#leaflet_options' do
-    it 'returns a hash of options for leaflet' do
+  describe "#leaflet_options" do
+    it "returns a hash of options for leaflet" do
       expect(leaflet_options[:VIEWERS][:WMS][:CONTROLS]).to eq(%w[Opacity Fullscreen])
     end
   end
 
-  describe '#render_value_as_truncate_abstract' do
-    context 'with multiple values' do
+  describe "#render_value_as_truncate_abstract" do
+    context "with multiple values" do
       let(:document) { SolrDocument.new(value: %w[short description]) }
-      it 'wraps in correct DIV class' do
+      it "wraps in correct DIV class" do
         expect(helper.render_value_as_truncate_abstract(document)).to eq '<div class="truncate-abstract">short description</div>'
       end
     end
   end
 
-  describe '#render_transformed_metadata' do
+  describe "#render_transformed_metadata" do
     let(:metadata) { instance_double(Geoblacklight::Metadata::Base) }
-    context 'with valid XML data' do
+    context "with valid XML data" do
       before do
-        allow(metadata).to receive(:transform).and_return('<div>test</div>')
+        allow(metadata).to receive(:transform).and_return("<div>test</div>")
       end
 
-      it 'renders the partial with metadata content' do
+      it "renders the partial with metadata content" do
         expect(helper).to receive(:render)
-          .with(partial: 'catalog/metadata/content', locals: { content: '<div>test</div>' })
+          .with(partial: "catalog/metadata/content", locals: {content: "<div>test</div>"})
         helper.render_transformed_metadata(metadata)
       end
     end
 
-    context 'with valid XML data without an HTML transform' do
+    context "with valid XML data without an HTML transform" do
       before do
         allow(metadata).to receive(:transform).and_raise(Geoblacklight::MetadataTransformer::TransformError)
-        allow(metadata).to receive(:to_xml).and_return('<data></data>')
+        allow(metadata).to receive(:to_xml).and_return("<data></data>")
       end
 
-      it 'renders the partial with metadata content' do
-        expect(helper).to receive(:render).with(partial: 'catalog/metadata/markup', locals: { content: '<data></data>' })
+      it "renders the partial with metadata content" do
+        expect(helper).to receive(:render).with(partial: "catalog/metadata/markup", locals: {content: "<data></data>"})
         helper.render_transformed_metadata(metadata)
       end
     end
 
-    context 'without XML data' do
+    context "without XML data" do
       before do
         allow(metadata).to receive(:transform).and_raise(Geoblacklight::MetadataTransformer::ParseError)
       end
 
-      it 'renders the partial with metadata content' do
-        expect(helper).to receive(:render).with(partial: 'catalog/metadata/missing')
+      it "renders the partial with metadata content" do
+        expect(helper).to receive(:render).with(partial: "catalog/metadata/missing")
         helper.render_transformed_metadata(metadata)
       end
     end
   end
 
-  describe '#first_metadata?' do
+  describe "#first_metadata?" do
     let(:metadata) { instance_double(Geoblacklight::Metadata::Base) }
     let(:references) { instance_double(Geoblacklight::References) }
     let(:document) { instance_double(SolrDocument) }
@@ -263,96 +264,96 @@ describe GeoblacklightHelper, type: :helper do
     before do
       allow(document).to receive(:references).and_return(references)
       allow(references).to receive(:shown_metadata).and_return([metadata])
-      allow(metadata).to receive(:type).and_return('fgdc')
+      allow(metadata).to receive(:type).and_return("fgdc")
     end
 
-    it 'confirms that a metadata resource is the first item reference' do
+    it "confirms that a metadata resource is the first item reference" do
       expect(helper.first_metadata?(document, metadata)).to be true
     end
   end
 
-  describe '#show_help_text?' do
-    let(:feature) { 'viewer_protocol' }
-    let(:translation_key) { 'wms' }
+  describe "#show_help_text?" do
+    let(:feature) { "viewer_protocol" }
+    let(:translation_key) { "wms" }
 
-    it 'confirms help text is available' do
+    it "confirms help text is available" do
       expect(helper.show_help_text?(feature, translation_key)).to be true
     end
   end
 
-  describe '#render_help_text_entry' do
-    let(:feature) { 'viewer_protocol' }
-    let(:translation_key) { 'wms' }
+  describe "#render_help_text_entry" do
+    let(:feature) { "viewer_protocol" }
+    let(:translation_key) { "wms" }
 
-    context 'valid entry' do
-      it 'renders help text entry for the wms viewer protocol' do
+    context "valid entry" do
+      it "renders help text entry for the wms viewer protocol" do
         expect(helper.render_help_text_entry(feature, translation_key)).to eq '<h3 class="help-text viewer_protocol h6"><a data-toggle="popover" data-title="Web Map Service (WMS)" data-content="A Web Map Service displays a geospatial dataset as map images.">Web Map Service (WMS)</a></h3>'
       end
     end
 
-    context 'invalid entry' do
-      it 'renders an empty span' do
-        expect(helper.render_help_text_entry('foo', 'bar')).to eq '<span class="help-text translation-missing"></span>'
+    context "invalid entry" do
+      it "renders an empty span" do
+        expect(helper.render_help_text_entry("foo", "bar")).to eq '<span class="help-text translation-missing"></span>'
       end
     end
   end
 
-  describe '#relations_icon' do
-    context 'when configured to use the geometry type' do
+  describe "#relations_icon" do
+    context "when configured to use the geometry type" do
       before do
         allow(Settings).to receive(:USE_GEOM_FOR_RELATIONS_ICON).and_return(true)
       end
 
-      it 'renders a goemetry type as the icon' do
-        html = Capybara.string(helper.relations_icon({ Settings.FIELDS.GEOM_TYPE => 'polygon' }, 'leaf'))
-        expect(html.title.strip).to eq 'Polygon'
+      it "renders a goemetry type as the icon" do
+        html = Capybara.string(helper.relations_icon({Settings.FIELDS.GEOM_TYPE => "polygon"}, "leaf"))
+        expect(html.title.strip).to eq "Polygon"
       end
 
-      it 'has the svg_tooltip class so that the Bootstrap tooltip is applied' do
-        html = Capybara.string(helper.relations_icon({ Settings.FIELDS.GEOM_TYPE => 'polygon' }, 'leaf'))
-        expect(html).to have_css('.blacklight-icons.svg_tooltip')
+      it "has the svg_tooltip class so that the Bootstrap tooltip is applied" do
+        html = Capybara.string(helper.relations_icon({Settings.FIELDS.GEOM_TYPE => "polygon"}, "leaf"))
+        expect(html).to have_css(".blacklight-icons.svg_tooltip")
       end
     end
 
-    context 'when not confiugred to use the geometry type' do
+    context "when not confiugred to use the geometry type" do
       before do
         allow(Settings).to receive(:USE_GEOM_FOR_RELATIONS_ICON).and_return(false)
       end
 
-      it 'renders the provided icon' do
-        html = Capybara.string(helper.relations_icon({ Settings.FIELDS.GEOM_TYPE => 'polygon' }, 'leaf'))
-        expect(html.title.strip).to eq 'Leaf'
+      it "renders the provided icon" do
+        html = Capybara.string(helper.relations_icon({Settings.FIELDS.GEOM_TYPE => "polygon"}, "leaf"))
+        expect(html.title.strip).to eq "Leaf"
       end
 
-      it 'does not have the svg_tooltip class' do
-        html = Capybara.string(helper.relations_icon({ Settings.FIELDS.GEOM_TYPE => 'polygon' }, 'leaf'))
-        expect(html).not_to have_css('.blacklight-icons.svg_tooltip')
+      it "does not have the svg_tooltip class" do
+        html = Capybara.string(helper.relations_icon({Settings.FIELDS.GEOM_TYPE => "polygon"}, "leaf"))
+        expect(html).not_to have_css(".blacklight-icons.svg_tooltip")
       end
     end
   end
 
-  describe '#results_js_map_selector' do
-    context 'viewing bookmarks' do
-      let(:controller_name) { 'bookmarks' }
+  describe "#results_js_map_selector" do
+    context "viewing bookmarks" do
+      let(:controller_name) { "bookmarks" }
 
-      it 'returns bookmarks data-map selector' do
-        expect(results_js_map_selector(controller_name)).to eq 'bookmarks'
+      it "returns bookmarks data-map selector" do
+        expect(results_js_map_selector(controller_name)).to eq "bookmarks"
       end
     end
 
-    context 'viewing catalog results' do
-      let(:controller_name) { 'catalog' }
+    context "viewing catalog results" do
+      let(:controller_name) { "catalog" }
 
-      it 'returns index data-map selector' do
-        expect(results_js_map_selector(controller_name)).to eq 'index'
+      it "returns index data-map selector" do
+        expect(results_js_map_selector(controller_name)).to eq "index"
       end
     end
 
-    context 'calling outside of intended scope' do
-      let(:controller_name) { 'outside' }
+    context "calling outside of intended scope" do
+      let(:controller_name) { "outside" }
 
-      it 'returns default data-map value' do
-        expect(results_js_map_selector(controller_name)).to eq 'index'
+      it "returns default data-map value" do
+        expect(results_js_map_selector(controller_name)).to eq "index"
       end
     end
   end

data/spec/lib/geoblacklight/bounding_box_spec.rb

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::BoundingBox do
-  describe '#initialize' do
-    it 'handles multiple input types as arguments' do
-      expect(described_class.new('1', '1', '1', '1')).to be_an described_class
+  describe "#initialize" do
+    it "handles multiple input types as arguments" do
+      expect(described_class.new("1", "1", "1", "1")).to be_an described_class
       expect(described_class.new(1, 2, 3, 3)).to be_an described_class
       expect(described_class.new(1.1, 2.1, 3.1, 3.1)).to be_an described_class
     end
   end
-  describe '#to_envelope' do
+  describe "#to_envelope" do
     let(:example_box) { described_class.new(-160, -80, 120, 70) }
-    it 'creates an envelope syntax version of the bounding box' do
-      expect(example_box.to_envelope).to eq 'ENVELOPE(-160, 120, 70, -80)'
+    it "creates an envelope syntax version of the bounding box" do
+      expect(example_box.to_envelope).to eq "ENVELOPE(-160, 120, 70, -80)"
     end
   end
-  describe '#from_rectangle' do
-    let(:example_box) { described_class.from_rectangle('-160 -80 120 70') }
-    it 'parses and creates a Geoblacklight::BoundingBox from a Solr lat-lon' do
+  describe "#from_rectangle" do
+    let(:example_box) { described_class.from_rectangle("-160 -80 120 70") }
+    it "parses and creates a Geoblacklight::BoundingBox from a Solr lat-lon" do
       expect(example_box).to be_an described_class
-      expect(example_box.to_envelope).to eq 'ENVELOPE(-160, 120, 70, -80)'
+      expect(example_box.to_envelope).to eq "ENVELOPE(-160, 120, 70, -80)"
     end
-    it 'checks for valididity' do
-      expect { described_class.from_rectangle('-160 -80 120') }.to raise_error Geoblacklight::Exceptions::WrongBoundingBoxFormat
+    it "checks for valididity" do
+      expect { described_class.from_rectangle("-160 -80 120") }.to raise_error Geoblacklight::Exceptions::WrongBoundingBoxFormat
     end
   end
 end

data/spec/lib/geoblacklight/document_presenter_spec.rb

@@ -1,16 +1,17 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe Geoblacklight::DocumentPresenter do
   # Please see https://github.com/projectblacklight/blacklight/blob/v6.15.0/spec/presenters/index_presenter_spec.rb#L4
   subject { presenter }
-  let(:request_context) { double(document_index_view_type: 'list') }
+  let(:request_context) { double(document_index_view_type: "list") }
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.add_index_field 'gbl_wxsIdentifier_s'
-      config.add_index_field 'index_display'
-      config.add_index_field 'period'
-      config.add_index_field 'multi_display'
+      config.add_index_field "gbl_wxsIdentifier_s"
+      config.add_index_field "index_display"
+      config.add_index_field "period"
+      config.add_index_field "multi_display"
     end
   end
   let(:solr_fields) { Settings.FIELDS }
@@ -21,41 +22,41 @@ describe Geoblacklight::DocumentPresenter do
   let(:document) do
     SolrDocument.new(
       id: 1,
-      gbl_wxsIdentifier_s: 'druid:abc123',
-      non_index_field: 'do not render',
-      period: 'Ends with period.',
+      gbl_wxsIdentifier_s: "druid:abc123",
+      non_index_field: "do not render",
+      period: "Ends with period.",
       multi_display: %w[blue blah]
     )
   end
 
-  describe '#index_fields_display' do
+  describe "#index_fields_display" do
     let(:rendered_index_text) { subject.index_fields_display }
-    let(:multi_valued_text) { document['multi_display'].join(' and ') }
-    let(:combined_fields) { document['gbl_wxsIdentifier_s'] + '. ' + document['period'] }
+    let(:multi_valued_text) { document["multi_display"].join(" and ") }
+    let(:combined_fields) { document["gbl_wxsIdentifier_s"] + ". " + document["period"] }
 
-    context 'with multi-valued field' do
-      it 'each value is separated by comma' do
+    context "with multi-valued field" do
+      it "each value is separated by comma" do
         expect(rendered_index_text).to include(multi_valued_text)
       end
     end
-    context 'with document fields not configured as index field' do
-      it 'does not render' do
-        expect(rendered_index_text).not_to include(document['non_index_field'])
+    context "with document fields not configured as index field" do
+      it "does not render" do
+        expect(rendered_index_text).not_to include(document["non_index_field"])
       end
     end
-    context 'with multiple document index fields present' do
-      it 'separates fields by period followed by a space' do
+    context "with multiple document index fields present" do
+      it "separates fields by period followed by a space" do
         expect(rendered_index_text).to include(combined_fields)
       end
-      context 'with index field ending in period' do
-        it 'renders only 1 period' do
-          expect(rendered_index_text).to include(document['period'] + ' ')
+      context "with index field ending in period" do
+        it "renders only 1 period" do
+          expect(rendered_index_text).to include(document["period"] + " ")
         end
       end
     end
-    context 'with document empty configured index field' do
-      it 'does not render a period followed by a space' do
-        expect(rendered_index_text).not_to include('. .')
+    context "with document empty configured index field" do
+      it "does not render a period followed by a space" do
+        expect(rendered_index_text).not_to include(". .")
       end
     end
   end