geoblacklight 2.3.0

data/spec/lib/geoblacklight/reference_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Geoblacklight::Reference do
+  let(:typical_reference) do
+    described_class.new(['http://www.opengis.net/def/serviceType/ogc/wms', 'http://hgl.harvard.edu:8080/geoserver/wms'])
+  end
+  let(:blank_reference) do
+    described_class.new([])
+  end
+  describe '#initialize' do
+    it 'instance variable reference is set' do
+      expect(typical_reference.instance_variable_get(:@reference)).to eq ['http://www.opengis.net/def/serviceType/ogc/wms', 'http://hgl.harvard.edu:8080/geoserver/wms']
+    end
+  end
+  describe '#endpoint' do
+    it 'returns the endpoint url for a reference' do
+      expect(typical_reference.endpoint).to eq 'http://hgl.harvard.edu:8080/geoserver/wms'
+    end
+    it 'returns nil for a blank reference' do
+      expect(blank_reference.endpoint).to be_nil
+    end
+  end
+  describe '#type' do
+    it 'looks up a constant using the uri' do
+      expect(typical_reference.type).to eq :wms
+      expect(blank_reference.type).to be_nil
+    end
+  end
+  describe '#to_hash' do
+    it 'creates a hash using type and endpoint' do
+      expect(typical_reference.to_hash).to eq wms: 'http://hgl.harvard.edu:8080/geoserver/wms'
+    end
+  end
+
+  describe 'reference' do
+    context 'key has one trailing slash' do
+      let(:iso19139_reference) do
+        described_class.new(['http://www.isotc211.org/schemas/2005/gmd/', 'https://raw.githubusercontent.com/OpenGeoMetadata/edu.stanford.purl/master/cg/357/zz/0321/iso19139.xml'])
+      end
+
+      it 'removes the trailing slash' do
+        expect(iso19139_reference.send(:uri)).to eq 'http://www.isotc211.org/schemas/2005/gmd'
+      end
+    end
+    context 'key does not have trailing slashes' do
+      let(:iso19139_reference) do
+        described_class.new(['http://www.isotc211.org/schemas/2005/gmd', 'https://raw.githubusercontent.com/OpenGeoMetadata/edu.stanford.purl/master/cg/357/zz/0321/iso19139.xml'])
+      end
+
+      it 'will return the key' do
+        expect(iso19139_reference.send(:uri)).to eq 'http://www.isotc211.org/schemas/2005/gmd'
+      end
+    end
+    context 'key has trailing slashes' do
+      let(:fgdc_reference) do
+        described_class.new(['http://www.opengis.net/cat/csw/csdgm////', 'https://raw.githubusercontent.com/OpenGeoMetadata/edu.harvard/master/217/121/227/77/fgdc.xml'])
+      end
+
+      it 'removes the trailing slashes' do
+        expect(fgdc_reference.send(:uri)).to eq 'http://www.opengis.net/cat/csw/csdgm'
+      end
+    end
+  end
+end

