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);