# Сначала нам нужно поместить все эти имена в текстовый файл, предполагая, что мы поместили их в файл requestment.txt.

# файл requestment.txt
pytest-html
pytest-xdist
pytest-ordering
pytest-rerunfailures

# Нам нужно всего лишь ввести команду в консоли pycharm, чтобы загрузить все содержимое папки.
pip install -r requirements.txt

# Прежде всего, имена наших модулей (имена файлов) обычно хранятся в папке тестовых случаев, а затем нам нужно убедиться, что имя модуля должно начинаться с test_ или заканчиваться на _test.
# Например, имя нашего модуля ниже является правильным примером.
test_demo1
demo2_test

# Затем нам нужно отметить, что имя тестового класса в нашем модуле должно начинаться с Test и не может иметь метод init.
# Например, правильное название класса приведено ниже.
class TestDemo1:
class TestLogin:

# Наконец, нам нужно отметить, что имя метода теста (имя Case) в нашем тестовом классе должно начинаться с test_.
# Например, имя нашего модуля ниже является правильным примером.
test_demo1(self)
test_demo2(self)

# Приведем пример тестового варианта использования:
# Имя файла — test_demo1.
class TestDemo:
    def test_demo1(self):
        print("тестовый вариант использования 1")

    def test_demo2(self):
        print("тестовый вариант использования 2")
        
# Конечно, наши вышеуказанные требования не обязательно должны быть одинаковыми. Мы можем внести изменения в будущем. Метод выполнения мы объясним ниже.

# Сначала давайте объясним файл глобальной конфигурации pytest.ini.
# Мы можем настроить некоторые свойства в pytest.ini, чтобы изменить свойства Pytest по умолчанию. Нам нужно создать его в корневом каталоге проекта, и имя должно быть pytest.ini.

1 [pytest]
2 #параметр
3 addopts = ‐vs 				# Это относится к некоторым вспомогательным параметрам при использовании команды по умолчанию, о которых мы расскажем позже.
4 testpaths = ./testcases		# Это относится к пути выполнения по умолчанию, который будет выполнять все тестовые случаи в папке, которые по умолчанию соответствуют условиям.
5 python_files = test_*.py		# Вот правила именования файлов, о которых мы упоминали ранее.
6 python_classes = Test*		# Вот правила именования имен классов, о которых мы упоминали ранее.
7 python_functions = test_*		# Вот правило именования случаев, о котором мы упоминали ранее.
8 #отметка
9 markers =						# Вот правила курения, о которых мы поговорим позже.
10 дым: вариант использования дыма				 
11 Product_manage: Управление продуктами		


# Тогда давайте сначала поговорим о том, как запустить Pytest с помощью командной строки консоли.
# Самое простое — ввести pytest непосредственно в командной строке консоли. Если pytest.ini существует, он будет выполнен в соответствии с содержимым файла, если нет, он будет выполнен в соответствии с форматом по умолчанию.
# Но мы можем расширить директиву параметра pytest с помощью некоторых параметров.

# -vs： -v вывести подробную информацию -s выводить отладочную информацию
pytest -vs

# -n： Многопоточная работа (предварительным условием является установка плагина: pytest-xdist)
pytest -vs -n=2

# --reruns num: Перезапуск после сбоя (предварительным условием является установка плагина: pytest-rerunfailres)
pytest -vs --reruns=2

# -x: Остановитесь, если вариант использования не удался
pytest -vs -x

# --maxfail: Завершить работу после нескольких неудач
pytest -vs --maxfail=2

# --html: Создать тестовый отчет HTML, позже Вам необходимо следить за расположением и именем созданного файла (обязательное условие — установка плагина: pytest-html)
pytest -vs --html ./reports/result.html

# -k： Чтобы запустить тестовый вариант использования, имя которого содержит определенную строку, мы можем использовать или для ее выражения или и для выражения того и другого.
# Использование или означает: имя текущего варианта использования содержит данные по обеим сторонам или.
# Использование и означает: имя текущего варианта использования удовлетворяет условию только в том случае, если оно содержит все данные с обеих сторон и.
pytest -vs -k "qiuluo"
pytest -vs -k "qiuluo or weiliang"
pytest -vs -k "qiuluo and weiliang"

