7 files changed, 360 insertions, 34 deletions

diff --git a/test/models/asset_license_test.rb b/test/models/asset_license_test.rb
new file mode 100644
index 0000000..9f2d04f
--- /dev/null
+++ b/test/models/asset_license_test.rb
@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class AssetLicenseTest < ActiveSupport::TestCase
+  test "find returns a populated entry for a known key" do
+    entry = AssetLicense.find("cc_by_4")
+
+    assert_equal "cc_by_4", entry.key
+    assert_equal "https://creativecommons.org/licenses/by/4.0/", entry.url
+    assert entry.requires_attribution
+    assert_equal "license", entry.style
+  end
+
+  test "find returns nil for an unknown or blank key" do
+    assert_nil AssetLicense.find("not_a_real_license")
+    assert_nil AssetLicense.find(nil)
+    assert_nil AssetLicense.find("")
+  end
+
+  test "keys includes every dictionary entry" do
+    assert_includes AssetLicense.keys, "cc0"
+    assert_includes AssetLicense.keys, "own_work"
+  end
+
+  test "a note-style entry has no attribution requirement and no url" do
+    entry = AssetLicense.find("own_work")
+
+    assert_not entry.requires_attribution
+    assert_nil entry.url
+    assert_equal "note", entry.style
+  end
+end
diff --git a/test/models/asset_test.rb b/test/models/asset_test.rb
index a1041e4..ab1cc5d 100644
--- a/test/models/asset_test.rb
+++ b/test/models/asset_test.rb
@@ -19,5 +19,38 @@ class AssetTest < ActiveSupport::TestCase
     assert_equal 0, draft.assets.length
     assert_equal 0, RelatedAsset.count
   end
-  
+
+  test "image? is true for supported image content types" do
+    assert Asset.new(:upload_content_type => "image/png").image?
+    assert Asset.new(:upload_content_type => "image/jpeg").image?
+  end
+
+  test "image? is false for non-image content types" do
+    assert_not Asset.new(:upload_content_type => "application/pdf").image?
+    assert_not Asset.new(:upload_content_type => nil).image?
+  end
+
+  test "license_key must be a known dictionary key" do
+    asset = Asset.new(:license_key => "not_a_real_license")
+    I18n.with_locale(:en) do
+      assert_not asset.valid?
+      assert_includes asset.errors[:license_key], "is not included in the list"
+    end
+  end
+
+  test "license_key may be blank" do
+    assert Asset.new(:license_key => nil).valid?
+  end  
+
+  test "pdf? is true only for application/pdf" do
+    assert Asset.new(:upload_content_type => "application/pdf").pdf?
+    assert_not Asset.new(:upload_content_type => "image/png").pdf?
+  end
+
+  test "show_credit? is false for a PDF even with every credit field present" do
+    asset = Asset.new(:name => "demo", :upload_content_type => "application/pdf",
+                       :creator => "Jane Doe", :source_url => "https://example.org", :license_key => "cc_by_4")
+    assert asset.has_credit?
+    assert_not asset.show_credit?
+  end
 end
diff --git a/test/models/helpers/content_helper_test.rb b/test/models/helpers/content_helper_test.rb
index a7ed478..c69ef4e 100644
--- a/test/models/helpers/content_helper_test.rb
+++ b/test/models/helpers/content_helper_test.rb
@@ -2,7 +2,127 @@ require 'test_helper'
 
 class ContentHelperTest < ActionView::TestCase
   test "weekday_abbr delegates through the current I18n locale" do
