trusty-cms 7.1.2 → 7.2

data/app/models/user.rb

@@ -1,3 +1,5 @@
+require 'trusty_cms/site_scope_auth_reporter'
+
 class User < ActiveRecord::Base
   has_many :pages, foreign_key: :created_by_id
   self.table_name = 'admins'
@@ -78,4 +80,15 @@ class User < ActiveRecord::Base
     errors.add :password, 'Complexity requirement not met. Length should be 12 characters and include: 1 uppercase, 1 lowercase, 1 digit and 1 special character.'
   end
 
+  # Observe-only instrument for the intermittent logout bug (issue #1040). This
+  # keeps Devise's exact (site-scoped) behavior — it returns the scoped lookup
+  # unchanged, so a mismatch still logs the user out exactly as before — and only
+  # reports when a valid user was excluded by the site scope. See
+  # TrustyCms::SiteScopeAuthReporter. The behavior-change fix is separate (PR #1041).
+  def self.serialize_from_session(key, salt)
+    record = to_adapter.get(key)
+    TrustyCms::SiteScopeAuthReporter.report_miss(key) if record.nil?
+    record if record && record.authenticatable_salt == salt
+  end
+
 end

data/lib/string_extensions/string_extensions.rb

@@ -14,8 +14,10 @@ class String
   end
 
   unless methods.include?('parameterize')
-    def parameterize(sep = '-')
-      remove_formatting.downcase.replace_whitespace(sep).collapse(sep)
+    def parameterize(separator = '-', preserve_case: false, locale: nil)
+      separator = '-' unless separator.is_a?(String)
+      slug = remove_formatting.replace_whitespace(separator).collapse(separator)
+      preserve_case ? slug : slug.downcase
     end
   end
 

data/lib/trusty_cms/site_scope_auth_reporter.rb

@@ -0,0 +1,108 @@
+module TrustyCms
+  # Observe-only telemetry for the intermittent CMS logout bug (diagnostic for
+  # issue #1040). It changes NO behavior.
+  #
+  # When the multi_site extension is active, `User` carries a site-scoped
+  # default_scope (an INNER JOIN on admins_sites for `Page.current_site`).
+  # Devise deserializes the session user every request through that scope, so if
+  # `current_site` points at a site the user is not assigned to, the lookup
+  # returns nil and the user is logged out. Because `current_site` is
+  # process-global mutable state shared across Puma threads, we suspect this is
+  # usually a race (the user IS on a site they belong to, but the global was
+  # clobbered by a concurrent request for another host).
+  #
+  # This reporter fires only when a session lookup misses BUT the user actually
+  # exists (unscoped) — i.e. a valid user was excluded by the site scope — and
+  # records enough context to tell a race from a genuine cross-site access or an
+  # unmatched-host fallback. It never raises into the auth path.
+  module SiteScopeAuthReporter
+    MESSAGE = 'CMS site-scope logout (possible current_site race)'.freeze
+
+    module_function
+
+    def report_miss(key)
+      return unless multi_site_scoped?
+
+      excluded = User.unscoped { User.to_adapter.get(key) }
+      return if excluded.nil? # ordinary unknown/expired session — not our bug
+
+      context = build_context(excluded)
+      Rails.logger.warn("[multi_site] #{MESSAGE} #{context.to_json}")
+      Honeybadger.notify(MESSAGE, context: context) if defined?(Honeybadger)
+      nil
+    rescue StandardError => e
+      # Telemetry must never break authentication.
+      Rails.logger.error("[multi_site] SiteScopeAuthReporter error: #{e.class}: #{e.message}")
+      nil
+    end
+
+    # Only meaningful when User is actually site-scoped by the multi_site
+    # extension; otherwise the scoped and unscoped lookups are identical.
+    def multi_site_scoped?
+      User.respond_to?(:is_site_scoped?) && User.is_site_scoped?
+    end
+
+    def build_context(user)
+      current = current_site
+      host = Thread.current[:trusty_request_host]
+      expected = expected_site_for(host)
+      site_ids = user.site_ids
+
+      {
+        user_id: user.id,
+        user_admin: user.admin?,
+        user_site_ids: site_ids,
+        current_site_id: current&.id,
+        current_site_name: current&.name,
+        current_site_domain_blank: current.present? && current.domain.blank?,
+        request_host: host,
+        expected_site_id: expected&.id,
+        expected_site_name: expected&.name,
+        classification: classify(site_ids, current, expected, host),
+        thread: Thread.current.object_id,
+        at: Time.now.utc.iso8601,
+      }
+    end
+
+    # race               -> user belongs to the host's site, but current_site is
+    #                       something else (the global was clobbered)
+    # genuine_cross_site -> user hit a host whose site they are not assigned to
+    # host_unmatched     -> request host matched no site (asset/unknown host);
+    #                       current_site falls back to the default site
+    # no_host_captured   -> ran outside a captured request (e.g. rake/console)
+    def classify(site_ids, current, expected, host)
+      return 'no_host_captured' if host.blank?
+      return 'host_unmatched' if expected.nil?
+      return 'race' if site_ids.include?(expected.id) && (current.nil? || site_ids.exclude?(current.id))
+      return 'genuine_cross_site' if site_ids.exclude?(expected.id)
+
+      'unknown'
+    end
+
+    def current_site
+      Page.current_site if Page.respond_to?(:current_site)
+    end
+
+    # Mirrors Site.find_for_host's matching but WITHOUT the Site.default /
+    # catchall fallback, so telemetry never creates a record and returns nil when
+    # the host matches no site (which is what drives the host_unmatched
+    # classification). A blank domain compiles to a regexp that matches every
+    # host, so blank domains are matched only by exact base_domain, never by the
+    # regexp.
+    def expected_site_for(host)
+      return nil if host.blank?
+
+      Site.all.detect do |site|
+        host == site.base_domain || domain_regexp_match?(site, host)
+      end
+    end
+
+    def domain_regexp_match?(site, host)
+      return false if site.domain.blank?
+
+      !(host =~ Regexp.compile(site.domain)).nil?
+    rescue RegexpError
+      false
+    end
+  end
+end

