Перейти к основному содержимому

Базовые утверждения

Утверждения для проверки значений

Доступ к утверждениям обеспечивает метод ЮТест.ОжидаетЧто, который возвращает инициализированный модуль ЮТУтверждения, реализующий работу с утверждениями.

подсказка

Не рекомендуется обращаться к модулю ЮТУтверждения напрямую, используйте ЮТест.ОжидаетЧто

Доступные методы​

подсказка

Полный и актуальный набор методов смотрите в описании API

Сравнение значений​

  • Равно - проверка на равенство конкретному значению. Для сериализуемых объектов идет сравнение по значению
  • НеРавно - проверка на не равенство конкретному значению. Для сериализуемых объектов идет сравнение по значению
  • Больше - проверяемое значение должно быть больше указанного
  • БольшеИлиРавно - проверяемое значение должно быть больше или равно указанному
  • Меньше - проверяемое значение должно быть меньше указанного
  • МеньшеИлиРавно - проверяемое значение должно быть меньше или равно указанному
  • ЭтоНеопределено - проверяемое значение должно быть равно Неопределено
  • ЭтоНеНеопределено - проверяемое значение должно быть не равно Неопределено
  • ЭтоNull - проверяемое значение должно быть равно Null
  • ЭтоНеNull - проверяемое значение должно быть не равно Null
  • ЭтоИстина - проверяемое значение должно быть истиной
  • ЭтоНеИстина - проверяемое значение не должно быть истиной
  • ЭтоЛожь - проверяемое значение должно быть ложью
  • ЭтоНеЛожь - проверяемое значение не должно быть ложью
  • ВСписке - проверяемое значение должно входить в список указанных.
Значение = 1;
ЮТУтверждения.Что(Значение)
  .Равно(1)
  .НеРавно(2)
  .Больше(0)
  .БольшеИлиРавно(-10)
  .Меньше(10)
  .МеньшеИлиРавно(2)
  .ЭтоНеИстина()
  .ЭтоНеЛожь()
  .ВСписке(ЮТКоллекция.ЗначениеВМассиве(0, 1, 2));

Особенности сравнения​

  • При сравнении значений сравниваются их типы. Это отличается от стандартного поведения 1С:Предприятие, где некоторые значения разных типов могут быть равны, например 1 = Истина 
    ЮТест.ОжидаетЧто(1 = Истина).ЭтоИстина(); // Проверка успешна
    ЮТест.ОжидаетЧто(1).Равно(Истина); // Проверка провалится
  • Для большинства типов данных реализовано сравнение "по значению", когда сравниваются (рекурсивно) значения реквизитов объекта.
  • Поддерживается сравнение структур и соответствий. 
    Значение1 = Новый Структура("Реквизит", 1);
    Значение2 = Новый Структура("Реквизит", 1);
    ЮТест.ОжидаетЧто(Значение1 = Значение2).ЭтоИстина(); // Проверка провалится
    ЮТест.ОжидаетЧто(Значение1).Равно(Значение2); // Проверка успешна
  • Поддерживается сравнение массивов, таблиц и табличных документов.
  • Поддерживается сравнение значений упакованных в ХранилищеЗначения.
  • Для прочих сериализуемых значений (не примитивов) сравнение происходит через сериализацию в JSON.

Методы позиционирования​

Любое из утверждений можно применять как к самому анализируемому объекту, так и к его свойствам, реквизитам, вложенным элементам.
Например, проверить, наличие заполненной табличной части документа используя выражение

ЮТест.ОжидаетЧто(Документ)
  .Свойство("Товары").Заполнено()
  .Свойство("Товары[0].Номенклатура").Равно(ОжидаемыйТовар)
;

Благодаря методам Свойство и Элемент можно позиционировать (переключать объект проверки) утверждения на вложенный реквизит/элемент.

Методы Свойство и Элемент переключают объект проверки для последующих методов-утверждений. Они будут применяться к значению свойства или элементу коллекции. Однако не переключает сам контекст на это значение, а всегда применяется к исходному объекту, помещенному в ОжидаетЧто.

  • Свойство - проверяет наличие свойства и позиционирует дальнейшие проверки на указанном свойстве.
  • Элемент - проверяет наличие элемента коллекции и позиционирует дальнейшие проверки на указанном элементе. На самом деле это просто алиас (псевдоним) для метода Свойство и выполняет он тоже самое.
  • Объект - позиционирует дальнейшие проверки на объекте, указанном в методе ОжидаетЧто.
  • НетСвойства - проверяет отсутствие свойства и позиционирует дальнейшие проверки на объекте, указанном в методе ОжидаетЧто.
