public void RestoreResults(TestNode testNode)
{
var result = _model.GetResultForTest(testNode.Id);
if (result != null)
{
SetTestResult(result);
foreach (TestNode child in testNode.Children)
{
RestoreResults(child);
}
}
}
private XmlNode GetFullXml(TestNode testNode)
{
ResultNode resultNode = _model.GetResultForTest(testNode);
XmlNode currentXml;
if (resultNode != null)
{
currentXml = resultNode.Xml.Clone();
foreach (TestNode child in testNode.Children)
{
XmlNode childXml = GetFullXml(child);
XmlNode importedChildXml = currentXml.OwnerDocument.ImportNode(childXml, true);
currentXml.AppendChild(importedChildXml);
}
}
else
{
currentXml = testNode.Xml.Clone();
foreach (TestNode child in testNode.Children)
{
XmlNode childXml = GetFullXml(child);
XmlNode importedChildXml = currentXml.OwnerDocument.ImportNode(childXml, true);
var oldChild = FindXmlNode(currentXml, child);
if (oldChild != null)
{
currentXml.ReplaceChild(importedChildXml, oldChild);
}
else
{
currentXml.AppendChild(importedChildXml);
}
}
}
return(currentXml);
}
public void Display(TreeNode treeNode)
{
if (treeNode == null)
{
throw new ArgumentNullException(nameof(treeNode));
}
_treeNode = treeNode;
_testNode = (TestNode)treeNode.Tag;
_resultNode = _model.GetResultForTest(_testNode.Id);
_packageSettings = _model.GetPackageSettingsForTest(_testNode.Id);
testResult.Text = _resultNode?.Outcome.ToString() ?? _testNode.RunState.ToString();
testResult.Font = new Font(this.Font, FontStyle.Bold);
if (_testNode.Type == "Project" || _testNode.Type == "Assembly")
{
TestName = Path.GetFileName(_testNode.Name);
}
else
{
TestName = _testNode.Name;
}
// Display each groupBox, for which there is data.
// Boxes are displayed top-down at the vertical
// offset
int verticalOffset = packageGroupBox.Top;
if (_packageSettings != null)
{
verticalOffset = DisplayPackageGroupBox(verticalOffset) + 4;
}
else
{
packageGroupBox.Hide();
}
// Test details are always shown
verticalOffset = DisplayTestGroupBox(verticalOffset) + 4;
if (_resultNode != null)
{
verticalOffset = DisplayResultGroupBox(verticalOffset) + 4;
}
else
{
resultGroupBox.Hide();
}
ClientSize = new Size(
ClientSize.Width, verticalOffset);
Rectangle screenArea = Screen.GetWorkingArea(this);
Location = new Point(
Location.X,
Math.Max(0, Math.Min(Location.Y, screenArea.Bottom - Height)));
Show();
}
public ResultNode GetResultForTest(TestNode testNode)
{
return(_model.GetResultForTest(testNode));
}
private void WireUpEvents()
{
#region Model Events
_model.Events.TestsLoading += (TestFilesLoadingEventArgs e) =>
{
UpdateViewCommands(testLoading: true);
var message = e.TestFilesLoading.Count == 1 ?
$"Loading Assembly: {e.TestFilesLoading[0]}" :
$"Loading {e.TestFilesLoading.Count} Assemblies...";
BeginLongRunningOperation(message);
};
_model.Events.TestLoaded += (TestNodeEventArgs e) =>
{
OnLongRunningOperationComplete();
UpdateViewCommands();
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
_lastFilesLoaded = _model.TestFiles.ToArray();
if (_lastFilesLoaded.Length == 1)
{
_view.SetTitleBar(_lastFilesLoaded.First());
}
};
_model.Events.TestsUnloading += (TestEventArgse) =>
{
UpdateViewCommands();
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
BeginLongRunningOperation("Unloading...");
};
_model.Events.TestUnloaded += (TestEventArgs e) =>
{
OnLongRunningOperationComplete();
UpdateViewCommands();
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
};
_model.Events.TestsReloading += (TestEventArgs e) =>
{
UpdateViewCommands();
BeginLongRunningOperation("Reloading...");
};
_model.Events.TestReloaded += (TestNodeEventArgs e) =>
{
OnLongRunningOperationComplete();
UpdateViewCommands();
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
};
_model.Events.TestLoadFailure += (TestLoadFailureEventArgs e) =>
{
OnLongRunningOperationComplete();
// HACK: Engine should recognize .NET Standard and give the
// appropriate error message. For now, we compensate for its
// failure by issuing the message ourselves and reloading the
// previously loaded test.
var msg = e.Exception.Message;
bool isNetStandardError =
e.Exception.Message == "Unrecognized Target Framework Identifier: .NETStandard";
if (!isNetStandardError)
{
_view.MessageDisplay.Error(e.Exception.Message);
return;
}
_view.MessageDisplay.Error("Test assemblies must target a specific platform, rather than .NETStandard.");
if (_lastFilesLoaded == null)
{
_view.Close();
}
else
{
_model.UnloadTests();
_model.LoadTests(_lastFilesLoaded);
}
};
_model.Events.RunStarting += (RunStartingEventArgs e) =>
{
UpdateViewCommands();
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
_view.RunSummaryButton.Visible = false;
};
_model.Events.RunFinished += (TestResultEventArgs e) => OnRunFinished(e.Result);
// Separate internal method for testing
void OnRunFinished(ResultNode result)
{
OnLongRunningOperationComplete();
UpdateViewCommands();
// Reset these in case run was cancelled
_view.StopRunMenuCommand.Visible = true;
_view.ForceStopMenuCommand.Visible = false;
_view.StopRunButton.Visible = true;
_view.ForceStopButton.Visible = false;
_view.RunSummaryButton.Visible = true;
//string resultPath = Path.Combine(TestProject.BasePath, "TestResult.xml");
// TODO: Use Work Directory
string resultPath = "TestResult.xml";
_model.SaveResults(resultPath);
//try
//{
// _model.SaveResults(resultPath);
// //log.Debug("Saved result to {0}", resultPath);
//}
//catch (Exception ex)
//{
// //log.Warning("Unable to save result to {0}\n{1}", resultPath, ex.ToString());
//}
//if (e.Result.Outcome.Status == TestStatus.Failed)
// _view.Activate();
// If we were running unattended, it's time to close
if (_options.Unattended)
{
_view.Close();
}
else
{
DisplayTestRunSummary(result, true);
}
};
_settings.Changed += (s, e) =>
{
switch (e.SettingName)
{
case "TestCentric.Gui.GuiLayout":
// Settings have changed (from settings dialog)
// so we want to update the GUI to match.
var newLayout = _settings.Gui.GuiLayout;
var oldLayout = _view.GuiLayout.SelectedItem;
// Make sure it hasn't already been changed
if (oldLayout != newLayout)
{
// Save position of form for old layout
SaveFormLocationAndSize(oldLayout);
// Update the GUI itself
SetGuiLayout(newLayout);
_view.GuiLayout.SelectedItem = newLayout;
}
break;
case "TestCentric.Gui.MainForm.ShowStatusBar":
_view.StatusBarView.Visible = _settings.Gui.MainForm.ShowStatusBar;
break;
}
};
_model.Events.UnhandledException += (UnhandledExceptionEventArgs e) =>
{
MessageBoxDisplay.Error($"{e.Message}\n\n{e.StackTrace}", "TestCentric - Internal Error");
};
#endregion
#region View Events
_view.Load += (s, e) =>
{
var guiLayout = _settings.Gui.GuiLayout;
_view.GuiLayout.SelectedItem = guiLayout;
SetGuiLayout(guiLayout);
var settings = _model.PackageOverrides;
if (_options.MaxAgents >= 0)
{
_model.Settings.Engine.Agents = _options.MaxAgents;
}
_view.RunAsX86.Checked = _options.RunAsX86;
};
_view.Shown += (s, e) =>
{
Application.DoEvents();
// Load test specified on command line or
// the most recent one if options call for it
if (_options.InputFiles.Count != 0)
{
LoadTests(_options.InputFiles);
}
else if (_settings.Gui.LoadLastProject && !_options.NoLoad)
{
foreach (string entry in _recentFiles.Entries)
{
if (entry != null && File.Exists(entry))
{
LoadTests(entry);
break;
}
}
}
//if ( guiOptions.include != null || guiOptions.exclude != null)
//{
// testTree.ClearSelectedCategories();
// bool exclude = guiOptions.include == null;
// string[] categories = exclude
// ? guiOptions.exclude.Split(',')
// : guiOptions.include.Split(',');
// if ( categories.Length > 0 )
// testTree.SelectCategories( categories, exclude );
//}
// Run loaded test automatically if called for
if (_model.IsPackageLoaded && _options.RunAllTests)
{
RunAllTests();
}
// Currently, --unattended without --run does nothing except exit.
else if (_options.Unattended)
{
_view.Close();
}
};
_view.SplitterPositionChanged += (s, e) =>
{
_settings.Gui.MainForm.SplitPosition = _view.SplitterPosition;
};
_view.FormClosing += (s, e) =>
{
if (_model.IsPackageLoaded)
{
if (_model.IsTestRunning)
{
if (!_view.MessageDisplay.YesNo("A test is running, do you want to forcibly stop the test and exit?"))
{
e.Cancel = true;
return;
}
_model.StopTestRun(true);
}
if (CloseProject() == DialogResult.Cancel)
{
e.Cancel = true;
}
}
if (!e.Cancel)
{
SaveFormLocationAndSize(_settings.Gui.GuiLayout);
}
};
_view.FileMenu.Popup += () =>
{
bool isPackageLoaded = _model.IsPackageLoaded;
bool isTestRunning = _model.IsTestRunning;
_view.OpenCommand.Enabled = !isTestRunning;
_view.CloseCommand.Enabled = isPackageLoaded && !isTestRunning;
_view.ReloadTestsCommand.Enabled = isPackageLoaded && !isTestRunning;
_view.SelectAgentMenu.Enabled = _agentSelectionController.AllowAgentSelection();
_view.RunAsX86.Enabled = isPackageLoaded && !isTestRunning;
_view.RecentFilesMenu.Enabled = !isTestRunning;
//if (!isTestRunning)
//{
// _recentProjectsMenuHandler.Load();
//}
};
_view.OpenCommand.Execute += () => OpenProject();
_view.CloseCommand.Execute += () => CloseProject();
_view.AddTestFilesCommand.Execute += () => AddTestFiles();
_view.ReloadTestsCommand.Execute += () => ReloadTests();
_view.SelectAgentMenu.Popup += () =>
{
_agentSelectionController.PopulateMenu();
};
_view.RunAsX86.CheckedChanged += () =>
{
var key = EnginePackageSettings.RunAsX86;
if (_view.RunAsX86.Checked)
{
ChangePackageSettingAndReload(key, true);
}
else
{
ChangePackageSettingAndReload(key, null);
}
};
_view.RecentFilesMenu.Popup += () =>
{
var menuItems = _view.RecentFilesMenu.MenuItems;
// Test for null, in case we are running tests with a mock
if (menuItems == null)
{
return;
}
menuItems.Clear();
int num = 0;
foreach (string entry in _model.RecentFiles.Entries)
{
var menuText = string.Format("{0} {1}", ++num, entry);
var menuItem = new ToolStripMenuItem(menuText);
menuItem.Click += (sender, ea) =>
{
// HACK: We are loading new files, cancel any runtime override
_model.PackageOverrides.Remove(EnginePackageSettings.RequestedRuntimeFramework);
string path = ((ToolStripMenuItem)sender).Text.Substring(2);
_model.LoadTests(new[] { path });
};
menuItems.Add(menuItem);
if (num >= _settings.Gui.RecentProjects.MaxFiles)
{
break;
}
}
};
_view.ExitCommand.Execute += () => _view.Close();
_view.GuiLayout.SelectionChanged += () =>
{
// Selection menu item has changed, so we want
// to update both the display and the settings
var oldLayout = _settings.Gui.GuiLayout;
var newLayout = _view.GuiLayout.SelectedItem;
if (oldLayout != newLayout)
{
SaveFormLocationAndSize(oldLayout);
SetGuiLayout(newLayout);
}
_settings.Gui.GuiLayout = _view.GuiLayout.SelectedItem;
};
_view.IncreaseFontCommand.Execute += () =>
{
applyFont(IncreaseFont(_settings.Gui.Font));
};
_view.DecreaseFontCommand.Execute += () =>
{
applyFont(DecreaseFont(_settings.Gui.Font));
};
_view.ChangeFontCommand.Execute += () =>
{
Font currentFont = _settings.Gui.Font;
Font newFont = _view.DialogManager.SelectFont(currentFont);
if (newFont != _settings.Gui.Font)
{
applyFont(newFont);
}
};
_view.DialogManager.ApplyFont += (font) => applyFont(font);
_view.RestoreFontCommand.Execute += () =>
{
applyFont(Form.DefaultFont);
};
_view.IncreaseFixedFontCommand.Execute += () =>
{
_settings.Gui.FixedFont = IncreaseFont(_settings.Gui.FixedFont);
};
_view.DecreaseFixedFontCommand.Execute += () =>
{
_settings.Gui.FixedFont = DecreaseFont(_settings.Gui.FixedFont);
};
_view.RestoreFixedFontCommand.Execute += () =>
{
_settings.Gui.FixedFont = new Font(FontFamily.GenericMonospace, 8.0f);
};
_view.RunAllMenuCommand.Execute += () => RunAllTests();
_view.RunSelectedMenuCommand.Execute += () => RunSelectedTests();
_view.RunFailedMenuCommand.Execute += () => RunFailedTests();
_view.RunAllToolbarCommand.Execute += () => RunAllTests();
_view.RunSelectedToolbarCommand.Execute += () => RunSelectedTests();
_view.RunButton.Execute += () =>
{
// Necessary test because we don't disable the button click
if (_model.HasTests && !_model.IsTestRunning)
{
RunAllTests();
}
// TODO: This should actually run the last Run action selected in the dropdown
};
_view.DebugAllToolbarCommand.Execute += () => _model.DebugAllTests();
_view.DebugSelectedToolbarCommand.Execute += () => _model.DebugSelectedTests();
_view.DebugButton.Execute += () =>
{
// Necessary test because we don't disable the button click
if (_model.HasTests && !_model.IsTestRunning)
{
_model.DebugAllTests();
}
// TODO: This should actually run the last Run action selected in the dropdown
};
_view.DisplayFormat.SelectionChanged += () =>
{
SetTreeDisplayFormat(_view.DisplayFormat.SelectedItem);
};
_view.GroupBy.SelectionChanged += () =>
{
switch (_view.DisplayFormat.SelectedItem)
{
case "TEST_LIST":
_settings.Gui.TestTree.TestList.GroupBy = _view.GroupBy.SelectedItem;
break;
case "FIXTURE_LIST":
_settings.Gui.TestTree.FixtureList.GroupBy = _view.GroupBy.SelectedItem;
break;
}
};
_view.StopRunMenuCommand.Execute += ExecuteNormalStop;
_view.StopRunButton.Execute += ExecuteNormalStop;
_view.ForceStopMenuCommand.Execute += ExecuteForcedStop;
_view.ForceStopButton.Execute += ExecuteForcedStop;
_view.TestParametersMenuCommand.Execute += DisplayTestParametersDialog;
_view.TestParametersToolbarCommand.Execute += DisplayTestParametersDialog;
_view.RunSummaryButton.Execute += () =>
{
var result = _model.GetResultForTest(_model.Tests.Id);
DisplayTestRunSummary(result, false);
};
//_view.RunSummaryButton.CheckedChanged += () =>
//{
// if (_view.RunSummaryButton.Checked)
// {
// var resultId = _model.GetResultForTest(_model.Tests.Id);
// var summary = ResultSummaryCreator.FromResultNode(resultId);
// string report = ResultSummaryReporter.WriteSummaryReport(summary);
// _view.DisplayTestRunSummary(report);
// }
// else
// _view.HideTestRunSummary();
//};
_view.ToolsMenu.Popup += () =>
{
_view.SaveResultsAsMenu.MenuItems.Clear();
foreach (string format in _resultFormats)
{
var formatItem = new ToolStripMenuItem(format);
formatItem.Click += (s, e) => SaveResults(format);
_view.SaveResultsAsMenu.MenuItems.Add(formatItem);
}
};
_view.SaveResultsCommand.Execute += () => SaveResults();
_view.OpenWorkDirectoryCommand.Execute += () => System.Diagnostics.Process.Start(_model.WorkDirectory);
_view.ExtensionsCommand.Execute += () =>
{
using (var extensionsDialog = new ExtensionDialog(_model.Services.ExtensionService))
{
extensionsDialog.Font = _settings.Gui.Font;
extensionsDialog.ShowDialog();
}
};
_view.SettingsCommand.Execute += () =>
{
SettingsDialog.Display(this, _model);
};
_view.TestCentricHelpCommand.Execute += () =>
{
System.Diagnostics.Process.Start("https://test-centric.org/testcentric-gui");
};
_view.NUnitHelpCommand.Execute += () =>
{
System.Diagnostics.Process.Start("https://docs.nunit.org/articles/nunit/intro.html");
};
_view.AboutCommand.Execute += () =>
{
using (AboutBox aboutBox = new AboutBox())
{
aboutBox.ShowDialog();
}
};
_view.ResultTabs.SelectionChanged += () =>
{
_settings.Gui.SelectedTab = _view.ResultTabs.SelectedIndex;
};
#endregion
}
private void DisplayTestProperties()
{
// TODO: Insert checks for errors in the XML
var testNode = _selectedItem as TestNode;
var resultNode = _model.GetResultForTest(testNode);
_view.TestPanel.Visible = testNode != null;
_view.ResultPanel.Visible = resultNode != null;
// TODO: We should actually try to set the font for bold items
// dynamically, since the global application font may be changed.
if (testNode != null)
{
_view.SuspendLayout();
_view.Header = testNode.Name;
_view.TestType = GetTestType(testNode);
_view.FullName = testNode.FullName;
_view.Description = testNode.GetProperty("Description");
_view.Categories = testNode.GetPropertyList("Category");
_view.TestCount = testNode.TestCount.ToString();
_view.RunState = testNode.RunState.ToString();
_view.SkipReason = testNode.GetProperty("_SKIPREASON");
var sb = new StringBuilder();
foreach (string item in testNode.GetAllProperties(_view.DisplayHiddenProperties))
{
if (sb.Length > 0)
{
sb.Append(Environment.NewLine);
}
sb.Append(item);
}
_view.Properties = sb.ToString();
if (resultNode != null)
{
_view.Outcome = resultNode.Outcome.ToString();
_view.ElapsedTime = resultNode.Duration.ToString("f3");
_view.AssertCount = resultNode.AssertCount.ToString();
var assertions = resultNode.Xml.SelectNodes("assertions/assertion");
XmlNode message = null;
XmlNode stackTrace = null;
if (assertions.Count > 0)
{
message = assertions[0].SelectSingleNode("message");
stackTrace = assertions[0].SelectSingleNode("stack-trace");
}
else if (resultNode.Outcome.Status == TestStatus.Failed)
{
message = resultNode.Xml.SelectSingleNode("failure/message");
stackTrace = resultNode.Xml.SelectSingleNode("failure/stack-trace");
}
else
{
message = resultNode.Xml.SelectSingleNode("reason/message");
}
_view.Message = message?.InnerText ?? "";
_view.StackTrace = stackTrace?.InnerText ?? "";
var output = resultNode.Xml.SelectSingleNode("output");
_view.Output = output != null ? output.InnerText : "";
}
_view.ResumeLayout();
}
else if (_selectedItem != null)
{
_view.Header = _selectedItem.Name;
}
}
