blacklight-maps 0.5.2 → 1.1.0

data/spec/lib/blacklight/maps/geometry_spec.rb

@@ -1,43 +1,56 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe BlacklightMaps::Geometry do
+  describe BlacklightMaps::Geometry::BoundingBox do
+    let(:bbox) { described_class.from_lon_lat_string('-100 -50 100 50') }
+    let(:bbox_california) { described_class.from_wkt_envelope('ENVELOPE(-124, -114, 42, 32)') }
+    let(:bbox_dateline) { described_class.from_lon_lat_string('165 30 -172 -20') }
 
-  describe "BlacklightMaps::Geometry::BoundingBox" do
+    it 'instantiates Geometry::BoundingBox' do
+      expect(bbox.class).to eq(described_class)
+    end
 
-    let(:bbox) { BlacklightMaps::Geometry::BoundingBox.from_lon_lat_string('-100 -50 100 50') }
-    let(:bbox_california) { BlacklightMaps::Geometry::BoundingBox.from_lon_lat_string('-124.4096196 32.5342321 -114.131211 42.0095169') }
-    let(:bbox_dateline) {BlacklightMaps::Geometry::BoundingBox.from_lon_lat_string('165 30 -172 -20') }
+    describe '#find_center' do
+      it 'returns center of simple bounding box' do
+        expect(bbox.find_center).to eq([0.0, 0.0])
+      end
+    end
 
-    it "should instantiate Geometry::BoundingBox" do
-      expect(bbox.class).to eq(::BlacklightMaps::Geometry::BoundingBox)
+    describe '#to_a' do
+      it 'returns the coordinates as an array' do
+        expect(bbox.to_a).to eq([-100, -50, 100, 50])
+      end
     end
 
-    it "should return center of simple bounding box" do
-      expect(bbox.find_center).to eq([0.0, 0.0])
+    describe '#geojson_geometry_array' do
+      it 'returns the coordinates as a multi dimensional array' do
+        expect(bbox.geojson_geometry_array).to eq(
+          [[[-100, -50], [100, -50], [100, 50], [-100, 50], [-100, -50]]]
+        )
+      end
     end
 
-    it "should return center of California bounding box" do
-      expect(bbox_california.find_center).to eq([-119.2704153, 37.271874499999996])
+    it 'returns center of California bounding box' do
+      expect(bbox_california.find_center).to eq([-119.0, 37.0])
     end
 
-    it "should return correct dateline bounding box" do
+    it 'returns correct dateline bounding box' do
       expect(bbox_dateline.find_center).to eq([-183.5, 5])
     end
   end
 
-  describe "BlacklightMaps::Geometry::Point" do
+  describe BlacklightMaps::Geometry::Point do
+    let(:point) { described_class.from_lat_lon_string('20,120') }
+    let(:unparseable_point) { described_class.from_lat_lon_string('35.86166,-184.195397') }
 
-    let(:point) { BlacklightMaps::Geometry::Point.from_lat_lon_string('20,120') }
-    let(:unparseable_point) { BlacklightMaps::Geometry::Point.from_lat_lon_string('35.86166,-184.195397') }
-
-    it "should instantiate Geometry::Point" do
-      expect(point.class).to eq(::BlacklightMaps::Geometry::Point)
+    it 'instantiates Geometry::Point' do
+      expect(point.class).to eq(described_class)
     end
 
-    it "should return a Solr-parseable coordinate if @long is > 180 or < -180" do
-      expect(unparseable_point.normalize_for_search).to eq([175.804603,35.86166])
+    it 'returns a Solr-parseable coordinate if @long is > 180 or < -180' do
+      expect(unparseable_point.normalize_for_search).to eq([175.804603, 35.86166])
     end
-
   end
-
 end

data/spec/lib/blacklight/maps/maps_search_builder_spec.rb

@@ -1,46 +1,42 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe BlacklightMaps::MapsSearchBuilderBehavior do
-
   let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
-  let(:user_params) { Hash.new }
+  let(:user_params) { {} }
   let(:context) { CatalogController.new }
-
-  before { allow(context).to receive(:blacklight_config).and_return(blacklight_config) }
-
   let(:search_builder_class) do
     Class.new(Blacklight::SearchBuilder) do
       include Blacklight::Solr::SearchBuilderBehavior
       include BlacklightMaps::MapsSearchBuilderBehavior
     end
   end
