geoblacklight 6.0.0.pre.alpha.7 → 6.0.0.pre.beta.2

data/spec/lib/geoblacklight/configuration/leaflet_config_spec.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::Configuration::LeafletConfig do
-  subject(:config) { described_class.new }
-
-  describe "#sleep=" do
-    it "replaces the default sleep config with a LeafletSleepConfig" do
-      config.sleep = {sleep: false, margin_distance: 50, message: "Wake up!"}
-
-      expect(config.sleep).to be_a(Geoblacklight::Configuration::LeafletSleepConfig)
-      expect(config.sleep.sleep).to be(false)
-      expect(config.sleep.margin_distance).to eq(50)
-      expect(config.sleep.message).to eq("Wake up!")
-    end
-
-    it "applies LeafletSleepConfig defaults for unspecified attributes" do
-      config.sleep = {message: "Custom message"}
-
-      expect(config.sleep.message).to eq("Custom message")
-      expect(config.sleep.sleep).to be(true)
-      expect(config.sleep.sleeptime).to eq(750)
-      expect(config.sleep.waketime).to eq(750)
-      expect(config.sleep.background).to eq("rgba(214, 214, 214, .7)")
-    end
-
-    it "replaces rather than merges with the previous sleep config" do
-      config.sleep = {sleep: false}
-
-      expect(config.sleep.sleep).to be(false)
-      expect(config.sleep.margin_distance).to eq(100)
-    end
-
-    it "produces a fresh independent object on each assignment" do
-      original = config.sleep
-      config.sleep = {sleep: false}
-
-      expect(config.sleep).not_to be(original)
-      expect(original.sleep).to be(true)
-    end
-
-    it "accepts an empty hash, falling back entirely to defaults" do
-      config.sleep = {}
-
-      expect(config.sleep).to be_a(Geoblacklight::Configuration::LeafletSleepConfig)
-      expect(config.sleep.sleep).to be(true)
-      expect(config.sleep.message).to eq("Click to Wake")
-    end
-
-    it "is reflected in #to_h" do
-      config.sleep = {sleep: false, message: "Hello"}
-
-      expect(config.to_h[:sleep]).to include("sleep" => false, "message" => "Hello")
-    end
-  end
-
-  describe "#layers=" do
-    let(:attributes) do
-      {
-        detect_retina: false,
-        index: {
-          DEFAULT: {color: "#7FCDBB", sr_color_name: "Green"},
-          UNAVAILABLE: Geoblacklight::Configuration::LayerConfig.new(
-            color: "#EDF8B1", sr_color_name: "Yellow"
-          )
-        }
-      }
-    end
-
-    it "replaces the default layers config with a LeafletLayersConfig" do
-      config.layers = attributes
-
-      expect(config.layers).to be_a(Geoblacklight::Configuration::LeafletLayersConfig)
-      expect(config.layers.detect_retina).to be(false)
-    end
-
-    it "coerces hash entries under index into LayerConfig instances" do
-      config.layers = attributes
-
-      default = config.layers.index[:DEFAULT]
-      expect(default).to be_a(Geoblacklight::Configuration::LayerConfig)
-      expect(default.color).to eq("#7FCDBB")
-      expect(default.sr_color_name).to eq("Green")
-      expect(default.weight).to eq(1)
-    end
-
-    it "preserves existing LayerConfig instances under index" do
-      config.layers = attributes
-
-      unavailable = config.layers.index[:UNAVAILABLE]
-      expect(unavailable).to be_a(Geoblacklight::Configuration::LayerConfig)
-      expect(unavailable.color).to eq("#EDF8B1")
-    end
-
-    it "replaces rather than merges with the previous layers config" do
-      config.layers = {index: {DEFAULT: {color: "#000000"}}}
-
-      expect(config.layers.index.keys).to eq([:DEFAULT])
-      expect(config.layers.index[:SELECTED]).to be_nil
-    end
-
-    it "produces a fresh independent object on each assignment" do
-      original = config.layers
-      config.layers = {index: {}}
-
-      expect(config.layers).not_to be(original)
-      expect(original.index).to include(:DEFAULT, :UNAVAILABLE, :SELECTED)
-    end
-
-    it "accepts an empty hash, resulting in an empty index" do
-      config.layers = {}
-
-      expect(config.layers).to be_a(Geoblacklight::Configuration::LeafletLayersConfig)
-      expect(config.layers.index).to eq({})
-    end
-
-    it "is reflected in #to_h" do
-      config.layers = attributes
-
-      expect(config.to_h[:layers]).to include(
-        "detect_retina" => false,
-        "index" => hash_including(
-          DEFAULT: {color: "#7FCDBB", weight: 1, radius: 4, sr_color_name: "Green"}
-        )
-      )
-    end
-  end
-end