-    I18n.locale = :de
-    assert_equal "Mo", weekday_abbr(Time.parse("2026-07-06"))
+    I18n.with_locale(:de) do
+      assert_equal "Mo", weekday_abbr(Time.parse("2026-07-06"))
+    end
+  end
+
+  test "asset_credit returns nil for a nil asset" do
+    assert_nil asset_credit(nil)
+  end
+
+  test "asset_credit returns nil when creator, source, and license are all blank" do
+    assert_nil asset_credit(Asset.new(:name => "blank"))
+  end
+
+  test "asset_credit renders creator, source link, and license link when all are present" do
+    asset = Asset.new(:name => "demo", :creator => "Jane Doe",
+                       :source_url => "https://example.org/photo", :license_key => "cc_by_4")
+
+    result = I18n.with_locale(:en) { asset_credit(asset) }
+
+    assert_match %r{<a href="https://example.org/photo">Photo demo</a>}, result
+    assert_match "by Jane Doe", result
+    assert_match %r{<a href="https://creativecommons.org/licenses/by/4.0/">Licensed under CC BY 4.0</a>}, result
+  end
+
+  test "asset_credit falls back to plain text when source_url is blank" do
+    asset = Asset.new(:name => "demo", :creator => "Jane Doe", :license_key => "cc_by_4")
+    assert_no_match %r{<a href="[^"]*">Photo demo</a>}, I18n.with_locale(:en) { asset_credit(asset) }
+  end
+
+  test "asset_credit omits the 'by' clause when creator is blank" do
+    asset = Asset.new(:name => "demo", :source_url => "https://example.org/photo", :license_key => "cc_by_4")
+    assert_no_match "by ", I18n.with_locale(:en) { asset_credit(asset) }
+  end
+
+  test "a note-style license renders with no 'Licensed under' prefix and no link" do
+    asset = Asset.new(:name => "demo", :creator => "CCC", :license_key => "own_work")
+    result = I18n.with_locale(:en) { asset_credit(asset) }
+
+    assert_match "Own work", result
+    assert_no_match "Licensed under", result
+    assert_no_match "<a", result
+  end
+
+  test "asset_credit degrades gracefully when the license_key is no longer in the dictionary" do
+    asset = Asset.new(:name => "demo", :creator => "Jane Doe")
+    asset.license_key = "a_retired_key"
+
+    result = I18n.with_locale(:en) { asset_credit(asset) }
+
+    assert_match "Photo demo by Jane Doe", result
+    assert_no_match "Licensed under", result
+  end
+
+  test "headline_image renders nothing when no images are attached" do
+    node = Node.root.children.create!(:slug => "headline_image_empty_test")
+    @page = node.draft
+    assert_nil headline_image
+  end
+
+  test "headline_image renders the flagged headline asset" do
+    node = Node.root.children.create!(:slug => "headline_image_flagged_test")
+    asset = Asset.create!(:name => "flagged", :upload_content_type => "image/png")
+    node.draft.assets << asset
+    node.draft.related_assets.find_by(:asset_id => asset.id).update!(:headline => true)
+    @page = node.draft
+
+    assert_match "glightbox", headline_image
+  end
+
+  test "headline_image falls back to a gallery-open caption when no headline is flagged" do
+    node = Node.root.children.create!(:slug => "headline_image_no_flag_test")
+    asset = Asset.create!(:name => "unflagged", :upload_content_type => "image/png")
+    node.draft.assets << asset
+    @page = node.draft
+
+    I18n.with_locale(:en) { assert_match t(:open_gallery), headline_image }
+  end
+
+  test "headline_image renders a document card for a PDF headline, not a lightbox image" do
+    node = Node.root.children.create!(:slug => "headline_image_pdf_test")
+    asset = Asset.create!(:name => "Expert Opinion", :upload_content_type => "application/pdf")
+    node.draft.assets << asset
+    node.draft.related_assets.find_by(:asset_id => asset.id).update!(:headline => true)
+    @page = node.draft
+
+    result = headline_image
+
+    assert_match "headline_document_card", result
+    assert_match "Expert Opinion", result
+    assert_no_match "data-gallery", result
+  end
+
+  test "headline_image lists other attached PDFs below the headline" do
+    node = Node.root.children.create!(:slug => "headline_image_multi_pdf_test")
+    headline_pdf = Asset.create!(:name => "Main Filing", :upload_content_type => "application/pdf")
+    other_pdf = Asset.create!(:name => "Supplementary Exhibit", :upload_content_type => "application/pdf")
+    node.draft.assets << headline_pdf
+    node.draft.assets << other_pdf
+    node.draft.related_assets.find_by(:asset_id => headline_pdf.id).update!(:headline => true)
+    @page = node.draft
+
+    result = headline_image
+
+    assert_match "Main Filing", result
+    assert_match "Supplementary Exhibit", result
+    assert_match "headline_document_card", result
+    assert_match "related_documents_list", result
+  end
+
+  test "headline_image lists attached PDFs even with no headline chosen" do
+    node = Node.root.children.create!(:slug => "headline_image_pdf_no_headline_test")
+    pdf_a = Asset.create!(:name => "Document A", :upload_content_type => "application/pdf")
+    pdf_b = Asset.create!(:name => "Document B", :upload_content_type => "application/pdf")
+    node.draft.assets << pdf_a
+    node.draft.assets << pdf_b
+    @page = node.draft
+
+    result = headline_image
+
+    assert_no_match "headline_document_card", result
+    assert_match "Document A", result
+    assert_match "Document B", result
   end
 end
