public ConditionCheckResultModel Check()
{
var result = new ConditionCheckResultModel();
result.IsValid = Directory.Exists(WatchPath);
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var maxHits = stub.Conditions?.Scenario?.MaxHits;
if (maxHits == null)
{
return(result);
}
var scenario = stub.Scenario;
var rawHitCount = _scenarioService.GetHitCount(scenario);
var actualHitCount = rawHitCount + 1; // Add +1 because the scenario is being hit right now but hit count has not been increased yet.
if (actualHitCount == null)
{
result.Log = "No hit count could be found.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
else if (actualHitCount >= maxHits)
{
result.Log =
$"Scenario '{scenario}' should have less than '{maxHits}' hits, but '{actualHitCount}' hits were counted.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
else if (actualHitCount < maxHits)
{
result.ConditionValidation = ConditionValidationType.Valid;
}
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
if (stub.Conditions?.Json == null)
{
return(result);
}
var convertedJsonConditions = ConvertJsonConditions(stub.Conditions.Json);
var body = _httpContextService.GetBody();
try
{
var jToken = JToken.Parse(body);
var logResults = new List <string>();
result.ConditionValidation = CheckSubmittedJson(convertedJsonConditions, jToken, logResults)
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
result.Log = string.Join(Environment.NewLine, logResults);
}
catch (JsonReaderException ex)
{
result.ConditionValidation = ConditionValidationType.Invalid;
result.Log = ex.Message;
}
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var bodyConditions = stub.Conditions?.Body?.ToArray();
if (bodyConditions == null || bodyConditions?.Any() != true)
{
return result;
}
var body = _httpContextService.GetBody();
var validBodyConditions = 0;
foreach (var condition in bodyConditions)
{
if (!StringHelper.IsRegexMatchOrSubstring(body, condition))
{
// If the check failed, it means the query string is incorrect and the condition should fail.
result.Log = $"Body condition '{condition}' failed.";
break;
}
validBodyConditions++;
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the body condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validBodyConditions == bodyConditions.Length
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return result;
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var pathCondition = conditions?.Url?.Path;
if (string.IsNullOrEmpty(pathCondition))
{
return(result);
}
var path = _httpContextService.Path;
if (StringHelper.IsRegexMatchOrSubstring(path, pathCondition))
{
// The path matches the provided regex. Add the stub ID to the resulting list.
result.ConditionValidation = ConditionValidationType.Valid;
}
else
{
result.Log = $"Condition '{pathCondition}' did not pass for request.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var methodCondition = conditions?.Method;
if (string.IsNullOrEmpty(methodCondition))
{
return(result);
}
var method = _httpContextService.Method;
if (string.Equals(methodCondition, method, StringComparison.OrdinalIgnoreCase))
{
// The path matches the provided regex. Add the stub ID to the resulting list.
result.ConditionValidation = ConditionValidationType.Valid;
}
else
{
result.Log = $"Condition '{methodCondition}' did not pass for request.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var state = stub.Conditions?.Scenario?.ScenarioState;
var scenario = stub.Scenario;
if (string.IsNullOrWhiteSpace(state) || string.IsNullOrWhiteSpace(scenario))
{
return(result);
}
var scenarioState = _scenarioService.GetScenario(scenario);
if (scenarioState == null)
{
scenarioState = new ScenarioStateModel(scenario);
_scenarioService.SetScenario(scenario, scenarioState);
}
if (!string.Equals(scenarioState.State.Trim(), state.Trim(), StringComparison.OrdinalIgnoreCase))
{
result.Log =
$"Scenario '{stub.Scenario}' is in state '{scenarioState.State}', but '{state}' was expected.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
else
{
result.ConditionValidation = ConditionValidationType.Valid;
}
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var jsonPathConditions = conditions?.JsonPath?.ToArray();
if (jsonPathConditions == null || jsonPathConditions?.Any() != true)
{
return(result);
}
var validJsonPaths = 0;
var body = _httpContextService.GetBody();
var jsonObject = JObject.Parse(body);
foreach (var condition in jsonPathConditions)
{
var elements = jsonObject.SelectToken(condition);
if (elements == null)
{
// No suitable JSON results found.
result.Log = $"No suitable JSON results found with JSONPath query '{condition}'.";
break;
}
validJsonPaths++;
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the header condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validJsonPaths == jsonPathConditions.Length
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
public ConditionCheckResultModel Check()
{
//开机启动不需要输入条件，直接通过
var result = new ConditionCheckResultModel();
result.IsValid = true;
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var formConditions = stub.Conditions?.Form?.ToArray() ?? Array.Empty <StubFormModel>();
if (!formConditions.Any())
{
return(result);
}
try
{
var form = _httpContextService.GetFormValues();
var validConditions = 0;
foreach (var condition in formConditions)
{
var(formKey, formValues) = form.FirstOrDefault(f => f.Item1 == condition.Key);
if (formKey == null)
{
result.ConditionValidation = ConditionValidationType.Invalid;
result.Log = $"No form value with key '{condition.Key}' found.";
break;
}
validConditions += formValues
.Count(value =>
StringHelper.IsRegexMatchOrSubstring(HttpUtility.UrlDecode(value), condition.Value));
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the form condition is passed and the stub ID is passed to the result.
if (validConditions == formConditions.Length)
{
result.ConditionValidation = ConditionValidationType.Valid;
}
else
{
result.Log =
$"Number of configured form conditions: '{formConditions.Length}'; number of passed form conditions: '{validConditions}'";
result.ConditionValidation = ConditionValidationType.Invalid;
}
}
catch (InvalidOperationException ex)
{
result.Log = ex.Message;
result.ConditionValidation = ConditionValidationType.Invalid;
}
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var xpathConditions = conditions?.Xpath?.ToArray() ?? new StubXpathModel[0];
if (!xpathConditions.Any())
{
return(result);
}
var validXpaths = 0;
var body = _httpContextService.GetBody();
var doc = new XmlDocument();
doc.LoadXml(body);
foreach (var condition in xpathConditions)
{
var nsManager = new XmlNamespaceManager(doc.NameTable);
var namespaces = condition.Namespaces;
if (namespaces != null)
{
foreach (var ns in namespaces)
{
nsManager.AddNamespace(ns.Key, ns.Value);
}
}
else
{
// If no namespaces are defined, check the XML namespaces with a regex.
nsManager.ParseBodyAndAssignNamespaces(body);
}
var elements = doc.SelectNodes(condition.QueryString, nsManager);
if (elements != null && elements.Count == 0)
{
// No suitable XML results found.
result.Log = $"No suitable XML results found with XPath query {condition}.";
break;
}
validXpaths++;
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the header condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validXpaths == xpathConditions.Length ? ConditionValidationType.Valid : ConditionValidationType.Invalid;
return(result);
}
public ConditionCheckResultModel Check()
{
var result = new ConditionCheckResultModel();
result.IsValid = true;
//var nowTime = new DateTime(DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, 0);
if (RepetitionType == TimeChangedRepetitionType.None && Time <= DateTime.Now)
{
result.IsValid = false;
result.Msg = "在不选择重复时指定的时间应该大于当前时间";
}
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var hostCondition = stub.Conditions?.Host;
if (hostCondition == null)
{
return(result);
}
var host = _clientDataResolver.GetHost();
result.ConditionValidation = !StringHelper.IsRegexMatchOrSubstring(host, hostCondition)
? ConditionValidationType.Invalid
: ConditionValidationType.Valid;
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var xpathConditions = stub.Conditions?.Xpath?.ToArray() ?? Array.Empty <StubXpathModel>();
if (!xpathConditions.Any())
{
return(result);
}
var validXpaths = 0;
var body = _httpContextService.GetBody();
try
{
var doc = new XmlDocument();
doc.LoadXml(body);
foreach (var condition in xpathConditions)
{
var nsManager = new XmlNamespaceManager(doc.NameTable);
var namespaces = condition.Namespaces;
if (namespaces != null)
{
foreach (var ns in namespaces)
{
nsManager.AddNamespace(ns.Key, ns.Value);
}
}
else
{
// If no namespaces are defined, check the XML namespaces with a regex.
nsManager.ParseBodyAndAssignNamespaces(body);
}
var elements = doc.SelectNodes(condition.QueryString, nsManager);
if (elements is { Count: 0 })
{
// No suitable XML results found.
result.Log = $"No suitable XML results found with XPath query {condition.QueryString}.";
break;
}
validXpaths++;
}
public ConditionCheckResultModel Check()
{
var result = new ConditionCheckResultModel();
result.IsValid = true;
if (Seconds <= 0)
{
result.IsValid = false;
result.Msg = "间隔秒数不能小于等于0";
}
if (Num < 0)
{
result.IsValid = false;
result.Msg = "循环次数不能小于0";
}
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var condition = conditions?.Url?.IsHttps;
if (condition == null)
{
return(result);
}
var shouldBeHttps = condition.Value;
var isHttps = _clientDataResolver.IsHttps();
result.ConditionValidation = isHttps == shouldBeHttps
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var clientIpCondition = stub.Conditions?.ClientIp;
if (clientIpCondition == null)
{
return(result);
}
var clientIp = IPAddress.Parse(_clientDataResolver.GetClientIp());
var ranges = IPAddressRange.Parse(clientIpCondition).AsEnumerable();
result.ConditionValidation = ranges
.Any(i => i.Equals(clientIp))
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var queryStringConditions = conditions?.Url?.Query;
if (queryStringConditions == null || queryStringConditions?.Any() != true)
{
return(result);
}
var validQueryStrings = 0;
var queryString = _httpContextService.GetQueryStringDictionary();
foreach (var condition in queryStringConditions)
{
// Check whether the condition query is available in the actual query string.
if (!queryString.TryGetValue(condition.Key, out var queryValue))
{
continue;
}
// Check whether the condition query value is available in the actual query string.
var value = condition.Value ?? string.Empty;
if (!StringHelper.IsRegexMatchOrSubstring(queryValue, value))
{
// If the check failed, it means the query string is incorrect and the condition should fail.
result.Log = $"Query string condition '{condition.Key}: {condition.Value}' failed.";
break;
}
validQueryStrings++;
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the query string condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validQueryStrings == queryStringConditions.Count
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
public ConditionCheckResultModel Validate(string stubId, StubConditionsModel conditions)
{
var result = new ConditionCheckResultModel();
var basicAuthenticationCondition = conditions?.BasicAuthentication;
if (basicAuthenticationCondition == null ||
(string.IsNullOrWhiteSpace(basicAuthenticationCondition.Username) &&
string.IsNullOrWhiteSpace(basicAuthenticationCondition.Password)))
{
return(result);
}
var headers = _httpContextService.GetHeaders();
// Try to retrieve the Authorization header.
if (!headers.TryGetValue("Authorization", out var authorization))
{
result.ConditionValidation = ConditionValidationType.Invalid;
result.Log = "No Authorization header found in request.";
}
else
{
var expectedBase64UsernamePassword = Convert.ToBase64String(
Encoding.UTF8.GetBytes(
$"{basicAuthenticationCondition.Username}:{basicAuthenticationCondition.Password}"));
var expectedAuthorizationHeader = $"Basic {expectedBase64UsernamePassword}";
if (expectedAuthorizationHeader == authorization)
{
result.Log = $"Basic authentication condition passed for stub '{stubId}'.";
result.ConditionValidation = ConditionValidationType.Valid;
}
else
{
result.Log =
$"Basic authentication condition failed for stub '{stubId}'. Expected '{expectedAuthorizationHeader}' but found '{authorization}'.";
result.ConditionValidation = ConditionValidationType.Invalid;
}
}
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var headerConditions = stub.Conditions?.Headers;
if (headerConditions == null || headerConditions?.Any() != true)
{
return(result);
}
var validHeaders = 0;
var headers = _httpContextService.GetHeaders();
foreach (var condition in headerConditions)
{
// Check whether the condition header is available in the actual headers.
var headerValue = headers.CaseInsensitiveSearch(condition.Key);
if (string.IsNullOrWhiteSpace(headerValue))
{
continue;
}
// Check whether the condition header value is available in the actual headers.
var value = condition.Value ?? string.Empty;
if (!StringHelper.IsRegexMatchOrSubstring(headerValue, value))
{
// If the check failed, it means the header is incorrect and the condition should fail.
result.Log = $"Header condition '{condition.Key}: {condition.Value}' failed.";
break;
}
validHeaders++;
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the header condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validHeaders == headerConditions.Count
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
/// <inheritdoc />
public ConditionCheckResultModel Validate(StubModel stub)
{
var result = new ConditionCheckResultModel();
var jsonPathConditions = stub.Conditions?.JsonPath?.ToArray();
if (jsonPathConditions == null || jsonPathConditions?.Any() != true)
{
return(result);
}
var validJsonPaths = 0;
var body = _httpContextService.GetBody();
var jsonObject = JObject.Parse(body);
foreach (var condition in jsonPathConditions)
{
if (condition is string conditionString)
{
// Condition is a string, so perform plain text JSONPath condition check.
var elements = jsonObject.SelectToken(conditionString);
if (elements == null)
{
// No suitable JSON results found.
result.Log = $"No suitable JSON results found with JSONPath query '{conditionString}'.";
break;
}
validJsonPaths++;
}
else
{
// Condition is an object, so first convert the condition to a StubJsonPathModel before executing the condition checker.
var jsonPathCondition = ConvertJsonPathCondition(stub.Id, condition);
var passed = false;
if (jsonPathCondition != null)
{
var elements = jsonObject.SelectToken(jsonPathCondition.Query);
if (elements != null)
{
// Retrieve the value from the JSONPath result.
var foundValue = JsonUtilities.ConvertFoundValue(elements);
// If a value is set for the condition, check if the found JSONPath value matches the value in the condition.
passed = string.IsNullOrWhiteSpace(jsonPathCondition.ExpectedValue) ||
StringHelper.IsRegexMatchOrSubstring(
foundValue,
jsonPathCondition.ExpectedValue);
}
}
if (!passed)
{
result.Log = "No suitable JSON results found.";
}
validJsonPaths += passed ? 1 : 0;
}
}
// If the number of succeeded conditions is equal to the actual number of conditions,
// the header condition is passed and the stub ID is passed to the result.
result.ConditionValidation = validJsonPaths == jsonPathConditions.Length
? ConditionValidationType.Valid
: ConditionValidationType.Invalid;
return(result);
}
public void RequestLogger_SetStubExecutionResult_HappyFlow()
{
// arrange
const string stubId = "stub-01";
var condition1 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.Invalid
};
var condition2 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.Valid
};
var condition3 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.NotExecuted
};
var conditions = new[]
{
condition1,
condition2,
condition3
};
var negativeCondition1 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.Invalid
};
var negativeCondition2 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.NotExecuted
};
var negativeCondition3 = new ConditionCheckResultModel
{
CheckerName = Guid.NewGuid().ToString(),
ConditionValidation = ConditionValidationType.Valid
};
var negativeConditions = new[]
{
negativeCondition1,
negativeCondition2,
negativeCondition3
};
// act
_logger.SetStubExecutionResult(stubId, false, conditions, negativeConditions);
var result = _logger.GetResult();
// assert
var executionResult = result.StubExecutionResults.Single();
Assert.AreEqual(stubId, executionResult.StubId);
Assert.IsFalse(executionResult.Passed);
var conditionsResult = executionResult.Conditions.ToArray();
Assert.AreEqual(2, conditionsResult.Length);
Assert.AreEqual(condition1, conditionsResult[0]);
Assert.AreEqual(condition2, conditionsResult[1]);
var negativeConditionsResult = executionResult.NegativeConditions.ToArray();
Assert.AreEqual(2, negativeConditionsResult.Length);
Assert.AreEqual(negativeCondition1, negativeConditionsResult[0]);
Assert.AreEqual(negativeCondition3, negativeConditionsResult[1]);
}
