public static FileInfo GetHtmlFormattedReport(string sessionId, bool condensed)
{
IDiskCacheGroup group = GetReportCacheGroup(sessionId);
string directory = condensed ? "Condensed" : "Full";
FileInfo htmlReportFile = group.GetFileInfo(Path.Combine(directory, HtmlReportFileName));
if (!htmlReportFile.Exists)
{
Report report = LoadSerializedReport(sessionId);
if (report == null)
{
return(null);
}
group.CreateSubdirectory(directory);
IReportManager reportManager = RuntimeAccessor.ServiceLocator.Resolve <IReportManager>();
FileSystemReportContainer reportContainer = new FileSystemReportContainer(htmlReportFile.DirectoryName, ReportBaseName);
IReportWriter reportWriter = reportManager.CreateReportWriter(report, reportContainer);
var reportFormatterOptions = new ReportFormatterOptions();
reportManager.Format(reportWriter, condensed ? "Html-Condensed" : "Html", reportFormatterOptions, NullProgressMonitor.CreateInstance());
}
return(htmlReportFile);
}
/// <summary>
/// Gets the report page size.
/// </summary>
/// <param name="options">The formatter options.</param>
/// <returns>The report page size.</returns>
protected int GetReportPageSize(ReportFormatterOptions options)
{
int value;
string field = options.Properties.GetValue(ReportPageSizeOption);
return((field != null) && Int32.TryParse(field, out value) ? value : -1);
}
/// <summary>
/// Parses the key/value array of property strings and build an option bag for the report formatter from them.
/// </summary>
/// <param name="properties">Key/value array of property strings</param>
/// <returns>The report formatter options.</returns>
protected static ReportFormatterOptions ParseOptions(string[] properties)
{
var options = new ReportFormatterOptions();
foreach (string option in properties)
{
KeyValuePair <string, string> pair = StringUtils.ParseKeyValuePair(option);
options.AddProperty(pair.Key, pair.Value);
}
return(options);
}
/// <summary>
/// Creates a launcher with default options and no test assemblies specified.
/// </summary>
public TestLauncher()
{
filePatterns = new List <string>();
testProject = new TestProject();
testRunnerOptions = new TestRunnerOptions();
testExplorationOptions = new TestExplorationOptions();
testExecutionOptions = new TestExecutionOptions();
reportFormats = new List <string>();
reportFormatterOptions = new ReportFormatterOptions();
progressMonitorProvider = NullProgressMonitorProvider.Instance;
logger = NullLogger.Instance;
}
public void FormatWritesTheTransformedReport()
{
string resourcePath = Path.Combine(Path.GetDirectoryName(AssemblyUtils.GetAssemblyLocalPath(GetType().Assembly)), @"..\Reports");
IReportWriter reportWriter = Mocks.StrictMock <IReportWriter>();
IReportContainer reportContainer = Mocks.StrictMock <IReportContainer>();
IProgressMonitor progressMonitor = NullProgressMonitor.CreateInstance();
string reportPath = SpecialPathPolicy.For <XsltReportFormatter>().CreateTempFileWithUniqueName().FullName;
using (Stream tempFileStream = File.OpenWrite(reportPath))
{
using (Mocks.Record())
{
SetupResult.For(reportWriter.ReportContainer).Return(reportContainer);
reportWriter.SerializeReport(null, AttachmentContentDisposition.Link);
LastCall.Constraints(Is.NotNull(), Is.Equal(AttachmentContentDisposition.Link))
.Do((SerializeReportDelegate) delegate(XmlWriter writer, AttachmentContentDisposition contentDisposition)
{
XmlDocument doc = new XmlDocument();
doc.InnerXml = "<report>The report.</report>";
doc.Save(writer);
});
SetupResult.For(reportContainer.ReportName).Return("Foo");
Expect.Call(reportContainer.OpenWrite("Foo.ext", MimeTypes.PlainText, new UTF8Encoding(false)))
.Return(tempFileStream);
reportWriter.AddReportDocumentPath("Foo.ext");
Expect.Call(reportContainer.OpenWrite(@"Foo\MbUnitLogo.png", MimeTypes.Png, null)).Return(new MemoryStream());
reportWriter.SaveReportAttachments(null);
LastCall.Constraints(Is.NotNull());
}
using (Mocks.Playback())
{
XsltReportFormatter formatter = new XsltReportFormatter("ext", MimeTypes.PlainText, new DirectoryInfo(resourcePath), "Diagnostic.xslt", new string[] { "MbUnitLogo.png" });
var reportFormatterOptions = new ReportFormatterOptions();
reportFormatterOptions.AddProperty(XsltReportFormatter.AttachmentContentDispositionOption, AttachmentContentDisposition.Link.ToString());
formatter.Format(reportWriter, reportFormatterOptions, progressMonitor);
string reportContents = File.ReadAllText(reportPath);
TestLog.EmbedXml("Diagnostic report contents", reportContents);
Assert.Contains(reportContents, "<resourceRoot>Foo</resourceRoot>");
Assert.Contains(reportContents, "The report.");
File.Delete(reportPath);
}
}
}
/// <summary>
/// Generates reports of the desired forms.
/// </summary>
/// <remarks>
/// <para>
/// This method adds the paths of the generated report documents to <see cref="ReportDocumentPaths" />.
/// </para>
/// </remarks>
/// <param name="reportDirectory">The report directory.</param>
/// <param name="reportName">The report name.</param>
/// <param name="reportArchive">Determines whether to enclose the resulting test report in a compressed archive file.</param>
/// <param name="reportFormats">The report formats to generate.</param>
/// <param name="reportFormatOptions">The report formatter options.</param>
/// <param name="reportManager">The report manager.</param>
/// <param name="progressMonitor">A progress monitor for the operation.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="reportDirectory"/>,
/// <paramref name="reportName"/>, <paramref name="reportFormats"/>, <paramref name="reportFormatOptions"/>,
/// <paramref name="reportManager"/>, or <paramref name="progressMonitor"/> is null.</exception>
public void GenerateReports(string reportDirectory, string reportName, ReportArchive reportArchive, IList <string> reportFormats,
ReportFormatterOptions reportFormatOptions, IReportManager reportManager, IProgressMonitor progressMonitor)
{
if (reportDirectory == null)
{
throw new ArgumentNullException("reportDirectory");
}
if (reportName == null)
{
throw new ArgumentNullException("reportName");
}
if (reportFormats == null)
{
throw new ArgumentNullException("reportFormats");
}
if (reportFormatOptions == null)
{
throw new ArgumentNullException("reportFormatOptions");
}
if (reportManager == null)
{
throw new ArgumentNullException("reportManager");
}
if (progressMonitor == null)
{
throw new ArgumentNullException("progressMonitor");
}
var factory = new ReportContainerFactory(new FileSystem(), reportDirectory, reportName);
using (progressMonitor.BeginTask("Generating reports.", reportFormats.Count))
using (IReportContainer reportContainer = factory.MakeForSaving(reportArchive))
{
IReportWriter reportWriter = reportManager.CreateReportWriter(report, reportContainer);
// Delete the report if it exists already.
reportContainer.DeleteReport();
// Format the report in all of the desired ways.
foreach (string reportFormat in reportFormats)
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(1))
reportManager.Format(reportWriter, reportFormat, reportFormatOptions, subProgressMonitor);
}
// Save the full paths of the documents.
foreach (string reportDocumentPath in reportWriter.ReportDocumentPaths)
{
AddReportDocumentPath(Path.Combine(reportDirectory, reportDocumentPath));
}
}
}
public void FormatWritesTheReportWithTheDefaultAttachmentContentDispositionIfNoneSpecified()
{
IProgressMonitor progressMonitor = Mocks.Stub <IProgressMonitor>();
IReportWriter writer = Mocks.StrictMock <IReportWriter>();
using (Mocks.Record())
{
writer.SaveReport(AttachmentContentDisposition.Absent, progressMonitor);
}
using (Mocks.Playback())
{
XmlReportFormatter formatter = new XmlReportFormatter();
var reportFormatterOptions = new ReportFormatterOptions();
formatter.Format(writer, reportFormatterOptions, progressMonitor);
}
}
/// <summary>
/// Gets the attachment content disposition.
/// </summary>
/// <param name="options">The formatter options.</param>
/// <returns>The attachment content disposition.</returns>
protected AttachmentContentDisposition GetAttachmentContentDisposition(ReportFormatterOptions options)
{
string contentDisposition = options.Properties.GetValue(AttachmentContentDispositionOption);
if (contentDisposition != null)
{
try
{
return((AttachmentContentDisposition)Enum.Parse(typeof(AttachmentContentDisposition), contentDisposition, true));
}
catch (ArgumentException)
{
// Ignore parse error.
}
}
return(DefaultAttachmentContentDisposition);
}
public string SaveReportAs(Report report, string fileName, string format, IProgressMonitor progressMonitor)
{
var file = string.Empty;
using (progressMonitor.BeginTask("Generating report", 100))
{
var folderName = Path.GetDirectoryName(fileName);
var reportContainer = new FileSystemReportContainer(folderName,
Path.GetFileNameWithoutExtension(fileName));
var reportWriter = reportManager.CreateReportWriter(report, reportContainer);
if (progressMonitor.IsCanceled)
{
throw new OperationCanceledException();
}
// Delete the report if it already exists
reportContainer.DeleteReport();
if (progressMonitor.IsCanceled)
{
throw new OperationCanceledException();
}
progressMonitor.Worked(10);
// Format the report
var reportFormatterOptions = new ReportFormatterOptions();
using (var subProgressMonitor = progressMonitor.CreateSubProgressMonitor(90))
reportManager.Format(reportWriter, format, reportFormatterOptions, subProgressMonitor);
if (progressMonitor.IsCanceled)
{
throw new OperationCanceledException();
}
if (reportWriter.ReportDocumentPaths.Count > 0)
{
file = Path.Combine(folderName, reportWriter.ReportDocumentPaths[0]);
}
}
return(file);
}
public void FormatWritesTheReportWithTheSpecifiedAttachmentContentDisposition()
{
IProgressMonitor progressMonitor = Mocks.Stub <IProgressMonitor>();
IReportWriter writer = Mocks.StrictMock <IReportWriter>();
using (Mocks.Record())
{
writer.SaveReport(AttachmentContentDisposition.Link, progressMonitor);
}
using (Mocks.Playback())
{
XmlReportFormatter formatter = new XmlReportFormatter();
ReportFormatterOptions options = new ReportFormatterOptions();
options.AddProperty(XmlReportFormatter.AttachmentContentDispositionOption, AttachmentContentDisposition.Link.ToString());
formatter.Format(writer, options, progressMonitor);
}
}
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions formatterOptions, IProgressMonitor progressMonitor)
{
using (progressMonitor.BeginTask("Formatting report.", 10))
{
using (MultipartMimeReportContainer archiveContainer = new MultipartMimeReportContainer(reportWriter.ReportContainer))
{
string archivePath = archiveContainer.ReportName + ".mht";
reportWriter.AddReportDocumentPath(archivePath);
archiveContainer.OpenArchive(archivePath);
progressMonitor.Worked(0.5);
DefaultReportWriter archiveWriter = new DefaultReportWriter(reportWriter.Report, archiveContainer);
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(9))
htmlReportFormatter.Format(archiveWriter, formatterOptions, subProgressMonitor);
archiveContainer.CloseArchive();
progressMonitor.Worked(0.5);
}
}
}
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions options, IProgressMonitor progressMonitor)
{
AttachmentContentDisposition attachmentContentDisposition = GetAttachmentContentDisposition(options);
using (progressMonitor.BeginTask("Formatting report.", 10))
{
progressMonitor.SetStatus("Applying template.");
ApplyTemplate(reportWriter, attachmentContentDisposition, options);
progressMonitor.Worked(3);
progressMonitor.SetStatus("Copying resources.");
CopyResources(reportWriter);
progressMonitor.Worked(2);
progressMonitor.SetStatus(@"");
if (attachmentContentDisposition == AttachmentContentDisposition.Link)
{
using (IProgressMonitor subProgressMonitor = progressMonitor.CreateSubProgressMonitor(5))
reportWriter.SaveReportAttachments(subProgressMonitor);
}
}
}
public void FormatWritesTheArchivedReport()
{
IReportWriter reportWriter = Mocks.StrictMock <IReportWriter>();
IReportContainer reportContainer = Mocks.StrictMock <IReportContainer>();
IReportFormatter htmlReportFormatter = Mocks.StrictMock <IReportFormatter>();
IProgressMonitor progressMonitor = NullProgressMonitor.CreateInstance();
var reportFormatterOptions = new ReportFormatterOptions();
string reportPath = SpecialPathPolicy.For <MHtmlReportFormatterTest>().CreateTempFileWithUniqueName().FullName;
using (Stream tempFileStream = File.OpenWrite(reportPath))
{
using (Mocks.Record())
{
SetupResult.For(reportWriter.ReportContainer).Return(reportContainer);
SetupResult.For(reportWriter.Report).Return(new Report());
Expect.Call(reportContainer.EncodeFileName(null))
.Repeat.Any()
.IgnoreArguments()
.Do((Gallio.Common.GallioFunc <string, string>) delegate(string value) { return(value); });
SetupResult.For(reportContainer.ReportName).Return("Foo");
Expect.Call(reportContainer.OpenWrite("Foo.mht", MimeTypes.MHtml, new UTF8Encoding(false)))
.Return(tempFileStream);
reportWriter.AddReportDocumentPath("Foo.mht");
Expect.Call(delegate { htmlReportFormatter.Format(null, null, null); })
.Constraints(Is.NotNull(), Is.Same(reportFormatterOptions), Is.NotNull())
.Do((FormatDelegate) delegate(IReportWriter innerReportWriter, ReportFormatterOptions innerFormatterOptions, IProgressMonitor innerProgressMonitor)
{
using (StreamWriter contentWriter = new StreamWriter(innerReportWriter.ReportContainer.OpenWrite("Foo.html", MimeTypes.Html, Encoding.UTF8)))
contentWriter.Write("<html><body>Some HTML</body></html>");
using (StreamWriter contentWriter = new StreamWriter(innerReportWriter.ReportContainer.OpenWrite(
innerReportWriter.ReportContainer.EncodeFileName("Foo\\Attachment 1%.txt"), MimeTypes.PlainText, Encoding.UTF8)))
contentWriter.Write("An attachment.");
using (StreamWriter contentWriter = new StreamWriter(innerReportWriter.ReportContainer.OpenWrite("Foo.css", null, null)))
contentWriter.Write("#Some CSS.");
});
}
using (Mocks.Playback())
{
MHtmlReportFormatter formatter = new MHtmlReportFormatter(htmlReportFormatter);
formatter.Format(reportWriter, reportFormatterOptions, progressMonitor);
string reportContents = File.ReadAllText(reportPath);
TestLog.AttachPlainText("MHTML Report", reportContents);
Assert.Contains(reportContents, "MIME-Version: 1.0");
Assert.Contains(reportContents, "Content-Type: multipart/related; type=\"text/html\"; boundary=");
Assert.Contains(reportContents, "This is a multi-part message in MIME format.");
Assert.Contains(reportContents, "text/html");
Assert.Contains(reportContents, "Content-Location: file:///Foo.html");
Assert.Contains(reportContents, Convert.ToBase64String(Encoding.UTF8.GetBytes("<html><body>Some HTML</body></html>"), Base64FormattingOptions.InsertLineBreaks));
Assert.Contains(reportContents, "text/plain");
Assert.Contains(reportContents, "Content-Location: file:///Foo/Attachment_1%25.txt");
Assert.Contains(reportContents, Convert.ToBase64String(Encoding.UTF8.GetBytes("An attachment."), Base64FormattingOptions.InsertLineBreaks));
Assert.Contains(reportContents, "text/css");
Assert.Contains(reportContents, "Content-Location: file:///Foo.css");
Assert.Contains(reportContents, Convert.ToBase64String(Encoding.UTF8.GetBytes("#Some CSS."), Base64FormattingOptions.InsertLineBreaks));
File.Delete(reportPath);
}
}
}
/// <inheritdoc /> public abstract void Format(IReportWriter reportWriter, ReportFormatterOptions formatterOptions, IProgressMonitor progressMonitor);
/// <inheritdoc />
public override void Format(IReportWriter reportWriter, ReportFormatterOptions options, IProgressMonitor progressMonitor)
{
AttachmentContentDisposition attachmentContentDisposition = GetAttachmentContentDisposition(options);
reportWriter.SaveReport(attachmentContentDisposition, progressMonitor);
}
private VtlReportWriter GetReportWriter(VelocityEngine velocityEngine, VelocityContext velocityContext, IReportWriter reportWriter, FormatHelper helper, ReportFormatterOptions options)
{
int pageSize = GetReportPageSize(options);
int testCount = (reportWriter.Report.TestPackageRun == null) ? 0 : reportWriter.Report.TestPackageRun.Statistics.TestCount;
if (pageSize < 0)
{
HtmlReportSplitSettings settings = preferenceManager.HtmlReportSplitSettings;
pageSize = settings.Enabled ? settings.PageSize : 0;
}
if (supportSplit && pageSize > 0 && testCount > pageSize)
{
return(new MultipleFilesVtlReportWriter(velocityEngine, velocityContext, reportWriter, templatePath, contentType, extension, helper, pageSize));
}
return(new SingleFileVtlReportWriter(velocityEngine, velocityContext, reportWriter, templatePath, contentType, extension, helper));
}
/// <summary>
/// Applies the template to produce a report.
/// </summary>
protected virtual void ApplyTemplate(IReportWriter reportWriter, AttachmentContentDisposition attachmentContentDisposition, ReportFormatterOptions options)
{
VelocityEngine velocityEngine = VelocityEngineFactory.CreateVelocityEngine();
var helper = new FormatHelper();
VelocityContext velocityContext = VelocityEngineFactory.CreateVelocityContext(reportWriter, helper);
var writer = GetReportWriter(velocityEngine, velocityContext, reportWriter, helper, options);
reportWriter.WithUpdatedContentPathsAndDisposition(attachmentContentDisposition, writer.Run);
}
/// <summary>
/// Saves the specified report.
/// </summary>
/// <param name="report"></param>
/// <param name="reportArchive"></param>
/// <param name="formatterName"></param>
/// <param name="outputPath"></param>
/// <param name="getOutputName"></param>
/// <param name="options"></param>
/// <returns></returns>
protected bool SaveReport(Report report, ReportArchive reportArchive, string formatterName, string outputPath, Func <string> getOutputName, ReportFormatterOptions options)
{
return(CaptureFileException(() => "The specified output directory is not a valid file path.", () =>
{
var factory = new ReportContainerFactory(new FileSystem(), outputPath, getOutputName());
using (IReportContainer outputContainer = factory.MakeForSaving(reportArchive))
{
IReportWriter reportWriter = reportManager.CreateReportWriter(report, outputContainer);
Context.ProgressMonitorProvider.Run(pm => reportManager.Format(reportWriter, formatterName, options, pm));
return true;
}
}));
}
private FacadeTestRunState Run(IFacadeTestListener testListener, string assemblyPath, Filter <ITestDescriptor> filter, FacadeOptions facadeOptions)
{
if (testListener == null)
{
throw new ArgumentNullException(@"testListener");
}
if (assemblyPath == null)
{
throw new ArgumentNullException("assemblyPath");
}
if (facadeOptions == null)
{
throw new ArgumentNullException("facadeOptions");
}
ILogger logger = new FilteredLogger(new TDNetLogger(testListener), LogSeverity.Info);
try
{
RuntimeAccessor.Instance.AddLogListener(logger);
var filterRules = new List <FilterRule <ITestDescriptor> >();
switch (facadeOptions.FilterCategoryMode)
{
case FacadeFilterCategoryMode.Disabled:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
case FacadeFilterCategoryMode.Include:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion,
new AndFilter <ITestDescriptor>(new[] { filter, ToCategoryFilter(facadeOptions.FilterCategoryNames) })));
break;
case FacadeFilterCategoryMode.Exclude:
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Exclusion, ToCategoryFilter(facadeOptions.FilterCategoryNames)));
filterRules.Add(new FilterRule <ITestDescriptor>(FilterRuleType.Inclusion, filter));
break;
}
var filterSet = new FilterSet <ITestDescriptor>(filterRules);
launcher.Logger = logger;
launcher.ProgressMonitorProvider = new LogProgressMonitorProvider(logger);
launcher.TestExecutionOptions.FilterSet = filterSet;
launcher.TestProject.TestRunnerFactoryName = StandardTestRunnerFactoryNames.IsolatedAppDomain;
launcher.TestProject.AddTestRunnerExtension(new TDNetExtension(testListener)); // This monitor will inform the user in real-time what's going on
launcher.TestProject.TestPackage.AddFile(new FileInfo(assemblyPath));
string assemblyDirectory = Path.GetDirectoryName(assemblyPath);
launcher.TestProject.TestPackage.ApplicationBaseDirectory = new DirectoryInfo(assemblyDirectory);
launcher.TestProject.TestPackage.WorkingDirectory = new DirectoryInfo(assemblyDirectory);
TestLauncherResult result = RunLauncher(launcher);
string reportDirectory = GetReportDirectory(logger);
if (reportDirectory != null)
{
var reportFormatterOptions = new ReportFormatterOptions();
var preferenceManager = (TDNetPreferenceManager)RuntimeAccessor.ServiceLocator.ResolveByComponentId("TDNetRunner.PreferenceManager");
var reportFormat = preferenceManager.ReportSettings.DetermineReportFormat(result.Report);
result.GenerateReports(reportDirectory, Path.GetFileName(assemblyPath), ReportArchive.Normal,
new[] { reportFormat }, reportFormatterOptions,
RuntimeAccessor.ServiceLocator.Resolve <IReportManager>(), NullProgressMonitor.CreateInstance());
// This will generate a link to the generated report
if (result.ReportDocumentPaths.Count != 0)
{
Uri rawUrl = new Uri(result.ReportDocumentPaths[0]);
string displayUrl = "file:///" + rawUrl.LocalPath.Replace(" ", "%20").Replace(@"\", "/");
// TDNet just prints the link on its own but it's not always clear to users what it represents.
// testListener.TestResultsUrl(displayUrl);
testListener.WriteLine("\nTest Report: " + displayUrl, FacadeCategory.Info);
}
}
// Inform no tests run, if necessary.
if (result.ResultCode == ResultCode.NoTests)
{
InformNoTestsWereRun(testListener, Resources.MbUnitTestRunner_NoTestsFound);
}
else if (result.Statistics.TestCount == 0)
{
InformNoTestsWereRun(testListener, null);
}
return(GetTestRunState(result));
}
finally
{
RuntimeAccessor.Instance.RemoveLogListener(logger);
}
}
/// <summary>
/// Populates the arguments for the XSL template processing.
/// </summary>
protected virtual void PopulateArguments(XsltArgumentList arguments, ReportFormatterOptions options, string reportName)
{
arguments.AddParam(@"resourceRoot", @"", reportName);
}
/// <summary>
/// Applies the transform to produce a report.
/// </summary>
protected virtual void ApplyTransform(IReportWriter reportWriter, AttachmentContentDisposition attachmentContentDisposition, ReportFormatterOptions options)
{
XsltArgumentList arguments = new XsltArgumentList();
PopulateArguments(arguments, options, reportWriter.ReportContainer.ReportName);
XPathDocument document = SerializeReportToXPathDocument(reportWriter, attachmentContentDisposition);
string reportPath = reportWriter.ReportContainer.ReportName + @"." + extension;
Encoding encoding = new UTF8Encoding(false);
XslCompiledTransform transform = Transform;
XmlWriterSettings settings = transform.OutputSettings.Clone();
settings.CheckCharacters = false;
settings.Encoding = encoding;
settings.CloseOutput = true;
using (XmlWriter writer = XmlWriter.Create(reportWriter.ReportContainer.OpenWrite(reportPath, contentType, encoding), settings))
transform.Transform(document, arguments, writer);
reportWriter.AddReportDocumentPath(reportPath);
}