data/lib/trusty_cms/version.rb

@@ -1,3 +1,3 @@
 module TrustyCms
-  VERSION = '7.1.2'.freeze
+  VERSION = '7.2'.freeze
 end

data/package.json

@@ -22,7 +22,7 @@
     "tablesaw": "^3.1.2"
   },
   "devDependencies": {
-    "esbuild": "^0.25.0",
+    "esbuild": "^0.28.1",
     "stylelint": "^13.3.2",
     "stylelint-config-recommended": "^3.0.0",
     "stylelint-order": "^4.0.0",

data/spec/controllers/admin/assets_controller_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+require 'rack/test'
+
+# Exercises Admin::AssetsController, which overrides the ResourceController CRUD
+# with custom upload handling (process_uploaded_asset, maybe_compress,
+# failure_response, set_owner_or_editor). Uses the JSON/partial endpoints so the
+# specs don't depend on the asset-pipeline-heavy admin HTML layout. High-value
+# regression net for a Rails/Ruby upgrade — file uploads and content-type
+# negotiation are common breakage points.
+RSpec.describe Admin::AssetsController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:user) { create(:admin) }
+  let(:fixtures_path) { TrustyCms::Engine.root.join('spec', 'fixtures', 'files') }
+
+  before do
+    # approved_content_types derives from the AssetType registry, which is empty
+    # by default; register the canonical set (shared with asset_spec) so uploads
+    # of text/plain, images, etc. can be approved. See AssetTypeRegistry.
+    register_standard_asset_types
+
+    # public_url generation needs a host; controller specs don't set one on the
+    # Disk service the way a real request would.
+    @previous_active_storage_url_options = ActiveStorage::Current.url_options
+    ActiveStorage::Current.url_options = { host: 'test.host', protocol: 'http' }
+
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(user)
+  end
+
+  after do
+    ActiveStorage::Current.url_options = @previous_active_storage_url_options
+  end
+
+  # A plain stub (not an rspec double) so it can be assigned in an `around`
+  # hook, which runs outside the per-test double lifecycle. api_key: nil makes
+  # should_compress? false, so uploads skip Kraken compression.
+  around do |example|
+    original_kraken = defined?($kraken) ? $kraken : nil
+    $kraken = Struct.new(:api_key).new(nil)
+    example.run
+    $kraken = original_kraken
+  end
+
+  def upload(filename, content_type)
+    Rack::Test::UploadedFile.new(fixtures_path.join(filename), content_type)
+  end
+
+  describe 'POST #uploader' do
+    it 'returns the asset url when the upload succeeds' do
+      expect {
+        post :uploader, params: { upload: upload('sample.txt', 'text/plain') }, format: :json
+      }.to change(Asset, :count).by(1)
+
+      expect(response).to have_http_status(:ok)
+      expect(JSON.parse(response.body)).to have_key('url')
+    end
+
+    it 'records the uploading user as owner/editor' do
+      post :uploader, params: { upload: upload('sample.txt', 'text/plain') }, format: :json
+
+      asset = Asset.last
+      expect(asset.created_by_id).to eq(user.id)
+      expect(asset.updated_by_id).to eq(user.id)
+    end
+
+    it 'returns unsupported media type for disallowed content types' do
+      expect(Asset).not_to receive(:create)
+
+      post :uploader, params: { upload: upload('sample.txt', 'application/x-unsupported') }, format: :json
+
+      expect(response).to have_http_status(:unsupported_media_type)
+      expect(JSON.parse(response.body)['error']).to eq('Unsupported file type.')
+      expect(flash[:error]).to eq('Unsupported file type.')
+    end
+
+    it 'rejects the generic octet-stream content type with a notice' do
+      post :uploader, params: { upload: upload('sample.txt', 'application/octet-stream') }, format: :json
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(JSON.parse(response.body)['error']).to match(/valid extension/)
+      expect(flash[:notice]).to match(/valid extension/)
+    end
+
+    it 'returns unprocessable entity when no file is provided' do
+      post :uploader, params: {}, format: :json
+
+      expect(response).to have_http_status(:unprocessable_entity)
+      expect(JSON.parse(response.body)['error']).to eq('No file uploaded.')
+      expect(flash[:error]).to eq('No file uploaded.')
+    end
+  end
+
+  describe 'POST #create' do
+    it 'creates an asset from an uploaded file and redirects (HTML)' do
+      expect {
+        post :create, params: { asset: { asset: [upload('sample.txt', 'text/plain')] } }
+      }.to change(Asset, :count).by(1)
+
+      expect(response).to be_redirect
+    end
+
+    it 'redirects back to new with a flash error when the upload is unsupported' do
+      expect {
+        post :create, params: { asset: { asset: [upload('sample.txt', 'application/x-unsupported')] } }
+      }.not_to change(Asset, :count)
+
+      expect(response).to redirect_to(new_admin_asset_path)
+      expect(flash[:error]).to eq('Unsupported file type.')
+    end
+  end
+
+  describe 'DELETE #destroy' do
+    it 'destroys the asset and redirects' do
+      asset = Asset.create!(asset: upload('sample.txt', 'text/plain'), caption: '')
+
+      expect {
+        delete :destroy, params: { id: asset.id }
+      }.to change(Asset, :count).by(-1)
+
+      expect(response).to be_redirect
+    end
+  end
+end