data/spec/lib/geoblacklight/references_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe Geoblacklight::References do
+  let(:references_field) { Settings.FIELDS.REFERENCES }
+  let(:file_format_field) { Settings.FIELDS.FILE_FORMAT }
+  let(:typical_ogp_shapefile) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'Shapefile',
+        references_field => {
+          'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://hgl.harvard.edu:8080/geoserver/wms',
+          'http://www.opengis.net/def/serviceType/ogc/wfs' => 'http://hgl.harvard.edu:8080/geoserver/wfs'
+        }.to_json
+      )
+    )
+  end
+  let(:no_service_shapefile) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'Shapefile',
+        references_field => {}.to_json
+      )
+    )
+  end
+  let(:typical_ogp_geotiff) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'GeoTIFF',
+        references_field => {
+          'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://hgl.harvard.edu:8080/geoserver/wms',
+          'http://www.opengis.net/def/serviceType/ogc/wfs' => 'http://hgl.harvard.edu:8080/geoserver/wfs'
+        }.to_json
+      )
+    )
+  end
+  let(:typical_arcgrid) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'ArcGRID',
+        references_field => {
+          'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://hgl.harvard.edu:8080/geoserver/wms',
+          'http://www.opengis.net/def/serviceType/ogc/wfs' => 'http://hgl.harvard.edu:8080/geoserver/wfs'
+        }.to_json
+      )
+    )
+  end
+  let(:complex_shapefile) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'Shapefile',
+        references_field => {
+          'http://schema.org/downloadUrl' => 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip',
+          'http://www.isotc211.org/schemas/2005/gmd/' => 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/iso19139.xml',
+          'http://www.loc.gov/mods/v3' => 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/mods.xml',
+          'http://schema.org/url' => 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/homepage',
+          'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://hgl.harvard.edu:8080/geoserver/wms',
+          'http://www.opengis.net/def/serviceType/ogc/wfs' => 'http://hgl.harvard.edu:8080/geoserver/wfs'
+        }.to_json
+      )
+    )
+  end
+  let(:direct_download_only) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'GeoTIFF',
+        references_field => {
+          'http://schema.org/downloadUrl' => 'http://example.com/layer-id-geotiff.tiff'
+        }.to_json
+      )
+    )
+  end
+  let(:simple_iiif_image) do
+    described_class.new(
+      SolrDocument.new(
+        file_format_field => 'Raster',
+        references_field => {
+          'http://schema.org/url' => 'http://arks.princeton.edu/ark:/88435/02870w62c',
+          'http://iiif.io/api/image' => 'http://libimages.princeton.edu/loris2/pudl0076%2Fmap_pownall%2F00000001.jp2/info.json'
+        }.to_json
+      )
+    )
+  end
+  let(:some_esri_services) do
+    described_class.new(
+      SolrDocument.new(
+        references_field => {
+          'urn:x-esri:serviceType:ArcGIS#NotValid' => 'foo',
+          'urn:x-esri:serviceType:ArcGIS#TiledMapLayer' => 'foo',
+          'urn:x-esri:serviceType:ArcGIS#DynamicMapLayer' => 'foo',
+          'urn:x-esri:serviceType:ArcGIS#ImageMapLayer' => 'foo'
+        }.to_json
+      )
+    )
+  end
+  let(:custom_fields) do
+    described_class.new(
+      SolrDocument.new, :new_ref_field
+    )
+  end
+  describe '#initialize' do
+    it 'parses configured references field to @refs' do
+      expect(typical_ogp_shapefile.instance_variable_get(:@refs)).to be_an Array
+    end
+    it 'empty references return an empty array' do
+      empty_refs = no_service_shapefile.instance_variable_get(:@refs)
+      expect(empty_refs).to be_an Array
+      expect(empty_refs).to eq []
+    end
+    it 'sets @references_field' do
+      expect(typical_ogp_shapefile.reference_field).to eq references_field
+      expect(custom_fields.reference_field).to eq :new_ref_field
+    end
+  end
+  describe 'format' do
+    it 'returns format' do
+      expect(complex_shapefile.format).to eq 'Shapefile'
+      expect(direct_download_only.format).to eq 'GeoTIFF'
+    end
+  end
+  describe 'refs' do
+    it 'is a set of enumberable references' do
+      complex_shapefile.refs.each do |reference|
+        expect(reference).to be_an Geoblacklight::Reference
+      end
+    end
+  end
+  describe 'shown_metadata_refs' do
+    it 'is a set of metadata references exposed by the configuration' do
+      expect(complex_shapefile.shown_metadata_refs.count).to eq 2
+      expect(complex_shapefile.shown_metadata_refs.first.type.to_s).to eq 'mods'
+      expect(complex_shapefile.shown_metadata_refs.last.type.to_s).to eq 'iso19139'
+    end
+    context 'with an overridden order for the formats' do
+      let(:settings_klass) { class_double('Settings').as_stubbed_const }
+      before do
+        allow(settings_klass).to receive(:METADATA_SHOWN).and_return %w(iso19139 mods)
+        allow(settings_klass).to receive(:FIELDS).and_return OpenStruct.new(FILE_FORMAT: 'dc_format_s')
+      end
+      it 'is ordered by the configuration' do
+        expect(complex_shapefile.shown_metadata_refs.first.type.to_s).to eq 'iso19139'
+        expect(complex_shapefile.shown_metadata_refs.last.type.to_s).to eq 'mods'
+      end
+    end
+  end
+  describe 'shown_metadata' do
+    it 'is a set of metadata resources exposed by the configuration' do
+      expect(complex_shapefile.shown_metadata.count).to eq 2
+      expect(complex_shapefile.shown_metadata.first).to be_a Geoblacklight::Metadata::Base
+    end
+  end
+  describe 'direct_download' do
+    it 'returns the direct download link' do
+      download = complex_shapefile.download
+      expect(download).to be_an Geoblacklight::Reference
+      expect(download.endpoint).to eq('http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip')
+      expect(direct_download_only.download.endpoint).to eq 'http://example.com/layer-id-geotiff.tiff'
+    end
+    it 'does not return if download not available' do
+      expect(typical_ogp_shapefile.download).to be_nil
+    end
+  end
+  describe 'preferred_download' do
+    it 'returns the direct download if available' do
+      expect(complex_shapefile.preferred_download[:file_download][:download]).to eq 'http://example.com/urn:hul.harvard.edu:HARVARD.SDE2.TG10USAIANNH/data.zip'
+      expect(direct_download_only.preferred_download[:file_download][:download]).to eq 'http://example.com/layer-id-geotiff.tiff'
+    end
+    it 'returns nil if there is no direct download' do
+      expect(typical_ogp_shapefile.preferred_download).to be_nil
+    end
+    it 'returns nil if there is no direct download' do
+      expect(typical_ogp_geotiff.preferred_download).to be_nil
+    end
+  end
+  describe 'download_types' do
+    it 'returns available downloads by format' do
+      types = complex_shapefile.download_types
+      expect(types.first[1]).to eq wfs: 'http://hgl.harvard.edu:8080/geoserver/wfs'
+      expect(types.count).to eq 3
+      expect(direct_download_only.download_types).to be_nil
+    end
+    it 'onlies return available downloads if no direct is present' do
+      types = typical_ogp_shapefile.download_types
+      expect(types.first[1]).to eq wfs: 'http://hgl.harvard.edu:8080/geoserver/wfs'
+      expect(types.count).to eq 3
+    end
+  end
+  describe '#esri_webservices' do
+    it 'returns webservices that are esri specific' do
+      expect(some_esri_services.esri_webservices.length).to eq 3
+    end
+  end
+  describe '#method_missing' do
+    it 'defaults to the base behavior if the method signature is not a URI key' do
+      expect { typical_ogp_shapefile.invalid }.to raise_error(NoMethodError)
+    end
+  end
+  describe 'downloads_by_format' do
+    it 'returns shapefile' do
+      expect(typical_ogp_shapefile.downloads_by_format.count).to eq 3
+    end
+    it 'returns geotiff' do
+      expect(typical_ogp_geotiff.downloads_by_format.count).to eq 1
+      expect(typical_ogp_geotiff.downloads_by_format[:geotiff][:wms]).to eq 'http://hgl.harvard.edu:8080/geoserver/wms'
+    end
+    it 'returns arcgrid as geotiff' do
+      expect(typical_arcgrid.downloads_by_format.count).to eq 1
+      expect(typical_arcgrid.downloads_by_format[:geotiff][:wms]).to eq 'http://hgl.harvard.edu:8080/geoserver/wms'
+    end
+    it 'does not return shapefile if wms and wfs are not present' do
+      expect(no_service_shapefile.downloads_by_format).to be_nil
+    end
+    it 'does not return GeoTIFF if wms is not present' do
+      expect(direct_download_only.downloads_by_format).to be_nil
+    end
+  end
+end

