9 files changed, 781 insertions, 14 deletions

diff --git a/test/models/concerns/rrule_humanizer_test.rb b/test/models/concerns/rrule_humanizer_test.rb
new file mode 100644
index 0000000..279ff73
--- /dev/null
+++ b/test/models/concerns/rrule_humanizer_test.rb
@@ -0,0 +1,99 @@
+require 'test_helper'
+
+class RruleHumanizerTest < ActiveSupport::TestCase
+  def humanize(rrule, locale = :de)
+    Event.new(rrule: rrule).humanize_rrule(locale)
+  end
+
+  test "weekly single day" do
+    assert_equal "Jeden Dienstag", humanize("FREQ=WEEKLY;BYDAY=TU")
+    assert_equal "Every Tuesday", humanize("FREQ=WEEKLY;BYDAY=TU", :en)
+  end
+
+  test "weekly two days" do
+    assert_equal "Jeden Mittwoch und Freitag", humanize("FREQ=WEEKLY;BYDAY=WE,FR")
+    assert_equal "Every Wednesday and Friday", humanize("FREQ=WEEKLY;BYDAY=WE,FR", :en)
+  end
+
+  test "weekly no byday" do
+    assert_equal "Wöchentlich", humanize("FREQ=WEEKLY")
+    assert_equal "Weekly", humanize("FREQ=WEEKLY", :en)
+  end
+
+  test "biweekly with day" do
+    assert_equal "Alle zwei Wochen donnerstags", humanize("FREQ=WEEKLY;INTERVAL=2;BYDAY=TH")
+    assert_equal "Every other Thursday", humanize("FREQ=WEEKLY;INTERVAL=2;BYDAY=TH", :en)
+  end
+
+  test "biweekly no day" do
+    assert_equal "Alle zwei Wochen", humanize("FREQ=WEEKLY;INTERVAL=2")
+    assert_equal "Every other week", humanize("FREQ=WEEKLY;INTERVAL=2", :en)
+  end
+
+  test "monthly nth weekday" do
+    assert_equal "Jeden ersten Dienstag im Monat", humanize("FREQ=MONTHLY;BYDAY=1TU")
+    assert_equal "Jeden zweiten Freitag im Monat", humanize("FREQ=MONTHLY;BYDAY=2FR")
+    assert_equal "Jeden dritten Sonntag im Monat", humanize("FREQ=MONTHLY;BYDAY=3SU")
+    assert_equal "Jeden letzten Mittwoch im Monat", humanize("FREQ=MONTHLY;BYDAY=-1WE")
+  end
+
+  test "monthly nth weekday english" do
+    assert_equal "Every first Tuesday of the month", humanize("FREQ=MONTHLY;BYDAY=1TU", :en)
+    assert_equal "Every last Wednesday of the month", humanize("FREQ=MONTHLY;BYDAY=-1WE", :en)
+  end
+
+  test "monthly second-to-last" do
+    assert_equal "Jeden vorletzten Donnerstag im Monat", humanize("FREQ=MONTHLY;BYDAY=-2TH")
+    assert_equal "Every second-to-last Thursday of the month", humanize("FREQ=MONTHLY;BYDAY=-2TH", :en)
+  end
+
+  test "monthly no byday" do
+    assert_equal "Monatlich", humanize("FREQ=MONTHLY")
+    assert_equal "Monthly", humanize("FREQ=MONTHLY", :en)
+  end
+
+  test "monthly with single excluded month" do
+    assert_equal "Jeden letzten Donnerstag im Monat, außer im Dezember",
+      humanize("FREQ=MONTHLY;BYDAY=-1TH;BYMONTH=1,2,3,4,5,6,7,8,9,10,11")
+    assert_equal "Every last Thursday of the month, except in December",
+      humanize("FREQ=MONTHLY;BYDAY=-1TH;BYMONTH=1,2,3,4,5,6,7,8,9,10,11", :en)
+  end
+
+  test "monthly excluding january" do
+    assert_equal "Jeden zweiten Mittwoch im Monat, außer im Januar",
+      humanize("FREQ=MONTHLY;BYMONTH=2,3,4,5,6,7,8,9,10,11,12;BYDAY=2WE")
+  end
+
+  test "blank rrule returns nil" do
+    assert_nil humanize(nil)
+    assert_nil humanize("")
+  end
+
+  test "count and until are not guessed at" do
+    assert_nil humanize("FREQ=MONTHLY;BYDAY=1WE;COUNT=36")
+    assert_nil humanize("FREQ=MONTHLY;BYDAY=1WE;UNTIL=20050105T222222Z")
+  end
+
+  test "unrecognized freq returns nil" do
+    assert_nil humanize("FREQ=YEARLY;BYMONTH=12")
+  end
+
+  test "falls back to english for unknown locale" do
+    assert_equal "Every Tuesday", humanize("FREQ=WEEKLY;BYDAY=TU", :fr)
+  end
+
+  test "wday_abbr returns the correct German abbreviation for each day" do
+    monday = Time.parse("2026-07-06") # confirmed Monday
+    assert_equal "Mo", RruleHumanizer.wday_abbr(monday, :de)
+    assert_equal "Di", RruleHumanizer.wday_abbr(monday + 1.day, :de)
+    assert_equal "Mi", RruleHumanizer.wday_abbr(monday + 2.days, :de)
+    assert_equal "Do", RruleHumanizer.wday_abbr(monday + 3.days, :de)
+    assert_equal "Fr", RruleHumanizer.wday_abbr(monday + 4.days, :de)
+    assert_equal "Sa", RruleHumanizer.wday_abbr(monday + 5.days, :de)
+    assert_equal "So", RruleHumanizer.wday_abbr(monday + 6.days, :de)
+  end
+
+  test "wday_abbr falls back to :de for an unrecognized locale" do
+    assert_equal "Mo", RruleHumanizer.wday_abbr(Time.parse("2026-07-06"), :fr)
+  end
+end
diff --git a/test/models/event_test.rb b/test/models/event_test.rb
index f310af8..e98605e 100644
--- a/test/models/event_test.rb
+++ b/test/models/event_test.rb
@@ -29,7 +29,6 @@ class EventTest < ActiveSupport::TestCase
         :longitude    => 13.378944,
         :rrule        => "FOOBAR",
         :allday       => false,
