geoblacklight 4.0.0 → 4.1.1

data/lib/tasks/geoblacklight.rake

@@ -1,39 +1,40 @@
 # frozen_string_literal: true
-require 'rails/generators'
-require 'generators/geoblacklight/install_generator'
+
+require "rails/generators"
+require "generators/geoblacklight/install_generator"
 
 namespace :geoblacklight do
-  desc 'Run Solr and GeoBlacklight for interactive development'
+  desc "Run Solr and GeoBlacklight for interactive development"
   task :server, [:rails_server_args] do |_t, args|
-    require 'solr_wrapper'
-    SolrWrapper.wrap(port: '8983') do |solr|
-      solr.with_collection(name: 'blacklight-core', dir: File.join(File.expand_path('../../', File.dirname(__FILE__)), 'solr', 'conf')) do
+    require "solr_wrapper"
+    SolrWrapper.wrap(port: "8983") do |solr|
+      solr.with_collection(name: "blacklight-core", dir: File.join(File.expand_path("../../", File.dirname(__FILE__)), "solr", "conf")) do
         puts "\nSolr server running: http://localhost:#{solr.port}/solr/#/blacklight-core"
         puts "\n^C to stop"
-        puts ' '
+        puts " "
         begin
-          Rake::Task['geoblacklight:solr:seed'].invoke
+          Rake::Task["geoblacklight:solr:seed"].invoke
           system "bundle exec rails s #{args[:rails_server_args]}"
         rescue Interrupt
-          puts 'Shutting down...'
+          puts "Shutting down..."
         end
       end
     end
   end
 
-  desc 'Run Solr and GeoBlacklight for interactive development with Webpack enabled'
+  desc "Run Solr and GeoBlacklight for interactive development with Webpack enabled"
   task :webpack do |_t|
-    require 'solr_wrapper'
-    SolrWrapper.wrap(port: '8983') do |solr|
-      solr.with_collection(name: 'blacklight-core', dir: File.join(File.expand_path('../../', File.dirname(__FILE__)), 'solr', 'conf')) do
+    require "solr_wrapper"
+    SolrWrapper.wrap(port: "8983") do |solr|
+      solr.with_collection(name: "blacklight-core", dir: File.join(File.expand_path("../../", File.dirname(__FILE__)), "solr", "conf")) do
         puts "\nSolr server running: http://localhost:#{solr.port}/solr/#/blacklight-core"
         puts "\n^C to stop"
-        puts ' '
+        puts " "
         begin
-          Rake::Task['geoblacklight:solr:seed'].invoke
-          system 'foreman start'
+          Rake::Task["geoblacklight:solr:seed"].invoke
+          system "foreman start"
         rescue Interrupt
-          puts 'Shutting down...'
+          puts "Shutting down..."
         end
       end
     end
@@ -42,41 +43,41 @@ namespace :geoblacklight do
   # Local fixtures: bundle exec rake "geoblacklight:index:seed"
   # Remote fixtures: bundle exec rake "geoblacklight:index:seed[:remote]"
   namespace :index do
-    desc 'Index GBL test fixture metadata into Solr'
+    desc "Index GBL test fixture metadata into Solr"
     task :seed, [:remote] => :environment do |t, args|
       docs = []
 
       if args.remote