# -m: выполнение варианта использования дыма, после которого должно следовать имя дыма.
# Здесь мы кратко представляем метод выполнения варианта использования дыма. На самом деле мы имеем метод группового выполнения.
# Например, наши варианты использования разделены на тест управления пользователями user_manage и тест управления продуктом Product_manage, и мы хотим выполнить только один из них.

# Сначала нам нужно разделить @mark на разные методы. Конкретные операции заключаются в следующем:
class TestDemo:
    
    # Мы используем @pytest.mark в Case. + Имя группы эквивалентно методу, разделенному на группу.
    # Примечание. В группе может быть несколько методов, и метод также можно разделить на несколько групп.
    @pytest.mark.user_manage
    def test_demo1(self):
        print("user_manage_test1")

    @pytest.mark.product_manage
    def test_demo2(self):
        print("product_manage_test1")
     
    @pytest.mark.user_manage
    @pytest.mark.product_manage
    def test_demo3(self):
        print("manage_test1")

# Нам нужно использовать только -m, о котором мы упоминали ранее, во время выполнения. + Просто название группы
pytest -vs -m user_manage

# Вставьте сюда предложение, мы можем использовать метод генерации исключений для имитации сбоя теста во время работы: поднять Exception() выдать исключение


# Наконец, мы также можем использовать основной метод для выполнения pytest, а также использовать параметры для настройки.
if __name__ == '__main__':
	pytest.main()
    
if __name__ == '__main__':
	pytest.main(["‐vs"])

# Метод пропуска случая в pytest на самом деле точно такой же, как и unittest.
# Нам нужно только использовать метод Skip или Skipif, чтобы указать параметры и вставить их в метод для пропуска.

# @pytest.mark.skip (причина пропуска)

# @pytest.mark.skipif(условие пропуска, причина пропуска)

# Мы приводим пример
class TestDemo:
    
    workage2 = 5
    workage3 = 20
    
    @pytest.mark.skip(reason="Пропустить без причины")
    def test_demo1(self):
        print("Меня пропустили")

    @pytest.mark.skipif(workage2<10,Reason="Пропуск менее 10 лет опыта работы")    
    def test_demo2(self):
        print("Меня пропустили из-за отсутствия опыта")
    
    @pytest.mark.skipif(workage3<10,Reason="Пропуск менее 10 лет опыта работы")
    def test_demo3(self):
        print("Из-за моего опыта меня казнили")
        
    def test_demo3(self):
        print("Я не пропустил условие, поэтому меня казнили")

# Обычно мы используем предварительную и постобработку для выполнения операций до и после некоторых методов.
# Если мы используем слой метода до и после, то он будет выполнять содержимое до и после выполнения каждого метода.
# Если мы используем пре- и постобработку слоя класса, то он будет выполнять контент до и после вызова всех методов этого класса, но независимо от того, сколько раз будет выполняться метод этого класса, он будет вызываться только один раз.
# Например, когда мы выполняем тест входа в систему, нам нужно открыть браузер только один раз, когда тест начинается, а затем закрыть браузер один раз, когда тест заканчивается, затем мы используем префикс и постфикс класса.
# При входе в систему, чтобы гарантировать, что предварительная операция не повлияет на последующий Case, мы открываем веб-страницу перед выполнением метода, закрываем веб-страницу после выполнения метода и используем предварительную и постобработку метод.

# Прошивка Pytest спереди и сзади на самом деле в основном такая же, как и у unittest.
# Первый — это предварительная и постобработка прошивки на уровне метода.
# Это есть в каждом тестовом методе (код варианта использования). Структура, которая автоматически вызывается до и после выполнения.
# перед выполнением метода
	def setUp(self):
		Каждый тестперед выполнением метод будет выполнен
		pass
# После выполнения метода
	def tearDown(self):
		каждыйтест После выполнения метод будет выполнен
		pass
    
# Потом есть прошивка классового уровня спереди и сзади
# Это до и после выполнения всех методов в каждом тестовом классе. Структура, которая будет автоматически вызываться (выполняться один раз до или после выполнения во всем классе)
# Нужно обратить внимание на: класс прошивки до и после, это метод класса
# перед всеми методами в классе
    @classmethod
    def setUpClass(cls):
    	pass
# Ведь все методы в классе
	@classmethod
	def tearDownClass(cls):
		pass
    
