1c/yaxunit
1
0
Fork 0
mirror of https://github.com/bia-technologies/yaxunit.git synced 2025-01-23 18:54:40 +02:00
Code Issues Releases Activity

#ONECICD-546

Browse Source
This commit is contained in:
Корякин Алексей Викторович (000106721) 2022-09-29 17:09:40 +03:00 committed by Максимов Валерий Валерьевич (000044217)
parent e3e450c19e
commit 964399640c
32 changed files with 1248 additions and 641 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
exts/yaxunit/.settings/templates/common_module.bsl
View File

@ -20,37 +20,40 @@
// Экспортные процедуры и функции, предназначенные для использования другими
// объектами конфигурации или другими программами
/////////////////////////////////////////////////////////////////////////////////
#Область ТестыAPI
#Область СлужебныйПрограммныйИнтерфейс
Процедура ИсполняемыеСценарии(ДополнительныеПараметры = Неопределено) Экспорт
Процедура ИсполняемыеСценарии() Экспорт
ЮТТесты
.Тест("ТестовыйМетод")
.ДобавитьТест("ТестовыйМетод")
.ДобавитьТест("ТестовыйМетод").СПараметрами(1, 2, 3);
;
КонецПроцедуры
#КонецОбласти
#Область События
Процедура ПередТестом() Экспорт
НачатьТранзакцию();
Процедура ПередВсемиТестами() Экспорт
КонецПроцедуры
Процедура ПослеТеста() Экспорт
Процедура ПередКаждымТестом() Экспорт
Пока ТранзакцияАктивна() Цикл
ОтменитьТранзакцию();
КонецЦикла;
КонецПроцедуры
Процедура ПослеКаждогоТеста() Экспорт
КонецПроцедуры
Процедура ПослеВсехТестов() Экспорт
КонецПроцедуры
#КонецОбласти
#Область Тесты
Процедура ТестовыйМетод() Экспорт
КонецПроцедуры
#КонецОбласти

2
exts/yaxunit/src/CommonModules/Мокито/Module.bsl
View File