предупреждение

Методы Свойство и Элемент всегда вычисляют путь от объекта указанного в ОжидаетЧто, они не учитывают предыдущие изменения позиции.

Например, чтобы проверить значение реквизита Реквизит.ВложенныйРеквизит

Неправильно
Объект = Новый Структура("Реквизит", Новый Структура("ВложенныйРеквизит", 1));

ЮТест.ОжидаетЧто(Объект)
  .Свойство("Реквизит")
    .Свойство("ВложенныйРеквизит").Равно(1) // Выбросит исключение, тк объект не содержит свойство "ВложенныйРеквизит"
;

Правильно в таком примере указывать сразу полный путь для свойства.

Правильно
ЮТест.ОжидаетЧто(Объект)
  .Свойство("Реквизит.ВложенныйРеквизит").Равно(1)
;

Методы Свойство и Элемент, принимают на вход не просто имя реквизита, а выражение, для перехода к нужному свойству, таким образом вы можете позиционироваться:

  • На свойствах объекта 
    ЮТест.ОжидаетЧто(Объект)
      .Свойство("Реквизит").Равно(ОжидаемоеЗначение)
  • На вложенных свойствах объекта Свойство("Реквизит.ВложенныйРеквизит") 
    ЮТест.ОжидаетЧто(Объект)
      .Свойство("Реквизит.ВложенныйРеквизит").Равно(ОжидаемоеЗначение)
  • На элементах коллекций 
    ЮТест.ОжидаетЧто(Документ.Товары)
      .Свойство("[0].Товар").Равно(ОжидаемоеЗначение);
    // Или
    ЮТест.ОжидаетЧто(Документ)
      .Свойство("Товары[0].Товар").Равно(ОжидаемоеЗначение);
  • Можно позиционировать на элементах коллекции с конца 
    ЮТест.ОжидаетЧто(Документ.Товары)
      .Свойство("[-1].Товар").Равно(ОжидаемоеЗначение) // Последний элемент;
      .Элемент(-1).ИмеетСвойство("Товар") // Последний элемент

Проверка заполненности​

  • Заполнено - проверяет заполненность значения 
    ЮТест.ОжидаетЧто(ОбъектПроверки)
      .Заполнено()
      .Свойство("Номер").Заполнено();
  • НеЗаполнено - проверяет незаполненность значения 
    Значения = ЮТКоллекции.ЗначениеВМассиве(0, "", " ", Неопределено, Null, '00010101', Новый Структура(), Справочники.Товары.ПустаяСсылка());
    Для каждого Значение Из Значения Цикл
      ЮТест.ОжидаетЧто(Значение)
        .НеЗаполнено()
    КонецЦикла;
  • Существует - проверяет существование (не равно Null и Неопределено) значения 
    ЮТест.ОжидаетЧто(ВыборкаЗапроса)
      .Свойство("Номер").Существует();
  • НеСуществует - проверяет не существование (не равно Null и Неопределено) значения 
    ЮТест.ОжидаетЧто(ВыборкаЗапроса)
      .Свойство("Номер").НеСуществует();

Проверка строк​

ПроверяемоеЗначение = "Ох, нелегкая это работа - Из болота тащить бегемота";
ЮТест.ОжидаетЧто("ПроверяемоеЗначение")
  .ИмеетДлинуБольше(10)
  .ИмеетДлинуМеньше(100)
  .ИмеетДлину(51)
  .Содержит("работа")
  .НеСодержит("зарплата")
  .НачинаетсяС("Ох")
  .ЗаканчиваетсяНа("мота")
ПроверяемоеЗначение = "Ох, нелегкая это работа - Из болота тащить бегемота";
ЮТест.ОжидаетЧто("ПроверяемоеЗначение")
  .СодержитСтрокуПоШаблону("^[а-яА-Я\s,\-]*$") // Строка содержит только кириллицу, пробелы и знаки пунктуации
  .НеСодержитСтрокуПоШаблону("\d") // Не содержит цифр

Проверка вхождения значения в интервал​

ЮТест.ОжидаетЧто(10)
  .МеждуВключаяГраницы(0, 10)
  .МеждуИсключаяГраницы(0, 100);