-        puts 'Indexing - Remote test fixtures'
-        JSON.load(
-          URI.open("https://api.github.com/repos/geoblacklight/geoblacklight/contents/spec/fixtures/solr_documents")
+        puts "Indexing - Remote test fixtures"
+        JSON.parse(
+          URI.parse("https://api.github.com/repos/geoblacklight/geoblacklight/contents/spec/fixtures/solr_documents").open.read
         ).each do |fixture|
-          if fixture['name'].include?('.json')
-            docs << JSON.load(URI.open(fixture['download_url']))
+          if fixture["name"].include?(".json")
+            docs << JSON.parse(URI.parse(fixture["download_url"]).open.read)
           end
         end
       else
-        puts 'Indexing - Local test fixtures'
-        docs = Dir['spec/fixtures/solr_documents/*.json'].map { |f| JSON.parse File.read(f) }.flatten
+        puts "Indexing - Local test fixtures"
+        docs = Dir["spec/fixtures/solr_documents/*.json"].map { |f| JSON.parse File.read(f) }.flatten
       end
 
       Blacklight.default_index.connection.add docs
       Blacklight.default_index.connection.commit
     end
 
-    desc 'Ingests a GeoHydra transformed.json'
-    task :ingest_all => :environment do
-      docs = JSON.parse(File.read(Rails.root.join('tmp', 'transformed.json')))
+    desc "Ingests a GeoHydra transformed.json"
+    task ingest_all: :environment do
+      docs = JSON.parse(File.read(Rails.root.join("tmp", "transformed.json")))
       docs.each do |doc|
         Blacklight.default_index.connection.add doc
         Blacklight.default_index.connection.commit
       end
     end
 
-    desc 'Ingests a directory of geoblacklight.json files'
+    desc "Ingests a directory of geoblacklight.json files"
     task :ingest, [:directory] => :environment do |_t, args|
-      args.with_defaults(directory: 'data')
-      Dir.glob(File.join(args[:directory], '**', 'geoblacklight.json')).each do |fn|
+      args.with_defaults(directory: "data")
+      Dir.glob(File.join(args[:directory], "**", "geoblacklight.json")).each do |fn|
         puts "Ingesting #{fn}"
         begin
           Blacklight.default_index.connection.add(JSON.parse(File.read(fn)))
@@ -84,47 +85,47 @@ namespace :geoblacklight do
           puts "Failed to ingest #{fn}: #{e.inspect}"
         end
       end
-      puts 'Committing changes to Solr'
+      puts "Committing changes to Solr"
       Blacklight.default_index.connection.commit
     end
   end
 
   namespace :downloads do
-    desc 'Delete all cached downloads'
+    desc "Delete all cached downloads"
     task delete: :environment do
-      FileUtils.rm_rf Dir.glob(Rails.root.join('tmp', 'cache', 'downloads', '*'))
+      FileUtils.rm_rf Dir.glob(Rails.root.join("tmp", "cache", "downloads", "*"))
     end
-    desc 'Create download directory'
+    desc "Create download directory"
     task mkdir: :environment do
-      FileUtils.mkdir_p(Rails.root.join('tmp', 'cache', 'downloads'), verbose: true)
+      FileUtils.mkdir_p(Rails.root.join("tmp", "cache", "downloads"), verbose: true)
     end
-    desc 'Precaches a download'
+    desc "Precaches a download"
     task :precache, [:doc_id, :download_type, :timeout] => [:environment] do |_t, args|
       unless args[:doc_id] && args[:download_type] && args[:timeout]
-        fail 'Please supply required arguments [document_id, download_type and timeout]'
+        fail "Please supply required arguments [document_id, download_type and timeout]"
       end
       document = Geoblacklight::SolrDocument.find(args[:doc_id])
       fail Blacklight::Exceptions::RecordNotFound if document[:id] != args[:doc_id]
       download = "Geoblacklight::#{args[:download_type].capitalize}Download"
-                 .constantize.new(document, timeout: args[:timeout].to_i)
+        .constantize.new(document, timeout: args[:timeout].to_i)
       download.get
       Rails.logger.info "Successfully downloaded #{download.file_name}"
       Rails.logger.info Geoblacklight::ShapefileDownload.file_path.to_s
     rescue Geoblacklight::Exceptions::ExternalDownloadFailed => error
-      Rails.logger.error error.message + ' ' + error.url
+      Rails.logger.error error.message + " " + error.url
     rescue NameError
       Rails.logger.error "Could not find that download type \"#{args[:download_type]}\""
     end
   end
 
   namespace :solr do
-    desc 'Put sample data into solr'
-    task :seed => :environment do
-      Rake::Task['geoblacklight:index:seed'].invoke
+    desc "Put sample data into solr"
+    task seed: :environment do
+      Rake::Task["geoblacklight:index:seed"].invoke
     end
   end
 
-  desc 'Stdout output asset paths'
+  desc "Stdout output asset paths"
   task application_asset_paths: [:environment] do
     puts Rails.application.config.assets.paths
   end

data/schema/geoblacklight-schema-aardvark.json

@@ -24,6 +24,12 @@
         "type": "string"
       }
     },