-        :custom_rrule => false,
         :node_id      => @cal_node.id
       )
     end
@@ -44,7 +43,6 @@ class EventTest < ActiveSupport::TestCase
       :longitude    => 13.378944,
       :rrule        => nil,
       :allday       => false,
-      :custom_rrule => false,
       :node_id      => @cal_node.id
     )
     
@@ -62,7 +60,6 @@ class EventTest < ActiveSupport::TestCase
       :longitude    => 13.378944,
       :rrule        => "FREQ=WEEKLY;INTERVAL=1",
       :allday       => false,
-      :custom_rrule => false,
       :node_id      => @cal_node.id
     )
     
@@ -74,17 +71,17 @@ class EventTest < ActiveSupport::TestCase
     
     assert_equal "2009-12-24T15:23:42".to_time, scoped_occurrences[51].start_time
     assert_equal "2009-12-24T20:05:23".to_time, scoped_occurrences[51].end_time
-    assert_equal @cal_node.event, scoped_occurrences[51].event
+    assert_equal @cal_node.events.first, scoped_occurrences[51].event
     assert_equal @cal_node, scoped_occurrences[51].node
     
     assert_equal "2009-03-19T15:23:42".to_time, scoped_occurrences[11].start_time
     assert_equal "2009-03-19T20:05:23".to_time, scoped_occurrences[11].end_time
-    assert_equal @cal_node.event, scoped_occurrences[11].event
+    assert_equal @cal_node.events.first, scoped_occurrences[11].event
     assert_equal @cal_node, scoped_occurrences[11].node
     
     assert_equal "2009-01-01T15:23:42".to_time, scoped_occurrences[0].start_time
     assert_equal "2009-01-01T20:05:23".to_time, scoped_occurrences[0].end_time
-    assert_equal @cal_node.event, scoped_occurrences[11].event
+    assert_equal @cal_node.events.first, scoped_occurrences[11].event
     assert_equal @cal_node, scoped_occurrences[11].node
   end
   
@@ -97,7 +94,6 @@ class EventTest < ActiveSupport::TestCase
       :longitude    => 13.378944,
       :rrule        => "FREQ=MONTHLY;INTERVAL=1;BYDAY=-1WE",
       :allday       => false,
-      :custom_rrule => true,
       :node_id      => @cal_node.id
     )
     
@@ -111,4 +107,4 @@ class EventTest < ActiveSupport::TestCase
     chaosradio_days = scoped_occurrences.map {|x| x.start_time.day}
     assert_equal expected_days, chaosradio_days
   end
