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

data/spec/controllers/catalog_controller_spec.rb

@@ -9,11 +9,26 @@ RSpec.describe CatalogController, type: :controller do
 
       expect(description_field.component).to eq Geoblacklight::MetadataDescriptionMarkdownComponent
     end
+
+    it "uses the truncatable layout for the fields that hold long lists of values" do
+      fields = Geoblacklight.configuration.fields
+      layouts = [fields.subject, fields.theme, fields.spatial_coverage].map do |key|
+        described_class.blacklight_config.show_fields[key].layout_component
+      end
+
+      expect(layouts).to all eq Geoblacklight::TruncatableMetadataFieldLayoutComponent
+    end
+
+    it "leaves the component free for the fields that use the truncatable layout" do
+      subject_field = described_class.blacklight_config.show_fields[Geoblacklight.configuration.fields.subject]
+
+      expect(subject_field.component).to eq Blacklight::MetadataFieldComponent
+    end
   end
 
   describe "#web_services" do
     it "returns a document based off an id" do
-      get :web_services, params: {id: "mit-f6rqs4ucovjk2"}
+      get :web_services, params: {id: "berkeley-s7pq31"}
       expect(response).to have_http_status :ok
       expect(assigns(:documents)).not_to be_nil
     end
@@ -21,17 +36,17 @@ RSpec.describe CatalogController, type: :controller do
 
   describe "#raw" do
     it "returns a JSON representation of a Solr Document" do
-      get :raw, params: {id: "tufts-cambridgegrid100-04"}
+      get :raw, params: {id: "berkeley-s7st30"}
       expect(response).to have_http_status :ok
       expect(response.body).not_to be_empty
       response_values = JSON.parse(response.body)
       expect(response_values).to include "gbl_mdVersion_s" => "Aardvark"
-      expect(response_values).to include Geoblacklight.configuration.fields.title => "100 Foot Grid Cambridge MA 2004"
-      expect(response_values).to include Geoblacklight.configuration.fields.identifier => ["urn:geodata.tufts.edu:Tufts.CambridgeGrid100_04"]
+      expect(response_values).to include Geoblacklight.configuration.fields.title => "2000 Census Block Groups, Calaveras County, California, 2018"
+      expect(response_values).to include Geoblacklight.configuration.fields.identifier => ["https://geodata.lib.berkeley.edu/catalog/berkeley-s7st30"]
       expect(response_values).to include Geoblacklight.configuration.fields.access_rights => "Public"
-      expect(response_values).to include Geoblacklight.configuration.fields.provider => "Tufts"
-      expect(response_values).to include Geoblacklight.configuration.fields.id => "tufts-cambridgegrid100-04"
-      expect(response_values).to include Geoblacklight.configuration.fields.geometry => "ENVELOPE(-71.163984,-71.052581,42.408316,42.34757)"
+      expect(response_values).to include Geoblacklight.configuration.fields.provider => "University of California Berkeley"
+      expect(response_values).to include Geoblacklight.configuration.fields.id => "berkeley-s7st30"
+      expect(response_values).to include Geoblacklight.configuration.fields.geometry => "ENVELOPE(-120.99553605196368,-120.01994492166297,38.50999518077548,37.83228807647538)"
     end
   end
 end

data/spec/controllers/{relation_controller_spec.rb → relations_controller_spec.rb}

@@ -2,7 +2,7 @@
 
 require "spec_helper"
 
-RSpec.describe RelationController, type: :controller do
+RSpec.describe RelationsController, type: :controller do
   describe "#index" do
     it "returns a listing of related documents for a record" do
       get :index, params: {id: "nyu_2451_34502"}

data/spec/factories/user.rb

@@ -2,7 +2,12 @@
 
 FactoryBot.define do
   factory :user do
