public static void AssertJTokenEquals(JToken token, ExpectedJToken expectedJToken, string pathName, params AssertionOptions[] options)
{
switch (expectedJToken.JToken.Type)
{
case JTokenType.Array:
token.Type.Should().Be(JTokenType.Array, $"В {pathName} ожидаелся массив");
token.ToObject <IEnumerable <object> >().Should()
.Equal(expectedJToken.JToken.ToObject <IEnumerable <object> >(), because: $"Ошибка в составе массива {pathName}");
break;
case JTokenType.Null:
token.ToObject <object>().Should().BeNull($"В {pathName} ожидался null");
break;
default:
if (expectedJToken.JToken.Type == JTokenType.String && expectedJToken.JToken.ToObject <string>().ToLower().Equals("не null"))
{
token.ToObject <object>().Should().NotBeNull($"В {pathName} ожидался не null");
}
if (token.Type == JTokenType.Array)
{
token.ToObject <IEnumerable <object> >().Should().OnlyContain(
x => x.Equals(expectedJToken.TokenObject),
$"Ошибка в составе массива {pathName}, все значения должны быть одинаковыми");
}
token.ToObject <object>().Should().Be(expectedJToken.TokenObject, $"Ошибка в значении {pathName}");
break;
}
}
public static void AssertJTokenContains(JToken token, ExpectedJToken expectedJToken, string pathName)
{
switch (expectedJToken.JToken.Type)
{
case JTokenType.Array:
token.Type.Should().Be(JTokenType.Array, $"В {pathName} ожидаелся массив");
token.ToObject <IEnumerable <object> >().Should()
.Contain(expectedJToken.JToken.ToObject <IEnumerable <object> >(), because: $"В массиве {pathName} ожидалось, что содержится подмножество");
break;
case JTokenType.String:
token.ToObject <object>()
.ToString().Should().Contain(expectedJToken.JToken.ToObject <string>(), $"В {pathName} ожидалась, что содержится строка");
break;
default:
if (token.Type == JTokenType.Array)
{
token.ToObject <IEnumerable <object> >().Should().Contain(expectedJToken.TokenObject, $"В массиве {pathName} ожидалось, что содержится объект");
}
else
{
throw new Exception($"Неподдерживаемый тип токена {expectedJToken.JToken.Type}");
}
break;
}
}
public void ТоЖдемПокаБудетРавен(string selectTokenPath, ExpectedJToken expectation)
{
var timeout = 240;
var complete = false;
while (!complete)
{
ProcessSimpleApiResponse(httpClientFixture.SendRequest(lastRequestHttpMethod, lastRequestPathWithQueryParams));
try
{
var targetToken = JTokenParser.ParseJTokenFromJObject(selectTokenPath,
(JObject)scenarioContext.GetActualJsonResponse());
JTokenAssertion.AssertJTokenEquals(targetToken, expectation, selectTokenPath);
complete = true;
}
catch
{
// ignored
}
finally
{
if (timeout <= 0)
{
throw new Exception($"Не удалось дождаться результата {selectTokenPath}={expectation.JToken} от запроса {lastRequestHttpMethod} {lastRequestPathWithQueryParams}");
}
}
Thread.Sleep(1000);
timeout--;
}
}
public void ДопустимВКонтекстТокенИзИсточника(string contextVariableName, ExpectedJToken extractedToken)
{
scenarioContext.Set <JToken>(extractedToken.JToken, contextVariableName);
}
public static void AssertJTokenCollectionEquals(IEnumerable <JToken> tokenCollection, ExpectedJToken expectedJToken, string pathName, params AssertionOptions[] options)
{
switch (expectedJToken.JToken.Type)
{
case JTokenType.Array:
var expectedCollection = expectedJToken.JToken.ToObject <IEnumerable <object> >();
if (options.Contains(AssertionOptions.AssertOrder))
{
tokenCollection.Select(x => x.ToObject <object>()).Should().Equal(expectedCollection,
$"Ошибка в составе массива {pathName}, с фиксированной сортировкой");
}
else
{
tokenCollection.Select(x => x.ToObject <object>()).Should().BeEquivalentTo(expectedCollection,
$"Ошибка в составе массива {pathName}");
}
break;
default:
tokenCollection.Select(x => x.ToObject <object>())
.Should().OnlyContain(x => x.Equals(expectedJToken.TokenObject),
$"Ошибка в составе массива {pathName}, все значения должны быть одинаковыми");
break;
}
}
public static void AssertJTokenCollectionContains(IEnumerable <JToken> tokenCollection, ExpectedJToken expectedJToken, string pathName)
{
var collection = tokenCollection.ToList();
switch (expectedJToken.JToken.Type)
{
case JTokenType.Array:
collection.Select(t => t.ToObject <object>())
.Should().Contain(expectedJToken.JToken.ToObject <IEnumerable <object> >(), because: $"В массиве {pathName} ожидалось, что содержится подмножество");
break;
default:
for (var i = 0; i < collection.Count(); i++)
{
AssertJTokenContains(collection.ElementAt(i), expectedJToken, pathName);
}
break;
}
}
public abstract void AssertContains(ExpectedJToken expectation);
public abstract void AssertEquals(ExpectedJToken expectation, params AssertionOptions[] options);
public void ТоВПолученномОтветеИмяДолжноБыть(string field, string table, string where, ExpectedJToken expectation)
{
var assertableValueExpression = $"из таблицы: {table}.{field} где: {where}";
var assertableValue = specFlowContextUtils.ResolveExtractorExpression(assertableValueExpression);
JToken expectedToken = JToken.Parse(assertableValue);
var assertableToken = new AssertableJToken(expectedToken, $"{table}.{field}");
assertableToken.AssertEquals(expectation);
}