<%= if MapSet.member?(@pending_files, file["id"]) do %>
- |
+ |
|
<% else %>
@@ -1415,6 +1481,9 @@ defmodule PhoenixKitDocumentCreator.Web.DocumentsLive do
{gettext("unfiled")}
+
+ {format_deleted_info(file["data"]["deleted"], @deleted_by_names)}
+ |
{format_time(file["modifiedTime"])} |
@@ -1653,6 +1722,25 @@ defmodule PhoenixKitDocumentCreator.Web.DocumentsLive do
end
end
+ # Formats the "Deleted" display: " · " or "—" when
+ # no deletion metadata is present.
+ defp format_deleted_info(nil, _names), do: "—"
+
+ defp format_deleted_info(%{"at" => at_iso} = deleted, names) do
+ by_uuid = Map.get(deleted, "by_uuid")
+ name = if by_uuid, do: Map.get(names, by_uuid, gettext("unknown")), else: gettext("unknown")
+
+ formatted_at =
+ case DateTime.from_iso8601(at_iso) do
+ {:ok, dt, _} -> Calendar.strftime(dt, "%b %d, %Y")
+ _ -> at_iso
+ end
+
+ "#{formatted_at} · #{name}"
+ end
+
+ defp format_deleted_info(_deleted, _names), do: "—"
+
defp sanitize_filename(name) do
name
|> to_string()
diff --git a/test/documents/composed_document_test.exs b/test/documents/composed_document_test.exs
index 47fc9fa..4093121 100644
--- a/test/documents/composed_document_test.exs
+++ b/test/documents/composed_document_test.exs
@@ -134,6 +134,36 @@ defmodule PhoenixKitDocumentCreator.Documents.ComposedDocumentTest do
end
end
+ describe "create_composed_document/2 — data field" do
+ test "data: opt is stored on the created Document" do
+ t1 = insert_template!(google_doc_id: "tmpl-data1", published: true)
+ section = %{template_uuid: t1.uuid, position: 0, variable_values: %{}, image_params: %{}}
+ recipe = %{"category_uuid" => "cat-1", "template_uuids" => [t1.uuid]}
+
+ assert {:ok, %Document{} = doc} =
+ Documents.create_composed_document([section],
+ created_by_uuid: Ecto.UUID.generate(),
+ name: "With data",
+ data: %{"recreate_recipe" => recipe}
+ )
+
+ assert doc.data == %{"recreate_recipe" => recipe}
+ end
+
+ test "data defaults to empty map when opt is omitted" do
+ t1 = insert_template!(google_doc_id: "tmpl-nodata1", published: true)
+ section = %{template_uuid: t1.uuid, position: 0, variable_values: %{}, image_params: %{}}
+
+ assert {:ok, %Document{} = doc} =
+ Documents.create_composed_document([section],
+ created_by_uuid: Ecto.UUID.generate(),
+ name: "No data"
+ )
+
+ assert doc.data == %{}
+ end
+ end
+
describe "create_composed_document/2 — validation" do
test "returns error for empty sections" do
assert {:error, :empty_sections} =
diff --git a/test/errors_test.exs b/test/errors_test.exs
index 6591c8b..b741488 100644
--- a/test/errors_test.exs
+++ b/test/errors_test.exs
@@ -17,6 +17,8 @@ defmodule PhoenixKitDocumentCreator.ErrorsTest do
{:create_folder_failed, "Failed to create the Drive folder"},
{:deleted_folder_not_found, "Deleted folder not found"},
{:documents_folder_not_found, "Documents folder not found"},
+ {:drive_file_not_found,
+ "File is missing in Google Drive — it cannot be restored. You can permanently delete this record."},
{:file_trashed, "File is in the Drive trash"},
{:folder_not_found, "Folder not found"},
{:folder_search_failed, "Failed to search Drive for the folder"},
diff --git a/test/integration/drive_bound_actions_test.exs b/test/integration/drive_bound_actions_test.exs
index fb503b0..4f2ab55 100644
--- a/test/integration/drive_bound_actions_test.exs
+++ b/test/integration/drive_bound_actions_test.exs
@@ -12,6 +12,8 @@ defmodule PhoenixKitDocumentCreator.Integration.DriveBoundActionsTest do
use PhoenixKitDocumentCreator.DataCase, async: false
alias PhoenixKitDocumentCreator.Documents
+ alias PhoenixKitDocumentCreator.Schemas.Document
+ alias PhoenixKitDocumentCreator.Schemas.Template
alias PhoenixKitDocumentCreator.Test.Repo, as: TestRepo
alias PhoenixKitDocumentCreator.Test.StubIntegrations
@@ -136,6 +138,78 @@ defmodule PhoenixKitDocumentCreator.Integration.DriveBoundActionsTest do
end
end
+ describe "delete_document/2 — data[\"deleted\"] stamping" do
+ test "stamps data[deleted] with at and by_uuid when a DB record exists" do
+ actor_uuid = Ecto.UUID.generate()
+ file_id = "drv-doc-del-data-1"
+
+ {:ok, _} = Documents.register_existing_document(%{google_doc_id: file_id, name: "Doc"})
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.delete_document(file_id, actor_uuid: actor_uuid)
+
+ record = TestRepo.get_by!(Document, google_doc_id: file_id)
+ assert %{"deleted" => deleted} = record.data
+ assert deleted["by_uuid"] == actor_uuid
+ assert is_binary(deleted["at"])
+ assert {:ok, _dt, _} = DateTime.from_iso8601(deleted["at"])
+ end
+
+ test "stamps data[deleted] with nil by_uuid when no actor_uuid given" do
+ file_id = "drv-doc-del-data-2"
+
+ {:ok, _} = Documents.register_existing_document(%{google_doc_id: file_id, name: "Doc"})
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.delete_document(file_id)
+
+ record = TestRepo.get_by!(Document, google_doc_id: file_id)
+ assert %{"deleted" => deleted} = record.data
+ assert is_nil(deleted["by_uuid"])
+ end
+
+ test "preserves other data keys when stamping deleted" do
+ file_id = "drv-doc-del-data-3"
+ actor_uuid = Ecto.UUID.generate()
+
+ {:ok, doc} = Documents.register_existing_document(%{google_doc_id: file_id, name: "Doc"})
+ # Manually set an existing data key that must survive the delete stamp.
+ TestRepo.update!(Document.changeset(doc, %{data: %{"recipe" => "preserved"}}))
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.delete_document(file_id, actor_uuid: actor_uuid)
+
+ record = TestRepo.get_by!(Document, google_doc_id: file_id)
+ assert record.data["recipe"] == "preserved"
+ assert is_map(record.data["deleted"])
+ end
+ end
+
+ describe "delete_template/2 — data[\"deleted\"] stamping" do
+ test "stamps data[deleted] with at and by_uuid when a DB record exists" do
+ actor_uuid = Ecto.UUID.generate()
+ file_id = "drv-tpl-del-data-1"
+
+ {:ok, _} = Documents.register_existing_template(%{google_doc_id: file_id, name: "Tpl"})
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.delete_template(file_id, actor_uuid: actor_uuid)
+
+ record = TestRepo.get_by!(Template, google_doc_id: file_id)
+ assert %{"deleted" => deleted} = record.data
+ assert deleted["by_uuid"] == actor_uuid
+ assert is_binary(deleted["at"])
+ end
+ end
+
describe "restore_document/2 — happy path" do
test "logs document.restored on :ok" do
actor_uuid = Ecto.UUID.generate()
@@ -168,6 +242,60 @@ defmodule PhoenixKitDocumentCreator.Integration.DriveBoundActionsTest do
end
end
+ describe "restore_document/2 — data[\"deleted\"] clearing" do
+ test "clears data[deleted] on restore when DB record exists" do
+ actor_uuid = Ecto.UUID.generate()
+ file_id = "drv-doc-restore-data-1"
+
+ {:ok, doc} = Documents.register_existing_document(%{google_doc_id: file_id, name: "Doc"})
+
+ TestRepo.update!(
+ Document.changeset(doc, %{
+ data: %{
+ "deleted" => %{"at" => "2025-01-01T00:00:00Z", "by_uuid" => actor_uuid},
+ "recipe" => "preserved"
+ }
+ })
+ )
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.restore_document(file_id, actor_uuid: actor_uuid)
+
+ record = TestRepo.get_by!(Document, google_doc_id: file_id)
+ refute Map.has_key?(record.data, "deleted")
+ assert record.data["recipe"] == "preserved"
+ end
+ end
+
+ describe "restore_template/2 — data[\"deleted\"] clearing" do
+ test "clears data[deleted] on restore when DB record exists" do
+ actor_uuid = Ecto.UUID.generate()
+ file_id = "drv-tpl-restore-data-1"
+
+ {:ok, tpl} = Documents.register_existing_template(%{google_doc_id: file_id, name: "Tpl"})
+
+ TestRepo.update!(
+ Template.changeset(tpl, %{
+ data: %{
+ "deleted" => %{"at" => "2025-01-01T00:00:00Z", "by_uuid" => actor_uuid},
+ "recipe" => "preserved"
+ }
+ })
+ )
+
+ stub_folder_resolution!()
+ stub_drive_move!(file_id)
+
+ assert :ok = Documents.restore_template(file_id, actor_uuid: actor_uuid)
+
+ record = TestRepo.get_by!(Template, google_doc_id: file_id)
+ refute Map.has_key?(record.data, "deleted")
+ assert record.data["recipe"] == "preserved"
+ end
+ end
+
describe "export_pdf/2 — happy path" do
test "logs document.exported_pdf on :ok with size_bytes" do
actor_uuid = Ecto.UUID.generate()
@@ -275,6 +403,63 @@ defmodule PhoenixKitDocumentCreator.Integration.DriveBoundActionsTest do
end
end
+ # ── Drive 404 handling ─────────────────────────────────────────────────
+
+ describe "restore_document/2 — Drive 404 (file deleted from Drive)" do
+ test "returns {:error, :drive_file_not_found} when GET parents returns 404" do
+ file_id = "drv-doc-404-get"
+ stub_folder_resolution!()
+
+ StubIntegrations.stub_request(
+ :get,
+ ~r{/drive/v3/files/#{Regex.escape(file_id)}(\?|$)},
+ {:ok,
+ %{status: 404, body: %{"error" => %{"code" => 404, "message" => "File not found."}}}}
+ )
+
+ assert {:error, :drive_file_not_found} =
+ Documents.restore_document(file_id, actor_uuid: Ecto.UUID.generate())
+ end
+
+ test "returns {:error, :drive_file_not_found} when PATCH move returns 404" do
+ file_id = "drv-doc-404-patch"
+ stub_folder_resolution!()
+
+ StubIntegrations.stub_request(
+ :get,
+ ~r{/drive/v3/files/#{Regex.escape(file_id)}(\?|$)},
+ {:ok, %{status: 200, body: %{"id" => file_id, "parents" => ["old-parent"]}}}
+ )
+
+ StubIntegrations.stub_request(
+ :patch,
+ "/drive/v3/files/#{file_id}",
+ {:ok,
+ %{status: 404, body: %{"error" => %{"code" => 404, "message" => "File not found."}}}}
+ )
+
+ assert {:error, :drive_file_not_found} =
+ Documents.restore_document(file_id, actor_uuid: Ecto.UUID.generate())
+ end
+ end
+
+ describe "restore_template/2 — Drive 404 (file deleted from Drive)" do
+ test "returns {:error, :drive_file_not_found} when Drive returns 404" do
+ file_id = "drv-tpl-404"
+ stub_folder_resolution!()
+
+ StubIntegrations.stub_request(
+ :get,
+ ~r{/drive/v3/files/#{Regex.escape(file_id)}(\?|$)},
+ {:ok,
+ %{status: 404, body: %{"error" => %{"code" => 404, "message" => "File not found."}}}}
+ )
+
+ assert {:error, :drive_file_not_found} =
+ Documents.restore_template(file_id, actor_uuid: Ecto.UUID.generate())
+ end
+ end
+
# ── Test stub helpers ─────────────────────────────────────────────────
# `Documents.create_template/2` (and friends) call `get_folder_ids/0` →
diff --git a/test/phoenix_kit_document_creator/google_docs_client_phase_test.exs b/test/phoenix_kit_document_creator/google_docs_client_phase_test.exs
new file mode 100644
index 0000000..8652ba0
--- /dev/null
+++ b/test/phoenix_kit_document_creator/google_docs_client_phase_test.exs
@@ -0,0 +1,259 @@
+defmodule PhoenixKitDocumentCreator.GoogleDocsClientPhaseTest do
+ use ExUnit.Case, async: true
+ alias PhoenixKitDocumentCreator.GoogleDocsClient
+
+ # ---------------------------------------------------------------------------
+ # list_image_inserts/3 — columns=1 uses inline PT-width path
+ # ---------------------------------------------------------------------------
+
+ describe "list_image_inserts/3 with columns=1" do
+ test "produces insertInlineImage requests, no insertTable" do
+ fill = %{
+ kind: :image_list,
+ columns: 1,
+ media: [
+ %{uri: "u1", width_px: nil, height_px: nil},
+ %{uri: "u2", width_px: nil, height_px: nil}
+ ],
+ separator: :newline
+ }
+
+ # Invoke via build_image_batch_requests/3 (the public API).
+ ranges = [%{name: "photos", start_index: 10, end_index: 30}]
+ fills = %{"photos" => fill}
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, 468.0)
+
+ refute Enum.any?(requests, &Map.has_key?(&1, "insertTable"))
+ assert Enum.any?(requests, &Map.has_key?(&1, :insertInlineImage))
+ end
+
+ test "width uses content-width-based PT (image_width_for_columns(cw, 1) = cw)" do
+ fill = %{
+ kind: :image_list,
+ columns: 1,
+ media: [%{uri: "u1", width_px: nil, height_px: nil}],
+ separator: :newline
+ }
+
+ ranges = [%{name: "img", start_index: 5, end_index: 25}]
+ fills = %{"img" => fill}
+ content_width_pt = 468.0
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, content_width_pt)
+
+ [_delete | inserts] = requests
+ [insert] = inserts
+ width_magnitude = get_in(insert, [:insertInlineImage, :objectSize, :width, :magnitude])
+ # image_width_for_columns(468.0, 1) == 468.0
+ assert width_magnitude == content_width_pt
+ end
+
+ test "inserts are ordered last-first with newline separators" do
+ fill = %{
+ kind: :image_list,
+ columns: 1,
+ media: [
+ %{uri: "first", width_px: nil, height_px: nil},
+ %{uri: "second", width_px: nil, height_px: nil}
+ ],
+ separator: :newline
+ }
+
+ ranges = [%{name: "p", start_index: 5, end_index: 24}]
+ fills = %{"p" => fill}
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, 468.0)
+
+ # delete + second_img + newline + first_img
+ uris =
+ for %{insertInlineImage: %{uri: u}} <- requests, do: u
+
+ assert uris == ["second", "first"]
+ end
+ end
+
+ # ---------------------------------------------------------------------------
+ # list_image_inserts/3 — columns >= 2 uses table path
+ # ---------------------------------------------------------------------------
+
+ describe "list_image_inserts/3 with columns >= 2" do
+ test "produces exactly one deleteContentRange + one insertTable, no insertInlineImage" do
+ fill = %{
+ kind: :image_list,
+ columns: 2,
+ media: [%{uri: "u1"}, %{uri: "u2"}, %{uri: "u3"}],
+ separator: :newline
+ }
+
+ ranges = [%{name: "grid", start_index: 50, end_index: 70}]
+ fills = %{"grid" => fill}
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, 468.0)
+
+ # build_image_batch_requests/3 emits the deleteContentRange (atom keys).
+ # list_image_inserts for columns>=2 emits ONLY insertTable (string keys).
+ # There must be exactly ONE deleteContentRange — a second one would be
+ # zero-width (startIndex == endIndex) and rejected by the Google Docs API.
+ delete_count =
+ Enum.count(requests, fn r ->
+ Map.has_key?(r, :deleteContentRange) or Map.has_key?(r, "deleteContentRange")
+ end)
+
+ assert delete_count == 1, "expected exactly 1 deleteContentRange, got #{delete_count}"
+ assert Enum.any?(requests, &Map.has_key?(&1, "insertTable"))
+ refute Enum.any?(requests, &Map.has_key?(&1, :insertInlineImage))
+ refute Enum.any?(requests, &Map.has_key?(&1, "insertInlineImage"))
+ end
+
+ test "insertTable has correct row count ceil(media / columns)" do
+ fill = %{
+ kind: :image_list,
+ columns: 2,
+ media: [%{uri: "u1"}, %{uri: "u2"}, %{uri: "u3"}],
+ separator: :newline
+ }
+
+ ranges = [%{name: "grid", start_index: 50, end_index: 70}]
+ fills = %{"grid" => fill}
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, 468.0)
+
+ table_req = Enum.find(requests, &Map.has_key?(&1, "insertTable"))
+ assert get_in(table_req, ["insertTable", "rows"]) == 2
+ assert get_in(table_req, ["insertTable", "columns"]) == 2
+ end
+ end
+
+ # ---------------------------------------------------------------------------
+ # build_image_batch_requests/3 — mixed slots
+ # ---------------------------------------------------------------------------
+
+ describe "build_image_batch_requests/3 mixed slots" do
+ test "single :image slot gets delete + inline insert; image_list columns=2 gets delete + insertTable" do
+ ranges = [
+ %{name: "logo", start_index: 100, end_index: 120},
+ %{name: "gallery", start_index: 50, end_index: 70}
+ ]
+
+ fills = %{
+ "logo" => %{
+ kind: :image,
+ columns: 1,
+ default_width_px: 400,
+ opacity: 1.0,
+ z_index: 0,
+ separator: nil,
+ media: [%{uri: "logo.png", width_px: 800, height_px: 400}]
+ },
+ "gallery" => %{
+ kind: :image_list,
+ columns: 2,
+ default_width_px: 400,
+ separator: :newline,
+ media: [%{uri: "g1"}, %{uri: "g2"}]
+ }
+ }
+
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, fills, 468.0)
+
+ # logo (higher start_index) processed first (desc order); gallery second.
+ # Verify exactly one deleteContentRange per slot (two slots → two deletes total).
+ total_deletes =
+ Enum.count(requests, fn r ->
+ Map.has_key?(r, :deleteContentRange) or Map.has_key?(r, "deleteContentRange")
+ end)
+
+ assert total_deletes == 2, "expected exactly 2 deleteContentRange (one per slot)"
+
+ # logo slot: atom-key delete + atom-key inline insert
+ assert Enum.any?(requests, &match?(%{deleteContentRange: %{range: %{startIndex: 100}}}, &1))
+ assert Enum.any?(requests, &match?(%{insertInlineImage: %{location: %{index: 100}}}, &1))
+
+ # gallery slot: atom-key delete (from outer loop) + string-key insertTable only
+ assert Enum.any?(requests, &match?(%{deleteContentRange: %{range: %{startIndex: 50}}}, &1))
+ assert Enum.any?(requests, &Map.has_key?(&1, "insertTable"))
+ # No second deleteContentRange for the gallery slot (would be zero-width and API-rejected)
+ gallery_string_deletes =
+ Enum.count(requests, &Map.has_key?(&1, "deleteContentRange"))
+
+ assert gallery_string_deletes == 0,
+ "list_image_inserts must not emit its own deleteContentRange for table slots"
+ end
+ end
+
+ # ---------------------------------------------------------------------------
+ # Cell-finder helper — extract_table_cells equivalent
+ # ---------------------------------------------------------------------------
+
+ describe "fill_table_cells/3 with extracted cell structure" do
+ test "extracts insert indices from a known Google Docs table element" do
+ # Simulate what the Docs API returns for a 2x2 table after insertTable.
+ # The private extract_table_cells/1 uses startIndex + 1 as the insert
+ # position. We verify the contract by constructing cells manually.
+ # cell.startIndex values: 10, 30, 50, 70 → insert indices: 11, 31, 51, 71.
+ cells = [
+ %{insert_index: 11},
+ %{insert_index: 31},
+ %{insert_index: 51},
+ %{insert_index: 71}
+ ]
+
+ media = [%{uri: "a"}, %{uri: "b"}, %{uri: "c"}]
+ reqs = GoogleDocsClient.fill_table_cells(cells, media, %{image_width_pt: 230.0})
+
+ # fill_table_cells zips cells with media (3 items), reverses → last-first
+ indices = for %{"insertInlineImage" => %{"location" => %{"index" => i}}} <- reqs, do: i
+ assert indices == [51, 31, 11]
+
+ uris = for %{"insertInlineImage" => %{"uri" => u}} <- reqs, do: u
+ assert uris == ["c", "b", "a"]
+ end
+
+ test "table startIndex + 1 gives correct insert position" do
+ # Mirrors the strategy used in extract_table_cells/1:
+ # cell.startIndex + 1 = first position inside the cell paragraph.
+ cell_start = 100
+ expected_insert = cell_start + 1
+
+ cells = [%{insert_index: expected_insert}]
+ media = [%{uri: "img"}]
+ [req] = GoogleDocsClient.fill_table_cells(cells, media, %{image_width_pt: 230.0})
+
+ assert get_in(req, ["insertInlineImage", "location", "index"]) == expected_insert
+ end
+ end
+
+ # ---------------------------------------------------------------------------
+ # build_image_fills columns pass-through
+ # ---------------------------------------------------------------------------
+
+ describe "build_image_fills columns integration (via build_image_batch_requests/3)" do
+ test "columns from image_params is respected — 2 columns → insertTable" do
+ # Simulate image_params as built by build_image_fills/1 with columns key.
+ fill = %{
+ kind: :image_list,
+ columns: 2,
+ default_width_px: 400,
+ separator: :newline,
+ media: [%{uri: "a"}, %{uri: "b"}, %{uri: "c"}, %{uri: "d"}]
+ }
+
+ ranges = [%{name: "slot", start_index: 10, end_index: 30}]
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, %{"slot" => fill}, 468.0)
+
+ assert Enum.any?(requests, &match?(%{"insertTable" => %{"rows" => 2, "columns" => 2}}, &1))
+ end
+
+ test "missing columns defaults to 1 → inline inserts" do
+ fill = %{
+ kind: :image_list,
+ columns: 1,
+ default_width_px: 400,
+ separator: :newline,
+ media: [%{uri: "a"}, %{uri: "b"}]
+ }
+
+ ranges = [%{name: "slot", start_index: 10, end_index: 30}]
+ requests = GoogleDocsClient.build_image_batch_requests(ranges, %{"slot" => fill}, 468.0)
+
+ refute Enum.any?(requests, &Map.has_key?(&1, "insertTable"))
+ assert Enum.any?(requests, &Map.has_key?(&1, :insertInlineImage))
+ end
+ end
+end
diff --git a/test/phoenix_kit_document_creator/google_docs_client_table_test.exs b/test/phoenix_kit_document_creator/google_docs_client_table_test.exs
new file mode 100644
index 0000000..760809e
--- /dev/null
+++ b/test/phoenix_kit_document_creator/google_docs_client_table_test.exs
@@ -0,0 +1,97 @@
+defmodule PhoenixKitDocumentCreator.GoogleDocsClientTableTest do
+ use ExUnit.Case, async: true
+ alias PhoenixKitDocumentCreator.GoogleDocsClient
+
+ describe "table_image_inserts/3 — phase A (table creation)" do
+ test "returns a deleteContentRange + insertTable for placeholder range" do
+ placeholder = %{start_index: 100, end_index: 120}
+ media = [%{uri: "u1"}, %{uri: "u2"}, %{uri: "u3"}]
+ opts = %{columns: 2, content_width_pt: 468.0}
+
+ reqs = GoogleDocsClient.table_image_inserts(placeholder, media, opts)
+
+ assert [
+ %{"deleteContentRange" => %{"range" => %{"startIndex" => 100, "endIndex" => 120}}},
+ %{"insertTable" => %{"rows" => 2, "columns" => 2, "location" => %{"index" => 100}}}
+ ] = reqs
+ end
+
+ test "rows = ceil(count / columns)" do
+ placeholder = %{start_index: 0, end_index: 10}
+ media = List.duplicate(%{uri: "u"}, 5)
+ opts = %{columns: 2, content_width_pt: 468.0}
+
+ reqs = GoogleDocsClient.table_image_inserts(placeholder, media, opts)
+
+ assert Enum.any?(
+ reqs,
+ &match?(
+ %{"insertTable" => %{"rows" => 3, "columns" => 2}},
+ &1
+ )
+ )
+ end
+
+ test "clamps columns to 1..4" do
+ placeholder = %{start_index: 0, end_index: 10}
+ media = [%{uri: "u"}]
+
+ reqs =
+ GoogleDocsClient.table_image_inserts(placeholder, media, %{
+ columns: 99,
+ content_width_pt: 468.0
+ })
+
+ assert Enum.any?(reqs, &match?(%{"insertTable" => %{"columns" => 4}}, &1))
+ end
+ end
+
+ describe "fill_table_cells/3 — phase B (image insertion into cells)" do
+ test "inserts one image per cell, left-to-right top-to-bottom" do
+ # Mock the doc-after-table-creation: cells with known startIndices.
+ # Each cell has a paragraph startIndex we insert into.
+ cells = [
+ %{insert_index: 200},
+ %{insert_index: 220},
+ %{insert_index: 240},
+ %{insert_index: 260}
+ ]
+
+ media = [%{uri: "a"}, %{uri: "b"}, %{uri: "c"}]
+ opts = %{image_width_pt: 230.0}
+
+ reqs = GoogleDocsClient.fill_table_cells(cells, media, opts)
+
+ uris = for %{"insertInlineImage" => %{"uri" => u}} <- reqs, do: u
+ assert uris == ["c", "b", "a"], "insert last-first to avoid index drift"
+
+ indices =
+ for %{"insertInlineImage" => %{"location" => %{"index" => i}}} <-
+ reqs,
+ do: i
+
+ # last-first by original cell order
+ assert indices == [240, 220, 200]
+ end
+
+ test "ignores extra cells when media is shorter" do
+ cells = [
+ %{insert_index: 200},
+ %{insert_index: 220},
+ %{insert_index: 240},
+ %{insert_index: 260}
+ ]
+
+ media = [%{uri: "a"}]
+ reqs = GoogleDocsClient.fill_table_cells(cells, media, %{image_width_pt: 230.0})
+ assert length(reqs) == 1
+ end
+
+ test "objectSize uses provided image_width_pt for width magnitude" do
+ cells = [%{insert_index: 100}]
+ media = [%{uri: "a"}]
+ [req] = GoogleDocsClient.fill_table_cells(cells, media, %{image_width_pt: 230.0})
+ assert get_in(req, ["insertInlineImage", "objectSize", "width", "magnitude"]) == 230.0
+ end
+ end
+end
diff --git a/test/phoenix_kit_document_creator/google_docs_client_width_test.exs b/test/phoenix_kit_document_creator/google_docs_client_width_test.exs
new file mode 100644
index 0000000..73472a6
--- /dev/null
+++ b/test/phoenix_kit_document_creator/google_docs_client_width_test.exs
@@ -0,0 +1,57 @@
+defmodule PhoenixKitDocumentCreator.GoogleDocsClientWidthTest do
+ use ExUnit.Case, async: true
+ alias PhoenixKitDocumentCreator.GoogleDocsClient
+
+ describe "content_width_pt/1" do
+ test "default A4-ish page with default margins (72pt each side)" do
+ doc = %{
+ "documentStyle" => %{
+ "pageSize" => %{"width" => %{"magnitude" => 612.0, "unit" => "PT"}},
+ "marginLeft" => %{"magnitude" => 72.0, "unit" => "PT"},
+ "marginRight" => %{"magnitude" => 72.0, "unit" => "PT"}
+ }
+ }
+
+ assert GoogleDocsClient.content_width_pt(doc) == 468.0
+ end
+
+ test "falls back to 468pt when documentStyle missing" do
+ assert GoogleDocsClient.content_width_pt(%{}) == 468.0
+ end
+
+ test "uses pageSize but missing margins → 72pt default each side" do
+ doc = %{
+ "documentStyle" => %{
+ "pageSize" => %{"width" => %{"magnitude" => 595.0, "unit" => "PT"}}
+ }
+ }
+
+ assert GoogleDocsClient.content_width_pt(doc) == 451.0
+ end
+ end
+
+ describe "image_width_for_columns/2" do
+ test "N=1 → full content width" do
+ assert GoogleDocsClient.image_width_for_columns(468.0, 1) == 468.0
+ end
+
+ test "N=2 → half minus single gap" do
+ # gap=8pt → (468 - 8)/2 = 230
+ assert GoogleDocsClient.image_width_for_columns(468.0, 2) == 230.0
+ end
+
+ test "N=4 → quarter minus three gaps" do
+ # (468 - 24)/4 = 111
+ assert GoogleDocsClient.image_width_for_columns(468.0, 4) == 111.0
+ end
+
+ test "clamps N below 1 to 1" do
+ assert GoogleDocsClient.image_width_for_columns(468.0, 0) == 468.0
+ end
+
+ test "clamps N above 4 to 4" do
+ # (468 - 24)/4 = 111
+ assert GoogleDocsClient.image_width_for_columns(468.0, 99) == 111.0
+ end
+ end
+end
|