-    sequence(:email) { |n| "user#{n}@example.com" }
+    # Rails' built-in authentication calls the column email_address, where Devise calls it email
+    if AuthenticationHelpers.provider == :rails
+      sequence(:email_address) { |n| "user#{n}@example.com" }
+    else
+      sequence(:email) { |n| "user#{n}@example.com" }
+    end
     password { "password" }
     password_confirmation { "password" }
   end

data/spec/features/axe_spec.rb

@@ -11,7 +11,7 @@ RSpec.feature "Accessibility testing", js: true do
     end
 
     it "validates an item page" do
-      visit solr_document_path("tufts-cambridgegrid100-04")
+      visit solr_document_path("berkeley-s7st30")
       expect(page).to be_accessible
     end
 
@@ -22,7 +22,8 @@ RSpec.feature "Accessibility testing", js: true do
     end
 
     it "validates an bookmarks page" do
-      visit solr_document_path("tufts-cambridgegrid100-04")
+      skip_without_authentication
+      visit solr_document_path("berkeley-s7st30")
       click_on "Bookmark"
       visit bookmarks_path
       expect(page).to be_accessible
@@ -61,6 +62,7 @@ RSpec.feature "Accessibility testing", js: true do
   end
 
   def be_accessible
-    be_axe_clean.excluding("#clover-viewer")
+    # Viewers are tested separately
+    be_axe_clean.excluding(".viewer")
   end
 end

data/spec/features/home_page_spec.rb

@@ -9,16 +9,17 @@ RSpec.feature "Home page", js: true do # use js: true for tests which require js
 
   scenario "map should be visible" do
     within "#main-container" do
-      expect(page).to have_css("#leaflet-viewer")
-      expect(page).to have_css("img.leaflet-tile", visible: :all)
+      expect(page).to have_css("#overview-map")
     end
+
+    # The map itself is drawn inside the element
+    expect(find("#overview-map").shadow_root).to have_css("canvas.maplibregl-canvas")
   end
 
-  scenario "clicking map search should create a spatial search" do
-    within "#leaflet-viewer" do
-      find(".search-control a").click
-      expect(page.current_url).to match(/bbox=/)
-    end
+  scenario "dragging a box over the map should create a spatial search" do
+    search_map_area
+
+    expect(page).to have_current_path(/bbox=/, url: true, wait: 10)
     expect(page).to have_css "#documents"
   end
 end

data/spec/features/index_view_spec.rb

@@ -8,29 +8,15 @@ RSpec.feature "Index view", js: true do
     visit search_catalog_path(q: "*")
   end
 
-  scenario "hover on record should produce bounding box on map" do
-    # Needed to find an svg element on the page
-    visit search_catalog_path(f: {Geoblacklight.configuration.fields.provider => ["Stanford"]})
-    # BL7 has svg icons, so sniffing for SVG path won't return false
-    # expect(Nokogiri::HTML.parse(page.body).css('path').length).to eq 0
-    find(".documentHeader", match: :first).hover
-    within("#leaflet-viewer") do
-      expect(page).to have_css("path")
-    end
-  end
+  scenario "searching the map should retain current search parameters" do
+    visit "/?f[#{subject_field}][]=Population"
 
-  scenario "click on a record area to expand collapse" do
-    within("article", match: :first) do
-      expect(page).to have_css(".collapsed")
-      find("button").click
-      expect(page).not_to have_css(".collapsed")
-    end
-  end
+    # A reader searches by dragging a box over the map, which the line of text on it says
+    expect(find("#overview-map").shadow_root).to have_css(".maplibregl-ctrl-geosearch")
+    search_map_area
 
-  scenario "clicking map search should retain current search parameters" do
-    visit "/?f[#{subject_field}][]=Population"
-    find("#leaflet-viewer").double_click
     within "#appliedParams" do
+      expect(page).to have_content("Bounding Box", wait: 10)
       expect(page).to have_content("Subject Population")
     end
   end

data/spec/features/layer_preview_spec.rb

