Refactor ValidationReportingTask to use ReportOptions parameter

msevestre · claude · msevestre · commit b28dcd7415cf · 2026-02-18T22:11:46.000-05:00
Replace DefaultFormat property with ReportOptions parameter that includes:
- ReportFormat as flags enum (None, Markdown, Pdf, All)
- OpenReport boolean
- Convenience properties ExportToMarkdown and ExportToPdf

This allows generating both Markdown and PDF reports in a single call
by using ReportFormat.All.

Co-Authored-By: Claude Opus 4.5 &lt;noreply@anthropic.com&gt;
diff --git a/src/InstallationValidator.Core/Presentation/MainPresenter.cs b/src/InstallationValidator.Core/Presentation/MainPresenter.cs
@@ -86,7 +86,7 @@ public async Task<InstallationValidationResult> StartInstallationValidation()
             validationResult.RunSummary = runSummary;
 
             this.LogLine(Logs.StartingReport);
-            await _validationReportingTask.CreateReport(validationResult, _outputFolderDTO.FolderPath, openReport: true);
+            await _validationReportingTask.CreateReport(validationResult, _outputFolderDTO.FolderPath, new ReportOptions(ReportFormat.Markdown, openReport: true));
             this.LogLine();
 
             this.LogLine(Logs.ValidationCompleted);
diff --git a/src/InstallationValidator.Core/Presentation/SimulationComparisonPresenter.cs b/src/InstallationValidator.Core/Presentation/SimulationComparisonPresenter.cs
@@ -70,7 +70,7 @@ public async Task StartComparison()
             this.LogLine();
 
             this.LogLine(Logs.StartingReport);
-            await _validationReportingTask.CreateReport(comparisonResult, _folderComparisonDTO.FirstFolder.FolderPath, _folderComparisonDTO.SecondFolder.FolderPath, openReport: true);
+            await _validationReportingTask.CreateReport(comparisonResult, _folderComparisonDTO.FirstFolder.FolderPath, _folderComparisonDTO.SecondFolder.FolderPath, new ReportOptions(ReportFormat.Markdown, openReport: true));
             this.LogLine();
 
             this.LogLine(Logs.ComparisonCompleted);
diff --git a/src/InstallationValidator.Core/Services/ValidationReportingTask.cs b/src/InstallationValidator.Core/Services/ValidationReportingTask.cs
@@ -1,54 +1,73 @@
+using System;
 using System.Threading.Tasks;
 using InstallationValidator.Core.Domain;
 
 namespace InstallationValidator.Core.Services
 {
-   public interface IValidationReportingTask
+   [Flags]
+   public enum ReportFormat
    {
-      Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, bool openReport = false);
-      Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, bool openReport);
+      None = 0,
+      Markdown = 1,
+      Pdf = 2,
+      All = Markdown | Pdf
    }
 
-   public enum ReportFormat
+   public class ReportOptions
+   {
+      public ReportFormat Format { get; }
+      public bool OpenReport { get; }
+
+      public bool ExportToMarkdown => Format.HasFlag(ReportFormat.Markdown);
+      public bool ExportToPdf => Format.HasFlag(ReportFormat.Pdf);
+
+      public ReportOptions(ReportFormat format, bool openReport)
+      {
+         Format = format;
+         OpenReport = openReport;
+      }
+   }
+
+   public interface IValidationReportingTask
    {
-      Markdown,
-      Pdf
+      Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, ReportOptions options);
+      Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, ReportOptions options);
    }
 
    public class ValidationReportingTask : IValidationReportingTask
    {
       private readonly IMarkdownReportingTask _markdownReportingTask;
       private readonly IPdfReportingTask _pdfReportingTask;
 
-      public ReportFormat DefaultFormat { get; set; } = ReportFormat.Markdown;
-
       public ValidationReportingTask(IMarkdownReportingTask markdownReportingTask, IPdfReportingTask pdfReportingTask)
       {
          _markdownReportingTask = markdownReportingTask;
          _pdfReportingTask = pdfReportingTask;
       }
 
-      public async Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, bool openReport = false)
+      public async Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, ReportOptions options)
       {
-         if (DefaultFormat == ReportFormat.Pdf)
+         if (options.ExportToMarkdown)
          {
-            await _pdfReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, openReport);
+            await _markdownReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, options.OpenReport);
          }