data/spec/lib/geoblacklight/relation/ancestors_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Geoblacklight::Relation::Ancestors do
+  let(:repository) { Blacklight::Solr::Repository.new(CatalogController.blacklight_config) }
+  let(:ancestors) { described_class.new('nyu_2451_34502', repository) }
+  let(:empty_ancestors) { described_class.new('harvard-g7064-s2-1834-k3', repository) }
+
+  describe '#create_search_params' do
+    it 'assembles the correct search params for finding ancestor documents' do
+      expect(ancestors.create_search_params).to eq(fq: ["{!join from=#{Settings.FIELDS.SOURCE} to=layer_slug_s}layer_slug_s:nyu_2451_34502"], fl: [Settings.FIELDS.TITLE.to_s, 'layer_slug_s'])
+    end
+  end
+
+  describe '#execute_query' do
+    it 'executes the query for finding ancestors, return response' do
+      expect(ancestors.execute_query).to include('responseHeader')
+    end
+  end
+
+  describe '#results' do
+    it 'produces a hash of results from the query' do
+      expect(ancestors.results).to include('numFound')
+      expect(ancestors.results).to include('docs')
+    end
+    it 'has non-zero numfound for a document with ancestors' do
+      expect(ancestors.results['numFound']).to be > 0
+    end
+    it 'has zero numfound for a document without ancestors' do
+      expect(empty_ancestors.results['numFound']).to eq(0)
+    end
+  end
+end