data/spec/lib/geoblacklight/configuration/leaflet_layers_config_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Geoblacklight::Configuration::LeafletLayersConfig do
-  subject(:config) { described_class.new(attributes) }
-
-  let(:attributes) do
-    {
-      detect_retina: true,
-      index: {
-        DEFAULT: {
-          color: "#7FCDBB",
-          sr_color_name: "Green"
-        },
-        UNAVAILABLE: Geoblacklight::Configuration::LayerConfig.new(
-          color: "#EDF8B1",
-          sr_color_name: "Yellow"
-        )
-      }
-    }
-  end
-
-  describe "initialization" do
-    it "sets detect_retina attribute" do
-      expect(config.detect_retina).to be(true)
-    end
-
-    it "converts hash elements under index to LayerConfig instances" do
-      expect(config.index[:DEFAULT]).to be_a(Geoblacklight::Configuration::LayerConfig)
-      expect(config.index[:DEFAULT].color).to eq("#7FCDBB")
-      expect(config.index[:DEFAULT].weight).to eq(1) # Uses default weight from LayerConfig
-    end
-
-    it "keeps existing LayerConfig instances under index" do
-      expect(config.index[:UNAVAILABLE]).to be_a(Geoblacklight::Configuration::LayerConfig)
-      expect(config.index[:UNAVAILABLE].color).to eq("#EDF8B1")
-      expect(config.index[:UNAVAILABLE].weight).to eq(1) # Uses default weight from LayerConfig
-    end
-  end
-
-  describe "#to_h" do
-    it "serializes index to a hash of hashes" do
-      expect(config.to_h).to eq(
-        "detect_retina" => true,
-        "index" => {
-          DEFAULT: {
-            color: "#7FCDBB",
-            weight: 1,
-            radius: 4,
-            sr_color_name: "Green"
-          },
-          UNAVAILABLE: {
-            color: "#EDF8B1",
-            weight: 1,
-            radius: 4,
-            sr_color_name: "Yellow"
-          }
-        }
-      )
-    end
-  end
-end

data/spec/lib/geoblacklight/configuration_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Geoblacklight::Configuration do
-  subject(:config) { Geoblacklight::Configuration.new }
-
-  describe "#leaflet_options" do
-    subject(:leaflet_options) { config.leaflet_options }
-
-    it "returns a hash of options for leaflet" do
-      expect(leaflet_options.layers.index.keys).to eq(%i[DEFAULT UNAVAILABLE SELECTED])
-    end
-
-    it "uses LayerConfig instances for index configurations" do
-      expect(leaflet_options.layers.index[:DEFAULT]).to be_a(Geoblacklight::Configuration::LayerConfig)
-      expect(leaflet_options.layers.index[:DEFAULT].weight).to eq(1)
-      expect(leaflet_options.layers.index[:DEFAULT].radius).to eq(4)
-      expect(leaflet_options.layers.index[:DEFAULT].color).to eq("#7FCDBB")
-      expect(leaflet_options.layers.index[:DEFAULT].sr_color_name).to eq("Green")
-    end
-
-    it "serializes layers options correctly with LayerConfig defaults" do
-      layers_hash = leaflet_options.to_h[:layers]
-      expect(layers_hash).to eq(
-        "detect_retina" => true,
-        "index" => {
-          DEFAULT: {
-            color: "#7FCDBB",
-            weight: 1,
-            radius: 4,
-            sr_color_name: "Green"
-          },
-          UNAVAILABLE: {
-            color: "#EDF8B1",
-            weight: 1,
-            radius: 4,
-            sr_color_name: "Yellow"
-          },
-          SELECTED: {
-            color: "#2C7FB8",
-            weight: 1,
-            radius: 4,
-            sr_color_name: "Blue"
-          }
-        }
-      )
-    end
-  end
-end

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

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.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[:features][0][:properties].keys.length).to eq 2
-      expect(response.format[:features][0][:isHTML]).to be true
-      expect(response.format[:features][0][:properties]["Header1"]).to eq "value1"
-      expect(response.format[:features][0][:properties]["Header2"]).to eq "value2"
-    end
-    it "returns a formated response when multiple features are retrieved" do
-      expect(response_multiple_features.format).not_to be_nil
-      expect(response.format[:features][0][:properties].keys.length).to eq 2
-      expect(response.format[:features][0][:isHTML]).to be true
-      expect(response.format[:features][0][:properties]["Header1"]).to eq "value1"
-      expect(response.format[:features][0][:properties]["Header2"]).to eq "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

data/spec/lib/geoblacklight/wms_layer_spec.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.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 "#feature_info" do
-    let(:response) { instance_double(Geoblacklight::FeatureInfoResponse) }
-    let(:params) { rails_4_params }
-
-    before do
-      allow(Geoblacklight::FeatureInfoResponse).to receive(:new).and_return(response)
-      allow(response).to receive(:check)
-    end
-
-    it "returns the response from the FeatureInfoResponse object" do
-      expect(wms_layer.feature_info).to eq(response.check)
-    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