-         else
+
+         if (options.ExportToPdf)
          {
-            await _markdownReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, openReport);
+            await _pdfReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, options.OpenReport);
          }
       }
 
-      public async Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, bool openReport = false)
+      public async Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, ReportOptions options)
       {
-         if (DefaultFormat == ReportFormat.Pdf)
+         if (options.ExportToMarkdown)
          {
-            await _pdfReportingTask.CreateReport(installationValidationResult, outputFolderPath, openReport);
+            await _markdownReportingTask.CreateReport(installationValidationResult, outputFolderPath, options.OpenReport);
          }
-         else
+
+         if (options.ExportToPdf)
          {
-            await _markdownReportingTask.CreateReport(installationValidationResult, outputFolderPath, openReport);
+            await _pdfReportingTask.CreateReport(installationValidationResult, outputFolderPath, options.OpenReport);
          }
       }
    }
diff --git a/tests/InstallationValidator.Tests/Presentation/MainPresenterSpecs.cs b/tests/InstallationValidator.Tests/Presentation/MainPresenterSpecs.cs
@@ -178,7 +178,7 @@ public void should_state_the_comparison_task()
       [Observation]
       public void should_generate_the_report()
       {
-         A.CallTo(() => _validationReportingTask.CreateReport(_result, _outputFolderDTO.FolderPath, true)).MustHaveHappened();
+         A.CallTo(() => _validationReportingTask.CreateReport(_result, _outputFolderDTO.FolderPath, A<ReportOptions>._)).MustHaveHappened();
       }
    }
 
diff --git a/tests/InstallationValidator.Tests/Presentation/SimulationComparisonPresenterSpecs.cs b/tests/InstallationValidator.Tests/Presentation/SimulationComparisonPresenterSpecs.cs
@@ -9,6 +9,7 @@
 using InstallationValidator.Core.Presentation.Views;
 using InstallationValidator.Core.Services;
 using OSPSuite.BDDHelper;
+using OSPSuite.BDDHelper.Extensions;
 using OSPSuite.Core;
 using OSPSuite.Core.Services;
 
@@ -129,7 +130,7 @@ public void should_start_the_comparison_task()
       [Observation]
       public void should_generate_the_report()
       {
-         A.CallTo(() => _validationReportingTask.CreateReport(A<BatchComparisonResult>._, _firstFolder.FolderPath, _secondFolder.FolderPath, true)).MustHaveHappened();
+         A.CallTo(() => _validationReportingTask.CreateReport(A<BatchComparisonResult>._, _firstFolder.FolderPath, _secondFolder.FolderPath, A<ReportOptions>._)).MustHaveHappened();
       }
    }
 
diff --git a/tests/InstallationValidator.Tests/Services/ValidationReportingTaskSpecs.cs b/tests/InstallationValidator.Tests/Services/ValidationReportingTaskSpecs.cs
@@ -29,17 +29,11 @@ protected override void Context()
       }
    }
 
-   public class When_creating_report_with_default_markdown_format : concern_for_ValidationReportingTask
+   public class When_creating_report_with_markdown_format : concern_for_ValidationReportingTask
    {
-      protected override void Context()
-      {
-         base.Context();
-         sut.DefaultFormat = ReportFormat.Markdown;
-      }
-
       protected override void Because()
       {
-         sut.CreateReport(_installationValidationResult, _outputFolder).Wait();
+         sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Markdown, openReport: false)).Wait();
       }
 
       [Observation]
@@ -59,15 +53,9 @@ public void should_not_use_pdf_reporting_task()
 
    public class When_creating_report_with_pdf_format : concern_for_ValidationReportingTask
    {
-      protected override void Context()
-      {
-         base.Context();
-         sut.DefaultFormat = ReportFormat.Pdf;
-      }
-
       protected override void Because()
       {
-         sut.CreateReport(_installationValidationResult, _outputFolder).Wait();
+         sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Pdf, openReport: false)).Wait();
       }
 
       [Observation]