ЮТест.ОжидаетЧто(ТекущаяДата())
  .МеждуВключаяНачалоГраницы(НачалоДня, НачалоСледующегоДня);

Проверка типа значения​

  • ИмеетТип - проверяемое значение должно иметь указанный тип
  • НеИмеетТип - тип проверяемого значения должен отличаться от указанного

В качестве аргумента можно указывать

  • Имя типа строкой или список имен типов через запятую.
    ИмеетТип("Строка").ИмеетТип("Строка, Число")
  • Конкретный тип.
    ИмеетТип(Тип("Строка"))
  • Описание типов.
    ИмеетТип(Новый ОписаниеТипов("Строка, Число"))

Проверка выполнения метода​

API для проверки, выбрасываемых методом проверяемого объекта исключения.
Первоначально необходимо описать какой метод нужно проверить, к какому объекту он относится и с какими параметрами его необходимо вызвать. Для этих целей необходимо использовать:

  • ЮТест.ОжидаетЧто - устанавливает владельца метода
  • Метод - устанавливает имя и параметры проверяемого метода
  • Параметр - добавляет параметр метода. Создан для удобства установки параметров проверяемого метода

После формируем ожидание - должен или нет методы выбросить исключение и с каким текстом.

  • ВыбрасываетИсключение - выполняет настроенный метод объекта с параметрами и проверяет, что метод выбросит исключение и текст исключения содержит(включает) указанную в строку. При необходимости можно настроить (передать параметр), чтобы метод выполнился в транзакции.

    ЮТест.ОжидаетЧто(Документ) // Объект, метод которого проверяем
      .Метод("Записать").Параметр(РежимЗаписиДокумента.Проведение) // Указываем проверяемый метод и параметры вызова
      .ВыбрасываетИсключение("Значение поля ""Дата"" не может быть пустой датой") // Утверждение-проверка, исключение должно содержать указанный текст.
      .ВыбрасываетИсключение("""Дата""") // Можно указать только часть исключения, проверить вхождение указанной строки.
      .ВыбрасываетИсключение("""Дата""", , Истина) // Выполнение указанного метода в транзакции
    Вопрос

    Можно ли не указывать текст исключения?
    Ответ: Нельзя, вы должны конкретизировать свои ожидания, зафиксировать, какую ошибку ждете, иначе поведение может измениться и тест это не отработает.

  • НеВыбрасываетИсключение - выполняет настроенный метод объекта с параметрами и проверяет, что метод не выбросит исключение или выбросит исключения с текстом отличным от указанного. При необходимости можно настроить (передать параметр), чтобы метод выполнился в транзакции.

    ЮТест.ОжидаетЧто(Документ) // Объект, метод которого проверяем
      .Метод("Записать").Параметр(РежимЗаписиДокумента.Проведение) // Указываем проверяемый метод и параметры вызова
      .НеВыбрасываетИсключение() // Утверждение-проверка, метод выполниться без ошибки.
      .НеВыбрасываетИсключение("""Дата""") // Утверждение-проверка, метод выполниться без ошибки, либо с ошибкой, которая не содержит "Дата".
      .НеВыбрасываетИсключение("""Дата""", , Истина) // Выполнение указанного метода в транзакции
    Не злоупотребляйте проверкой НеВыбрасываетИсключение

    Многие используют это утверждение для вызова чуть ли не каждого проверяемого метода. Этого делать не стоит.
    Это утверждение должно редко применяться, если ваш метод упадет, это и так будет отражено в отчете. Один из случаев когда оно может применяться — вы используете его перед проверками на исключения, чтобы убедиться, что метод рабочий.

    Документ = СоздатьДокумент();
    Утверждение = ЮТест.ОжидаетЧто(Документ)
      .Метод("Записать").Параметр(РежимЗаписиДокумента.Проведение)
      .НеВыбрасываетИсключение("""Дата"""); // Проверим, что при нормальном заполнении ошибки нет

    Документ.Дата = Неопределено;
    Утверждение.ВыбрасываетИсключение("""Дата""", "Документ проведен при незаполненной дате");
    Нельзя явно вызывать проверяемый метод

    Хочу обратить внимание. Когда вы проверяете метод на исключения/их отсутствие вы должны указать:

    ЮТест.ОжидаетЧто(Документ)                   // 1. Владельца метода
      .Метод("Записать")                         // 2. Имя метода
      .Параметр(РежимЗаписиДокумента.Проведение) // 3. Параметры вызова метода

    // Явно вызывать метод нельзя.
    ЮТест.ОжидаетЧто(Документ)
      .Метод(Документ.Записать(РежимЗаписиДокумента.Проведение)) // Так делать нельзя, так не сработает проверка.

    Вы не должны явно вызывать метод, это должен сделать тестовый движок, чтобы поймать и проанализировать ошибку.