-
   let(:search_builder) { search_builder_class.new(context) }
 
-  describe 'add_spatial_search_to_solr' do
+  before { allow(context).to receive(:blacklight_config).and_return(blacklight_config) }
 
+  describe 'add_spatial_search_to_solr' do
     describe 'coordinate search' do
-
-      subject { search_builder.with({coordinates: '35.86166,104.195397', spatial_search_type: 'point'}) }
-
-      it 'should return a coordinate point spatial search if coordinates are given' do
-        expect(subject[:fq].first).to include('geofilt')
-        expect(subject[:pt]).to eq('35.86166,104.195397')
+      let(:coordinate_search) do
+        search_builder.with(coordinates: '35.86166,104.195397', spatial_search_type: 'point')
       end
 
+      it 'returns a coordinate point spatial search if coordinates are given' do
+        expect(coordinate_search[:fq].first).to include('geofilt')
+        expect(coordinate_search[:pt]).to eq('35.86166,104.195397')
+      end
     end
 
     describe 'bbox search' do
-
-      subject { search_builder.with({coordinates: '[6.7535159,68.162386 TO 35.5044752,97.395555]',
-                                     spatial_search_type: 'bbox'}) }
-
-      it 'should return a bbox spatial search if a bbox is given' do
-        expect(subject[:fq].first).to include(blacklight_config.view.maps.coordinates_field)
+      let(:bbox_search) do
+        search_builder.with(coordinates: '[6.7535159,68.162386 TO 35.5044752,97.395555]',
+                            spatial_search_type: 'bbox')
       end
 
+      it 'returns a bbox spatial search if a bbox is given' do
+        expect(bbox_search[:fq].first).to include(blacklight_config.view.maps.coordinates_field)
+      end
     end
-
   end
-
 end

data/spec/lib/blacklight/maps/render_constraints_override_spec.rb

@@ -1,95 +1,68 @@
-require 'spec_helper'
-
-describe BlacklightMaps::RenderConstraintsOverride do
+# frozen_string_literal: true
 
-  class BlacklightMapsControllerTestClass < CatalogController
-    attr_accessor :params
-  end
+require 'spec_helper'
 
-  before(:each) do
-    @fake_controller = BlacklightMapsControllerTestClass.new
-    @fake_controller.extend(BlacklightMaps::RenderConstraintsOverride)
-    @fake_controller.params = { coordinates: "35.86166,104.195397", spatial_search_type: "point" }
+describe BlacklightMaps::RenderConstraintsOverride, type: :helper do
+  let(:mock_controller) { CatalogController.new }
+  let(:blacklight_config) { Blacklight::Configuration.new }
+  let(:test_params) { { coordinates: '35.86166,104.195397', spatial_search_type: 'point' } }
+  let(:test_search_state) do
+    Blacklight::SearchState.new(test_params, blacklight_config, mock_controller)
   end
 
-  describe "testing for spatial parameters" do
-
-    describe "has_spatial_parameters?" do
-
-      it "should be true if coordinate params are present" do
-        expect(@fake_controller.has_spatial_parameters?).to be true
-      end
+  describe 'has_search_parameters?' do
+    before { mock_controller.params = test_params }
 
+    it 'returns true if coordinate params are present' do
+      expect(mock_controller.has_search_parameters?).to be_truthy
     end
+  end
 
-    describe "has_search_parameters?" do
-
-      it "should be true if coordinate params are present" do
-        expect(@fake_controller.has_search_parameters?).to be true
-      end
-
+  describe 'has_spatial_parameters?' do
+    it 'returns true if coordinate params are present' do
+      expect(helper.has_spatial_parameters?(test_search_state)).to be_truthy
     end
-
   end
 
-  describe "render spatial constraints" do
-
-    before do
-      @test_params = @fake_controller.params
+  describe 'query_has_constraints?' do
+    it 'returns true if there are coordinate params' do
+      expect(helper.query_has_constraints?(test_search_state)).to be_truthy
     end
+  end
 
-    describe "query_has_constraints?" do
-
-      it "should be true if there are coordinate params" do
-        expect(@fake_controller.query_has_constraints?).to be true
-      end
+  describe 'spatial_constraint_label' do
+    let(:bbox_params) { { spatial_search_type: 'bbox' } }
 
