Prune redundant slow system specs; convert non-JS ones to request specs

The system suite booted real headless Chrome for many specs that only
rendered static pages, making the suite slow without adding coverage a
faster layer couldn't provide. This moves that coverage down to request
specs and removes dead test files that never ran.

- Convert 9 browser-booting, non-JS system specs to request specs
  (faqs, sectors, login, home/community-news, story ideas, workshop
  variation ideas, workshop logs, organization sectors, stories). Each
  conversion preserves the original assertions — including link-vs-text
  checks via Capybara.string(response.body) — and adds coverage that was
  previously missing (sector filtering, workshop-log show, stories empty
  state and body search).
- Delete 17 spec/system/*_test.rb files: RSpec only loads *_spec.rb, so
  these never executed. Their flows are either already covered by request
  specs or were dormant; removing them stops them masquerading as coverage.

Remaining system specs all genuinely require a browser (Stimulus,
TomSelect, Turbo streams, accept_confirm, file upload/download).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: maebeale

spec/requests/faqs_spec.rb

@@ -70,6 +70,11 @@
         expect(response.body).to include("Unpublished FAQ")
       end
 
+      it "shows the New FAQ admin control" do
+        get faqs_path
+        expect(response.body).to include("New FAQ")
+      end
+
       it "filters by unpublished param" do
         get faqs_path, params: { published: "false" } # needs to be string param
         expect(response.body).to include("Unpublished FAQ")
@@ -109,6 +114,12 @@
         expect(response.body).to include("Published FAQ")
         expect(response.body).not_to include("Unpublished FAQ")
       end
+
+      it "hides admin controls" do
+        get faqs_path
+        expect(response.body).not_to include("New FAQ")
+        expect(response.body).not_to include(edit_faq_path(published_faq))
+      end
     end
 
     context "as a guest" do
@@ -124,6 +135,12 @@
         expect(response.body).not_to include("Published FAQ")
         expect(response.body).not_to include("Unpublished FAQ")
       end
+
+      it "hides admin controls" do
+        get faqs_path
+        expect(response.body).not_to include("New FAQ")
+        expect(response.body).not_to include(edit_faq_path(public_faq))
+      end
     end
   end
 

spec/requests/home_spec.rb

@@ -20,6 +20,20 @@
     end
   end
 
+  describe "GET / (signed in)" do
+    it "shows the Upcoming Events and Community News sections" do
+      user = create(:user)
+      create(:person, user: user)
+      sign_in user
+
+      get root_path
+
+      expect(response).to have_http_status(:ok)
+      expect(response.body).to include("Upcoming Events")
+      expect(response.body).to include("Community News")
+    end
+  end
+
   describe "GET /home/* (turbo frame lazy loading)" do
     %w[workshops resources events community_news stories video_recordings].each do |section|
       it "#{section} returns 200 for visitors" do

spec/requests/login_spec.rb

@@ -0,0 +1,45 @@
+require "rails_helper"
+
+RSpec.describe "User login", type: :request do
+  let(:password) { "MyString" }
+  let(:generic_error) { "Invalid email or password. Please email us or fill out our Contact Us form for assistance." }
+
+  def log_in(email, password)
+    post user_session_path, params: { user: { email: email, password: password } }
+  end
+
+  context "when user is inactive" do
+    let(:user) { create(:user, password: password, inactive: true) }
+
+    it "does not allow login and shows the generic error" do
+      log_in(user.email, password)
+
+      expect(response).to redirect_to(new_user_session_path)
+      follow_redirect!
+      expect(response.body).to include(generic_error)
+    end
+  end
+
+  context "when credentials are wrong" do
+    let(:user) { create(:user, password: password) }
+
+    it "shows the generic error" do
+      log_in(user.email, "wrong_password")
+
+      expect(response).to have_http_status(:unprocessable_content)
+      expect(response.body).to include(generic_error)
+    end
+  end
+
+  context "when user is active and unlocked" do
+    let(:user) { create(:user, password: password) }
+
+    it "logs in successfully" do
+      log_in(user.email, password)
+
+      expect(response).to redirect_to(root_path)
+      follow_redirect!
+      expect(response.body).not_to include(generic_error)
+    end
+  end
+end

spec/requests/organizations_spec.rb

@@ -67,6 +67,57 @@
     end
   end
 
+  describe "sector displays" do
+    let!(:organization_with_sectors) do
+      affiliated_sector_1 = create(:sector, name: "Affiliated Sector 1")
+      affiliated_sector_2 = create(:sector, name: "Affiliated Sector 2")
+      person_1 = create(:person)
+      person_2 = create(:person)
+      create(:sectorable_item, sector: affiliated_sector_1, sectorable: person_1)
+      create(:sectorable_item, sector: affiliated_sector_2, sectorable: person_2)
+
+      org = create(:organization, organization_status: organization_status)
+      create(:sectorable_item, sector: create(:sector, name: "Direct Sector 1"), sectorable: org)
+      create(:sectorable_item, sector: create(:sector, name: "Direct Sector 2"), sectorable: org)
+      create(:affiliation, organization: org, person: person_1, position: :default)
+      create(:affiliation, organization: org, person: person_2, position: :default)
+      org
+    end
+
+    it "truncates sectors to the first 3 with a 'more' indicator on the show page" do
+      get organization_url(organization_with_sectors)
+
+      page = Capybara.string(response.body)
+      all_sector_names = organization_with_sectors.all_sectors.map(&:name).sort
+      expect(all_sector_names.length).to be > 3
+      all_sector_names.first(3).each { |name| expect(page).to have_content(name) }
+      expect(page).not_to have_content(all_sector_names[3])
+      expect(page).to have_content(/\+?[0-9]+ more|\.\.\./i)
+    end
+
+    it "lists all sectors with per-sector people counts on the populations served page" do
+      get populations_served_organization_url(organization_with_sectors)
+
+      page = Capybara.string(response.body)
+      expect(page).to have_content("Sector Distribution")
+      expect(page).to have_content(organization_with_sectors.name)
+
+      organization_with_sectors.all_sectors.map(&:name).each do |name|
+        expect(page).to have_content(name)
+      end
+
+      people = organization_with_sectors.users.includes(person: :sectors).map(&:person).compact
+      expected_counts = Hash.new(0)
+      people.each do |person|
+        primary_sector = person.sectors.first
+        expected_counts[primary_sector.name] += 1 if primary_sector
+      end
+      expected_counts.each do |_sector_name, count|
+        expect(page).to have_content("#{count} #{count == 1 ? 'person' : 'people'}")
+      end
+    end
+  end
+
   describe "GET /new" do
     it "renders a successful response" do
       get new_organization_url

spec/requests/sectors_spec.rb

@@ -27,6 +27,44 @@
       get sectors_url
       expect(response).to be_successful
     end
+
+    context "filtering" do
+      let!(:sectors) do
+        [
+          create(:sector, name: "Sector1", published: true),
+          create(:sector, name: "Sector2", published: true),
+          create(:sector, name: "Sector3", published: false),
+          create(:sector, name: "Sector4", published: false)
+        ]
+      end
+
+      it "returns all sectors without filters" do
+        get sectors_url
+        sectors.each { |sector| expect(response.body).to include(sector.name) }
+      end
+
+      it "returns only published sectors when published=true" do
+        get sectors_url, params: { published: "true" }
+        expect(response.body).to include("Sector1", "Sector2")
+        expect(response.body).not_to include("Sector3")
+        expect(response.body).not_to include("Sector4")
+      end
+
+      it "returns only unpublished sectors when published=false" do
+        get sectors_url, params: { published: "false" }
+        expect(response.body).to include("Sector3", "Sector4")
+        expect(response.body).not_to include("Sector1")
+        expect(response.body).not_to include("Sector2")
+      end
+
+      it "filters by name" do
+        get sectors_url, params: { sector_name: "Sector1" }
+        expect(response.body).to include("Sector1")
+        expect(response.body).not_to include("Sector2")
+        expect(response.body).not_to include("Sector3")
+        expect(response.body).not_to include("Sector4")
+      end
+    end
   end
 
   describe "GET /show" do

spec/requests/stories_spec.rb

@@ -66,6 +66,23 @@
         expect(response.body).not_to include(story_in_other_org.title)
       end
 
+      it "shows the empty-state message when no stories match" do
+        get stories_url(title: "no-such-story-zzz"), headers: { "Turbo-Frame" => "story_results" }
+        expect(response.body).to include("No stories found")
+      end
+
+      it "filters by title and body query together" do
+        match = Story.create!(base_attributes.merge(title: "Best Story Match", rhino_body: "healing through art", published: true))
+        title_only = Story.create!(base_attributes.merge(title: "Best Story Other", rhino_body: "something else", published: true))
+        body_only = Story.create!(base_attributes.merge(title: "Unrelated Tale", rhino_body: "healing through art", published: true))
+
+        get stories_url(title: "Best Story", query: "healing"), headers: { "Turbo-Frame" => "story_results" }
+
+        expect(response.body).to include(match.title)
+        expect(response.body).not_to include(title_only.title)
+        expect(response.body).not_to include(body_only.title)
+      end
+
       describe "external link handling" do
         let(:turbo_headers) { { "Turbo-Frame" => "story_results" } }
 

spec/requests/story_ideas_spec.rb

@@ -59,6 +59,19 @@
         get story_idea_url(create(:story_idea))
         expect(response).to be_successful
       end
+
+      it "renders the organization and creator as links" do
+        creator = create(:user)
+        creator_person = create(:person, user: creator)
+        org = create(:organization, name: "Community Arts Project")
+        story_idea = create(:story_idea, created_by: creator, organization: org)
+
+        get story_idea_url(story_idea)
+
+        page = Capybara.string(response.body)
+        expect(page).to have_link(org.name, href: organization_path(org))
+        expect(page).to have_link(creator.name, href: person_path(creator_person))
+      end
     end
 
     describe "GET /new" do
@@ -228,6 +241,29 @@
         get story_idea_url(story_idea)
         expect(response).to be_successful
       end
+
+      it "renders the organization as plain text and the creator as a link" do
+        person = create(:person, user: regular_user)
+        org = create(:organization, name: "Community Arts Project")
+        story_idea = create(:story_idea, created_by: regular_user, organization: org)
+
+        get story_idea_url(story_idea)
+
+        page = Capybara.string(response.body)
+        expect(page).to have_text(org.name)
+        expect(page).not_to have_link(org.name)
+        expect(page).to have_link(regular_user.name, href: person_path(person))
+      end
+
+      it "renders the creator as plain text when they have no person record" do
+        story_idea = create(:story_idea, created_by: regular_user)
+
+        get story_idea_url(story_idea)
+
+        page = Capybara.string(response.body)
+        expect(page).to have_text(regular_user.name)
+        expect(page).not_to have_link(regular_user.name)
+      end
     end
   end
 

spec/requests/workshop_logs_spec.rb

@@ -54,6 +54,79 @@
     clear_enqueued_jobs
   end
 
+  describe "GET /show" do
+    it "renders the organization as plain text and the creator as a link (non-admin)" do
+      person = create(:person, user: user)
+      create(:affiliation, person: person, organization: organization)
+      workshop_log = create(:workshop_log, created_by: user, organization: organization,
+                            workshop: workshop, windows_type: windows_type, workshop_held_on: 1.day.ago)
+
+      get workshop_log_path(workshop_log)
+
+      page = Capybara.string(response.body)
+      expect(page).to have_text(organization.name)
+      expect(page).not_to have_link(organization.name)
+      expect(page).to have_link(user.name, href: person_path(person))
+    end
+
+    it "renders the creator as plain text when they have no person record" do
+      workshop_log = create(:workshop_log, created_by: user, organization: organization,
+                            workshop: workshop, windows_type: windows_type, workshop_held_on: 1.day.ago)
+
+      get workshop_log_path(workshop_log)
+
+      page = Capybara.string(response.body)
+      expect(page).to have_text(user.name)
+      expect(page).not_to have_link(user.name)
+    end
+
+    it "shows the external title in the heading and beside the Workshop label when there is no workshop" do
+      workshop_log = create(:workshop_log, created_by: user, organization: organization,
+                            workshop: nil, windows_type: windows_type,
+                            external_workshop_title: "Community Mural Project", workshop_held_on: 1.day.ago)
+
+      get workshop_log_path(workshop_log)
+
+      page = Capybara.string(response.body)
+      expect(page).to have_css("h1", text: "Community Mural Project")
+      workshop_div = page.find("span", text: "Workshop:").ancestor("div", match: :first)
+      expect(workshop_div).to have_text("Community Mural Project")
+    end
+
+    it "shows the workshop name in the heading and both the workshop and external title when both are present" do
+      titled_workshop = create(:workshop, :published, title: "Healing Through Art", windows_type: windows_type)
+      workshop_log = create(:workshop_log, created_by: user, organization: organization,
+                            workshop: titled_workshop, windows_type: windows_type,
+                            external_workshop_title: "Guest-led Session", workshop_held_on: 1.day.ago)
+
+      get workshop_log_path(workshop_log)
+
+      page = Capybara.string(response.body)
+      expect(page).to have_css("h1", text: "Healing Through Art")
+      workshop_div = page.find("span", text: "Workshop:").ancestor("div", match: :first)
+      expect(workshop_div).to have_text("Healing Through Art")
+      expect(workshop_div).to have_text("Guest-led Session")
+    end
+
+    context "as an admin" do
+      let(:admin) { create(:user, :admin) }
+      before { sign_in admin }
+
+      it "renders the organization and creator as links" do
+        person = create(:person, user: user)
+        create(:affiliation, person: person, organization: organization)
+        workshop_log = create(:workshop_log, created_by: user, organization: organization,
+                              workshop: workshop, windows_type: windows_type, workshop_held_on: 1.day.ago)
+
+        get workshop_log_path(workshop_log)
+
+        page = Capybara.string(response.body)
+        expect(page).to have_link(organization.name, href: organization_path(organization))
+        expect(page).to have_link(user.name, href: person_path(person))
+      end
+    end
+  end
+
   describe "GET /index" do
     it "loads the index page successfully" do
       get workshop_logs_path