Проверка наличия свойств/реквизитов​

Поддерживается проверка наличия свойство для различных объектов: структур, массивов, таблиц, документов и тд.
Вы можете проверить наличие свойства не только у текущего объекта, но и у его дочерних.
Например, ИмеетСвойство("Родитель.Наименование"), будет выполнена проверка наличия свойства Родитель у текущего объекта и свойства Наименование у родителя.

Также можно проверять наличие свойств у коллекций.
Например, ИмеетСвойство("Товары[0].Наименование"), утверждение проверит наличие свойства Товары, наличие у него первого элемента и наличие свойства Наименование у этого элемента.

Документ = Документы.ПриходТовара.СоздатьДокумент();

ЮТест.ОжидаетЧто(Документ)
  .ИмеетСвойство("Товары[0]")
  .Свойство("Товары[0]")
    .ИмеетСвойство("Товар")
    .ИмеетСвойство("Количество")
    .ИмеетСвойство("Цена");

Как вы могли заметить, в качестве имени свойства указывается выражение, такое же, как и в обычном коде.

Документ = Документы.ПриходТовара.СоздатьДокумент();

Свойство = Документ.Товары[0].Наименование;
ЮТест.ОжидаетЧто(Документ)
  .Свойство("Товары[0].Наименование");
// И там и там для того, чтобы добраться до наименования используется одно и тоже выражение.

Проверка коллекции​

  • ИмеетДлину - проверяет, что коллекция имеет указанный размер

  • ИмеетДлинуБольше - проверяет, что коллекция имеет размер, который больше указанного

  • ИмеетДлинуМеньше - проверяет, что коллекция имеет размер, который меньше указанного

  • НеИмеетДлину - проверяет, что размер коллекции отличается от указанного

    Коллекция = ЮТКоллекции.ЗначениеВМассиве(1, 2, 3);
    ЮТест.ОжидаетЧто(Коллекция)
      .ИмеетДлину(3)
      .ИмеетДлинуБольше(2)
      .ИмеетДлинуМеньше(4)
      .НеИмеетДлину(4)
    ;

  • Содержит - проверяемая коллекция должна содержать указанный элемент

  • НеСодержит - проверяемая коллекция не должна содержать указанный элемент

    Коллекция = ЮТКоллекции.ЗначениеВМассиве(1, 2, 3);
    ЮТест.ОжидаетЧто(Коллекция)
      .Содержит(1) // Конкретное значение
      .Содержит(ЮТест.Предикат() // Значение по условиям
        .ИмеетТип("Число")
        .Больше(2))
      .НеСодержит(0)
      .НеСодержит(ЮТест.Предикат()  // Не содержит строк
        .ИмеетТип("Строка"))
    ;

  • КаждыйЭлементСодержитСвойство - проверяет, что каждый элемент коллекции имеет указанное свойство

  • КаждыйЭлементСодержитСвойствоСоЗначением - проверяет, что каждый элемент коллекции имеет указанное свойство, которое равно ожидаемому значению

  • ЛюбойЭлементСодержитСвойство - проверяет, что в коллекции есть элемент содержащий указанное свойство

  • ЛюбойЭлементСодержитСвойствоСоЗначением - проверяет, что в коллекции есть элемент содержащий указанное свойство, которое равно ожидаемому значению

    Коллекция = ЮТКоллекции.ЗначениеВМассиве(
      Новый Структура("С1", 1), 
      Новый Структура("С1, С2", 1, 2)
    );
    ЮТест.ОжидаетЧто(Коллекция)
      .КаждыйЭлементСодержитСвойство("С1")               // Проверка, что все элементы коллекции содержат свойство `С1`
      .КаждыйЭлементСодержитСвойствоСоЗначением("С1", 1) // Проверка, что все элементы коллекции содержат свойство `С1` со значением `1`
      .ЛюбойЭлементСодержитСвойство("С2")                // Проверка, что хотя бы один элемент коллекции содержат свойство `С2`
      .ЛюбойЭлементСодержитСвойство("С2", 2)             // Проверка, что хотя бы один элемент коллекции содержат свойство `С2` со значением `2`
    ;

  • КаждыйЭлементСоответствуетПредикату - проверяет, что элементы коллекции соответствуют переданным условиям

    Коллекция = ЮТКоллекции.ЗначениеВМассиве(1, 2, 3);
    ЮТест.ОжидаетЧто(Коллекция)
      .КаждыйЭлементСоответствуетПредикату(ЮТест.Предикат()
        .ИмеетТип("Число") // Все элементы это числа
        .НеРавно(0))       // и каждый не равен `0`

  • ЛюбойЭлементСоответствуетПредикату - проверяет, что коллекция содержит элемент, который соответствует переданным условиям

    Коллекция = ЮТКоллекции.ЗначениеВМассиве(1, 2, 3);
    ЮТест.ОжидаетЧто(Коллекция)
      .ЛюбойЭлементСоответствуетПредикату(ЮТест.Предикат()
        .ИмеетТип("Число") // Есть элемент, который является числом
        .Больше(2))        // и больше `2`