+    it 'returns the point label' do
+      expect(helper.spatial_constraint_label(test_search_state)).to eq(I18n.t('blacklight.search.filters.coordinates.point'))
     end
 
-    describe "spatial_constraint_label" do
+    it 'returns the bbox label' do
+      expect(helper.spatial_constraint_label(bbox_params)).to eq(I18n.t('blacklight.search.filters.coordinates.bbox'))
+    end
+  end
 
-      it "should return the point label" do
-        expect(@fake_controller.spatial_constraint_label(@test_params)).to eq(I18n.t('blacklight.search.filters.coordinates.point'))
+  describe 'render spatial constraints' do
+    describe 'render_spatial_query' do
+      before do
+        allow(helper).to receive_messages(search_action_path: search_catalog_path)
       end
 
-      it "should return the bbox label" do
-        @test_params = { spatial_search_type: "bbox" }
-        expect(@fake_controller.spatial_constraint_label(@test_params)).to eq(I18n.t('blacklight.search.filters.coordinates.bbox'))
+      it 'renders the coordinates' do
+        expect(helper.render_spatial_query(test_search_state)).to have_content(test_params[:coordinates])
       end
 
-    end
-
-    describe "render_spatial_query" do
-
-      before :each do
-        # have to create a request or call to 'url _for' returns an error
-        @fake_controller.request = ActionDispatch::Request.new(params:{controller: 'catalog', action: 'index'})
-        @fake_controller.request.path_parameters[:controller] = 'catalog'
+      it 'removes the spatial params' do
+        expect(helper.remove_spatial_params(test_search_state)).not_to have_content('spatial_search_type')
       end
-
-      # TODO: can't get these specs to pass, getting error:
-      # NoMethodError: undefined method `render_constraint_element'
-
-      it "should render the coordinates" #do
-        #expect(@fake_controller.render_spatial_query(@test_params)).to have_content(@fake_controller.params[:coordinates])
-      #end
-
-      it "should remove spatial params in the 'remove' link" #do
-        #expect(@fake_controller.render_spatial_query(@test_params)).to_not have_content("spatial_search_type")
-      #end
-
     end
 
-    describe "render_search_to_s_coord" do
-
-      it "should return render_search_to_s_element when coordinates are present" do
-        expect(@fake_controller).to receive(:render_search_to_s_element)
-        expect(@fake_controller).to receive(:render_filter_value)
-        @fake_controller.render_search_to_s_coord(@test_params)
+    describe 'render_search_to_s_coord' do
+      it 'returns render_search_to_s_element when coordinates are present' do
+        expect(helper).to receive(:render_search_to_s_element)
+        expect(helper).to receive(:render_filter_value)
+        helper.render_search_to_s_coord(test_params)
       end
-
     end
-
   end
-
-end
+end

data/spec/spec_helper.rb

@@ -1,36 +1,34 @@
-ENV["RAILS_ENV"] ||= 'test'
+# frozen_string_literal: true
 
-require 'engine_cart'
+# testing environent:
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'simplecov'
 require 'coveralls'
 Coveralls.wear!('rails')
-EngineCart.load_application!
-
-require 'capybara/poltergeist'
-Capybara.javascript_driver = :poltergeist
 
-Capybara.register_driver :poltergeist do |app|
-  options = {}
-
-  options[:timeout] = 120 if RUBY_PLATFORM == "java"
-
-  Capybara::Poltergeist::Driver.new(app, options)
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter '/spec/'
 end
 
-if ENV["COVERAGE"] or ENV["CI"]
-  require 'simplecov'
-
-  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  SimpleCov.start do
-    add_filter "/spec/"
-  end
-end
+# engine_cart:
+require 'bundler/setup'
+require 'engine_cart'
+EngineCart.load_application!
 
 require 'blacklight/maps'
 
 require 'rspec/rails'
 require 'capybara/rspec'
-
+require 'selenium-webdriver'
+require 'webdrivers'
 
 RSpec.configure do |config|
   config.infer_spec_type_from_file_location!
+  config.fixture_path = "#{Blacklight::Maps.root}/spec/fixtures"
+
+  config.before(:each, type: :system, js: true) do
+    driven_by :selenium, using: :headless_chrome, screen_size: [1024, 768]
+  end
 end

