Approvaltests and PDF

Question

Can I use ApprovalTests with PDF's? I tried using the FileLauncher but it seems the identical PDF's are slightly different at file (bit) level. Or did I use it wrongly?

[TestMethod]
[UseReporter(typeof(FileLauncherReporter))]
public void TestPdf()
{
    var createSomePdf = PdfCreate();

    ApprovalTests.Approvals.Verify(new FileInfo(createSomePdf.FileName));

}

Answer 1

The Pdf is most likely being created with a timestamp. Depending on the method used to create the pdf, you might be able to mock out the created time. but I had to scrub it.

Here's the code I used to do that.

    public static void VerifyPdf(string coverFile)
    {
        ScrubPdf(coverFile);
        Approvals.Verify(new ExistingFileWriter(coverFile));
    }

    private static void ScrubPdf(string coverFile)
    {
        long location;
        using (var pdf = File.OpenRead(coverFile))
        {
            location = Find("/CreationDate (", pdf);

        }
        using (var pdf = File.OpenWrite(coverFile))
        {
            pdf.Seek(location, SeekOrigin.Begin);

            var original = "/CreationDate (D:20110426104115-07'00')";
            var desired = new System.Text.ASCIIEncoding().GetBytes(original);

            pdf.Write(desired, 0, desired.Length);
            pdf.Flush();
        }
    }

Answer 2

Looks like this is built in to ApprovalTests now.

usage:

Approvals.VerifyPdfFile(pdfFileLocation);

See the source:

public static void VerifyPdfFile(string pdfFilePath)
{
    PdfScrubber.ScrubPdf(pdfFilePath);
    Verify(new ExistingFileWriter(pdfFilePath));
}

Answer 3

I found a command-line tool, diff-pdf. Compares 2 PDFs and returns exit code 0 if they're the same, 1 if they differ. Download + extract + add it to your PATH.

Downside - it must render both PDFs to perform the diff. If they're big, perf hit.

Approver (based heavily on ApprovalTests.Approvers.FileApprover):

public class DiffPdfApprover : IApprovalApprover
{
    public static void Verify(byte[] bytes)
    {
        var writer = new ApprovalTests.Writers.BinaryWriter(bytes, "pdf");
        var namer = ApprovalTests.Approvals.GetDefaultNamer();
        var reporter = ApprovalTests.Approvals.GetReporter();

        ApprovalTests.Core.Approvals.Verify(new DiffPdfApprover(writer, namer), reporter);
    }

    private DiffPdfApprover(IApprovalWriter writer, IApprovalNamer namer)
    {
        this.writer = writer;
        this.namer = namer;
    }

    private readonly IApprovalNamer namer;
    private readonly IApprovalWriter writer;
    private string approved;
    private ApprovalException failure;
    private string received;

    public virtual bool Approve()
    {
        string basename = string.Format(@"{0}\{1}", namer.SourcePath, namer.Name);
        approved = Path.GetFullPath(writer.GetApprovalFilename(basename));
        received = Path.GetFullPath(writer.GetReceivedFilename(basename));
        received = writer.WriteReceivedFile(received);

        failure = Approve(approved, received);
        return failure == null;
    }

    public static ApprovalException Approve(string approved, string received)
    {
        if (!File.Exists(approved))
        {
            return new ApprovalMissingException(received, approved);
        }

        var process = new Process();
        //settings up parameters for the install process
        process.StartInfo.FileName = "diff-pdf";
        process.StartInfo.Arguments = String.Format("\"{0}\" \"{1}\"", received, approved);

        process.Start();

        process.WaitForExit();

        if (process.ExitCode != 0)
        {
            return new ApprovalMismatchException(received, approved);
        }

        return null;
    }

    public void Fail()
    {
        throw failure;
    }

    public void ReportFailure(IApprovalFailureReporter reporter)
    {
        reporter.Report(approved, received);
    }

    public void CleanUpAfterSucess(IApprovalFailureReporter reporter)
    {
        File.Delete(received);
        if (reporter is IApprovalReporterWithCleanUp)
        {
            ((IApprovalReporterWithCleanUp)reporter).CleanUp(approved, received);
        }
    }
}

To Verify:

DiffPdfApprover.Verify(pdfBytes);

diff-pdf can visually show diffs as well. I rolled a Reporter for this, but don't use it much. I think it'll come in handy if there are regressions after initial report dev (which is where I'm at right now).

public class DiffPdfReporter : GenericDiffReporter
{
    private static readonly string Path = FindFullPath("diff-pdf.exe");
    public DiffPdfReporter() : base(Path,
        GetArgs(),
        "Please put diff-pdf.exe in your %PATH%. https://github.com/vslavik/diff-pdf. And restart whatever's running the tests. Everything seems to cache the %PATH%.") { }

    private static string GetArgs()
    {
        return "--view \"{0}\" \"{1}\"";
    }

    private static string FindFullPath(string programInPath)
    {
        foreach (var path in from path in Environment.GetEnvironmentVariable("path").Split(';')
                             select path)
        {
            var fullPath = System.IO.Path.Combine(path, programInPath);
            if (File.Exists(fullPath))
                return fullPath;
        }
        return null;
    }
}