-end
\ No newline at end of file
+end
diff --git a/test/models/helpers/admin_helper_test.rb b/test/models/helpers/admin_helper_test.rb
index 23d9f40..94e9861 100644
--- a/test/models/helpers/admin_helper_test.rb
+++ b/test/models/helpers/admin_helper_test.rb
@@ -1,4 +1,14 @@
 require 'test_helper'
 
 class AdminHelperTest < ActionView::TestCase
+  test "mtime_busted_path appends the file's real mtime as a query param" do
+    path = "/stylesheets/admin.css"
+    expected_mtime = File.mtime(Rails.public_path.join("stylesheets/admin.css")).to_i
+
+    assert_equal "#{path}?v=#{expected_mtime}", mtime_busted_path(path)
+  end
+
+  test "mtime_busted_path raises clearly for a missing file rather than silently omitting the version" do
+    assert_raises(RuntimeError) { mtime_busted_path("/stylesheets/does_not_exist.css") }
+  end
 end
diff --git a/test/models/helpers/content_helper_test.rb b/test/models/helpers/content_helper_test.rb
index 2da82d7..a7ed478 100644
--- a/test/models/helpers/content_helper_test.rb
+++ b/test/models/helpers/content_helper_test.rb
@@ -1,4 +1,8 @@
 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"))
+  end
 end
diff --git a/test/models/helpers/datetime_helper_test.rb b/test/models/helpers/datetime_helper_test.rb
new file mode 100644
index 0000000..a24e5d3
--- /dev/null
+++ b/test/models/helpers/datetime_helper_test.rb
@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class DatetimeHelperTest < ActionView::TestCase
+  test "relative_time_phrase pluralizes correctly in English and German" do
+    travel_to Time.zone.parse("2026-07-12 12:00:00") do
+      I18n.with_locale(:en) do
+        assert_equal "1 day ago", relative_time_phrase(1.day.ago)
+        assert_equal "3 days ago", relative_time_phrase(3.days.ago)
+      end
+      I18n.with_locale(:de) do
+        assert_equal "vor 1 Tag", relative_time_phrase(1.day.ago)
+        assert_equal "vor 3 Tagen", relative_time_phrase(3.days.ago)
+        assert_equal "vor 1 Monat", relative_time_phrase(30.days.ago)
+        assert_equal "vor 2 Monaten", relative_time_phrase(45.days.ago)
+        assert_equal "vor 2 Jahren", relative_time_phrase(2.years.ago)
+      end
+    end
+  end
+end
diff --git a/test/models/helpers/events_helper_test.rb b/test/models/helpers/events_helper_test.rb
index 2e7567e..0486b3e 100644
--- a/test/models/helpers/events_helper_test.rb
+++ b/test/models/helpers/events_helper_test.rb
@@ -1,4 +1,25 @@
 require 'test_helper'
 
 class EventsHelperTest < ActionView::TestCase
+  test "rrule_with_break_opportunities inserts a break opportunity after each semicolon" do
+    result = rrule_with_break_opportunities("FREQ=MONTHLY;BYMONTH=1,2,3;BYDAY=-1TH")
+    assert_equal "FREQ=MONTHLY;<wbr>BYMONTH=1,2,3;<wbr>BYDAY=-1TH", result
+    assert result.html_safe?
+  end
+
+  test "rrule_with_break_opportunities escapes HTML-significant characters" do
+    result = rrule_with_break_opportunities("FREQ=WEEKLY;BYDAY=<script>")
+    assert_no_match /<script>/, result
+    assert_match "&lt;script&gt;", result
+  end
+
+  test "rrule_with_break_opportunities returns an empty string for blank input" do
+    assert_equal "", rrule_with_break_opportunities(nil)
+    assert_equal "", rrule_with_break_opportunities("")
+  end
+
+  test "rrule_with_break_opportunities preserves a trailing semicolon" do
+    result = rrule_with_break_opportunities("FREQ=WEEKLY;")
+    assert_equal "FREQ=WEEKLY;<wbr>", result
+  end
 end
diff --git a/test/models/helpers/nodes_helper_test.rb b/test/models/helpers/nodes_helper_test.rb
index 13011de..5ab924f 100644
--- a/test/models/helpers/nodes_helper_test.rb
+++ b/test/models/helpers/nodes_helper_test.rb
@@ -1,4 +1,36 @@
 require 'test_helper'
 
 class NodesHelperTest < ActionView::TestCase
