geoblacklight 6.0.0.pre.alpha.3 → 6.0.0.pre.alpha.5

data/spec/controllers/download_controller_spec.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.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"}
-        expect(response).to have_http_status :unauthorized
-      end
-    end
-    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"}
-      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"}
-        expect(response).to have_http_status :unauthorized
-      end
-    end
-    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"}
-        expect(response).to have_http_status :ok
-      end
-    end
-
-    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(Geoblacklight::GeojsonDownload).to receive(:new).and_return(geojson_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::GeojsonDownload).to receive(:new)
-        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"
-      end
-    end
-
-    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(Geoblacklight::GeotiffDownload).to receive(:new).and_return(geotiff_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::GeotiffDownload).to receive(:new)
-        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"
-      end
-    end
-
-    context "when requesting CSV files" do
-      let(:id) { "tufts-cambridgegrid100-04" }
-      let(:type) { "csv" }
-      let(:csv_download) { instance_double(Geoblacklight::CsvDownload) }
-
-      before do
-        allow(csv_download).to receive(:get).and_return("file.csv")
-        allow(Geoblacklight::CsvDownload).to receive(:new).and_return(csv_download)
-      end
-
-      it "downloads the files and notifies the user" do
-        expect(Geoblacklight::CsvDownload).to receive(:new)
-        get :show, params: {id: id, type: type}
-
-        expect(response.body).to include "success"
-        expect(response.body).to include "Your file file.csv is ready for download"
-      end
-    end
-  end
-end

data/spec/features/download_layer_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Download layer" do
-  let(:shapefile_download) { instance_double(Geoblacklight::ShapefileDownload) }
-  let(:kmz_download) { instance_double(Geoblacklight::KmzDownload) }
-  let(:csv_download) { instance_double(Geoblacklight::CsvDownload) }
-
-  before do
-    allow(Geoblacklight::ShapefileDownload).to receive(:new).and_return(shapefile_download)
-    allow(Geoblacklight::KmzDownload).to receive(:new).and_return(kmz_download)
-    allow(Geoblacklight::CsvDownload).to receive(:new).and_return(csv_download)
-  end
-
-  # cleanup any downloaded files
-  after do
-    FileUtils.rm("tufts-cambridgegrid100-04-shapefile.zip", force: true)
-    FileUtils.rm("tufts-cambridgegrid100-04-kmz.kmz", force: true)
-  end
-
-  scenario "clicking initial shapefile download button should trigger download", js: true do
-    allow(shapefile_download).to receive(:get).and_return("tufts-cambridgegrid100-04-shapefile.zip")
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    find('a[data-download-type="shapefile"]', text: "Export Shapefile").click
-    expect(page).to have_css(
-      'a[href="/download/file/tufts-cambridgegrid100-04-shapefile.zip"]',
-      text: "Your file tufts-cambridgegrid100-04-shapefile.zip is ready for download"
-    )
-  end
-
-  scenario "failed download should return message with link to layer", js: true do
-    allow(shapefile_download).to receive(:get).and_raise(Geoblacklight::Exceptions::ExternalDownloadFailed.new(
-      message: "Failed", url: "http://www.example.com/failed"
-    ))
-    visit solr_document_path("mit-f6rqs4ucovjk2")
-    find("#downloads-button").click
-    find('#downloads-collapse a[data-download-type="shapefile"]', text: "Export Shapefile").click
-    expect(page).to have_text "Download failed (shapefile)"
-    expect(page).to have_css "div.alert.alert-danger", text: "Sorry, the requested file could not be downloaded."
-  end
-
-  scenario "clicking kmz download button should trigger download", js: true do
-    allow(kmz_download).to receive(:get).and_return("tufts-cambridgegrid100-04-kmz.kmz")
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    find('#downloads-collapse a[data-download-type="kmz"]', text: "Export KMZ").click
-    expect(page).to have_css(
-      'a[href="/download/file/tufts-cambridgegrid100-04-kmz.kmz"]',
-      text: "Your file tufts-cambridgegrid100-04-kmz.kmz is ready for download"
-    )
-  end
-
-  scenario "jpg download option should be present under toggle" do
-    visit solr_document_path("princeton-02870w62c")
-    find("#downloads-button").click
-    expect(page).to have_css("#downloads-collapse a", text: "Original JPG")
-  end
-
-  scenario "clicking jpg download button should redirect to external image" do
-    visit solr_document_path("princeton-02870w62c")
-    find("#downloads-button").click
-    expect(page).to have_css(
-      "#downloads-collapse a[href='https://iiif-cloud.princeton.edu/iiif/2/6c%2F52%2F12%2F6c5212e81bc845f59bb1cdc740a88bad%2Fintermediate_file/full/full/0/default.jpg']", text: "Original JPG"
-    )
-  end
-
-  scenario "options should be available under toggle" do
-    visit solr_document_path("tufts-cambridgegrid100-04")
-    find("#downloads-button").click
-    expect(page).to have_css('#downloads-collapse a[data-download-type="shapefile"]', text: "Export Shapefile")
-    expect(page).to have_css('#downloads-collapse a[data-download-type="kmz"]', text: "Export KMZ")
-  end
-
-  scenario "restricted layer should not have download available to non logged in user" do
-    visit solr_document_path("stanford-cg357zz0321")
-    expect(page).to have_css "a", text: "Login to View and Download"
-    expect(page).not_to have_css "button", text: "Download"
-  end
-
-  scenario "restricted layer should have download available to logged in user" do
-    sign_in
-    visit solr_document_path("stanford-cg357zz0321")
-    expect(page).not_to have_css "a", text: "Login to view and download"
-    expect(page).to have_css "button", text: "Download"
-  end
-
-  scenario "layer with direct download and wms/wfs should include all download types" do
-    sign_in
-    visit solr_document_path("stanford-cg357zz0321")
-    find("#downloads-button").click
-    expect(page).to have_css("#downloads-collapse a", text: "Original")
-    expect(page).to have_css("#downloads-collapse a", text: "Export")
-  end
-end