diff --git a/test/models/node_attach_asset_test.rb b/test/models/node_attach_asset_test.rb
new file mode 100644
index 0000000..cb5b60f
--- /dev/null
+++ b/test/models/node_attach_asset_test.rb
@@ -0,0 +1,107 @@
+require "test_helper"
+
+class NodeAttachAssetTest < ActiveSupport::TestCase
+
+  def setup
+    @user  = users(:quentin)
+    @other = users(:aaron)
+    @node  = Node.root.children.create!(:slug => "attach_asset_test")
+    @image = create_image_asset
+  end
+
+  test "attaches to a draft-only node" do
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 1, result[:attached]
+    assert_includes @node.draft.assets, @image
+  end
+
+  test "attaches to head when no draft is pending" do
+    @node.publish_draft!(@user)
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 1, result[:attached]
+    assert_includes @node.head.assets, @image
+  end
+
+  test "attaches to head and pending draft alike" do
+    @node.publish_draft!(@user)
+    @node.lock_for_editing!(@user)
+    @node.create_new_draft(@user)
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 2, result[:attached]
+    assert_includes @node.head.assets, @image
+    assert_includes @node.draft.assets, @image
+  end
+
+  test "attaches to all three lifecycle rows" do
+    @node.publish_draft!(@user)
+    @node.lock_for_editing!(@user)
+    @node.create_new_draft(@user)
+    @node.autosave!({ :title => "wip" }, @user)
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 3, result[:attached]
+    [@node.head, @node.draft, @node.autosave].each do |row|
+      assert_includes row.assets, @image
+    end
+  end
+
+  test "skips rows that already carry the asset" do
+    @node.draft.related_assets.create!(:asset => @image)
+    @node.publish_draft!(@user)
+    @node.lock_for_editing!(@user)
+    @node.create_new_draft(@user)
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 0, result[:attached]
+    assert_equal 2, result[:already]
+    assert_equal 1, @node.draft.related_assets.where(:asset_id => @image.id).count
+  end
+
+  test "refuses when another user holds the lock and writes nothing" do
+    @node.lock_for_editing!(@other)
+    assert_raises(LockedByAnotherUser) { @node.attach_asset!(@image, :user => @user) }
+    assert_empty @node.draft.assets.reload
+  end
+
+  test "proceeds when the attaching user holds the lock" do
+    @node.lock_for_editing!(@user)
+    result = @node.attach_asset!(@image, :user => @user)
+    assert_equal 1, result[:attached]
+  end
+
+  test "sets the headline when none exists" do
+    result = @node.attach_asset!(@image, :user => @user, :headline => true)
+    assert_equal :set, result[:headline]
+    assert_equal @image, @node.draft.headline_asset
+  end
+
+  test "keeps an existing headline and reports it" do
+    incumbent = create_image_asset
+    @node.draft.related_assets.create!(:asset => incumbent, :headline => true)
+    result = @node.attach_asset!(@image, :user => @user, :headline => true)
+    assert_equal :kept_existing, result[:headline]
+    assert_equal incumbent, @node.draft.reload.headline_asset
+    assert_includes @node.draft.assets, @image
+  end
+
+  test "declines the headline flag for ineligible asset types" do
+    plain = create_plain_asset
+    result = @node.attach_asset!(plain, :user => @user, :headline => true)
+    assert_equal :not_eligible, result[:headline]
+    assert_includes @node.draft.assets.reload, plain
+    assert_nil @node.draft.headline_asset
+  end
+
+  test "refuses nodes in the Trash" do
+    @node.trash!(@user)
+    assert_raises(ActiveRecord::RecordInvalid) { @node.attach_asset!(@image, :user => @user) }
+  end
+
+  private
+
+    def create_image_asset
+      Asset.create!(:name => "attach test image", :upload_content_type => "image/png")
+    end
+
+    def create_plain_asset
+      Asset.create!(:name => "attach test note", :upload_content_type => "text/plain")
+    end
+end
diff --git a/test/models/node_test.rb b/test/models/node_test.rb
index ab66f81..ba38340 100644
--- a/test/models/node_test.rb
+++ b/test/models/node_test.rb
@@ -268,7 +268,6 @@ class NodeTest < ActiveSupport::TestCase
     assert_equal "quentin", node.head.user.login
   end
   