+  FakePage = Struct.new(:tag_list)
+
+  test "default_event_tag_mapping matches erfa-detail" do
+    page = FakePage.new(["erfa-detail"])
+    assert_equal ["erfa-detail", "open-day"], default_event_tag_mapping(page)
+  end
+
+  test "default_event_tag_mapping matches chaostreff-detail" do
+    page = FakePage.new(["chaostreff-detail"])
+    assert_equal ["chaostreff-detail", "open-day"], default_event_tag_mapping(page)
+  end
+
+  test "default_event_tag_mapping returns nil for unrelated tags" do
+    page = FakePage.new(["update"])
+    assert_nil default_event_tag_mapping(page)
+  end
+
+  test "default_event_tag_list is nil without a matching tag" do
+    page = FakePage.new([])
+    assert_nil default_event_tag_list(page)
+  end
+
+  test "sitemap_node_open? is false for a configured collapsed path" do
+    club = Node.root.children.create!(:slug => "club")
+    erfas = club.children.create!(:slug => "erfas")
+    assert_equal false, sitemap_node_open?(erfas)
+  end
+
+  test "sitemap_node_open? is true for anything not configured as collapsed" do
+    node = Node.root.children.create!(:slug => "sitemap_open_test")
+    assert_equal true, sitemap_node_open?(node)
+  end
 end
diff --git a/test/models/node_test.rb b/test/models/node_test.rb
index 514ba3f..91a4a6d 100644
--- a/test/models/node_test.rb
+++ b/test/models/node_test.rb
@@ -98,6 +98,7 @@ class NodeTest < ActiveSupport::TestCase
     assert_not_nil node.draft
     assert_nil node.draft.user
     assert_nil node.head
+    assert_nil node.autosave
   end
   
   def test_create_new_draft_of_published_page
@@ -110,15 +111,19 @@ class NodeTest < ActiveSupport::TestCase
     node.publish_draft!
     assert_not_nil node.find_or_create_draft( @user1 )
   end
-  
+
   def test_find_or_create_draft_if_draft_exists_and_is_owned_by_user
     node = Node.root.children.create :slug => "xyz"
     node.publish_draft!
-    
-    node.find_or_create_draft @user1
-    node.find_or_create_draft @user1
+
+    first_call  = node.find_or_create_draft @user1
+    second_call = node.find_or_create_draft @user1
+
+    assert_equal first_call, second_call
+    assert_equal 2, node.pages.count
+    assert_equal @user1, node.lock_owner
   end
-  
+
   def test_exception_if_draft_exists_but_locked_by_another_user
     node = Node.root.children.create :slug => "xyz"
     node.publish_draft!
@@ -280,6 +285,191 @@ class NodeTest < ActiveSupport::TestCase
     node = Node.root.children.create( :slug => "wow" )
     assert_nil node.draft.published_at
   end