data/spec/features/esri_viewer_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "feature_layer reference", js: true do
-  scenario "displays image map layer" do
-    skip "spec depend on potentially flaky external services"
-    visit solr_document_path "32653ed6-8d83-4692-8a06-bf13ffe2c018"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(page).to have_css "img.leaflet-image-layer", visible: true
-  end
-  scenario "displays dynamic layer (all layers)" do
-    skip "spec depend on potentially flaky external services"
-    visit solr_document_path "90f14ff4-1359-4beb-b931-5cb41d20ab90"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(page).to have_css "img.leaflet-image-layer", visible: true
-  end
-  scenario "displays dynamic layer (single layer)" do
-    skip "spec depend on potentially flaky external services"
-    visit solr_document_path "4669301e-b4b2-4c8b-bf40-01b968a2865b"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(page).to have_css "img.leaflet-image-layer", visible: true
-  end
-  scenario "displays feature layer" do
-    pending "cannot currently test for svg feature"
-    visit solr_document_path "f406332e63eb4478a9560ad86ae90327_18"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(Nokogiri::HTML.parse(page.body).css("g").length).to eq 23
-    fail
-  end
-  scenario "displays tiled map layer" do
-    skip "spec depend on potentially flaky external services"
-    visit solr_document_path "31567cf1-bad8-4bc5-8d57-44b96c207ecc"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(page).to have_css "img.leaflet-tile.leaflet-tile-loaded", visible: true
-  end
-  scenario "displays Esri WMS layer" do
-    skip "spec depend on potentially flaky external services"
-    visit solr_document_path "purdue-urn-f082acb1-b01e-4a08-9126-fd62a23fd9aa"
-    expect(page).to have_css ".leaflet-control-zoom", visible: true
-    expect(page).to have_css "img.leaflet-tile.leaflet-tile-loaded", visible: true
-  end
-end

data/spec/features/index_map_spec.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Index map", js: true do
-  # Colors
-  default_color = "#7FCDBB"
-  selected_color = "#2C7FB8"
-  scenario "displays index map viewer (polygon)" do
-    skip "Doesn't work for importmaps when headless in CI" if ENV["CI"]
-
-    visit solr_document_path("stanford-fb897vt9938")
-    # Wait until SVG elements are added
-    expect(page).to have_css ".leaflet-overlay-pane svg"
-    within "#leaflet-viewer" do
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{default_color}']"
-      # Click the top-left corner of the polygon instead of the center
-      # to prevent it being occluded by other DOM elements (occurs in headless mode)
-      find("svg g path:nth-child(2)").click(x: 1, y: 1)
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{selected_color}']"
-      first("svg g path").click(x: 1, y: 1)
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{default_color}']"
-    end
-  end
-
-  scenario "displays index map viewer (points)" do
-    skip "Doesn't work for importmaps when headless in CI" if ENV["CI"]
-
-    visit solr_document_path("cornell-ny-aerial-photos-1960s")
-    # Wait until SVG elements are added
-    expect(page).to have_css ".leaflet-overlay-pane svg"
-    within "#leaflet-viewer" do
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{default_color}']"
-      find("svg g path:nth-child(2)").click(x: 1, y: 1)
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{selected_color}']"
-      first("svg g path").click(x: 1, y: 1)
-      expect(page).to have_css "svg g path:nth-child(2)[fill='#{default_color}']"
-    end
-  end
-end

data/spec/features/layer_with_no_references_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "layer with no wms or iiif" do
-  scenario "has map with bounding box" do
-    pending "waiting on #201, need example metadata record"
-    fail
-  end
-end

