public static KarmaSettings Read(string path, IKarmaLogger logger)
{
logger.Info("Reading settings from {0}", path);
KarmaSettings settings = null;
if (PathUtils.PathHasFileName(path, Globals.SettingsFilename) && File.Exists(path))
{
try
{
settings = JsonConvert.DeserializeObject <KarmaSettings>(File.ReadAllText(path, Encoding.UTF8));
settings.SettingsFile = path;
}
catch (Exception ex)
{
logger.Error(ex.Message);
}
}
else
{
settings = new KarmaSettings
{
KarmaConfigFile = Path.GetFileName(path)
};
}
settings.Directory = Path.GetDirectoryName(path);
return(settings);
}
public IEnumerable <ConsolidatedTestResult> ConsolidateResults(IKarmaLogger logger)
{
if (Files == null)
{
return(Enumerable.Empty <ConsolidatedTestResult>());
}
var tests = Files.AllTests.Select(t => new ConsolidatedTestResult(t)).ToList();
if (Results != null)
{
foreach (var browser in Results.Browsers)
{
foreach (var result in browser.AllTestResults)
{
var test = tests.FirstOrDefault(t => t.Test.DisplayName == result.DisplayName);
if (test != null)
{
test.Results.Add(result);
}
}
}
}
return(tests);
}
public void AddLogger(IKarmaLogger logger)
{
if (logger != null)
{
_loggers.Add(logger);
}
}
public override void AddLogger(IKarmaLogger logger)
{
if (logger != null)
{
_loggers.Add(logger);
}
}
public KarmaTestContainerDiscoverer(
[Import(typeof(SVsServiceProvider))] IServiceProvider serviceProvider,
ILogger logger,
ISolutionListener solutionListener,
ITestFilesUpdateWatcher testFilesUpdateWatcher,
ITestFileAddRemoveListener testFilesAddRemoveListener)
{
Logger = KarmaLogger.Create(logger: logger);
_serviceProvider = serviceProvider;
_solutionListener = solutionListener;
_testFilesUpdateWatcher = testFilesUpdateWatcher;
_testFilesUpdateWatcher.Changed += OnProjectItemChanged;
_testFilesAddRemoveListener = testFilesAddRemoveListener;
_testFilesAddRemoveListener.Changed += OnProjectItemChanged;
_testFilesAddRemoveListener.StartListening();
_solutionListener.SolutionUnloaded += SolutionListenerOnSolutionUnloaded;
_solutionListener.ProjectChanged += OnSolutionProjectChanged;
_solutionListener.StartListening();
Logger.Info("KarmaTestContainerDiscoverer created");
}
public IEnumerable<ConsolidatedTestResult> ConsolidateResults(IKarmaLogger logger)
{
if (Files == null)
{
return Enumerable.Empty<ConsolidatedTestResult>();
}
var tests = Files.AllTests.Select(t => new ConsolidatedTestResult(t)).ToList();
if (Results != null)
{
foreach (var browser in Results.Browsers)
{
foreach (var result in browser.AllTestResults)
{
var test = tests.FirstOrDefault(t => t.Test.DisplayName == result.DisplayName);
if (test != null)
{
test.Results.Add(result);
}
}
}
}
return tests;
}
public KarmaCommand(string command, string source, IKarmaLogger logger)
{
Command = command;
Settings = KarmaSettings.Read(source, logger);
Directory = IO.Path.GetDirectoryName(IO.Path.GetFullPath(source));
Logger = logger;
if (Settings.LogToFile)
{
Logger.AddLogger(Settings.LogFilePath);
}
}
public IEnumerable <TestCase> GetTests(IEnumerable <string> sources, IKarmaLogger logger)
{
try
{
return(sources.SelectMany(s => GetTests(s, logger)).ToList());
}
catch (Exception ex)
{
logger.Error(ex.Message);
return(Enumerable.Empty <TestCase>());
}
}
public Karma Discover(string source, IKarmaLogger logger)
{
if (_karmaDiscoverCommand != null)
{
throw new Exception("Test discovery already running");
}
_karmaDiscoverCommand = new KarmaDiscoverCommand(source, logger);
try
{
return(_karmaDiscoverCommand.Run());
}
finally
{
_karmaDiscoverCommand = null;
}
}
private KarmaTestResults.Karma Run(string source, VsConfig.Config vsConfig, IKarmaLogger logger)
{
if (_karmaRunCommand != null)
{
throw new Exception("Karma is already running");
}
_karmaRunCommand = new KarmaRunCommand(source, vsConfig, logger);
try
{
return(_karmaRunCommand.Run());
}
finally
{
_karmaRunCommand = null;
}
}
public virtual void AddLogger(IKarmaLogger logger)
{
throw new NotImplementedException();
}
public KarmaDiscoverCommand(string source, IKarmaLogger logger)
: base("discover", source, logger)
{
}
public KarmaRunCommand(string source, VsConfig.Config vsConfig, IKarmaLogger logger)
: base("run", source, logger)
{
_vsConfig = vsConfig;
}
public IEnumerable <TestCase> GetTests(string source, IKarmaLogger logger)
{
var karma = Discover(source, logger);
return(karma == null?Enumerable.Empty <TestCase>() : karma.GetTestCases(source));
}
private void RunTests(string source, IEnumerable <TestCase> tests, KarmaTestResults.Karma karma, IFrameworkHandle frameworkHandle, IKarmaLogger logger)
{
var vsConfig = CreateVsConfig(tests, karma);
var runKarma = Run(source, vsConfig, logger);
if (runKarma == null)
{
logger.Error("No karma");
return;
}
var consolidatedResults = runKarma.ConsolidateResults(logger);
var testNames = tests.Select(t => t.DisplayName).Union(consolidatedResults.Select(r => r.Test.DisplayName));
var results = from displayName in testNames
join test in tests
on displayName equals test.DisplayName
into test_
from test in test_.DefaultIfEmpty()
join result in consolidatedResults
on displayName equals result.Test.DisplayName
into result_
from result in result_.DefaultIfEmpty()
select new TestCaseResult(test, result, source);
foreach (var result in results)
{
frameworkHandle.RecordStart(result.Test);
foreach (var res in result.Result.Results)
{
frameworkHandle.RecordResult(new TestResult(result.Test)
{
ComputerName = Environment.MachineName,
DisplayName = res.Browser.Name,
Outcome = res.Outcome,
Duration = res.Time,
ErrorMessage = res.Message
});
}
frameworkHandle.RecordEnd(result.Test, result.Result.Outcome);
}
}
static Item()
{
Logger = KarmaLogger.Create();
}