data/spec/lib/geoblacklight/relation/descendants_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Geoblacklight::Relation::Descendants do
+  let(:repository) { Blacklight::Solr::Repository.new(CatalogController.blacklight_config) }
+  let(:descendants) { described_class.new('nyu_2451_34636', repository) }
+  let(:empty_descendants) { described_class.new('harvard-g7064-s2-1834-k3', repository) }
+
+  describe '#create_search_params' do
+    it 'assembles the correct search params for finding descendant documents' do
+      expect(descendants.create_search_params).to eq(fq: "#{Settings.FIELDS.SOURCE}:nyu_2451_34636", fl: [Settings.FIELDS.TITLE.to_s, 'layer_slug_s'])
+    end
+  end
+
+  describe '#execute_query' do
+    it 'executes the query for finding descendants, return response' do
+      expect(descendants.execute_query).to include('responseHeader')
+    end
+  end
+
+  describe '#results' do
+    it 'produces a hash of results from the query' do
+      expect(descendants.results).to include('numFound')
+      expect(descendants.results).to include('docs')
+    end
+    it 'has non-zero numfound for a document with descendants' do
+      expect(descendants.results['numFound']).to be > 0
+    end
+    it 'has zero numfound for a document without descendants' do
+      expect(empty_descendants.results['numFound']).to eq(0)
+    end
+  end
+end

data/spec/lib/geoblacklight/relation/relation_response_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Geoblacklight::Relation::RelationResponse do
+  let(:repository) { Blacklight::Solr::Repository.new(CatalogController.blacklight_config) }
+  let(:relation_resp) { described_class.new('nyu_2451_34502', repository) }
+  let(:empty_relation_resp) { described_class.new('harvard-g7064-s2-1834-k3', repository) }
+  describe '#initialize' do
+    it 'creates a RelationResponse' do
+      expect(relation_resp).to be_an described_class
+    end
+  end
+
+  describe '#ancestors' do
+    it 'returns a hash of ancestor documents' do
+      expect(relation_resp.ancestors).to include('numFound')
+      expect(relation_resp.ancestors).to include('docs')
+    end
+  end
+
+  describe '#descendants' do
+    it 'returns a hash of descendant documents' do
+      expect(relation_resp.ancestors).to include('numFound')
+      expect(relation_resp.ancestors).to include('docs')
+    end
+  end
+
+  describe '#empty?' do
+    it 'returns false if document has ancestors or descendants' do
+      expect(relation_resp.empty?).to be false
+    end
+    it 'returns true if document has neither ancestors nor descendants' do
+      expect(empty_relation_resp.empty?).to be true
+    end
+
+    context 'with a layer slug containing a colon' do
+      let(:empty_relation_resp) { described_class.new('uva-Norfolk:police_point', repository) }
+
+      it 'returns true if document has neither ancestors nor descendants' do
+        expect(empty_relation_resp.empty?).to be true
+      end
+    end
+  end
+end