@@ -3,17 +3,10 @@
 require "spec_helper"
 
 RSpec.feature "Layer preview", js: true do
-  scenario "Restricted layer should show bounding box" do
-    visit solr_document_path("berkeley-s76d73")
-    within("#leaflet-viewer") do
-      expect(page).to have_css("path")
-    end
-  end
+  # A restricted layer offers its location instead, which is spec/features/restricted_viewer_spec.rb
+  scenario "Public layer should be previewed as data" do
+    visit solr_document_path("berkeley-s7pq31")
 
-  scenario "Public layer should show wms layer not bounding box" do
-    visit solr_document_path("mit-f6rqs4ucovjk2")
-    within ".leaflet-tile-pane" do
-      expect(page).to have_css(".leaflet-layer", count: 2)
-    end
+    expect(preview_tabs).to include "Web Map Service (WMS)"
   end
 end

data/spec/features/locator_map_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.feature "locator map", js: true do
+  # A record with nothing previewable, so its sidebar says where it is instead
+  before { visit solr_document_path("princeton-1r66j405w") }
+
+  subject(:map) { map_ready("#locator-map").shadow_root }
+
+  scenario "draws where the record is" do
+    expect(drawn_extents("#locator-map")).to eq [[[-74.68, 40.33], [-74.63, 40.37]]]
+  end
+
+  # Both of these arrive with the style document, a moment after the map itself - and the globe
+  # survives this app setting the theme while the map is still being built
+  scenario "opens as a globe, and can be zoomed and flattened" do
+    expect(map).to have_css("button.maplibregl-ctrl-globe-enabled", wait: 10)
+    expect(map).to have_css("button.maplibregl-ctrl-zoom-in")
+  end
+
+  scenario "credits the basemap it borrowed, out of the corner it can spare" do
+    # CARTO and OpenStreetMap both require the credit, so it is there to open rather than gone: the
+    # empty class comes off once the basemap says who made it, and compact is the collapsed "i"
+    expect(map).to have_css(".maplibregl-ctrl-attrib.maplibregl-compact:not(.maplibregl-attrib-empty)", wait: 10)
+  end
+
+  scenario "has nothing to search, because a locator answers one question" do
+    expect(map).to have_no_css(".maplibregl-ctrl-geosearch")
+  end
+end

data/spec/features/relations_spec.rb

@@ -5,22 +5,33 @@ require "spec_helper"
 RSpec.feature "Display related documents" do
   scenario "Record with relations should render widget in catalog#show", js: true do
     visit solr_document_path("nyu_2451_34635")
-    expect(page).to have_css(".card.relations", visible: :all)
-    expect(page).to have_css("div.card-header", text: "Derived records...", visible: :all)
+    expect(page).to have_css(".card.relations", visible: :all, wait: 10)
+    expect(page).to have_css("div.card-header", text: "Source of", visible: :all, wait: 10)
   end
 
   scenario "Record without relations should not render widget in catalog#show", js: true do
-    visit solr_document_path("harvard-g7064-s2-1834-k3")
-    expect(page).to have_no_css(".card.relations")
+    # Public polygon record, which carries none of the relationship fields
+    visit solr_document_path("berkeley-s7pq31")
+
+    # The card is rendered inside a lazily-fetched turbo-frame, so wait for the frame to
+    # report itself complete before asserting absence. A negative Capybara matcher is
+    # satisfied the instant the element is missing, so without this the assertion passes
+    # at t=0 for every record - including ones that do have relations.
+    expect(page).to have_css("turbo-frame#relations[complete]", visible: :all, wait: 10)
+    expect(page).to have_no_css(".card.relations", visible: :all)
   end
 
   scenario "Relationship browse link returns relationship-scoped results", js: true do
     # Wabash Topo parent record
     visit solr_document_path("eee6150b-ce2f-4837-9d17-ce72a0c1c26f")
 