# Наконец, есть прошивка на уровне модуля спереди и сзади.
# Структура кода, выполняемая до и после выполнения каждого файла кода
# Следует отметить, что уровень модуля необходимо писать вне класса, а функцию можно определить напрямую.
# перед файлом кода
	def setUpModule():
		pass
# после файла кода
	def tearDownModule():
		pass
    
# Ниже мы используем вариант использования входа в учетную запись пользователя, чтобы кратко продемонстрировать прошивку до и после.

import unittest

class TestLogin(unittest.TestCase):
    
    # Методы, которые необходимо вызвать перед выполнением этого класса
    @classmethod
    def setUpClass(cls) -> None:
    	print('------Открыть браузер')
    
    # Методы, которые необходимо вызвать после выполнения этого класса
    @classmethod
    def tearDownClass(cls) -> None:
    	print('------Закрыть браузер')
    
    # Каждый тестперед выполнением Метод, который метод вызовет первым
    def setUp(self):
    	print('Введите URL...')
    
    # каждыйтест После выполнения Методы, которые будут вызываться методом
    def tearDown(self) -> None:
    	print('Закрыть текущую страницу...')
    
    # тестCase1
    def test_1(self):
    	print('Введите правильное имя пользователя и код проверки пароля, нажмите, чтобы войти 1')
  
	# тестCase2
    def test_2(self):
    	print('Введите неправильное имя пользователя и код проверки пароля, нажмите, чтобы войти 2')

# Прежде всего, нам нужно знать, что функции, реализованные в Fixtrue, по сути, такие же, как и в прошивке, но они будут более удобными.
# Сначала мы приводим полный формат Fixture, а затем вводим каждый параметр отдельно.
@pytest.fixture(scope=None,autouse=False,params=None,ids=None ,name=None)

# объем: объем
# Существует три основных типа параметров: функция, класс и пакет/пакет сеанса.

# функция: выполнять предварительную и постобработку на функциональном уровне
# Обычно мы используем выход для разделения передней и задней частей. До выхода это передняя часть, а после выхода — пост-раздел.
	@pytest.fixture(scope="function")
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield
		print("Закрыть соединение с базой данных")
# Мы также можем использовать выход или возврат, чтобы вернуть некоторые параметры для использования в методах.
# Однако следует отметить, что пост-операция все еще может быть выполнена после того, как доходность возвращает параметр, но пост-операция не может быть выполнена после того, как return возвращает параметр.
	@pytest.fixture(scope="function")
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield "success"
      # return "success" Почтовые операции не могут быть выполнены после выполнения
		print("Закрыть соединение с базой данных")
# Когда вызывается наш метод, мы можем напрямую использовать exe_database_sql для представления возвращаемой информации для вывода.
def test_2(self,exe_database_sql):
    	print(exe_database_sql)
        
# класс: выполняется до и после класса
	@pytest.fixture(scope="class")
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield
		print("Закрыть соединение с базой данных")
        
# пакет/сеанс: выполняется до и после всего сеанса проекта
	@pytest.fixture(scope="session")
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield
		print("Закрыть соединение с базой данных")

        
# autouse: запускать ли автоматически
# По умолчанию этот параметр имеет значение False, мы можем изменить его на True.
# Функция этого параметра заключается главным образом в том, чтобы определить, может ли прошивка автоматически запускаться в пределах пользовательского диапазона.
# Если он запускается автоматически, все методы будут автоматически выполнять префикс и префикс при выполнении, но если он имеет значение False, нам нужно запустить его вручную;

# Прежде всего, если он запускается автоматически, нам не нужно заботиться ни о каких параметрах, все наши методы будут вызываться автоматически.
	@pytest.fixture(scope="function",autoues=True)
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield
		print("Закрыть соединение с базой данных")
        
# Но если автоматический запуск отключен, у нас будут разные методы вызова в разных областях.
	@pytest.fixture(scope="function",autoues=Flase)
	def exe_database_sql():
		print("Выполнить SQL-запрос")
		yield
		print("Закрыть соединение с базой данных")
        
# scope = функция: нам нужно добавить имя метода Fixture после метода
	def test_2(self,exe_database_sql):
    	print(exe_database_sql)
        
