10 files changed, 405 insertions, 60 deletions

diff --git a/test/controllers/assets_controller_test.rb b/test/controllers/assets_controller_test.rb
index 5f5f6e5..f834541 100644
--- a/test/controllers/assets_controller_test.rb
+++ b/test/controllers/assets_controller_test.rb
@@ -4,17 +4,16 @@ class AssetsControllerTest < ActionController::TestCase
 
   def setup
     login_as :quentin
+    @existing_asset_ids = Asset.pluck(:id)
   end
 
   def teardown
-    # Clean up any files written to disk during tests
-    Dir.glob(Rails.root.join('public', 'system', 'uploads', 'test_*')).each do |dir|
+    (Asset.pluck(:id) - @existing_asset_ids).each do |id|
+      dir = Asset.upload_root.join(id.to_s)
+      raise "Refusing to delete #{dir} -- outside tmp/, Rails.env.test? may be false" unless
+        dir.to_s.start_with?(Rails.root.join("tmp").to_s)
       FileUtils.rm_rf(dir)
     end
-    # Remove uploads created for assets created during tests
-    Asset.where("upload_file_name IS NOT NULL").where("id > 1000000").each do |a|
-      FileUtils.rm_rf(Rails.root.join('public', 'system', 'uploads', a.id.to_s))
-    end
   end
 
   # --- index ---
@@ -64,15 +63,14 @@ class AssetsControllerTest < ActionController::TestCase
 
     # original and all four variants should exist on disk
     %w[original medium thumb headline large].each do |style|
-      path = Rails.root.join('public', 'system', 'uploads',
-                             asset.id.to_s, style, 'test_image.png')
+      path = asset.send(:file_path, style)
       assert File.exist?(path), "Expected #{style} variant at #{path}"
     end
   end
 
   # --- create with PDF ---
 
-  test "create asset with PDF upload generates only original" do
+  test "create asset with PDF upload generates rasterized variants" do
     uploaded = Rack::Test::UploadedFile.new(
       Rails.root.join('test', 'fixtures', 'files', 'test_document.pdf'),
       'application/pdf'
@@ -83,18 +81,14 @@ class AssetsControllerTest < ActionController::TestCase
     assert_response :redirect
 
     asset = Asset.last
-    assert_equal 'test_document.pdf', asset.upload_file_name
-    assert_equal 'application/pdf',   asset.upload_content_type
-
-    # only original should exist, no image variants
-    original_path = Rails.root.join('public', 'system', 'uploads',
-                                    asset.id.to_s, 'original', 'test_document.pdf')
+    original_path = asset.send(:file_path, :original)
     assert File.exist?(original_path), "Expected original at #{original_path}"
+    assert_equal 'test_document.pdf', File.basename(original_path)
 
     %w[medium thumb headline large].each do |style|
-      path = Rails.root.join('public', 'system', 'uploads',
-                             asset.id.to_s, style, 'test_document.pdf')
-      assert !File.exist?(path), "Expected no #{style} variant for PDF"
+      path = asset.send(:file_path, style)
+      assert File.exist?(path), "Expected a #{style} variant at #{path}"
+      assert_equal '.png', File.extname(path), "Expected #{style} variant to be a PNG, not a PDF"
     end
   end
 
@@ -137,7 +131,7 @@ class AssetsControllerTest < ActionController::TestCase
     )
     post :create, params: { asset: { name: 'To be deleted', upload: uploaded } }
     asset = Asset.last
-    upload_dir = Rails.root.join('public', 'system', 'uploads', asset.id.to_s)
+    upload_dir = asset.send(:upload_root).join(asset.id.to_s)
     assert Dir.exist?(upload_dir), "Upload directory should exist before destroy"
 
     assert_difference 'Asset.count', -1 do
diff --git a/test/controllers/nodes_controller_test.rb b/test/controllers/nodes_controller_test.rb
index ddc4565..b8f9278 100644
--- a/test/controllers/nodes_controller_test.rb
+++ b/test/controllers/nodes_controller_test.rb
@@ -514,12 +514,6 @@ class NodesControllerTest < ActionController::TestCase
     assert_includes assigns(:nodes), chaostreff_node
   end
 
-  test "recent combined with a search term does not raise an ambiguous column error" do
-    login_as :quentin
-    get :recent, params: { :q => "Zombies" }
-    assert_response :success
-  end
-
   test "drafts combined with a search term does not raise an ambiguous column error" do
     login_as :quentin
     get :drafts, params: { :q => "Zombies" }
diff --git a/test/controllers/pages_controller_test.rb b/test/controllers/pages_controller_test.rb
index 3879014..732869b 100644
--- a/test/controllers/pages_controller_test.rb
+++ b/test/controllers/pages_controller_test.rb
@@ -1,5 +1,72 @@
 require 'test_helper'
 
 class PagesControllerTest < ActionController::TestCase
