geoblacklight 2.3.0

data/spec/javascripts/geoblacklight_spec.js

@@ -0,0 +1,21 @@
+//= require geoblacklight
+
+describe('GeoBlacklight', function() {
+  describe('loads and makes available libraries', function() {
+    it('Leaflet is defined', function() {
+      expect(L).toBeDefined();
+    });
+
+    it('History.js is defined', function() {
+      expect(History).toBeDefined();
+    });
+
+    it('MetadataDownloadButton is defined', function() {
+      expect(GeoBlacklight.MetadataDownloadButton).toBeDefined();
+    });
+
+    it ('Readmore is defined', function() {
+      expect(Readmore).toBeDefined();
+    });
+  });
+});

data/spec/javascripts/metadata_download_button_spec.js

@@ -0,0 +1,14 @@
+//= require geoblacklight
+
+describe('MetadataDownloadButton', function() {
+  describe('initialize', function() {
+    fixture.set('<button id="foo" data-ref-endpoint="http://testdomain" data-ref-download="#bar">test element</button><a href="http://testdomain" id="bar">another test element</a>');
+
+    it('creates a new instance and sets the download button @href value', function() {
+      var button = new GeoBlacklight.MetadataDownloadButton('#foo');
+      expect(button.$el.attr('id')).toBe('foo');
+      expect(button.$download.attr('id')).toBe('bar');
+      expect(button.$download.attr('href')).toBe('http://testdomain');
+    });
+  });
+});

data/spec/javascripts/spec_helper.js

@@ -0,0 +1,32 @@
+// Teaspoon includes some support files, but you can use anything from your own support path too.
+// require support/jasmine-jquery-1.7.0
+// require support/jasmine-jquery-2.0.0
+// require support/jasmine-jquery-2.1.0
+// require support/sinon
+// require support/your-support-file
+//
+// PhantomJS (Teaspoons default driver) doesn't have support for Function.prototype.bind, which has caused confusion.
+// Use this polyfill to avoid the confusion.
+//= require support/bind-poly
+//
+// You can require your own javascript files here. By default this will include everything in application, however you
+// may get better load performance if you require the specific files that are being used in the spec that tests them.
+//= require application
+//
+// Deferring execution
+// If you're using CommonJS, RequireJS or some other asynchronous library you can defer execution. Call
+// Teaspoon.execute() after everything has been loaded. Simple example of a timeout:
+//
+// Teaspoon.defer = true
+// setTimeout(Teaspoon.execute, 1000)
+//
+// Matching files
+// By default Teaspoon will look for files that match _spec.{js,js.coffee,.coffee}. Add a filename_spec.js file in your
+// spec path and it'll be included in the default suite automatically. If you want to customize suites, check out the
+// configuration in teaspoon_env.rb
+//
+// Manifest
+// If you'd rather require your spec files manually (to control order for instance) you can disable the suite matcher in
+// the configuration and use this file as a manifest.
+//
+// For more information: http://github.com/modeset/teaspoon

data/spec/javascripts/util_spec.js

@@ -0,0 +1,12 @@
+//= require geoblacklight
+
+'use strict';
+
+describe('GeoBlacklight.Util', function() {
+  describe('linkify', function() {
+    it('returns a linkified string', function() {
+      expect(GeoBlacklight.Util.linkify('http://www.example.com'))
+        .toEqual("<a href='http://www.example.com'>http://www.example.com</a>");
+    });
+  });
+});

data/spec/lib/geoblacklight/bounding_box_spec.rb

@@ -0,0 +1,27 @@
+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
+      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
+    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)'
+    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
+      expect(example_box).to be_an described_class
+      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
+    end
+  end
+end

data/spec/lib/geoblacklight/controller_override_spec.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/lib/geoblacklight/document_presenter_spec.rb

