Added overloads of ConvertHtmlToPng and ConvertHtmlToPdf

- Exposed PdfOptions in ConvertHtmlToPdf overload
- Exposed ScreenshotOptions in ConvertHtmlToPng overload

Author: stesee

Codeuctivity.HtmlRenderer/Codeuctivity.HtmlRenderer.csproj

@@ -40,7 +40,7 @@
 	<ItemGroup>
 		<PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="all" />
 		<PackageReference Include="PuppeteerSharp" Version="8.0.0" />
-		<PackageReference Include="SonarAnalyzer.CSharp" Version="8.49.0.57237">
+		<PackageReference Include="SonarAnalyzer.CSharp" Version="8.50.0.58025">
 			<PrivateAssets>all</PrivateAssets>
 			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
 		</PackageReference>

Codeuctivity.HtmlRenderer/Renderer.cs

@@ -137,7 +137,19 @@ private static bool IsRunningOnWslOrAzure()
         /// </summary>
         /// <param name="sourceHtmlFilePath"></param>
         /// <param name="destinationPdfFilePath"></param>
-        public async Task ConvertHtmlToPdf(string sourceHtmlFilePath, string destinationPdfFilePath)
+        public Task ConvertHtmlToPdf(string sourceHtmlFilePath, string destinationPdfFilePath)
+        {
+            PdfOptions pdfOptions = new PdfOptions();
+            return ConvertHtmlToPdf(sourceHtmlFilePath, destinationPdfFilePath, pdfOptions);
+        }
+
+        /// <summary>
+        /// Converts a HTML file to a PDF
+        /// </summary>
+        /// <param name="sourceHtmlFilePath"></param>
+        /// <param name="destinationPdfFilePath"></param>
+        /// <param name="pdfOptions"></param>
+        public async Task ConvertHtmlToPdf(string sourceHtmlFilePath, string destinationPdfFilePath, PdfOptions pdfOptions)
         {
             if (!File.Exists(sourceHtmlFilePath))
             {
@@ -149,15 +161,26 @@ public async Task ConvertHtmlToPdf(string sourceHtmlFilePath, string destination
             await page.GoToAsync($"file://{absolutePath}").ConfigureAwait(false);
             // Wait for fonts to be loaded. Omitting this might result in no text rendered in PDF.
             await page.EvaluateExpressionHandleAsync("document.fonts.ready");
-            await page.PdfAsync(destinationPdfFilePath).ConfigureAwait(false);
+            await page.PdfAsync(destinationPdfFilePath, pdfOptions).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Converts a HTML file to a PNG
+        /// </summary>
+        /// <param name="sourceHtmlFilePath"></param>
+        /// <param name="destinationPngFilePath"></param>
+        public Task ConvertHtmlToPng(string sourceHtmlFilePath, string destinationPngFilePath)
+        {
+            return ConvertHtmlToPng(sourceHtmlFilePath, destinationPngFilePath, new ScreenshotOptions { FullPage = true });
         }
 
         /// <summary>
         /// Converts a HTML file to a PNG
         /// </summary>
         /// <param name="sourceHtmlFilePath"></param>
         /// <param name="destinationPngFilePath"></param>
-        public async Task ConvertHtmlToPng(string sourceHtmlFilePath, string destinationPngFilePath)
+        /// <param name="screenshotOptions"></param>
+        public async Task ConvertHtmlToPng(string sourceHtmlFilePath, string destinationPngFilePath, ScreenshotOptions screenshotOptions)
         {
             if (!File.Exists(sourceHtmlFilePath))
             {
@@ -169,7 +192,7 @@ public async Task ConvertHtmlToPng(string sourceHtmlFilePath, string destination
             await page.GoToAsync($"file://{absolutePath}").ConfigureAwait(false);
             // Wait for fonts to be loaded. Omitting this might result in no text the screenshot.
             await page.EvaluateExpressionHandleAsync("document.fonts.ready");
-            await page.ScreenshotAsync(destinationPngFilePath, new ScreenshotOptions { FullPage = true }).ConfigureAwait(false);
+            await page.ScreenshotAsync(destinationPngFilePath, screenshotOptions).ConfigureAwait(false);
         }
 
         private void DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)

Codeuctivity.HtmlRendererCliTests/Codeuctivity.HtmlRendererCliTests.csproj

@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
-    <PackageReference Include="SonarAnalyzer.CSharp" Version="8.49.0.57237">
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="8.50.0.58025">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

Codeuctivity.HtmlRendererTests/Codeuctivity.HtmlRendererTests.csproj

@@ -18,7 +18,7 @@
   <ItemGroup>
     <PackageReference Include="Codeuctivity.ImageSharpCompare" Version="2.0.76" />
     <PackageReference Include="Codeuctivity.PdfjsSharp" Version="1.2.70" />
-    <PackageReference Include="SonarAnalyzer.CSharp" Version="8.49.0.57237">
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="8.50.0.58025">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>

Codeuctivity.HtmlRendererTests/ExpectedTestOutcome/ExpectedConvertHtmlToPngBasicTextFormatedInlineBackground.html.False.png

@@ -1,6 +1,7 @@
 using Codeuctivity.HtmlRenderer;
 using Codeuctivity.HtmlRendererTests.Infrastructure;
 using Codeuctivity.PdfjsSharp;
+using Jering.Javascript.NodeJS;
 using PuppeteerSharp;
 using System;
 using System.IO;
@@ -11,8 +12,17 @@
 
 namespace Codeuctivity.HtmlRendererTests
 {
-    public class RendererTests
+    public class RendererTests : IDisposable
     {
+        private bool disposedValue;
+
+        public RendererTests()
+        {
+            Rasterize = new Rasterizer();
+        }
+
+        public Rasterizer Rasterize { get; private set; }
+
         [Theory]
         [InlineData("BasicTextFormated.html")]
         public async Task ShouldConvertHtmlToPdf(string testFileName)
@@ -32,11 +42,9 @@ public async Task ShouldConvertHtmlToPdf(string testFileName)
 
                 var actualImagePathDirectory = Path.Combine(Path.GetTempPath(), testFileName);
 
-                using var rasterize = new Rasterizer();
-
                 if (!IsRunningOnWslOrAzureOrMacos())
                 {
-                    var actualImages = await rasterize.ConvertToPngAsync(actualFilePath, actualImagePathDirectory);
+                    var actualImages = await Rasterize.ConvertToPngAsync(actualFilePath, actualImagePathDirectory);
                     Assert.Single(actualImages);
                     DocumentAsserter.AssertImageIsEqual(actualImages.Single(), expectReferenceFilePath, 2000);
                 }
@@ -45,6 +53,46 @@ public async Task ShouldConvertHtmlToPdf(string testFileName)
             await ChromiumProcessDisposedAsserter.AssertNoChromiumProcessIsRunning();
         }
 
+        [Theory]
+        [InlineData("BasicTextFormatedInlineBackground.html", false, 6000)]
+        [InlineData("BasicTextFormatedInlineBackground.html", true, 6000)]
+        public async Task ShouldConvertHtmlToPdfWithOptions(string testFileName, bool printBackground, int allowedPixelDiff)
+        {
+            var sourceHtmlFilePath = $"../../../TestInput/{testFileName}";
+            var actualFilePath = Path.Combine(Path.GetTempPath(), $"ActualConvertHtmlToPdf{testFileName}.{printBackground}.pdf");
+            var expectReferenceFilePath = $"../../../ExpectedTestOutcome/ExpectedFromHtmlConvertHtmlToPdf{testFileName}.{printBackground}.png";
+
+            if (File.Exists(actualFilePath))
+            {
+                File.Delete(actualFilePath);
+            }
+
+            await using (var chromiumRenderer = await Renderer.CreateAsync())
+            {
+                await chromiumRenderer.ConvertHtmlToPdf(sourceHtmlFilePath, actualFilePath, new PdfOptions() { PrintBackground = printBackground });
+
+                var actualImagePathDirectory = Path.Combine(Path.GetTempPath(), testFileName);
+
+                if (!IsRunningOnWslOrAzureOrMacos())
+                {
+                    try
+                    {
+                        var actualImages = await Rasterize.ConvertToPngAsync(actualFilePath, actualImagePathDirectory);
+                        Assert.Single(actualImages);
+                        // File.Copy(actualImages.Single(), expectReferenceFilePath, true);
+                        DocumentAsserter.AssertImageIsEqual(actualImages.Single(), expectReferenceFilePath, allowedPixelDiff);
+                    }
+                    catch (InvocationException ex)
+                    {
+                        // Working around issue in Jering.Javascript.NodeJS, silencing false positiv failing
+                        Assert.True(RuntimeInformation.IsOSPlatform(OSPlatform.Windows), ex.Message);
+                    }
+                }
+                File.Delete(actualFilePath);
+            }
+            await ChromiumProcessDisposedAsserter.AssertNoChromiumProcessIsRunning();
+        }
+
         private static bool IsRunningOnWslOrAzureOrMacos()
         {
             if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) || RuntimeInformation.IsOSPlatform(OSPlatform.FreeBSD))
@@ -88,6 +136,36 @@ public async Task ShouldConvertHtmlToPng(string testFileName)
             await ChromiumProcessDisposedAsserter.AssertNoChromiumProcessIsRunning();
         }
 
+        [Theory]
+        [InlineData("BasicTextFormatedInlineBackground.html", false, 11000)]
+        [InlineData("BasicTextFormatedInlineBackground.html", true, 9500)]
+        public async Task ShouldConvertHtmlToPngScreenshotOptions(string testFileName, bool omitBackground, int allowedPixelDiff)
+        {
+            var sourceHtmlFilePath = $"../../../TestInput/{testFileName}";
+            var actualFilePath = Path.Combine(Path.GetTempPath(), $"ActualConvertHtmlToPng{testFileName}.{omitBackground}.png");
+            var expectReferenceFilePath = $"../../../ExpectedTestOutcome/ExpectedConvertHtmlToPng{testFileName}.{omitBackground}.png";
+
+            if (File.Exists(actualFilePath))
+            {
+                File.Delete(actualFilePath);
+            }
+
+            await using (var chromiumRenderer = await Renderer.CreateAsync())
+            {
+                ScreenshotOptions screenshotOptions = new ScreenshotOptions
+                {
+                    OmitBackground = omitBackground
+                };
+
+                await chromiumRenderer.ConvertHtmlToPng(sourceHtmlFilePath, actualFilePath, screenshotOptions);
+                // File.Copy(actualFilePath, expectReferenceFilePath);
+                DocumentAsserter.AssertImageIsEqual(actualFilePath, expectReferenceFilePath, allowedPixelDiff);
+            }
+
+            File.Delete(actualFilePath);
+            await ChromiumProcessDisposedAsserter.AssertNoChromiumProcessIsRunning();
+        }
+
         [Fact]
         public async Task ShouldDisposeGracefull()
         {
@@ -124,5 +202,24 @@ public async Task ShouldConvertHtmlToPngNoSandbox(string testFileName)
             File.Delete(actualFilePath);
             await ChromiumProcessDisposedAsserter.AssertNoChromiumProcessIsRunning();
         }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!disposedValue)
+            {
+                if (disposing)
+                {
+                    Rasterize?.Dispose();
+                }
+
+                disposedValue = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(disposing: true);
+            GC.SuppressFinalize(this);
+        }
     }
 }