# scope = class: нам нужно добавить вызов декоратора @pytest.mark.usefixtures("exe_database_sql") к соответствующему классу.
@pytest.mark.usefixtures("exe_database_sql")
class TestDemo:
    pass

# scope = session:. Обычно реализуется в сочетании с файлом conftest.py, мы представим его позже.

# Также следует отметить, что autoouse ограничен использованием вышеуказанных методов в своем собственном классе. Если вы хотите использовать его в разных классах, нам также необходимо настроить его в conftest.py.


# params: реализовать параметризованную конфигурацию
# Обычно наши скрипты заполняют атрибуты на основе экспортированного файла yaml. О параметризации мы поговорим позже. Сначала мы параметризуем Fixture.
# За параметрами обычно следуют конкретные данные (список, кортеж и т. д.), а затем у нас есть фиксированный способ записи при вызове.
# Сначала нам нужно определить запрос в параметре метода Fixture, а затем использовать request.param для использования переданных нами данных параметров.
class TestDemo:
    def read_yaml():
        return ["грецкий орех", "ореховый малыш", "ореховый шеф-повар"]
    
    # Во-первых, нашим параметрам необходимо получить данные: params=read_yaml()
    @pytest.fixture(scope="function",autouse=False,params=read_yaml())
    # Тогда нашему методу Fixture требуется параметр запроса
	def exe_database_sql(request):
        print("Выполнить SQL-запрос")
        # Мы получаем данные через request.param и можем использовать выход для возврата данных.
        yield request.param
        print("Закрыть соединение с базой данных")
        

# ids: идентификатор псевдонима параметра
# Его нельзя использовать отдельно. Его следует использовать вместе с параметрами. Его функция — создание псевдонимов для параметров. 
# Когда мы используем pytest для вывода тестовых данных, соответствующий метод будет вызываться n раз. Эти идентификаторы предназначены для изменения консоли консоли для отображения данных.
class TestDemo:
    def read_yaml():
        return ["грецкий орех", "ореховый малыш", "ореховый шеф-повар"]
    
    # когда мы пишемids,Наш контрольный выход больше не будет таким, как указано выше ["грецкий орех", "ореховый малыш", "ореховый шеф-повар"],Это то, что мы написали ["1","2","3"]
    @pytest.fixture(scope="function",autouse=False,params=read_yaml(),ids=["1","2","3"])
	def exe_database_sql(request):
        print("Выполнить SQL-запрос")
        # Мы получаем данные через request.param и можем использовать выход для возврата данных.
        yield request.param
        print("Закрыть соединение с базой данных")
        
# имя: псевдоним прибора
# Функция состоит в том, чтобы присвоить fixtrue псевдоним. После использования псевдонима имя fixtrue больше нельзя использовать. Можно использовать только псевдонимы.
class TestDemo:
    
    # Если мы используем здесь псевдонимы
    @pytest.fixture(scope="function",name="exe_datebase_sql_name")
	def exe_database_sql(request):
        print("Выполнить SQL-запрос")
        yield 
        print("Закрыть соединение с базой данных")
        
    # Для работы нам необходимо использовать псевдонимы. Предыдущие имена использовать нельзя.
	def test_2(self,exe_datebase_sql_name):
    	print(exe_database_sql)    

# Для начала нам нужно знать, что имя файла conftest.py имеет фиксированную форму и не может быть изменено.
# Файл conftest.py в основном используется для хранения нашего Fixture, а затем мы будем оценивать методы, которые можно использовать, на основе различных местоположений файла.
# conftest можно создавать на разных уровнях каталогов. Если мы создадим его в корневом каталоге, во всех случаях будет использоваться это исправление.
# Но если мы создадим conftest.py в файле модуля в папке тестовых случаев, его область действия будет включена только в этот каталог.

# conftest.py создан в корневом каталоге
# Все фикстуры, которые мы написали в файле conftest в этом каталоге, могут быть выполнены в любом тестовом классе.
import pytest
@pytest.fixture(scope="function",name="exe_datebase_sql_name")
def exe_database_sql():
    print("Все методы могут быть выполнены перед запуском")
    yield 
    print("Все методы могут быть выполнены после запуска")