-  # will be removed anyway
+  test "preview shows the autosave when a draft and an autosave both exist" do
+    login_as :quentin
+
+    node = Node.root.children.create!(:slug => "preview_retest")
+    node.draft.update!(:title => "draft title")
+    node.publish_draft!
+
+    node.draft
+    node.lock_for_editing!(users(:quentin))
+    node.autosave!({ :title => "draft title" }, users(:quentin))
+    node.save_draft!(users(:quentin))
+    node.autosave!({ :title => "autosave title" }, users(:quentin))
+
+    get :preview, params: { :id => node.draft_id }
+
+    assert_response :success
+    assert_match "autosave title", response.body
+  end
+
+  test "preview renders a headlined image on the autosave without crashing" do
+    login_as :quentin
+
+    node = Node.root.children.create!(:slug => "preview_retest_with_image")
+    node.lock_for_editing!(users(:quentin))
+    node.autosave!({ :title => "draft title" }, users(:quentin))
+    node.save_draft!(users(:quentin))
+    node.autosave!({ :title => "autosave title" }, users(:quentin))
+
+    asset = Asset.create!(:name => "test", :upload_content_type => "image/png")
+    node.autosave.related_assets.create!(:asset_id => asset.id, :position => 1, :headline => true)
+
+    get :preview, params: { :id => node.draft_id }
+
+    assert_response :success
+    assert_match "autosave title", response.body
+  end
+
+  test "preview shows the autosave when no draft exists at all" do
+    login_as :quentin
+
+    node = Node.root.children.create!(:slug => "preview_retest_no_draft")
+    node.draft.destroy
+    node.update_column(:draft_id, nil)
+
+    node.lock_for_editing!(users(:quentin))
+    node.autosave!({ :title => "autosave only title" }, users(:quentin))
+
+    asset = Asset.create!(:name => "test", :upload_content_type => "image/png")
+    node.autosave.related_assets.create!(:asset_id => asset.id, :position => 1)
+
+    get :preview, params: { :id => node.autosave_id }
+
+    assert_response :success
+    assert_match "autosave only title", response.body
+  end
+
+  test "preview shows head normally when there is no draft or autosave" do
+    login_as :quentin
+
+    node = Node.root.children.create!(:slug => "preview_retest_head_only")
+    node.draft.update!(:title => "head title")
+    node.publish_draft!
+
+    get :preview, params: { :id => node.head_id }
+
+    assert_response :success
+    assert_match "head title", response.body
+  end
 end
diff --git a/test/controllers/related_assets_controller_test.rb b/test/controllers/related_assets_controller_test.rb
index 9d20cbb..ced4b74 100644
--- a/test/controllers/related_assets_controller_test.rb
+++ b/test/controllers/related_assets_controller_test.rb
@@ -88,4 +88,75 @@ class RelatedAssetsControllerTest < ActionController::TestCase
     ordered_asset_ids = node.draft.reload.related_assets.map(&:asset_id)
     assert_equal [second.id, first.id], ordered_asset_ids
   end
+
+  test "update sets the headline flag" do
+    login_as :quentin
+    node = Node.root.children.create!(:slug => "related_assets_headline_test")
+    asset = Asset.create!(:name => "headline-photo", :upload_content_type => "image/png")
+    node.draft.assets << asset
+    related = node.draft.related_assets.find_by(:asset_id => asset.id)
+
+    patch :update, params: { :node_id => node.id, :id => related.id, :headline => "true" }
+
+    assert_response :success
+    assert related.reload.headline?
+  end
+
+  test "update with headline=true clears any previous headline on the same page" do
+    login_as :quentin
+    node = Node.root.children.create!(:slug => "related_assets_headline_swap_test")
+    first  = Asset.create!(:name => "first-headline", :upload_content_type => "image/png")
+    second = Asset.create!(:name => "second-headline", :upload_content_type => "image/png")
+    node.draft.assets << first
+    node.draft.assets << second
+
+    first_related  = node.draft.related_assets.find_by(:asset_id => first.id)
+    second_related = node.draft.related_assets.find_by(:asset_id => second.id)
+    first_related.update!(:headline => true)
+
+    patch :update, params: { :node_id => node.id, :id => second_related.id, :headline => "true" }
+
+    assert_response :success
+    assert_not first_related.reload.headline?
+    assert second_related.reload.headline?
+  end
+
+  test "update with headline=false clears the headline" do
+    login_as :quentin
+    node = Node.root.children.create!(:slug => "related_assets_headline_unset_test")
+    asset = Asset.create!(:name => "unset-headline", :upload_content_type => "image/png")
+    node.draft.assets << asset
+    related = node.draft.related_assets.find_by(:asset_id => asset.id)
+    related.update!(:headline => true)
+
+    patch :update, params: { :node_id => node.id, :id => related.id, :headline => "false" }
+
+    assert_response :success
+    assert_not related.reload.headline?
+  end
+
+  test "search includes PDF assets as headline-eligible candidates" do
+    login_as :quentin
+    node = Node.root.children.create!(:slug => "related_assets_search_pdf_test")
+    asset = Asset.create!(:name => "expert-opinion-searchable", :upload_content_type => "application/pdf")
+
+    get :search, params: { :node_id => node.id, :search_term => "expert-opinion-searchable" }
+
+    assert_response :success
+    ids = JSON.parse(response.body).map { |r| r["id"] }
+    assert_includes ids, asset.id
+  end
+
+  test "search matches by filename as well as name" do
+    login_as :quentin
+    node = Node.root.children.create!(:slug => "related_assets_search_filename_test")
+    asset = Asset.create!(:name => "Untitled", :upload_content_type => "application/pdf",
+                           :upload_file_name => "Stellungnahme_Patientendaten_Schutz.pdf")
+
+    get :search, params: { :node_id => node.id, :search_term => "Patientendaten" }
+
+    assert_response :success
+    ids = JSON.parse(response.body).map { |r| r["id"] }
+    assert_includes ids, asset.id
+  end
 end
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_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