public static void AddLogger(this ITestLogger logger, IMessageLogger childLogger)
{
if (logger != null)
{
logger.AddLogger(l => l.Logger == childLogger, () => new TestMessageTestLogger(childLogger));
}
}
public DiagnosticMessageVisitor(IMessageLogger logger, string assemblyDisplayName, bool showDiagnostics, Stopwatch stopwatch)
{
this.logger = logger;
this.assemblyDisplayName = assemblyDisplayName;
this.showDiagnostics = showDiagnostics;
this.stopwatch = stopwatch;
}
public void AddLogger(IMessageLogger logger)
{
if (logger != null)
{
_loggers.Add(new KarmaTestMessageLogger(logger));
}
}
private void ParseTests(StreamReader standardOutput, ITestCaseDiscoverySink discoverySink, IMessageLogger logger, string source)
{
string testcase = "";
bool testsStarted = false;
Regex testCaseMatch = new Regex(@".*\.$");
while (standardOutput.Peek() != -1)
{
string line = standardOutput.ReadLine();
if (!string.IsNullOrEmpty(line))
{
if (testCaseMatch.IsMatch(line))
{
testsStarted = true;
testcase = line.Trim();
logger.SendMessage(TestMessageLevel.Informational, string.Format("Found test case {0}", testcase.Trim('.')));
}
else if(testsStarted)
{
TestCase test = new TestCase(testcase + line.Trim(), Plugin.VisualStudio2012.GTest.GTestExecutor.ExecutorUri, source);
discoverySink.SendTestCase(test);
logger.SendMessage(TestMessageLevel.Informational, string.Format("Found test {0}", testcase + line.Trim()));
}
}
}
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext
, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
#if DEBUG && LAUNCH_DEBUGGER
System.Diagnostics.Debugger.Launch();
#endif
try
{
Logger.Initialize(logger);
var sourceGroups = sources.GroupBy(Path.GetExtension);
foreach (IGrouping<string, string> sourceGroup in sourceGroups)
{
IIutestTestDiscoverer discoverer = iutestTestDiscovererFactory.GetTestDiscoverer(sourceGroup.Key);
if( discoverer != null )
{
discoverer.DiscoverTests(sourceGroup, discoveryContext, logger, discoverySink);
}
}
}
catch( Exception e )
{
Logger.Error("iutest_adapter: Exception caught while DiscoverTests: {0}, {1} ", e.Message, e.HResult );
Logger.Error(e.StackTrace);
}
finally
{
Logger.Uninitialize();
}
}
static Defaults()
{
//use the simple logger if on unix as the color setting relies on p/invoke
if (IsRunningOnMono ()) {
_logger = new MessageLoggerProxy (new SimpleMessageLogger ());
FrameworkVersion=Utilities.FrameworkVersion.NET4_5;
}
else
{
_logger = new MessageLoggerProxy(new ConsoleMessageLogger());
var frameworkVersionsToCheck = new List<IFrameworkVersion>();
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET4_5);
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET4_0.Full);
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET4_0.Client);
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET3_5);
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET3_0);
frameworkVersionsToCheck.Add(Utilities.FrameworkVersion.NET2_0);
foreach (IFrameworkVersion frameworkVersion in frameworkVersionsToCheck)
{
if (frameworkVersion.IsFrameworkInstalled())
{
FrameworkVersion = frameworkVersion;
return;
}
}
}
}
public IEnumerable<TestCase> Discover(IEnumerable<string> sources, IMessageLogger logger)
{
foreach (string source in sources)
{
Assembly assembly = Assembly.LoadFrom(source);
IEnumerable<Type> testGeneratorTypes = assembly.GetTypes()
.Where(TypeIsImplementationOfTestGeneratorInterface);
foreach (Type testGeneratorType in testGeneratorTypes)
{
ITestGenerator testGenerator = Activator.CreateInstance(testGeneratorType) as ITestGenerator;
foreach (Test test in testGenerator.Generate())
{
yield return new TestCase(String.Format("{0}#{1}", testGeneratorType.FullName, test.Name.Replace(" ", "")), TestGeneratorAdapter.ExecutorUri, source)
{
DisplayName = test.Name,
LineNumber = test.LineNumber,
CodeFilePath = test.SourceFile
};
}
}
}
}
internal static ICollection<IPlayer> CreatePlayers(GameType gameType, IMessageLogger messageLogger)
{
logger = messageLogger;
ICollection<IPlayer> players = new List<IPlayer>();
switch (gameType)
{
case GameType.SinglePlayer:
var humanPlayer = CreateHumanPlayer();
var computerPlayer = CreateComputerPlayer();
players.Add(humanPlayer);
players.Add(computerPlayer);
break;
case GameType.MultiPlayer:
var firstPlayer = CreateHumanPlayer();
var secondPlayer = CreateHumanPlayer();
players.Add(firstPlayer);
players.Add(secondPlayer);
break;
default:
BullsAndCowsException.GameTypeException();
break;
}
return players;
}
public DbDiffChangeLoggerContext(DbDiffOptions opts, IMessageLogger logger, DbDiffOptsLogger ltype)
{
m_opts = opts;
m_ltype = ltype;
m_oldValue = m_opts.DiffLogger;
m_opts.SetLogger(m_ltype, logger);
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
_logger = logger;
_logger.SendMessage(TestMessageLevel.Informational, ">>> DiscoverTests");
GetTests(sources, discoverySink);
}
public NewItemFactoryTypeModel(Type type, NewItemFactory factory)
{
this.type = type;
this.factory = factory;
this.desiredSize = new Size(0, 0);
this.exceptionLogger = null;
}
/// <summary>
/// Finds tests in Catch unit test binaries. Note: We have to run the binary to enumerate tests.
/// </summary>
/// <param name="sources">Binaries to search for tests.</param>
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext context, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
currentLogger = logger;
foreach (var source in sources)
{
switch (checkCatchTestBinaryFormat(source))
{
case CatchBinaryFormat.NoCatchTestBinary:
continue;
case CatchBinaryFormat.CatchTestBinary:
foreach (var testCase in ListTestsInBinary(source))
{
discoverySink.SendTestCase(testCase);
}
continue;
case CatchBinaryFormat.CatchTestBinaryWithXmlTestList:
foreach (var testCase in ListTestsInBinaryXml(source))
{
discoverySink.SendTestCase(testCase);
}
break;
}
}
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
testLogger = new TestLogger(logger);
testLogger.SendMainMessage("Discovery started");
foreach (var source in sources)
{
testLogger.SendDebugMessage(String.Format("Processing: '{0}'", source));
try
{
using (var sandbox = new Sandbox<Discoverer>(source))
{
if (sandbox.Content != null)
{
sandbox.Content
.DiscoverTests()
.Select(name => name.ToTestCase(source))
.ForEach(discoverySink.SendTestCase);
}
}
}
catch (Exception ex)
{
testLogger.SendErrorMessage(ex, String.Format("Exception found while discovering tests in source '{0}'", source));
// just go on with the next
}
}
testLogger.SendMainMessage("Discovery finished");
}
public static List<TestCase> GetTests(IEnumerable<string> sources, ITestCaseDiscoverySink discoverySink, IMessageLogger logger = null)
{
var tests = new List<TestCase>();
foreach (var source in sources)
{
var testType = TestType.Pester;
var scriptContents = System.IO.File.ReadAllText(source);
if (scriptContents.StartsWith("#pester", StringComparison.OrdinalIgnoreCase))
{
testType = TestType.Pester;
}
else if (scriptContents.StartsWith("#psate", StringComparison.OrdinalIgnoreCase))
{
testType = TestType.PSate;
}
if (testType == TestType.Pester)
{
DiscoverPesterTests(discoverySink, logger, source, tests);
}
else if (testType == TestType.PSate)
{
DiscoverPsateTests(discoverySink, source, tests);
}
}
return tests;
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
Code.Require(sources, "sources");
Code.Require(discoverySink, "discoverySink");
BoostTestAdapterSettings settings = BoostTestAdapterSettingsProvider.GetSettings(discoveryContext);
_sourceFilters = SourceFilterFactory.Get(settings);
IDictionary<string, ProjectInfo> solutioninfo = null;
var numberOfAttempts = 100;
// try several times to overcome "Application is Busy" COMException
while (numberOfAttempts > 0)
{
try
{
solutioninfo = PrepareTestCaseData(sources);
// set numberOfAttempts = 0, because there is no need to try again,
// since obviously no exception was thrown at this point
numberOfAttempts = 0;
}
catch (COMException)
{
--numberOfAttempts;
// re-throw after all attempts have failed
if (numberOfAttempts == 0)
{
throw;
}
}
}
GetBoostTests(solutioninfo, discoverySink);
}
// The Adapter is constructed using the default constructor.
// We don't have any info to initialize it until one of the
// ITestDiscovery or ITestExecutor methods is called. The
// each Discover or Execute method must call this method.
protected virtual void Initialize(IMessageLogger messageLogger)
{
Verbosity = 0; // In case we throw below
AdapterVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString();
try
{
var registry = RegistryCurrentUser.OpenRegistryCurrentUser(@"Software\nunit.org\VSAdapter");
UseVsKeepEngineRunning = registry.Exist("UseVsKeepEngineRunning") && (registry.Read<int>("UseVsKeepEngineRunning") == 1);
ShadowCopy = registry.Exist("ShadowCopy") && (registry.Read<int>("ShadowCopy") == 1);
#if DEBUG && VERBOSE
Verbosity = 1;
#else
Verbosity = (registry.Exist("Verbosity")) ? registry.Read<int>("Verbosity") : 0;
#endif
}
catch (Exception e)
{
messageLogger.SendMessage(TestMessageLevel.Error, "Unable to access registry. Default settings will be used");
messageLogger.SendMessage(TestMessageLevel.Error, e.ToString());
}
TestEngine = new TestEngine();
TestLog = new TestLogger(messageLogger, Verbosity);
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger log, ITestCaseDiscoverySink discoverySink)
{
log.Version();
RemotingUtility.CleanUpRegisteredChannels();
foreach (var assemblyPath in sources)
{
try
{
if (AssemblyDirectoryContainsFixie(assemblyPath))
{
log.Info("Processing " + assemblyPath);
using (var environment = new ExecutionEnvironment(assemblyPath))
{
var methodGroups = environment.DiscoverTestMethodGroups(new Options());
foreach (var methodGroup in methodGroups)
discoverySink.SendTestCase(new TestCase(methodGroup.FullName, VsTestExecutor.Uri, assemblyPath));
}
}
else
{
log.Info("Skipping " + assemblyPath + " because it is not a test assembly.");
}
}
catch (Exception exception)
{
log.Error(exception);
}
}
}
public void DiscoverTests(IEnumerable<string> sources,
IDiscoveryContext discoveryContext,
IMessageLogger logger,
ITestCaseDiscoverySink discoverySink)
{
var validSources = from source in sources
where source.EndsWith(StringHelper.GetSearchExpression(), StringComparison.CurrentCultureIgnoreCase)
select source;
foreach (var source in validSources) {
var results = appDomainRunner.ExecuteSpecifications(source);
var query = from result in results
from @group in result.Examples
from example in @group.Examples
select example;
foreach (var example in query) {
var testCase = new TestCase(example.Reason, DefaultTestExecutor.ExecutorUri, source) {
CodeFilePath = example.FileName,
LineNumber = example.LineNumber
};
discoverySink.SendTestCase(testCase);
}
}
}
public static PropertyValueEditor GetValueEditor(IEnumerable attributes, IMessageLogger exceptionLogger)
{
PropertyValueEditor propertyValueEditor = null;
if (attributes != null)
{
foreach (Attribute attribute in attributes)
{
EditorAttribute editorAttribute = attribute as EditorAttribute;
if (editorAttribute != null)
{
try
{
Type editorType = Type.GetType(editorAttribute.EditorTypeName);
if (editorType != null && typeof(PropertyValueEditor).IsAssignableFrom(editorType))
{
propertyValueEditor = (PropertyValueEditor)Activator.CreateInstance(editorType);
break;
}
}
catch (Exception e)
{
if (exceptionLogger != null)
{
exceptionLogger.WriteLine(string.Format(CultureInfo.CurrentCulture, ExceptionStringTable.ValueEditorLoadFailed, ExtensibilityMetadataHelper.GetExceptionMessage(e)));
}
}
}
}
}
return propertyValueEditor;
}
public virtual void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
TestAdapterInfo = CreateTestAdapterInfo();
var testLogger = TestAdapterInfo.CreateLogger(logger);
var discoverLogger = new TestLogger(testLogger, "Discover");
var testSettings = discoveryContext.RunSettings.GetTestSettings(TestAdapterInfo.SettingsName);
var count = 0;
var testCount = 0;
foreach (var source in sources)
{
var sourceSettings = GetSourceSettings(source, testSettings);
if (sourceSettings != null)
{
testCount += DiscoverTests(sourceSettings, testLogger, discoverySink).Result;
count += 1;
}
else
{
discoverLogger.Warn("Could not get settings for {0}", source);
}
}
if (count > 0 || testCount > 0)
{
discoverLogger.Info("{0} tests discovered in {1} test containers", testCount, count);
}
}
public void DiscoverTests(IEnumerable<string> sources,
IDiscoveryContext discoveryContext,
IMessageLogger logger,
ITestCaseDiscoverySink discoverySink)
{
GetTests(sources, discoverySink);
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
ChutzpahTracer.TraceInformation("Begin Test Adapter Discover Tests");
var settingsProvider = discoveryContext.RunSettings.GetSettings(AdapterConstants.SettingsName) as ChutzpahAdapterSettingsProvider;
var settings = settingsProvider != null ? settingsProvider.Settings : new ChutzpahAdapterSettings();
ChutzpahTracingHelper.Toggle(settings.EnabledTracing);
var testOptions = new TestOptions
{
MaxDegreeOfParallelism = settings.MaxDegreeOfParallelism,
ChutzpahSettingsFileEnvironments = new ChutzpahSettingsFileEnvironments(settings.ChutzpahSettingsFileEnvironments)
};
IList<TestError> errors;
var testCases = testRunner.DiscoverTests(sources, testOptions, out errors);
ChutzpahTracer.TraceInformation("Sending discovered tests to test case discovery sink");
foreach (var testCase in testCases)
{
var vsTestCase = testCase.ToVsTestCase();
discoverySink.SendTestCase(vsTestCase);
}
foreach (var error in errors)
{
logger.SendMessage(TestMessageLevel.Error, RunnerCallback.FormatFileErrorMessage(error));
}
ChutzpahTracer.TraceInformation("End Test Adapter Discover Tests");
}
/// <summary>
/// Accepts a handle to the logger instance so that subsequently, textual messages can be sent to it.
/// </summary>
/// <param name="logger">Reference to the logger.</param>
public static void Initialize(IMessageLogger logger)
{
_loggerInstance = logger; //VS sink handle
ConfigureLog4Net();
Info("Logger initialized. Logging to {0}", log4net.GlobalContext.Properties["LogFilePath"]);
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink) {
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(discoverySink, "discoverySink");
var settings = discoveryContext.RunSettings;
DiscoverTests(sources, logger, discoverySink, settings);
}
public GameEngine(IEnumerable<IPlayer> players, ICommandManager commandManager, GameType mode, IMessageLogger logger)
{
commandManager.SetGameEngine(this);
this.commandManager = commandManager;
this.Players = players;
this.Mode = mode;
this.Logger = logger;
}
public static IEnumerable<NodeUnitTestDescriptor> DiscoverTests(string filename, IMessageLogger logger)
{
List<NodeUnitTestDescriptor> foundTests = new List<NodeUnitTestDescriptor>();
StringBuilder sbException = new StringBuilder();
Process proc = new Process();
string nodeFullPath = NodeJsHelper.LocateNodeJs();
proc.StartInfo.FileName = nodeFullPath;
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardInput = true;
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.RedirectStandardError = true;
proc.StartInfo.CreateNoWindow = true;
proc.OutputDataReceived += (sender, args) =>
{
if (!string.IsNullOrEmpty(args.Data))
{
try
{
var test = JsonConvert.DeserializeObject<NodeUnitTestDescriptor>(args.Data);
foundTests.Add(test);
}
catch(JsonReaderException)
{
logger.SendMessage(TestMessageLevel.Informational, args.Data);
}
}
};
proc.ErrorDataReceived += (sender, args) =>
{
if (!string.IsNullOrEmpty(args.Data))
{
sbException.AppendLine(args.Data);
}
};
proc.Start();
proc.BeginOutputReadLine();
proc.BeginErrorReadLine();
proc.StandardInput.Write(Resources.Disco);
proc.StandardInput.Write("disco(\"" + filename.Replace("\\", "\\\\") + "\");");
proc.StandardInput.Close();
proc.WaitForExit();
if (sbException.Length > 0)
{
throw new Exception(sbException.ToString());
}
return foundTests;
}
/// <summary>
/// Creates a new instance of the <see cref="CustomTextMessageEncoderFactory" />
/// </summary>
/// <param name="mediaType"></param>
/// <param name="charSet"></param>
/// <param name="alternateContentType"></param>
/// <param name="messageLogger"></param>
/// <param name="version"></param>
/// <param name="transformers"></param>
public CustomTextMessageEncoderFactory(string mediaType, string charSet, string alternateContentType, IMessageLogger messageLogger, MessageVersion version, IList<IMessageTransformer> transformers)
{
this.version = version;
this.mediaType = mediaType;
this.charSet = charSet;
this.alternateContentType = alternateContentType;
this.messageLogger = messageLogger ?? new NullMessageLogger();
this.transformers = transformers;
this.encoder = new CustomTextMessageEncoder(this);
}
public TestGeneratorAdapterTests()
{
testGeneratorDiscoverer = Substitute.For<ITestGeneratorDiscoverer>();
discoveryContext = Substitute.For<IDiscoveryContext>();
discoverySink = Substitute.For<ITestCaseDiscoverySink>();
logger = Substitute.For<IMessageLogger>();
frameworkHandle = Substitute.For<IFrameworkHandle>();
runContext = Substitute.For<IRunContext>();
testGenerator = Substitute.For<ITestGenerator>();
}
public BackgroundThreadLogger(
IMessageLogger logger
)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
_logger = logger;
}
public void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
foreach(var source in sources) {
var xDomainSink = new TestAdapterLogger(logger, source);
xDomainSink.OnBeginTest += (_, e) => discoverySink.SendTestCase(e.TestCase);
CrossDomainConeRunner.WithProxyInDomain<ConeTestAdapterProxy, int>(string.Empty,
new [] { source, },
proxy => proxy.DiscoverTests(source, xDomainSink)
);
}
}
/// <summary>
/// Constructor of MessageController
/// </summary>
/// <param name="messageLogger">Interface to store and access messages</param>
/// <param name="mapper">DTO object mapper</param>
public MessageController(IMessageLogger messageLogger, IMapper mapper)
{
_messageLogger = messageLogger;
_mapper = mapper;
}
public TransactionScheduledMessageMachine(IMessageLogger logger, IPrintJobService printJobService) : this()
{
this.printJobService = printJobService;
this.logger = logger;
}
public TestLogger(IMessageLogger messageLogger, int verbosity)
{
MessageLogger = messageLogger;
Verbosity = verbosity;
}
public VsTestFrameworkLogger(IMessageLogger logger, SettingsWrapper settings)
{
_logger = logger;
_settings = settings;
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
if (string.IsNullOrEmpty(new RunSettings(discoveryContext.RunSettings).GetSetting("TestDatabaseConnectionString")))
{
logger.SendMessage(TestMessageLevel.Informational, "No RunSettings TestDatabaseConnectionString set - will not attempt to discover tests..");
return;
}
logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...");
var includePath = new RunSettings(discoveryContext.RunSettings).GetSetting("IncludePath");
SetPathFilter(includePath, logger);
lock (_lock)
{
GetTests(sources, discoverySink);
}
if (_tests != null)
{
logger.SendMessage(TestMessageLevel.Informational, string.Format("tSQLt Test Adapter, searching for tests...done - {0} found", _tests.GetTests().Sum(p => p.Tests.Count)));
}
else
{
logger.SendMessage(TestMessageLevel.Informational, "tSQLt Test Adapter, searching for tests...done - none found");
}
}
static void RunTests(IMessageLogger log, IFrameworkHandle frameworkHandle, string assemblyPath, Action <NamedPipeServerStream> sendCommand)
{
if (!IsTestAssembly(assemblyPath))
{
log.Info("Skipping " + assemblyPath + " because it is not a test assembly.");
return;
}
log.Info("Processing " + assemblyPath);
var pipeName = Guid.NewGuid().ToString();
Environment.SetEnvironmentVariable("FIXIE_NAMED_PIPE", pipeName);
using (var pipe = new NamedPipeServerStream(pipeName, PipeDirection.InOut, 1, PipeTransmissionMode.Message))
{
Start(assemblyPath, frameworkHandle);
pipe.WaitForConnection();
sendCommand(pipe);
var recorder = new ExecutionRecorder(frameworkHandle, assemblyPath);
while (true)
{
var messageType = pipe.ReceiveMessage();
if (messageType == typeof(PipeMessage.CaseSkipped).FullName)
{
var testResult = pipe.Receive <PipeMessage.CaseSkipped>();
recorder.Record(testResult);
}
else if (messageType == typeof(PipeMessage.CasePassed).FullName)
{
var testResult = pipe.Receive <PipeMessage.CasePassed>();
recorder.Record(testResult);
}
else if (messageType == typeof(PipeMessage.CaseFailed).FullName)
{
var testResult = pipe.Receive <PipeMessage.CaseFailed>();
recorder.Record(testResult);
}
else if (messageType == typeof(PipeMessage.Exception).FullName)
{
var exception = pipe.Receive <PipeMessage.Exception>();
throw new RunnerException(exception);
}
else if (messageType == typeof(PipeMessage.Completed).FullName)
{
var completed = pipe.Receive <PipeMessage.Completed>();
break;
}
else
{
var body = pipe.ReceiveMessage();
throw new Exception($"Test runner received unexpected message of type {messageType}: {body}");
}
}
}
}
private string EvaluateJavaScript(string nodeExePath, string testFile, string discoverResultFile, IMessageLogger logger, string workingDirectory)
{
workingDirectory = workingDirectory.TrimEnd(new char['\\']);
var arguments = WrapWithQuotes(this.findTestsScriptFile)
+ " " + this.Name +
" " + WrapWithQuotes(testFile) +
" " + WrapWithQuotes(discoverResultFile) +
" " + WrapWithQuotes(workingDirectory);
var processStartInfo = new ProcessStartInfo(nodeExePath, arguments)
{
CreateNoWindow = true,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true
};
var stdout = string.Empty;
try
{
using (var process = Process.Start(processStartInfo))
{
process.EnableRaisingEvents = true;
process.OutputDataReceived += (sender, args) =>
{
stdout += args.Data + Environment.NewLine;
};
process.ErrorDataReceived += (sender, args) =>
{
stdout += args.Data + Environment.NewLine;
};
process.BeginErrorReadLine();
process.BeginOutputReadLine();
process.WaitForExit();
#if DEBUG
logger.SendMessage(TestMessageLevel.Informational, string.Format(CultureInfo.InvariantCulture, " Process exited: {0}", process.ExitCode));
#endif
}
#if DEBUG
logger.SendMessage(TestMessageLevel.Informational, string.Format(CultureInfo.InvariantCulture, " StdOut:{0}", stdout));
#endif
}
catch (FileNotFoundException e)
{
logger.SendMessage(TestMessageLevel.Error, string.Format(CultureInfo.InvariantCulture, "Error starting node.exe.\n {0}", e));
}
return(stdout);
}
public static void Info(this IMessageLogger logger, string message) => logger.SendMessage(TestMessageLevel.Informational, message);
public static void Version(this IMessageLogger logger) => logger.Info(Framework.Version);
public static void Error(this IMessageLogger logger, Exception exception) => logger.SendMessage(TestMessageLevel.Error, exception.ToString());
/// <summary>
/// Discovers tests from the sources.
/// </summary>
/// <param name="testExtensionSourceMap"> The test extension source map. </param>
/// <param name="settings"> The settings. </param>
/// <param name="testCaseFilter"> The test case filter. </param>
/// <param name="logger"> The logger. </param>
public void LoadTests(IDictionary <string, IEnumerable <string> > testExtensionSourceMap, IRunSettings settings, string testCaseFilter, IMessageLogger logger)
{
this.testPlatformEventSource.DiscoveryStart();
try
{
foreach (var kvp in testExtensionSourceMap)
{
this.LoadTestsFromAnExtension(kvp.Key, kvp.Value, settings, testCaseFilter, logger);
}
}
finally
{
this.testPlatformEventSource.DiscoveryStop(this.discoveryResultCache.TotalDiscoveredTests);
}
}
/// <summary>
/// ITestDiscover, Given a list of test sources this method pulls out the test cases
/// </summary>
/// <param name="sources">List of test sources passed from client (Client can be VS or command line)</param>
/// <param name="discoveryContext">Context and runSettings for current run. Discoverer pulls out the tests based on current context</param>
/// <param name="logger">Used to relay messages to registered loggers</param>
/// <param name="discoverySink">Callback used to notify client upon discovery of test cases</param>
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
ValidateArg.NotNull(sources, "sources");
ValidateArg.NotNull(discoverySink, "discoverySink");
ValidateArg.NotNull(logger, "logger");
var env = new Dictionary <string, string>();
var root = Environment.GetEnvironmentVariable(NodejsConstants.NodeToolsVsInstallRootEnvironmentVariable);
if (!string.IsNullOrEmpty(root))
{
env["VsInstallRoot"] = root;
env["MSBuildExtensionsPath32"] = Path.Combine(root, "MSBuild");
}
using (var buildEngine = new MSBuild.ProjectCollection(env))
{
try
{
// Load all the test containers passed in (.njsproj msbuild files)
foreach (var source in sources)
{
buildEngine.LoadProject(source);
}
foreach (var proj in buildEngine.LoadedProjects)
{
var projectHome = Path.GetFullPath(Path.Combine(proj.DirectoryPath, "."));
var testItems = new Dictionary <string, List <TestFileEntry> >(StringComparer.OrdinalIgnoreCase);
// Provide all files to the test analyzer
foreach (var item in proj.Items.Where(item => item.ItemType == "Compile" || item.ItemType == "TypeScriptCompile"))
{
//Check to see if this is a TestCase
var value = item.GetMetadataValue("TestFramework");
if (!TestContainerDiscoverer.IsValidTestFramework(value))
{
continue;
}
var fileAbsolutePath = CommonUtils.GetAbsoluteFilePath(projectHome, item.EvaluatedInclude);
var typeScriptTest = TypeScript.TypeScriptHelpers.IsTypeScriptFile(fileAbsolutePath);
if (typeScriptTest)
{
fileAbsolutePath = TypeScript.TypeScriptHelpers.GetTypeScriptBackedJavaScriptFile(proj, fileAbsolutePath);
}
else if (!Path.GetExtension(fileAbsolutePath).Equals(".js", StringComparison.OrdinalIgnoreCase))
{
continue;
}
List <TestFileEntry> fileList;
if (!testItems.TryGetValue(value, out fileList))
{
fileList = new List <TestFileEntry>();
testItems.Add(value, fileList);
}
fileList.Add(new TestFileEntry(fileAbsolutePath, typeScriptTest));
}
DiscoverTests(testItems, proj, discoverySink, logger);
}
}
catch (Exception ex)
{
logger.SendMessage(TestMessageLevel.Error, ex.Message);
throw;
}
finally
{
// Disposing buildEngine does not clear the document cache in
// VS 2013, so manually unload all projects before disposing.
buildEngine.UnloadAllProjects();
}
}
}
public List <NodejsTestInfo> FindTests(IEnumerable <string> testFiles,
string nodeExe,
IMessageLogger logger,
string workingDirectory)
{
var testInfo = string.Empty;
var discoverResultFile = Path.GetTempFileName();
try
{
var stdout = EvaluateJavaScript(nodeExe, string.Join(";", testFiles), discoverResultFile, logger, workingDirectory);
if (!string.IsNullOrWhiteSpace(stdout))
{
var stdoutLines = stdout.Split(new[] { Environment.NewLine },
StringSplitOptions.RemoveEmptyEntries).Where(s => s.StartsWith("NTVS_ERROR:")).Select(s => s.Trim().Remove(0, 11));
if (stdoutLines != null && stdoutLines.Count() > 0)
{
foreach (var s in stdoutLines)
{
logger.SendMessage(TestMessageLevel.Error, s);
}
//There was an error during detection, return an empty set
return(new List <NodejsTestInfo>());
}
}
for (var i = 0; i < 4; i++)
{
try
{
testInfo = File.ReadAllText(discoverResultFile);
break;
}
catch (IOException)
{
//We took an error processing the file. Wait a few and try again
Thread.Sleep(500);
}
}
}
finally
{
try
{
File.Delete(discoverResultFile);
}
catch (Exception)
{
//Unable to delete for some reason
//We leave the file behind in this case, its in TEMP so eventually OS will clean up
}
}
var testCases = new List <NodejsTestInfo>();
var discoveredTests = (List <DiscoveredTest>)JsonConvert.DeserializeObject(testInfo, typeof(List <DiscoveredTest>));
if (discoveredTests != null)
{
foreach (var discoveredTest in discoveredTests)
{
var line = discoveredTest.Line + 1;
var column = discoveredTest.Column + 1;
var test = new NodejsTestInfo(discoveredTest.File, discoveredTest.Test, this.Name, line, column);
testCases.Add(test);
}
}
return(testCases);
}
public IOutputLogger CreateOutput(IMessageLogger messageLogger, IAdapterSettings settings)
{
return(new OutputLogger(messageLogger, adapterInfo, settings));
}
internal void SendTestCases(string source, IEnumerable <UnitTestElement> testElements, ITestCaseDiscoverySink discoverySink, IDiscoveryContext discoveryContext, IMessageLogger logger)
{
var shouldCollectSourceInformation = MSTestSettings.RunConfigurationSettings.CollectSourceInformation;
var navigationSessions = new Dictionary <string, object>();
try
{
if (shouldCollectSourceInformation)
{
navigationSessions.Add(source, PlatformServiceProvider.Instance.FileOperations.CreateNavigationSession(source));
}
// Get filter expression and skip discovery in case filter expression has parsing error.
ITestCaseFilterExpression filterExpression = this.TestMethodFilter.GetFilterExpression(discoveryContext, logger, out var filterHasError);
if (filterHasError)
{
return;
}
foreach (var testElement in testElements)
{
var testCase = testElement.ToTestCase();
// Filter tests based on test case filters
if (filterExpression != null && filterExpression.MatchTestCase(testCase, (p) => this.TestMethodFilter.PropertyValueProvider(testCase, p)) == false)
{
continue;
}
if (shouldCollectSourceInformation)
{
string testSource = testElement.TestMethod.DeclaringAssemblyName ?? source;
if (!navigationSessions.TryGetValue(testSource, out var testNavigationSession))
{
testNavigationSession = PlatformServiceProvider.Instance.FileOperations.CreateNavigationSession(testSource);
navigationSessions.Add(testSource, testNavigationSession);
}
if (testNavigationSession != null)
{
var className = testElement.TestMethod.DeclaringClassFullName
?? testElement.TestMethod.FullClassName;
var methodName = testElement.TestMethod.Name;
// If it is async test method use compiler generated type and method name for navigation data.
if (!string.IsNullOrEmpty(testElement.AsyncTypeName))
{
className = testElement.AsyncTypeName;
// compiler generated method name is "MoveNext".
methodName = "MoveNext";
}
PlatformServiceProvider.Instance.FileOperations.GetNavigationData(
testNavigationSession,
className,
methodName,
out var minLineNumber,
out var fileName);
if (!string.IsNullOrEmpty(fileName))
{
testCase.LineNumber = minLineNumber;
testCase.CodeFilePath = fileName;
}
}
}
discoverySink.SendTestCase(testCase);
}
}
finally
{
foreach (object navigationSession in navigationSessions.Values)
{
PlatformServiceProvider.Instance.FileOperations.DisposeNavigationSession(navigationSession);
}
}
}
public PointingCandidatesStrategy(IMessageLogger logger)
{
_logger = logger;
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
foreach (var testCase in DiscoverTestCases(sources))
{
discoverySink.SendTestCase(testCase);
}
}
/// <summary>
/// Default constructor.
/// </summary>
protected TestLoggerManager(TestSessionMessageLogger sessionLogger, InternalTestLoggerEvents loggerEvents)
{
this.messageLogger = sessionLogger;
this.testLoggerExtensionManager = TestLoggerExtensionManager.Create(messageLogger);
this.loggerEvents = loggerEvents;
}
public TestLogger(IMessageLogger messageLogger) : this(messageLogger, 0)
{
}
public TestLogger(IMessageLogger messageLogger)
{
MessageLogger = messageLogger;
}
/// <summary>
/// Initializes a new instance of the <see cref="DotnetDataCollectionLauncher"/> class.
/// </summary>
/// <param name="processHelper">
/// The process helper.
/// </param>
/// <param name="fileHelper">
/// The file Helper.
/// </param>
/// <param name="messageLogger">
/// The message Logger.
/// </param>
internal DotnetDataCollectionLauncher(IProcessHelper processHelper, IFileHelper fileHelper, IMessageLogger messageLogger) : base(processHelper, messageLogger)
{
this.processHelper = processHelper;
this.fileHelper = fileHelper;
this.DataCollectorProcessId = -1;
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
IsDiscoverTestCalled = true;
throw new NotImplementedException();
}
public void Initialize(IMessageLogger logger)
{
this.messageLogger = logger;
}
public override void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
Sources = sources;
IsNativeDiscoverTestCalled = true;
base.DiscoverTests(sources, discoveryContext, logger, discoverySink);
}
// TODO -- take in MessagingRoot instead?
public MessageRouter(MessagingSerializationGraph serializers, IChannelGraph channels,
ISubscriptionsRepository subscriptions, HandlerGraph handlers, IMessageLogger logger, UriAliasLookup lookup,
MessagingSettings settings)
{
_serializers = serializers;
_channels = channels;
_subscriptions = subscriptions;
_handlers = handlers;
_logger = logger;
_lookup = lookup;
_settings = settings;
_workers = _settings.Workers;
}
public virtual void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
if (DllTestDiscoverer.ShouldTestDiscovered(sources) == false)
{
return;
}
DiscoveryContext = discoveryContext;
MessageLogger = logger;
DiscoverySink = discoverySink;
var testCase = new TestCase("A.C.M", new Uri("executor://dllexecutor"), "A");
discoverySink.SendTestCase(testCase);
}
private HashSet <string> ValidateTargetsExist(IMessageLogger <BinaryAnalyzerContext> logger, HashSet <string> targets)
{
return(targets);
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
IsDiscoverTestCalled = true;
Sources = sources;
DiscoveryContext = discoveryContext;
MessageLogger = logger;
DiscoverySink = discoverySink;
}
public void DiscoverTests(IEnumerable <string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink)
{
if (ShimTestDiscoverer.AssemblyResolver == null)
{
ShimTestDiscoverer.AssemblyResolver = new AssemblyResolver();
}
this.testDiscoverer = new TestDiscoverer();
this.testDiscoverer.DiscoverTests(sources, discoveryContext, logger, discoverySink);
}
private void DiscoverTests(Dictionary <string, List <TestFileEntry> > testItems, MSBuild.Project proj, ITestCaseDiscoverySink discoverySink, IMessageLogger logger)
{
var result = new List <TestFrameworks.NodejsTestInfo>();
var projectHome = Path.GetFullPath(Path.Combine(proj.DirectoryPath, "."));
var projSource = proj.FullPath;
var nodeExePath =
Nodejs.GetAbsoluteNodeExePath(
projectHome,
proj.GetPropertyValue(NodeProjectProperty.NodeExePath));
if (!File.Exists(nodeExePath))
{
logger.SendMessage(TestMessageLevel.Error, string.Format(CultureInfo.CurrentCulture, "Node.exe was not found. Please install Node.js before running tests."));
return;
}
var testCount = 0;
foreach (var testFx in testItems.Keys)
{
var testFramework = GetTestFrameworkObject(testFx);
if (testFramework == null)
{
logger.SendMessage(TestMessageLevel.Warning, string.Format(CultureInfo.CurrentCulture, "Ignoring unsupported test framework {0}", testFx));
continue;
}
var fileList = testItems[testFx];
var files = string.Join(";", fileList.Select(p => p.File));
logger.SendMessage(TestMessageLevel.Informational, string.Format(CultureInfo.CurrentCulture, "Processing: {0}", files));
var discoveredTestCases = testFramework.FindTests(fileList.Select(p => p.File), nodeExePath, logger, projectHome);
testCount += discoveredTestCases.Count;
foreach (var discoveredTest in discoveredTestCases)
{
var qualifiedName = discoveredTest.FullyQualifiedName;
logger.SendMessage(TestMessageLevel.Informational, string.Format(CultureInfo.CurrentCulture, " " /*indent*/ + "Creating TestCase:{0}", qualifiedName));
//figure out the test source info such as line number
var filePath = discoveredTest.ModulePath;
var entry = fileList.Find(p => p.File.Equals(filePath, StringComparison.OrdinalIgnoreCase));
FunctionInformation fi = null;
if (entry.IsTypeScriptTest)
{
fi = SourceMapper.MaybeMap(new FunctionInformation(string.Empty,
discoveredTest.TestName,
discoveredTest.SourceLine,
entry.File));
}
discoverySink.SendTestCase(
new TestCase(qualifiedName, TestExecutor.ExecutorUri, projSource)
{
CodeFilePath = (fi != null) ? fi.Filename : filePath,
LineNumber = (fi != null && fi.LineNumber.HasValue) ? fi.LineNumber.Value : discoveredTest.SourceLine,
DisplayName = discoveredTest.TestName
});
}
logger.SendMessage(TestMessageLevel.Informational, string.Format(CultureInfo.CurrentCulture, "Processing finished for framework of {0}", testFx));
}
if (testCount == 0)
{
logger.SendMessage(TestMessageLevel.Warning, string.Format(CultureInfo.CurrentCulture, "Discovered 0 testcases."));
}
}