+
+  test "lock_for_editing! acquires the lock without creating a draft or autosave" do
+    node = create_node_with_published_page
+
+    node.lock_for_editing!(@user1)
+
+    assert_equal @user1, node.lock_owner
+    assert_nil node.draft
+    assert_nil node.autosave
+  end
+
+  test "autosave! creates a buffer that never appears among a node's pages, leaving the draft untouched" do
+    node = create_node_with_draft
+    node.lock_for_editing!(@user1)
+    page_count_before = node.pages.count
+
+    node.autosave!({ :title => "in progress" }, @user1)
+    node.reload
+
+    assert_not_nil node.autosave
+    assert_nil node.autosave.node_id
+    assert_equal page_count_before, node.pages.count
+    assert_not_equal "in progress", node.draft.title
+  end
+
+  test "save_draft! promotes an autosave into an existing draft without creating a new revision" do
+    node = create_node_with_draft
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "in progress" }, @user1)
+    page_count_before = node.pages.count
+
+    node.save_draft!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_equal "in progress", node.draft.title
+    assert_equal page_count_before, node.pages.count
+  end
+
+  test "save_draft! promotes an autosave into a brand new, correctly-revisioned draft when none exists" do
+    node = create_node_with_published_page
+    head_revision = node.head.revision
+
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "updated version" }, @user1)
+    node.reload
+
+    assert_nil node.draft
+    assert_nil node.autosave.node_id
+
+    node.save_draft!(@user1)
+    node.reload
+
+    assert_not_nil node.draft
+    assert_equal head_revision + 1, node.draft.revision
+    assert_equal head_revision, node.head.revision
+    assert_nil node.autosave
+    assert_equal 2, node.pages.count
+    assert_equal node.head.user, node.draft.user
+    assert_equal @user1, node.draft.editor
+    assert_equal node.head.published_at, node.draft.published_at
+  end
+
+  test "autosave!, save_draft!, and lock_for_editing! raise LockedByAnotherUser for a second user" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+
+    assert_raise(LockedByAnotherUser) { node.autosave!({ :title => "x" }, @user2) }
+    assert_raise(LockedByAnotherUser) { node.save_draft!(@user2) }
+    assert_raise(LockedByAnotherUser) { node.lock_for_editing!(@user2) }
+
+    assert_equal @user1, node.reload.lock_owner
+  end
+
+  test "wipe_draft! leaves a fresh autosave and its lock untouched" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "still typing" }, @user1)
+
+    node.wipe_draft!
+    node.reload
+
+    assert_not_nil node.autosave
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "wipe_draft! destroys a stale, orphaned autosave and releases its lock" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "abandoned mid-session" }, @user1)
+    node.autosave.update_column(:updated_at, 2.days.ago)
+
+    node.wipe_draft!
+    node.reload
+
+    assert_nil node.autosave
+    assert_nil node.lock_owner
+  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)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_not_nil node.draft
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! discards an autosave on a fresh node without touching its only draft" do
+    node = create_node_with_draft
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "typing" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_not_nil node.draft
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! does nothing when a published node has no draft or autosave" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_not_nil node.head
+    assert_nil node.draft
+  end
+
+  test "revert! discards a fresh autosave and releases the lock when no draft exists" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "in progress" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_nil node.draft
+    assert_nil node.lock_owner
+  end
+
+  test "revert! destroys an existing draft and releases the lock" do
+    node = create_node_with_published_page
+    head_title = node.head.title
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "second version" }, @user1)
+    node.save_draft!(@user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.draft
+    assert_equal head_title, node.head.title
+    assert_nil node.lock_owner
+  end
+
+  test "revert! discards only the autosave when a draft survives beneath it" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+    node.autosave!({ :title => "second version" }, @user1)
+    node.save_draft!(@user1)
+    node.autosave!({ :title => "third version, still typing" }, @user1)
+
+    node.revert!(@user1)
+    node.reload
+
+    assert_nil node.autosave
+    assert_not_nil node.draft
+    assert_equal "second version", node.draft.title
+    assert_equal @user1, node.lock_owner
+  end
+
+  test "revert! raises LockedByAnotherUser for a non-owner" do
+    node = create_node_with_published_page
+    node.lock_for_editing!(@user1)
+
+    assert_raise(LockedByAnotherUser) { node.revert!(@user2) }
+    assert_equal @user1, node.reload.lock_owner
+  end
   
   def create_revisions node, count
     count.times do
@@ -287,4 +477,173 @@ class NodeTest < ActiveSupport::TestCase
       node.publish_draft!
     end
   end
+
+  test "available_layer_pairs matches the six-state table" do
+    node = Node.root.children.create!(:slug => "layer_pairs_test")
+    user = @user1 || User.find_by_login("aaron")
+
+    assert_equal [[:draft, :autosave]], (node.lock_for_editing!(user); node.autosave!({title: "v1"}, user); node.available_layer_pairs) # state F
+
+    node.save_draft!(user)
+    node.publish_draft!
+    assert_equal [], node.available_layer_pairs # state A
+
+    node.lock_for_editing!(user)
+    node.autosave!({title: "v2"}, user)
+    assert_equal [[:head, :autosave]], node.available_layer_pairs # state B
+
+    node.save_draft!(user)
+    assert_equal [[:head, :draft]], node.available_layer_pairs # state C
+
+    node.lock_for_editing!(user)
+    node.autosave!({title: "v3"}, user)
+    assert_equal [[:head, :draft], [:draft, :autosave]], node.available_layer_pairs # state D
+  end
+
+  test "publishing a staged move under one's own descendant is rejected, not allowed to crash" do
+    a = Node.root.children.create!(:slug => "cycle_guard_a")
+    b = a.children.create!(:slug => "cycle_guard_b")
+
+    a.staged_parent_id = b.id
+
+    assert_raises(ActiveRecord::RecordInvalid) { a.publish_draft! }
+
+    a.reload
+    assert_equal Node.root.id, a.parent_id
+  end
+
+  test "editor_search matches a partial substring, not just a whole word" do
+    node = Node.root.children.create!(:slug => "editor_search_substring_test")
+    node.find_or_create_draft(@user1)
+    node.draft.update(:title => "Biometrics Conference")
+    node.publish_draft!
+
+    assert_includes Node.editor_search("bio"), node
+    assert_includes Node.editor_search("Conf"), node
+  end
+
+  test "editor_search returns an empty relation for a blank term, not every node" do
+    assert_equal 0, Node.editor_search("").count
+    assert_equal 0, Node.editor_search(nil).count
+    assert_equal 0, Node.editor_search("   ").count
+  end
+
+  test "editor_search requires every word to match, but each word can match a different field" do
+    node = Node.root.children.create!(:slug => "editor_search_multiword_test")
+    node.find_or_create_draft(@user1)
+    node.draft.update(:title => "Backspace e.V. Bamberg", :abstract => "Spiegelgraben 41, 96052 Bamberg")
+    node.publish_draft!
+
+    assert_includes Node.editor_search("Backspace Spiegelgraben"), node
+    assert_equal 0, Node.editor_search("Backspace Nonexistentstreet").count
+  end
+
+  test "drafts_and_autosaves without a user sorts by recency only" do
+    older = Node.root.children.create!(:slug => "drafts_order_older")
+    older.find_or_create_draft(@user1)
+    newer = Node.root.children.create!(:slug => "drafts_order_newer")
+    newer.find_or_create_draft(@user1)
+
+    result = Node.drafts_and_autosaves.to_a
+    assert result.index(newer) < result.index(older)
+  end
+
+  test "drafts_and_autosaves with a user puts their own locked nodes first, regardless of recency" do
+    mine = Node.root.children.create!(:slug => "drafts_order_mine")
+    mine.lock_for_editing!(@user1)
+    mine.autosave!({:title => "mine"}, @user1)
+
+    someone_elses_newer = Node.root.children.create!(:slug => "drafts_order_theirs")
+    other_user = User.find_by_login("quentin")
+    someone_elses_newer.lock_for_editing!(other_user)
+    someone_elses_newer.autosave!({:title => "theirs"}, other_user)
+
+    result = Node.drafts_and_autosaves(current_user_id: @user1.id).to_a
+    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")
+    node.find_or_create_draft(@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")
+    node.find_or_create_draft(@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")
+    asset = Asset.create!(:name => "carryover-photo", :upload_content_type => "image/png")
+    node.draft.assets << asset
+
+    node.lock_for_editing!(user)
+    node.autosave!({:title => "v1"}, user)
+
+    assert_includes node.autosave.reload.assets, asset
+  end
+
+  test "autosave! does not reset assets already attached directly to an existing autosave" do
+    node = Node.root.children.create!(:slug => "autosave_asset_no_reset_test")
+    user = User.find_by_login("quentin")
+    original = Asset.create!(:name => "original-photo", :upload_content_type => "image/png")
+    extra = Asset.create!(:name => "extra-photo", :upload_content_type => "image/png")
+    node.draft.assets << original
+
+    node.lock_for_editing!(user)
+    node.autosave!({:title => "v1"}, user)
+    node.autosave.assets << extra
+
+    node.autosave!({:title => "v2"}, user)
+
+    assert_includes node.autosave.reload.assets, original
+    assert_includes node.autosave.reload.assets, extra
+  end
+
+  test "autosave! carries over other-locale translations to the newly created autosave row" do
+    node = Node.root.children.create!(:slug => "autosave_translation_carryover_test")
+    user = User.find_by_login("quentin")
+
+    Globalize.with_locale(:en) { node.draft.update!(:title => "English title") }
+
+    node.lock_for_editing!(user)
+    Globalize.with_locale(:de) { node.autosave!({:title => "German edit"}, user) }
+
+    autosave = node.autosave.reload
+    assert_includes autosave.translated_locales, :en
+    assert_equal "English title", Globalize.with_locale(:en) { autosave.title }
+    assert_equal "German edit",   Globalize.with_locale(:de) { autosave.title }
+  end
+
+  test "autosave! does not reset other-locale translations already attached directly to an existing autosave" do
+    node = Node.root.children.create!(:slug => "autosave_translation_no_reset_test")
+    user = User.find_by_login("quentin")
+
+    Globalize.with_locale(:en) { node.draft.update!(:title => "Original English title") }
+
+    node.lock_for_editing!(user)
+    Globalize.with_locale(:de) { node.autosave!({:title => "v1"}, user) }
+    Globalize.with_locale(:en) { node.autosave.update!(:title => "Edited directly on autosave") }
+
+    Globalize.with_locale(:de) { node.autosave!({:title => "v2"}, user) }
+
+    autosave = node.autosave.reload
+    assert_equal "Edited directly on autosave", Globalize.with_locale(:en) { autosave.title }
+    assert_equal "v2",                          Globalize.with_locale(:de) { autosave.title }
+  end
 end
diff --git a/test/models/page_test.rb b/test/models/page_test.rb
index afba8b5..24bc7c5 100644
--- a/test/models/page_test.rb
+++ b/test/models/page_test.rb
@@ -142,5 +142,232 @@ class PageTest < ActiveSupport::TestCase
     update        = updates2009.children.create!( :slug => "my-first-update" )
     assert_equal "update", update.draft.template_name
   end
-  
+
+  test "a page scheduled for future publication is not yet public even after being published" do
+    node = Node.root.children.create!(slug: "preview-scheduled-test")
+    draft = node.find_or_create_draft(@user1)
+    draft.title = "Scheduled test"
+    draft.published_at = 1.day.from_now
+    draft.save!
+    token = draft.ensure_preview_token!
+
+    node.publish_draft!
+    page = Page.find_by(preview_token: token)
+
+    assert_equal page.id, page.node.head_id
+    assert_not page.public?
+  end
+
+  test "a superseded page is no longer the head, even though it was once published" do
+    node = Node.root.children.create!(slug: "preview-superseded-test")
+    first_draft = node.find_or_create_draft(@user1)
+    first_draft.title = "First version"
+    first_draft.save!
+    first_token = first_draft.ensure_preview_token!
+    node.publish_draft!
+
+    second_draft = node.find_or_create_draft(@user1)
+    second_draft.title = "Second version"
+    second_draft.save!
+    node.publish_draft!
+
+    first_page = Page.find_by(preview_token: first_token)
+
+    assert_not_equal first_page.id, first_page.node.head_id
+    assert first_page.published_at.present?
+  end
+
+  test "clone_attributes_from preserves an unchanged locale's original timestamp" do
+    n = Node.root.children.create!(:slug => "clone_preserve_timestamp_test")
+    source = n.draft
+    Globalize.with_locale(:de) { source.update!(:title => "Deutscher Titel") }
+    Globalize.with_locale(:en) { source.update!(:title => "English Title") }
+
+    target = Page.create!
+    target.clone_attributes_from(source)
+    original_en_updated_at = target.translations.find_by(:locale => :en).updated_at
+
+    Globalize.with_locale(:de) { source.update!(:title => "Deutscher Titel (bearbeitet)") }
+    target.clone_attributes_from(source)
+
+    en_translation = target.translations.find_by(:locale => :en)
+    assert_equal "English Title", en_translation.title
+    assert_equal original_en_updated_at, en_translation.updated_at
+  end
+
+  test "clone_attributes_from gives a genuinely changed locale a fresh timestamp" do
+    n = Node.root.children.create!(:slug => "clone_fresh_timestamp_test")
+    source = n.draft
+    Globalize.with_locale(:de) { source.update!(:title => "Erste Version") }
+
+    target = Page.create!
+    target.clone_attributes_from(source)
+    original_de_updated_at = target.translations.find_by(:locale => :de).updated_at
+
+    Globalize.with_locale(:de) { source.update!(:title => "Zweite Version") }
+    target.clone_attributes_from(source)
+
+    de_translation = target.translations.find_by(:locale => :de)
+    assert_equal "Zweite Version", de_translation.title
+    assert_operator de_translation.updated_at, :>, original_de_updated_at
+  end
+
+  test "clone_attributes_from removes a locale no longer present in the source" do
+    n = Node.root.children.create!(:slug => "clone_removed_locale_test")
+    source = n.draft
+    Globalize.with_locale(:en) { source.update!(:title => "English Title") }
+
+    target = Page.create!
+    target.clone_attributes_from(source)
+    assert_includes target.translations.map(&:locale), :en
+
+    source.translations.where(:locale => :en).delete_all
+    target.clone_attributes_from(source)
+
+    assert_not_includes target.reload.translations.map(&:locale), :en
+  end
+
+  def test_diff_against_inline_keeps_tags_and_marks_only_the_changed_word
+    n = Node.root.children.create! :slug => "diff_against_test"
+    d = n.find_or_create_draft @user1
+    d.title = "Old heading"
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft @user1
+    d2.title = "New heading"
+    d2.save!
+
+    diff = d2.diff_against(n.head)
+
+    assert_match "<del>Old</del>", diff[:title]
+    assert_match "<ins>New</ins>", diff[:title]
+  end
+
+  def test_diff_against_side_by_side_returns_two_annotated_strings
+    n = Node.root.children.create! :slug => "diff_against_sbs_test"
+    d = n.find_or_create_draft @user1
+    d.title = "Old heading"
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft @user1
+    d2.title = "New heading"
+    d2.save!
+
+    old_html, new_html = d2.diff_against(n.head, view: :side_by_side)[:title]
+
+    assert_match "<del>Old</del>", old_html
+    assert_match "<ins>New</ins>", new_html
+  end
+
+  test "diff_against handles an inserted paragraph split without corrupting the document" do
+    n = Node.root.children.create! :slug => "paragraph_split_test"
+    d = n.find_or_create_draft @user1
+    d.body = "<p>Der Vortragsraum ist ab 19 Uhr geöffnet, der Zugang erfolgt über den Hinterhof.</p>"
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft @user1
+    d2.body = "<p>Der Vortragsraum ist ab 19 Uhr geöffnet,</p>\n<p>der Zugang erfolgt über den Hinterhof.</p>"
+    d2.save!
+
+    diff = d2.diff_against(n.head)
+    fragment = Nokogiri::HTML::DocumentFragment.parse(diff[:body])
+
+    assert_equal 2, fragment.css('ins.diff_structural').length
+    assert_match "der Zugang erfolgt über den Hinterhof.", fragment.text
+  end
+
+  test "diff_against reports tag and template changes" do
+    n = Node.root.children.create! :slug => "field_diff_test"
+    d = n.find_or_create_draft @user1
+    d.tag_list = "update"
+    d.template_name = "standard_template"
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft @user1
+    d2.tag_list = "update, pressemitteilung"
+    d2.template_name = "title_only"
+    d2.save!
+
+    diff = d2.diff_against(n.head)
+
+    assert_equal ["pressemitteilung"], diff[:tags][:added]
+    assert_equal [], diff[:tags][:removed]
+    assert diff[:template_name][:changed]
+    assert_equal "standard_template", diff[:template_name][:from]
+    assert_equal "title_only", diff[:template_name][:to]
+  end
+
+  test "diff_against reports added and removed assets by filename" do
+    n = Node.root.children.create! :slug => "asset_diff_test"
+    d = n.find_or_create_draft @user1
+    d.save!
+    n.publish_draft!
+
+    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])
+
+    d2 = n.find_or_create_draft @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.save!
+
+    diff = d2.diff_against(n.head)
+
+    assert_equal [added_asset], diff[:assets][:added]
+    assert_equal [removed_asset], diff[:assets][:removed]
+  end
+
+  test "diff_against with an explicit locale compares that locale's own translation on each side" do
+    n = Node.root.children.create!(:slug => "diff_locale_test")
+    d = n.find_or_create_draft(@user1)
+    Globalize.with_locale(:en) { d.update!(:title => "Old English") }
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft(@user1)
+    Globalize.with_locale(:en) { d2.update!(:title => "New English") }
+    d2.save!
+
+    diff = d2.diff_against(n.head, :locale => :en)
+
+    assert_match "<del>Old</del>", diff[:title]
+    assert_match "<ins>New</ins>", diff[:title]
+  end
+
+  test "diff_against with an explicit locale ignores content in other locales entirely" do
+    n = Node.root.children.create!(:slug => "diff_locale_isolation_test")
+    d = n.find_or_create_draft(@user1)
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft(@user1)
+    Globalize.with_locale(:de) { d2.update!(:title => "Nur Deutsch geändert") }
+    d2.save!
+
+    diff = d2.diff_against(n.head, :locale => :en)
+
+    assert_no_match(/Deutsch/, diff[:title])
+  end
+
+  test "locale_diff_summary flags a locale that only exists on one side as changed" do
+    n = Node.root.children.create!(:slug => "diff_locale_summary_test")
+    d = n.find_or_create_draft(@user1)
+    d.save!
+    n.publish_draft!
+
+    d2 = n.find_or_create_draft(@user1)
+    Globalize.with_locale(:en) { d2.update!(:title => "New English translation") }
+    d2.save!
+
+    summary = d2.locale_diff_summary(n.head)
+    en_entry = summary.find { |s| s[:locale] == :en }
+
+    assert en_entry[:changed]
+    refute en_entry[:exists_there]
+  end
 end