data/spec/controllers/admin/changes_controller_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+# Exercises Admin::ChangesController, which builds a PaperTrail-backed diff view
+# of recent page changes. Controller specs (views not rendered) let us drive the
+# action and its private diff-building helpers without the admin HTML layout.
+# PaperTrail behaviour is a plausible upgrade casualty, so this pins it down.
+RSpec.describe Admin::ChangesController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:user) { create(:admin) }
+  let!(:site) { create(:site) }
+
+  before do
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(user)
+    # The multi-site extension (which provides #current_site) isn't loaded in the
+    # dummy app, so stub it to the site our fixtures are scoped to.
+    allow(controller).to receive(:current_site).and_return(site)
+  end
+
+  # Create a page scoped to the current site and give it a versioned change so
+  # the controller has something to diff.
+  def page_with_change
+    page = create(:home, title: 'Original', site_id: site.id)
+    PaperTrail.request(whodunnit: user.id.to_s) do
+      page.update!(title: 'Updated Title')
+    end
+    page
+  end
+
+  # rails-controller-testing (which provides `assigns`) isn't in the bundle, so
+  # read the controller's assigned ivars directly.
+  def changes
+    controller.instance_variable_get(:@changes)
+  end
+
+  describe 'GET #show' do
+    it 'succeeds and assigns recent changes' do
+      page_with_change
+
+      get :show
+
+      expect(response).to have_http_status(:ok)
+      expect(changes).to be_present
+    end
+
+    it 'loads a single change when a version_id is given' do
+      page = page_with_change
+      version = PaperTrail::Version.where(item_type: 'Page', item_id: page.id).last
+
+      get :show, params: { version_id: version.id }
+
+      expect(response).to have_http_status(:ok)
+      expect(changes.size).to eq(1)
+      expect(changes.first[:id]).to eq(version.id)
+    end
+
+    it 'reports an error when the version_id is unknown' do
+      get :show, params: { version_id: 0 }
+
+      expect(changes).to be_empty
+      expect(controller.instance_variable_get(:@change_error)).to eq('Version ID not found.')
+    end
+
+    it 'succeeds with no changes present' do
+      get :show
+
+      expect(response).to have_http_status(:ok)
+      expect(changes).to eq([])
+    end
+  end
+end

