public TestFilter CheckVsTestFilter(TestFilter filter, IDiscoveryConverter discovery, IVsTestFilter vsTestFilter)
{
// If we have a VSTest TestFilter, convert it to an nunit filter
if (vsTestFilter == null || vsTestFilter.IsEmpty)
{
return(filter);
}
TestLog.Debug(
$"TfsFilter used, length: {vsTestFilter.TfsTestCaseFilterExpression?.TestCaseFilterValue.Length}");
// NOTE This overwrites filter used in call
var filterBuilder = CreateTestFilterBuilder();
if (Settings.DiscoveryMethod == DiscoveryMethod.Current)
{
filter = Settings.UseNUnitFilter
? filterBuilder.ConvertVsTestFilterToNUnitFilter(vsTestFilter)
: filterBuilder.ConvertTfsFilterToNUnitFilter(vsTestFilter, discovery);
}
else
{
filter = filterBuilder
.ConvertTfsFilterToNUnitFilter(vsTestFilter, discovery.LoadedTestCases);
}
Dump?.AddString($"\n\nTFSFilter: {vsTestFilter.TfsTestCaseFilterExpression.TestCaseFilterValue}\n");
Dump?.DumpVSInputFilter(filter, "(At Execution (TfsFilter)");
return(filter);
}
public override TestFilter CheckFilterInCurrentMode(TestFilter filter, IDiscoveryConverter discovery)
{
if (!discovery.IsDiscoveryMethodCurrent)
{
return(filter);
}
if ((VsTestFilter == null || VsTestFilter.IsEmpty) && filter != TestFilter.Empty)
{
if (discovery.NoOfLoadedTestCasesAboveLimit)
{
TestLog.Debug("Setting filter to empty due to number of testcases");
filter = TestFilter.Empty;
}
else
{
var filterBuilder = CreateTestFilterBuilder();
filter = filterBuilder.FilterByList(discovery.LoadedTestCases);
}
}
else if (VsTestFilter != null && !VsTestFilter.IsEmpty && !Settings.UseNUnitFilter)
{
var s = VsTestFilter.TfsTestCaseFilterExpression.TestCaseFilterValue;
var scount = s.Split('|', '&').Length;
if (scount > Settings.AssemblySelectLimit)
{
TestLog.Debug("Setting filter to empty due to TfsFilter size");
filter = TestFilter.Empty;
}
}
return(filter);
}
public TestFilter ConvertTfsFilterToNUnitFilter(IVsTestFilter vsFilter, IDiscoveryConverter discovery)
{
var filteredTestCases = vsFilter.CheckFilter(discovery.LoadedTestCases).ToList();
var explicitCases = discovery.CheckTestCasesExplicit(filteredTestCases).ToList();
bool isExplicit = filteredTestCases.Count == explicitCases.Count;
var tcs = isExplicit ? filteredTestCases : filteredTestCases.Except(explicitCases);
var testCases = tcs as TestCase[] ?? tcs.ToArray();
// TestLog.Info(string.Format("TFS Filter detected: LoadedTestCases {0}, Filtered Test Cases {1}", loadedTestCases.Count, testCases.Count()));
return(testCases.Any() ? FilterByList(testCases) : NoTestsFound);
}
public override TestFilter CheckFilterInCurrentMode(TestFilter filter, IDiscoveryConverter discovery)
{
if (!discovery.IsDiscoveryMethodCurrent)
{
return(filter);
}
if (filter != TestFilter.Empty)
{
filter = CheckFilter(filter, discovery);
}
else if (VsTestFilter is { IsEmpty : false } && !Settings.UseNUnitFilter)
public override TestFilter CheckFilterInCurrentMode(TestFilter filter, IDiscoveryConverter discovery)
{
if (!discovery.IsDiscoveryMethodCurrent)
{
return(filter);
}
if (filter.IsEmpty())
{
return(filter);
}
filter = CheckFilter(discovery);
return(filter);
}
public TestConverter(ITestLogger logger, string sourceAssembly, IAdapterSettings settings, IDiscoveryConverter discoveryConverter)
{
this.discoveryConverter = discoveryConverter;
adapterSettings = settings;
_logger = logger;
_sourceAssembly = sourceAssembly;
_vsTestCaseMap = new Dictionary <string, TestCase>();
TraitsCache = new Dictionary <string, TraitsFeature.CachedTestCaseInfo>();
if (CollectSourceInformation)
{
_navigationDataProvider = new NavigationDataProvider(sourceAssembly, logger);
}
}
protected TestFilter CheckFilter(IDiscoveryConverter discovery)
{
TestFilter filter;
if (discovery.NoOfLoadedTestCasesAboveLimit)
{
TestLog.Debug("Setting filter to empty due to number of testcases");
filter = TestFilter.Empty;
}
else
{
var filterBuilder = CreateTestFilterBuilder();
filter = filterBuilder.FilterByList(discovery.LoadedTestCases);
}
return(filter);
}
public TestFilter ConvertVsTestFilterToNUnitFilter(IVsTestFilter vsFilter, IDiscoveryConverter discovery)
{
if (settings.DiscoveryMethod == DiscoveryMethod.Legacy)
{
return(ConvertTfsFilterToNUnitFilter(vsFilter, discovery.LoadedTestCases));
}
if (!settings.UseNUnitFilter)
{
return(ConvertTfsFilterToNUnitFilter(vsFilter, discovery));
}
var result = ConvertVsTestFilterToNUnitFilter(vsFilter);
if (result == null)
{
return(ConvertTfsFilterToNUnitFilter(vsFilter, discovery));
}
return(result);
}
public void Setup()
{
ctx = Substitute.For <IExecutionContext>();
var settings = Substitute.For <IAdapterSettings>();
settings.AssemblySelectLimit.Returns(10);
ctx.Settings.Returns(settings);
var engineAdapter = new NUnitEngineAdapter();
engineAdapter.Initialize();
ctx.EngineAdapter.Returns(engineAdapter);
settings.DiscoveryMethod.Returns(DiscoveryMethod.Current);
discovery = Substitute.For <IDiscoveryConverter>();
discovery.NoOfLoadedTestCases.Returns(1);
discovery.IsDiscoveryMethodCurrent.Returns(true);
discovery.LoadedTestCases.Returns(new List <TestCase>
{
new ("A", new Uri(NUnitTestAdapter.ExecutorUri), "line 23")
});
public override TestFilter CheckFilterInCurrentMode(TestFilter filter, IDiscoveryConverter discovery)
{
if (!discovery.IsDiscoveryMethodCurrent)
{
return(filter);
}
if (filter.IsEmpty())
{
return(filter);
}
if (discovery.NoOfLoadedTestCasesAboveLimit)
{
TestLog.Debug("Setting filter to empty due to number of testcases");
filter = TestFilter.Empty;
}
else
{
var filterBuilder = CreateTestFilterBuilder();
filter = filterBuilder.FilterByList(discovery.LoadedTestCases);
}
return(filter);
}
public abstract TestFilter CheckFilterInCurrentMode(TestFilter filter, IDiscoveryConverter discovery);