-    expect(page).to have_content(:all, "Has part...")
-    expect(page).to have_link("Browse all 4 records...", visible: :all)
-    click_link("Browse all 4 records...", visible: :all)
+    expect(page).to have_content(:all, "Has 4 parts", wait: 10)
+    expect(page).to have_link("Browse all 4 parts of this item", visible: :all, wait: 10)
+
+    # Follow the link's href directly rather than clicking it - the sidebar is still drawing
+    # asynchronously at this point, which can shift the link out from under a real click.
+    browse_all_href = find_link("Browse all 4 parts of this item", visible: :all)[:href]
+    visit browse_all_href
 
     expect(page).not_to have_content("No results found for your search")
   end
@@ -28,24 +39,24 @@ RSpec.feature "Display related documents" do
   scenario "Record with dct_isPartOf_sm value(s) should link to relations", js: true do
     # All Relationships
     visit solr_document_path("all-relationships")
-    expect(page).to have_content(:all, "Is part of...")
+    expect(page).to have_content(:all, "Part of", wait: 10)
   end
 
   scenario "Record pointed at by a parent with dct_isPartOf_sm value(s) should link back", js: true do
     # The Related Record
     visit solr_document_path("the-related-record")
-    expect(page).to have_content(:all, "Has part...")
+    expect(page).to have_content(:all, "Has part", wait: 10)
   end
 
   scenario "Record with pcdm_memberOf_sm value(s) should link to relations", js: true do
     # All Relationships
     visit solr_document_path("all-relationships")
-    expect(page).to have_content(:all, "Belongs to collection...")
+    expect(page).to have_content(:all, "In collection", wait: 10)
   end
 
   scenario "Record pointed at by a parent with pcdm_memberOf_sm value(s) should link back", js: true do
     # The Related Record
     visit solr_document_path("the-related-record")
-    expect(page).to have_content(:all, "Collection records...")
+    expect(page).to have_content(:all, "Contains", wait: 10)
   end
 end

data/spec/features/restricted_viewer_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.feature "Restricted item viewer", js: true do
+  scenario "shows where the layer is rather than failing to load it" do
+    visit solr_document_path("stanford-dp018hs9766")
+
+    # The viewer was handed a record with no service references, so the only preview it can offer
+    # is the record's own extent
+    previews = find("ogm-viewer").shadow_root.find("ogm-previews", visible: :all)
+    expect(previews.shadow_root).to have_css("wa-tab", text: "Location", visible: :all)
+  end
+end

data/spec/features/search_results_map_spec.rb

@@ -3,19 +3,95 @@
 require "spec_helper"
 
 RSpec.feature "search results map", js: true do
+  before { visit search_catalog_path(q: "Minneapolis") }
+
+  scenario "draws where each result is, numbered the way the list beside it is" do
+    expect(drawn_extents.count).to eq page.all(".document").count
+
+    # The map counts from one over everything it was given, and the counter beside a result counts
+    # from the start of the whole result set - so on the first page of results the two agree
+    expect(page.all(".document").map { |result| result["data-document-counter"] })
+      .to eq (1..drawn_extents.count).map(&:to_s)
+  end
+
   scenario "view is scoped to Twin Cities metro area" do
