WIP: Add 'document_history' property

Whitehall stores change notes and editorial remarks _per edition_,
yet we're only planning to migrate the latest (published) edition
out of Content Publisher, for simplicity. So we imagine this
property will be used to form one large 'editorial remark' in
Whitehall (and potentially as one large entry in the public
changenote history too).

The TimelineEntry class is doing the heavy lifting here. I've
generally followed the same logic as _content_publisher_entry.html.erb
in deciding which properties to expose.

The way we're testing this behaviour (by layering edition upon
edition in a unit test) doesn't appear to have been done before,
as we were getting an Uninitialized Constant error on
`RevisionUpdater::Image`. Adding a `require_relative` to the
`RevisionUpdater` class worked around that.

Author: ChrisBAshton

app/models/whitehall_migration/document_export.rb

@@ -24,6 +24,32 @@ def self.export_to_hash(document)
       body: content_revision.contents["body"],
       tags: document.live_edition.revision.tags_revision.tags,
       political: document.live_edition.political?,
+      document_history: document_history(document),
     }
   end
+
+  def self.document_history(document)
+    timeline_entries = TimelineEntry.where(document:)
+      .includes(:created_by, :details)
+      .order(created_at: :desc)
+      .includes(:edition)
+
+    timeline_entries.map do |entry|
+      entry_content = if entry.internal_note? && entry.details
+                        entry.details.body
+                      elsif (entry.withdrawn? || entry.withdrawn_updated?) && entry.details
+                        entry.details.public_explanation
+                      end
+
+      {
+        edition_number: entry.edition.number,
+        entry_type: entry.entry_type,
+        date: entry.created_at.to_fs(:date),
+        time: entry.created_at.to_fs(:time),
+        backdated_to: entry.backdated? ? entry.revision.backdated_to.to_fs(:date) : nil,
+        user: entry.created_by.email,
+        entry_content:,
+      }
+    end
+  end
 end

lib/versioning/revision_updater.rb

@@ -1,5 +1,6 @@
 module Versioning
   class RevisionUpdater < BaseUpdater
+    require_relative "./revision_updater/image"
     include RevisionUpdater::Image
     include RevisionUpdater::FileAttachment
 

spec/models/whitehall_migration/document_export_spec.rb

@@ -113,5 +113,141 @@
 
       expect(described_class.export_to_hash(document)[:political]).to be(true)
     end
+
+    describe "the `document_history` property" do
+      let(:document) { instance_double(Document) }
+
+      it "includes internal notes" do
+        details = instance_double(InternalNote, body: "This is an internal note")
+        e = entry_double(
+          internal_note?: true,
+          details:,
+          entry_type: "internal_note",
+          edition: instance_double(Edition, number: 1),
+          created_by: instance_double(User, email: "example@gov.uk"),
+        )
+        stub_chain_with([e])
+
+        expect(described_class.document_history(document)).to eq([
+          {
+            edition_number: 1,
+            entry_type: "internal_note",
+            date: "2024-01-01",
+            time: "10:00",
+            backdated_to: nil,
+            user: "example@gov.uk",
+            entry_content: "This is an internal note",
+          },
+        ])
+      end
+
+      it "includes withdrawn/updated entries with public explanation" do
+        details = instance_double(Withdrawal, public_explanation: "Withdrawn explanation")
+        e = entry_double(
+          withdrawn_updated?: true,
+          details:,
+          entry_type: "withdrawn",
+          edition: instance_double(Edition, number: 2),
+          created_at: build_time(date: "2024-02-01", time: "11:00"),
+          created_by: instance_double(User, email: "withdrawn-author@gov.uk"),
+        )
+        stub_chain_with([e])
+
+        expect(described_class.document_history(document)).to eq([
+          {
+            edition_number: 2,
+            entry_type: "withdrawn",
+            date: "2024-02-01",
+            time: "11:00",
+            backdated_to: nil,
+            user: "withdrawn-author@gov.uk",
+            entry_content: "Withdrawn explanation",
+          },
+        ])
+      end
+
+      it "includes backdated entries (backdated_to on revision) with nil entry_content" do
+        backdated_to = Date.new(2022, 1, 1) # real Date; .to_fs(:date) -> "2022-01-01"
+        revision = instance_double(Revision, backdated_to:)
+
+        e = entry_double(
+          backdated?: true,
+          revision:,
+          entry_type: "published",
+          edition: instance_double(Edition, number: 5),
+          created_at: build_time(date: "2024-05-01", time: "14:00"),
+          created_by: instance_double(User, email: "backdated-author@gov.uk"),
+        )
+        stub_chain_with([e])
+
+        expect(described_class.document_history(document)).to eq([
+          {
+            edition_number: 5,
+            entry_type: "published",
+            date: "2024-05-01",
+            time: "14:00",
+            backdated_to: "2022-01-01",
+            user: "backdated-author@gov.uk",
+            entry_content: nil,
+          },
+        ])
+      end
+
+      it "returns entries ordered by created_at desc (we respect the chain's order)" do
+        newer = entry_double(
+          entry_type: "withdrawn",
+          withdrawn_updated?: true,
+          details: instance_double(Withdrawal, public_explanation: "Later"),
+          edition: instance_double(Edition, number: 2),
+          created_at: build_time(date: "2024-02-01", time: "11:00"),
+          created_by: instance_double(User, email: "b@gov.uk"),
+        )
+
+        older = entry_double(
+          internal_note?: true,
+          details: instance_double(InternalNote, body: "Earlier note"),
+          entry_type: "internal_note",
+          edition: instance_double(Edition, number: 1),
+          created_at: build_time(date: "2024-01-01", time: "10:00"),
+          created_by: instance_double(User, email: "a@gov.uk"),
+        )
+
+        # We hand back [newer, older] from the ordered chain
+        stub_chain_with([newer, older])
+
+        result = described_class.document_history(document)
+        expect(result.map { |h| h[:edition_number] }).to eq([2, 1])
+      end
+
+      def build_time(date:, time:)
+        t = instance_double(Time)
+        allow(t).to receive(:to_fs).with(:date).and_return(date)
+        allow(t).to receive(:to_fs).with(:time).and_return(time)
+        t
+      end
+
+      def stub_chain_with(entries)
+        # Simulate: TimelineEntry.where(document: doc).includes(...).order(...).includes(...)
+        allow(TimelineEntry).to receive(:where).with(document:).and_return(entries)
+        allow(entries).to receive(:includes).and_return(entries)
+        allow(entries).to receive(:order).with(created_at: :desc).and_return(entries)
+      end
+
+      def entry_double(overrides = {})
+        defaults = {
+          edition: instance_double(Edition, number: 1),
+          entry_type: "internal_note",
+          created_at: build_time(date: "2024-01-01", time: "10:00"),
+          created_by: instance_double(User, email: "example@gov.uk"),
+          details: nil,
+          internal_note?: false,
+          withdrawn?: false,
+          withdrawn_updated?: false,
+          backdated?: false,
+          revision: nil,
+        }
+        instance_double(TimelineEntry, **defaults.merge(overrides))
+      end
+    end
   end
 end