data/spec/controllers/admin/configuration_controller_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+# Exercises Admin::ConfigurationController, which batch-updates TrustyCms::Config
+# entries inside a transaction and is admin-gated. Config plumbing is easy to
+# break in a framework upgrade, so pin the happy path and the auth gate.
+RSpec.describe Admin::ConfigurationController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:admin) { create(:admin) }
+
+  before do
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(admin)
+  end
+
+  describe 'GET #show' do
+    it 'succeeds' do
+      get :show
+      expect(response).to have_http_status(:ok)
+    end
+  end
+
+  describe 'GET #edit' do
+    it 'succeeds for an admin' do
+      get :edit
+      expect(response).to have_http_status(:ok)
+    end
+  end
+
+  describe 'PUT #update' do
+    it 'persists the submitted config values and redirects to show' do
+      put :update, params: { trusty_config: { 'admin.title' => 'Renamed CMS' } }
+
+      expect(response).to redirect_to(action: :show)
+      expect(TrustyCms::Config['admin.title']).to eq('Renamed CMS')
+    end
+  end
+
+  describe 'authorization' do
+    it 'denies a non-admin access to edit' do
+      allow(controller).to receive(:current_user).and_return(create(:non_admin, email: 'plain@example.com'))
+
+      get :edit
+
+      expect(response).to be_redirect
+      expect(flash[:error]).to be_present
+    end
+  end
+end

data/spec/controllers/admin/page_attachments_controller_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'rack/test'
+
+# Exercises Admin::PageAttachmentsController, whose custom #load_model builds a
+# PageAttachment from an asset_id (+ optional page_id) and rescues a missing
+# asset. Controller spec (views not rendered) drives the action and its
+# before-action without needing the admin HTML layout.
+RSpec.describe Admin::PageAttachmentsController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:user) { create(:admin) }
+  let(:fixtures_path) { TrustyCms::Engine.root.join('spec', 'fixtures', 'files') }
+  let(:asset) do
+    Asset.create!(asset: Rack::Test::UploadedFile.new(fixtures_path.join('sample.txt'), 'text/plain'), caption: '')
+  end
+
+  before do
+    register_standard_asset_types # shared canonical AssetTypes (see AssetTypeRegistry)
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(user)
+  end
+
+  describe 'GET #new' do
+    it 'builds a PageAttachment for the asset with a new (unsaved) page' do
+      get :new, params: { asset_id: asset.id }
+
+      expect(response).to have_http_status(:ok)
+      model = controller.instance_variable_get(:@page_attachment)
+      expect(model).to be_a(PageAttachment)
+      expect(model.asset).to eq(asset)
+      expect(model.page).to be_a(Page).and be_new_record
+    end
+
+    it 'associates an existing page when a page_id is given' do
+      page = create(:home, title: 'Attach Target')
+
+      get :new, params: { asset_id: asset.id, page_id: page.id }
+
+      expect(controller.instance_variable_get(:@page)).to eq(page)
+    end
+
+    # NOTE: latent bug — load_model rescues a missing asset with
+    # `render nothing: true`, but the `nothing:` option was removed in Rails 5.1.
+    # It's now ignored, so Rails falls through to rendering the (nonexistent)
+    # `new` template and raises MissingTemplate instead of returning an empty
+    # body. Characterizing current behavior; the fix is `head :no_content`.
+    # This is exactly the kind of breakage a Rails 8 upgrade should clean up.
+    it 'raises MissingTemplate for a missing asset (broken rescue path)' do
+      expect {
+        get :new, params: { asset_id: 0 }
+      }.to raise_error(ActionView::MissingTemplate)
+    end
+  end
+end

