geoblacklight 2.3.0

data/spec/lib/geoblacklight/wms_layer_spec.rb

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

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Geoblacklight::SolrDocument::Carto do
+  let(:document) { MyDocument.new }
+  let(:geojson_download) { instance_double(Geoblacklight::GeojsonDownload) }
+
+  before do
+    class MyDocument
+      extend Blacklight::Solr::Document
+      include Geoblacklight::SolrDocument::Carto
+    end
+
+    allow(Geoblacklight::GeojsonDownload).to receive(:new).and_return(geojson_download)
+  end
+
+  describe '#carto_reference' do
+    it 'returns nil for restricted documents' do
+      expect(document).to receive(:public?).and_return(false)
+      expect(document.carto_reference).to be_nil
+    end
+    it 'returns nil for no download_types' do
+      expect(document).to receive(:public?).and_return(true)
+      expect(document).to receive(:download_types).and_return(nil)
+      expect(document.carto_reference).to be_nil
+    end
+    it 'returns nil with no :geojson download type' do
+      expect(document).to receive(:public?).and_return(true)
+      expect(document).to receive(:download_types).and_return(geotiff: 'geotiff')
+      expect(document.carto_reference).to be_nil
+    end
+    it 'Creates and returns a GeojsonDownload url' do
+      expect(document).to receive(:public?).and_return(true)
+      expect(document).to receive(:download_types)
+        .and_return(geojson: { 'stuff' => 'stuff' })
+      expect(geojson_download)
+        .to receive(:url_with_params)
+        .and_return('http://www.example.com/geojsonDownload')
+      expect(document.carto_reference).to eq 'http://www.example.com/geojsonDownload'
+    end
+  end
+
+  describe '#cartodb_reference' do
+    before do
+      allow(Deprecation).to receive(:warn).with(
+        described_class,
+        'cartodb_reference is deprecated and will be removed from Geoblacklight 2.0.0 (use Geoblacklight::SolrDocument::Carto#carto_reference instead)',
+        kind_of(Array)
+      )
+      allow(document).to receive(:public?).and_return(true)
+      allow(document).to receive(:download_types).and_return(geojson: { 'stuff' => 'stuff' })
+      allow(geojson_download)
+        .to receive(:url_with_params)
+        .and_return('http://www.example.com/geojsonDownload')
+    end
+
+    it 'aliases to #carto_reference' do
+      expect(Deprecation).to receive(:warn)
+      expect(document.cartodb_reference).to eq(document.carto_reference)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Geoblacklight::SolrDocument::Inspection do
+  let(:subject) { SolrDocument.new }
+  describe '#inspectable?' do
+    it 'returns true for wms viewer protocol' do
+      expect(subject).to receive(:viewer_protocol).and_return('wms')
+      expect(subject.inspectable?).to be_truthy
+    end
+
+    it 'returns false for iiif viewer protocol' do
+      expect(subject).to receive(:viewer_protocol).and_return('iiif')
+      expect(subject.inspectable?).to be_falsy
+    end
+  end
+end

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

@@ -0,0 +1,251 @@
+require 'spec_helper'
+
+describe Geoblacklight::SolrDocument do
+  let(:document) { SolrDocument.new(document_attributes) }
+  let(:rights_field) { Settings.FIELDS.RIGHTS }
+  let(:provenance_field) { Settings.FIELDS.PROVENANCE }
+  let(:references_field) { Settings.FIELDS.REFERENCES }
+  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)
+        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)
+        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
+        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
+        expect(document.public?).to be_falsey
+      end
+    end
+  end
+  describe '#downloadable?' do
+    describe 'available direct download' do
+      let(:document_attributes) do
+        {
+          rights_field => 'Public',
+          references_field => {
+            'http://schema.org/downloadUrl' => 'http://example.com/direct/data.zip'
+          }.to_json
+        }
+      end
+      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) { { provenance_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')
+        expect(document.same_institution?).to be_truthy
+      end
+    end
+    describe 'within a different institution' do
+      let(:document_attributes) { { provenance_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
+    let(:document_attributes) { {} }
+    it 'generates a new references object' do
+      expect(document.references).to be_an Geoblacklight::References
+    end
+  end
+  describe 'download_types' do
+    let(:document_attributes) { {} }
+    it 'calls download_types' do
+      expect_any_instance_of(Geoblacklight::References).to receive(:download_types)
+      document.download_types
+    end
+  end
+  describe 'direct_download' do
+    let(:document_attributes) { {} }
+    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'
+          }.to_json
+        }
+      end
+      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
+      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
+      let(:document_attributes) do
+        {
+          references_field => {
+            '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')
+      end
+    end
+    describe 'without an hgl download' do
+      let(:document_attributes) { {} }
+      it 'returns nil' do
+        expect(document.direct_download).to be_nil
+      end
+    end
+  end
+  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'
+          }.to_json
+        }
+      end
+      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
+      let(:document_attributes) { {} }
+      it 'returns nil' do
+        expect(document.oembed).to be_nil
+      end
+    end
+  end
+  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'
+          }.to_json
+        }
+      end
+      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
+      let(:document_attributes) { {} }
+      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
+      let(:document_attributes) do
+        {
+          references_field => {
+            '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')
+      end
+    end
+    describe 'without a data dictionary download' do
+      let(:document_attributes) { {} }
+      it 'returns nil' do
+        expect(document.data_dictionary_download).to be_nil
+      end
+    end
+  end
+  describe 'item_viewer' do
+    let(:document_attributes) { {} }
+    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
+      let(:document_attributes) do
+        {
+          references_field => {
+            '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'
+      end
+    end
+    let(:document_attributes) { {} }
+    it 'returns leaflet protocol' do
+      expect(document.viewer_protocol).to eq 'map'
+    end
+  end
+  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'
+          }.to_json
+        }
+      end
+      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 ''
+    end
+  end
+  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
+      expect_any_instance_of(Geoblacklight::References).to receive(:wms).and_return(reference)
+      expect(document.checked_endpoint('wms')).to eq 'http://www.example.com/wms'
+    end
+    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
+    end
+  end
+  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)
+      expect(document.wms_url).to be_nil
+    end
+    it 'raises no method error' do
+      expect { document.wms_urlz }.to raise_error NoMethodError
+    end
+  end
+end