@@ -87,46 +75,91 @@ public void should_not_use_markdown_reporting_task()
 
    public class When_creating_report_with_open_report_flag : concern_for_ValidationReportingTask
    {
+      protected override void Because()
+      {
+         sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Markdown, openReport: true)).Wait();
+      }
+
+      [Observation]
+      public void should_pass_open_report_flag_to_underlying_task()
+      {
+         A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, true))
+            .MustHaveHappened();
+      }
+   }
+
+   public class When_creating_batch_comparison_report : concern_for_ValidationReportingTask
+   {
+      private BatchComparisonResult _batchComparisonResult;
+
       protected override void Context()
       {
          base.Context();
-         sut.DefaultFormat = ReportFormat.Markdown;
+         _batchComparisonResult = new BatchComparisonResult();
       }
 
       protected override void Because()
       {
-         sut.CreateReport(_installationValidationResult, _outputFolder, openReport: true).Wait();
+         sut.CreateReport(_batchComparisonResult, "folder1", "folder2", new ReportOptions(ReportFormat.Markdown, openReport: false)).Wait();
       }
 
       [Observation]
-      public void should_pass_open_report_flag_to_underlying_task()
+      public void should_use_markdown_reporting_task_for_batch_comparison()
       {
-         A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, true))
+         A.CallTo(() => _markdownReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))
             .MustHaveHappened();
       }
    }
 
-   public class When_creating_batch_comparison_report : concern_for_ValidationReportingTask
+   public class When_creating_report_with_all_formats : concern_for_ValidationReportingTask
+   {
+      protected override void Because()
+      {
+         sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.All, openReport: false)).Wait();
+      }
+
+      [Observation]
+      public void should_use_markdown_reporting_task()
+      {
+         A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, false))
+            .MustHaveHappened();
+      }
+
+      [Observation]
+      public void should_use_pdf_reporting_task()
+      {
+         A.CallTo(() => _pdfReportingTask.CreateReport(_installationValidationResult, _outputFolder, false))
+            .MustHaveHappened();
+      }
+   }
+
+   public class When_creating_batch_comparison_report_with_all_formats : concern_for_ValidationReportingTask
    {
       private BatchComparisonResult _batchComparisonResult;
 
       protected override void Context()
       {
          base.Context();
          _batchComparisonResult = new BatchComparisonResult();
-         sut.DefaultFormat = ReportFormat.Markdown;
       }
 
       protected override void Because()
       {
-         sut.CreateReport(_batchComparisonResult, "folder1", "folder2", openReport: false).Wait();
+         sut.CreateReport(_batchComparisonResult, "folder1", "folder2", new ReportOptions(ReportFormat.All, openReport: false)).Wait();
       }
 
       [Observation]
-      public void should_use_markdown_reporting_task_for_batch_comparison()
+      public void should_use_markdown_reporting_task()
       {
          A.CallTo(() => _markdownReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))
             .MustHaveHappened();
       }
