Example #1
0
        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;
            }
        }
Example #2
0
        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--;
            }
        }
Example #4
0
 public void ДопустимВКонтекстТокенИзИсточника(string contextVariableName, ExpectedJToken extractedToken)
 {
     scenarioContext.Set <JToken>(extractedToken.JToken, contextVariableName);
 }
Example #5
0
        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;
            }
        }
Example #6
0
        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;
            }
        }
Example #7
0
 public abstract void AssertContains(ExpectedJToken expectation);
Example #8
0
 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);
        }