data/spec/controllers/admin/pages_controller_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+# Exercises Admin::PagesController — the most heavily customized ResourceController
+# subclass (search, restore, per-site edit guards, meta-row setup, ordering).
+# Controller specs (views not rendered) let us drive the actions and their many
+# private helpers without the asset-pipeline-heavy admin HTML layout. This is the
+# highest-blast-radius controller in the app, so keep it green across the Rails 8 bump.
+RSpec.describe Admin::PagesController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:admin) { create(:admin) }
+  let!(:home) { create(:home, title: 'Home') }
+
+  before do
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(admin)
+    # #current_site / Page.current_site / Page.homepage come from the multi-site
+    # extension, which isn't loaded in the dummy app; stub the touch points.
+    allow(Page).to receive(:current_site).and_return(nil)
+    allow(Page).to receive(:homepage).and_return(home)
+  end
+
+  describe 'GET #index' do
+    it 'succeeds and sets up the site/homepage/search' do
+      get :index
+      expect(response).to have_http_status(:ok)
+      expect(controller.instance_variable_get(:@homepage)).to eq(home)
+    end
+  end
+
+  describe 'GET #new' do
+    it 'builds a new page with defaults' do
+      get :new
+      expect(response).to have_http_status(:ok)
+      page = controller.instance_variable_get(:@page)
+      expect(page).to be_a(Page).and be_new_record
+    end
+
+    it 'roots a top-level page at "/" when no parent is given' do
+      get :new
+      expect(controller.instance_variable_get(:@page).slug).to eq('/')
+    end
+
+    it 'sets the parent_id from page_id' do
+      get :new, params: { page_id: home.id }
+      expect(controller.instance_variable_get(:@page).parent_id).to eq(home.id)
+    end
+  end
+
+  describe 'GET #edit' do
+    context 'when the page belongs to a site the admin can access' do
+      let(:site) { create(:site) }
+      let(:page) { create(:page, title: 'Editable', parent: home, site_id: site.id) }
+
+      before { admin.sites << site }
+
+      it 'succeeds and loads edit assigns' do
+        get :edit, params: { id: page.id }
+
+        expect(response).to have_http_status(:ok)
+        expect(controller.instance_variable_get(:@page)).to eq(page)
+        expect(controller.instance_variable_get(:@page_url)).to be_present
+      end
+    end
+
+    context 'when the page belongs to a site the admin cannot access' do
+      let(:site) { create(:site) }
+      let(:page) { create(:page, title: 'Forbidden', parent: home, site_id: site.id) }
+
+      it 'redirects back to the pages index' do
+        get :edit, params: { id: page.id }
+        expect(response).to redirect_to(admin_pages_url)
+      end
+    end
+  end
+
+  describe 'POST #create' do
+    it 'creates a page and redirects' do
+      expect {
+        post :create, params: { page: { title: 'Fresh', slug: 'fresh', breadcrumb: 'Fresh', parent_id: home.id } }
+      }.to change(Page, :count).by(1)
+
+      expect(response).to be_redirect
+    end
+
+    it 're-renders new via the rescue_from validation_error handler when invalid' do
+      expect {
+        post :create, params: { page: { title: '', slug: '', breadcrumb: '', parent_id: home.id } }
+      }.not_to change(Page, :count)
+
+      expect(flash[:error]).to be_present
+    end
+  end
+
+  describe 'PUT #update' do
+    it 'updates the page and redirects' do
+      page = create(:page, title: 'Before', parent: home)
+
+      put :update, params: { id: page.id, page: { title: 'After' } }
+
+      expect(response).to be_redirect
+      expect(page.reload.title).to eq('After')
+    end
+  end
+
+  describe 'DELETE #destroy' do
+    it 'destroys the page and counts descendants' do
+      page = create(:page, title: 'Doomed', parent: home)
+
+      expect {
+        delete :destroy, params: { id: page.id }
+      }.to change(Page, :count).by(-1)
+
+      expect(response).to be_redirect
+    end
+  end
+
+  describe 'GET #search' do
+    it 'returns matching pages when a query is present' do
+      create(:page, title: 'Findable', slug: 'findable', parent: home)
+
+      get :search, params: { site_id: nil, search: { query: 'Findable' } }
+
+      expect(response).to have_http_status(:ok)
+      titles = controller.instance_variable_get(:@pages).map(&:title)
+      expect(titles).to include('Findable')
+    end
+
+    it 'does not run a query when none is given' do
+      get :search, params: { site_id: '' }
+      expect(controller.instance_variable_get(:@pages)).to be_nil
+    end
+  end
+
+  describe 'POST #save_table_position' do
+    it 'saves the new order and returns ok' do
+      allow(Page).to receive(:save_order)
+      post :save_table_position, params: { new_position: %w[1 2 3] }
+      expect(response).to have_http_status(:ok)
+      expect(Page).to have_received(:save_order).with(%w[1 2 3])
+    end
+  end
+
+  describe 'PUT #restore' do
+    # NOTE: latent bug / Rails 8 upgrade blocker — restore_page_version calls
+    # PaperTrail's `reify`, which YAML-loads the stored version. Under Psych 4+
+    # (psych 5.4 is pinned) safe-loading rejects ActiveSupport::TimeWithZone
+    # because no permitted classes are configured, so restoring any page that has
+    # a timestamp in its versioned state raises Psych::DisallowedClass. Page
+    # restore is effectively broken until paper_trail's serializer is configured
+    # with permitted classes (e.g. via ActiveRecord::Base.yaml_column_permitted_classes
+    # or a custom serializer). Characterizing current behavior.
+    it 'currently fails to reify a versioned page (Psych safe-load blocker)' do
+      page = create(:page, title: 'V1', parent: home)
+      PaperTrail.request(whodunnit: admin.id.to_s) { page.update!(title: 'V2') }
+
+      expect {
+        put :restore, params: { id: page.id, version_index: 1 }
+      }.to raise_error(Psych::DisallowedClass, /TimeWithZone/)
+    end
+  end
+end

