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