@@ -0,0 +1,61 @@
+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
+  let(:request_context) { double(document_index_view_type: 'list') }
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.add_index_field 'layer_id_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 }
+  subject { presenter }
+  let(:presenter) do
+    described_class.new(document, request_context, blacklight_config)
+  end
+
+  let(:document) do
+    SolrDocument.new(
+      id: 1,
+      layer_id_s: 'druid:abc123',
+      non_index_field: 'do not render',
+      period: 'Ends with period.',
+      multi_display: %w(blue blah)
+    )
+  end
+
+  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['layer_id_s'] + '. ' + document['period'] }
+
+    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'])
+      end
+    end
+    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'] + ' ')
+        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('. .')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Geoblacklight::GeojsonDownload do
+  let(:document) { SolrDocument.new(layer_slug_s: 'test', solr_wfs_url: 'http://www.example.com/wfs', layer_id_s: 'stanford-test', solr_geom: 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:download) { described_class.new(document) }
+  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'
+    end
+    it 'merges custom options' do
+      download = described_class.new(document, timeout: 33)
+      options = download.instance_variable_get(:@options)
+      expect(options[:timeout]).to eq 33
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Geoblacklight::GeotiffDownload do
+  let(:document) { SolrDocument.new(layer_slug_s: 'test', layer_id_s: 'stanford-test', solr_geom: 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:download) { described_class.new(document) }
+  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[:reflect]).to be_truthy
+    end
+    it 'merges custom options' do
+      download = described_class.new(document, timeout: 33)
+      options = download.instance_variable_get(:@options)
+      expect(options[:timeout]).to eq 33
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Geoblacklight::HglDownload do
+  subject(:download) { described_class.new(document, options) }
+
+  let(:document) { SolrDocument.new(layer_slug_s: 'test', layer_id_s: 'cite:harvard-test') }
+  let(:options) { 'foo@example.com' }
+
+  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'
+    end
+    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
+    let(:references_field) { Settings.FIELDS.REFERENCES }
+    let(:references_values) do
+      {
+        'http://www.opengis.net/def/serviceType/ogc/wms' => 'http://www.example.com/wms'
+      }
+    end
+    let(:options) do
+      {
+        service_type: 'wms',
+        references_field => references_values.to_json
+      }
+    end
+    let(:faraday_connection) { instance_double(Faraday::Connection) }
+    let(:faraday_response) { instance_double(Faraday::Response) }
+    let(:faraday_request) { instance_double(Faraday::Request) }
+    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' }
+
+    before do
+      allow(reference).to receive(:endpoint).and_return(endpoint)
+      allow(references).to receive(:hgl).and_return(reference)
+      allow(document).to receive(:references).and_return(references)
+      allow(faraday_request).to receive(:params=)
+      allow(faraday_request).to receive(:options).and_return(faraday_request_options)
+    end
+
+    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)
+
+      expect(download.get).to eq faraday_response
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Geoblacklight::KmzDownload do
+  let(:document) { SolrDocument.new(layer_slug_s: 'test', solr_wfs_url: 'http://www.example.com/wfs', layer_id_s: 'stanford-test', solr_geom: 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:download) { described_class.new(document) }
+  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, -90, 180, 90'
+    end
+    it 'merges custom options' do
+      download = described_class.new(document, timeout: 33)
+      options = download.instance_variable_get(:@options)
+      expect(options[:timeout]).to eq 33
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Geoblacklight::ShapefileDownload do
+  let(:document) { SolrDocument.new(layer_slug_s: 'test', solr_wfs_url: 'http://www.example.com/wfs', layer_id_s: 'stanford-test', solr_geom: 'ENVELOPE(-180, 180, 90, -90)') }
+  let(:download) { described_class.new(document) }
+  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'
+    end
+    it 'merges custom options' do
+      download = described_class.new(document, timeout: 33)
+      options = download.instance_variable_get(:@options)
+      expect(options[:timeout]).to eq 33
+    end
+  end
+end

data/spec/lib/geoblacklight/download_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe Geoblacklight::Download do
+  subject(:download) { described_class.new(document, options) }
+
+  let(:faraday_connection) { instance_double(Faraday::Connection) }
+  let(:faraday_response) { instance_double(Faraday::Response) }
+  let(:references_field) { Settings.FIELDS.REFERENCES }
+  let(:document) { SolrDocument.new(layer_slug_s: '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
+      expect(download).to be_a described_class
+    end
+  end
+
+  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
+      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'
+    end
+  end
+  describe '#file_path' do
+    it 'returns the path with name and extension' do
+      expect(download.class.file_path).to eq "#{Rails.root}/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'
+    end
+  end
+  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
+      expect(File).to receive(:file?).and_return(true)
+      expect(download.download_exists?).to be_truthy
+    end
+  end
+  describe '#get' do
+    before do
+      allow(File).to receive(:file?).and_return(true)
+    end
+
+    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
+      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(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('')
+        allow(File).to receive(:rename)
+
+        expect(download.get).to eq 'test-shapefile.zip'
+      end
+    end
+  end
+  describe '#create_download_file' do
+    let(:file) { instance_double(File) }
+    let(:shapefile) { OpenStruct.new(headers: { 'content-type' => 'application/zip' }) }
+    let(:connection) { instance_double(Faraday::Connection) }
+    let(:response) { instance_double(Faraday::Response) }
+
+    before do
+      allow(file).to receive(:write)
+      allow(Faraday).to receive(:new).and_return(connection)
+      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('')
+      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' }) }
+
+      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
+        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')
+      end
+    end
+
+    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('')
+        allow(File).to receive(:rename)
+
+        expect(download.create_download_file).to eq download.file_name
+      end
+    end
+  end
+  describe '#initiate_download' do
+    let(:faraday_request) { instance_double(Faraday::Request) }
+    let(:faraday_request_options) { OpenStruct.new(timeout: nil, open_timeout: nil) }
+
+    before do
+      allow(faraday_request).to receive(:params=)
+      allow(faraday_request).to receive(:options).and_return(faraday_request_options)
+    end
+
+    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)
+
+      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)
+      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'
+      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 { download.initiate_download }.to raise_error(Geoblacklight::Exceptions::ExternalDownloadFailed)
+    end
+  end
+  describe '#url_with_params' do
+    let(:options) do
+      {
+        service_type: 'wms',
+        request_params: {
+          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='
+    end
+  end
+end