data/spec/lib/geoblacklight/view_helper_override_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Geoblacklight::ViewHelperOverride do
+  class GeoblacklightControllerTestClass
+    include AbstractController::Translation
+    attr_accessor :params
+  end
+
+  let(:fake_controller) do
+    GeoblacklightControllerTestClass.new
+                                    .extend(described_class)
+  end
+
+  describe 'spatial_parameters?' do
+    it 'does not have spatial parameters' do
+      fake_controller.params = {}
+      expect(fake_controller.spatial_parameters?).to be_falsey
+    end
+    it 'has spatial parameters' do
+      fake_controller.params = { bbox: '123' }
+      expect(fake_controller.spatial_parameters?).to be_truthy
+    end
+  end
+  describe 'render_search_to_s_bbox' do
+    it 'returns an empty string for no bbox' do
+      fake_controller.params = {}
+      expect(fake_controller.render_search_to_s_bbox(fake_controller.params)).to eq ''
+    end
+    it 'returns render_search_to_s_element when bbox is present' do
+      fake_controller.params = { bbox: '123' }
+      params = { 'bbox' => '123' }
+      expect(fake_controller).to receive(:render_search_to_s_element)
+      expect(fake_controller).to receive(:render_filter_value)
+      fake_controller.render_search_to_s_bbox(params)
+    end
+  end
+end

data/spec/lib/geoblacklight/wms_layer/feature_info_response_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Geoblacklight::FeatureInfoResponse do
+  let(:response) { described_class.new(OpenStruct.new(body: '<html><body><table><th>Header1</th><th>Header2</th><td>value1</td><td>value2</td></body></html>', headers: { 'content-type' => 'all good' })) }
+  let(:response_multiple_features) { described_class.new(OpenStruct.new(body: '<html><body><table><th>Header1</th><th>Header2</th><tr><td>value1</td><td>value2</td></tr><tr><td>value3</td><td>value4</td></tr></body></html>', headers: { 'content-type' => 'all good' })) }
+  let(:error_response) { described_class.new(error: 'bad stuff') }
+  let(:content_response) { described_class.new(OpenStruct.new(headers: { 'content-type' => 'text/xml' })) }
+
+  describe '#initialize' do
+    it 'initializes as a FeatureInfoResponse type' do
+      expect(response).to be_an described_class
+    end
+  end
+
+  describe '#error?' do
+    it 'if no error' do
+      expect(response.error?).to be_falsey
+    end
+    it 'if error key is present' do
+      expect(error_response.error?).to be_truthy
+    end
+    it 'if content-type header is text/xml' do
+      expect(content_response.error?).to be_truthy
+    end
+  end
+
+  describe '#format' do
+    it 'returns a formated response' do
+      expect(response.format).not_to be_nil
+      expect(response.format[:values].length).to eq 2
+      expect(response.format[:values][0]).to eq %w(Header1 value1)
+      expect(response.format[:values][1]).to eq %w(Header2 value2)
+    end
+    it 'returns a formated response when multiple features are retrieved' do
+      expect(response_multiple_features.format).not_to be_nil
+      expect(response_multiple_features.format[:values].length).to eq 2
+      expect(response_multiple_features.format[:values][0]).to eq %w(Header1 value1)
+      expect(response_multiple_features.format[:values][1]).to eq %w(Header2 value2)
+    end
+  end
+
+  describe '#check' do
+    it 'returns a formated response if no errors' do
+      expect(response.check).to eq response.format
+    end
+    it 'returns the unformated response if there are errors' do
+      expect(error_response.check).to eq error_response.instance_variable_get('@response')
+    end
+  end
+end