# Все тестовые классы в файле тестовых примеров
# Здесь следует отметить: когда мы используем Fixture в режиме conftest, мы можем использовать его без импорта пакета импорта.
import pytest
class TestDemo1:
	# тестCase1
    def test_1(self,exe_datebase_sql_name):
    	print('Введите правильное имя пользователя и код проверки пароля, нажмите, чтобы войти 1' + exe_datebase_sql_name)
        
# conftest.py создан в папке usercases в папке testcases.
# Все фикстуры, записанные в файле conftest, который мы создали в этом каталоге, могут использоваться только в тестовом классе в этом каталоге. Если они используются в других тестовых классах, произойдет ошибка.
import pytest
@pytest.fixture(scope="function",name="usercases_fixture")
def exe_database_sql():
    print("Метод usercases может быть выполнен перед запуском")
    yield 
    print("Метод usercases может быть выполнен после запуска")
# класс теста в папке пользовательских случаев в файле тестовых случаев
import pytest
class TestUserCases1:
	# тестCase1
    def test_1(self,usercases_fixture):
    	print('Введите правильное имя пользователя и код проверки пароля, нажмите, чтобы войти 1' + usercases_fixture)
        
# Наконец, мы просто задаем приоритет порядка до и после выполнения:
fixture_session > fixture_class > setup_class > fixture_function > setup

# Сначала нам нужно скачать allure на компьютер и настроить переменные среды.
# Здесь мы указываем официальный адрес для загрузки с сайта: https://github.com/allure-framework/allure2/releases. 
# Напоминание: ссылка для скачивания находится на github. Если ее не удается открыть, вы можете обновить и повторить попытку или использовать вспомогательные инструменты, такие как лестницы ускорителей.
# Чтобы настроить переменные среды, вам нужно всего лишь поместить каталог, в котором находится bin-файл, в путь компьютера, который здесь не будет показан.

# На втором этапе нам нужно загрузить плагин allure-pytest на pycharm (если вы ранее копировали весь файл, его нужно было скачать здесь)
pip install allure-pytest

# На третьем этапе мы можем напрямую сгенерировать интерфейс отображения результатов теста Allure.

# 1. Обычно сначала нам нужно создать временный файл Json.
# Обычно мы добавляем строку типа «‐alluredir=./temps ‐‐clean‐alluredir"
# ‐‐alluredir = Адрес создания файла ： Указывает, что мы будем создавать временные файлы Allure в указанном нами относительном временном каталоге.
# ‐‐clean‐alluredir ： Поскольку каждый раз будет создаваться большое количество файлов, мы очистим все файлы в текущем каталоге перед созданием, чтобы гарантировать, что наши данные являются самыми последними.

# 2. Нам нужно использовать временные файлы для создания веб-страницы allure.html.
# Обычно мы выполняем его в основном методе
if __name__ == '__main__':
    # нормальная работа
    pytest.main()
    # Спящий режим: в основном для создания временных файлов JSON.
    time.sleep(3)
    # allure generate фиксированное заявление + каталог временных файлов JSON allure + -o Инструкции вывода + allure.html сгенерированный каталог файлов + --clean Очистить старые данные
    os.system("allure generate ./temps ‐o ./reports ‐‐clean")

# Формат: @pytest.mark.parametrize(имя параметра, значение параметра)
# Значение: мы будем использовать имя параметра в качестве идентификатора, а затем вызывать его последовательно в соответствии с количеством значений параметра. Если имеется n значений параметра, мы вызовем этот случай n раз.

# 1. Если значение параметра представляет собой список или кортеж, имя параметра может быть одним.
# Прежде всего, поскольку здесь мы используем список (кортеж) из одного элемента, имя нашего параметра может быть
@pytest.mark.parameterize('caseinfo',['грецкий орех','ореховый малыш','Фуфу','Фуфу детка'])
# В параметрах метода нам нужно вызвать имя параметра caseinfo параметраparameterize, которое должно быть точно таким же.
def test_01_get_token(self,caseinfo):
    # Здесь мы можем использовать имя параметра caseinfo для замены элементов в списке.
    # В списке их несколько, и наш метод будет выполняться несколько раз. Например, если в списке четыре элемента, то наш метод будет выполняться четыре раза, и каждый раз разные элементы будут присваиваться по порядку.
	print("Получить код аутентификации единого интерфейса:"+caseinfo)
    
