| <%@ ServiceHost Language="C#" Debug="true" Factory="DataJS.Tests.TestSynchronizerFactory" Service="DataJS.Tests.TestSynchronizer" %> |
| |
| // Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. |
| // Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation |
| // files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, |
| // modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the |
| // Software is furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE |
| // WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
| // COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, |
| // ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| namespace DataJS.Tests |
| { |
| using System; |
| using System.Collections.Generic; |
| using System.Linq; |
| using System.Net; |
| using System.ServiceModel; |
| using System.ServiceModel.Activation; |
| using System.ServiceModel.Channels; |
| using System.ServiceModel.Description; |
| using System.ServiceModel.Dispatcher; |
| using System.ServiceModel.Web; |
| using System.Text; |
| using System.Threading; |
| using System.Xml; |
| |
| /// <summary> |
| /// This factory supports reconfiguring the service to allow incoming messages |
| /// to be larger than the default. |
| /// </summary> |
| public class TestSynchronizerFactory : WebScriptServiceHostFactory |
| { |
| protected override ServiceHost CreateServiceHost(Type serviceType, Uri[] baseAddresses) |
| { |
| var result = base.CreateServiceHost(serviceType, baseAddresses); |
| result.Opening += ServiceHostOpening; |
| return result; |
| } |
| |
| private static void UpdateService(ServiceDescription description) |
| { |
| const long LargeMaxReceivedMessageSize = 1024 * 1024 * 16; |
| foreach (var endpoint in description.Endpoints) |
| { |
| var basic = endpoint.Binding as BasicHttpBinding; |
| if (basic != null) |
| { |
| basic.MaxReceivedMessageSize = LargeMaxReceivedMessageSize; |
| } |
| |
| var http = endpoint.Binding as WebHttpBinding; |
| if (http != null) |
| { |
| http.MaxReceivedMessageSize = LargeMaxReceivedMessageSize; |
| } |
| } |
| } |
| |
| private void ServiceHostOpening(object sender, EventArgs e) |
| { |
| UpdateService((sender as ServiceHost).Description); |
| } |
| } |
| |
| /// <summary>Use this class to log test activity.</summary> |
| /// <remarks> |
| /// A test run can be created by invoking CreateTestRun. With a test |
| /// run ID, the following operations can be invoked: |
| /// |
| /// - AddTestPages: adds test pages to be made available to future callers (typically to support tests from different files) |
| /// - SetTestNamePrefix: sets a string that will be prefixed to every test name in logs (typically to include a browser name) |
| /// - MarkInProgress: resets the test run to "in-progress" for another variation (typically to run a different browser) |
| /// - IsTestRunInProgress: checks whether it's still in progress |
| /// - GetTestRunResults: returns the test results in TRX format |
| /// - LogAssert: logs a single assertion in the current test for the run |
| /// - LogTestStart: logs a test that has begun execution |
| /// - LogTestDone: logs a test that has ended execution |
| /// - TestCompleted: logs that a test has completed execution; returns the next page with tests or an empty string |
| /// </remarks> |
| [ServiceContract] |
| [ServiceBehavior(IncludeExceptionDetailInFaults = true)] |
| [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)] |
| public class TestSynchronizer |
| { |
| private static readonly Dictionary<string, TestRunContext> testRuns = new Dictionary<string, TestRunContext>(); |
| private const string Inconclusive = "Inconclusive"; |
| private const string InProgress = "InProgress"; |
| private const string Failed = "Failed"; |
| private const string Passed = "Passed"; |
| private const string Completed = "Completed"; |
| |
| /// <summary> |
| /// Adds test pages to the specified runs; replaces existing files (helps with reliablity when something |
| /// fails part-way). |
| /// </summary> |
| /// <remarks>This method is typically called by the test harness.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public int AddTestPages(string testRunId, string pages, string filter) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| context.TestPages.Clear(); |
| context.TestPages.AddRange(pages.Split(',').Select(page => page + "?testRunId=" + testRunId + (filter == null ? string.Empty : "?filter=" + filter))); |
| return context.TestPages.Count; |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test harness.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public string CreateTestRun() |
| { |
| DisableResponseCaching(); |
| |
| Guid value = Guid.NewGuid(); |
| string result = value.ToString(); |
| TestRunContext context = CreateTestRunContextWithId(value); |
| |
| lock (testRuns) |
| { |
| testRuns.Add(result, context); |
| } |
| |
| return result; |
| } |
| |
| /// <summary>Checks whether the test run is in progress.</summary> |
| /// <remarks>This method is typically called by the test harness.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public bool IsTestRunInProgress(string testRunId) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| return context.TestRun.ResultSummary.Outcome == InProgress; |
| } |
| |
| /// <summary>Provides a list of all test runs being tracked.</summary> |
| [OperationContract] |
| [WebGet(ResponseFormat=WebMessageFormat.Json)] |
| public IEnumerable<string> GetActiveTestRuns() |
| { |
| DisableResponseCaching(); |
| |
| List<string> result; |
| lock (testRuns) |
| { |
| result = new List<string>(testRuns.Keys); |
| } |
| |
| return result; |
| } |
| |
| /// <remarks>This method is typically called by the test harness.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Xml)] |
| public Message GetTestRunResults(string testRunId) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| TestRun run = context.TestRun; |
| this.CompleteTestRun(run); |
| |
| TestRunXmlBodyWriter writer = new TestRunXmlBodyWriter(run); |
| return Message.CreateMessage( |
| MessageVersion.None, |
| OperationContext.Current.OutgoingMessageHeaders.Action, |
| writer); |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test case.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public void LogAssert(string testRunId, bool pass, string message, string name, string actual, string expected) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| TestRun run = context.TestRun; |
| string prefixedName = context.TestNamePrefix + name; |
| TestResult result = run.TestResults.LastOrDefault(r => r.TestName == prefixedName); |
| if (result == null) |
| { |
| throw new InvalidOperationException("Unable to find test " + prefixedName + " in run " + testRunId); |
| } |
| |
| result.DebugTrace.AppendLine(message); |
| if (!pass) |
| { |
| result.ErrorMessages.AppendLine(message); |
| result.ErrorMessages.AppendLine("Expected: " + expected); |
| result.ErrorMessages.AppendLine("Actual: " + actual); |
| } |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test case.</remarks> |
| [OperationContract] |
| [WebInvoke(ResponseFormat = WebMessageFormat.Json, RequestFormat = WebMessageFormat.Json)] |
| public void LogBatch(string[] urls) |
| { |
| DisableResponseCaching(); |
| |
| foreach (var url in urls) |
| { |
| Uri parsed = new Uri(OperationContext.Current.Channel.LocalAddress.Uri, url); |
| string methodName = parsed.Segments[parsed.Segments.Length - 1]; |
| System.Reflection.MethodInfo method = this.GetType().GetMethod(methodName); |
| System.Reflection.ParameterInfo[] parameterInfos = method.GetParameters(); |
| object[] parameters = new object[parameterInfos.Length]; |
| System.Collections.Specialized.NameValueCollection query = System.Web.HttpUtility.ParseQueryString(parsed.Query); |
| for (int i = 0; i < parameters.Length; i++) |
| { |
| object value = query[parameterInfos[i].Name]; |
| parameters[i] = Convert.ChangeType(value, parameterInfos[i].ParameterType, System.Globalization.CultureInfo.InvariantCulture); |
| } |
| |
| method.Invoke(this, parameters); |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test case.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public void LogTestStart(string testRunId, string name, DateTime startTime) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| TestRun run = context.TestRun; |
| string prefixedName = context.TestNamePrefix + name; |
| Guid testId = Guid.NewGuid(); |
| Guid executionId = Guid.NewGuid(); |
| Guid testListId = run.TestLists.Single().Id; |
| run.TestDefinitions.Add(new TestDefinition() |
| { |
| Id = testId, |
| Name = prefixedName, |
| ExecutionId = executionId, |
| }); |
| run.TestEntries.Add(new TestEntry() |
| { |
| TestId = testId, |
| ExecutionId = executionId, |
| TestListId = testListId |
| }); |
| run.TestResults.Add(new TestResult() |
| { |
| ExecutionId = executionId, |
| TestId = testId, |
| TestListId = testListId, |
| TestName = prefixedName, |
| ComputerName = Environment.MachineName, |
| StartTime = startTime, |
| EndTime = startTime, |
| TestType = Guid.Parse("13cdc9d9-ddb5-4fa4-a97d-d965ccfc6d4b"), |
| Outcome = InProgress, |
| // RelativeResultsDirectory? |
| }); |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test case.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public void LogTestDone(string testRunId, string name, int failures, int total, DateTime endTime) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| TestRun run = context.TestRun; |
| string prefixedName = context.TestNamePrefix + name; |
| TestResult result = run.TestResults.LastOrDefault(r => r.TestName == prefixedName); |
| if (failures > 0) |
| { |
| result.Outcome = Failed; |
| } |
| else |
| { |
| result.Outcome = Passed; |
| } |
| |
| result.EndTime = endTime; |
| } |
| } |
| |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public void MarkInProgress(string testRunId) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| context.TestRun.ResultSummary.Outcome = InProgress; |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test harness.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public void SetTestNamePrefix(string testRunId, string prefix) |
| { |
| DisableResponseCaching(); |
| |
| TestRunContext context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| context.TestNamePrefix = prefix; |
| } |
| } |
| |
| /// <remarks>This method is typically called by the test case.</remarks> |
| [OperationContract] |
| [WebGet(ResponseFormat = WebMessageFormat.Json)] |
| public string TestCompleted(string testRunId, int failures, int total) |
| { |
| DisableResponseCaching(); |
| |
| var context = GetTestRunContext(testRunId); |
| lock (context) |
| { |
| string result; |
| if (context.TestPages.Count == 0) |
| { |
| context.TestRun.ResultSummary.Outcome = Completed; |
| result = ""; |
| } |
| else |
| { |
| result = context.TestPages[0]; |
| context.TestPages.RemoveAt(0); |
| } |
| |
| return result; |
| } |
| } |
| |
| private static TestRunContext CreateTestRunContextWithId(Guid value) |
| { |
| TestRun run = new TestRun(); |
| run.Id = value; |
| run.Name = "Test run"; |
| run.TestTimes.Creation = DateTime.Now; |
| run.TestTimes.Queueing = DateTime.Now; |
| run.TestLists.Add(new TestList() |
| { |
| Name = "All Results", |
| Id = Guid.NewGuid() |
| }); |
| |
| // For the time being, set up a fake test settings. |
| run.TestSettings.Id = Guid.NewGuid(); |
| |
| run.ResultSummary.Outcome = InProgress; |
| |
| TestRunContext context = new TestRunContext(); |
| context.TestRun = run; |
| |
| return context; |
| } |
| |
| private static void DisableResponseCaching() |
| { |
| WebOperationContext.Current.OutgoingResponse.Headers[HttpResponseHeader.CacheControl] = "no-cache"; |
| } |
| |
| private static TestRunContext GetTestRunContext(string testRunId) |
| { |
| if (testRunId == null) |
| { |
| throw new ArgumentNullException("testRunId"); |
| } |
| |
| lock (testRuns) |
| { |
| // For an 0-filled GUID, allow create-on-demand to simplify ad-hoc testing. |
| // Something like: |
| // http://localhost:8989/tests/odata-qunit-tests.htm?testRunId=00000000-0000-0000-0000-000000000000 |
| if (!testRuns.ContainsKey(testRunId)) |
| { |
| Guid value = Guid.Parse(testRunId); |
| if (value == Guid.Empty) |
| { |
| TestRunContext context = CreateTestRunContextWithId(value); |
| testRuns.Add(testRunId, context); |
| } |
| } |
| |
| return testRuns[testRunId]; |
| } |
| } |
| |
| private void CompleteTestRun(TestRun run) |
| { |
| run.TestTimes.Finish = DateTime.Now; |
| |
| // Fill counts in result object. |
| var summary = run.ResultSummary; |
| summary.Executed = 0; |
| summary.Error = 0; |
| summary.Failed = 0; |
| summary.Timeout = 0; |
| summary.Aborted = 0; |
| summary.Inconclusive = 0; |
| summary.PassedButRunAborted = 0; |
| summary.NotRunnable = 0; |
| summary.NotExecuted = 0; |
| summary.Disconnected = 0; |
| summary.Warning = 0; |
| summary.Passed = 0; |
| summary.Completed = 0; |
| summary.InProgress = 0; |
| summary.Pending = 0; |
| |
| foreach (var testResult in run.TestResults) |
| { |
| string outcome = testResult.Outcome; |
| switch (outcome) |
| { |
| case InProgress: |
| summary.Executed++; |
| summary.InProgress++; |
| break; |
| case Failed: |
| summary.Executed++; |
| summary.Completed++; |
| summary.Failed++; |
| break; |
| case Passed: |
| summary.Executed++; |
| summary.Completed++; |
| summary.Passed++; |
| break; |
| default: |
| summary.Failed++; |
| break; |
| } |
| } |
| |
| summary.Total = run.TestResults.Count; |
| |
| if (summary.Failed != 0) |
| { |
| summary.Outcome = Failed; |
| } |
| else if (summary.Total <= 0 || summary.Passed < summary.Total) |
| { |
| summary.Outcome = Inconclusive; |
| } |
| else |
| { |
| summary.Outcome = Passed; |
| } |
| } |
| } |
| |
| public class TestRunContext |
| { |
| public TestRunContext() |
| { |
| this.TestPages = new List<string>(); |
| } |
| |
| public TestRun TestRun { get; set; } |
| public string TestNamePrefix { get; set; } |
| public List<string> TestPages { get; set; } |
| } |
| |
| public class TestResultWriter |
| { |
| private const string TestNamespace = "http://microsoft.com/schemas/VisualStudio/TeamTest/2010"; |
| |
| public static void WriteTestRun(TestRun run, string path) |
| { |
| if (run == null) |
| { |
| throw new ArgumentNullException("run"); |
| } |
| if (path == null) |
| { |
| throw new ArgumentNullException("path"); |
| } |
| |
| using (XmlWriter writer = XmlWriter.Create(path)) |
| { |
| WriteTestRun(run, path); |
| } |
| } |
| |
| public static void WriteTestRun(TestRun run, XmlWriter writer) |
| { |
| if (run == null) |
| { |
| throw new ArgumentNullException("run"); |
| } |
| if (writer == null) |
| { |
| throw new ArgumentNullException("writer"); |
| } |
| |
| writer.WriteStartElement("TestRun", TestNamespace); |
| writer.WriteGuidIfPresent("id", run.Id); |
| writer.WriteAttributeString("name", run.Name); |
| writer.WriteAttributeString("runUser", run.RunUser); |
| |
| WriteTestSettings(run.TestSettings, writer); |
| WriteResultSummary(run.ResultSummary, writer); |
| |
| // Write test definitions. |
| writer.WriteStartElement("TestDefinitions", TestNamespace); |
| foreach (var definition in run.TestDefinitions) |
| { |
| WriteTestDefinition(definition, writer); |
| } |
| |
| writer.WriteEndElement(); |
| |
| // Write test lists. |
| writer.WriteStartElement("TestLists", TestNamespace); |
| foreach (var list in run.TestLists) |
| { |
| WriteTestList(list, writer); |
| } |
| |
| writer.WriteEndElement(); |
| |
| // Write test entries. |
| writer.WriteStartElement("TestEntries", TestNamespace); |
| foreach (var entry in run.TestEntries) |
| { |
| WriteTestEntry(entry, writer); |
| } |
| |
| writer.WriteEndElement(); |
| |
| // Write test results. |
| writer.WriteStartElement("Results", TestNamespace); |
| foreach (var result in run.TestResults) |
| { |
| WriteTestResults(result, writer); |
| } |
| |
| writer.WriteEndElement(); |
| |
| // Close the test run element. |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteTestResults(TestResult result, XmlWriter writer) |
| { |
| if (result == null) |
| { |
| throw new ArgumentNullException("result"); |
| } |
| |
| writer.WriteStartElement("UnitTestResult", TestNamespace); |
| writer.WriteGuidIfPresent("testId", result.TestId); |
| writer.WriteGuidIfPresent("testListId", result.TestListId); |
| writer.WriteGuidIfPresent("executionId", result.ExecutionId); |
| writer.WriteGuidIfPresent("RelativeResultsDirectory", result.RelativeResultsDirectory); |
| |
| writer.WriteAttributeString("testName", result.TestName); |
| writer.WriteAttributeString("computerName", result.ComputerName); |
| writer.WriteAttributeString("duration", result.Duration.ToString()); |
| writer.WriteAttributeString("startTime", XmlConvert.ToString(result.StartTime)); |
| writer.WriteAttributeString("endTime", XmlConvert.ToString(result.EndTime)); |
| writer.WriteAttributeString("outcome", result.Outcome); |
| |
| writer.WriteGuidIfPresent("testType", result.TestType); |
| |
| if (result.DebugTrace.Length > 0) |
| { |
| writer.WriteStartElement("Output"); |
| |
| writer.WriteStartElement("DebugTrace"); |
| writer.WriteString(result.DebugTrace.ToString()); |
| writer.WriteEndElement(); |
| |
| writer.WriteStartElement("ErrorInfo"); |
| writer.WriteStartElement("Message"); |
| writer.WriteString(result.ErrorMessages.ToString()); |
| writer.WriteEndElement(); |
| writer.WriteEndElement(); |
| |
| writer.WriteEndElement(); |
| } |
| |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteTestEntry(TestEntry entry, XmlWriter writer) |
| { |
| if (entry == null) |
| { |
| throw new ArgumentNullException("entry"); |
| } |
| |
| writer.WriteStartElement("TestEntry", TestNamespace); |
| writer.WriteGuidIfPresent("testId", entry.TestId); |
| writer.WriteGuidIfPresent("testListId", entry.TestListId); |
| writer.WriteGuidIfPresent("executionId", entry.ExecutionId); |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteTestList(TestList list, XmlWriter writer) |
| { |
| if (list == null) |
| { |
| throw new ArgumentNullException("list"); |
| } |
| |
| writer.WriteStartElement("TestList", TestNamespace); |
| writer.WriteAttributeString("name", list.Name); |
| writer.WriteGuidIfPresent("id", list.Id); |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteTestDefinition(TestDefinition definition, XmlWriter writer) |
| { |
| if (definition == null) |
| { |
| throw new ArgumentNullException("definition"); |
| } |
| |
| writer.WriteStartElement("UnitTest", TestNamespace); |
| writer.WriteAttributeString("name", definition.Name); |
| writer.WriteAttributeString("storage", definition.Storage); |
| writer.WriteGuidIfPresent("id", definition.Id); |
| |
| // There are more thing we could write here: DeploymentItems, Execution, TestMethod |
| |
| // This is the minimum needed to load the test in the IDE. |
| writer.WriteStartElement("Execution", TestNamespace); |
| writer.WriteGuidIfPresent("id", definition.ExecutionId); |
| writer.WriteEndElement(); |
| |
| writer.WriteStartElement("TestMethod", TestNamespace); |
| writer.WriteAttributeString("codeBase", "fake-test-file.js"); |
| writer.WriteAttributeString("adapterTypeName", "Microsoft.VisualStudio.TestTools.TestTypes.Unit.UnitTestAdapter, Microsoft.VisualStudio.QualityTools.Tips.UnitTest.Adapter, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"); |
| writer.WriteAttributeString("className", "FakeClassName, TestLogging, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"); |
| writer.WriteAttributeString("name", definition.Name); |
| writer.WriteEndElement(); |
| |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteResultSummary(ResultSummary resultSummary, XmlWriter writer) |
| { |
| if (resultSummary == null) |
| { |
| throw new ArgumentNullException("resultSummary"); |
| } |
| |
| writer.WriteStartElement("ResultSummary", TestNamespace); |
| writer.WriteAttributeString("outcome", resultSummary.Outcome); |
| |
| writer.WriteStartElement("Counters", TestNamespace); |
| |
| foreach (var p in typeof(ResultSummary).GetProperties()) |
| { |
| if (p.PropertyType != typeof(int)) |
| { |
| continue; |
| } |
| |
| int value = (int)p.GetValue(resultSummary, null); |
| string attributeName = p.Name; |
| attributeName = attributeName.Substring(0, 1).ToLowerInvariant() + attributeName.Substring(1); |
| writer.WriteAttributeString(attributeName, value.ToString()); |
| } |
| |
| writer.WriteEndElement(); |
| writer.WriteEndElement(); |
| } |
| |
| private static void WriteTestSettings(TestSettings testSettings, XmlWriter writer) |
| { |
| if (testSettings == null) |
| { |
| throw new ArgumentNullException("testSettings"); |
| } |
| |
| writer.WriteStartElement("TestSettings", TestNamespace); |
| writer.WriteAttributeString("name", testSettings.Name); |
| writer.WriteGuidIfPresent("id", testSettings.Id); |
| // There are more things we could write here. |
| writer.WriteEndElement(); |
| } |
| } |
| |
| public static class XmlWriterExtensions |
| { |
| public static void WriteGuidIfPresent(this XmlWriter writer, string attributeName, Guid value) |
| { |
| if (value != Guid.Empty) |
| { |
| writer.WriteAttributeString(attributeName, value.ToString()); |
| } |
| } |
| } |
| |
| public class TestRun |
| { |
| public TestRun() |
| { |
| this.TestDefinitions = new List<TestDefinition>(); |
| this.TestLists = new List<TestList>(); |
| this.TestEntries = new List<TestEntry>(); |
| this.TestResults = new List<TestResult>(); |
| this.ResultSummary = new ResultSummary(); |
| this.TestTimes = new TestTimes(); |
| this.TestSettings = new TestSettings(); |
| |
| this.Id = Guid.NewGuid(); |
| this.RunUser = Environment.UserDomainName + "\\" + Environment.UserName; |
| } |
| |
| public Guid Id { get; set; } |
| public string Name { get; set; } |
| public string RunUser { get; set; } |
| public TestSettings TestSettings { get; set; } |
| public TestTimes TestTimes { get; set; } |
| public ResultSummary ResultSummary { get; set; } |
| public List<TestDefinition> TestDefinitions { get; set; } |
| public List<TestList> TestLists { get; set; } |
| public List<TestEntry> TestEntries { get; set; } |
| public List<TestResult> TestResults { get; set; } |
| } |
| |
| public class TestSettings |
| { |
| public Guid Id { get; set; } |
| public string Name { get; set; } |
| } |
| |
| public class TestTimes |
| { |
| public DateTime Creation { get; set; } |
| public DateTime Queueing { get; set; } |
| public DateTime Start { get; set; } |
| public DateTime Finish { get; set; } |
| } |
| |
| public class ResultSummary |
| { |
| public string Outcome { get; set; } |
| public int Total { get; set; } |
| public int Executed { get; set; } |
| public int Error { get; set; } |
| public int Failed { get; set; } |
| public int Timeout { get; set; } |
| public int Aborted { get; set; } |
| public int Inconclusive { get; set; } |
| public int PassedButRunAborted { get; set; } |
| public int NotRunnable { get; set; } |
| public int NotExecuted { get; set; } |
| public int Disconnected { get; set; } |
| public int Warning { get; set; } |
| public int Passed { get; set; } |
| public int Completed { get; set; } |
| public int InProgress { get; set; } |
| public int Pending { get; set; } |
| } |
| |
| public class TestDefinition |
| { |
| public string Name { get; set; } |
| public string Storage { get; set; } |
| public Guid Id { get; set; } |
| public Guid ExecutionId { get; set; } |
| } |
| |
| public class TestList |
| { |
| public string Name { get; set; } |
| public Guid Id { get; set; } |
| } |
| |
| public class TestEntry |
| { |
| public Guid TestId { get; set; } |
| public Guid ExecutionId { get; set; } |
| public Guid TestListId { get; set; } |
| } |
| |
| public class TestResult |
| { |
| public TestResult() |
| { |
| this.DebugTrace = new StringBuilder(); |
| this.ErrorMessages = new StringBuilder(); |
| } |
| |
| public Guid ExecutionId { get; set; } |
| public Guid TestId { get; set; } |
| public string TestName { get; set; } |
| public string ComputerName { get; set; } |
| public TimeSpan Duration { get { return this.EndTime - this.StartTime; } } |
| public DateTime StartTime { get; set; } |
| public DateTime EndTime { get; set; } |
| public Guid TestType { get; set; } |
| public string Outcome { get; set; } |
| public Guid TestListId { get; set; } |
| public Guid RelativeResultsDirectory { get; set; } |
| public StringBuilder DebugTrace { get; set; } |
| public StringBuilder ErrorMessages { get; set; } |
| } |
| |
| class TestRunXmlBodyWriter : BodyWriter |
| { |
| private readonly TestRun run; |
| |
| public TestRunXmlBodyWriter(TestRun run) |
| : base(true) |
| { |
| this.run = run; |
| } |
| |
| protected override void OnWriteBodyContents(XmlDictionaryWriter writer) |
| { |
| TestResultWriter.WriteTestRun(this.run, writer); |
| } |
| } |
| } |