-    visit search_catalog_path(q: "Minneapolis")
-    expect(page).to have_css "#leaflet-viewer"
-    sleep 1
-
-    bbox = page.find("#leaflet-viewer")["data-bounds"]
-
-    # Example bbox for q: Minneapolis
-    # "-94.537353515625,44.004669106432225,-92.208251953125,45.87088761346192"
-    left, bottom, right, top = bbox.split(",")
-    expect(left.to_f).to be_within(1).of(-94)
-    expect(bottom.to_f).to be_within(1).of(44)
-    expect(right.to_f).to be_within(1).of(-92)
-    expect(top.to_f).to be_within(1).of(45)
+    # Example extent for q: Minneapolis
+    # [[-94.012, 44.471], [-92.732, 45.415]]
+    (west, south), (east, north) = drawn_extents.first
+
+    expect(west).to be_within(1).of(-94)
+    expect(south).to be_within(1).of(44)
+    expect(east).to be_within(1).of(-92)
+    expect(north).to be_within(1).of(45)
+  end
+
+  scenario "comes back knowing the area the reader searched" do
+    # The line of text saying how to search goes up with the map
+    expect(find("#overview-map").shadow_root).to have_css(".maplibregl-ctrl-geosearch")
+
+    search_map_area
+
+    within "#appliedParams" do
+      expect(page).to have_content("Bounding Box", wait: 10)
+    end
+
+    # A map that draws, rather than an empty box
+    expect(find("#overview-map").shadow_root).to have_css("canvas.maplibregl-canvas")
+
+    # ...and one that has been told what the results were narrowed to, which is what it points
+    # itself at: the results themselves can't do that job, because a bbox query matches everything
+    # that *intersects* the box and a single continent-wide dataset among them would frame a continent.
+    # Read as a property rather than the search-bounds attribute: the map is carried over this search
+    # rather than rebuilt, so its attribute is frozen at whatever it was on the first render, and it's
+    # the live property the controller corrects on reconnect that the map actually goes by.
+    expect(page.evaluate_script("document.querySelector('#overview-map').searchBounds")).to eq searched_bbox
+  end
+
+  scenario "keeps the same map, canvas and all, rather than rebuilding it" do
+    map = map_ready
+    canvas = map.shadow_root.find("canvas.maplibregl-canvas", visible: :all)
+    page.execute_script("arguments[0].dataset.probe = 'kept-map'", map)
+    page.execute_script("arguments[0].dataset.probe = 'kept-canvas'", canvas)
+
+    search_map_area
+
+    within "#appliedParams" do
+      expect(page).to have_content("Bounding Box", wait: 10)
+    end
+
+    # A freshly built element or WebGL canvas would start without these - they are set by hand above,
+    # not by the server or component. Keeping both is what avoids another map load and tile fetch.
+    carried = find("#overview-map")
+    expect(carried["data-probe"]).to eq "kept-map"
+    expect(carried.shadow_root.find("canvas.maplibregl-canvas", visible: :all)["data-probe"]).to eq "kept-canvas"
+
+    # And it's been given the narrowed results to draw, not left showing what it had before
+    expect(drawn_extents.count).to eq page.all(".document").count
+  end
+
+  describe "pointing at a result" do
+    let(:result) { page.all(".document").first }
+    let(:layer_id) { result["data-map-id"] }
+
+    scenario "from the list tells the map which one it is" do
+      map_ready
+      result.hover
+
+      expect(page.evaluate_script("document.querySelector('#overview-map').highlighted")).to eq layer_id
+    end
+
+    scenario "on the map marks its row in the list" do
+      map = map_ready
+
+      # As the map reports a reader's pointer landing on a number. Sent here rather than pointed at,
+      # because the numbers are drawn into a canvas inside the map's own shadow root, and where each
+      # of them lands on screen is the map's business.
+      page.execute_script(<<~JS, map, layer_id)
+        const [map, id] = arguments
+        map.dispatchEvent(new CustomEvent("highlightChange", { detail: { place: 1, id } }))
+      JS
+
+      expect(result[:class]).to include "highlighted"
+    end
   end
 end

data/spec/features/search_spec.rb

@@ -6,11 +6,15 @@ RSpec.feature "Search" do
   scenario "When searching child records from a parent record, supressed records are not hidden", js: true do
     visit "/catalog/princeton-1r66j405w"
 
-    within(".card.relations.relationship-source_descendants", visible: :all) do
+    within(".card.relations", visible: :all) do
       expect(page).to have_link(href: /f%5Bdct_source_sm%5D/, visible: :all)
     end
 