data/spec/controllers/admin/preferences_controller_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+# Exercises Admin::PreferencesController, which lets the current user edit their
+# own profile/preferences. Simple ApplicationController subclass; covers the
+# show/edit render paths and the valid/invalid update branches.
+RSpec.describe Admin::PreferencesController, type: :controller do
+  routes { TrustyCms::Application.routes }
+
+  let(:admin) { create(:admin) }
+
+  before do
+    allow(controller).to receive(:authenticate_user!).and_return(true)
+    allow(controller).to receive(:current_user).and_return(admin)
+  end
+
+  describe 'GET #show' do
+    it 'succeeds' do
+      get :show
+      expect(response).to have_http_status(:ok)
+    end
+  end
+
+  describe 'GET #edit' do
+    it 'succeeds' do
+      get :edit
+      expect(response).to have_http_status(:ok)
+    end
+  end
+
+  describe 'PUT #update' do
+    it 'updates the current user and redirects to configuration' do
+      put :update, params: { user: { first_name: 'Preferred' } }
+
+      expect(response).to redirect_to(admin_configuration_path)
+      expect(admin.reload.first_name).to eq('Preferred')
+    end
+
+    it 're-renders edit with an error when the update is invalid' do
+      put :update, params: { user: { email: 'not-an-email' } }
+
+      expect(flash[:error]).to be_present
+    end
+  end
+end