+
+      [Observation]
+      public void should_use_pdf_reporting_task()
+      {
+         A.CallTo(() => _pdfReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))
+            .MustHaveHappened();
+      }
    }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,54 +1,73 @@`
	`1`	`+using System;`
`1`	`2`	`using System.Threading.Tasks;`
`2`	`3`	`using InstallationValidator.Core.Domain;`
`3`	`4`
`4`	`5`	`namespace InstallationValidator.Core.Services`
`5`	`6`	`{`
`6`		`- public interface IValidationReportingTask`
	`7`	`+ [Flags]`
	`8`	`+ public enum ReportFormat`
`7`	`9`	`{`
`8`		`- Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, bool openReport = false);`
`9`		`- Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, bool openReport);`
	`10`	`+ None = 0,`
	`11`	`+ Markdown = 1,`
	`12`	`+ Pdf = 2,`
	`13`	`+ All = Markdown \| Pdf`
`10`	`14`	`}`
`11`	`15`
`12`		`- public enum ReportFormat`
	`16`	`+ public class ReportOptions`
	`17`	`+ {`
	`18`	`+ public ReportFormat Format { get; }`
	`19`	`+ public bool OpenReport { get; }`
	`20`	`+`
	`21`	`+ public bool ExportToMarkdown => Format.HasFlag(ReportFormat.Markdown);`
	`22`	`+ public bool ExportToPdf => Format.HasFlag(ReportFormat.Pdf);`
	`23`	`+`
	`24`	`+ public ReportOptions(ReportFormat format, bool openReport)`
	`25`	`+ {`
	`26`	`+ Format = format;`
	`27`	`+ OpenReport = openReport;`
	`28`	`+ }`
	`29`	`+ }`
	`30`	`+`
	`31`	`+ public interface IValidationReportingTask`
`13`	`32`	`{`
`14`		`- Markdown,`
`15`		`- Pdf`
	`33`	`+ Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, ReportOptions options);`
	`34`	`+ Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, ReportOptions options);`
`16`	`35`	`}`
`17`	`36`
`18`	`37`	`public class ValidationReportingTask : IValidationReportingTask`
`19`	`38`	`{`
`20`	`39`	`private readonly IMarkdownReportingTask _markdownReportingTask;`
`21`	`40`	`private readonly IPdfReportingTask _pdfReportingTask;`
`22`	`41`
`23`		`- public ReportFormat DefaultFormat { get; set; } = ReportFormat.Markdown;`
`24`		`-`
`25`	`42`	`public ValidationReportingTask(IMarkdownReportingTask markdownReportingTask, IPdfReportingTask pdfReportingTask)`
`26`	`43`	`{`
`27`	`44`	`_markdownReportingTask = markdownReportingTask;`
`28`	`45`	`_pdfReportingTask = pdfReportingTask;`
`29`	`46`	`}`
`30`	`47`
`31`		`- public async Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, bool openReport = false)`
	`48`	`+ public async Task CreateReport(BatchComparisonResult comparisonResult, string firstFolderPath, string secondFolderPath, ReportOptions options)`
`32`	`49`	`{`
`33`		`- if (DefaultFormat == ReportFormat.Pdf)`
	`50`	`+ if (options.ExportToMarkdown)`
`34`	`51`	`{`
`35`		`- await _pdfReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, openReport);`
	`52`	`+ await _markdownReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, options.OpenReport);`
`36`	`53`	`}`
`37`		`- else`
	`54`	`+`
	`55`	`+ if (options.ExportToPdf)`
`38`	`56`	`{`
`39`		`- await _markdownReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, openReport);`
	`57`	`+ await _pdfReportingTask.CreateReport(comparisonResult, firstFolderPath, secondFolderPath, options.OpenReport);`
`40`	`58`	`}`
`41`	`59`	`}`
`42`	`60`
`43`		`- public async Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, bool openReport = false)`
	`61`	`+ public async Task CreateReport(InstallationValidationResult installationValidationResult, string outputFolderPath, ReportOptions options)`
`44`	`62`	`{`
`45`		`- if (DefaultFormat == ReportFormat.Pdf)`
	`63`	`+ if (options.ExportToMarkdown)`
`46`	`64`	`{`
`47`		`- await _pdfReportingTask.CreateReport(installationValidationResult, outputFolderPath, openReport);`
	`65`	`+ await _markdownReportingTask.CreateReport(installationValidationResult, outputFolderPath, options.OpenReport);`
`48`	`66`	`}`
`49`		`- else`
	`67`	`+`
	`68`	`+ if (options.ExportToPdf)`
`50`	`69`	`{`
`51`		`- await _markdownReportingTask.CreateReport(installationValidationResult, outputFolderPath, openReport);`
	`70`	`+ await _pdfReportingTask.CreateReport(installationValidationResult, outputFolderPath, options.OpenReport);`
`52`	`71`	`}`
`53`	`72`	`}`
`54`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ public void should_state_the_comparison_task()`
`178`	`178`	`[Observation]`
`179`	`179`	`public void should_generate_the_report()`
`180`	`180`	`{`
`181`		`- A.CallTo(() => _validationReportingTask.CreateReport(_result, _outputFolderDTO.FolderPath, true)).MustHaveHappened();`
	`181`	`+ A.CallTo(() => _validationReportingTask.CreateReport(_result, _outputFolderDTO.FolderPath, A<ReportOptions>._)).MustHaveHappened();`