data/spec/system/index_view_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'catalog#index map view', js: true do
+  before do
+    CatalogController.blacklight_config = Blacklight::Configuration.new
+    CatalogController.configure_blacklight do |config|
+      # use geojson facet for blacklight-maps catalog#index map view specs
+      config.add_facet_field 'geojson_ssim', limit: -2, label: 'GeoJSON', show: false
+      config.add_facet_fields_to_solr_request!
+    end
+    visit search_catalog_path q: 'korea', view: 'maps'
+  end
+
+  it 'displays map elements' do
+    expect(page).to have_selector('#documents.map')
+    expect(page).to have_selector('#blacklight-index-map')
+  end
+
+  it 'displays tile layer attribution' do
+    expect(find('div.leaflet-control-container')).to have_content('OpenStreetMap contributors, CC-BY-SA')
+  end
+
+  describe '#sortAndPerPage' do
+    it 'shows the mapped item count' do
+      expect(page).to have_selector('.mapped-count .badge', text: '4')
+    end
+
+    it 'shows the mapped item caveat' do
+      expect(page).to have_selector('.mapped-caveat')
+    end
+
+    # TODO: placeholder spec: #sortAndPerPage > .view-type > .view-type-group
+    # shows active map icon. however, this spec doesn't work because
+    # Blacklight::ConfigurationHelperBehavior#has_alternative_views? returns false,
+    # so catalog/_view_type_group partial renders no content, can't figure out why
+    it 'shows the map view icon' do
+      pending("expect(page).to have_selector('.view-type-maps.active')")
+      fail
+    end
+  end
+
+  describe 'data attributes' do
+    let(:maxzoom) { CatalogController.blacklight_config.view.maps.maxzoom }
+    let(:tileurl) { CatalogController.blacklight_config.view.maps.tileurl }
+
+    it 'has maxzoom value from config' do
+      expect(page).to have_selector("#blacklight-index-map[data-maxzoom='#{maxzoom}']")
+    end
+
+    it 'has tileurl value from config' do
+      expect(page).to have_selector("#blacklight-index-map[data-tileurl='#{tileurl}']")
+    end
+  end
+
+  describe 'marker clusters' do
+    before do
+      3.times do # zoom out to create cluster
+        find('a.leaflet-control-zoom-out').click
+        sleep(1) # give Leaflet time to combine clusters or spec can fail
+      end
+    end
+
+    it 'has one marker cluster' do
+      expect(page).to have_selector('div.marker-cluster', count: 1)
+    end
+
+    it 'shows the result count' do
+      expect(find('div.marker-cluster')).to have_content(4)
+    end
+
+    describe 'click marker cluster' do
+      before { find('div.marker-cluster').click }
+
+      it 'splits into two marker clusters' do
+        expect(page).to have_selector('div.marker-cluster', count: 2)
+      end
+    end
+  end
+
+  describe 'marker popups' do
+    before do
+      find('.marker-cluster', text: '1', match: :first).click
+    end
+
+    it 'shows a popup with correct content' do
+      expect(page).to have_selector('div.leaflet-popup-content-wrapper')
+      expect(page).to have_css('.geo_popup_heading', text: 'Seoul (Korea)')
+    end
+
+    describe 'click search link' do
+      before { find('div.leaflet-popup-content a').click }
+
+      it 'runs a new search' do
+        expect(page).to have_selector('.constraint-value .filter-value', text: 'Seoul (Korea)')
+      end
+
+      it 'uses the default view type' do
+        expect(current_url).to include('view=list')
+      end
+    end
+  end
+
+  describe 'map search control' do
+    it 'has a search control' do
+      expect(page).to have_selector('.leaflet-control .search-control')
+    end
+
+    describe 'search control hover' do
+      before { find('.search-control').hover }
+
+      it 'adds a border to the map' do
+        expect(page).to have_selector('.leaflet-overlay-pane path')
+      end
+    end
+
+    describe 'search control click' do
+      before { find('.search-control').click }
+
+      it 'runs a new search' do
+        expect(page).to have_selector('.constraint.coordinates')
+        expect(current_url).to include('view=list')
+      end
+    end
+  end
+end