public void FakesDataCollectorSettingsShouldBeInserted()
{
string runSettingsXml = @"<RunSettings><RunConfiguration></RunConfiguration></RunSettings>";
var doc = new XmlDocument();
using (var xmlReader = XmlReader.Create(
new StringReader(runSettingsXml),
new XmlReaderSettings()
{
CloseInput = true
}))
{
doc.Load(xmlReader);
}
var dataCollectorNode2 = new DataCollectorSettings()
{
AssemblyQualifiedName = FakesUtilities.FakesMetadata.DataCollectorAssemblyQualifiedName,
Uri = new Uri(FakesUtilities.FakesMetadata.DataCollectorUriV2),
FriendlyName = FakesUtilities.FakesMetadata.FriendlyName,
IsEnabled = true,
Configuration = doc.FirstChild as XmlElement
};
FakesUtilities.InsertOrReplaceFakesDataCollectorNode(doc, dataCollectorNode2);
Assert.IsTrue(XmlRunSettingsUtilities.ContainsDataCollector(doc, FakesUtilities.FakesMetadata.DataCollectorUriV2));
}
public void SetSettings(DataCollectorSettings settings)
{
_settings = settings;
AfDatabaseName = _settings.AFDatabaseName;
AfElementTemplateName = _settings.AFElementTemplateName;
AfServerName = _settings.AFServerName;
}
public void OtherRunsettingsShouldNotBeChanged()
{
string runSettingsXml = @"<RunSettings><RunConfiguration><TargetFrameworkVersion>FrameworkCore10</TargetFrameworkVersion></RunConfiguration></RunSettings>";
var doc = new XmlDocument();
using (var xmlReader = XmlReader.Create(
new StringReader(runSettingsXml),
new XmlReaderSettings()
{
CloseInput = true
}))
{
doc.Load(xmlReader);
}
var dataCollectorNode2 = new DataCollectorSettings()
{
AssemblyQualifiedName = FakesUtilities.FakesMetadata.DataCollectorAssemblyQualifiedName,
Uri = new Uri(FakesUtilities.FakesMetadata.DataCollectorUriV2),
FriendlyName = FakesUtilities.FakesMetadata.FriendlyName,
IsEnabled = true,
Configuration = doc.CreateElement("Configuration")
};
FakesUtilities.InsertOrReplaceFakesDataCollectorNode(doc, dataCollectorNode2);
Assert.IsTrue(XmlRunSettingsUtilities.ContainsDataCollector(doc, FakesUtilities.FakesMetadata.DataCollectorUriV2));
XmlNodeList nodes = doc.SelectNodes("//RunSettings/RunConfiguration/TargetFrameworkVersion");
Assert.AreEqual("FrameworkCore10", nodes[0].InnerText);
}
CoverageParameters GetCoverageParameters(DataCollectorSettings coverageSettings)
{
if (coverageSettings is null)
{
return(defaultCoverageParameters);
}
return(ParseSettings(coverageSettings));
}
public void SetSettings(DataCollectorSettings settings)
{
_settings = settings;
AfDatabaseName = _settings.AFDatabaseName;
AfElementTemplateName = _settings.AFElementTemplateName;
AfServerName = _settings.AFServerName;
}
protected virtual IInProcDataCollector CreateDataCollector(DataCollectorSettings dataCollectorSettings, TypeInfo interfaceTypeInfo)
{
var inProcDataCollector = new InProcDataCollector(dataCollectorSettings.CodeBase, dataCollectorSettings.AssemblyQualifiedName,
interfaceTypeInfo, dataCollectorSettings.Configuration.OuterXml);
inProcDataCollector.LoadDataCollector(inProcDataCollectionSink);
return(inProcDataCollector);
}
/// <summary>
/// To be called once at game start!
/// </summary>
public static void Initialize(DataCollectorSettings settings)
{
//Debug.Log("[DataCollector] initializing");
if (_instance != null)
{
Debug.LogError("[DataCollector] already instantiated before initialization");
}
DataCollector.settings = settings;
instance.buildVersion = settings.buildVersion; // doing random thing calling instance to start instanciation
}
/// <summary>
/// Adds the Fakes data collector settings in the run settings document.
/// </summary>
/// <returns>
/// The <see cref="DataCollectorSettings"/>.
/// </returns>
private static DataCollectorSettings CreateFakesDataCollectorSettings()
{
// embed the fakes run settings
var settings = new DataCollectorSettings
{
AssemblyQualifiedName = FakesMetadata.DataCollectorAssemblyQualifiedName,
FriendlyName = FakesMetadata.FriendlyName,
IsEnabled = true,
Uri = new Uri(FakesMetadata.DataCollectorUri)
};
return(settings);
}
public void InProcDataCollectorIsReadingMultipleDataCollector()
{
var multiSettingsXml = @"<RunSettings>
<InProcDataCollectionRunSettings>
<InProcDataCollectors>
<InProcDataCollector friendlyName='Test Impact' uri='InProcDataCollector://Microsoft/TestImpact/1.0' assemblyQualifiedName='TestImpactListener.Tests, Version=1.0.0.0, Culture=neutral, PublicKeyToken=7ccb7239ffde675a' codebase='E:\repos\MSTest\src\managed\TestPlatform\TestImpactListener.Tests\bin\Debug\TestImpactListener.Tests1.dll'>
<Configuration>
<Port>4312</Port>
</Configuration>
</InProcDataCollector>
<InProcDataCollector friendlyName='InProcDataCol' uri='InProcDataCollector://Microsoft/InProcDataCol/2.0' assemblyQualifiedName='TestImpactListener.Tests, Version=2.0.0.0, Culture=neutral, PublicKeyToken=7ccb7239ffde675a' codebase='E:\repos\MSTest\src\managed\TestPlatform\TestImpactListener.Tests\bin\Debug\TestImpactListener.Tests2.dll'>
<Configuration>
<Port>4313</Port>
</Configuration>
</InProcDataCollector>
</InProcDataCollectors>
</InProcDataCollectionRunSettings>
</RunSettings>";
var inProcDataCollectionManager = new TestableInProcDataCollectionExtensionManager(multiSettingsXml, null);
Assert.IsTrue(inProcDataCollectionManager.IsInProcDataCollectionEnabled, "InProcDataCollection must be enabled if runsettings contains inproc datacollectors.");
Assert.AreEqual(inProcDataCollectionManager.DataCollectors.Count, 2, "One Datacollector must be registered");
bool secondOne = false;
DataCollectorSettings dataCollectorSettings1 = null;
DataCollectorSettings dataCollectorSettings2 = null;
foreach (var inProcDC in inProcDataCollectionManager.DataCollectors.Values)
{
if (secondOne)
{
dataCollectorSettings2 = (inProcDC as MockDataCollector).DataCollectorSettings;
}
else
{
dataCollectorSettings1 = (inProcDC as MockDataCollector).DataCollectorSettings;
secondOne = true;
}
}
Assert.IsTrue(string.Equals(dataCollectorSettings1.AssemblyQualifiedName, "TestImpactListener.Tests, Version=1.0.0.0, Culture=neutral, PublicKeyToken=7ccb7239ffde675a", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(dataCollectorSettings1.CodeBase, @"E:\repos\MSTest\src\managed\TestPlatform\TestImpactListener.Tests\bin\Debug\TestImpactListener.Tests1.dll", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(dataCollectorSettings1.Configuration.OuterXml.ToString(), @"<Configuration><Port>4312</Port></Configuration>", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(dataCollectorSettings2.AssemblyQualifiedName, "TestImpactListener.Tests, Version=2.0.0.0, Culture=neutral, PublicKeyToken=7ccb7239ffde675a", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(dataCollectorSettings2.CodeBase, @"E:\repos\MSTest\src\managed\TestPlatform\TestImpactListener.Tests\bin\Debug\TestImpactListener.Tests2.dll", StringComparison.OrdinalIgnoreCase));
Assert.IsTrue(string.Equals(dataCollectorSettings2.Configuration.OuterXml.ToString(), @"<Configuration><Port>4313</Port></Configuration>", StringComparison.OrdinalIgnoreCase));
}
CoverageParameters ParseSettings(DataCollectorSettings coverageSettings)
{
try
{
string configurationXml = coverageSettings.Configuration.OuterXml;
XmlSerializer serializer = new XmlSerializer(typeof(CoverletRunSettingsConfiguration));
using StringReader reader = new StringReader(configurationXml);
CoverletRunSettingsConfiguration settings = (CoverletRunSettingsConfiguration)serializer.Deserialize(reader);
return(settings.ToParameters());
}
catch (Exception e)
{
Debug.WriteLine(e);
return(defaultCoverageParameters);
}
}
private static bool DoesDataCollectorSettingsExist(string friendlyName,
DataCollectionRunSettings dataCollectionRunSettings,
out DataCollectorSettings dataCollectorSettings)
{
dataCollectorSettings = null;
foreach (var dataCollectorSetting in dataCollectionRunSettings.DataCollectorSettingsList)
{
if (dataCollectorSetting.FriendlyName.Equals(friendlyName, StringComparison.OrdinalIgnoreCase))
{
dataCollectorSettings = dataCollectorSetting;
return(true);
}
}
return(false);
}
internal static void EnableDataCollectorUsingFriendlyName(string argument, DataCollectionRunSettings dataCollectionRunSettings)
{
DataCollectorSettings dataCollectorSettings = null;
if (!DoesDataCollectorSettingsExist(argument, dataCollectionRunSettings, out dataCollectorSettings))
{
dataCollectorSettings = new DataCollectorSettings();
dataCollectorSettings.FriendlyName = argument;
dataCollectorSettings.IsEnabled = true;
dataCollectionRunSettings.DataCollectorSettingsList.Add(dataCollectorSettings);
}
else
{
dataCollectorSettings.IsEnabled = true;
}
}
private async void UnitTestService_TestSessionStarting(object sender, TestSessionEventArgs e)
{
if (coverageCollectionCompletion == null || e.Test.OwnerObject is not Project testProject)
{
return;
}
var configuration = IdeApp.Workspace.ActiveConfiguration;
DataCollectorSettings coverageSettings = GetRunSettings(testProject);
provider.Prepare(testProject, configuration, coverageSettings);
await e.Session.Task;
var results = provider.GetCoverage(testProject, configuration);
if (results != null)
{
SaveResults(results, testProject, configuration);
}
coverageCollectionCompletion.SetResult(true);
}
/// <summary>
/// Enables coverlet in-proc datacollector
/// </summary>
internal static void EnableCoverletInProcDataCollector(string argument, DataCollectionRunSettings dataCollectionRunSettings, IRunSettingsProvider runSettingProvider, IFileHelper fileHelper)
{
DataCollectorSettings dataCollectorSettings = null;
if (!DoesDataCollectorSettingsExist(argument, dataCollectionRunSettings, out dataCollectorSettings))
{
// Create a new setting with default values
dataCollectorSettings = new DataCollectorSettings();
dataCollectorSettings.FriendlyName = argument;
dataCollectorSettings.AssemblyQualifiedName = CoverletConstants.CoverletDataCollectorAssemblyQualifiedName;
dataCollectorSettings.CodeBase = GetCoverletCodeBasePath(runSettingProvider, fileHelper) ?? CoverletConstants.CoverletDataCollectorCodebase;
dataCollectorSettings.IsEnabled = true;
dataCollectionRunSettings.DataCollectorSettingsList.Add(dataCollectorSettings);
}
else
{
// Set Assembly qualified name and code base if not already set
dataCollectorSettings.AssemblyQualifiedName = dataCollectorSettings.AssemblyQualifiedName ?? CoverletConstants.CoverletDataCollectorAssemblyQualifiedName;
dataCollectorSettings.CodeBase = (dataCollectorSettings.CodeBase ?? GetCoverletCodeBasePath(runSettingProvider, fileHelper)) ?? CoverletConstants.CoverletDataCollectorCodebase;
dataCollectorSettings.IsEnabled = true;
}
}
public MockDataCollector(DataCollectorSettings dataCollectorSettings)
{
this.DataCollectorSettings = dataCollectorSettings;
}
/// <summary>
/// Loads and initializes data collector using data collector settings.
/// </summary>
/// <param name="dataCollectorSettings">
/// The data collector settings.
/// </param>
/// <param name="settingsXml"> runsettings Xml</param>
private void LoadAndInitialize(DataCollectorSettings dataCollectorSettings, string settingsXml)
{
DataCollectorInformation dataCollectorInfo;
DataCollectorConfig dataCollectorConfig;
try
{
// Look up the extension and initialize it if one is found.
var extensionManager = this.DataCollectorExtensionManager;
var dataCollectorUri = string.Empty;
this.TryGetUriFromFriendlyName(dataCollectorSettings.FriendlyName, out dataCollectorUri);
DataCollector dataCollector = null;
if (!string.IsNullOrWhiteSpace(dataCollectorUri))
{
dataCollector = this.TryGetTestExtension(dataCollectorUri);
}
if (dataCollector == null)
{
this.LogWarning(string.Format(CultureInfo.CurrentUICulture, Resources.Resources.DataCollectorNotFound, dataCollectorSettings.FriendlyName));
return;
}
if (this.RunDataCollectors.ContainsKey(dataCollector.GetType()))
{
// Collector is already loaded (may be configured twice). Ignore duplicates and return.
return;
}
dataCollectorConfig = new DataCollectorConfig(dataCollector.GetType());
// Attempt to get the data collector information verifying that all of the required metadata for the collector is available.
dataCollectorInfo = new DataCollectorInformation(
dataCollector,
dataCollectorSettings.Configuration,
dataCollectorConfig,
this.dataCollectionEnvironmentContext,
this.attachmentManager,
this.events,
this.messageSink,
settingsXml);
}
catch (Exception ex)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("DataCollectionManager.LoadAndInitialize: exception while creating data collector {0} : {1}", dataCollectorSettings.FriendlyName, ex);
}
// No data collector info, so send the error with no direct association to the collector.
this.LogWarning(string.Format(CultureInfo.CurrentUICulture, Resources.Resources.DataCollectorInitializationError, dataCollectorSettings.FriendlyName, ex));
return;
}
try
{
dataCollectorInfo.InitializeDataCollector();
lock (this.RunDataCollectors)
{
// Add data collectors to run cache.
this.RunDataCollectors[dataCollectorConfig.DataCollectorType] = dataCollectorInfo;
}
}
catch (Exception ex)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("DataCollectionManager.LoadAndInitialize: exception while initializing data collector {0} : {1}", dataCollectorSettings.FriendlyName, ex);
}
// Log error.
dataCollectorInfo.Logger.LogError(this.dataCollectionEnvironmentContext.SessionDataCollectionContext, string.Format(CultureInfo.CurrentCulture, Resources.Resources.DataCollectorInitializationError, dataCollectorConfig.FriendlyName, ex.Message));
// Dispose datacollector.
dataCollectorInfo.DisposeDataCollector();
}
}
/// <summary>
/// Inserts a data collector settings in the file
/// </summary>
/// <param name="runSettingDocument">runSettingDocument</param>
/// <param name="settings">settings</param>
public static void InsertDataCollectorsNode(IXPathNavigable runSettingDocument, DataCollectorSettings settings)
{
if (runSettingDocument == null)
{
throw new ArgumentNullException(nameof(runSettingDocument));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var navigator = runSettingDocument.CreateNavigator();
MoveToDataCollectorsNode(ref navigator);
var settingsXml = settings.ToXml();
var dataCollectorNode = settingsXml.CreateNavigator();
dataCollectorNode.MoveToRoot();
navigator.AppendChild(dataCollectorNode);
}
protected override IInProcDataCollector CreateDataCollector(DataCollectorSettings dataCollectorSettings, TypeInfo interfaceTypeInfo)
{
return(new MockDataCollector(dataCollectorSettings));
}
/// <summary>
/// Loads and initializes datacollector using datacollector settings.
/// </summary>
/// <param name="dataCollectorSettings">
/// The data collector settings.
/// </param>
private void LoadAndInitialize(DataCollectorSettings dataCollectorSettings)
{
var collectorTypeName = dataCollectorSettings.AssemblyQualifiedName;
DataCollectorInformation dataCollectorInfo;
DataCollectorConfig dataCollectorConfig;
try
{
var dataCollector = this.dataCollectorLoader.Load(dataCollectorSettings.CodeBase, dataCollectorSettings.AssemblyQualifiedName);
if (dataCollector == null)
{
this.LogWarning(string.Format(CultureInfo.CurrentUICulture, Resources.Resources.DataCollectorNotFound, collectorTypeName, string.Empty));
return;
}
if (this.RunDataCollectors.ContainsKey(dataCollector.GetType()))
{
// Collector is already loaded (may be configured twice). Ignore duplicates and return.
return;
}
dataCollectorConfig = new DataCollectorConfig(dataCollector.GetType());
// Attempt to get the data collector information verifying that all of the required metadata for the collector is available.
dataCollectorInfo = new DataCollectorInformation(
dataCollector,
dataCollectorSettings.Configuration,
dataCollectorConfig,
this.dataCollectionEnvironmentContext,
this.attachmentManager,
this.events,
this.messageSink);
if (!dataCollectorInfo.DataCollectorConfig.TypeUri.Equals(dataCollectorSettings.Uri))
{
// If the data collector was not found, send an error.
this.LogWarning(string.Format(CultureInfo.CurrentCulture, Resources.Resources.DataCollectorNotFound, dataCollectorConfig.DataCollectorType.FullName, dataCollectorSettings.Uri));
return;
}
}
catch (Exception ex)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("DataCollectionManager.LoadAndInitialize: exception while creating data collector {0} : {1}", collectorTypeName, ex);
}
// No data collector info, so send the error with no direct association to the collector.
this.LogWarning(string.Format(CultureInfo.CurrentUICulture, Resources.Resources.DataCollectorInitializationError, collectorTypeName, ex.Message));
return;
}
try
{
dataCollectorInfo.InitializeDataCollector();
lock (this.RunDataCollectors)
{
// Add data collectors to run cache.
this.RunDataCollectors[dataCollectorConfig.DataCollectorType] = dataCollectorInfo;
}
}
catch (Exception ex)
{
if (EqtTrace.IsErrorEnabled)
{
EqtTrace.Error("DataCollectionManager.LoadAndInitialize: exception while initializing data collector {0}: " + ex, collectorTypeName);
}
// Log error.
dataCollectorInfo.Logger.LogError(this.dataCollectionEnvironmentContext.SessionDataCollectionContext, string.Format(CultureInfo.CurrentCulture, Resources.Resources.DataCollectorInitializationError, dataCollectorConfig.FriendlyName, ex.Message));
// Dispose datacollector.
dataCollectorInfo.DisposeDataCollector();
}
}
internal static void InsertOrReplaceFakesDataCollectorNode(XmlDocument runSettings, DataCollectorSettings settings)
{
// override current settings
var navigator = runSettings.CreateNavigator();
var nodes = navigator.Select("/RunSettings/DataCollectionRunSettings/DataCollectors/DataCollector");
foreach (XPathNavigator dataCollectorNavigator in nodes)
{
var uri = dataCollectorNavigator.GetAttribute("uri", string.Empty);
// We assume that only one uri can exist in a given runsettings
if (string.Equals(FakesMetadata.DataCollectorUriV1, uri, StringComparison.OrdinalIgnoreCase) ||
string.Equals(FakesMetadata.DataCollectorUriV2, uri, StringComparison.OrdinalIgnoreCase))
{
dataCollectorNavigator.ReplaceSelf(settings.ToXml().CreateNavigator());
return;
}
}
// insert new node
XmlRunSettingsUtilities.InsertDataCollectorsNode(runSettings.CreateNavigator(), settings);
}
public void Prepare(Project testProject, ConfigurationSelector configuration, DataCollectorSettings coverageSettings)
{
var unitTestDll = testProject.GetOutputFileName(configuration).ToString();
var sourceRootTranslator = new SourceRootTranslator(logger, fileSystem);
var cecilSymbolHelper = new CecilSymbolHelper();
var instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), fileSystem, logger, sourceRootTranslator);
var coverageParameters = GetCoverageParameters(coverageSettings);
var coverage = new CoverletCoverage(unitTestDll,
coverageParameters,
logger,
instrumentationHelper,
fileSystem,
sourceRootTranslator,
cecilSymbolHelper);
coverage.PrepareModules();
projectCoverageMap[new Tuple <Project, ConfigurationSelector>(testProject, configuration)] = coverage;
}