-  
   test "update?" do
     Node.root.descendants.delete_all
     updates       = Node.root.children.create!( :slug => "updates" )
@@ -359,6 +358,16 @@ class NodeTest < ActiveSupport::TestCase
     assert_equal @user1, node.reload.lock_owner
   end
 
+  test "title reads from autosave when neither draft nor head exists yet" do
+    node = Node.root.children.create!(:slug => "title_autosave_only_test")
+    node.draft.destroy
+    node.update_column(:draft_id, nil)
+    node.lock_for_editing!(users(:quentin))
+    node.autosave!({ :title => "autosave-only title" }, users(:quentin))
+
+    assert_equal "autosave-only title", node.reload.title
+  end
+
   test "revert! is a safe no-op on a fresh node with only a draft" do
     node = create_node_with_draft
     node.lock_for_editing!(@user1)
@@ -537,30 +546,6 @@ class NodeTest < ActiveSupport::TestCase
     assert result.index(mine) < result.index(someone_elses_newer)
   end
 
-  test "recently_changed includes a node whose head was recently published" do
-    node = Node.root.children.create!(:slug => "recent_changed_published")
-    find_or_create_draft(node, @user1)
-    node.autosave!({:title => "v1"}, @user1)
-    node.save_draft!(@user1)
-    node.publish_draft!
-
-    assert_includes Node.recently_changed, node
-  end
-
-  test "recently_changed excludes a node only touched by locking or unlocking after an old publish" do
-    node = Node.root.children.create!(:slug => "recent_changed_lock_only")
-    find_or_create_draft(node, @user1)
-    node.autosave!({:title => "v1"}, @user1)
-    node.save_draft!(@user1)
-    node.publish_draft!
-    node.head.update_column(:updated_at, 20.days.ago)
-
-    node.lock_for_editing!(@user1)
-    node.unlock!
-
-    assert_not_includes Node.recently_changed, node
-  end
-
   test "autosave! carries over the current related assets to the newly created autosave row" do
     node = Node.root.children.create!(:slug => "autosave_asset_carryover_test")
     user = User.find_by_login("quentin")