-    click_link "Browse all 4 records...", visible: :all
+    # The sidebar holds a map of where this record is, and it arrives after the page does - so the
+    # link below is still moving until it has been drawn
+    map_ready("#locator-map")
+
+    click_link "Browse all 4 items sourced from this item", visible: :all
     expect(page).to have_css ".document", count: 4
   end
 end

data/spec/features/sign_in_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.feature "Signing in to see a restricted record" do
+  let(:restricted) { "stanford-dp018hs9766" }
+
+  scenario "brings the reader back to the record once they're signed in" do
+    skip_without_authentication
+    visit solr_document_path(restricted)
+    click_link "Login to View and Download"
+    fill_in_sign_in_form FactoryBot.create(:user)
+
+    expect(page).to have_current_path(solr_document_path(restricted))
+    expect(page).to have_link "Log Out"
+    expect(page).to have_no_link "Login to View and Download"
+  end
+
+  scenario "is not offered when the app has no authentication" do
+    skip "the test app has authentication" if AuthenticationHelpers.provider
+    visit solr_document_path(restricted)
+
+    expect(page).to have_css "h1", text: "Elkhorn Slough"
+    expect(page).to have_no_link "Login to View and Download"
+  end
+end

data/spec/features/tilejson_spec.rb

@@ -18,8 +18,6 @@ RSpec.feature "tilejson layer" do
 
     visit solr_document_path("princeton-fk4544658v-tilejson")
 
-    expect(page).to have_css ".leaflet-control-zoom", visible: :visible
-    expect(page).to have_css "div[data-leaflet-viewer-protocol-value='Tilejson']"
-    expect(page).to have_css "div[data-leaflet-viewer-url-value='https://map-tiles-staging.princeton.edu/2a91d82c541c426cb787cc62afe8f248/mosaicjson/tilejson.json']"
+    expect(preview_tabs).to include "TileJSON"
   end
 end

data/spec/features/tms_spec.rb

@@ -5,7 +5,7 @@ require "spec_helper"
 RSpec.feature "tms layer" do
   scenario "displays tms layer", js: true do
     visit solr_document_path("cugir-007957")
-    expect(page).to have_css ".leaflet-control-zoom"
-    expect(page).to have_css "img[src*='cugir.library.cornell.edu']", visible: :all
+
+    expect(preview_tabs).to include "Tiled Map Service (TMS)"
   end
 end