Проверка на соответствие набору условий, предикату​

Работа и суть предикатов описана в отдельной статье.

Предикаты позволяют проверить каждый элемент коллекцию на соответствие набору условий​

Предположим, нам необходимо проверить, что движения документа выполненные по регистру делают приход. Тогда тест может выглядеть так.

Документ = СоздатьИПровестиДокумент(...);
Движения = ЮТЗапросы.ДвиженияДокумента(Документ, "ОстаткиТоваров");

ЮТест.ОжидаетЧто(Движения)
  .Заполнено()
  .ИмеетДлину(Документ.Товары.Количество())
  .КаждыйЭлементСоответствуетПредикату(
    ЮТест.Предикат()
      .Реквизит("ВидДвижения").Равно(ВидДвиженияНакопления.Приход)
      .Реквизит("Количество").Больше(0)
  )
;

// Условия предиката будут применены для каждой записи движений. Если ожидания не совпадут, то будет выброшена ошибка.

Предикаты позволяют проверить наличие элемента по сложным условиям​

Документ = СоздатьИПровестиДокумент(...);
Движения = ЮТЗапросы.ДвиженияДокумента(Документ, "ОстаткиТоваров");

ЮТест.ОжидаетЧто(ПолучитьСообщенияПользователю())
  .Заполнено()
  .Содержит(
    ЮТест.Предикат()
      .Реквизит("Текст")
        .НачинаетсяС("Начало")
        .ЗаканчиваетсяНа("окончание")
        .НеСодержит("исключение")
  )
;

Примеры​

Базовые проверки​

Предположим, у нас имеется функция Сложение, которая выполняет сложение двух параметров.

Проверки для нее могут выглядеть следующим образом:

Тест для 'Сложение'
Результат = Сложение(2, 3);
ЮТест.ОжидаетЧто(Результат, "Сложение чисел") // Используя модуль утверждений установим проверяемое значение и пояснение
  .ИмеетТип("Число") // Проверим тип
  .Заполнено() // Заполненность проверяемого значения
  .Больше(0) // Сравним с нулем
  .Равно(5); // Проверим ожидаемый результат

Результат = Сложение("2", 3);
ЮТест.ОжидаетЧто(Результат, "Сложение строки и числа")
  .ИмеетТип("Строка")
  .Равно("23");

Результат = Сложение('2000010101', 3);
ЮТест.ОжидаетЧто(Результат, "Сложение даты и числа")
  .Равно('2000010101000003');

В примере на каждом этапе уменьшается количество проверок. В реальном тесте достаточно проверки на равенство, остальные проверки приведены для демонстрации возможностей механизма.

Проверка сложного объекта​

ЮТест.ОжидаетЧто(Ссылка, "Созданный объект")
  .Заполнено()
  .ИмеетТип("ДокументСсылка.ПриходТовара")
  .Свойство("Номер").Заполнено()
  .Свойство("Дата").Заполнено()
  .Свойство("Поставщик").Равно(Поставщик)
  .Свойство("Склад").Равно(Склад)
  .Свойство("Валюта").Равно(Валюта)
  .Свойство("Организация").Равно(Организация)
  .Свойство("Товары").ИмеетДлину(2)
  .Свойство("Товары[0].Товар").Равно(Товар1)
  .Свойство("Товары[0].Цена").Больше(0)
  .Свойство("Товары[0].Количество").Больше(0)
  .Свойство("Товары[0].Сумма").Равно(100)
  .Свойство("Товары[-1].Товар").Равно(Товар2)
  .Свойство("Товары[-1].Сумма").Равно(200)
  .Свойство("Проведен").ЭтоИстина()