@ -157,7 +157,7 @@
Параметр9 = "_!%*",
Параметр10 = "_!%*") Экспорт
Возврат МокитоСлужебный.МассивПараметров(Параметр1,
Возврат ЮТОбщий.ЗначениеВМассиве(Параметр1,
Параметр2,
Параметр3,
Параметр4,

93
exts/yaxunit/src/CommonModules/МокитоСлужебный/Module.bsl
View File

@ -228,6 +228,16 @@
Если ПараметрыПерехватаОбъекта = Неопределено И ЭтоОбъект(Ключ) Тогда
ПараметрыПерехватаОбъекта = ПараметрыПерехвата[Ключ.Ссылка];
Если ПараметрыПерехватаОбъекта = Неопределено Тогда
ПолноеИмя = СтрРазделить(Ключ.Метаданные().ПолноеИмя(), ".");
Менеджер = Новый(СтрШаблон("%1Менеджер.%2", ПолноеИмя[0], ПолноеИмя[1]));
ПараметрыПерехватаОбъекта = ПараметрыПерехвата[Менеджер];
КонецЕсли;
КонецЕсли;
Возврат ПараметрыПерехватаОбъекта;
@ -271,13 +281,13 @@
#Область ОбработчикиСобытий
Процедура ПередТестом(ОписаниеСобытия) Экспорт
Процедура ПередКаждымТестом(ОписаниеСобытия) Экспорт
ИнициализироватьНастройки();
КонецПроцедуры
Процедура ПослеТеста(ОписаниеСобытия) Экспорт
Процедура ПослеКаждогоТеста(ОписаниеСобытия) Экспорт
ОчиститьНастройки();
@ -285,85 +295,6 @@
#КонецОбласти
Функция МассивПараметров(Параметр1 = "_!%*",
Параметр2 = "_!%*",
Параметр3 = "_!%*",
Параметр4 = "_!%*",
Параметр5 = "_!%*",
Параметр6 = "_!%*",
Параметр7 = "_!%*",
Параметр8 = "_!%*",
Параметр9 = "_!%*",
Параметр10 = "_!%*") Экспорт
ФлагКонец = "_!%*";
Параметры = Новый Массив;
Если Параметр1 <> ФлагКонец Тогда
Параметры.Добавить(Параметр1);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр2 <> ФлагКонец Тогда
Параметры.Добавить(Параметр2);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр3 <> ФлагКонец Тогда
Параметры.Добавить(Параметр3);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр4 <> ФлагКонец Тогда
Параметры.Добавить(Параметр4);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр5 <> ФлагКонец Тогда
Параметры.Добавить(Параметр5);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр6 <> ФлагКонец Тогда
Параметры.Добавить(Параметр6);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр7 <> ФлагКонец Тогда
Параметры.Добавить(Параметр7);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр8 <> ФлагКонец Тогда
Параметры.Добавить(Параметр8);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр9 <> ФлагКонец Тогда
Параметры.Добавить(Параметр9);
Иначе
Возврат Параметры;
КонецЕсли;
Если Параметр10 <> ФлагКонец Тогда
Параметры.Добавить(Параметр10);
Иначе
Возврат Параметры;
КонецЕсли;
Возврат Параметры;
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////

21
exts/yaxunit/src/CommonModules/ОМ_Мокито/Module.bsl
View File

@ -18,37 +18,30 @@
// @strict-types
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции, предназначенные для использования другими
// объектами конфигурации или другими программами
/////////////////////////////////////////////////////////////////////////////////
#Область ТестыAPI
#Область СлужебныйПрограммныйИнтерфейс
Процедура ИсполняемыеСценарии() Экспорт
ЮТТесты
.Тест("Обучение")
.Тест("Проверить")
.Тест("МокированиеМетодовСсылочныхОбъектов")
.Тест("НастройкаСерверныхМоковСКлиента")
.ДобавитьТест("Обучение")
.ДобавитьТест("Проверить")
.ДобавитьТест("МокированиеМетодовСсылочныхОбъектов")
.ДобавитьТест("НастройкаСерверныхМоковСКлиента")
;
КонецПроцедуры
#КонецОбласти
#Область Тесты
Процедура Обучение() Экспорт
Описание = "Обучение через явный вызов метода";
Мокито.Обучение(РаботаСHTTP)
.Когда(РаботаСHTTP.ОтправитьОбъектНаСервер(Мокито.ЛюбойПараметр(), Мокито.ЛюбойПараметр()))
.Вернуть(1)
.Когда(РаботаСHTTP.ОтправитьОбъектНаСервер(Справочники.ИсточникиДанных.FTP, 2))
.Вернуть(10)
.Прогон();
ЮТУтверждения.Что(РаботаСHTTP.ОтправитьОбъектНаСервер(Справочники.ИсточникиДанных.FTP, 2), Описание + ". Кейс 1")
.Равно(10);
ЮТУтверждения.Что(РаботаСHTTP.ОтправитьОбъектНаСервер(Справочники.ИсточникиДанных.FTP, 1), Описание + ". Кейс 2")

11
exts/yaxunit/src/CommonModules/ОМ_ЮТИсполнитель/Module.bsl
View File

@ -20,20 +20,23 @@
// Экспортные процедуры и функции, предназначенные для использования другими
// объектами конфигурации или другими программами
/////////////////////////////////////////////////////////////////////////////////
#Область ТестыAPI
#Область СлужебныйПрограммныйИнтерфейс
Процедура ИсполняемыеСценарии(ДополнительныеПараметры = Неопределено) Экспорт
ЮТТесты
.Тест("ПропуститьИсполнение")
.ТестКлиент("ВыполнитьМодульноеТестирование")
.Тест("ВыполнитьГруппуНаборовТестов")
;
КонецПроцедуры
#КонецОбласти
#Область Тесты
Процедура ПропуститьИсполнение() Экспорт
ЮТест.Пропустить();
КонецПроцедуры
#КонецОбласти

128
exts/yaxunit/src/CommonModules/ОМ_ЮТУтверждения/Module.bsl
View File

@ -25,37 +25,38 @@
Процедура ИсполняемыеСценарии(ДополнительныеПараметры = Неопределено) Экспорт
ЮТТесты
.Тест("Что")
.Тест("Метод")
.Тест("Свойство")
.Тест("ЭтоИстина")
.Тест("ЭтоНеИстина")
.Тест("ЭтоЛожь")
.Тест("ЭтоНеЛожь")
.Тест("Равно")
.Тест("НеРавно")
.Тест("Больше")
.Тест("БольшеИлиРавно")
.Тест("Меньше")
.Тест("МеньшеИлиРавно")
.Тест("Заполнено")
.Тест("НеЗаполнено")
.Тест("Существует")
.Тест("НеСуществует")
.Тест("ЭтоНеопределено")
.Тест("ЭтоНеНеопределено")
.Тест("ЭтоNull")
.Тест("ЭтоНеNull")
.Тест("ИмеетТип")
.Тест("НеИмеетТип")
.Тест("Содержит")
.Тест("НеСодержит")
.Тест("ИмеетДлину")
.Тест("НеИмеетДлину")
.Тест("ВыбрасываетИсключение")
.Тест("НеВыбрасываетИсключение")
.ТестСервер("СравнениеСложныхОбъектов")
.Тест("ФормированиеСообщения")
.ДобавитьТест("Что")
.ДобавитьТест("Метод")
.ДобавитьТест("Свойство")
.ДобавитьТест("НетСвойства")
.ДобавитьТест("ЭтоИстина")
.ДобавитьТест("ЭтоНеИстина")
.ДобавитьТест("ЭтоЛожь")
.ДобавитьТест("ЭтоНеЛожь")
.ДобавитьТест("Равно")
.ДобавитьТест("НеРавно")
.ДобавитьТест("Больше")
.ДобавитьТест("БольшеИлиРавно")
.ДобавитьТест("Меньше")
.ДобавитьТест("МеньшеИлиРавно")
.ДобавитьТест("Заполнено")
.ДобавитьТест("НеЗаполнено")
.ДобавитьТест("Существует")
.ДобавитьТест("НеСуществует")
.ДобавитьТест("ЭтоНеопределено")
.ДобавитьТест("ЭтоНеНеопределено")
.ДобавитьТест("ЭтоNull")
.ДобавитьТест("ЭтоНеNull")
.ДобавитьТест("ИмеетТип")
.ДобавитьТест("НеИмеетТип")
.ДобавитьТест("Содержит")
.ДобавитьТест("НеСодержит")
.ДобавитьТест("ИмеетДлину")
.ДобавитьТест("НеИмеетДлину")
.ДобавитьТест("ВыбрасываетИсключение")
.ДобавитьТест("НеВыбрасываетИсключение")
.ДобавитьСерверныйТест("СравнениеСложныхОбъектов")
.ДобавитьТест("ФормированиеСообщения")
;
КонецПроцедуры
@ -86,7 +87,7 @@
ДанныеКонтекста = ЮТКонтекст.КонтекстПроверки();
ЮТУтверждения.Что(ДанныеКонтекста, "Свойство не установлено")
.Свойство("ИмяСвойства").Равно("");
.Свойство("ИмяСвойства").Равно(Неопределено);
ЮТУтверждения.Что(Объект)
.Свойство("Примитив");
@ -139,7 +140,7 @@
Исключение
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуИсполнения(Ошибка, "Задано неправильное имя атрибута структуры");
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `Структура` содержит свойство `1+1`, но это не так.");
Попытка
Ошибка = Неопределено;
@ -148,7 +149,9 @@
Исключение
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуИсполнения(Ошибка, "Невалидный составной идентификатор: Задано неправильное имя атрибута структуры");
ПроверитьОшибкуУтверждения(Ошибка,
"Невалидный составной идентификатор: ожидали, что проверяемое значение `Структура` содержит свойство `Объект.1`, но это не так.");
Попытка
Ошибка = Неопределено;
@ -159,6 +162,48 @@
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `Структура` содержит свойство `Объект.Нулевой`, но это не так");
Объект = Мокито.МассивПараметров("1", "2", "3");
ЮТУтверждения.Что(Объект, "Проверка элементов массива")
.Элемент(0).Равно("1")
.Элемент(1).Равно("2")
.Элемент(-1).Равно("3")
.Свойство("[00]").Равно("1")
.Свойство("[1]").Равно("2")
.Свойство("[-1]").Равно("3")
.НетСвойства(3)
.НетСвойства("[3]");
Объект.Добавить(Новый Структура("Первый, Второй", 1, Мокито.МассивПараметров(2)));
ЮТУтверждения.Что(Объект, "Проверка свойства элемента массива")
.Свойство("[3].Первый").Равно(1)
.Свойство("[3].Второй[-1]").Равно(2)
.Свойство("[3].Второй[0]").Равно(2)
КонецПроцедуры
Процедура НетСвойства() Экспорт
ВложеннаяСтруктура = Новый Структура("Строка, Число", "Строка", 123);
ВложенноеСоответствие = Новый Соответствие();
ВложенноеСоответствие.Вставить("Строка", "Строка");
ВложенноеСоответствие.Вставить("Число", 234);
ВложенноеСоответствие.Вставить(123, 456);
Объект = Новый Структура("Структура, Соответствие", ВложеннаяСтруктура, ВложенноеСоответствие);
ЮТест.ОжидаетЧто(Объект)
.Свойство("Структура").Равно(ВложеннаяСтруктура)
.НетСвойства("Число")
.Равно(Объект);
Попытка
Ошибка = Неопределено;
ЮТест.ОжидаетЧто(Объект)
.НетСвойства("Соответствие")
Исключение
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `Структура` не содержит свойство `Соответствие`, но это не так.");
КонецПроцедуры
Процедура Метод() Экспорт
@ -739,7 +784,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `` является заполненным, но это не так");
ПроверитьДанныеОшибкиУтверждения(Неопределено);
ПроверитьДанныеОшибкиСравнения(Неопределено, Неопределено);
Попытка
Ошибка = Неопределено;
@ -749,7 +794,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `0` является заполненным, но это не так");
ПроверитьДанныеОшибкиУтверждения(0);
ПроверитьДанныеОшибкиСравнения(0, Неопределено);
Попытка
Ошибка = Неопределено;
@ -802,7 +847,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `Нет` не является заполненным, но это не так");
ПроверитьДанныеОшибкиУтверждения(Ложь);
ПроверитьДанныеОшибкиСравнения(Ложь, Неопределено);
Попытка
Ошибка = Неопределено;
@ -843,7 +888,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `` существует, но это не так");
ПроверитьДанныеОшибкиУтверждения(Неопределено);
ПроверитьДанныеОшибкиСравнения(Неопределено, Неопределено);
Попытка
Ошибка = Неопределено;
@ -853,7 +898,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что проверяемое значение `` существует, но это не так");
ПроверитьДанныеОшибкиУтверждения(Null);
ПроверитьДанныеОшибкиСравнения(Null, Неопределено);
КонецПроцедуры
@ -874,7 +919,7 @@
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Пустая строка: ожидали, что проверяемое значение `` не существует, но это не так");
ПроверитьДанныеОшибкиУтверждения("");
ПроверитьДанныеОшибкиСравнения("", Неопределено);
Попытка
Ошибка = Неопределено;
@ -1416,7 +1461,8 @@
Исключение
Ошибка = ИнформацияОбОшибке();
КонецПопытки;
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что метод `МетодБезИсключение` вызовет исключение `Исключение`, но получили `{(1)}: Недостаточно фактических параметров`");
ПроверитьОшибкуУтверждения(Ошибка, "Ожидали, что метод `МетодБезИсключение` вызовет исключение `Исключение`, но получили");
ПроверитьОшибкуУтверждения(Ошибка, "Недостаточно фактических параметров");
Попытка
Ошибка = Неопределено;

2
exts/yaxunit/src/CommonModules/ОМ_ЮТФильтрация/Module.bsl
View File

@ -173,7 +173,7 @@
Наборы = Новый Массив();
Набор = ЮТФабрика.ОписаниеТестовогоНабора("Тесты");
Тест = ЮТФабрика.ОписаниеТеста("Тест1", "Тест 1", Контексты.Сервер + ", " + Контексты.КлиентУправляемоеПриложение);
Тест = ЮТФабрика.ОписаниеТеста("Тест1", "Тест 1", ЮТОбщий.ЗначениеВМассиве(Контексты.Сервер, Контексты.КлиентУправляемоеПриложение));
Набор.Тесты.Добавить(Тест);
Наборы.Добавить(Набор);

153
exts/yaxunit/src/CommonModules/ОМ_ЮТЧитатель/Module.bsl
View File

@ -16,45 +16,44 @@
//
//©///////////////////////////////////////////////////////////////////////////©//
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции, предназначенные для использования другими
// объектами конфигурации или другими программами
/////////////////////////////////////////////////////////////////////////////////
#Область ТестыAPI
#Область СлужебныйПрограммныйИнтерфейс
Процедура ИсполняемыеСценарии(ДополнительныеПараметры = Неопределено) Экспорт
ЮТТесты
.Тест("ПрочитатьНаборыТестов")
.Тест("ИсполняемыеСценарииМодуля")
.Тест("ЭтоТестовыйМодуль")
.ДобавитьТестовыйНабор("ЭтоТестовыйМодуль", "Параметризированный, 1,2")
.Тест("ЭтоТестовыйМодуль").СПараметрами("ОМ_ЮТЧитатель", Истина)
.Тест("ЭтоТестовыйМодуль").СПараметрами("ОМ_ЮТУтверждения", Истина)
.Тест("ЭтоТестовыйМодуль").СПараметрами("ОМ_Мокито", Истина)
.Тест("ЭтоТестовыйМодуль").СПараметрами("ЮТЧитатель", Ложь)
.ДобавитьТестовыйНабор("ЗагрузкаТестов")
.ТестКлиент("ЗагрузитьТесты")
.ТестСервер("ЗагрузитьТесты")
;
КонецПроцедуры
#КонецОбласти
#Область Тесты
Процедура ПрочитатьНаборыТестов() Экспорт
Процедура ЗагрузитьТесты() Экспорт
ПараметрыЗапуска = ЮТФабрика.ПараметрыЗапуска();
ПараметрыЗапуска.filter.extensions = Неопределено;
ПараметрыЗапуска.filter.modules = ЮТОбщий.ЗначениеВМассиве("ОМ_ЮТЧитатель");
Наборы = ЮТЧитатель.ЗагрузитьТесты(ПараметрыЗапуска);
ЮТУтверждения.Что(Наборы, "Прочитанные наборы")
ЮТест.ОжидаетЧто(Наборы, "Прочитанные наборы")
.ИмеетТип("Массив")
.ИмеетДлину(1);
НаборМодуля = Наборы[0];
ЮТУтверждения.Что(НаборМодуля, "Набор тестов ОМ_ЮТЧитатель")
ЮТест.ОжидаетЧто(НаборМодуля, "Набор тестов ОМ_ЮТЧитатель")
.ИмеетТип("Структура")
.Свойство("МетаданныеМодуля").ИмеетТип("Структура")
.Свойство("НаборыТестов").ИмеетТип("Массив");
МетаданныеМодуля = НаборМодуля.МетаданныеМодуля;
ЮТУтверждения.Что(МетаданныеМодуля, "Метаданные модуля")
ЮТест.ОжидаетЧто(МетаданныеМодуля, "Метаданные модуля")
.Заполнено()
.ИмеетТип("Структура")
.Свойство("Имя").Равно("ОМ_ЮТЧитатель")
@ -66,27 +65,26 @@
НаборыТестов = НаборМодуля.НаборыТестов;
ЮТУтверждения.Что(НаборыТестов, "Наборы тестов модуля")
ЮТест.ОжидаетЧто(НаборыТестов, "Наборы тестов модуля")
.ИмеетТип("Массив")
.ИмеетДлину(1);
.ИмеетДлину(3);
ЮТУтверждения.Что(НаборыТестов[0], "Набор тестов модуля")
ЮТест.ОжидаетЧто(НаборыТестов[0], "Набор тестов по умолчанию")
.ИмеетТип("Структура")
.Свойство("Имя").Равно("Тесты")
.Свойство("Ошибки").ИмеетДлину(0)
.Свойство("Имя").Равно("ОМ_ЮТЧитатель")
.Свойство("Представление").Равно("ОМ_ЮТЧитатель")
.Свойство("Теги").ИмеетТип("Массив")
.Свойство("Теги").ИмеетДлину(0)
.Свойство("Тесты").ИмеетТип("Массив");
.Свойство("Ошибки").ИмеетТип("Массив").НеЗаполнено()
.Свойство("Теги").ИмеетТип("Массив").НеЗаполнено()
.Свойство("Тесты").ИмеетТип("Массив").ИмеетДлину(1);
Тесты = НаборыТестов[0].Тесты;
ЮТУтверждения.Что(Тесты.Количество(), "Количество тестов модуля")
ЮТест.ОжидаетЧто(Тесты.Количество(), "Количество тестов модуля")
.БольшеИлиРавно(1);
ЮТУтверждения.Что(Тесты[0], "Первый тест")
.Свойство("Имя").Равно("ПрочитатьНаборыТестов")
.Свойство("Представление").Равно("ПрочитатьНаборыТестов")
ЮТест.ОжидаетЧто(Тесты[0], "Первый тест")
.Свойство("Имя").Равно("ИсполняемыеСценарииМодуля")
.Свойство("Представление").НеЗаполнено()
.Свойство("Теги").Равно(Новый Массив())
.Свойство("КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("КлиентУправляемоеПриложение"));
@ -94,7 +92,7 @@
ПараметрыЗапуска.filter.extensions = ЮТОбщий.ЗначениеВМассиве("tests");
Наборы = ЮТЧитатель.ЗагрузитьТесты(ПараметрыЗапуска);
ЮТУтверждения.Что(Наборы, "Прочитанные наборы расширения tests")
ЮТест.ОжидаетЧто(Наборы, "Прочитанные наборы расширения tests")
.ИмеетДлину(2);
КонецПроцедуры
@ -102,7 +100,7 @@
Процедура ИсполняемыеСценарииМодуля() Экспорт
МетаданныеМодуля = Новый Структура;
МетаданныеМодуля.Вставить("Имя", "ОМ_СтроковыеФункцииКлиентСервер");
МетаданныеМодуля.Вставить("Имя", "ОМ_ЮТЧитатель");
МетаданныеМодуля.Вставить("КлиентУправляемоеПриложение", Истина);
МетаданныеМодуля.Вставить("КлиентОбычноеПриложение", Истина);
МетаданныеМодуля.Вставить("Клиент", Ложь);
@ -112,74 +110,51 @@
ЮТФильтрация.УстановитьКонтекст(Новый Структура("filter", Новый Структура));
Сценарии = ЮТЧитатель.ИсполняемыеСценарииМодуля(МетаданныеМодуля);
ЮТУтверждения.Что(Сценарии, "Сценарии")
ЮТест.ОжидаетЧто(Сценарии, "Сценарии")
.ИмеетТип("Массив")
.ИмеетДлину(3);
.ИмеетДлину(3)
.Элемент(0).ИмеетТип("Структура")
.Элемент(1).ИмеетТип("Структура")
.Элемент(2).ИмеетТип("Структура")
;
НаборПоУмолчанию = Сценарии[0];
НаборЭтоТестовыйМодуль = Сценарии[1];
НаборЗагрузкаТестов = Сценарии[2];
Наборы = ЮТОбщий.КоллекцияВСоответствие(Сценарии, "Имя");
ЮТУтверждения.Что(Наборы, "Наборы тестов")
.Свойство("Тесты").ИмеетТип("Структура")
.Свойство("ТестовыйНабор").ИмеетТип("Структура")
.Свойство("Тестовый набор 2").ИмеетТип("Структура")
.ИмеетДлину(3);
Набор1 = Наборы["Тесты"];
Набор2 = Наборы["ТестовыйНабор"];
Набор3 = Наборы["Тестовый набор 2"];
ЮТУтверждения.Что(Набор1, "Набор по умолчанию")
.Свойство("Имя").Равно("Тесты")
.Свойство("Представление").Равно("ОМ_СтроковыеФункцииКлиентСервер")
ЮТест.ОжидаетЧто(НаборПоУмолчанию, "Набор по умолчанию")
.Свойство("Имя").Равно("ОМ_ЮТЧитатель")
.Свойство("Представление").Равно("ОМ_ЮТЧитатель")
.Свойство("Теги").ИмеетДлину(0)
.Свойство("Тесты").ИмеетДлину(3);
.Свойство("Тесты").ИмеетДлину(1)
.Свойство("Тесты[0].Имя").Равно("ИсполняемыеСценарииМодуля")
.Свойство("Тесты[0].Представление").НеЗаполнено()
.Свойство("Тесты[0].Теги").ИмеетДлину(0)
.Свойство("Тесты[0].КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("Сервер", "КлиентУправляемоеПриложение"))
;
ЮТУтверждения.Что(Набор2, "Набор ""ТестовыйНабор""")
.Свойство("Имя").Равно("ТестовыйНабор")
.Свойство("Представление").Равно("ТестовыйНабор")
.Свойство("Теги").ИмеетДлину(0)
.Свойство("Тесты").ИмеетДлину(3);
ЮТест.ОжидаетЧто(НаборЗагрузкаТестов, "Набор 'ЗагрузкаТестов'")
.Свойство("Имя").Равно("ЗагрузкаТестов")
.Свойство("Тесты").ИмеетДлину(2)
.Свойство("Тесты[0].Имя").Равно("ЗагрузитьТесты")
.Свойство("Тесты[0].КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("КлиентУправляемоеПриложение"))
.Свойство("Тесты[1].Имя").Равно("ЗагрузитьТесты")
.Свойство("Тесты[1].КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("Сервер"))
;
ЮТУтверждения.Что(Набор3, "Набор ""Тестовый набор 2""")
.Свойство("Имя").Равно("Тестовый набор 2")
.Свойство("Теги").ИмеетДлину(2)
.Свойство("Тесты").ИмеетДлину(1);
ТестыПоУмолчанию = Набор1.Тесты;
ЮТУтверждения.Что(ТестыПоУмолчанию[0], "Первый тест набора по умолчанию")
.ИмеетТип("Структура")
.Свойство("Имя").Равно("ТестовыйМетод3")
.Свойство("Представление").Равно("Тестовый метод 3")
.Свойство("Теги").ИмеетДлину(0)
.Свойство("КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("Сервер", "КлиентУправляемоеПриложение"));
ЮТУтверждения.Что(ТестыПоУмолчанию[1], "Второй тест набора по умолчанию")
.Свойство("Имя").Равно("ТестовыйМетод4")
.Свойство("Представление").Равно("ТестовыйМетод4")
.Свойство("Теги").ИмеетДлину(0)
.Свойство("КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("КлиентУправляемоеПриложение"));
ЮТУтверждения.Что(ТестыПоУмолчанию[2], "Третий тест набора по умолчанию")
.Свойство("Имя").Равно("ТестовыйМетод4")
.Свойство("КонтекстВызова").Равно(ЮТОбщий.ЗначениеВМассиве("Сервер"))
ЮТест.ОжидаетЧто(НаборЭтоТестовыйМодуль, "Набор 'ЭтоТестовыйМодуль'")
.Свойство("Имя").Равно("ЭтоТестовыйМодуль")
.Свойство("Тесты").ИмеетДлину(4)
.Свойство("Теги").ИмеетДлину(3)
;
КонецПроцедуры
Процедура ЭтоТестовыйМодуль() Экспорт
Процедура ЭтоТестовыйМодуль(ИмяМодуля, ЭтоТестовый) Экспорт
Варианты = Новый Структура();
Варианты.Вставить("ОМ_ЮТЧитатель", Истина);
Варианты.Вставить("ОМ_СтроковыеФункцииКлиентСервер", Истина);
Варианты.Вставить("ОМ_ОшибкаЗагрузкиСценариев", Истина);
Варианты.Вставить("ЮТЧитатель", Ложь);
Для Каждого Вариант Из Варианты Цикл
ОписаниеМодуля = ЮТМетаданныеСервер.МетаданныеМодуля(Вариант.Ключ);
ЮТУтверждения.Что(ЮТЧитатель.ЭтоТестовыйМодуль(ОписаниеМодуля), "Проверка модуля " + Вариант.Ключ)
.Равно(Вариант.Значение);
КонецЦикла;
ОписаниеМодуля = ЮТМетаданныеСервер.МетаданныеМодуля(ИмяМодуля);
ЮТест.ОжидаетЧто(ЮТЧитатель.ЭтоТестовыйМодуль(ОписаниеМодуля), "Проверка модуля " + ИмяМодуля)
.Равно(ЭтоТестовый);
КонецПроцедуры

35
exts/yaxunit/src/CommonModules/ЮТПараметрыСервер/Module.bsl → exts/yaxunit/src/CommonModules/ОМ_ЮТест/Module.bsl
View File

@ -16,40 +16,31 @@
//
//©///////////////////////////////////////////////////////////////////////////©//
// @strict-types
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции, предназначенные для использования другими
// объектами конфигурации или другими программами
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции для служебного использования внутри подсистемы
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныйПрограммныйИнтерфейс
Функция ПрочитатьКонфигурационныйФайл(Знач ТекстИзФайла = "") Экспорт
Процедура ИсполняемыеСценарии(ДополнительныеПараметры = Неопределено) Экспорт
Попытка
Возврат ЮТОбщий.ЗначениеИзJSON(ТекстИзФайла);
Исключение
ЮТТесты
.Тест("Пропустить")
;
ВызватьИсключение СтрШаблон("Ошибка чтения конфигурационного файла: '%1'", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()));
КонецПопытки;
КонецПроцедуры
Процедура Пропустить() Экспорт
КонецФункции
ЮТест.Пропустить();
ВызватьИсключение "Не отработал пропуск теста";
КонецПроцедуры
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
// Процедуры и функции, составляющие внутреннюю реализацию модуля
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныеПроцедурыИФункции
#КонецОбласти

8
exts/yaxunit/src/CommonModules/ЮТПараметрыСервер/ЮТПараметрыСервер.mdo → exts/yaxunit/src/CommonModules/ОМ_ЮТест/ОМ_ЮТест.mdo
View File

@ -1,11 +1,11 @@
<?xml version="1.0" encoding="UTF-8"?>
<mdclass:CommonModule xmlns:mdclass="http://g5.1c.ru/v8/dt/metadata/mdclass" uuid="ae3fc89b-811b-4cd7-8403-bf334dfbed19">
<name>ЮТПараметрыСервер</name>
<mdclass:CommonModule xmlns:mdclass="http://g5.1c.ru/v8/dt/metadata/mdclass" uuid="99f3e7cb-2833-48ec-b998-6c497d633d15">
<name>ОМ_ЮТест</name>
<synonym>
<key>ru</key>
<value>Параметры сервер</value>
<value>О м ест</value>
</synonym>
<clientManagedApplication>true</clientManagedApplication>
<server>true</server>
<clientOrdinaryApplication>true</clientOrdinaryApplication>
<serverCall>true</serverCall>
</mdclass:CommonModule>

79
exts/yaxunit/src/CommonModules/ЮТ/Module.bsl
View File

@ -1,79 +0,0 @@
//©///////////////////////////////////////////////////////////////////////////©//
//
// Copyright 2021-2022 BIA-Technologies Limited Liability Company
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//©///////////////////////////////////////////////////////////////////////////©//
/////////////////////////////////////////////////////////////////////////////////
// Основной модуль для запуска тестирования
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
// Инициализировать
// Выполняет чтение и инициализацию параметров подсистемы тестирования
// Параметры:
// ПараметрыЗапускаСтрокой - Строка - Строка запуска приложения
//
// Возвращаемое значение:
// Структура - См. ЮТФабрика.ПараметрыЗапуска
Функция Инициализировать(Знач ПараметрыЗапускаСтрокой) Экспорт
Возврат ЮТПараметры.ПараметрыЗапуска(ПараметрыЗапускаСтрокой);
КонецФункции
// ВыполнятьМодульноеТестирование
// Возвращает признак необходимости выполнять модульное тестирование
// Параметры:
// Параметры - См. ЮТФабрика.ПараметрыЗапуска
//
// Возвращаемое значение:
// Булево - Необходимость выполнения модульного тестирования
Функция ВыполнятьМодульноеТестирование(Параметры) Экспорт
Возврат Параметры.ВыполнятьМодульноеТестирование;
КонецФункции
// ВыполнитьМодульноеТестирование
// Запускает выполнение модульного тестирования
//
// Параметры:
// Параметры - См. ЮТФабрика.ПараметрыЗапуска
Процедура ВыполнитьМодульноеТестирование(Параметры = Неопределено) Экспорт
Если Параметры = Неопределено Тогда
Параметры = ЮТ.Инициализировать(ПараметрЗапуска);
КонецЕсли;
Если НЕ ВыполнятьМодульноеТестирование(Параметры) Тогда
Возврат;
КонецЕсли;
ЮТКонтекст.ИнициализироватьКонтекст();
ТестовыеМодули = ЮТЧитатель.ЗагрузитьТесты(Параметры);
РезультатыТестирования = ЮТИсполнитель.ВыполнитьМодульноеТестирование(ТестовыеМодули);
ЮТОтчет.СформироватьОтчет(РезультатыТестирования, Параметры);
Если Параметры.CloseAfterTests Тогда
ПрекратитьРаботуСистемы(Ложь);
КонецЕсли;
КонецПроцедуры
#КонецОбласти

72
exts/yaxunit/src/CommonModules/ЮТИсполнитель/Module.bsl
View File

@ -22,15 +22,31 @@
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
#Если Клиент Тогда
// ВыполнитьМодульноеТестирование
// Метод, по параметрам запуска, запускает выполнение всего процесса тестирования.
//
// Параметры:
// ТестовыеМодули - Массив из см. ЮТФабрика.ОписаниеТестовогоМодуля
//
// Возвращаемое значение:
// Массив из см. ЮТФабрика.ОписаниеИсполняемогоНабораТестов
Функция ВыполнитьМодульноеТестирование(ТестовыеМодули) Экспорт
// Параметры - См. ЮТФабрика.ПараметрыЗапуска
Процедура ВыполнитьМодульноеТестирование(Параметры = Неопределено) Экспорт
Если Параметры = Неопределено Тогда
Параметры = ЮТПараметры.ПараметрыЗапуска(ПараметрЗапуска);
КонецЕсли;
Если НЕ Параметры.ВыполнятьМодульноеТестирование Тогда
Возврат;
КонецЕсли;
ЮТКонтекст.ИнициализироватьКонтекст();
ЮТКонтекст.УстановитьГлобальныеНастройкиВыполнения(Параметры.settings);
ЮТСобытия.Инициализация(Параметры);
// Повторно сохраним для передачи на сервер
ЮТКонтекст.УстановитьГлобальныеНастройкиВыполнения(ЮТКонтекст.ГлобальныеНастройкиВыполнения());
ЮТКонтекст.УстановитьКонтекстИсполнения(ДанныеКонтекстаИсполнения());
ТестовыеМодули = ЮТЧитатель.ЗагрузитьТесты(Параметры);
РезультатыТестирования = Новый Массив();
@ -48,9 +64,15 @@
КонецЦикла;
Возврат РезультатыТестирования;
ЮТОтчет.СформироватьОтчет(РезультатыТестирования, Параметры);
КонецФункции
Если Параметры.CloseAfterTests Тогда
ПрекратитьРаботуСистемы(Ложь);
КонецЕсли;
КонецПроцедуры
#КонецЕсли
#КонецОбласти
@ -73,6 +95,9 @@
Возврат Наборы;
КонецЕсли;
Уровни = ЮТФабрика.УровниИсполнения();
ЮТКонтекст.КонтекстИсполнения().Уровень = Уровни.Модуль;
ЮТСобытия.ПередВсемиТестамиМодуля(ТестовыйМодуль);
Если ЕстьОшибки(ТестовыйМодуль) Тогда
@ -90,6 +115,8 @@
КонецЦикла;
ЮТКонтекст.КонтекстИсполнения().Уровень = Уровни.Модуль;
ЮТСобытия.ПослеВсехТестовМодуля(ТестовыйМодуль);
Если ЕстьОшибки(ТестовыйМодуль) Тогда
@ -110,6 +137,9 @@
Функция ВыполнитьНаборТестов(Набор, ТестовыйМодуль)
Уровни = ЮТФабрика.УровниИсполнения();
ЮТКонтекст.КонтекстИсполнения().Уровень = Уровни.НаборТестов;
Набор.ДатаСтарта = ТекущаяУниверсальнаяДатаВМиллисекундах();
ЮТСобытия.ПередТестовымНабором(ТестовыйМодуль, Набор);
@ -118,14 +148,15 @@
КонецЕсли;
Результаты = Новый Массив();
ЮТКонтекст.КонтекстИсполнения().Уровень = Уровни.Тест;
Для Каждого Тест Из Набор.Тесты Цикл
Тест.ДатаСтарта = ТекущаяУниверсальнаяДатаВМиллисекундах();
ЮТСобытия.ПередТестом(ТестовыйМодуль, Набор, Тест);
ЮТСобытия.ПередКаждымТестом(ТестовыйМодуль, Набор, Тест);
ВыполнитьТестовыйМетод(Тест);
ЮТСобытия.ПослеТеста(ТестовыйМодуль, Набор, Тест);
ЮТСобытия.ПослеКаждогоТеста(ТестовыйМодуль, Набор, Тест);
ОбработатьЗавершениеТеста(Тест);
@ -133,7 +164,9 @@
КонецЦикла;
ЮТКонтекст.КонтекстИсполнения().Уровень = Уровни.НаборТестов;
ЮТСобытия.ПослеТестовогоНабора(ТестовыйМодуль, Набор);
Набор.Длительность = ТекущаяУниверсальнаяДатаВМиллисекундах() - Набор.ДатаСтарта;
Возврат Результаты;
@ -197,6 +230,7 @@
КатегорииНаборов.Вставить("Пропущенные", Новый Массив());
КонтекстыПриложения = ЮТФабрика.КонтекстыПриложения();
КонтекстыМодуля = ЮТФабрика.КонтекстыМодуля(ТестовыйМодуль.МетаданныеМодуля);
КонтекстыИсполнения = ЮТФабрика.КонтекстыИсполнения();
Для Каждого Набор Из ИсполняемыеТестовыеНаборы Цикл
@ -206,6 +240,8 @@
ОшибкаКонтекста = Неопределено;
Если КонтекстыПриложения.Найти(Набор.Режим) = Неопределено Тогда
ОшибкаКонтекста = "Неподдерживаемый режим запуска";
ИначеЕсли КонтекстыМодуля.Найти(Набор.Режим) = Неопределено Тогда
ОшибкаКонтекста = "Модуль не доступен в этом контексте";
ИначеЕсли КонтекстИсполнения <> КонтекстыИсполнения.Сервер И КонтекстИсполнения <> КонтекстыИсполнения.Клиент Тогда
ОшибкаКонтекста = "Неизвестный контекст/режим исполнения";
КонецЕсли;
@ -222,7 +258,7 @@
КатегорииНаборов.Пропущенные.Добавить(Набор);
Продолжить;
КонецЕсли;
Если КонтекстИсполнения = КонтекстыИсполнения.Сервер Тогда
КатегорииНаборов.Серверные.Добавить(Набор);
@ -252,7 +288,7 @@
СтатусыИсполненияТеста = ЮТФабрика.СтатусыИсполненияТеста();
Тест.Статус = СтатусыИсполненияТеста.Исполнение;
Ошибка = ЮТОбщий.ВыполнитьМетод(Тест.ПолноеИмяМетода);
Ошибка = ЮТОбщий.ВыполнитьМетод(Тест.ПолноеИмяМетода, Тест.Параметры);
Если Ошибка <> Неопределено Тогда
ЮТРегистрацияОшибок.ЗарегистрироватьОшибкуВыполненияТеста(Тест, Ошибка);
@ -274,4 +310,18 @@
КонецПроцедуры
// Данные контекста исполнения.
//
// Возвращаемое значение:
// Структура - Данные контекста исполнения:
// * Уровень - Строка
Функция ДанныеКонтекстаИсполнения()
Контекст = Новый Структура();
Контекст.Вставить("Уровень", "");
Возврат Контекст;
КонецФункции
#КонецОбласти

107
exts/yaxunit/src/CommonModules/ЮТКонтекст/Module.bsl
View File

@ -86,29 +86,56 @@
// КонтекстТеста
// Возвращает структуру, в которой можно хранить данные используемые в тесте
// Данные живут в рамках одного теста, но доступны в обработчиках событий `ПередТестом` и `ПослеТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеТеста`
// Данные живут в рамках одного теста, но доступны в обработчиках событий `ПередКаждымТестом` и `ПослеКаждогоТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеКаждогоТеста`
// Возвращаемое значение:
// Неопределено, Структура - Контекст теста, возвращает неопределено если контекст не инициализирован
// Структура - Контекст теста
// Неопределено - Если метод вызывается за рамками теста
Функция КонтекстТеста() Экспорт
Возврат ЮТКонтекст.ЗначениеКонтекста(ИмяКонтекстаТеста());
Возврат ЗначениеКонтекста(ИмяКонтекстаТеста());
КонецФункции
// КонтекстНабора
// Возвращает структуру, в которой можно хранить данные используемые в тестах набора
// Данные живут в рамках одного набора тестов (данные между клиентом и сервером не синхронизируются)
// Доступны в каждом тесте набора и в обработчиках событий `ПередТестовымНабором`, `ПослеТестовогоНабора`, `ПередТестом` и `ПослеТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеТеста`
// Доступны в каждом тесте набора и в обработчиках событий
// + `ПередТестовымНабором`
// + `ПослеТестовогоНабора`
// + `ПередКаждымТестом`
// + `ПослеКаждогоТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеКаждогоТеста`
// Возвращаемое значение:
// Неопределено, Структура - Контекст набора тестов, возвращает неопределено если контекст не инициализирован
// Структура - Контекст набора тестов
// Неопределено - Если метод вызывается за рамками тестового набора
Функция КонтекстНабора() Экспорт
Возврат ЮТКонтекст.ЗначениеКонтекста(ИмяКонтекстаНабораТестов());
Возврат ЗначениеКонтекста(ИмяКонтекстаНабораТестов());
КонецФункции
// КонтекстМодуля
// Возвращает структуру, в которой можно хранить данные используемые в тестах модуля
// Данные живут в рамках одного тестового модуля (данные между клиентом и сервером не синхронизируются)
// Доступны в каждом тесте модуля и в обработчиках событий
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеВсехТестов`
// Возвращаемое значение:
// Структура - Контекст тестового модуля
// Неопределено - Если метод вызывается за рамками тестового модуля
Функция КонтекстМодуля() Экспорт
Возврат ЗначениеКонтекста(ИмяКонтекстаМодуля());
КонецФункции
Функция ГлобальныеНастройкиВыполнения() Экспорт
Возврат ЗначениеКонтекста(ИмяГлобальныеНастройкиВыполнения());
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
@ -123,7 +150,7 @@
// Неопределено, Структура - Контекст ошибки, см. ЮТРегистрацияОшибок.НовыйКонтекстОшибки
Функция КонтекстОшибки() Экспорт
Возврат ЮТКонтекст.ЗначениеКонтекста(ИмяКонтекстаОшибки());
Возврат ЗначениеКонтекста(ИмяКонтекстаОшибки());
КонецФункции
@ -133,7 +160,7 @@
// Неопределено, Структура - Контекст проверки
Функция КонтекстПроверки() Экспорт
Возврат ЮТКонтекст.ЗначениеКонтекста(ИмяКонтекстаУтверждений());
Возврат ЗначениеКонтекста(ИмяКонтекстаУтверждений());
КонецФункции
@ -143,7 +170,17 @@
// Неопределено, Структура - Контекст проверки
Функция КонтекстЧитателя() Экспорт
Возврат ЮТКонтекст.ЗначениеКонтекста(ИмяКонтекстаЧитателя());
Возврат ЗначениеКонтекста(ИмяКонтекстаЧитателя());
КонецФункции
// КонтекстЧитателя
// Возвращает служебный контекста, данные используемые исполнителем тестов
// Возвращаемое значение:
// см. ЮТИсполнитель.ДанныеКонтекстаИсполнения
Функция КонтекстИсполнения() Экспорт
Возврат ЗначениеКонтекста(ИмяКонтекстаИсполнения());
КонецФункции
@ -158,31 +195,49 @@
Процедура УстановитьКонтекстОшибки() Экспорт
ДанныеОшибки = ЮТФабрика.ОписаниеКонтекстаОшибки();
ЮТКонтекст.УстановитьЗначениеКонтекста(ИмяКонтекстаОшибки(), ДанныеОшибки);
УстановитьЗначениеКонтекста(ИмяКонтекстаОшибки(), ДанныеОшибки);
КонецПроцедуры
Процедура УстановитьКонтекстУтверждений(Знач ДанныеКонтекста) Экспорт
ЮТКонтекст.УстановитьЗначениеКонтекста(ИмяКонтекстаУтверждений(), ДанныеКонтекста);
УстановитьЗначениеКонтекста(ИмяКонтекстаУтверждений(), ДанныеКонтекста);
КонецПроцедуры
Процедура УстановитьКонтекстНабораТестов(Знач ДанныеКонтекста) Экспорт
ЮТКонтекст.УстановитьЗначениеКонтекста(ИмяКонтекстаНабораТестов(), ДанныеКонтекста);
УстановитьЗначениеКонтекста(ИмяКонтекстаНабораТестов(), ДанныеКонтекста);
КонецПроцедуры
Процедура УстановитьКонтекстМодуля(Знач ДанныеКонтекста) Экспорт
УстановитьЗначениеКонтекста(ИмяКонтекстаМодуля(), ДанныеКонтекста);
КонецПроцедуры
Процедура УстановитьКонтекстТеста(Знач ДанныеКонтекста) Экспорт
ЮТКонтекст.УстановитьЗначениеКонтекста(ИмяКонтекстаТеста(), ДанныеКонтекста);
УстановитьЗначениеКонтекста(ИмяКонтекстаТеста(), ДанныеКонтекста);
КонецПроцедуры
Процедура УстановитьКонтекстЧитателя(Знач ДанныеКонтекста, Знач УстановитьНаСервер = Ложь) Экспорт
Процедура УстановитьКонтекстЧитателя(Знач ДанныеКонтекста) Экспорт
ЮТКонтекст.УстановитьЗначениеКонтекста(ИмяКонтекстаЧитателя(), ДанныеКонтекста, УстановитьНаСервер);
УстановитьЗначениеКонтекста(ИмяКонтекстаЧитателя(), ДанныеКонтекста, Истина);
КонецПроцедуры
Процедура УстановитьКонтекстИсполнения(Знач ДанныеКонтекста) Экспорт
УстановитьЗначениеКонтекста(ИмяКонтекстаИсполнения(), ДанныеКонтекста, Истина);
КонецПроцедуры
Процедура УстановитьГлобальныеНастройкиВыполнения(Знач Настройки) Экспорт
УстановитьЗначениеКонтекста(ИмяГлобальныеНастройкиВыполнения(), Настройки, Истина);
КонецПроцедуры
@ -211,6 +266,12 @@
КонецФункции
Функция ИмяКонтекстаМодуля()
Возврат "КонтекстМодуля";
КонецФункции
Функция ИмяКонтекстаТеста()
Возврат "КонтекстТеста";
@ -223,4 +284,16 @@
КонецФункции
Функция ИмяГлобальныеНастройкиВыполнения()
Возврат "ГлобальныеНастройкиВыполнения";
КонецФункции
Функция ИмяКонтекстаИсполнения()
Возврат "КонтекстИсполнения";
КонецФункции
#КонецОбласти

93
exts/yaxunit/src/CommonModules/ЮТКонтекстТеста/Module.bsl Normal file
View File

@ -0,0 +1,93 @@
//©///////////////////////////////////////////////////////////////////////////©//
//
// Copyright 2021-2022 BIA-Technologies Limited Liability Company
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//©///////////////////////////////////////////////////////////////////////////©//
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции для служебного использования внутри подсистемы
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныйПрограммныйИнтерфейс
// Возвращает значение контекста
//
// Параметры:
// ИмяЗначения - Строка
//
// Возвращаемое значение:
// Произвольный
Функция Значение(ИмяЗначения) Экспорт
Уровень = ЮТКонтекст.КонтекстИсполнения().Уровень;
Уровни = ЮТФабрика.УровниИсполнения();
Если Уровень = Уровни.Тест И ЮТКонтекст.КонтекстТеста().Свойство(ИмяЗначения) Тогда
Возврат ЮТКонтекст.КонтекстТеста()[ИмяЗначения];
ИначеЕсли (Уровень = Уровни.Тест ИЛИ Уровень = Уровни.НаборТестов)
И ЮТКонтекст.КонтекстНабора().Свойство(ИмяЗначения) Тогда
Возврат ЮТКонтекст.КонтекстНабора()[ИмяЗначения];
ИначеЕсли (Уровень = Уровни.Тест ИЛИ Уровень = Уровни.НаборТестов ИЛИ Уровень = Уровни.Модуль)
И ЮТКонтекст.КонтекстМодуля().Свойство(ИмяЗначения) Тогда
Возврат ЮТКонтекст.КонтекстМодуля()[ИмяЗначения];
Иначе
Возврат Неопределено;
КонецЕсли;
КонецФункции
// Установить значение.
// Устанавливает значение в контекст тестов.
// Установка происходит в соответствии с уровнем исполнения
// Параметры:
// ИмяЗначения - Строка
// Значение - Произвольный
Процедура УстановитьЗначение(ИмяЗначения, Значение) Экспорт
Уровень = ЮТКонтекст.КонтекстИсполнения().Уровень;
Уровни = ЮТФабрика.УровниИсполнения();
Если Уровень = Уровни.Тест Тогда
ЮТКонтекст.КонтекстТеста().Вставить(ИмяЗначения, Значение);
ИначеЕсли Уровень = Уровни.НаборТестов Тогда
ЮТКонтекст.КонтекстНабора().Вставить(ИмяЗначения, Значение);
ИначеЕсли Уровень = Уровни.Модуль Тогда
ЮТКонтекст.КонтекстМодуля().Вставить(ИмяЗначения, Значение);
КонецЕсли;
КонецПроцедуры
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
// Процедуры и функции, составляющие внутреннюю реализацию модуля
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныеПроцедурыИФункции
#КонецОбласти

11
exts/yaxunit/src/CommonModules/ЮТКонтекстТеста/ЮТКонтекстТеста.mdo Normal file
View File

@ -0,0 +1,11 @@
<?xml version="1.0" encoding="UTF-8"?>
<mdclass:CommonModule xmlns:mdclass="http://g5.1c.ru/v8/dt/metadata/mdclass" uuid="c0983c71-269a-40ef-bd4d-3e08f4003d6c">
<name>ЮТКонтекстТеста</name>
<synonym>
<key>ru</key>
<value>Контекст теста</value>
</synonym>
<clientManagedApplication>true</clientManagedApplication>
<server>true</server>
<clientOrdinaryApplication>true</clientOrdinaryApplication>
</mdclass:CommonModule>

121
exts/yaxunit/src/CommonModules/ЮТОбщий/Module.bsl
View File

@ -427,67 +427,84 @@
КонецФункции
Функция ЗначениеВМассиве(Значение,
Значение2 = Неопределено,
Значение3 = Неопределено,
Значение4 = Неопределено,
Значение5 = Неопределено,
Значение6 = Неопределено,
Значение7 = Неопределено,
Значение8 = Неопределено,
Значение9 = Неопределено) Экспорт
Значение2 = "_!%*",
Значение3 = "_!%*",
Значение4 = "_!%*",
Значение5 = "_!%*",
Значение6 = "_!%*",
Значение7 = "_!%*",
Значение8 = "_!%*",
Значение9 = "_!%*",
Значение10 = "_!%*") Экспорт
Массив = Новый Массив;
Массив.Добавить(Значение);
Если Не Значение2 = Неопределено Тогда
Массив.Добавить(Значение2);
ФлагОкончания = "_!%*";
Значения = Новый Массив;
Если Значение <> ФлагОкончания Тогда
Значения.Добавить(Значение);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение3 = Неопределено Тогда
Массив.Добавить(Значение3);
Если Значение2 <> ФлагОкончания Тогда
Значения.Добавить(Значение2);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение4 = Неопределено Тогда
Массив.Добавить(Значение4);
Если Значение3 <> ФлагОкончания Тогда
Значения.Добавить(Значение3);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение5 = Неопределено Тогда
Массив.Добавить(Значение5);
Если Значение4 <> ФлагОкончания Тогда
Значения.Добавить(Значение4);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение6 = Неопределено Тогда
Массив.Добавить(Значение6);
Если Значение5 <> ФлагОкончания Тогда
Значения.Добавить(Значение5);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение7 = Неопределено Тогда
Массив.Добавить(Значение7);
Если Значение6 <> ФлагОкончания Тогда
Значения.Добавить(Значение6);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение8 = Неопределено Тогда
Массив.Добавить(Значение8);
Если Значение7 <> ФлагОкончания Тогда
Значения.Добавить(Значение7);
Иначе
Возврат Значения;
КонецЕсли;
Если Не Значение9 = Неопределено Тогда
Массив.Добавить(Значение9);
Если Значение8 <> ФлагОкончания Тогда
Значения.Добавить(Значение8);
Иначе
Возврат Значения;
КонецЕсли;
Возврат Массив;
Если Значение9 <> ФлагОкончания Тогда
Значения.Добавить(Значение9);
Иначе
Возврат Значения;
КонецЕсли;
Если Значение10 <> ФлагОкончания Тогда
Значения.Добавить(Значение10);
Иначе
Возврат Значения;
КонецЕсли;
Возврат Значения;
КонецФункции
@ -593,7 +610,7 @@
Алгоритм = ПолноеИмяМетода;
ИначеЕсли Параметры = Неопределено Тогда
ИначеЕсли НЕ ЗначениеЗаполнено(Параметры) Тогда
Алгоритм = ПолноеИмяМетода + "()";
@ -602,7 +619,7 @@
Алгоритм = "";
Для Инд = 0 По Параметры.ВГраница() Цикл
Алгоритм = ЮТОбщий.ДобавитьСтроку(Алгоритм, СтрШаблон("Параметры[%1]", Инд), ", ");
Алгоритм = ДобавитьСтроку(Алгоритм, СтрШаблон("Параметры[%1]", Инд), ", ");
КонецЦикла;
@ -741,6 +758,24 @@
КонецФункции
Процедура ВызовУстаревшегоМетода(УстаревшийМетод, РекомендуемыйМетод = Неопределено) Экспорт
Сообщение = СтрШаблон("Используется устаревший метод '%1'. В следующий релизах метод будет удален", УстаревшийМетод);
Если ЗначениеЗаполнено(РекомендуемыйМетод) Тогда
Сообщение = СтрШаблон("%1. Рекомендуется использовать '%2'", Сообщение, РекомендуемыйМетод);
КонецЕсли;
СообщитьПользователю(Сообщение);
КонецПроцедуры
Функция УстановленБезопасныйРежим() Экспорт
Возврат ЮТОбщийВызовСервера.УстановленБезопасныйРежим();
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////

6
exts/yaxunit/src/CommonModules/ЮТОбщийВызовСервера/Module.bsl
View File

@ -42,6 +42,12 @@
КонецФункции
Функция УстановленБезопасныйРежим() Экспорт
Возврат БезопасныйРежим();
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////

2
exts/yaxunit/src/CommonModules/ЮТОтчетJUnit/Module.bsl
View File

@ -147,7 +147,7 @@
КонецЕсли;
КонецЕсли;
Если ЗаписатьСтек Тогда
Если ЗаписатьСтек И ОписаниеОшибки.Стек <> Неопределено Тогда
ЗаписьXML.ЗаписатьТекст(ОписаниеОшибки.Стек);
КонецЕсли;

33
exts/yaxunit/src/CommonModules/ЮТПараметры/Module.bsl
View File

@ -28,7 +28,7 @@
// ПараметрыЗапускаСтрокой - Строка - Параметры запуска приложения
//
// Возвращаемое значение:
// Структура - Загруженные параметры запуска, см. ЮТФабрика.ПараметрыЗапуска
// см. ЮТФабрика.ПараметрыЗапуска
Функция ПараметрыЗапуска(Знач ПараметрыЗапускаСтрокой) Экспорт
Попытка
@ -54,6 +54,27 @@
#Область СлужебныйПрограммныйИнтерфейс
Функция ЗначениеНастройкиТеста(ИмяНастройки, ОписаниеТеста, ОписаниеТестовогоНабора, ЗначениеПоУмолчанию) Экспорт
Значение = ЗначениеПоУмолчанию;
Если ОписаниеТеста.НастройкиВыполнения.Свойство(ИмяНастройки) Тогда
Значение = ОписаниеТеста.НастройкиВыполнения[ИмяНастройки];
ИначеЕсли ОписаниеТестовогоНабора.НастройкиВыполнения.Свойство(ИмяНастройки) Тогда
Значение = ОписаниеТестовогоНабора.НастройкиВыполнения[ИмяНастройки];
Иначе
ГлобальныеНастройки = ЮТКонтекст.ГлобальныеНастройкиВыполнения();
Если ГлобальныеНастройки.Свойство(ИмяНастройки) Тогда
Значение = ГлобальныеНастройки[ИмяНастройки];
КонецЕсли;
КонецЕсли;
Возврат Значение;
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
@ -70,7 +91,7 @@
// Формат строки "RunUnitTests=/путь/к/конфигурационному/файлу", где ключ указывается обязательно, а путь - по желанию
//
// Возвращаемое значение:
// Структура - Прочитанные параметры. См. Параметры
// см. ЮТФабрика.ПараметрыЗапуска
Функция ПрочитатьПараметрыЗапуска(Знач ПараметрыЗапускаСтрокой)
Параметры = ЮТФабрика.ПараметрыЗапуска();
@ -124,7 +145,11 @@
Функция ПрочитатьКонфигурационныйФайл(ПутьКФайлу)
#Если НЕ ВебКлиент Тогда
Если ЮТОбщий.УстановленБезопасныйРежим() Тогда
ВызватьИсключение "Раширение подключено в безопасном режиме. Чтение конфигурационного файла недоступно";
КонецЕсли;
Файл = Новый Файл(ПутьКФайлу);
Если Не Файл.Существует() Тогда
@ -138,7 +163,7 @@
Текст = ЮТОбщий.ДанныеТекстовогоФайла(ПутьКФайлу);
Если ЗначениеЗаполнено(Текст) Тогда
ДанныеФайла = ЮТПараметрыСервер.ПрочитатьКонфигурационныйФайл(Текст);
ДанныеФайла = ЮТОбщий.ЗначениеИзJSON(Текст);
КонецЕсли;
Исключение

76
exts/yaxunit/src/CommonModules/ЮТРегистрацияОшибок/Module.bsl
View File

@ -22,13 +22,15 @@
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
#Область ФиксацияОшибокВРезультате
// Регистрирует ошибку обработки события исполнения тестов
//
// Параметры:
// ИмяСобытия - Строка
// ОписаниеСобытия - см. ЮТФабрика.ОписаниеСобытияИсполненияТестов
// Ошибка - ИнформацияОбОшибке
Процедура ЗарегистрироватьОшибкуСобытия(ИмяСобытия, ОписаниеСобытия, Ошибка) Экспорт
Процедура ЗарегистрироватьОшибкуСобытияИсполнения(ИмяСобытия, ОписаниеСобытия, Ошибка) Экспорт
ТипОшибки = ЮТФабрика.ТипыОшибок().ОшибкаОбработкиСобытия;
Пояснение = СтрШаблон("%1 '%2': %3", ТипОшибки, ИмяСобытия, Ошибка.Описание);
@ -69,6 +71,8 @@
Если ТипОшибки = ЮТФабрика.ТипыОшибок().Утверждений Тогда
ДанныеОшибки = ДанныеОшибкиУтверждений(Ошибка);
ИначеЕсли ТипОшибки = ЮТФабрика.ТипыОшибок().Пропущен Тогда
ДанныеОшибки = ДанныеОшибкиПропуска(Ошибка);
Иначе
ДанныеОшибки = ДанныеОшибки(Ошибка, Ошибка.Описание, ТипОшибки);
КонецЕсли;
@ -88,6 +92,8 @@
КонецПроцедуры
#КонецОбласти
// Вызввает ошибку выполнения теста, на основании перехваченной ошибки
//
// Параметры:
@ -132,6 +138,16 @@
КонецПроцедуры
Процедура Пропустить(Сообщение) Экспорт
СтруктураОшибки = ЮТКонтекст.КонтекстОшибки();
СтруктураОшибки.ОшибкаУтверждения = Ложь;
СообщениеОбОшибке = СообщениеОбОшибке(Сообщение, ПрефиксОшибкиПропуска());
ВызватьИсключение СообщениеОбОшибке;
КонецПроцедуры
Функция ПредставлениеОшибки(Знач Описание, Знач Ошибка) Экспорт
Если ТипЗнч(Ошибка) = Тип("ИнформацияОбОшибке") Тогда
@ -199,6 +215,10 @@
ТипОшибки = ТипыОшибок.Утверждений;
ИначеЕсли СтрНачинаетсяС(Описание, ПрефиксОшибкиПропуска()) Тогда
ТипОшибки = ТипыОшибок.Пропущен;
Иначе
ТипОшибки = ТипыОшибок.Исполнения;
@ -221,7 +241,13 @@
КонецФункции
Функция СтатусВыполненияТеста(Тест) Экспорт
Функция ПрефиксОшибкиПропуска() Экспорт
Возврат "[Skip]";
КонецФункции
Функция СтатусВыполненияТеста(Тест) Экспорт
СтатусыИсполненияТеста = ЮТФабрика.СтатусыИсполненияТеста();
@ -297,11 +323,12 @@
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныеПроцедурыИФункции
#Область КонструкторыОписанийОшибки
Функция ДанныеОшибки(Ошибка, Сообщение, ТипОшибки)
ДанныеОшибки = ЮТФабрика.ОписаниеВозникшейОшибки();
ДанныеОшибки = ЮТФабрика.ОписаниеВозникшейОшибки(ТипОшибки + ": " + Сообщение);
ДанныеОшибки.Сообщение = ТипОшибки + ": " + Сообщение;
Если Ошибка <> Неопределено Тогда
ДанныеОшибки.Стек = ПодробноеПредставлениеОшибки(Ошибка);
КонецЕсли;
@ -314,18 +341,10 @@
Функция ДанныеОшибкиУтверждений(Ошибка)
ДлинаПрефикса = СтрДлина(ПрефиксОшибкиУтверждений());
Описание = ИзвлечьТекстОшибки(Ошибка, ПрефиксОшибкиУтверждений());
Описание = Сред(Ошибка.Описание, ДлинаПрефикса + 1);
Описание = СокрЛП(Описание);
ДанныеОшибки = ЮТФабрика.ОписаниеОшибкиСравнения(Описание);
Если СтрНачинаетсяС(Описание, "<") И СтрЗаканчиваетсяНа(Описание, ">") Тогда
Описание = Сред(Описание, 2, СтрДлина(Описание) - 2);
КонецЕсли;
ДанныеОшибки = ЮТФабрика.ОписаниеОшибкиСравнения();
ДанныеОшибки.Сообщение = Описание;
ДанныеОшибки.Стек = ПодробноеПредставлениеОшибки(Ошибка);
ДобавитьСообщенияПользователю(ДанныеОшибки);
@ -340,7 +359,34 @@
КонецФункции
Функция МодулиУтверждений()
Функция ДанныеОшибкиПропуска(Ошибка)
Описание = ИзвлечьТекстОшибки(Ошибка, ПрефиксОшибкиПропуска());
ДанныеОшибки = ЮТФабрика.ОписаниеОшибкиПропуска(Описание);
Возврат ДанныеОшибки;
КонецФункции
Функция ИзвлечьТекстОшибки(Ошибка, Префикс)
ДлинаПрефикса = СтрДлина(Префикс);
Описание = Сред(Ошибка.Описание, ДлинаПрефикса + 1);
Описание = СокрЛП(Описание);
Если СтрНачинаетсяС(Описание, "<") И СтрЗаканчиваетсяНа(Описание, ">") Тогда
Описание = Сред(Описание, 2, СтрДлина(Описание) - 2);
КонецЕсли;
Возврат Описание;
КонецФункции
#КонецОбласти
Функция МодулиУтверждений()
Возврат ЮТОбщий.ЗначениеВМассиве("ЮТУтверждения");

102
exts/yaxunit/src/CommonModules/ЮТСобытия/Module.bsl
View File

@ -29,12 +29,23 @@
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныйПрограммныйИнтерфейс
Процедура Инициализация(ПараметрыЗапуска) Экспорт
Параметры = ЮТОбщий.ЗначениеВМассиве(ПараметрыЗапуска);
ВызватьОбработчикРасширения("Инициализация", Параметры);
КонецПроцедуры
#Область СобытияИсполненияТестов
// Обработчик события "ПередВсемиТестамиМодуля"
//
// Параметры:
// ТестовыйМодуль - см. ЮТФабрика.ОписаниеТестовогоМодуля
Процедура ПередВсемиТестамиМодуля(ТестовыйМодуль) Экспорт
ЮТКонтекст.УстановитьКонтекстМодуля(Новый Структура());
ОписаниеСобытия = ЮТФабрика.ОписаниеСобытияИсполненияТестов(ТестовыйМодуль);
ВызватьОбработкуСобытия("ПередВсемиТестами", ОписаниеСобытия);
@ -54,13 +65,13 @@
КонецПроцедуры
// Обработчик события "ПередТестом"
// Обработчик события "ПередКаждымТестом"
//
// Параметры:
// ТестовыйМодуль - см. ЮТФабрика.ОписаниеТестовогоМодуля
// Набор - см. ЮТФабрика.ОписаниеИсполняемогоНабораТестов
// Тест - см. ЮТФабрика.ОписаниеИсполняемогоТеста
Процедура ПередТестом(ТестовыйМодуль, Набор, Тест) Экспорт
Процедура ПередКаждымТестом(ТестовыйМодуль, Набор, Тест) Экспорт
ОписаниеСобытия = ЮТФабрика.ОписаниеСобытияИсполненияТестов(ТестовыйМодуль, Набор, Тест);
ЮТКонтекст.УстановитьКонтекстТеста(Новый Структура());
@ -75,21 +86,23 @@
КонецЕсли;
#КонецЕсли
ВызватьОбработкуСобытия("ПередКаждымТестом", ОписаниеСобытия);
ВызватьОбработкуСобытия("ПередТестом", ОписаниеСобытия);
КонецПроцедуры
// Обработчик события "ПослеТеста"
// Обработчик события "ПослеКаждогоТеста"
//
// Параметры:
// ТестовыйМодуль - см. ЮТФабрика.ОписаниеТестовогоМодуля
// Набор - см. ЮТФабрика.ОписаниеИсполняемогоНабораТестов
// Тест - см. ЮТФабрика.ОписаниеИсполняемогоТеста
Процедура ПослеТеста(ТестовыйМодуль, Набор, Тест) Экспорт
Процедура ПослеКаждогоТеста(ТестовыйМодуль, Набор, Тест) Экспорт
ОписаниеСобытия = ЮТФабрика.ОписаниеСобытияИсполненияТестов(ТестовыйМодуль, Набор, Тест);
ВызватьОбработкуСобытия("ПослеТеста", ОписаниеСобытия);
ВызватьОбработкуСобытия("Послееста", ОписаниеСобытия);
ВызватьОбработкуСобытия("ПослеКаждогоТеста", ОписаниеСобытия);
#Если Сервер ИЛИ ТолстыйКлиентОбычноеПриложение ИЛИ ТолстыйКлиентУправляемоеПриложение Тогда
Если ВТранзакции(ОписаниеСобытия) Тогда
@ -126,20 +139,35 @@
КонецПроцедуры
Процедура ВызватьОбработкуСобытия(ИмяСобытия, ОписаниеСобытия)
#КонецОбласти
#Область СобытияЗагрузкиТестов
// Обработчик события "ПередЧтениемСценариевМодуля"
// Позволяет настроить базовые параметры перед чтением настроек тестов модуля
// Параметры:
// МетаданныеМодуля - см. ЮТФабрика.ОписаниеМодуля
Процедура ПередЧтениемСценариевМодуля(МетаданныеМодуля) Экспорт
ЭтоСобытиеПеред = СтрНачинаетсяС(ИмяСобытия, "Перед");
Если ЭтоСобытиеПеред Тогда
ВызватьОбработчикРасширения(ИмяСобытия, ОписаниеСобытия);
ВызватьОбработчикТестовогоМодуля(ИмяСобытия, ОписаниеСобытия);
Иначе
ВызватьОбработчикТестовогоМодуля(ИмяСобытия, ОписаниеСобытия);
ВызватьОбработчикРасширения(ИмяСобытия, ОписаниеСобытия);
КонецЕсли;
Параметры = ЮТОбщий.ЗначениеВМассиве(МетаданныеМодуля);
ВызватьОбработчикРасширения("ПередЧтениемСценариевМодуля", Параметры);
КонецПроцедуры
// После чтения сценариев модуля.
// Позволяет настроить/обработать параметры загруженных настроек тестов модуля
// Параметры:
// МетаданныеМодуля - см. ЮТФабрика.ОписаниеМодуля
// ИсполняемыеСценарии - см. ЮТТесты.СценарииМодуля
Процедура ПослеЧтенияСценариевМодуля(МетаданныеМодуля, ИсполняемыеСценарии) Экспорт
Параметры = ЮТОбщий.ЗначениеВМассиве(МетаданныеМодуля, ИсполняемыеСценарии);
ВызватьОбработчикРасширения("ПослеЧтенияСценариевМодуля", Параметры);
КонецПроцедуры
#КонецОбласти
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
@ -147,22 +175,46 @@
/////////////////////////////////////////////////////////////////////////////////
#Область СлужебныеПроцедурыИФункции
Процедура ВызватьОбработчикРасширения(ИмяСобытия, ОписаниеСобытия)
Процедура ВызватьОбработкуСобытия(ИмяСобытия, ОписаниеСобытия)
ЭтоСобытиеПеред = СтрНачинаетсяС(ИмяСобытия, "Перед");
Параметры = ЮТОбщий.ЗначениеВМассиве(ОписаниеСобытия);
Если ЭтоСобытиеПеред Тогда
Ошибки = ВызватьОбработчикРасширения(ИмяСобытия, Параметры);
ВызватьОбработчикТестовогоМодуля(ИмяСобытия, ОписаниеСобытия);
Иначе
ВызватьОбработчикТестовогоМодуля(ИмяСобытия, ОписаниеСобытия);
Ошибки = ВызватьОбработчикРасширения(ИмяСобытия, Параметры);
КонецЕсли;
Для Каждого Ошибка Из Ошибки Цикл
ЮТРегистрацияОшибок.ЗарегистрироватьОшибкуСобытияИсполнения(ИмяСобытия, ОписаниеСобытия, Ошибка);
КонецЦикла;
КонецПроцедуры
Функция ВызватьОбработчикРасширения(ИмяСобытия, ПараметрыСобытия)
Ошибки = Новый Массив();
Для Каждого ИмяМодуля Из ЮТРасширения.ОбработчикиСобытий() Цикл
Если ЮТОбщий.МетодМодуляСуществует(ИмяМодуля, ИмяСобытия) Тогда
ПолноеИмяМетода = СтрШаблон("%1.%2", ИмяМодуля, ИмяСобытия);
Ошибка = ЮТОбщий.ВыполнитьМетод(ПолноеИмяМетода, ЮТОбщий.ЗначениеВМассиве(ОписаниеСобытия));
Ошибка = ЮТОбщий.ВыполнитьМетод(ПолноеИмяМетода, ПараметрыСобытия);
КонецЕсли;
Если Ошибка <> Неопределено Тогда
ЮТРегистрацияОшибок.ЗарегистрироватьОшибкуСобытия(ИмяСобытия, ОписаниеСобытия, Ошибка);
Ошибки.Добавить(Ошибка);
КонецЕсли;
КонецЦикла;
КонецПроцедуры
Возврат Ошибки;
КонецФункции
// Вызвать обработчик модуля.
//
@ -182,7 +234,7 @@
КонецЕсли;
Если Ошибка <> Неопределено Тогда
ЮТРегистрацияОшибок.ЗарегистрироватьОшибкуСобытия(ИмяСобытия, ОписаниеСобытия, Ошибка);
ЮТРегистрацияОшибок.ЗарегистрироватьОшибкуСобытияИсполнения(ИмяСобытия, ОписаниеСобытия, Ошибка);
КонецЕсли;
КонецПроцедуры
@ -191,15 +243,7 @@
ИмяПараметра = ЮТФабрика.ПараметрыИсполненияТеста().ВТранзакции;
Если ОписаниеСобытия.Тест.НастройкиВыполнения.Свойство(ИмяПараметра) Тогда
ВТранзакции = ОписаниеСобытия.Тест.НастройкиВыполнения[ИмяПараметра];
ИначеЕсли ОписаниеСобытия.Набор.НастройкиВыполнения.Свойство(ИмяПараметра) Тогда
ВТранзакции = ОписаниеСобытия.Набор.НастройкиВыполнения[ИмяПараметра];
Иначе
ВТранзакции = Ложь;
КонецЕсли;
Возврат ВТранзакции;
Возврат ЮТПараметры.ЗначениеНастройкиТеста(ИмяПараметра, ОписаниеСобытия.Тест, ОписаниеСобытия.Набор, Ложь);
КонецФункции

20
exts/yaxunit/src/CommonModules/ЮТТестовыеДанные/Module.bsl
View File

@ -314,18 +314,6 @@
КонецФункции
// Варианты.
//
// Параметры:
// Реквизиты - Строка - Реквизиты
//
// Возвращаемое значение:
// ОбщийМодуль
Функция Варианты(Реквизиты) Экспорт
Возврат ЮТКонструкторВариантов.Варианты(Реквизиты);
КонецФункции
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
// Экспортные процедуры и функции для служебного использования внутри подсистемы
@ -333,21 +321,21 @@
#Область СлужебныйПрограммныйИнтерфейс
// Обработчик события "ПередТестом"
// Обработчик события "ПередКаждымТестом"
//
// Параметры:
// ОписаниеСобытия - см. ЮТФабрика.ОписаниеСобытияИсполненияТестов
Процедура ПередТестом(ОписаниеСобытия) Экспорт
Процедура ПередКаждымТестом(ОписаниеСобытия) Экспорт
ЮТКонтекст.КонтекстТеста().Вставить("ВременныеФайлы", Новый Массив);
КонецПроцедуры
// Обработчик события "ПослеТеста"
// Обработчик события "ПослеКаждогоТеста"
//
// Параметры:
// ОписаниеСобытия - см. ЮТФабрика.ОписаниеСобытияИсполненияТестов
Процедура ПослеТеста(ОписаниеСобытия) Экспорт
Процедура ПослеКаждогоТеста(ОписаниеСобытия) Экспорт
ВременныеФайлы = ЮТКонтекст.КонтекстТеста().ВременныеФайлы;

215
exts/yaxunit/src/CommonModules/ЮТТесты/Module.bsl
View File

@ -26,15 +26,15 @@
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
// ТестовыйНабор
// ДобавитьТестовыйНабор
// Создает и регистрирует набор, в который будут добавлятся последующие тесты
// Параметры:
// Имя - Строка - Имя набора тестов
// ТегиСтрокой - Строка - Теги относящиеся к набору и вложенным тестам. Это строка разделенная запятыми
//
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
Функция ТестовыйНабор(Имя, ТегиСтрокой = "") Экспорт
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ДобавитьТестовыйНабор(Имя, ТегиСтрокой = "") Экспорт
ИсполняемыеСценарии = СценарииМодуля();
@ -49,7 +49,7 @@
Контекст = Контекст();
НовыйТестовыйНабор = ЮТФабрика.ОписаниеТестовогоНабора(Имя, ТегиСтрокой);
ИсполняемыеСценарии.ТестовыеНаборы.Вставить(Имя, НовыйТестовыйНабор);
ИсполняемыеСценарии.ТестовыеНаборы.Добавить(НовыйТестовыйНабор);
Контекст.ТекущийНабор = НовыйТестовыйНабор;
Контекст.ТекущийЭлемент = НовыйТестовыйНабор;
@ -57,8 +57,11 @@
КонецФункции
// Тест
// Регистрирует тест
// ДобавитьТест
// Регистрирует тест, исполняемый в контекстах, в которых доступен тестовый модуль
// Напрмер если модуль с тестами клиент-серверный, то тест будет вызван и на клиенте и на сервере
// Если клиентский, то только на клиенте
// Если клиент обычное приложение, то только при запуске в режиме обычного приложения
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
@ -66,8 +69,8 @@
// Контексты - Строка - Контексты, строка перечисления контекстов вызова, разделенных запятой.
// Возможные значения см. ЮТФабрика.КонтекстыВызова
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
Функция Тест(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "", Контексты = Неопределено) Экспорт
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ДобавитьТест(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "", Контексты = Неопределено) Экспорт
Контекст = Контекст();
Набор = Контекст.ТекущийНабор;
@ -91,33 +94,31 @@
КонецФункции
// ТестКлиент
// Регистрирует текст вызывемый на клиенте
// ДобавитьКлиентскийТест
// Регистрирует текст исполняемый на клиенте
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
// ТегиСтрокой - Строка - Теги строкой. Это строка разделенная запятыми
//
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
Функция ТестКлиент(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
Тест(ИмяТестовогоМетода, ПредставлениеТеста, ТегиСтрокой, КонтекстыВызоваКлиента());
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ДобавитьКлиентскийТест(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
ДобавитьТест(ИмяТестовогоМетода, ПредставлениеТеста, ТегиСтрокой, КонтекстыВызоваКлиента());
Возврат ЮТТесты;
КонецФункции
// Тест сервер.
// Регистрирует текст вызывемый на сервере
// Регистрирует текст исполняемый на сервере
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
// ТегиСтрокой - Строка - Теги строкой. Это строка разделенная запятыми
//
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
Функция ТестСервер(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ДобавитьСерверныйТест(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
Режимы = ЮТФабрика.КонтекстыВызова();
@ -134,7 +135,7 @@
// Значение - Произвольный - Значение настройки
//
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
// ОбщийМодуль - Этот же модуль, для замыкания
Функция НастройкаИсполнения(ИмяПараметра, Значение) Экспорт
Контекст = Контекст();
@ -155,7 +156,7 @@
// ВыполнятьВТранзакции - Булево
//
// Возвращаемое значение:
// CommonModule.ЮТТесты - Этот же модуль, для замыкания
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ВТранзакции(ВыполнятьВТранзакции = Истина) Экспорт
НастройкаИсполнения(ЮТФабрика.ПараметрыИсполненияТеста().ВТранзакции, ВыполнятьВТранзакции);
@ -164,6 +165,110 @@
КонецФункции
Функция СПараметрами(Параметр1 = "_!%*",
Параметр2 = "_!%*",
Параметр3 = "_!%*",
Параметр4 = "_!%*",
Параметр5 = "_!%*",
Параметр6 = "_!%*",
Параметр7 = "_!%*",
Параметр8 = "_!%*",
Параметр9 = "_!%*",
Параметр10 = "_!%*") Экспорт
Параметры = ЮТОбщий.ЗначениеВМассиве(Параметр1,
Параметр2,
Параметр3,
Параметр4,
Параметр5,
Параметр6,
Параметр7,
Параметр8,
Параметр9,
Параметр10);
Контекст = Контекст();
Если Контекст.ТекущийЭлемент = Неопределено Тогда
ВызватьИсключение "Не инициализированы настройки регистрации тестов";
ИначеЕсли НЕ ЭтоОписаниеТеста(Контекст.ТекущийЭлемент) Тогда
ВызватьИсключение "Параметры устанавливаются только для теста";
КонецЕсли;
Контекст.ТекущийЭлемент.Параметры = Параметры;
Возврат ЮТТесты;
КонецФункции
#Область Устаревшие
// Тест
// Регистрирует тест
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
// ТегиСтрокой - Строка - Теги строкой. Это строка разделенная запятыми
// Контексты - Строка - Контексты, строка перечисления контекстов вызова, разделенных запятой.
// Возможные значения см. ЮТФабрика.КонтекстыВызова
// Возвращаемое значение:
// ОбщийМодуль - Этот же модуль, для замыкания
Функция Тест(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "", Контексты = Неопределено) Экспорт
ЮТОбщий.ВызовУстаревшегоМетода("ЮТТесты.Тест", "ЮТТесты.ДобавитьТест");
Возврат ДобавитьТест(ИмяТестовогоМетода, ПредставлениеТеста, ТегиСтрокой, Контексты);
КонецФункции
// ТестКлиент
// Регистрирует текст вызывемый на клиенте
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
// ТегиСтрокой - Строка - Теги строкой. Это строка разделенная запятыми
//
// Возвращаемое значение:
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ТестКлиент(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
ЮТОбщий.ВызовУстаревшегоМетода("ЮТТесты.ТестКлиент", "ЮТТесты.ДобавитьКлиентскийТест");
Возврат ДобавитьКлиентскийТест(ИмяТестовогоМетода, ПредставлениеТеста, ТегиСтрокой);
КонецФункции
// Тест сервер.
// Регистрирует текст вызывемый на сервере
// Параметры:
// ИмяТестовогоМетода - Строка - Имя тестового метода
// ПредставлениеТеста - Строка - Представление теста
// ТегиСтрокой - Строка - Теги строкой. Это строка разделенная запятыми
//
// Возвращаемое значение:
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ТестСервер(ИмяТестовогоМетода, ПредставлениеТеста = "", ТегиСтрокой = "") Экспорт
ЮТОбщий.ВызовУстаревшегоМетода("ЮТТесты.ТестСервер", "ЮТТесты.ДобавитьСерверныйТест");
Возврат ДобавитьСерверныйТест(ИмяТестовогоМетода, ПредставлениеТеста, ТегиСтрокой);
КонецФункции
// ТестовыйНабор
// Создает и регистрирует набор, в который будут добавлятся последующие тесты
// Параметры:
// Имя - Строка - Имя набора тестов
// ТегиСтрокой - Строка - Теги относящиеся к набору и вложенным тестам. Это строка разделенная запятыми
//
// Возвращаемое значение:
// ОбщийМодуль - Этот же модуль, для замыкания
Функция ТестовыйНабор(Имя, ТегиСтрокой = "") Экспорт
ЮТОбщий.ВызовУстаревшегоМетода("ЮТТесты.ТестовыйНабор", "ЮТТесты.ДобавитьТестовыйНабор");
Возврат ДобавитьТестовыйНабор(Имя, ТегиСтрокой);
КонецФункции
#КонецОбласти
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
@ -176,6 +281,15 @@
ИнициализироватьКонтекст(МетаданныеМодуля);
ЮТСобытия.ПередЧтениемСценариевМодуля(МетаданныеМодуля);
КонецПроцедуры
Процедура ПослеЧтенияСценариевМодуля() Экспорт
Контекст = Контекст();
ЮТСобытия.ПослеЧтенияСценариевМодуля(Контекст.МетаданныеМодуля, Контекст.ИсполняемыеСценарии);
КонецПроцедуры
// Описание сценариев модуля
@ -198,18 +312,19 @@
// Исполняемые сценарии.
//
// Параметры:
// МетаданныеМодуля - см. ЮТФабрика.ОписаниеМодуля
//
// Возвращаемое значение:
// Структура - Исполняемые сценарии:
// * ТестовыеНаборы - Соответствие - Тестовые наборы модуля
// * Ключ - Строка - Имя тестового набора
// * Значение - см. ЮТФабрика.ОписаниеТестовогоНабора
Функция ИсполняемыеСценарии()
// Структура -- Исполняемые сценарии::
// * ТестовыеНаборы - Массив из см. ЮТФабрика.ОписаниеТестовогоНабора - Тестовые наборы модуля
Функция ИсполняемыеСценарии(МетаданныеМодуля)
Структура = Новый Структура;
Структура.Вставить("ТестовыеНаборы", Новый Соответствие);
Структура.Вставить("ТестовыеНаборы", Новый Массив());
НаборПоУмолчанию = ЮТФабрика.ОписаниеТестовогоНабора("Тесты");
Структура.ТестовыеНаборы.Вставить(НаборПоУмолчанию.Имя, НаборПоУмолчанию);
Набор = ЮТФабрика.ОписаниеТестовогоНабора(МетаданныеМодуля.Имя);
Структура.ТестовыеНаборы.Добавить(Набор);
Возврат Структура;
@ -218,14 +333,13 @@
Функция КонтекстыВызоваКлиента()
Режимы = ЮТФабрика.КонтекстыВызова();
Возврат СтрШаблон("%1, %2", Режимы.КлиентУправляемоеПриложение, Режимы.КлиентОбычноеПриложение);
Возврат ЮТОбщий.ЗначениеВМассиве(Режимы.КлиентУправляемоеПриложение, Режимы.КлиентОбычноеПриложение);
КонецФункции
Функция КонтекстыВызоваПоУмолчанию()
Возврат СтрСоединить(ЮТФабрика.КонтекстыМодуля(Контекст().МетаданныеМодуля), ", ");
Возврат ЮТФабрика.КонтекстыМодуля(Контекст().МетаданныеМодуля);
КонецФункции
@ -233,6 +347,8 @@
Если НЕ ЗначениеЗаполнено(Контексты) Тогда
Контексты = КонтекстыВызоваПоУмолчанию();
ИначеЕсли ТипЗнч(Контексты) = Тип("Строка") Тогда
Контексты = СтрРазделить(Контексты, ", ", Ложь);
КонецЕсли;
Возврат ЮТФабрика.ОписаниеТеста(Имя, Представление, Контексты, ТегиСтрокой);
@ -242,7 +358,7 @@
Функция ЭтоИсполняемыеСценарии(ИсполняемыеСценарии)
Возврат ТипЗнч(ИсполняемыеСценарии) = Тип("Структура")
И ТипЗнч(ЮТОбщий.ЗначениеСтруктуры(ИсполняемыеСценарии, "ТестовыеНаборы")) = Тип("Соответствие");
И ТипЗнч(ЮТОбщий.ЗначениеСтруктуры(ИсполняемыеСценарии, "ТестовыеНаборы")) = Тип("Массив");
КонецФункции
@ -260,12 +376,6 @@
КонецФункции
Функция ТестовыйНаборПоУмолчанию(ИсполняемыеСценарии)
Возврат ИсполняемыеСценарии.ТестовыеНаборы["Тесты"];
КонецФункции
#Область Контекст
Функция Контекст()
@ -276,27 +386,8 @@
Процедура ИнициализироватьКонтекст(МетаданныеМодуля)
КонтекстРегистрации = ОписаниеКонтекстаРегистрацииСценариев(МетаданныеМодуля);
ЮТКонтекст.УстановитьЗначениеКонтекста("КонтекстРегистрацияТестов", КонтекстРегистрации);
КонецПроцедуры
// Описание контекста регистрации сценариев.
//
// Параметры:
// МетаданныеМодуля - Структура - Метаданные модуля, см. ЮТФабрика.ОписаниеМодуля
//
// Возвращаемое значение:
// Структура - Описание контекста регистрации сценариев:
// * МетаданныеМодуля - см. ЮТФабрика.ОписаниеМодуля
// * ИсполняемыеСценарии - Структура -:
// ** ТестовыеНаборы - Соответствие -
Функция ОписаниеКонтекстаРегистрацииСценариев(МетаданныеМодуля)
ИсполняемыеСценарии = ИсполняемыеСценарии();
Набор = ТестовыйНаборПоУмолчанию(ИсполняемыеСценарии);
Набор.Представление = МетаданныеМодуля.Имя;
ИсполняемыеСценарии = ИсполняемыеСценарии(МетаданныеМодуля);
Набор = ИсполняемыеСценарии.ТестовыеНаборы[0];
Контекст = Новый Структура();
@ -305,9 +396,9 @@
Контекст.Вставить("ТекущийНабор", Набор);
Контекст.Вставить("ТекущийЭлемент", Набор);
Возврат Контекст;
КонецФункции
ЮТКонтекст.УстановитьЗначениеКонтекста("КонтекстРегистрацияТестов", Контекст);
КонецПроцедуры
#КонецОбласти

207
exts/yaxunit/src/CommonModules/ЮТУтверждения/Module.bsl
View File

@ -115,19 +115,48 @@
УстановитьОписаниеПроверки(ОписаниеПроверки);
Контекст = Контекст();
Контекст.ИмяСвойства = ""; // Очищаем для формирования корректного сообщения об ошибке
Контекст.ИмяСвойства = Неопределено; // Очищаем для формирования корректного сообщения об ошибке
ЭтоДействительнаяЦепочкаСвойств(Контекст.ПроверяемоеЗначение, ИмяСвойства, Истина);
Путь = НормализованныйПутьКСвойству(Контекст.ПроверяемоеЗначение, ИмяСвойства, Истина);
Контекст.ИмяСвойства = ИмяСвойства;
Контекст.НормализованныйПутьКСвойству = Путь;
Возврат ЮТУтверждения;
КонецФункции
// Проверяет наличие элемента с указанным индексом и позиционируется на нем для последующих проверок
//
// Параметры:
// Индекс - Число - Индекс элемента коллекции
// ОписаниеПроверки - Строка - Описание конкретной проверки
//
// Возвращаемое значение:
// ОбщийМодуль - Этот модуль для замыкания
Функция Элемент(Знач Индекс, Знач ОписаниеПроверки = Неопределено) Экспорт
Возврат Свойство(Индекс, ОписаниеПроверки);
КонецФункции
// Используется после вызова метода "Свойство", для переключения с ранее указанного свойства на объект
//
// Возвращаемое значение:
// ОбщийМодуль - Этот модуль для замыкания
Функция Объект() Экспорт
Контекст = Контекст();
Контекст.ИмяСвойства = Неопределено;
Возврат ЮТУтверждения;
КонецФункции
// НетСвойства
// Проверяет отсутствие свойства
//
// Проверяет отсутствие свойства основного объекта
// И сбрасывает ранее установленное проверяемое свойство
//
// Параметры:
// ИмяСвойства - Строка - Наименование свойства объекта.
// Возможно обращение к вложенным свойствам через точку
@ -139,8 +168,10 @@
УстановитьОписаниеПроверки(ОписаниеПроверки);
Контекст = Контекст();
Контекст.ИмяСвойства = Неопределено; // Очищаем для формирования корректного сообщения об ошибке
Если ЭтоДействительнаяЦепочкаСвойств(Контекст.ПроверяемоеЗначение, ИмяСвойства, Ложь) Тогда
Путь = НормализованныйПутьКСвойству(Контекст.ПроверяемоеЗначение, ИмяСвойства, Ложь);
Если Путь <> Неопределено Тогда
ЮТРегистрацияОшибок.СгенерироватьОшибкуСравнения(СтрШаблон("не содержит свойство `%1`", ИмяСвойства), Неопределено, ИмяСвойства);
КонецЕсли;
@ -792,11 +823,42 @@
КонецПроцедуры
// Обработчик события "ПередТестом"
// Инициализирует контекст утверждений
//
// Возвращаемое значение:
// Структура - контекст утверждений:
// * ПроверяемоеЗначение - Произвольный
// * ПредставлениеПроверяемогоЗначения - Строка
// * ПрефиксОшибки - Строка
// * ИмяМетода - Строка
// * ИмяСвойства - Строка
// * НормализованныйПутьКСвойству - Неопределено - Не указано свойство
// - Массив из Строка, Число
// * ПараметрыМетода - Неопределено - Не установлены
// - Массив из Произвольный
// * ОписаниеПроверки - Строка
Функция НовыйКонтекстУтверждения() Экспорт
Контекст = Новый Структура;
Контекст.Вставить("ПроверяемоеЗначение", Неопределено);
Контекст.Вставить("ПредставлениеПроверяемогоЗначения", Неопределено);
Контекст.Вставить("ПрефиксОшибки", "");
Контекст.Вставить("ИмяМетода", "");
Контекст.Вставить("ИмяСвойства", Неопределено);
Контекст.Вставить("НормализованныйПутьКСвойству", Неопределено);
Контекст.Вставить("ПараметрыМетода", Неопределено);
Контекст.Вставить("ОписаниеПроверки", Неопределено);
Возврат Контекст;
КонецФункции
// Обработчик события "ПередКаждымТестом"
//
// Параметры:
// ОписаниеСобытия - см. ЮТФабрика.ОписаниеСобытияИсполненияТестов
Процедура ПередТестом(ОписаниеСобытия) Экспорт
Процедура ПередКаждымТестом(ОписаниеСобытия) Экспорт
ЮТУтверждения.СброситьКонтекст();
@ -812,21 +874,6 @@
#Область Контекст
Функция НовыйКонтекстУтверждения()
Контекст = Новый Структура;
Контекст.Вставить("ПроверяемоеЗначение", Неопределено);
Контекст.Вставить("ПредставлениеПроверяемогоЗначения", Неопределено);
Контекст.Вставить("ПрефиксОшибки", "");
Контекст.Вставить("ИмяМетода", "");
Контекст.Вставить("ИмяСвойства", "");
Контекст.Вставить("ПараметрыМетода", Неопределено);
Контекст.Вставить("ОписаниеПроверки", Неопределено);
Возврат Контекст;
КонецФункции
Функция ИнициализироватьКонтекстУтверждения()
Контекст = НовыйКонтекстУтверждения();
@ -857,23 +904,21 @@
Контекст = Контекст();
Значение = Контекст.ПроверяемоеЗначение;
Если ЗначениеЗаполнено(Контекст.ИмяСвойства) Тогда
Если Контекст.ИмяСвойства <> Неопределено Тогда
Если ТипЗнч(Контекст.ИмяСвойства) = Тип("Строка") Тогда
Для Каждого Часть Из Контекст.НормализованныйПутьКСвойству Цикл
Части = СтрРазделить(Контекст.ИмяСвойства, ".");
Если ТипЗнч(Значение) = Тип("ХранилищеЗначения") Тогда
Значение = Значение.Получить();
КонецЕсли;
Для Каждого Часть Из Части Цикл
Значение = Значение[Часть];
КонецЦикла;
Если ТипЗнч(Часть) = Тип("Число") И Часть < 0 И ТипЗнч(Значение) <> Тип("Соответствие") Тогда
Часть = Значение.Количество() + Часть;
КонецЕсли;
Иначе
Значение = Значение[Часть];
Значение = Значение[Контекст.ИмяСвойства]; // Для соответствий
КонецЕсли;
КонецЦикла;
КонецЕсли;
@ -888,9 +933,13 @@
КонецФункции
Функция ЭтоДействительнаяЦепочкаСвойств(Знач Значение, Цепочка, ФиксироватьОшибку = Истина)
Функция НормализованныйПутьКСвойству(Знач Значение, Цепочка, ФиксироватьОшибку = Истина)
Если ТипЗнч(Цепочка) = Тип("Строка") Тогда
ПутьКСвойству = Новый Массив();
ТипПути = ТипЗнч(Цепочка);
Если ТипПути = Тип("Строка") Тогда
Части = СтрРазделить(Цепочка, ".");
@ -900,33 +949,72 @@
ПройденныйПуть.Добавить(Часть);
Попытка
ЕстьСвойство = ЗначениеИмеетСвойство(Значение, Часть);
Исключение
ЮТРегистрацияОшибок.СгенерироватьОшибкуВыполнения(ИнформацияОбОшибке());
КонецПопытки;
ПозицияИндекса = СтрНайти(Часть, "[");
Если ЕстьСвойство Тогда
Значение = Значение[Часть];
ИначеЕсли ФиксироватьОшибку Тогда
ПутьСвойства = СтрСоединить(ПройденныйПуть, ".");
ЮТРегистрацияОшибок.СгенерироватьОшибкуСравнения(СтрШаблон("содержит свойство `%1`", ПутьСвойства), Значение, Цепочка);
Если ПозицияИндекса > 0 И ПозицияИндекса > 0 И СтрЗаканчиваетсяНа(Часть, "]") Тогда
Если ПозицияИндекса > 1 Тогда
ПутьКСвойству.Добавить(Лев(Часть, ПозицияИндекса - 1));
КонецЕсли;
Пока ПозицияИндекса > 0 Цикл
ЗакрывающаяПозиция = СтрНайти(Часть, "]", , ПозицияИндекса);
ИндексСтрокой = Сред(Часть, ПозицияИндекса + 1, ЗакрывающаяПозиция - ПозицияИндекса - 1);
Индекс = Число(ИндексСтрокой);
ПутьКСвойству.Добавить(Индекс);
ПозицияИндекса = СтрНайти(Часть, "[", , ЗакрывающаяПозиция);
КонецЦикла;
Иначе
Возврат Ложь;
ПутьКСвойству.Добавить(Часть);
КонецЕсли;
КонецЦикла;
Иначе
ИначеЕсли ТипПути = Тип("Соответствие") Тогда
Попытка
Возврат ЗначениеИмеетСвойство(Значение, Цепочка); // Для соответствий
Исключение
ЮТРегистрацияОшибок.СгенерироватьОшибкуВыполнения(ИнформацияОбОшибке());
КонецПопытки;
ПутьКСвойству.Добавить(Цепочка);
ИначеЕсли ТипПути = Тип("Число") Тогда
ПутьКСвойству.Добавить(Цепочка);
КонецЕсли;
ПройденныйПуть = Новый Массив();
Для Каждого Часть Из ПутьКСвойству Цикл
ПройденныйПуть.Добавить(Часть);
Если ТипЗнч(Значение) = Тип("ХранилищеЗначения") Тогда
Значение = Значение.Получить();
КонецЕсли;
Попытка
ЕстьСвойство = ЗначениеИмеетСвойство(Значение, Часть);
Исключение
ЕстьСвойство = Ложь;
КонецПопытки;
Если ЕстьСвойство Тогда
Значение = Значение[Часть];
ИначеЕсли ФиксироватьОшибку Тогда
ПутьСвойства = СтрСоединить(ПройденныйПуть, ".");
ЮТРегистрацияОшибок.СгенерироватьОшибкуСравнения(СтрШаблон("содержит свойство `%1`", ПутьСвойства), Значение, Цепочка);
Иначе
Возврат Неопределено;
КонецЕсли;
КонецЦикла;
Возврат ПутьКСвойству;
КонецФункции
Функция ЗначениеИмеетСвойство(Значение, Свойство)
@ -949,6 +1037,13 @@
КонецЦикла;
ИначеЕсли ТипЗнч(Свойство) = Тип("Число") Тогда
Если Свойство < 0 Тогда
Свойство = Значение.Количество() + Свойство;
КонецЕсли;
Результат = Свойство >= 0 И Значение.Количество() > Свойство;
Иначе
Результат = ЮТОбщий.ПеременнаяСодержитСвойство(Значение, Свойство);
@ -971,7 +1066,7 @@
ИначеЕсли ЭтоТипМассива(ТипПроверяемогоЗначения) Тогда
Индекс = ПроверяемоеЗначение.Найти(ОжидаемоеЗначение);
ИскомоеЗначениеНайдено = Индекс <> Неопределено И ТипЗнч(ПроверяемоеЗначение[Индекс]) = ТипЗнч(ОжидаемоеЗначение);
ИскомоеЗначениеНайдено = Индекс <> Неопределено;
ИначеЕсли ЭтоТипКлючЗначение(ТипПроверяемогоЗначения) Тогда
@ -1152,7 +1247,7 @@
ЮТРегистрацияОшибок.СгенерироватьОшибкуВыполнения(ИнформацияОбОшибке());
КонецПопытки;
ОбработатьРезультатУтверждения(Результат, "является заполненным", Реверс, ПроверяемоеЗначение);
ОбработатьРезультатСравнения(Результат, "является заполненным", Реверс, ПроверяемоеЗначение, Неопределено);
КонецПроцедуры
@ -1164,7 +1259,7 @@
ЮТРегистрацияОшибок.СгенерироватьОшибкуВыполнения(ИнформацияОбОшибке());
КонецПопытки;
ОбработатьРезультатУтверждения(Результат, "существует", Реверс, ПроверяемоеЗначение);
ОбработатьРезультатСравнения(Результат, "существует", Реверс, ПроверяемоеЗначение, Неопределено);
КонецПроцедуры

106
exts/yaxunit/src/CommonModules/ЮТФабрика/Module.bsl
View File

@ -112,6 +112,7 @@
// * МалоПараметров - Строка
// * МногоПараметров - Строка
// * НекорректныйКонтекстИсполнения - Строка
// * Пропущен - Строка
Функция ТипыОшибок() Экспорт
Типы = Новый Структура;
@ -141,11 +142,23 @@
|| ЧтенияТестов | Загрузки тестов | Сломан |
|| МалоПараметров | Мало фактических параметров | Сломан |
|| МногоПараметров | Много фактических параметров | Сломан |
|| НекорректныйКонтекстИсполнения | Некорректный контекст исполнения | Сломан |
|| НекорректныйКонтекстИсполнения | Некорректный контекст исполнения | Пропущен |
|| Пропущен | Пропущен | Пропущен |
|");
КонецФункции
Функция УровниИсполнения() Экспорт
Уровни = Новый Структура;
Уровни.Вставить("Модуль", "Модуль");
Уровни.Вставить("НаборТестов", "НаборТестов");
Уровни.Вставить("Тест", "Тест");
Возврат Новый ФиксированнаяСтруктура(Уровни);
КонецФункции
#КонецОбласти
#Область СтруктурыДанных
@ -207,7 +220,7 @@
// Параметры:
// Имя - Строка - Имя тестового метода
// Представление - Строка - Представление, краткое описание теста
// КонтекстыВызова - Строка - Контексты исполнения теста, см. КонтекстВызова
// КонтекстыВызова - Массив из Строка - Контексты исполнения теста
// ТегиСтрокой - Строка - Теги теста
//
// Возвращаемое значение:
@ -217,11 +230,8 @@
// * Теги - Массив из Строка - Теги теста
// * КонтекстВызова - Массив из Строка - Контексты исполнения теста
// * НастройкиВыполнения- Структура - Настройки исполнения теста
Функция ОписаниеТеста(Имя, Знач Представление, КонтекстыВызова, Знач ТегиСтрокой = "") Экспорт
Если НЕ ЗначениеЗаполнено(Представление) Тогда
Представление = Имя;
КонецЕсли;
// * Параметры - Неопределено, Массив из Произвольный - Параметры теста
Функция ОписаниеТеста(Имя, Представление, КонтекстыВызова, Знач ТегиСтрокой = "") Экспорт
Если ТегиСтрокой = Неопределено Тогда
ТегиСтрокой = "";
@ -231,8 +241,9 @@
Описание.Вставить("Имя", Строка(Имя));
Описание.Вставить("Представление", Строка(Представление));
Описание.Вставить("Теги", СтрРазделить(ТегиСтрокой, ", ", Ложь));
Описание.Вставить("КонтекстВызова", СтрРазделить(КонтекстыВызова, ", ", Ложь));
Описание.Вставить("КонтекстВызова", КонтекстыВызова);
Описание.Вставить("НастройкиВыполнения", Новый Структура());
Описание.Вставить("Параметры", Неопределено);
Возврат Описание;
@ -242,18 +253,18 @@
// Возвращает описание исполняемого тестового набора.
// Содержит данные необходимые для выполнения прогона тестов
// Параметры:
// НаборТестов - Массив - Коллекция зарегистрированных тестовых наборов, см. ОписаниеТестовогоНабора
// НаборТестов - Массив из см. ОписаниеТеста - Коллекция зарегистрированных тестовых наборов, см. ОписаниеТестовогоНабора
// ТестовыйМодуль - Структура - Описание тестового модуля, см. ЮТФабрика.ОписаниеМодуля
//
// Возвращаемое значение:
// Структура - Описание исполняемого набора тестов:
// * Имя - Строка - Имя набора
// * Представление - Строка - Представление набора
// * Теги - Массив - Тэги набора
// * Теги - Массив из Строка - Тэги набора
// * Ошибки - Массив из см. ЮТФабрика.ОписаниеВозникшейОшибки - Описания ошибок выполнения теста
// * Режим - Строка - Режим исполнения набора, см. КонтекстыВызова
// * МетаданныеМодуля - см. ЮТФабрика.ОписаниеМодуля
// * Тесты - Массив - Тесты набора, структуру тестов см. ОписаниеИсполняемогоТеста
// * Тесты - Массив из см. ОписаниеИсполняемогоТеста - Тесты набора, структуру тестов см. ОписаниеИсполняемогоТеста
// * Выполнять - Булево - Признак, что можно выполнить прогон набора (нет ошибок блокирующих запуск)
// * ДатаСтарта - Число - Дата запуска набора
// * Длительность - Число - Продолжительность выполнения набора
@ -265,7 +276,7 @@
Описание.Вставить("Имя", НаборТестов.Имя);
Описание.Вставить("Представление", НаборТестов.Представление);
Описание.Вставить("Теги", НаборТестов.Теги);
Описание.Вставить("Ошибки", НаборТестов.Ошибки);
Описание.Вставить("Ошибки", ЮТОбщий.СкопироватьМассив(НаборТестов.Ошибки));
Описание.Вставить("Режим", "");
Описание.Вставить("МетаданныеМодуля", ТестовыйМодуль.МетаданныеМодуля);
Описание.Вставить("Тесты", Новый Массив);
@ -303,8 +314,17 @@
ПолноеИмяМетода = СтрШаблон("%1.%2", ТестовыйМодуль.МетаданныеМодуля.Имя, Тест.Имя);
Если ЗначениеЗаполнено(Тест.Представление) Тогда
Представление = Тест.Представление;
ИначеЕсли ЗначениеЗаполнено(Тест.Параметры) Тогда
ПредставлениеПараметров = СтрСоединить(Тест.Параметры, ", ");
Представление = СтрШаблон("%1(%2)", Тест.Имя, ПредставлениеПараметров);
Иначе
Представление = Тест.Имя;
КонецЕсли;
ОписаниеТеста = Новый Структура;
ОписаниеТеста.Вставить("Имя", Тест.Представление);
ОписаниеТеста.Вставить("Имя", Представление);
ОписаниеТеста.Вставить("Метод", Тест.Имя);
ОписаниеТеста.Вставить("ПолноеИмяМетода", ПолноеИмяМетода);
ОписаниеТеста.Вставить("Теги", Тест.Теги);
@ -314,6 +334,7 @@
ОписаниеТеста.Вставить("Статус", СтатусыИсполненияТеста().Ожидание);
ОписаниеТеста.Вставить("Ошибки", Новый Массив);
ОписаниеТеста.Вставить("НастройкиВыполнения", Тест.НастройкиВыполнения);
ОписаниеТеста.Вставить("Параметры", Тест.Параметры);
Возврат ОписаниеТеста;
@ -328,6 +349,7 @@
// * ВыполнятьМодульноеТестирование - Булево - Признак необходимости выполнения тестов
// * reportPath - Строка - Файл или каталог сохранения отчета о тестировании
// * filter - Структура - Параметры отбора запускаемых тестов, см. ПараметрыФильтрации
// * settings - см. НастройкиВыполнения
// * closeAfterTests - Булево - Признак необходимости закрытия приложения по окончании прогона
// * reportFormat - Строка - Формат отчета о тестировании.
// Модули реализующие различные форматы отчетов собраны в подсистеме ЮТФормированиеОтчета
@ -340,6 +362,7 @@
Параметры.Вставить("reportPath", "");
Параметры.Вставить("closeAfterTests", Истина);
Параметры.Вставить("filter", ПараметрыФильтрации());
Параметры.Вставить("settings", НастройкиВыполнения());
Параметры.Вставить("reportFormat", "jUnit");
Возврат Параметры;
@ -390,19 +413,26 @@
// ОписаниеВозникшейОшибки
// Возвращает базовую структуру ошибки
//
// Параметры:
// Сообщение - Строка
//
// Возвращаемое значение:
// Структура - Описание возникшей ошибки:
// * Сообщение - Строка - Описание возникшей ошибки
// * Стек - Строка - Стек возникшей ошибки
// * ТипОшибки - Строка - Тип возникшей ошибки. Доступные значения см. ЮТФабрика.ТипыОшибок
Функция ОписаниеВозникшейОшибки() Экспорт
Функция ОписаниеВозникшейОшибки(Сообщение) Экспорт
Возврат Новый Структура("Сообщение, Стек, ТипОшибки", "");
Возврат Новый Структура("Сообщение, Стек, ТипОшибки", Сообщение);
КонецФункции
// ОписаниеОшибкиСравнения
// Возвращает базовую структуру ошибки проверки факта и ожидания
// Возвращает базовую структуру ошибки проверки факта и ожидания
//
// Параметры:
// Сообщение - Строка
//
// Возвращаемое значение:
// Структура - Описание возникшей ошибки:
// * Сообщение - Строка - Описание возникшей ошибки
@ -410,9 +440,9 @@
// * ТипОшибки - Строка - Тип возникшей ошибки. Доступные значения см. ЮТФабрика.ТипыОшибок
// * ПроверяемоеЗначение - Произвольный - Проверяемое, фактическое значение
// * ОжидаемоеЗначение - Произвольный - Ожидаемое значение
Функция ОписаниеОшибкиСравнения() Экспорт
Функция ОписаниеОшибкиСравнения(Сообщение) Экспорт
Описание = ОписаниеВозникшейОшибки();
Описание = ОписаниеВозникшейОшибки(Сообщение);
Описание.ТипОшибки = ТипыОшибок().Утверждений;
Описание.Вставить("ПроверяемоеЗначение");
Описание.Вставить("ОжидаемоеЗначение");
@ -421,6 +451,26 @@
КонецФункции
// Возвращает базовую структуру ошибки пропуска теста
//
// Параметры:
// Сообщение - Строка
//
// Возвращаемое значение:
// Структура -- Описание возникшей ошибки::
// * Сообщение - Строка - Описание возникшей ошибки
// * Стек - Строка - Стек возникшей ошибки
// * ТипОшибки - Строка - Тип возникшей ошибки. Доступные значения
// См. ЮТФабрика.ТипыОшибок
Функция ОписаниеОшибкиПропуска(Сообщение) Экспорт
Описание = ОписаниеВозникшейОшибки(Сообщение);
Описание.ТипОшибки = ТипыОшибок().Пропущен;
Возврат Описание;
КонецФункции
// Описание события исполнения тестов.
//
// Параметры:
@ -546,9 +596,9 @@
// * suites - Неопределено, Массив из Строка - Список тестовых наборов
// * paths - Неопределено, Массив из Строка - Список путей до тестовых методов, путь может быть не полным.
// Например:
// - tests - Ищем тесты в расширении tests
// - tests.ОМ_ОбщегоНазначения - Ищем тесты в модуле ОМ_ОбщегоНазначения расширения tests
// - tests.ОМ_ОбщегоНазначения.ПолучитьЗначениеРеквизита - указание конкретного теста
// + tests - Ищем тесты в расширении tests
// + tests.ОМ_ОбщегоНазначения - Ищем тесты в модуле ОМ_ОбщегоНазначения расширения tests
// + tests.ОМ_ОбщегоНазначения.ПолучитьЗначениеРеквизита - указание конкретного теста
// * tags - Неопределено, Массив из Строка - Список тэгов
// * contexts - Неопределено, Массив из Строка - Список тестируемых контекстов
// * tests - Неопределено, Массив из Строка - Список полных имен тестовых методов. ИмяМодуля.ИмяМетода{.Контекст}
@ -567,4 +617,16 @@
КонецФункции
Функция НастройкиВыполнения()
ПараметрыИсполнения = ПараметрыИсполненияТеста();
Настройки = Новый Структура();
Настройки.Вставить(ПараметрыИсполнения.ВТранзакции, Ложь);
Возврат Настройки;
КонецФункции
#КонецОбласти

2
exts/yaxunit/src/CommonModules/ЮТФильтрация/Module.bsl
View File

@ -242,7 +242,7 @@
Фильтр.Вставить("ЕстьФильтрТестов", Фильтр.Тесты.Количество());
Фильтр.Вставить("ЕстьФильтрКонтекстов", ЗначениеЗаполнено(Фильтр.Контексты));
ЮТКонтекст.УстановитьКонтекстЧитателя(Новый Структура("Фильтр", Фильтр), Истина);
ЮТКонтекст.УстановитьКонтекстЧитателя(Новый Структура("Фильтр", Фильтр));
КонецПроцедуры

11
exts/yaxunit/src/CommonModules/ЮТЧитатель/Module.bsl
View File

@ -63,11 +63,10 @@
// ПрочитатьНаборТестов
// Читает набор тестов из модуля
// Параметры:
// МетаданныеМодуля - См. ЮТФабрика.ОписаниеМодуля
// СтроковыйРежим - Строка - Строковый режим (контекст) исполнения теста
// ОписаниеМодуля - см. ЮТФабрика.ОписаниеМодуля
//
// Возвращаемое значение:
// Неопределено, Структура - Если прочитано, то будет возвращено описание набора. См. ОписаниеНабораТестов
// Неопределено, Массив из см. ЮТФабрика.ОписаниеТестовогоНабора- Если прочитано, то будет возвращено описание наборов
Функция ИсполняемыеСценарииМодуля(ОписаниеМодуля) Экспорт
ЭтоТестовыйМодуль = Истина;
@ -91,8 +90,6 @@
КонецЕсли;
Данные = ЮТТесты.СценарииМодуля();
Если Ошибка <> Неопределено Тогда
Данные = Новый Массив(); // Фиксируем, чтобы отобразить в отчете
@ -103,10 +100,10 @@
ИначеЕсли ЭтоТестовыйМодуль Тогда
ЮТТесты.ПослеЧтенияСценариевМодуля();
Сценарии = ЮТТесты.СценарииМодуля();
Данные = ЮТОбщий.ВыгрузитьЗначения(Сценарии.ТестовыеНаборы, "Значение");
Данные = ЮТФильтрация.ОтфильтроватьТестовыеНаборы(Данные, ОписаниеМодуля);
Данные = ЮТФильтрация.ОтфильтроватьТестовыеНаборы(Сценарии.ТестовыеНаборы, ОписаниеМодуля);
Иначе

122
exts/yaxunit/src/CommonModules/ЮТест/Module.bsl Normal file
View File

@ -0,0 +1,122 @@
//©///////////////////////////////////////////////////////////////////////////©//
//
// Copyright 2021-2022 BIA-Technologies Limited Liability Company
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//©///////////////////////////////////////////////////////////////////////////©//
/////////////////////////////////////////////////////////////////////////////////
// Основной модуль для запуска тестирования
/////////////////////////////////////////////////////////////////////////////////
#Область ПрограммныйИнтерфейс
// Возвращает API формирования утверждения для проверки теста
//
// Параметры:
// ПроверяемоеЗначение - Произвольный - Проверяемое фактическое значение
// Сообщение - Строка - Описание проверки, которое будет выведено при возникновении ошибки
//
// Возвращаемое значение:
// ОбщийМодуль - Утверждения
Функция ОжидаетЧто(ПроверяемоеЗначение, Сообщение = "") Экспорт
Возврат ЮТУтверждения.Что(ПроверяемоеЗначение, Сообщение);
КонецФункции
// Пропустить выполнение теста
// Используется если тест выполняется в неподходящих условиях и не нужно его выполнять, но отразить в отчете требуется
// Параметры:
// Сообщение - Неопределено - Сообщение
Процедура Пропустить(Сообщение = Неопределено) Экспорт
ЮТРегистрацияОшибок.Пропустить(Сообщение);
КонецПроцедуры
// Возвращает API для работы с тестовыми данными
//
// Возвращаемое значение:
// ОбщийМодуль - Данные
Функция Данные() Экспорт
Возврат ЮТТестовыеДанные;
КонецФункции
// Конструктор вариантов прогона теста
// Используется для формирования набора различных параметров выполнения
// Параметры:
// Реквизиты - Строка - Список реквизитов варианта разделенных запятой
//
// Возвращаемое значение:
// ОбщийМодуль - Варианты
Функция Варианты(Реквизиты) Экспорт
Возврат ЮТКонструкторВариантов.Варианты(Реквизиты);
КонецФункции
Функция Контекст() Экспорт
Возврат ЮТКонтекстТеста;
КонецФункции
// КонтекстТеста
// Возвращает структуру, в которой можно хранить данные используемые в тесте
// Данные живут в рамках одного теста, но доступны в обработчиках событий `ПередКаждымТестом` и `ПослеКаждогоТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеКаждогоТеста`
// Возвращаемое значение:
// Структура - Контекст теста
// Неопределено - Если метод вызывается за рамками теста
Функция КонтекстТеста() Экспорт
Возврат ЮТКонтекст.КонтекстТеста();
КонецФункции
// КонтекстНабора
// Возвращает структуру, в которой можно хранить данные используемые в тестах набора
// Данные живут в рамках одного набора тестов (данные между клиентом и сервером не синхронизируются)
// Доступны в каждом тесте набора и в обработчиках событий
// + `ПередТестовымНабором`
// + `ПослеТестовогоНабора`
// + `ПередКаждымТестом`
// + `ПослеКаждогоТеста`
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеКаждогоТеста`
// Возвращаемое значение:
// Структура - Контекст набора тестов
// Неопределено - Если метод вызывается за рамками тестового набора
Функция КонтекстТестовогоНабора() Экспорт
Возврат ЮТКонтекст.КонтекстНабора();
КонецФункции
// КонтекстМодуля
// Возвращает структуру, в которой можно хранить данные используемые в тестах модуля
// Данные живут в рамках одного тестового модуля (данные между клиентом и сервером не синхронизируются)
// Доступны в каждом тесте модуля и в обработчиках событий
// Например, в контекст можно помещать создаваемые данные, что бы освободить/удалить их в обработчике `ПослеВсехТестов`
// Возвращаемое значение:
// Структура - Контекст тестового модуля
// Неопределено - Если метод вызывается за рамками тестового модуля
Функция КонтекстМодуля() Экспорт
Возврат ЮТКонтекст.КонтекстМодуля();
КонецФункции
#КонецОбласти

7
exts/yaxunit/src/CommonModules/ЮТ/ЮТ.mdo → exts/yaxunit/src/CommonModules/ЮТест/ЮТест.mdo
View File

@ -1,10 +1,11 @@
<?xml version="1.0" encoding="UTF-8"?>
<mdclass:CommonModule xmlns:mdclass="http://g5.1c.ru/v8/dt/metadata/mdclass" uuid="34241a49-2c1e-41ac-b97b-f22be47c83e8">
<name>ЮТ</name>
<mdclass:CommonModule xmlns:mdclass="http://g5.1c.ru/v8/dt/metadata/mdclass" uuid="00657e40-f22c-4638-ae35-a322d57470cc">
<name>ЮТест</name>
<synonym>
<key>ru</key>
<value>ЮТ</value>
<value>Тест</value>
</synonym>
<clientManagedApplication>true</clientManagedApplication>
<server>true</server>
<clientOrdinaryApplication>true</clientOrdinaryApplication>
</mdclass:CommonModule>

5
exts/yaxunit/src/Configuration/Configuration.mdo
View File

@ -37,18 +37,20 @@
<commonModules>CommonModule.МокитоСлужебный</commonModules>
<commonModules>CommonModule.ОМ_Мокито</commonModules>
<commonModules>CommonModule.ОМ_МокитоОбучение</commonModules>
<commonModules>CommonModule.ОМ_ЮТест</commonModules>
<commonModules>CommonModule.ОМ_ЮТИсполнитель</commonModules>
<commonModules>CommonModule.ОМ_ЮТУтверждения</commonModules>
<commonModules>CommonModule.ОМ_ЮТФильтрация</commonModules>
<commonModules>CommonModule.ОМ_ЮТЧитатель</commonModules>
<commonModules>CommonModule.РаботаСHTTP</commonModules>
<commonModules>CommonModule.ЮТ</commonModules>
<commonModules>CommonModule.ЮТест</commonModules>
<commonModules>CommonModule.ЮТИсполнитель</commonModules>
<commonModules>CommonModule.ЮТИсполнительСервер</commonModules>
<commonModules>CommonModule.ЮТКонструкторВариантов</commonModules>
<commonModules>CommonModule.ЮТКонтекст</commonModules>
<commonModules>CommonModule.ЮТКонтекстКлиент</commonModules>
<commonModules>CommonModule.ЮТКонтекстСервер</commonModules>
<commonModules>CommonModule.ЮТКонтекстТеста</commonModules>
<commonModules>CommonModule.ЮТМетаданныеСервер</commonModules>
<commonModules>CommonModule.ЮТОбщий</commonModules>
<commonModules>CommonModule.ЮТОбщийВызовСервера</commonModules>
@ -56,7 +58,6 @@
<commonModules>CommonModule.ЮТОтчетJSON</commonModules>
<commonModules>CommonModule.ЮТОтчетJUnit</commonModules>
<commonModules>CommonModule.ЮТПараметры</commonModules>
<commonModules>CommonModule.ЮТПараметрыСервер</commonModules>
<commonModules>CommonModule.ЮТПовторногоИспользования</commonModules>
<commonModules>CommonModule.ЮТРасширения</commonModules>
<commonModules>CommonModule.ЮТРегистрацияОшибок</commonModules>

6
exts/yaxunit/src/Configuration/ManagedApplicationModule.bsl
View File

@ -16,8 +16,12 @@
//
//©///////////////////////////////////////////////////////////////////////////©//
#Область ОписаниеПеременных
Перем ЮТДанныеКонтекста Экспорт;
#КонецОбласти
/////////////////////////////////////////////////////////////////////////////////
// Обработчики событий модуля
/////////////////////////////////////////////////////////////////////////////////
@ -31,7 +35,7 @@
&После("ПриНачалеРаботыСистемы")
Процедура ЮТПриНачалеРаботыСистемы()
ЮТ.ВыполнитьМодульноеТестирование();
ЮТИсполнитель.ВыполнитьМодульноеТестирование();
КонецПроцедуры

4
exts/yaxunit/src/Subsystems/ЮТДвижок/ЮТДвижок.mdo
View File

@ -9,7 +9,6 @@
<content>CommonModule.МокитоОбучение</content>
<content>CommonModule.МокитоПроверки</content>
<content>CommonModule.МокитоСлужебный</content>
<content>CommonModule.ЮТ</content>
<content>CommonModule.ЮТИсполнитель</content>
<content>CommonModule.ЮТИсполнительСервер</content>
<content>CommonModule.ЮТКонтекст</content>
@ -21,7 +20,6 @@
<content>CommonModule.ЮТОтчетJSON</content>
<content>CommonModule.ЮТОтчетJUnit</content>
<content>CommonModule.ЮТПараметры</content>
<content>CommonModule.ЮТПараметрыСервер</content>
<content>CommonModule.ЮТПовторногоИспользования</content>
<content>CommonModule.ЮТРасширения</content>
<content>CommonModule.ЮТРегистрацияОшибок</content>
@ -36,4 +34,6 @@
<content>CommonModule.ЮТКонструкторВариантов</content>
<content>CommonModule.ЮТОбщийВызовСервера</content>
<content>CommonModule.ЮТТестовыеДанныеВызовСервера</content>
<content>CommonModule.ЮТест</content>
<content>CommonModule.ЮТКонтекстТеста</content>
</mdclass:Subsystem>