public ScenarioSession ResumeScenario(string userSubject, int id) { _logger.Info($"{nameof(ResumeScenario)}({userSubject}, {id})"); try { ScenarioSession scenarioSession = _dataAccessService.GetScenarioSessions(userSubject).FirstOrDefault(s => s.ScenarioId == id); if (scenarioSession == null) { throw new ScenarioSessionNotFoundException(userSubject, id); } bool needInitialize = false; if (!_activeScenarios.TryGetValue(userSubject, out ScenarioMonitoringData scenarioMonitoringData)) { needInitialize = true; } else if (scenarioMonitoringData.ScenarioId != id) { needInitialize = true; } if (needInitialize) { scenarioMonitoringData = new ScenarioMonitoringData { ScenarioId = id, ScenarioSessionId = scenarioSession.ScenarioSessionId, ActivationTime = scenarioSession.StartTime, LastUseTime = DateTime.UtcNow }; _activeScenarios.AddOrUpdate(userSubject, scenarioMonitoringData, (k, v) => v); ScenarioDefinition scenarioDefinition = _scenarios[id]; IEnumerable <Client.DataLayer.Model.Scenarios.ScenarioAccount> scenarioAccounts = _dataAccessService.GetScenarioAccounts(scenarioSession.ScenarioSessionId); foreach (var scenarioAccount in scenarioAccounts) { AccountDescriptor account = _accountsService.GetById(scenarioAccount.AccountId); if (account.AccountType == AccountType.IdentityProvider || account.AccountType == AccountType.ServiceProvider) { AccountDescriptor accountDescriptor = _accountsService.Authenticate(scenarioAccount.AccountId, "qqq"); _executionContextManager.InitializeStateExecutionServices(accountDescriptor.AccountId, accountDescriptor.SecretSpendKey); } } } else { scenarioMonitoringData.LastUseTime = DateTime.UtcNow; } return(scenarioSession); } catch (Exception ex) { _logger.Error($"Failed {nameof(ResumeScenario)}({userSubject}, {id})", ex); throw; } }
public static ElementGenerator <T> For(Action <ScenarioDefinition> configure) { var definition = new ScenarioDefinition(); configure(definition); var activators = definition.Activators().ToList(); activators.Add(new ElementRequestActivator(new InMemoryFubuRequest(), definition.Naming)); var stringifier = definition.Display.BuildStringifier(); var formatter = new DisplayFormatter(definition.Services, stringifier); definition.Services.Add <IDisplayFormatter>(formatter); definition.Library.Import(new DefaultHtmlConventions().Library); var generator = ElementGenerator <T> .For(definition.Library, activators); generator.Model = definition.Model; return(generator); }
private void SetupTestMethod(TestClassGenerationContext generationContext, CodeMemberMethod testMethod, ScenarioDefinition scenarioDefinition, IEnumerable <Tag> additionalTags, string variantName, string exampleSetIdentifier, bool rowTest = false) { testMethod.Attributes = MemberAttributes.Public; testMethod.Name = GetTestMethodName(scenarioDefinition, variantName, exampleSetIdentifier); var friendlyTestName = scenarioDefinition.Name; if (variantName != null) { friendlyTestName = string.Format("{0}: {1}", scenarioDefinition.Name, variantName); } if (rowTest) { _testGeneratorProvider.SetRowTest(generationContext, testMethod, friendlyTestName); } else { _testGeneratorProvider.SetTestMethod(generationContext, testMethod, friendlyTestName); } List <string> scenarioCategories; _decoratorRegistry.DecorateTestMethod(generationContext, testMethod, ConcatTags(scenarioDefinition.GetTags(), additionalTags), out scenarioCategories); if (scenarioCategories.Any()) { _testGeneratorProvider.SetTestMethodCategories(generationContext, testMethod, scenarioCategories); } }
public static Solution Create(Action<ScenarioDefinition> configure) { var def = new ScenarioDefinition(); configure(def); return def.Solution; }
private ValidationScenario(ScenarioDefinition definition) { var validator = new Validator(new TypeResolver(), definition.Graph(), definition.Services); Model = definition.Model; Notification = validator.Validate(Model); }
public virtual void test_quote_secenarioDefinition() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.calc.marketdata.PerturbationMapping<?>> perturbationMapping = new java.util.ArrayList<>(); IList <PerturbationMapping <object> > perturbationMapping = new List <PerturbationMapping <object> >(); int nScenarios = 3; foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet()) { DoubleArray shifts = DoubleArray.of(nScenarios, n => Math.Pow(0.9, n)); ScenarioPerturbation <double> perturb = GenericDoubleShifts.of(ShiftType.SCALED, shifts); perturbationMapping.Add(PerturbationMapping.of(MarketDataFilter.ofId(entry.Key), perturb)); } ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(perturbationMapping); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, MARKET_DATA, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; for (int i = 0; i < nScenarios; ++i) { ImmutableMap.Builder <QuoteId, double> builder = ImmutableMap.builder(); foreach (KeyValuePair <QuoteId, double> entry in MARKET_QUOTES.entrySet()) { builder.put(entry.Key, entry.Value * Math.Pow(0.9, i)); } ImmutableMarketData shiftedMarketData = ImmutableMarketData.builder(VALUATION_DATE).addValueMap(builder.build()).addValueMap(MARKET_FX_QUOTES).build(); MarketData shiftedMarketDataCalibrated = StandardComponents.marketDataFactory().create(REQUIREMENTS, CONFIG, shiftedMarketData, REF_DATA); Results shiftedResults = CALC_RUNNER.calculate(RULES, TARGETS, COLUMN, shiftedMarketDataCalibrated, REF_DATA); CurrencyAmount pv = shiftedResults.get(0, 0, typeof(CurrencyAmount)).Value; assertEquals(pvs.get(i), pv); } }
public static List <GherkinStep> GetSteps(Step step, ScenarioDefinition scenario) { var res = new List <GherkinStep>(); var outline = scenario as ScenarioOutline; var stepText = step.Text; if (outline != null && stepText.Contains("<") && stepText.Contains(">")) { var m = _exampleRegex.Match(stepText); if (m.Success) { for (int i = 0; i < m.Groups.Count; i++) { var exampleValue = m.Groups[i].Value.Replace("<", string.Empty).Replace(">", string.Empty); var resStep = GetGherkinStep(step, exampleValue); res.Add(resStep); } } } else { var resStep = GetGherkinStep(step, stepText); res.Add(resStep); } return(res); }
public ActionResult <ScenarioDto> GetScenario(int scenarioId) { IEnumerable <ScenarioDefinition> scenarioDefinitions = _scenarioRunner.GetScenarioDefinitions(); IEnumerable <ScenarioSession> scenarioSessions = _dataAccessService.GetScenarioSessions(User.Identity.Name); ScenarioDefinition scenarioDefinition = scenarioDefinitions.FirstOrDefault(s => s.Id == scenarioId); if (scenarioDefinition != null) { var scenarioSession = scenarioSessions.FirstOrDefault(ss => ss.ScenarioId == scenarioDefinition.Id); var scenario = new ScenarioDto { Name = scenarioDefinition.Name, Id = scenarioId.ToString(), IsActive = scenarioSession != null, CurrentStep = scenarioSession?.CurrentStep ?? 0, SessionId = scenarioSession?.ScenarioSessionId ?? 0, StartTime = scenarioSession?.StartTime ?? DateTime.MinValue, Steps = scenarioDefinition.Steps.Select(s => new ScenarioStepDto { Id = s.Id, Caption = s.Caption }).ToArray() }; return(Ok(scenario)); } return(BadRequest()); }
private void SetupIdentityProviders(ScenarioDefinition scenarioDefinition, long scenarioSessionId) { foreach (var scenarioAccount in scenarioDefinition.Setup.Accounts.Where(a => a.AccountType == AccountType.IdentityProvider)) { long accountId = _accountsService.Create(AccountType.IdentityProvider, scenarioAccount.AccountInfo, "qqq", true); _dataAccessService.AddScenarionSessionAccount(scenarioSessionId, accountId); AccountDescriptor accountDescriptor = _accountsService.Authenticate(accountId, "qqq"); _executionContextManager.InitializeStateExecutionServices(accountId, accountDescriptor.SecretSpendKey); foreach (var attributeScheme in scenarioAccount.IdentityScheme) { long schemeId = _dataAccessService.AddAttributeToScheme(accountDescriptor.PublicSpendKey.ToHexString(), attributeScheme.AttributeName, attributeScheme.AttributeSchemeName, attributeScheme.Alias, null); if (attributeScheme.CanBeRoot) { _dataAccessService.ToggleOnRootAttributeScheme(schemeId); } } IdentitiesScheme rootScheme = _dataAccessService.GetRootIdentityScheme(accountDescriptor.PublicSpendKey.ToHexString()); foreach (var identity in scenarioAccount.Identities) { IEnumerable <(string attributeName, string content)> attrs = GetAttribitesAndContent(identity, accountDescriptor); Identity identityDb = _dataAccessService.CreateIdentity(accountDescriptor.AccountId, identity.Alias, attrs.ToArray()); } } }
public ActionResult <ScenarioDto> GetActiveScenario() { try { _logger.Info($"{nameof(GetActiveScenario)}()"); IEnumerable <ScenarioDefinition> scenarioDefinitions = _scenarioRunner.GetScenarioDefinitions(); ScenarioSession scenarioSession = _scenarioRunner.GetActiveScenarioSession(User.Identity.Name); if (scenarioSession != null) { ScenarioDefinition scenarioDefinition = scenarioDefinitions.FirstOrDefault(s => s.Id == scenarioSession.ScenarioId); return(new ScenarioDto { Name = scenarioDefinition.Name, Id = scenarioDefinition.Id.ToString(), IsActive = scenarioSession != null, CurrentStep = scenarioSession?.CurrentStep ?? 0, SessionId = scenarioSession?.ScenarioSessionId ?? 0, StartTime = scenarioSession?.StartTime ?? DateTime.MinValue, Steps = scenarioDefinition.Steps.Select(s => new ScenarioStepDto { Id = s.Id, Caption = s.Caption }).ToArray() }); } return(null); } catch (Exception ex) { _logger.Error($"Failed {nameof(GetActiveScenario)}()", ex); throw; } }
private static ContainerOrTerminalNode ParseScenarioDefinition(ScenarioDefinition definition, CharacterPositionFinder finder, LineInfo locationAfterDefinition) { var start = GetLineInfo(definition.Location); var end = locationAfterDefinition; var spanStart = finder.GetCharacterPosition(start); var spanEnd = spanStart + finder.GetLineLength(start); var locationInside = definition.Steps.Select(_ => _.Location).OrderBy(_ => _.Line).ThenBy(_ => _.Column).FirstOrDefault(); if (locationInside != null) { var lineInfo = GetLineInfo(locationInside); var position = finder.GetCharacterPosition(lineInfo) - 1; spanEnd = position; } var container = new Container { Type = nameof(ScenarioDefinition), Name = definition.Name, LocationSpan = new LocationSpan(start, end), HeaderSpan = new CharacterSpan(spanStart, spanEnd), FooterSpan = CharacterSpan.None, // TODO: FIX }; container.Children.AddRange(ParseSteps(definition, finder, locationAfterDefinition)); return(container); }
public virtual void test_parameter_secenarioDefinition() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.List<com.opengamma.strata.calc.marketdata.PerturbationMapping<?>> perturbationMapping = new java.util.ArrayList<>(); IList <PerturbationMapping <object> > perturbationMapping = new List <PerturbationMapping <object> >(); int nVolParams = EXP_VOLS.ParameterCount; int nScenarios = 3; PointShiftsBuilder builder = PointShifts.builder(ShiftType.SCALED); for (int i = 0; i < nVolParams; ++i) { object id = EXP_VOLS.getParameterMetadata(i).Identifier; for (int j = 0; j < nScenarios; ++j) { builder.addShift(j, id, Math.Pow(0.9, j)); } } ScenarioPerturbation <ParameterizedData> perturb = builder.build(); perturbationMapping.Add(PerturbationMapping.of(MarketDataFilter.ofId(VOL_ID), perturb)); ScenarioDefinition scenarioDefinition = ScenarioDefinition.ofMappings(perturbationMapping); ScenarioMarketData marketDataCalibrated = StandardComponents.marketDataFactory().createMultiScenario(REQUIREMENTS, SCENARIO_CONFIG, MARKET_DATA, REF_DATA, scenarioDefinition); Results results = CALC_RUNNER.calculateMultiScenario(RULES, TARGETS, COLUMN, marketDataCalibrated, REF_DATA); CurrencyScenarioArray pvs = results.get(0, 0, typeof(CurrencyScenarioArray)).Value; for (int i = 0; i < nScenarios; ++i) { int index = i; BlackFxOptionSmileVolatilities shiftedSmile = EXP_VOLS.withPerturbation((j, v, m) => Math.Pow(0.9, index) * v); CurrencyAmount pv = PRICER.presentValue(OPTION_TRADE.resolve(REF_DATA), EXP_RATES, shiftedSmile).convertedTo(USD, EXP_RATES); assertEquals(pvs.get(i), pv); } }
public static bool UpdateTestCaseDetails(ScenarioDefinition scenarioDefinition, ITestBase testCase) { if (testCase == null) { return(false); } var scenarioDescription = scenarioDefinition?.Description?.Trim() ?? string.Empty; scenarioDescription = scenarioDescription .Replace("\n", "<br>") .Replace("\r", ""); var title = scenarioDefinition?.Name?.Trim() ?? string.Empty; var updated = false; if (testCase.WorkItem.Description.Trim() != scenarioDescription) { testCase.WorkItem.Description = scenarioDescription; updated = true; } if (testCase.Title == title) { return(updated); } testCase.Title = title; return(true); }
public ScenarioSession AbandonScenario(string userSubject, int id) { _logger.Info($"{nameof(AbandonScenario)}({userSubject}, {id})"); try { ScenarioDefinition scenarioDefinition = _scenarios[id]; ScenarioSession scenarioSession = _dataAccessService.GetScenarioSessions(userSubject).FirstOrDefault(s => s.ScenarioId == id); if (scenarioSession == null) { return(null); } IEnumerable <Client.DataLayer.Model.Scenarios.ScenarioAccount> scenarioAccounts = _dataAccessService.GetScenarioAccounts(scenarioSession.ScenarioSessionId); foreach (var scenarioAccount in scenarioAccounts) { _executionContextManager.UnregisterExecutionServices(scenarioAccount.AccountId); } _activeScenarios.TryRemove(userSubject, out ScenarioMonitoringData scenarioMonitoringData); return(scenarioSession); } catch (Exception ex) { _logger.Error($"Failed {nameof(AbandonScenario)}({userSubject}, {id})", ex); throw; } }
private static void ChurnScenarios(string[] arrLine, Feature feature, ITestManagementTeamProject teamProject, ICollection <Tag> tags, string area, IList <TestCaseField> fieldsCollection) { var backgroundSteps = GetBackgroundSteps(arrLine, feature); var iterationStart = backgroundSteps.Any() ? 1 : 0; ScenarioDefinition background = null; if (backgroundSteps.Any()) { background = GetBackground(feature); } var scenarioDefinitions = feature.Children.ToArray(); for (; iterationStart < scenarioDefinitions.Length; iterationStart++) { var scenarioDefinition = scenarioDefinitions[iterationStart]; var scenarioTags = GherkinUtils.GetTags(scenarioDefinition); if (!CanChurnScenario(scenarioDefinition, fieldsCollection)) { continue; } var hash = GetHash(arrLine, scenarioDefinitions, iterationStart, scenarioDefinition, backgroundSteps); var mtmIdTag = scenarioTags.FirstOrDefault( scenarioTag => scenarioTag.Name.Trim().ToUpperInvariant().StartsWith( SyncUtil.MtmTcLink, StringComparison.InvariantCulture)); Logger.Info(ResourceStrings.DECORATION, $"Syncing scenario, {scenarioDefinition.Name}"); if (mtmIdTag == null) { SaveChanges(teamProject, background, null, scenarioDefinition, hash, area, tags, fieldsCollection); continue; } var testCaseId = Regex.Match(mtmIdTag.Name, SyncUtil.MtmTcIdPattern).Groups[1].Value; try { var testCase = teamProject.TestCases.Find(Int32.Parse(testCaseId, CultureInfo.InvariantCulture)); if (testCase != null) { if (UpdateTestCase(testCase, scenarioDefinition, hash, fieldsCollection)) { testCase.Actions.Clear(); SaveChanges(teamProject, background, testCase, scenarioDefinition, hash, area, tags, fieldsCollection); } continue; } } catch (DeniedOrNotExistException) { // This could happen when a test case is deleted from the MTM but exists in the corresponding feature file Logger.Info(ResourceStrings.DECORATION, $"Linked test case, {mtmIdTag.Name}, is not found"); } // Need to create a test case when the link is failed SaveChanges(teamProject, background, null, scenarioDefinition, hash, area, tags, fieldsCollection); } }
/// <summary> /// Performs validation of a method (request/response) with a given service /// target and zero or more test scenarios /// </summary> /// <param name="method"></param> /// <param name="account"></param> /// <param name="credentials"></param> /// <returns></returns> public static async Task <ValidationResults> ValidateServiceResponseAsync( this MethodDefinition method, ScenarioDefinition[] scenarios, IServiceAccount account, ValidationOptions options = null) { if (null == method) { throw new ArgumentNullException("method"); } if (null == account) { throw new ArgumentNullException("account"); } ValidationResults results = new ValidationResults(); if (scenarios.Length == 0) { // If no descenarios are defined for this method, add a new default scenario scenarios = new ScenarioDefinition[] { new ScenarioDefinition { Description = "verbatim", Enabled = true, MethodName = method.Identifier, RequiredScopes = method.RequiredScopes } }; // results.AddResult("init", new ValidationMessage(null, "No scenarios were defined for method {0}. Will request verbatim from docs.", method.Identifier), ValidationOutcome.None); } if (scenarios.Any() && !scenarios.Any(x => x.Enabled)) { results.AddResult("init", new ValidationWarning(ValidationErrorCode.AllScenariosDisabled, null, "All scenarios for method {0} were disabled.", method.Identifier), ValidationOutcome.Skipped); return(results); } foreach (var scenario in scenarios.Where(x => x.Enabled)) { try { await ValidateMethodWithScenarioAsync(method, scenario, account, results, options); } catch (Exception ex) { results.AddResult( "validation", new ValidationError( ValidationErrorCode.ExceptionWhileValidatingMethod, method.SourceFile.DisplayName, ex.Message)); } } return(results); }
public static BindingScenario <T> For(Action <ScenarioDefinition> configuration) { var definition = new ScenarioDefinition(); configuration(definition); return(new BindingScenario <T>(definition)); }
private void SetupUsers(ScenarioDefinition scenarioDefinition, long scenarioSessionId) { foreach (var scenarioAccount in scenarioDefinition.Setup.Accounts.Where(a => a.AccountType == AccountType.User)) { long accountId = _accountsService.Create(AccountType.User, scenarioAccount.AccountInfo, "qqq", true); _dataAccessService.AddScenarionSessionAccount(scenarioSessionId, accountId); } }
public static Solution Create(Action <ScenarioDefinition> configure) { var def = new ScenarioDefinition(); configure(def); return(def.Solution); }
public static ParsingScenario Create(Action <ScenarioDefinition> configure) { var definition = new ScenarioDefinition(); configure(definition); return(definition.As <IScenarioBuilder>().Build()); }
public static ValidationScenario <T> For(Action <ScenarioDefinition> configuration) { var scenario = new ScenarioDefinition(); configuration(scenario); return(new ValidationScenario <T>(scenario)); }
private BindingScenario(ScenarioDefinition definition) { var context = new BindingContext(definition.RequestData, definition.Services, this); context.ForObject(definition.Model, () => definition.Actions.Each(x => x(context))); Model = definition.Model; Problems = context.Problems; }
/// <summary> /// Verify that the expectations in the scenario are met by the response /// </summary> /// <param name="scenario"></param> /// <param name="actualResponse"></param> /// <param name="detectedErrors"></param> public static void ValidateExpectations(this ScenarioDefinition scenario, HttpResponse actualResponse, List <ValidationError> detectedErrors) { if (scenario == null) { throw new ArgumentNullException("scenario"); } if (actualResponse == null) { throw new ArgumentNullException("actualResponse"); } if (detectedErrors == null) { throw new ArgumentNullException("detectedErrors"); } var expectations = scenario.Expectations; if (null == expectations || expectations.Count == 0) { return; } foreach (string key in expectations.Keys) { string keyIndex; var type = BasicRequestDefinition.LocationForKey(key, out keyIndex); object expectedValues = expectations[key]; switch (type) { case PlaceholderLocation.Body: ExpectationSatisfied(key, actualResponse.Body, expectedValues, detectedErrors); break; case PlaceholderLocation.HttpHeader: ExpectationSatisfied(key, actualResponse.Headers[keyIndex].FirstOrDefault(), expectedValues, detectedErrors); break; case PlaceholderLocation.Json: try { object value = JsonPath.ValueFromJsonPath(actualResponse.Body, keyIndex); ExpectationSatisfied(key, value, expectedValues, detectedErrors); } catch (Exception ex) { detectedErrors.Add(new ValidationError(ValidationErrorCode.JsonParserException, null, ex.Message)); } break; case PlaceholderLocation.Invalid: case PlaceholderLocation.StoredValue: case PlaceholderLocation.Url: detectedErrors.Add(new ValidationWarning(ValidationErrorCode.InvalidExpectationKey, null, "The expectation key {0} is invalid. Supported types are Body, HttpHeader, and JsonPath.", key)); break; } } }
/// <summary> /// Verify that the expectations in the scenario are met by the response /// </summary> /// <param name="scenario"></param> /// <param name="actualResponse"></param> /// <param name="detectedErrors"></param> public static void ValidateExpectations(this ScenarioDefinition scenario, HttpResponse actualResponse, IssueLogger issues) { if (scenario == null) { throw new ArgumentNullException("scenario"); } if (actualResponse == null) { throw new ArgumentNullException("actualResponse"); } if (issues == null) { throw new ArgumentNullException("issues"); } var expectations = scenario.Expectations; if (null == expectations || expectations.Count == 0) { return; } foreach (string key in expectations.Keys) { string keyIndex; var type = BasicRequestDefinition.LocationForKey(key, out keyIndex); object expectedValues = expectations[key]; switch (type) { case PlaceholderLocation.Body: ExpectationSatisfied(key, actualResponse.Body, expectedValues, issues); break; case PlaceholderLocation.HttpHeader: ExpectationSatisfied(key, actualResponse.Headers[keyIndex], expectedValues, issues); break; case PlaceholderLocation.Json: try { object value = JsonPath.ValueFromJsonPath(actualResponse.Body, keyIndex); ExpectationSatisfied(key, value, expectedValues, issues); } catch (Exception ex) { issues.Error(ValidationErrorCode.JsonParserException, string.Empty, ex); } break; case PlaceholderLocation.Invalid: case PlaceholderLocation.StoredValue: case PlaceholderLocation.Url: issues.Warning(ValidationErrorCode.InvalidExpectationKey, $"The expectation key {key} is invalid. Supported types are Body, HttpHeader, and JsonPath."); break; } } }
internal static void MatchResult(ExtendedExamples examples, ScenarioDefinition scenario, ICollection <SbeScenario> results) { foreach (var row in examples.Rows) { var rowTitle = row.GetTitle(scenario.Name); var result = results.FirstOrDefault(x => x.Title.Equals(rowTitle, StringComparison.OrdinalIgnoreCase)); row.Result = result.Outcome; } }
public static IList <Tag> GetTags(ScenarioDefinition scenarioDefinition) { if (scenarioDefinition is ScenarioOutline outline) { return(outline.Tags.ToArray()); } return(new List <Tag>(((Scenario)scenarioDefinition).Tags)); }
/// <summary> /// Add information about the test that generated this call to the request headers. /// </summary> /// <param name="scenario"></param> /// <param name="request"></param> internal static void AddTestHeaderToRequest(ScenarioDefinition scenario, HttpRequest request) { var headerValue = string.Format( "method-name: {0}; scenario-name: {1}", scenario.MethodName, scenario.Description); request.Headers.Add("ApiDocsTestInfo", headerValue); }
public static IEnumerable <Tag> GetTags(this ScenarioDefinition scenarioDefinition) { if (!scenarioDefinition.HasTags()) { return(new List <Tag>()); } return(((IHasTags)scenarioDefinition).Tags); }
private ScenarioTestCase(SpecFlowFeatureTestClass featureTestClass, ScenarioDefinition scenario, string[] featureTags, Location location) { FeatureFile = featureTestClass; Name = scenario.Name; SourceInformation = new SourceInformation { FileName = featureTestClass.FeatureFilePath, LineNumber = location?.Line }; Traits = new Dictionary <string, List <string> >(); Traits.Add("Category", featureTags.Concat(((IHasTags)scenario).Tags.GetTags()).ToList()); }
private CodeMemberMethod CreateTestMethod(TestClassGenerationContext generationContext, ScenarioDefinition scenario, IEnumerable <Tag> additionalTags, string variantName = null, string exampleSetIdentifier = null) { CodeMemberMethod testMethod = CreateMethod(generationContext.TestClass); SetupTestMethod(generationContext, testMethod, scenario, additionalTags, variantName, exampleSetIdentifier); return(testMethod); }
protected virtual PickleStep[] PickleSteps(ScenarioDefinition scenarioDefinition) { var result = new List <PickleStep>(); foreach (var step in scenarioDefinition.Steps) { result.Add(PickleStep(step)); } return(result.ToArray()); }