# 2. Если значение параметра в списке несколько, имя параметра может быть несколькими.
# Здесь у нас есть список, вложенный в список. Если мы используем одно имя параметра, то будет выведен первый список ['Walnut Kitchen', 'Walnut Baby'].
# Но если у нас многопараметрическое имя, система автоматически присвоит элементы первого списка arg1 отдельно, нам удобно использовать его отдельно.
@pytest.mark.parameterize('arg1,arg2',[['ореховая кухня','ореховый малыш'],['фуфу кухня','фуфу детка']])
# Примечание. Разумеется, оно также должно соответствовать имени параметра! ! !
def test_01_get_token(self,arg1,arg2):
	print("Получить код аутентификации единого интерфейса: "+str(arg1)+" "+str(arg2))

# yaml — формат данных, расширение может быть yaml, yml
# Поддерживает # комментариев, указывающих уровни посредством отступов, с учетом регистра, а окончательный результат отображения файла yaml представляет собой формат списка словарей.
# Файлы Yaml часто используются для записи конфигураций, например, файлы конфигурации в Java Spring, и мы также часто используем yaml для записи Автоматизированного тестированиевариант использования

# Файлы Yaml обычно существуют в двух форматах.

# Формат словаря: если мы пишем файл yaml в обычном режиме, следующий режим словаря:
name: грецкий орех

# Режим списка: если мы возьмем список из yaml, мы также получим список, когда его получит py.
msjy:
    - name1: грецкий орех
    - name2: Фуфу
    - ages1: 18
    - ages2: 19
# Мы также можем использовать эту функцию для создания нескольких списков непосредственно в yaml для многократного извлечения.
-
	name:'xxx'
    age:18
-
	name:'xxx'
    age:20

# Здесь мы сначала приведем пример функции для анализа файлов yaml:
import os.path
import yaml

# Вот чтобы получить текущий путь, потому что нам нужно найти соответствующий файл yaml, тогда конкретный путь требует, чтобы мы его соединили.
def get_obj_path():
    # Здесь мы используем класс Python os для получения текущего пути, а конечный возвращаемый результат на самом деле является строкой String.
    # Мы используем «common» в качестве разграничения (common — это имя текущей папки, мы разделяем Str и получаем предыдущую часть) и получаем предыдущую часть пути для сращивания.
    return os.path.dirname(__file__).split('common')[0]

# Затем мы определяем здесь метод для анализа файла yaml.
def read_yaml(yamlPath):
    with open(get_obj_path() + yamlPath,mode = 'r',encoding = 'utf-8') as f:
        # Нам нужен пип здесь install pyyaml
        value = yaml.load(steam=f,Loader=yaml.FullLoader)
        return value
    
# Затем мы используем здесь основной метод для выполнения описанного выше варианта использования (на самом деле он должен выполняться в других тестовых классах)
if __name__ = '__main__':
    # Вызовите метод read_yaml и укажите путь yaml.
    print(read_yaml('testcase/user_manage/get_token.yaml'))

# Прежде чем мы все поймем, мы можем объединить его с предыдущим параметризацией для работы:
# Здесь мы меняем необходимые данные на содержимое yaml-файла, читаемого read_yaml.
@pytest.mark.parametrize('caseinfo',read_yaml('testcase/user_manage/get_token.yaml'))
def test_01_get_token(self,caseinfo):
    # Здесь мы можем получить содержимое файла yaml и вывести его.
	print("Получить код аутентификации единого интерфейса:"+caseinfo)
    
# Конечно, если мы знаем, какие элементы есть в нашем yaml, мы также можем использовать [], чтобы выразить это конкретно.
@pytest.mark.parametrize('caseinfo',read_yaml('testcase/user_manage/get_token.yaml'))
def test_01_get_token(self,caseinfo):
	print("Получить код аутентификации единого интерфейса:")
    # Здесь мы можем напрямую получить значение, соответствующее namekey
    print("caseinfo[name]："+ caseinfo['name'])
    # Здесь мы можем получить значения, соответствующие методу, URL-адресу и данным на уровне запроса.
    print("caseinfo[name]："+ caseinfo['request']['method'])
    print("caseinfo[name]："+ caseinfo['request']['url'])
    print("caseinfo[name]："+ caseinfo['request']['data'])