10 files changed, 372 insertions, 58 deletions

diff --git a/test/controllers/assets_controller_test.rb b/test/controllers/assets_controller_test.rb
index 5f5f6e5..05fc6de 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,19 +81,56 @@ 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
+
+  # --- create with attach ---
+
+  test "create with node_id attaches the asset to the node's draft" do
+    node = Node.root.children.create!(:slug => "asset_attach_target")
+
+    post :create, params: { asset: { name: 'Attach me' }, node_id: node.id }
+
+    assert_response :redirect
+    asset = Asset.last
+    assert_includes node.draft.assets.reload, asset
+    assert_match /attached/, flash[:notice]
+  end
+
+  test "create against a foreign-locked node keeps the asset but refuses the attach" do
+    node = Node.root.children.create!(:slug => "asset_attach_locked")
+    node.lock_for_editing!(users(:aaron))
+
+    assert_difference 'Asset.count', 1 do
+      post :create, params: { asset: { name: 'Orphaned for now' }, node_id: node.id }
     end
+
+    assert_empty node.draft.assets.reload
+    assert_equal node_path(node), flash[:locked_node_path]
+    assert_equal "aaron", flash[:locked_by]
+  end
+
+  test "create with headline against a page that has one keeps the incumbent and warns" do
+    node = Node.root.children.create!(:slug => "asset_attach_headline")
+    incumbent = Asset.create!(:name => 'Incumbent', :upload_content_type => 'image/png')
+    node.draft.related_assets.create!(:asset => incumbent, :headline => true)
+
+    uploaded = Rack::Test::UploadedFile.new(
+      Rails.root.join('test', 'fixtures', 'files', 'test_image.png'), 'image/png')
+    post :create, params: { asset: { name: 'Challenger', upload: uploaded },
+                            node_id: node.id, headline: "1" }
+
+    assert_includes node.draft.assets.reload, Asset.last
+    assert_equal incumbent, node.draft.reload.headline_asset
+    assert_equal node_path(node), flash[:headline_kept_path]
   end
 
   # --- edit ---
@@ -137,7 +172,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..d777108 100644
--- a/test/controllers/nodes_controller_test.rb
+++ b/test/controllers/nodes_controller_test.rb
@@ -79,6 +79,35 @@ class NodesControllerTest < ActionController::TestCase
     end
   end
 
+  test "create with asset_id attaches the asset to the new draft, as headline when asked" do
+    login_as :quentin
+    asset = Asset.create!(:name => 'Birth attachment', :upload_content_type => 'image/png')
+
+    post :create, params: { :kind => "generic", :parent_id => Node.root.id,
+                            :title => "Born Attached",
+                            :asset_id => asset.id, :asset_headline => "1" }
+
+    assert_response :redirect
+    node = Node.last
+    assert_includes node.draft.assets, asset
+    assert_equal asset, node.draft.headline_asset
+    assert_match /attached/, flash[:notice]
+  end
+
+  test "the attach notice survives the redirect into the editor" do
+    login_as :quentin
+    asset = Asset.create!(:name => 'Flash survivor', :upload_content_type => 'image/png')
+
+    post :create, params: { :kind => "generic", :parent_id => Node.root.id,
+                            :title => "Notice Carrier", :asset_id => asset.id }
+    assert_redirected_to edit_node_path(Node.last)
+
+    get :edit, params: { :id => Node.last.id }
+    assert_response :success
+    assert_match /attached/, flash[:notice]
+    assert_no_match /ready to edit/, flash[:notice]
+  end
+
   test "editing a node" do
     login_as :quentin
 
@@ -409,7 +438,7 @@ class NodesControllerTest < ActionController::TestCase
 
     get :show, params: { id: node.id }
     assert_response :success
-    assert_select "a", text: "add event"
+    assert_select "a", text: "Add event"
     assert_select "a[href*='tag_list=open-day']"
     assert_select "a[href*='auto_tag_source=erfa-detail']"
   end
@@ -420,7 +449,7 @@ class NodesControllerTest < ActionController::TestCase
 
     get :show, params: { id: node.id }
     assert_response :success
-    assert_select "a", text: "add event"
+    assert_select "a", text: "Add event"
     assert_select "a[href*='tag_list=']", count: 0
   end
 
@@ -514,12 +543,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 2384adc..ced4b74 100644
--- a/test/controllers/related_assets_controller_test.rb
+++ b/test/controllers/related_assets_controller_test.rb
@@ -134,4 +134,29 @@ class RelatedAssetsControllerTest < ActionController::TestCase
     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_test.rb b/test/models/asset_test.rb
index d246abe..ab1cc5d 100644
--- a/test/models/asset_test.rb
+++ b/test/models/asset_test.rb
@@ -41,4 +41,16 @@ class AssetTest < ActiveSupport::TestCase
   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 d6c7b43..c69ef4e 100644
--- a/test/models/helpers/content_helper_test.rb
+++ b/test/models/helpers/content_helper_test.rb
@@ -79,4 +79,50 @@ class ContentHelperTest < ActionView::TestCase
 
     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 710b4cc..bb86ddb 100644
--- a/test/models/related_asset_test.rb
+++ b/test/models/related_asset_test.rb
@@ -11,15 +11,25 @@ class RelatedAssetTest < ActiveSupport::TestCase
     assert related.valid?
   end
 
-  test "headline cannot be set on a non-image asset" do
+  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 => "programme", :upload_content_type => "application/pdf")
+    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 assets"
+    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