`182`	`182`	`}`
`183`	`183`	`}`
`184`	`184`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@`
`9`	`9`	`using InstallationValidator.Core.Presentation.Views;`
`10`	`10`	`using InstallationValidator.Core.Services;`
`11`	`11`	`using OSPSuite.BDDHelper;`
	`12`	`+using OSPSuite.BDDHelper.Extensions;`
`12`	`13`	`using OSPSuite.Core;`
`13`	`14`	`using OSPSuite.Core.Services;`
`14`	`15`
`@@ -129,7 +130,7 @@ public void should_start_the_comparison_task()`
`129`	`130`	`[Observation]`
`130`	`131`	`public void should_generate_the_report()`
`131`	`132`	`{`
`132`		`- A.CallTo(() => _validationReportingTask.CreateReport(A<BatchComparisonResult>._, _firstFolder.FolderPath, _secondFolder.FolderPath, true)).MustHaveHappened();`
	`133`	`+ A.CallTo(() => _validationReportingTask.CreateReport(A<BatchComparisonResult>._, _firstFolder.FolderPath, _secondFolder.FolderPath, A<ReportOptions>._)).MustHaveHappened();`
`133`	`134`	`}`
`134`	`135`	`}`
`135`	`136`
Original file line number	Diff line number	Diff line change
`@@ -29,17 +29,11 @@ protected override void Context()`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`- public class When_creating_report_with_default_markdown_format : concern_for_ValidationReportingTask`
	`32`	`+ public class When_creating_report_with_markdown_format : concern_for_ValidationReportingTask`
`33`	`33`	`{`
`34`		`- protected override void Context()`
`35`		`- {`
`36`		`- base.Context();`
`37`		`- sut.DefaultFormat = ReportFormat.Markdown;`
`38`		`- }`
`39`		`-`
`40`	`34`	`protected override void Because()`
`41`	`35`	`{`
`42`		`- sut.CreateReport(_installationValidationResult, _outputFolder).Wait();`
	`36`	`+ sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Markdown, openReport: false)).Wait();`
`43`	`37`	`}`
`44`	`38`
`45`	`39`	`[Observation]`
`@@ -59,15 +53,9 @@ public void should_not_use_pdf_reporting_task()`
`59`	`53`
`60`	`54`	`public class When_creating_report_with_pdf_format : concern_for_ValidationReportingTask`
`61`	`55`	`{`
`62`		`- protected override void Context()`
`63`		`- {`
`64`		`- base.Context();`
`65`		`- sut.DefaultFormat = ReportFormat.Pdf;`
`66`		`- }`
`67`		`-`
`68`	`56`	`protected override void Because()`
`69`	`57`	`{`
`70`		`- sut.CreateReport(_installationValidationResult, _outputFolder).Wait();`
	`58`	`+ sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Pdf, openReport: false)).Wait();`
`71`	`59`	`}`
`72`	`60`
`73`	`61`	`[Observation]`
`@@ -87,46 +75,91 @@ public void should_not_use_markdown_reporting_task()`
`87`	`75`
`88`	`76`	`public class When_creating_report_with_open_report_flag : concern_for_ValidationReportingTask`
`89`	`77`	`{`
	`78`	`+ protected override void Because()`
	`79`	`+ {`
	`80`	`+ sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.Markdown, openReport: true)).Wait();`
	`81`	`+ }`
	`82`	`+`
	`83`	`+ [Observation]`
	`84`	`+ public void should_pass_open_report_flag_to_underlying_task()`
	`85`	`+ {`
	`86`	`+ A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, true))`
	`87`	`+ .MustHaveHappened();`
	`88`	`+ }`
	`89`	`+ }`
	`90`	`+`
	`91`	`+ public class When_creating_batch_comparison_report : concern_for_ValidationReportingTask`
	`92`	`+ {`
	`93`	`+ private BatchComparisonResult _batchComparisonResult;`
	`94`	`+`
`90`	`95`	`protected override void Context()`
`91`	`96`	`{`
`92`	`97`	`base.Context();`
`93`		`- sut.DefaultFormat = ReportFormat.Markdown;`
	`98`	`+ _batchComparisonResult = new BatchComparisonResult();`
`94`	`99`	`}`
`95`	`100`
`96`	`101`	`protected override void Because()`
`97`	`102`	`{`
`98`		`- sut.CreateReport(_installationValidationResult, _outputFolder, openReport: true).Wait();`
	`103`	`+ sut.CreateReport(_batchComparisonResult, "folder1", "folder2", new ReportOptions(ReportFormat.Markdown, openReport: false)).Wait();`
`99`	`104`	`}`
`100`	`105`
`101`	`106`	`[Observation]`
`102`		`- public void should_pass_open_report_flag_to_underlying_task()`
	`107`	`+ public void should_use_markdown_reporting_task_for_batch_comparison()`
`103`	`108`	`{`
`104`		`- A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, true))`
	`109`	`+ A.CallTo(() => _markdownReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))`
`105`	`110`	`.MustHaveHappened();`
`106`	`111`	`}`
`107`	`112`	`}`
`108`	`113`
`109`		`- public class When_creating_batch_comparison_report : concern_for_ValidationReportingTask`
	`114`	`+ public class When_creating_report_with_all_formats : concern_for_ValidationReportingTask`
	`115`	`+ {`
	`116`	`+ protected override void Because()`
	`117`	`+ {`
	`118`	`+ sut.CreateReport(_installationValidationResult, _outputFolder, new ReportOptions(ReportFormat.All, openReport: false)).Wait();`
	`119`	`+ }`
	`120`	`+`
	`121`	`+ [Observation]`
	`122`	`+ public void should_use_markdown_reporting_task()`
	`123`	`+ {`
	`124`	`+ A.CallTo(() => _markdownReportingTask.CreateReport(_installationValidationResult, _outputFolder, false))`
	`125`	`+ .MustHaveHappened();`
	`126`	`+ }`
	`127`	`+`
	`128`	`+ [Observation]`
	`129`	`+ public void should_use_pdf_reporting_task()`
	`130`	`+ {`
	`131`	`+ A.CallTo(() => _pdfReportingTask.CreateReport(_installationValidationResult, _outputFolder, false))`
	`132`	`+ .MustHaveHappened();`
	`133`	`+ }`
	`134`	`+ }`
	`135`	`+`
	`136`	`+ public class When_creating_batch_comparison_report_with_all_formats : concern_for_ValidationReportingTask`
`110`	`137`	`{`
`111`	`138`	`private BatchComparisonResult _batchComparisonResult;`
`112`	`139`
`113`	`140`	`protected override void Context()`
`114`	`141`	`{`
`115`	`142`	`base.Context();`
`116`	`143`	`_batchComparisonResult = new BatchComparisonResult();`
`117`		`- sut.DefaultFormat = ReportFormat.Markdown;`
`118`	`144`	`}`
`119`	`145`
`120`	`146`	`protected override void Because()`
`121`	`147`	`{`
`122`		`- sut.CreateReport(_batchComparisonResult, "folder1", "folder2", openReport: false).Wait();`
	`148`	`+ sut.CreateReport(_batchComparisonResult, "folder1", "folder2", new ReportOptions(ReportFormat.All, openReport: false)).Wait();`
`123`	`149`	`}`
`124`	`150`
`125`	`151`	`[Observation]`
`126`		`- public void should_use_markdown_reporting_task_for_batch_comparison()`
	`152`	`+ public void should_use_markdown_reporting_task()`
`127`	`153`	`{`
`128`	`154`	`A.CallTo(() => _markdownReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))`
`129`	`155`	`.MustHaveHappened();`
`130`	`156`	`}`
	`157`	`+`
	`158`	`+ [Observation]`
	`159`	`+ public void should_use_pdf_reporting_task()`
	`160`	`+ {`
	`161`	`+ A.CallTo(() => _pdfReportingTask.CreateReport(_batchComparisonResult, "folder1", "folder2", false))`
	`162`	`+ .MustHaveHappened();`
	`163`	`+ }`
`131`	`164`	`}`
`132`	`165`	`}`