data/spec/features/linkified_attribute_table_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Attribute table values", js: true do
-  xscenario "are linkified" do
-    # ArcGIS server returning an error. Wait until SVG elements are added
-    visit solr_document_path "f406332e63eb4478a9560ad86ae90327_18"
-    expect(page).to have_css ".leaflet-overlay-pane svg"
-    page.first("svg g path").click
-    expect(page).to have_css 'td a[href="http://www.minneapolismn.gov/fire/stations/fire_station28"]', text: "http://www.minneapolismn.gov/fire/stations/fire_station28"
-  end
-end

data/spec/features/multiple_downloads_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Multiple downloads" do
-  feature "when item has multiple downloads in dct_references_s" do
-    scenario "downloads are listed in download card" do
-      visit solr_document_path "cugir-007950"
-      find("#downloads-button").click
-      within "#downloads-collapse" do
-        expect(page).to have_link "Shapefile", href: "https://cugir-data.s3.amazonaws.com/00/79/50/cugir-007950.zip"
-        expect(page).to have_link "PDF", href: "https://cugir-data.s3.amazonaws.com/00/79/50/agBROO.pdf"
-        expect(page).to have_link "KMZ", href: "https://cugir-data.s3.amazonaws.com/00/79/50/agBROO2011.kmz"
-      end
-    end
-  end
-end

data/spec/features/show_page_download_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.feature "Download display on show page" do
-  scenario "with download String" do
-    visit solr_document_path "2eddde2f-c222-41ca-bd07-2fd74a21f4de"
-    find("#downloads-button").click
-    within "#downloads-collapse" do
-      expect(page).to have_selector(:css, 'a[href="ftp://gdrs.dnr.state.mn.us/gdrs/data/pub/us_mn_state_dnr/fgdb_base_usgs_scanned_topo_100k_drg.zip"]')
-    end
-  end
-
-  scenario "with download Array" do
-    visit solr_document_path "princeton-sx61dn82p"
-    find("#downloads-button").click
-    within "#downloads-collapse" do
-      expect(page).to have_selector(:css, 'a[href="https://figgy.princeton.edu/downloads/a990e1b4-7f0e-44b8-ae2a-de7e93cdd74a/file/36a2274c-e0c6-4901-a14f-7c422d15e194"]')
-      expect(page).to have_selector(:css, 'a[href="https://libimages1.princeton.edu/loris/figgy_prod/2e%2Fa9%2F43%2F2ea943b0bd4348fc9954b299f1b359f6%2Fintermediate_file.jp2/full/full/0/default.jpg"]')
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::CsvDownload do
-  let(:document) { SolrDocument.new(Geoblacklight.configuration.fields.id => "test", :solr_wfs_url => "http://www.example.com/wfs", Geoblacklight.configuration.fields.wxs_identifier => "stanford-test", Geoblacklight.configuration.fields.geometry => "ENVELOPE(-180, 180, 90, -90)") }
-  let(:download) { described_class.new(document) }
-  describe "#initialize" do
-    it "initializes as a CsvDownload object with specific options" do
-      expect(download).to be_an described_class
-      options = download.instance_variable_get(:@options)
-      expect(options[:content_type]).to eq "text/csv"
-      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/geojson_download_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::GeojsonDownload do
-  let(:document) { SolrDocument.new(Geoblacklight.configuration.fields.id => "test", :solr_wfs_url => "http://www.example.com/wfs", Geoblacklight.configuration.fields.wxs_identifier => "stanford-test", Geoblacklight.configuration.fields.geometry => "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"
-      expect(options[:extension]).to eq "geojson"
-    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

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::GeotiffDownload do
-  let(:document) do
-    SolrDocument.new(Geoblacklight.configuration.fields.id => "test", Geoblacklight.configuration.fields.wxs_identifier => "stanford-test",
-      Geoblacklight.configuration.fields.geometry => "ENVELOPE(-180, 180, 90, -90)")
-  end
-  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/kmz_download_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::KmzDownload do
-  let(:document) { SolrDocument.new(Geoblacklight.configuration.fields.id => "test", :solr_wfs_url => "http://www.example.com/wfs", Geoblacklight.configuration.fields.wxs_identifier => "stanford-test", Geoblacklight.configuration.fields.geometry => "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.0, -90.0, 180.0, 90.0"
-    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

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::ShapefileDownload do
-  let(:document) { SolrDocument.new(Geoblacklight.configuration.fields.id => "test", :solr_wfs_url => "http://www.example.com/wfs", Geoblacklight.configuration.fields.wxs_identifier => "stanford-test", Geoblacklight.configuration.fields.geometry => "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

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.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) { Geoblacklight.configuration.fields.references }
-  let(:document) do
-    SolrDocument.new(:"#{Geoblacklight.configuration.fields.id}" => "test",
-      references_field => {"http://www.opengis.net/def/serviceType/ogc/wms" => "http://www.example.com/wms"}.to_json)
-  end
-  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.join("tmp", "cache", "downloads").to_s
-    end
-
-    it "is configurable" do
-      expect(Geoblacklight.configuration).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 do
-          download.create_download_file
-        end.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