Проверка вызова метода​

ЮТУтверждения.Что(ОМ_ЮТУтверждения)
  .Метод("МетодБезИсключение", ЮТМетоды.МассивПараметров("Исключение"))
  .НеВыбрасываетИсключение()
  .НеВыбрасываетИсключение("Ожидаемое исключение");
ЮТУтверждения.Что(ОМ_ЮТУтверждения)
  .Метод("МетодИсключение", ЮТМетоды.МассивПараметров("Исключение", 2))
  .ВыбрасываетИсключение("Слишком много фактических параметров");
ЮТУтверждения.Что(ОМ_ЮТУтверждения)
  .Метод("МетодИсключение", ЮТМетоды.МассивПараметров("Исключение"))
  .ВыбрасываетИсключение("Исключение");
ЮТУтверждения.Что(ОМ_ЮТУтверждения)
  .Метод("МетодБезИсключение")
  .ВыбрасываетИсключение("Недостаточно фактических параметров");

Проверка вызова метода используя параметры по умолчанию​

Предположим, имеется метод

Функция МетодСоЗначениеПоУмолчанию(Значение = 999, ОбязательноеЗначение) Экспорт

Для проверки метода с использованием параметра по умолчанию, просто пропустите этот параметр при формировании массива параметров.

ЮТУтверждения.Что(ОМ_ЮТУтверждения)
  .Метод("МетодСоЗначениеПоУмолчанию", ЮТМетоды.МассивПараметров(, "Исключение"))
  .НеВыбрасываетИсключение()
;

Проверка соответствия предикату​

Дата = ЮТест.Данные().СлучайнаяДата();

Объект = Новый Структура;
Объект.Вставить("Число", 1);
Объект.Вставить("Строка", "1");
Объект.Вставить("Дата", Дата);
Объект.Вставить("Массив", ЮТКоллекции.ЗначениеВМассиве(1, "1"));

ПроверкаЧисла = ЮТест.Предикат().Реквизит("Число")
  .ИмеетТип(Тип("Число"))
  .БольшеИлиРавно(1)
  .МеньшеИлиРавно(10)
  .Получить();
ПроверкаДаты = ЮТест.Предикат().Реквизит("Дата")
  .ИмеетТип(Новый ОписаниеТипов("Дата"))
  .Равно(Дата)
  .Получить();

ЮТест.ОжидаетЧто(Объект)
  .СоответствуетПредикату(ЮТест.Предикат()
    .Заполнено()
    .ИмеетТип("Структура"))
  .СоответствуетПредикату(ПроверкаЧисла)
  .СоответствуетПредикату(ПроверкаДаты)
;

Проверка элементов коллекции на соответствие предикату​

ТаблицаРезультатов = ЮТест.Данные().ЗагрузитьИзМакета("ОбщийМакет.ЮТ_МакетТестовыхДанных.R2C1:R5C11", ОписанияТипов);
ЮТест.ОжидаетЧто(ТаблицаРезультатов)
  .ИмеетТип("Массив")
  .ИмеетДлину(3)
  .КаждыйЭлементСоответствуетПредикату(ЮТест.Предикат()
    .Реквизит("Товар").Заполнено().ИмеетТип("СправочникСсылка.Товары")
    .Реквизит("Период").Заполнено().ИмеетТип("Дата")
    .Реквизит("Количество").Заполнено().ИмеетТип("Число")
    .Реквизит("Цена").Заполнено().ИмеетТип("Число")
  );

ЮТест.ОжидаетЧто(ТаблицаРезультатов)
  .Содержит(ЮТест.Предикат()
    .Реквизит("Товар").Равно(Товар1)) // Таблица содержит строку с Товар1
  .Содержит(ЮТест.Предикат(Новый Структура("Товар", Товар2))) // Таблица содержит строку с Товар2
  .Содержит(ЮТест.Предикат()
    .Реквизит("Товар").Равно(Товар3)  // Таблица содержит строку с Товар3
    .Реквизит("Количество").Равно(2)) // и количеством 2