Files
Khaemhat/tests/Khaemhat.Infrastructure.Tests/Files/PdfWriterTests.cs
T
Alby96andClaude Opus 5.5 b341ade9e9 feat: attachments, file store and in-house PDF/CSV/XLSX/ZIP writers (#34)
Documents need attachments and generated files (SPEC 9.4) before the UI of
M3 can show them, and the spec forbids external libraries for PDF and
spreadsheets.

- VolumeFileStore keeps files under <data>/files/<COMPANY>/<yyyy>/<guid>,
  writing a .part file in the same folder with size limit and SHA-256, then
  quota and scanner checks (IFileScanner hook, no-op by default).
- attachments table (migration 007) with kind, version series, lock, trash
  and the uploading user; AttachmentService uploads, adds generated files as
  the next version, lists, opens, zips, locks, trashes, restores and purges
  after 30 days (new system job system.attachments-trash).
- FileGenerationService runs IFileGenerator implementations into the store;
  three generators for the fictitious test document (PDF, CSV, XLSX).
- CsvWriter (Italian Excel defaults, formula-injection guard), XlsxWriter,
  ZipStreamWriter and PdfWriter (standard Type1 fonts, WinAnsi, AFM widths,
  JPEG, Flate, xref) only write asynchronously, so they can stream to an
  HTTP response.
- ADR 0021 records versioning, storage layout, PDF scope and CSV defaults.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-11 18:06:48 +01:00

212 lines
9.7 KiB
C#

using System.Globalization;
using System.IO.Compression;
using System.Text;
using System.Text.RegularExpressions;
using Khaemhat.Infrastructure.Files;
namespace Khaemhat.Infrastructure.Tests.Files;
/// <summary>The in-house PDF writer, first version (SPEC §2 "PDF e file", issue #34).</summary>
[TestClass]
public sealed partial class PdfWriterTests
{
private static readonly Encoding Latin1 = Encoding.Latin1;
[TestMethod]
public async Task Document_HasHeaderTrailerAndXrefOffsetsThatPointAtTheObjects()
{
var bytes = await WriteAsync(async pdf =>
{
var first = await pdf.AddPageAsync();
first.DrawText("Prima pagina", 50, 780, PdfFont.HelveticaBold, 16);
first.DrawLine(50, 770, 545, 770, 1, PdfColor.FromHex("#1F5F8B"));
first.DrawRectangle(50, 700, 200, 40, PdfColor.Black, PdfColor.Gray(230));
var second = await pdf.AddPageAsync(PdfWriter.A4Height, PdfWriter.A4Width);
second.DrawTextRight("€ 1.234,56", 800, 500, PdfFont.TimesRoman, 10);
await pdf.AddPageAsync();
Assert.AreEqual(3, pdf.PageCount);
});
var text = Latin1.GetString(bytes);
StringAssert.StartsWith(text, "%PDF-1.7\n");
StringAssert.EndsWith(text, "%%EOF\n");
StringAssert.Contains(text, "/Type /Pages /Kids [");
StringAssert.Contains(text, "/Count 3");
Assert.AreEqual(3, PageObject().Count(text));
StringAssert.Contains(text, "/MediaBox [0 0 841.89 595.28]");
var startxref = long.Parse(StartXref().Match(text).Groups[1].Value, CultureInfo.InvariantCulture);
Assert.AreEqual("xref", text.Substring((int)startxref, 4));
var header = XrefHeader().Match(text, (int)startxref);
var size = int.Parse(header.Groups[1].Value, CultureInfo.InvariantCulture);
var entries = XrefEntry().Matches(text, header.Index + header.Length).Take(size).ToList();
Assert.HasCount(size, entries);
Assert.AreEqual("f", entries[0].Groups[3].Value);
for (var i = 1; i < size; i++)
{
var offset = int.Parse(entries[i].Groups[1].Value, CultureInfo.InvariantCulture);
StringAssert.StartsWith(text[offset..], $"{i} 0 obj\n", $"xref entry {i}");
}
StringAssert.Contains(text, $"/Size {size} /Root 1 0 R /Info 3 0 R");
}
[TestMethod]
public async Task Text_IsWinAnsiEncoded_EuroAndAccentsIncluded()
{
var bytes = await WriteAsync(
async pdf =>
{
var page = await pdf.AddPageAsync();
page.DrawText("Totale € città (prova) \\ fine", 50, 700, PdfFont.Helvetica, 12, PdfColor.FromHex("#FF0000"));
},
compress: false);
var text = Latin1.GetString(bytes);
// € is 0x80 (octal 200), à is 0xE0 (octal 340); parentheses and backslash are escaped.
StringAssert.Contains(text, "(Totale \\200 citt\\340 \\(prova\\) \\\\ fine) Tj");
StringAssert.Contains(text, "1 0 0 rg BT /F1 12 Tf 1 0 0 1 50 700 Tm");
StringAssert.Contains(text, "/BaseFont /Helvetica /Encoding /WinAnsiEncoding");
CollectionAssert.AreEqual(new byte[] { 0x80, 0xE0, 0xE8, 0xE9, 0xEC, 0xF2, 0xF9, (byte)'?' }, PdfTextLayout.EncodeWinAnsi("€àèéìòù漢"));
}
[TestMethod]
public async Task ContentStreams_AreFlateCompressed()
{
var bytes = await WriteAsync(async pdf => (await pdf.AddPageAsync()).DrawText("Compresso è meglio", 50, 700, PdfFont.Courier, 10));
var text = Latin1.GetString(bytes);
var match = FlateStream().Match(text);
Assert.IsTrue(match.Success);
var length = int.Parse(match.Groups[1].Value, CultureInfo.InvariantCulture);
var start = match.Index + match.Length;
using var zlib = new ZLibStream(new MemoryStream(bytes, start, length), CompressionMode.Decompress);
using var reader = new StreamReader(zlib, Latin1);
StringAssert.Contains(reader.ReadToEnd(), "(Compresso \\350 meglio) Tj");
}
[TestMethod]
public async Task DocumentInfo_IsWritten_WithUnicodeAsUtf16()
{
var info = new PdfDocumentInfo { Title = "Fattura n. 7", Author = "Società Prova", CreationDate = new DateTimeOffset(2026, 11, 11, 10, 30, 0, TimeSpan.Zero) };
var output = new AsyncOnlyStream();
await using (var pdf = new PdfWriter(output, info, leaveOpen: true))
{
await pdf.AddPageAsync();
}
var text = Latin1.GetString(output.ToArray());
StringAssert.Contains(text, "/Title (Fattura n. 7)");
StringAssert.Contains(text, "/Author <FEFF0053006F0063006900650074" + "00E0");
StringAssert.Contains(text, "/Creator (Khaemhat)");
StringAssert.Contains(text, "/CreationDate (D:20261111103000Z)");
}
[TestMethod]
public async Task EmptyDocument_GetsOneBlankPage()
{
var text = Latin1.GetString(await WriteAsync(_ => Task.CompletedTask));
StringAssert.Contains(text, "/Count 1");
}
[TestMethod]
public void Jpeg_SizeAndComponents_AreReadFromTheFrameHeader()
{
var info = JpegInfo.Read(TinyJpeg(width: 64, height: 32, components: 3));
Assert.AreEqual(new JpegInfo(64, 32, 3, 8, false), info);
Assert.AreEqual(1, JpegInfo.Read(TinyJpeg(10, 10, 1)).Components);
Assert.IsTrue(JpegInfo.Read(TinyJpeg(10, 10, 4, adobe: true)).AdobeInverted);
Assert.ThrowsExactly<InvalidDataException>(() => JpegInfo.Read("not a jpeg"u8));
Assert.ThrowsExactly<InvalidDataException>(() => JpegInfo.Read(new byte[] { 0xFF, 0xD8, 0xFF, 0xD9 }));
}
[TestMethod]
public async Task Jpeg_IsEmbeddedAsIs_WithDctDecode()
{
var jpeg = TinyJpeg(64, 32, 3);
var bytes = await WriteAsync(async pdf =>
{
var image = pdf.AddJpeg(jpeg);
var page = await pdf.AddPageAsync();
page.DrawImage(image, 50, 600, 128, 64);
Assert.AreEqual(64, image.Width);
});
var text = Latin1.GetString(bytes);
StringAssert.Contains(text, $"/Subtype /Image /Width 64 /Height 32 /ColorSpace /DeviceRGB /BitsPerComponent 8 /Filter /DCTDecode /Length {jpeg.Length} >>");
StringAssert.Contains(text, "/XObject << /Im1 ");
Assert.IsGreaterThanOrEqualTo(0, text.IndexOf(Latin1.GetString(jpeg), StringComparison.Ordinal));
}
[TestMethod]
public void Measure_UsesTheAfmWidths_AndWrapKeepsLinesInsideTheWidth()
{
// Helvetica: "A" = 667, "i" = 222; Helvetica-Bold: "A" = 722; Courier: 600 for every character.
Assert.AreEqual(6.67, PdfTextLayout.Measure("A", PdfFont.Helvetica, 10), 1e-9);
Assert.AreEqual(8.89, PdfTextLayout.Measure("Ai", PdfFont.Helvetica, 10), 1e-9);
Assert.AreEqual(7.22, PdfTextLayout.Measure("A", PdfFont.HelveticaBold, 10), 1e-9);
Assert.AreEqual(5.56, PdfTextLayout.Measure("€", PdfFont.Helvetica, 10), 1e-9);
Assert.AreEqual(18, PdfTextLayout.Measure("abc", PdfFont.Courier, 10), 1e-9);
Assert.AreEqual(PdfTextLayout.Measure("e", PdfFont.Helvetica, 10), PdfTextLayout.Measure("è", PdfFont.Helvetica, 10));
var text = "Questo è un paragrafo abbastanza lungo da andare a capo più volte, con una parolaincredibilmentelunghissimachenonstainriga.";
var lines = PdfTextLayout.Wrap(text, PdfFont.Helvetica, 10, 120);
Assert.IsGreaterThan(2, lines.Count);
Assert.IsTrue(lines.All(l => PdfTextLayout.Measure(l, PdfFont.Helvetica, 10) <= 120));
Assert.AreEqual(text.Replace(" ", string.Empty, StringComparison.Ordinal), string.Concat(lines).Replace(" ", string.Empty, StringComparison.Ordinal));
Assert.HasCount(2, PdfTextLayout.Wrap("riga uno\nriga due", PdfFont.Helvetica, 10, 500));
StringAssert.EndsWith(PdfTextLayout.Fit("Descrizione molto lunga di un articolo", PdfFont.Helvetica, 10, 60), "…");
}
private static async Task<byte[]> WriteAsync(Func<PdfWriter, Task> draw, bool compress = true)
{
var output = new AsyncOnlyStream();
var pdf = new PdfWriter(output, new PdfDocumentInfo { Title = "Prova" }, leaveOpen: true) { CompressContent = compress };
await using (pdf)
{
await draw(pdf);
await pdf.CloseAsync();
}
return output.ToArray();
}
/// <summary>The header of a JPEG file built by hand: SOI, APP0 (JFIF), optional APP14 (Adobe), SOF0, EOI. No pixels.</summary>
private static byte[] TinyJpeg(int width, int height, int components, bool adobe = false)
{
var bytes = new List<byte> { 0xFF, 0xD8 };
bytes.AddRange([0xFF, 0xE0, 0x00, 0x10, (byte)'J', (byte)'F', (byte)'I', (byte)'F', 0x00, 0x01, 0x01, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00]);
if (adobe)
{
bytes.AddRange([0xFF, 0xEE, 0x00, 0x0E, (byte)'A', (byte)'d', (byte)'o', (byte)'b', (byte)'e', 0x00, 0x64, 0x00, 0x00, 0x00, 0x00, 0x02]);
}
var length = 8 + (3 * components);
bytes.AddRange([0xFF, 0xC0, (byte)(length >> 8), (byte)length, 0x08, (byte)(height >> 8), (byte)height, (byte)(width >> 8), (byte)width, (byte)components]);
for (var c = 1; c <= components; c++)
{
bytes.AddRange([(byte)c, 0x11, 0x00]);
}
bytes.AddRange([0xFF, 0xD9]);
return [.. bytes];
}
[GeneratedRegex(@"/Type /Page /Parent")]
private static partial Regex PageObject();
[GeneratedRegex(@"startxref\n(\d+)\n%%EOF")]
private static partial Regex StartXref();
[GeneratedRegex(@"xref\n0 (\d+)\n")]
private static partial Regex XrefHeader();
[GeneratedRegex(@"(\d{10}) (\d{5}) ([nf])\r\n")]
private static partial Regex XrefEntry();
[GeneratedRegex(@"<< /Length (\d+) /Filter /FlateDecode >>\nstream\n")]
private static partial Regex FlateStream();
}