diff --git a/test/models/page_test.rb b/test/models/page_test.rb
index 1f924f9..98a00d2 100644
--- a/test/models/page_test.rb
+++ b/test/models/page_test.rb
@@ -309,11 +309,15 @@ class PageTest < ActiveSupport::TestCase
 
     kept_asset    = Asset.create!(:upload_file_name => "kept.png", :upload_content_type => "image/png", :upload_file_size => 1)
     removed_asset = Asset.create!(:upload_file_name => "removed.pdf", :upload_content_type => "application/pdf", :upload_file_size => 1)
-    n.head.update_assets([kept_asset.id, removed_asset.id])
+    n.head.related_assets.delete_all
+    n.head.related_assets.create!(:asset_id => kept_asset.id, :position => 1)
+    n.head.related_assets.create!(:asset_id => removed_asset.id, :position => 2)
 
     d2 = find_or_create_draft(n, @user1)
     added_asset = Asset.create!(:upload_file_name => "added.png", :upload_content_type => "image/png", :upload_file_size => 1)
-    d2.update_assets([kept_asset.id, added_asset.id])
+    d2.related_assets.delete_all
+    d2.related_assets.create!(:asset_id => kept_asset.id, :position => 1)
+    d2.related_assets.create!(:asset_id => added_asset.id, :position => 2)
     d2.save!
 
     diff = d2.diff_against(n.head)
diff --git a/test/models/related_asset_test.rb b/test/models/related_asset_test.rb
index a739e6b..bb86ddb 100644
--- a/test/models/related_asset_test.rb
+++ b/test/models/related_asset_test.rb
@@ -1,8 +1,54 @@
 require 'test_helper'
 
-class RelatedImageTest < ActiveSupport::TestCase
-  # Replace this with your real tests.
-  test "the truth" do
-    assert true
+class RelatedAssetTest < ActiveSupport::TestCase
+  test "headline can be set on an image asset" do
+    node = Node.root.children.create!(:slug => "related_asset_headline_image_test")
+    asset = Asset.create!(:name => "photo", :upload_content_type => "image/png")
+    node.draft.assets << asset
+    related = node.draft.related_assets.find_by(:asset_id => asset.id)
+
+    related.headline = true
+    assert related.valid?
+  end
+
+  test "headline can be set on a PDF asset" do
+    node = Node.root.children.create!(:slug => "related_asset_headline_pdf_test")
+    asset = Asset.create!(:name => "expert opinion", :upload_content_type => "application/pdf")
+    node.draft.assets << asset
+    related = node.draft.related_assets.find_by(:asset_id => asset.id)
+
+    related.headline = true
+    assert related.valid?
+  end
+
+  test "headline cannot be set on a non-image, non-PDF asset" do
+    node = Node.root.children.create!(:slug => "related_asset_headline_text_test")
+    asset = Asset.create!(:name => "programme", :upload_content_type => "text/plain")
+    node.draft.assets << asset
+    related = node.draft.related_assets.find_by(:asset_id => asset.id)
+
+    related.headline = true
+    assert_not related.valid?
+    assert_includes related.errors[:headline], "can only be set on image or PDF assets"
+  end
+
+  test "the headline validation does not raise when asset is missing" do
+    related = RelatedAsset.new(:headline => true)
+    assert_not related.valid?
+  end
+
+  test "at most one headline per page is enforced at the database level" do
+    node = Node.root.children.create!(:slug => "related_asset_headline_uniqueness_test")
+    first  = Asset.create!(:name => "first", :upload_content_type => "image/png")
+    second = Asset.create!(:name => "second", :upload_content_type => "image/png")
+    node.draft.assets << first
+    node.draft.assets << second
+
+    node.draft.related_assets.find_by(:asset_id => first.id).update!(:headline => true)
+    second_related = node.draft.related_assets.find_by(:asset_id => second.id)
+
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      RelatedAsset.where(:id => second_related.id).update_all(:headline => true)
+    end
   end
 end