+    "gbl_displayNote_sm": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
     "dct_creator_sm": {
       "type": "array",
       "items": {

data/spec/components/geoblacklight/display_note_component_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Geoblacklight::DisplayNoteComponent, type: :component do
+  subject(:rendered) do
+    render_inline_to_capybara_node(described_class.new(**kwargs))
+  end
+
+  describe "prefixed" do
+    let(:kwargs) { {display_note: "Warning: Full force applied."} }
+    it "prefixed, includes display note and icon" do
+      expect(rendered).to have_selector("div.gbl-display-note.alert.alert-warning")
+      expect(rendered).to have_selector("span.blacklight-icons > svg")
+      expect(rendered).to have_text("Warning: Full force applied.")
+    end
+  end
+
+  describe "non-prefixed" do
+    let(:kwargs) { {display_note: "Simple note."} }
+    it "non-prefixed, includes only default display note" do
+      expect(rendered).to have_selector("div.gbl-display-note.alert.alert-secondary")
+      expect(rendered).to_not have_selector("span.blacklight-icons > svg")
+      expect(rendered).to have_text("Simple note.")
+    end
+  end
+end

data/spec/components/geoblacklight/homepage_feature_facet_component_spec.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 RSpec.describe Geoblacklight::HomepageFeatureFacetComponent, type: :component do
   subject(:rendered) do
@@ -7,7 +8,7 @@ RSpec.describe Geoblacklight::HomepageFeatureFacetComponent, type: :component do
   end
 
   # Build a search
-  let(:context) { { whatever: :value } }
+  let(:context) { {whatever: :value} }
   let(:service) { Blacklight::SearchService.new(config: blacklight_config, user_params: user_params, **context) }
   let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
   let(:user_params) { {} }
@@ -15,25 +16,25 @@ RSpec.describe Geoblacklight::HomepageFeatureFacetComponent, type: :component do
   let(:copy_of_catalog_config) { ::CatalogController.blacklight_config.deep_copy }
   let(:blacklight_solr) { RSolr.connect(Blacklight.connection_config.except(:adapter)) }
 
-  describe 'homepage' do
+  describe "homepage" do
     before do
       (@response, @document_list) = service.search_results
     end
 
     let(:kargs) do
       {
-        icon: 'home',
-        label: 'geoblacklight.home.institution',
+        icon: "home",
+        label: "geoblacklight.home.institution",
         facet_field: Settings.FIELDS.PROVIDER,
         response: @response
       }
     end
 
-    it 'includes facet links' do
-      expect(rendered).to have_selector('div.category-block')
-      expect(rendered).to have_selector('div.category-icon')
-      expect(rendered).to have_selector('a.home-facet-link')
-      expect(rendered).to have_selector('a.more_facets_link')
+    it "includes facet links" do
+      expect(rendered).to have_selector("div.category-block")
+      expect(rendered).to have_selector("div.category-icon")
+      expect(rendered).to have_selector("a.home-facet-link")
+      expect(rendered).to have_selector("a.more_facets_link")
     end
   end
 end

data/spec/components/geoblacklight/icon_facet_item_component_spec.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 RSpec.describe Geoblacklight::IconFacetItemComponent, type: :component do
   subject(:rendered) do
     render_inline_to_capybara_node(described_class.new(suppress_link: true, **kwargs))
   end
 
-  let(:kwargs) { { facet_item: facet_item } }
-  let(:facet_item) { instance_double(Blacklight::FacetItemPresenter, label: 'Stanford', value: 'stanford', hits: 5, href: nil, selected?: false, facet_config: facet_config) }
-  let(:facet_config) { Blacklight::Configuration::FacetField.new(field: 'provider_facet', label: 'Provider') }
+  let(:kwargs) { {facet_item: facet_item} }
+  let(:facet_item) { instance_double(Blacklight::FacetItemPresenter, label: "Stanford", value: "stanford", hits: 5, href: nil, selected?: false, facet_config: facet_config) }
+  let(:facet_config) { Blacklight::Configuration::FacetField.new(field: "provider_facet", label: "Provider") }
 
-  it 'prepends the icon to the facet item label' do
-    expect(rendered).to have_selector('span.facet-label', text: 'Stanford')
-    expect(rendered).to have_selector('span.facet-label svg title', text: 'Stanford University')
+  it "prepends the icon to the facet item label" do
+    expect(rendered).to have_selector("span.facet-label", text: "Stanford")
+    expect(rendered).to have_selector("span.facet-label svg title", text: "Stanford University")
   end
 end

data/spec/config/initializers/rails_config_spec.rb

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-describe 'Config' do
-  it 'Loads new Aardvark relationships' do
-    expect(Settings).to respond_to('RELATIONSHIPS_SHOWN')
+require "spec_helper"
+
+describe "Config" do
+  it "Loads new v4.1 Settings defaults" do
+    expect(Settings).to respond_to("RELATIONSHIPS_SHOWN")
+    expect(Settings.FIELDS.DISPLAY_NOTE).to be_present
+    expect(Settings.DISPLAY_NOTES_SHOWN).to respond_to(:danger)
+    expect(Settings.SIDEBAR_STATIC_MAP).to include("iiif")
+
     [:field, :query_type, :icon, :label].each do |method|
-      expect(Settings.RELATIONSHIPS_SHOWN.MEMBER_OF).to respond_to(method)
+      expect(Settings.RELATIONSHIPS_SHOWN.MEMBER_OF_ANCESTORS).to respond_to(method)
     end
   end
-
-  it 'Loads new v3.4 Settings.FIELDS defaults' do
-    expect(Settings.HOMEPAGE_MAP_GEOM).to be_nil
-  end
 end

data/spec/controllers/catalog_controller_spec.rb

@@ -1,61 +1,62 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe CatalogController, type: :controller do
-  describe '#web_services' do
-    it 'returns a document based off an id' do
-      get :web_services, params: { id: 'mit-f6rqs4ucovjk2' }
+  describe "#web_services" do
+    it "returns a document based off an id" do
+      get :web_services, params: {id: "mit-f6rqs4ucovjk2"}
       expect(response).to have_http_status :ok
       expect(assigns(:documents)).not_to be_nil
     end
   end
 
-  describe '.default_solr_params' do
-    it 'sets the number of rows returned by Solr to 10 and does not filter the results' do
+  describe ".default_solr_params" do
+    it "sets the number of rows returned by Solr to 10 and does not filter the results" do
       get :index
       expect(response).to have_http_status :ok
       expect(assigns(:response).docs).not_to be_empty
       expect(assigns(:response).docs.length).to eq 10
     end
 
-    it 'sets the starting document index to 0' do
+    it "sets the starting document index to 0" do
       get :index
       expect(response).to have_http_status :ok
       expect(assigns(:response).docs).not_to be_empty
-      expect(assigns(:response).docs.first.id).to eq 'stanford-cg357zz0321'
+      expect(assigns(:response).docs.first.id).to eq "stanford-cg357zz0321"
     end
 
-    context 'with altered default parameters' do
+    context "with altered default parameters" do
       let(:blacklight_config) { Blacklight::Configuration.new }
 
       before do
         allow(controller).to receive_messages blacklight_config: blacklight_config
       end
 
-      it 'sets the starting document index' do
-        blacklight_config.default_solr_params = { start: 2, 'q.alt' => '*:*' }
+      it "sets the starting document index" do
+        blacklight_config.default_solr_params = {:start => 2, "q.alt" => "*:*"}
         get :index
         expect(response).to have_http_status :ok
         expect(assigns(:response).docs).not_to be_empty
-        expect(assigns(:response).docs.first.id).to eq 'mit-001145244'
+        expect(assigns(:response).docs.first.id).to eq "mit-001145244"
       end
 
-      it 'filters using a default DisMax query when no query is provided by the client' do
-        blacklight_config.default_solr_params = { start: 10, 'q.alt' => '{!dismax}id:nyu' }
+      it "filters using a default DisMax query when no query is provided by the client" do
+        blacklight_config.default_solr_params = {:start => 10, "q.alt" => "{!dismax}id:nyu"}
         get :index
         expect(response).to have_http_status :ok
         expect(assigns(:response).docs).to be_empty
       end
     end
 
-    context 'with altered per page parameters' do
+    context "with altered per page parameters" do
       let(:blacklight_config) { Blacklight::Configuration.new }
 
       before do
         allow(controller).to receive_messages blacklight_config: blacklight_config
       end
 
-      it 'alters the number of documents returned from Solr' do
+      it "alters the number of documents returned from Solr" do
         blacklight_config.default_per_page = 20
         get :index
         expect(response).to have_http_status :ok
@@ -65,19 +66,19 @@ describe CatalogController, type: :controller do
     end
   end
 
-  describe '#raw' do
-    it 'returns a JSON representation of a Solr Document' do
-      get :raw, params: { id: 'tufts-cambridgegrid100-04' }
+  describe "#raw" do
+    it "returns a JSON representation of a Solr Document" do
+      get :raw, params: {id: "tufts-cambridgegrid100-04"}
       expect(response).to have_http_status :ok
       expect(response.body).not_to be_empty
       response_values = JSON.parse(response.body)
-      expect(response_values).to include 'gbl_mdVersion_s' => 'Aardvark'
-      expect(response_values).to include Settings.FIELDS.TITLE => '100 Foot Grid Cambridge MA 2004'
-      expect(response_values).to include Settings.FIELDS.IDENTIFIER => ['urn:geodata.tufts.edu:Tufts.CambridgeGrid100_04']
-      expect(response_values).to include Settings.FIELDS.ACCESS_RIGHTS => 'Public'
-      expect(response_values).to include Settings.FIELDS.PROVIDER => 'Tufts'
-      expect(response_values).to include Settings.FIELDS.ID => 'tufts-cambridgegrid100-04'
-      expect(response_values).to include Settings.FIELDS.GEOMETRY => 'ENVELOPE(-71.163984,-71.052581,42.408316,42.34757)'
+      expect(response_values).to include "gbl_mdVersion_s" => "Aardvark"
+      expect(response_values).to include Settings.FIELDS.TITLE => "100 Foot Grid Cambridge MA 2004"
+      expect(response_values).to include Settings.FIELDS.IDENTIFIER => ["urn:geodata.tufts.edu:Tufts.CambridgeGrid100_04"]
+      expect(response_values).to include Settings.FIELDS.ACCESS_RIGHTS => "Public"
+      expect(response_values).to include Settings.FIELDS.PROVIDER => "Tufts"
+      expect(response_values).to include Settings.FIELDS.ID => "tufts-cambridgegrid100-04"
+      expect(response_values).to include Settings.FIELDS.GEOMETRY => "ENVELOPE(-71.163984,-71.052581,42.408316,42.34757)"
     end
   end
 end

data/spec/controllers/download_controller_spec.rb

@@ -1,120 +1,121 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe DownloadController, type: :controller do
-  describe '#file' do
-    describe 'restricted file' do
-      it 'redirects to login for authentication' do
-        get :file, params: { id: 'stanford-cg357zz0321-shapefile', format: 'zip' }
+  describe "#file" do
+    describe "restricted file" do
+      it "redirects to login for authentication" do
+        get :file, params: {id: "stanford-cg357zz0321-shapefile", format: "zip"}
         expect(response).to have_http_status :unauthorized
       end
     end
-    describe 'public file' do
-      it 'initiates download' do
+    describe "public file" do
+      it "initiates download" do
         allow(controller).to receive(:render) # Needed for testing with Rails 4
         expect(controller).to receive(:send_file)
-        get :file, params: { id: 'mit-f6rqs4ucovjk2-shapefile', format: 'zip' }
+        get :file, params: {id: "mit-f6rqs4ucovjk2-shapefile", format: "zip"}
       end
     end
   end
-  describe '#show' do
-    describe 'restricted file' do
-      it 'redirects to login for authentication' do
-        get :show, params: { id: 'stanford-cg357zz0321', format: 'json' }
+  describe "#show" do
+    describe "restricted file" do
+      it "redirects to login for authentication" do
+        get :show, params: {id: "stanford-cg357zz0321", format: "json"}
         expect(response).to have_http_status :unauthorized
       end
     end
-    describe 'public file' do
+    describe "public file" do
       let(:shapefile_download) { instance_double(Geoblacklight::ShapefileDownload) }
 
       before do
         allow(Geoblacklight::ShapefileDownload).to receive(:new).and_return(shapefile_download)
       end
 
-      it 'initiates download creation' do
-        allow(shapefile_download).to receive(:get).and_return('success')
-        get :show, params: { id: 'mit-f6rqs4ucovjk2', type: 'shapefile' }
+      it "initiates download creation" do
+        allow(shapefile_download).to receive(:get).and_return("success")
+        get :show, params: {id: "mit-f6rqs4ucovjk2", type: "shapefile"}
         expect(response).to have_http_status :ok
       end
     end
 
-    context 'when requesting GeoJSON files' do
-      let(:id) { 'tufts-cambridgegrid100-04' }
-      let(:type) { 'geojson' }
+    context "when requesting GeoJSON files" do
+      let(:id) { "tufts-cambridgegrid100-04" }
+      let(:type) { "geojson" }
       let(:geojson_download) { instance_double(Geoblacklight::GeojsonDownload) }
 
       before do
-        allow(geojson_download).to receive(:get).and_return('file.json')
+        allow(geojson_download).to receive(:get).and_return("file.json")
         allow(Geoblacklight::GeojsonDownload).to receive(:new).and_return(geojson_download)
       end
 
-      it 'downloads the files and notifies the user' do
+      it "downloads the files and notifies the user" do
         expect(Geoblacklight::GeojsonDownload).to receive(:new)
-        get :show, params: { id: id, type: type }
+        get :show, params: {id: id, type: type}
 
-        expect(response.body).to include 'success'
-        expect(response.body).to include 'Your file file.json is ready for download'
+        expect(response.body).to include "success"
+        expect(response.body).to include "Your file file.json is ready for download"
       end
     end
 
-    context 'when requesting GeoTIFF files' do
-      let(:id) { 'tufts-cambridgegrid100-04' }
-      let(:type) { 'geotiff' }
+    context "when requesting GeoTIFF files" do
+      let(:id) { "tufts-cambridgegrid100-04" }
+      let(:type) { "geotiff" }
       let(:geotiff_download) { instance_double(Geoblacklight::GeotiffDownload) }
 
       before do
-        allow(geotiff_download).to receive(:get).and_return('file.tiff')
+        allow(geotiff_download).to receive(:get).and_return("file.tiff")
         allow(Geoblacklight::GeotiffDownload).to receive(:new).and_return(geotiff_download)
       end
 
-      it 'downloads the files and notifies the user' do
+      it "downloads the files and notifies the user" do
         expect(Geoblacklight::GeotiffDownload).to receive(:new)
-        get :show, params: { id: id, type: type }
+        get :show, params: {id: id, type: type}
 
-        expect(response.body).to include 'success'
-        expect(response.body).to include 'Your file file.tiff is ready for download'
+        expect(response.body).to include "success"
+        expect(response.body).to include "Your file file.tiff is ready for download"
       end
     end
   end
 
-  describe '#hgl' do
+  describe "#hgl" do
     let(:hgl_download) { instance_double(Geoblacklight::HglDownload) }
 
-    it 'requests file' do
-      allow(hgl_download).to receive(:get).and_return('success')
+    it "requests file" do
+      allow(hgl_download).to receive(:get).and_return("success")
       allow(Geoblacklight::HglDownload).to receive(:new).and_return(hgl_download)
 
-      get :hgl, params: { id: 'harvard-g7064-s2-1834-k3', email: 'foo@example.com' }
+      get :hgl, params: {id: "harvard-g7064-s2-1834-k3", email: "foo@example.com"}
       expect(response).to have_http_status :ok
     end
 
-    it 'renders form' do
+    it "renders form" do
       allow(Geoblacklight::HglDownload).to receive(:new).and_return(hgl_download)
 
-      get :hgl, params: { id: 'harvard-g7064-s2-1834-k3' }
-      expect(response).to render_template('hgl')
+      get :hgl, params: {id: "harvard-g7064-s2-1834-k3"}
+      expect(response).to render_template("hgl")
     end
 
-    context 'when an error occurs while downloading a file' do
+    context "when an error occurs while downloading a file" do
       let(:exception) { Geoblacklight::Exceptions::ExternalDownloadFailed.new(url: nil) }
 
-      it 'uses the default error message when the exception does not have a URL' do
+      it "uses the default error message when the exception does not have a URL" do
         allow(Geoblacklight::HglDownload).to receive(:new).and_raise(exception)
 
-        get :hgl, params: { id: 'harvard-g7064-s2-1834-k3', email: 'foo@example.com' }
-        expect(response.body).to include('danger')
-        expect(response.body).to include('Sorry, the requested file could not be downloaded')
+        get :hgl, params: {id: "harvard-g7064-s2-1834-k3", email: "foo@example.com"}
+        expect(response.body).to include("danger")
+        expect(response.body).to include("Sorry, the requested file could not be downloaded")
       end
     end
 
-    context 'when downloading the requested file fails' do
-      it 'flashes the error message' do
+    context "when downloading the requested file fails" do
+      it "flashes the error message" do
         allow(hgl_download).to receive(:get).and_return(nil)
         allow(Geoblacklight::HglDownload).to receive(:new).and_return(hgl_download)
 
-        get :hgl, params: { id: 'harvard-g7064-s2-1834-k3', email: 'foo@example.com' }
-        expect(response.body).to include('danger')
-        expect(response.body).to include('Sorry, the requested file could not be downloaded')
+        get :hgl, params: {id: "harvard-g7064-s2-1834-k3", email: "foo@example.com"}
+        expect(response.body).to include("danger")
+        expect(response.body).to include("Sorry, the requested file could not be downloaded")
       end
     end
   end

data/spec/controllers/relation_controller_spec.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
-require 'spec_helper'
+
+require "spec_helper"
 
 describe RelationController, type: :controller do
-  describe '#index' do
-    it 'returns a listing of related documents for a record' do
-      get :index, params: { id: 'nyu_2451_34502' }
+  describe "#index" do
+    it "returns a listing of related documents for a record" do
+      get :index, params: {id: "nyu_2451_34502"}
       expect(response).to have_http_status :ok
       expect(assigns(:relations)).not_to be_nil
     end