data/spec/features/truncated_metadata_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.feature "Metadata fields that limit their values" do
+  let(:group) { "div.truncate-field:has(dt.blacklight-dct_subject_sm)" }
+  let(:read_more) { find("#{group} > dd.read-more-slot button") }
+
+  # Princeton record carrying nine subject values, four more than the five it shows in full
+  scenario "The values past the limit are hidden until the reader asks for them", js: true do
+    visit solr_document_path("princeton-dc7h14b252v")
+
+    subjects = find(group)
+
+    # Every value keeps its own dd. The value at the limit is clipped to show that the list
+    # carries on; the ones after it are taken out of view entirely.
+    expect(subjects).to have_css("dd:not(.read-more-slot)", count: 9, visible: :all)
+    expect(subjects).to have_css("dd.truncate-preview", count: 1, visible: :all)
+    expect(subjects).to have_css("dd.visually-hidden", count: 3, visible: :all)
+
+    # The text assertions are scoped to the field: the viewer's own metadata panel lists
+    # every subject too, so a page-wide matcher would race with the viewer loading.
+    expect(subjects).to have_no_text("Physical maps")
+
+    read_more.click
+
+    expect(subjects).to have_no_css("dd.visually-hidden", visible: :all)
+    expect(subjects).to have_no_css("dd.truncate-preview", visible: :all)
+    expect(subjects).to have_text("Physical maps")
+    expect(read_more).to have_text("Close")
+
+    read_more.click
+
+    expect(subjects).to have_css("dd.visually-hidden", count: 3, visible: :all)
+    expect(subjects).to have_css("dd.truncate-preview", count: 1, visible: :all)
+    expect(read_more).to have_text("Read more")
+  end
+
+  scenario "The clipped value fades out, the way a clamped description does", js: true do
+    visit solr_document_path("princeton-dc7h14b252v")
+
+    preview = find("#{group} > dd.truncate-preview", visible: :all)
+    expect(preview.evaluate_script("getComputedStyle(this, '::after').backgroundImage")).to include "linear-gradient"
+
+    # A shade under one line tall, so the value reads as cut off rather than as its own entry
+    line_height = preview.evaluate_script("parseFloat(getComputedStyle(this).lineHeight)")
+    expect(preview.evaluate_script("this.getBoundingClientRect().height")).to be < line_height
+
+    # The gradient covers the value, so it must not swallow clicks on the link beneath it
+    expect(preview.evaluate_script("getComputedStyle(this, '::after').pointerEvents")).to eq "none"
+  end
+
+  scenario "The hidden values stay available to assistive technology", js: true do
+    visit solr_document_path("princeton-dc7h14b252v")
+
+    # visually-hidden leaves the values in the accessibility tree, so the button is of no use
+    # to assistive technology and says so rather than promising something it cannot deliver
+    expect(read_more[:"aria-disabled"]).to eq "true"
+    expect(read_more[:"aria-label"]).to include "assistive technology"
+
+    hidden = all("#{group} > dd.visually-hidden", visible: :all).last
+    expect(hidden.evaluate_script("getComputedStyle(this).display")).not_to eq "none"
+    expect(hidden.evaluate_script("getComputedStyle(this).visibility")).not_to eq "hidden"
+  end
+
+  scenario "Fields short enough to fit are left alone", js: true do
+    visit solr_document_path("princeton-dc7h14b252v")
+
+    # Wait for the initializer to have run before asserting that it skipped this field
+    expect(page).to have_css("#{group} > dd.read-more-slot button")
+
+    spatial = "div.truncate-field:has(dt.blacklight-dct_spatial_sm)"
+    expect(page).to have_no_css("#{spatial} > dd.read-more-slot button")
+    expect(page).to have_no_css("#{spatial} > dd.visually-hidden", visible: :all)
+    expect(page).to have_no_css("#{spatial} > dd.truncate-preview", visible: :all)
+  end
+end

data/spec/features/viewer_requests_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.feature "Viewer requests", js: true do
+  # What the viewer would ask about while previewing this record: the restricted file itself, and
+  # the basemap it draws underneath, which is an unrelated origin
+  let(:probe) do
+    <<~JS
+      (() => {
+        const viewer = document.querySelector("ogm-viewer")
+        if (typeof viewer.requestTransform !== "function") return null
+        return {
+          service: viewer.requestTransform("https://stacks.stanford.edu/file/druid:dp018hs9766/es2005_1m_10color_cog.tif", "tile"),
+          basemap: viewer.requestTransform("https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json", "metadata"),
+        }
+      })()
+    JS
+  end
+
+  around do |example|
+    configured = Geoblacklight.configuration.restricted_origins
+    Geoblacklight.configuration.restricted_origins = ["https://stacks.stanford.edu/"]
+    example.run
+    Geoblacklight.configuration.restricted_origins = configured
+  end
+
+  scenario "a signed-in reader's requests carry cookies to the configured service, and nowhere else" do
+    sign_in
+    visit solr_document_path("stanford-dp018hs9766")
+
+    # The transform is set once the initializers run, which is a moment after the page arrives
+    transform = page.document.synchronize(5) do
+      page.evaluate_script(probe) || raise(Capybara::ElementNotFound)
+    end
+
+    expect(transform["service"]).to eq("credentials" => "include")
+    expect(transform["basemap"]).to be_nil
+  end
+end