Примеры тестовых сценариев

Что такое тестирование сценария?

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

Давайте изучим это с помощью видео ниже —

Зачем создавать тестовые сценарии?

Тестовые сценарии создаются по следующим причинам:

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

Когда не создать тестовый сценарий?

Тестовые сценарии не могут быть созданы, когда

• Тестируемое приложение является сложным, нестабильным, и в проекте есть время.
• Проекты, которые следуют Agile методологии, такие как Scrum, Kanban, могут не создавать тестовые сценарии.
• Сценарий тестирования не может быть создан для исправления новой ошибки или регрессионного тестирования . В таких случаях сценарии тестирования должны быть уже задокументированы в предыдущих циклах тестирования. Это особенно верно для проектов технического обслуживания.

Как написать тестовые сценарии

Как тестер, вы можете выполнить следующие пять шагов для создания тестовых сценариев:

• Шаг 1 : Прочтите документы с требованиями, такие как BRS, SRS, FRS, тестируемой системы (SUT). Вы также можете сослаться на примеры использования, книги, руководства и т. Д. Приложения, подлежащего тестированию.
• Шаг 2 : Для каждого требования определите возможные действия и цели пользователей. Определить технические аспекты требования. Определите возможные сценарии злоупотребления системой и оцените пользователей с менталитетом хакера.
• Шаг 3: После прочтения Документа с требованиями и проведения надлежащего анализа перечислите различные сценарии тестирования, которые проверяют каждую функцию программного обеспечения.
• Шаг 4: После того, как вы перечислили все возможные сценарии тестирования, создается матрица отслеживания, чтобы убедиться, что каждому требованию соответствует соответствующий сценарий тестирования.
• Шаг 5: Созданные сценарии проверяются вашим руководителем. Позже они также рассматриваются другими заинтересованными сторонами в проекте.

Советы по созданию тестовых сценариев

• Каждый тестовый сценарий должен быть привязан как минимум к одному требованию или пользовательской истории в соответствии с методологией проекта.
• Перед созданием тестового сценария, который проверяет несколько требований одновременно, убедитесь, что у вас есть тестовый сценарий, который проверяет это требование изолированно.
• Избегайте создания слишком сложных тестовых сценариев, охватывающих несколько требований.
• Количество сценариев может быть большим, и запускать их все дорого. Исходя из приоритетов клиента, запускайте только выбранные тестовые сценарии

Пример 1. Сценарий тестирования для приложения электронной коммерции

Для приложения электронной коммерции несколько тестовых сценариев

Тестовый сценарий 1: проверка функциональности входа

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

1. Проверьте поведение системы при вводе действительного адреса электронной почты и пароля.
2. Проверьте поведение системы при вводе неверного идентификатора электронной почты и действительного пароля.
3. Проверьте поведение системы при вводе действительного адреса электронной почты и неверного пароля.
4. Проверьте поведение системы при вводе неверного идентификатора электронной почты и неверного пароля.
5. Проверьте поведение системы, если адрес электронной почты и пароль оставлены пустыми и введен вход.
6. Проверить Забыли пароль работает как положено
7. Проверьте поведение системы при вводе действительного / недействительного номера телефона и пароля.
8. Проверять поведение системы, когда установлен флажок «Держать меня в подписи»

Как видно, тестовые случаи являются более конкретными.

Тестовый сценарий 2. Проверка функциональности поиска

Any capability that may be tested is defined as a TEST SCENARIO. It’s also known as Test Possibility or Test Condition. As a tester, you should put yourself in the shoes of the end user and determine the Application Under Test’s real-world scenarios and use cases.

In liner statements, a test scenario is a complete list containing test cases that cover end-to-end functionality of a software program. A scenario is defined as a liner statement. The test scenario is a classification of testable requirements at a high level. These criteria are categorized according to a module’s functionality and derived from use cases.

Because there are so many test cases in the scenario, there is a thorough testing process. The tester must evaluate the test cases for each scenario before completing the test scenario. Testers must put themselves in the shoes of the user in the test scenario because they are testing the software application from the user’s perspective. The most important aspect of the process is scenario preparation, which necessitates seeking advice or assistance from customers, stakeholders, or developers.

Important − Because the text scenario process does not include navigation steps or input, the test execution process cannot be done.

These are high-level documents that describe all of the conceivable permutations or various ways or combinations of utilizing the application, with the primary goal of understanding the application’s general flow.

Method of Writing Test Scenario

To build Test Scenarios as a tester, follow these steps —

• Examine the software’s requirement documents, such as SRS (System Requirement Specification), the BRS (Business Requirement Specification), and FRS (Functional Requirement Specification). You could also consult the application’s use cases, books, manuals, and other resources.

• For each requirement, determine all technical aspects and objectives.

• Find every feasible way for the user to interact with the software.

• Determine all possible scenarios in which the system could be exploited, as well as users who could be hackers.

• Make a list of various test cases to check each function of the software after reading the requirement document and completing the scheduled analysis.

• Create a traceability matrix after you’ve identified all of the possible test scenarios to see if each requirement has a matching test scenario or not.

• All possibilities are reviewed by the project supervisor. They are then evaluated by the project’s other stakeholders.

When writing test cases, we had to observe a few rules —

• Always keep a list of the most frequently utilized features and modules.

• We usually begin the scenarios by selecting modules one by one, in order to maintain a good sequence and avoid missing any module levels.

• Scenarios are usually defined at the module level.

• Delete scenario should always be the final resort; else, we will waste a lot of time re-creating data.

• It should be written in plain English.

• Every scenario should be written in a single or two-line format, try not to write in paragraphs.

• Do’s and checks should be included in every scenario.

Reason for creating Test Scenario

One test scenario can cover several test cases. As a result, Test Scenarios and Test Cases have a one-to-many relationship. However, the tester must consider each scenario when developing it. It was created by testers to test the application from the perspective of an end-user. Testers look for crucial information from all developers, stakeholders, and customers.

The following are the reasons for their creation −

• The design of excellent Test Scenarios ensures complete and proper Test Coverage.

• It is necessary to create them in order to investigate a program’s end-to-end functionality.

• They can be used to determine the most significant and critical end-to-end transactions or real-time application usage.

• They can be used as a tool for quickly determining testing workforce, which can then be utilized to assist clients or organizations with proposal creation and testing workforce organization efficiently and effectively.

• Approval of applications is done at multiple levels, including customers, business analysts, developers, and so on, to ensure thorough and proper testing.

When Test Scenario should not be created

There are some conditions in which its production should be prevented —

• It is unlikely to be developed in projects that use Agile Methodologies like Scrum.

• It may be avoided when the applications to be tested are unstable or excessively complicated, or when the project is in a critical-time state.

• Its creation may be prevented for regression testing or a new defect because substantial documentation of them would happen in previous test cycles in maintenance projects.

Features of Test Scenario

• The test scenario is a one-liner that directs testers through the testing process.

• The product’s complexity and repetition are reduced by using a test scenario.

• A test scenario is when you talk and think about tests in great detail yet write them down in liner statements.

• It’s a series of procedures threaded together.

• When the tester does not have enough time to write test cases and the team agrees on a comprehensive liner scenario, the test scenario becomes more significant.

• The test scenario is a useful activity for saving time.

• It is simple to maintain because adding and modifying test scenarios is simple and self-contained.

Test Scenario Examples

We’re using the Gmail application to create test cases for the most often used modules, such as Login, Compose, and inbox

Test Scenarios for the Login module

• Check that the home page is displayed after entering the correct login information (username and password).

• Check for the home page after entering the invalid Username and password.

• Check for an error message if you leave the username and password fields blank.

• Enter a valid Login, click Cancel, and look for the fields to be reset.

• Check that the account has been blocked by entering invalid Login more than three times.

• Check sure the Username is displayed on the home screen after entering a valid Login.

Test Scenario for compose module

• Checks if all users have access to the To, Cc, and Bcc email addresses.

• Check that the entire user has access to the To, Cc, and Bcc fields.

• Prepare a message, send it, and wait for a confirmation message.

• Compose an email, send it, and check the sender’s sent item as well as the inbox.

• Create a message, send it, and check for invalid and legitimate email addresses (valid format) in the sender’s inbox

• Check for conformation messages and check-in draft messages after composing main and then discarding it.

• After you’ve finished writing your email, save it as a draft and look for the confirmation message.

• Compose an email, shut it, and check for confirmation before saving it as a draft.

On the Inbox module, Test scenario.

• Check that all received mail is shown and highlighted in the inbox by clicking on it.

• Check that the sender email id for the most recent received email has been accurately displayed.

• Select the email, reply, and forward it; check the sender’s sent item and the receiver’s inbox.

• Examine any attached attachments to the email to see if they have been downloaded or not.

• Before downloading, be sure the attachment has been properly inspected for malware.

• Select the email, reply, and forward it, then save it as a draft. Check the Draft section for the confirmation message and checks.

• Check that all of the emails that have been marked as read have not been highlighted.

• Verify that all Cc recipients are visible to all users.

• Checks that all Bcc email recipients are hidden from the users.

• Select the message, delete it, and then check the Trash folder.

Any capability that may be tested is defined as a TEST SCENARIO. It’s also known as Test Possibility or Test Condition. As a tester, you should put yourself in the shoes of the end user and determine the Application Under Test’s real-world scenarios and use cases.

In liner statements, a test scenario is a complete list containing test cases that cover end-to-end functionality of a software program. A scenario is defined as a liner statement. The test scenario is a classification of testable requirements at a high level. These criteria are categorized according to a module’s functionality and derived from use cases.

Because there are so many test cases in the scenario, there is a thorough testing process. The tester must evaluate the test cases for each scenario before completing the test scenario. Testers must put themselves in the shoes of the user in the test scenario because they are testing the software application from the user’s perspective. The most important aspect of the process is scenario preparation, which necessitates seeking advice or assistance from customers, stakeholders, or developers.

Important − Because the text scenario process does not include navigation steps or input, the test execution process cannot be done.

These are high-level documents that describe all of the conceivable permutations or various ways or combinations of utilizing the application, with the primary goal of understanding the application’s general flow.

Method of Writing Test Scenario

To build Test Scenarios as a tester, follow these steps —

• Examine the software’s requirement documents, such as SRS (System Requirement Specification), the BRS (Business Requirement Specification), and FRS (Functional Requirement Specification). You could also consult the application’s use cases, books, manuals, and other resources.

• For each requirement, determine all technical aspects and objectives.

• Find every feasible way for the user to interact with the software.

• Determine all possible scenarios in which the system could be exploited, as well as users who could be hackers.

• Make a list of various test cases to check each function of the software after reading the requirement document and completing the scheduled analysis.

• Create a traceability matrix after you’ve identified all of the possible test scenarios to see if each requirement has a matching test scenario or not.

• All possibilities are reviewed by the project supervisor. They are then evaluated by the project’s other stakeholders.

When writing test cases, we had to observe a few rules —

• Always keep a list of the most frequently utilized features and modules.

• We usually begin the scenarios by selecting modules one by one, in order to maintain a good sequence and avoid missing any module levels.

• Scenarios are usually defined at the module level.

• Delete scenario should always be the final resort; else, we will waste a lot of time re-creating data.

• It should be written in plain English.

• Every scenario should be written in a single or two-line format, try not to write in paragraphs.

• Do’s and checks should be included in every scenario.

Reason for creating Test Scenario

One test scenario can cover several test cases. As a result, Test Scenarios and Test Cases have a one-to-many relationship. However, the tester must consider each scenario when developing it. It was created by testers to test the application from the perspective of an end-user. Testers look for crucial information from all developers, stakeholders, and customers.

The following are the reasons for their creation −

• The design of excellent Test Scenarios ensures complete and proper Test Coverage.

• It is necessary to create them in order to investigate a program’s end-to-end functionality.

• They can be used to determine the most significant and critical end-to-end transactions or real-time application usage.

• They can be used as a tool for quickly determining testing workforce, which can then be utilized to assist clients or organizations with proposal creation and testing workforce organization efficiently and effectively.

• Approval of applications is done at multiple levels, including customers, business analysts, developers, and so on, to ensure thorough and proper testing.

When Test Scenario should not be created

There are some conditions in which its production should be prevented —

• It is unlikely to be developed in projects that use Agile Methodologies like Scrum.

• It may be avoided when the applications to be tested are unstable or excessively complicated, or when the project is in a critical-time state.

• Its creation may be prevented for regression testing or a new defect because substantial documentation of them would happen in previous test cycles in maintenance projects.

Features of Test Scenario

• The test scenario is a one-liner that directs testers through the testing process.

• The product’s complexity and repetition are reduced by using a test scenario.

• A test scenario is when you talk and think about tests in great detail yet write them down in liner statements.

• It’s a series of procedures threaded together.

• When the tester does not have enough time to write test cases and the team agrees on a comprehensive liner scenario, the test scenario becomes more significant.

• The test scenario is a useful activity for saving time.

• It is simple to maintain because adding and modifying test scenarios is simple and self-contained.

Test Scenario Examples

We’re using the Gmail application to create test cases for the most often used modules, such as Login, Compose, and inbox

Test Scenarios for the Login module

• Check that the home page is displayed after entering the correct login information (username and password).

• Check for the home page after entering the invalid Username and password.

• Check for an error message if you leave the username and password fields blank.

• Enter a valid Login, click Cancel, and look for the fields to be reset.

• Check that the account has been blocked by entering invalid Login more than three times.

• Check sure the Username is displayed on the home screen after entering a valid Login.

Test Scenario for compose module

• Checks if all users have access to the To, Cc, and Bcc email addresses.

• Check that the entire user has access to the To, Cc, and Bcc fields.

• Prepare a message, send it, and wait for a confirmation message.

• Compose an email, send it, and check the sender’s sent item as well as the inbox.

• Create a message, send it, and check for invalid and legitimate email addresses (valid format) in the sender’s inbox

• Check for conformation messages and check-in draft messages after composing main and then discarding it.

• After you’ve finished writing your email, save it as a draft and look for the confirmation message.

• Compose an email, shut it, and check for confirmation before saving it as a draft.

On the Inbox module, Test scenario.

• Check that all received mail is shown and highlighted in the inbox by clicking on it.

• Check that the sender email id for the most recent received email has been accurately displayed.

• Select the email, reply, and forward it; check the sender’s sent item and the receiver’s inbox.

• Examine any attached attachments to the email to see if they have been downloaded or not.

• Before downloading, be sure the attachment has been properly inspected for malware.

• Select the email, reply, and forward it, then save it as a draft. Check the Draft section for the confirmation message and checks.

• Check that all of the emails that have been marked as read have not been highlighted.

• Verify that all Cc recipients are visible to all users.

• Checks that all Bcc email recipients are hidden from the users.

• Select the message, delete it, and then check the Trash folder.

Введение в тестовый сценарий

Тестовый сценарий — это комбинация двух слов, то есть теста и сценария. Тест представляет собой акт проверки или подтверждения, а сценарий представляет собой путешествие пользователя. Любая тестируемая функциональность называется сценарием тестирования. Сценарий тестирования может быть описан как проверка или подтверждение правильности поездки пользователя. Он будет в форме документов, содержащих все тестовые примеры, подробно написанные для проверки сквозной функциональности приложений. Это одна из высокоуровневых категорий требований, которые можно проверить. Это также известно как возможность тестирования или условия тестирования.

Зачем создавать тестовые сценарии?

Несколько тестовых случаев могут быть охвачены одним тестовым сценарием. Следовательно, связь между сценариями тестирования и контрольными случаями является однозначным. Но каждый сценарий должен быть учтен тестером при его создании. Тестеры создают его для тестирования приложения с точки зрения конечного пользователя. Тестировщики стремятся от всех разработчиков, заинтересованных сторон и клиентов подготовить их, которые являются критическими.

Причина их создания заключается в следующем:

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

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

• Его нельзя создавать в проектах, следующих за гибкими методологиями, такими как Scrum и т. Д.
• Когда тестируемые приложения нестабильны или слишком сложны, или когда проект находится в критическом состоянии, его создания можно избежать.
• Его можно избежать для регрессионного тестирования или для новой ошибки, потому что в проектах технического обслуживания их тяжелая документация может произойти заранее в предыдущих циклах тестирования.

Как тестовые сценарии могут быть написаны?

Следующие шаги могут быть выполнены тестером для создания тестовых сценариев:

• Шаг 1: Документ о требованиях, таких как Спецификация бизнес-требований (BRS), Спецификация функциональных требований (FRS) и Спецификация системных требований (SRS) приложения, подлежащего тестированию, следует внимательно и тщательно прочитать. Руководства, книги, варианты использования и т. Д. Тестируемого приложения могут быть отнесены к тому же.
• Шаг 2: Все возможные цели и действия пользователя должны быть правильно определены для каждого требования. Все технические характеристики каждого требования также должны быть определены.
• Шаг 3: Все возможные причины взлома системы и оценки пользователя должны выполняться с точки зрения хакера. Оценка пользователя может быть выполнена путем нахождения всех возможностей пользовательского управления приложениями.
• Шаг 4: Полный список всех возможных тестовых случаев для проверки всех функциональных возможностей приложения должен быть составлен после полного прочтения документа с требованиями и завершения анализа.
• Шаг 5: После привлечения всех из них для проверки соответствия требования и его сценария тестирования должна быть создана матрица отслеживания.
• Шаг 6: Все созданные тестовые сценарии проверяются и оцениваются супервизором. Это также дополнительно проверяется всеми заинтересованными сторонами.

В соответствии с процедурой проекта каждый сценарий тестирования должен соответствовать как минимум одной пользовательской истории или требованию. Обязательно проверять каждый тестовый сценарий на соответствие его требованию отдельно, перед несколькими требованиями в одном тестовом сценарии. Сложные тестовые сценарии с несколькими требованиями можно избежать для простоты. Цена прямо пропорциональна их количеству. Поэтому желательно всегда запускать только выбранные и требуемые в соответствии с приоритетом клиента.

Примеры

Ниже приведены несколько примеров сценария тестирования.

Тестовый сценарий для интернет-магазина приложений Buykart

Сценарии тестирования, которые можно принять во внимание при проверке приложения для онлайн-покупок Buykart, следующие:

Тестовый сценарий 1: проверка работоспособности входа

Тестовые случаи, которые можно рассмотреть для создания:

• Поведение приложения при вводе действительного идентификатора входа и действительного пароля можно проверить.
• Поведение приложения при вводе действительного логина и неверного пароля может быть проверено.
• Поведение приложения при вводе неверного логина и действительного пароля можно проверить.
• Поведение приложения при вводе неверного логина и неверного пароля можно проверить.
• Поведение приложения при входе путем ввода идентификатора входа без пароля можно проверить.
• Поведение приложения при входе путем ввода пароля без идентификатора входа можно проверить.
• Поведение приложения при входе в систему без ввода логина и пароля можно проверить.
• Поведение приложения при выборе забытого пароля.

Тестовый сценарий 2. Проверка функциональности поиска

Тестовые случаи, которые можно рассмотреть для создания:

• Поведение приложения при поиске действующего товара.
• Поведение приложения при поиске недействительного продукта.

Тестовый сценарий 3: проверка деталей продукта

Тестовые случаи, которые можно рассмотреть для создания:

• Поведение приложения при выборе продукта.
• Поведение приложения продукта в списке пожеланий.
• Поведение приложения при добавлении товара в корзину.
• Поведение приложения при выборе опции «Купить сейчас».
• Поведение приложения при вводе неверного адреса.
• Поведение приложения при вводе действительного адреса.
• Поведение приложения при проверке нескольких вариантов оплаты.

Тестовый сценарий 4: проверка функциональности платежа

Тестовые случаи, которые можно рассмотреть для создания:

• Поведение приложения при выборе каждого варианта оплаты.
• Поведение приложения, когда выбран правильный способ оплаты.
• Поведение приложения при выборе неверного варианта оплаты.
• Поведение приложения при успешной оплате.
• Поведение приложения при отклонении платежа.

Тестовый сценарий 5: проверка функциональности деталей заказа

Тестовые случаи, которые можно рассмотреть для создания:

• Поведение приложения при выборе каждого заказа.
• Поведение приложения при выборе опции «Возврат товара».
• Поведение приложения при выборе опции отслеживания товара.
• Поведение приложения при выборе опции «Обзор продукта».

Вывод

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

Рекомендуемые статьи

Это было руководство к тому, что такое тестовый сценарий. Здесь мы обсудим, как создавать тестовые сценарии на разных примерах. Вы также можете взглянуть на следующие статьи, чтобы узнать больше —

1. Стресс нестабильности работы
2. Мотивированный и посвященный
3. Что такое Agile Testing?
4. Как написать контрольный пример?

Что такое тестовый пример?

Тестовые примеры содержат ряд действий, которые мы выполняем для улучшения определенной функции или функциональности нашего приложение определить.

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

Пример тестового сценария

Распространенной частью программного обеспечения является функциональность входа в систему. тестовый сценарий это может быть описано в тестовых случаях следующим образом:

• Тестовый пример 1: проверьте работу при вводе правильного имени пользователя и пароля.
• 2: Проверьте операцию, если введены неверные имя пользователя и пароль.
• 3: Проверьте операцию, если имя пользователя пусто и нажата кнопка входа.
• И так далее.

Такого рода тестовые сценарии довольно расплывчаты и включают широкий диапазон переменных. Тем не менее, тестирование очень специфично. Вот почему у нас есть сложные тестовые примеры nodig.

Запись тестовых примеров

Определение тестовых примеров может занять много времени, и иногда нам приходится повторять тест. Вот почему нам нужно их задокументировать. Мы должны записать следующие элементы для каждого тестового примера:

• Тестовый кейс должен иметь ожидаемый результат.
  В нашем тестовом случае ожидаемым результатом было бы успешное вход в систему.
  Если мы не предопределим ожидаемые результаты, мы можем пропустить небольшие различия в расчетах. Результаты могут выглядеть хорошо, но на самом деле они ошибочны. Например, если мы рассчитаем зарплату, могут быть только незначительные различия. Если мы заранее определим ожидаемый результат, то увидим отклонения в тесте. Предположим, создатель тестового примера покинул организацию, и теперь нам нужно запустить тестовый пример. Тогда это помогает, если контрольный пример задокументирован.
• Тестовый случай может иметь Предварительные условия, например, определенные значения в базе данных, которые должны присутствовать заранее. Для этого теста, имя пользователя / пароль должны быть введены заранее.
• Тестовый набор также может включать в себя условия после завершения теста, которые применяются после его завершения. Для этого тестового случая было бы условием публикации, что дата и время входа в систему хранятся в базе данных. Нам также необходимо сохранить статус входа в систему, чтобы работать с приложением.
• Во время выполнения контрольного примера мы документируем результаты, полученные в столбце фактических результатов.

Проектирование тестовых примеров

Формат для теста входа в систему содержит следующий формат:

1. Идентификатор теста
2. Часть тестового сценария.
3. Тестовые шаги должны быть выполнены.
4. Тестовые данные.
5. Ожидаемые результаты.
6. Актуальные результаты.
7. Результат теста (успешный или нет).

При подготовке тестового примера нам нужна следующая информация:

• Описание которого требование мы собираемся проверить.
• Объяснение о том, как проверить систему.
• Принципы тестирования, такие как: версия приложения для тестирования, файлы данных, операционная системааппаратное обеспечение, безопасный доступфизическая или логическая дата, время суток, требования, такие как другие тесты, и другая информация о настройках, связанная с требованиями, которые мы тестируем.
• Входы и выходы тестов.
• Тест может содержать не более 15 шагов.

Лучшие практики для хороших тестовых случаев

1. Контрольные примеры должны быть простыми и прозрачными

Создавайте максимально простые тесты. Они должны быть четкими и краткими, так как разработчик тестовых случаев не может их запускать.

Используйте напористый язык, например, перейдите на домашнюю страницу, введите информацию, щелкните по ней и так далее. Это упрощает понимание этапов тестирования и ускоряет выполнение тестов.

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

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

3. Избегайте повторения тестовых случаев

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

4. Не оставляйте доставленное приложение

Однако не предполагайте, что приложение работает при подготовке тестового примера. Придерживайтесь требований и проектная документация.

5. Обеспечить покрытие 100%

Убедитесь, что вы создали тестовые случаи, которые проверяют все перечисленные требования к программному обеспечению. Кроме того, используйте ЖЕСТОКИЙ матрица, чтобы гарантировать, что никакие функции / условия не будут непроверены.

6. Контрольные примеры должны быть идентифицируемыми

Назовите идентификатор тестового примера, чтобы мы могли легко его идентифицировать. Это полезно для отладки или определения требования на более позднем этапе.

7. Повторяемость и автономность

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

8. Обзор коллегиального обзора

После того, как мы создали тестовые примеры, мы передаем их на рассмотрение коллеге. Коллеги могут найти ошибки в наших тестовых примерах, которые мы сами упустили.

Обсудить с нами LinkedIn.

Когда ручного тестировщика впервые просишь проверить метод REST API, того охватывает паника: «Как это делать? Я вообще почти ничего не знаю про API. Что делать? Как это тестировать?»

Спокойно. Без паники =) Я уже рассказывала на простом языке, что такое API. А сегодня я расскажу о том, как его тестировать. На самом деле почти также, как GUI: в первую очередь это тест-дизайн и придумывание проверок, а потом уже всякие API-штучки. Но и про них не стоит забывать.

Я дам вам чек-лист, к которому вы сможете обращаться потом — «так, это проверил, и это, и это. А вот это забыл, пойду посмотрю!». А потом мы обсудим каждый пункт — зачем это проверять и как.

После теории будет практика! Для неё возьмем метод doRegister системы Users — он находится в открытом доступе, можете дергать по ходу чтения и проверять =) 

Чек-лист проверок

Общий чек-лист:

1. Правильное тело (пример)

2. Бизнес-логика: позитив, негатив

3. Различные параметры (обязательность, работа параметров)

4. Перестановка мест слагаемых (заголовки, тело)

5. Регистрозависимость (заголовки, тело)

6. Ошибки: не well formed xml / json

Где искать параметры:

• В URL

• В заголовках

• В теле запроса

• Комбинация

Тестирование параметров:

1. Правильный параметр (из примера)

2. Обязательность (что, если параметр не указать?)

3. Бизнес-логика (тест-дизайн)

4. Регистрозависимость (если параметр текстовый)

5. Перестановка местами

То есть берём REST-часть и обычную, применяем тест-дизайн, словно это параметр в графическом интерфейсе.

Тестирование заголовков:

• Заголовки из документации работают (в целом)

• А если какой-то не передать? (обязательность)

• А если передать, но неправильно? (текст ошибки)

• Позитивные тесты по доке

• Регистронезависимость заголовков

Что смотрим в ответе:

• Status Code

• Body

В теле смотрим:

1. Какие поля вернулись в ответе?

2. Значения в полях

3. Текст ошибок 

Поля в ответе нужно:

• сравнить с ТЗ

• сравнить между собой SOAP REST 

Кратко прошлись, теперь разберемся в деталях и с примерами.

Содержание

• Позитив или негатив?

• В каком порядке тестируем

  1. Примеры

  2. Основной позитивный сценарий

  3. Альтернативные сценарии/a>

  4. Негативные сценарии

  5. Параметры запроса

  6. Остальные тесты

• Что тестируем в запросе

  1. Заголовки (Headers)

  2. Тело запроса (body)

  3. URL

  4. Тип метода

• Что тестируем в ответе

  1. Тело ответа

  2. Статус-коды

• Итоговый чек-лист проверки doRegister

• Вывод

Позитив или негатив?

Я учу начинающих тестировщиков так: ВСЕГДА сначала позитивное тестирование, а потом негативное. Иначе вы успеете проверить всякий треш, а с нормальными данными система работать не будет. 

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

Сначала надо проверить негатив. Потому что разработчики продукта, которые подключают наше API, всегда будут напарываться на грабли. Не прочитали документацию / прочитали криво — получили ошибку.

И нужно, чтобы по сообщению об ошибке они поняли:

— Что они сделали не так

— Как это исправить

Это нужно для того, чтобы уменьшить количество обращений в тех. поддержку.

Так что проверьте сначала всякие извращения, а потом, пока разработчик чинит найденные баги, сидите со своими позитивными тестами и позитивными сценариями.

В целом, есть логика в его словах. Ну и плюс всё зависит от времени, если вам позитивные тесты погонять займет полчасика, то проще начать с них. А если там куча сценариев + обязательные автотесты часа на 4, то можно сначала погонять руками, выдать пачку замечаний и сидеть спокойно писать свои тесты.

Обсудите со своими разработчиками, как им будет удобнее — чтобы вы сначала потыкали “на слом” и прислали очевидные баги, или вдумчиво проверили всё и прислали результат одним файлом. Как им удобнее, так и делайте. 

Но лично я всё же считаю, что как минимум основной сценарий позитивный проверить надо. И желательно пару ответвлений от него.

В каком порядке тестируем

1. Примеры в ТЗ

Самое простое, что можно сделать — дернуть пример из документации, чтобы посмотреть, как метод вообще работает. А потом уже писать обвязку в коде.

Это пойдут делать тестировщики, получив от вас новый функционал. И это же сделает разработчик интеграции / другой пользователь API.

Отсюда вытекают следующие выводы:

а) Примеры в документации должны быть! Причем желательно не один, а на каждый интересный кейс. Чтобы на него точно обратили внимание!

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

Практика на примере Users

В Users есть только один пример:

{

    "email": "milli@mail.ru",

    "name": " Машенька",

    "password": "1"

}

Его и попробуем отправить!

• Тип запроса — POST

• URL — http://users.bugred.ru/tasks/rest/doregister

• Тело — из примера

Упс, ошибочка… Читаем её внимательно: 

" email milli@mail.ru уже есть в базе"

В целом логично, раз метод создает нового пользователя, может быть ограничение уникальности. Смотрим в ТЗ, и правда:

Имя и емейл должны быть уникальными

Значит, метод не идемпотентный… Нельзя просто взять пример из ТЗ и отправить не глядя.

Справка

Метод HTTP является идемпотентным, если повторный идентичный запрос, сделанный один или несколько раз подряд, имеет один и тот же эффект, не изменяющий состояние сервера. Корректно реализованные методы GET, HEAD, PUT и DELETE идемпотентны, но не метод POST. © developer.mozilla.org

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

{

    "email": "milli5678@mail.ru",

    "name": " Машенька5678",

    "password": "1"

}

А можно использовать функционал Postman, который позволяет указать рандомные значения — динамические переменные. Пожалуй, мне хватит $randomInt. Но так как я отправляю запрос в JSON-формате, то надо обернуть переменную в фигурные скобки, иначе постман считает её как простой текст:

{

    "email": "milli{{$randomInt}}@mail.ru",

    "name": " Машенька{{$randomInt}}",

    "password": "1"

}

Сработало!

См также: Как понять, что мы отправляли, какую переменную? 

Пример проверили, отлично. Он рабочий, но не идемпотентный, так что его нужно скорректировать под себя. Документация НЕ неправильная, запрос рабочий, если его прогонять на пустой базе в первый раз.

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

И чем больше у вас пользователей, тем больше таких вопросов будет. Заводить ли тут баг на правку документации? Можно предложить дописать в ТЗ как-то так:

Запрос (для проверки запроса исправьте имя пользователя и email, чтобы они были уникальными): …

То есть заранее подсказываем, что надо изменить, чтобы запрос сработал AS IS. Можно было бы и пример с рандомными переменными постмана дать, но тут надо понимать, что через постман его будут дергать тестировщики и аналитики со стороны заказчика.

Разработчики же должны написать код, используя ваш пример. А они тоже любят копипастить))) И если дать пример, заточенный под постман, то к вам снова придут с вопросом, почему ваш пример не работает, но уже в коде. И тут опять или писать около примера, что “$randomInt — переменная Postman, она тут для того-то”, или всё же примеры оставить в покое.

Я не вижу особой проблемы в текущем описании, это не повод ставить баг на документацию. Пример нормальный и рабочий. А если принесет головную боль поддержке, тогда и замените.

В нашей доке всего 1 пример. Если бы их было больше, надо было бы вызвать все. Именно на примерах пользователи учатся работать с системой. Дернули, получили такой же ответ, изучили его, осознали, запомнили =)

2. Основной позитивный сценарий

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

В идеале он берет этот сценарий из примера. Если примеров нет, будет дергать метод наобум, как он считает правильным. Знаете, как с новым девайсом — сначала попробовал сам, если не получилось, пошел читать инструкцию.

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

Практика на примере Users

А у нас есть пример, так что основной позитивный сценарий мы уже почти проверили! 

Почему “почти”? Мы проверили, что система вернула в ответе «успешно создалась Машенька562», но точно ли она создалась? Может быть, разработчик сделал заглушку и пока метод в разработке, он всегда возвращает ответ в стиле “успешный успех”, ничего при этом не делая.

Так что идем и проверяем, есть ли наша Машенька в GUI — http://users.bugred.ru/. Ищем поиском — есть!

Проверяем все поля:

• Емейл правильный, какой мы отправляли.

• Автор «rest», что логично.

• Дата изменения — сегодня, что тоже правильно.

Значит, пользователь правда создан! Хотя постойте… Я же выполняла не метод CreateUser, а doRegister. Его основная цель — не создать карточку, а зарегистрировать пользователя в системе. Просто при регистрации карточка автоматом создается, поэтому её тоже зацепили проверкой.

А как проверить, что регистрация прошла успешно? Правильно, попробовать авторизоваться!

Нажимаем «Войти» и вводим наши данные: milli754@mail.ru / 1

Вошли! Ура, значит, регистрация правда сработала. Вот теперь мы закончили с основным позитивным сценарием.

3. Альтернативные сценарии

На самом деле если в ТЗ нет отдельно выделенного сценария использования, то можно объединить пункты “альтернативные сценарии” и “негативное тестирование”, потому что по факту после базового теста мы:

1. Читаем каждое предложение из ТЗ, «Особенности использования» или как этот раздел у вас называется

2. Продумываем, как его проверить: как позитивно, так и негативно.

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

Практика на примере Users

Читаем особенности использования:

Пользователь создается и появляется в системе.

Это мы уже проверили. Дальше:

Автор у него всегда будет «SOAP / REST», изменять его можно только через соответствующий-метод.

Автора тоже проверили, но только вот в ТЗ он указан капсом, а по факту создается в нижнем регистре. Это уже небольшой баг, скорее всего документации, так как некритично и проще доку обновить. Сделали заметочку / сами исправили доку, если есть доступ.

А дальше видим, что изменять только только через соответствующий метод. Ага, то есть если создали через REST, менять можно тоже только через REST, через SOAP нельзя. И наоборот. Это и проверим.

Для начала под Машенькой в ГУИ посмотрим, есть ли возможность отредактировать собственную карточку — нету. Ок. Открываем в SOAP Ui WSDL проекта — http://users.bugred.ru/tasks/soap/WrapperSoapServer.php?wsdl, и смотрим, каким методом можно вносить изменения.

Нам вполне подойдет UpdateUserOneField, он обновляет одно любое поле пользователя. А как понять, какие поля есть? Покопаться в документации. В Users описаны не все методы, но есть описание CreateUser, где можно взять названия полей. Допустим, хочу обновить кличку кошки — cat. Получается запрос:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wrap="http://foo.bar/wrappersoapserver">

   <soapenv:Header/>

   <soapenv:Body>

      <wrap:UpdateUserOneField>

         <email>milli754@mail.ru</email>

         <field>cat</field>

         <value>Еночка</value>

      </wrap:UpdateUserOneField>

   </soapenv:Body>

</soapenv:Envelope>

Отправляем, хммммм:

Поле cat успешно изменено на Еночка у пользователя с email milli754@mail.ru

Проверяем в интерфейсе, находим карточку пользователя и жмем “Просмотр” (прямую ссылку давать бесполезно, база дропается каждую ночь, тут только самому создать и посмотреть). Значение обновилось:

Значит, условие из ТЗ не выполнено, можно ставить баг!

А мы пока читаем дальше:

Имя и емейл должны быть уникальными

Раз должны, то будет ошибка в случае неуникальности. А мы решили вынести тестирование негативных сценариев отдельно. Видите, решение тестировать альтернативы отдельно от негативного сразу оказалось не самым удобным — куда лучше просто читать ТЗ и каждый пункт проверять. Так хоть не запутаешься, что проверил, а что ещё нет… Однако в рамках статьи мы всё-таки рассмотрим негативные тесты отдельно. 

Пока же смотрим дальше — а всё, кончилось ТЗ, метод то простенький. Тогда переходим к негативу!

4. Негативные сценарии

По факту это проверка сообщений об ошибках. Смотрим на метод и думаем, как его можно сломать? Сначала бизнесово, а потом API-шно…

С бизнесовой точки зрения очень удобно, когда все ошибки прописывают прямо в ТЗ. Получается руководство к действию! Это можно быть разделение на «Особенности использования» и «Исключительные ситуации», как в Folks (логин для входа тут). Тогда тестируем блок «Исключительные ситуации».

Или вот описание Jira Cloud REST API, выберем в левом навигационном меню какой-нибудь метод, например «Delete avatar». Там есть описание метода, а потом в блоке Responces переключалки между кодами ответов.

Ну так вот все желтые коды — это ошибки. Открываем каждую, читаем «Returned if» и выполняем это условие, очень удобно:

В общем, если есть отдельно про ошибки — класс, проверяем по ТЗ. А потом ещё думаем сами, что там могло быть пропущено.

Плюс проверяем логику ошибок в API, но о ней чуть позже. Сначала бизнес-логика, потом уже серебряная пуля типа well formed json.

Практика на примере Users

Ограничение в ТЗ:

Имя и емейл должны быть уникальными

Для проверки нам надо сделать неуникальным:

1. имя

2. емейл

3. оба поля сразу

Можем взять за основу наш исходный запрос, который 1 раз создался:

{

    "email": "milli754@mail.ru",

    "name": " Машенька562",

    "password": "1"

}

И варьируем его

1. Уникальный емейл, дубликат имени

{

    "email": "milli{{$randomInt}}@mail.ru",

    "name": " Машенька562",

    "password": "1"

}

2. Уникальное имя, дубликат емейл

{

    "email": "milli754@mail.ru",

    "name": " Машенька{{$randomInt}}",

    "password": "1"

}

3. Дубликаты сразу имени и емейл

{

    "email": "milli754@mail.ru",

    "name": " Машенька562",

    "password": "1"

}

И смотрим на ответ. Понятно ли нам из сообщения об ошибке, что именно пошло не так? А статус-код соответствует типу ошибки?

5. Параметры запроса

На входе мы передаем какие-то параметры. И теперь нам нужно взять каждый параметр и проверить отдельно. Как проверяем:

1. Обязательность

2. Перестановка мест слагаемых

3. Бизнес-логика

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

Вот у вас есть параметры запроса. Как их проверять? Если вы впали в ступор сейчас, то просто представьте себе, что это не API, а GUI. Что у вас в интерфейсе есть форма ввода с этими полями? Как будете тестировать? Вот ровно так и тестируйте, выкинув разве что попытку убрать ограничение на клиенте (снять с поля maxlenght).

Практика на примере Users

По ТЗ входные параметры:

Тестируем каждый параметр в отдельности. И тут, как и в GUI, надо понимать:

• Есть ли какие-то проверки у поля? Проверяется ли email по маске email-а? Имя выверяется по справочникам? Или это “просто строка, как прислали, так и сохранил?”

• Куда данные идут дальше, где отображаются? В приветствии, в отчете, в личном кабинете, где?

• Как они потом используются? На емейл придет письмо?

email

Вроде доп. проверок разработчик не делал, но точно я этого не знаю. Поле базовое, может есть прям во фреймворке какие-то проверки, или в интернете скопипастил… Так что тут стоит убедиться, что email корректный.

Можно взять за основу вот этот чек-лист, но часть проверок скомбинировать

1. Корректный существующий email, куда может прийти почта — подставляем свой (начинаем всегда с корректного)

2. Верхний регистр, цифры в имени пользователя и доменной части — TEST77@mail9.ru

3. Email с дефисами и нижним подчеркиванием — test_user-1@mail_test-1.com

4. Email с точками в имени пользователя и парой точек в доменной части — test.user@test.test.test.ru

А дальше идут интересные тесты, которые по идее должны падать, но упадут ли в Users, есть ли там такие проверки?

1. Email без точек в доменной части — test@mailcom

2. Превышение длины email (>320 символов)

3. Отсутствие @ в email — testmail.ru

4. Email с пробелами в имени пользователя — test user@mail.ru

5. Email с пробелами в доменной части — test@ma il.ru

6. Email без имени пользователя — @mail.ru

7. Email без доменной части — test@

8. Некорректный домен первого уровня (допустимо 2-6 букв после точки: .ru) — test@mail.urururururu

Помним, что имя должно быть быть уникальным при этом, потому что негативные тесты мы не смешиваем, только если в этом состоит сам тест “а что, если несколько полей сразу плохие”. Так что пример запроса:

{

    "email": "test@mailcom",

    "name": " Машенька{{$randomInt}}",

    "password": "1"

}

И сервер отвечает — некорректный емейл!

Так что проверки на емейл нужны, особенно — на некорректный.

name

Имя можно тестировать по разному. Если по нему определяется пол, тесты будут одни, если предлагаются подсказки, другие, а если это простая строка — третьи.

Так вот, в Users имя — это простая строка. Пол по ней не определяется, оно просто сохраняется в системе, разве что в правом верхнем углу отображается

Поэтому закапываться в “а теперь проверим мужское имя, и женское, и…” смысла нет.. Так что наша задача — проверить:

• Что это правда простая строка и туда влезет всё, что можно

• Максимальную длину изучить

Ну и начинаем с позитивного теста. Итого получаем:

1. Простое имя типа “Ольга”

2. Имя с разным регистром, разными буквами и спецсимволами (все спецсимволы можно перечислить) — если есть ограничение по длине, разобьем на разные тесты

3. 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест.

4. 1 000 000 символов — ищем технологическую границу

Обратите внимание на то, что мы вроде как тестируем API-метод, но после его выполнения лезем в графический интерфейс и проверяем, как там выглядит результат нашего запроса.

А всё почему? Потому что нет абстрактных методов, которые делают “ничего”, просто отправляются. Они все зачем-то нужны. В нашем случае — чтобы создать пользователя в системе. И важно понимать, а что будет потом с нашими данными? Будут ли они нормально отображаться в интерфейсе? Ведь если нет, то надо ставить ограничение на API-метод.

Поэтому помните, что API и GUI идут рука об руку, а не живут в разных мирах.

Password

На пароле тоже никаких ограничений нет — мы это знаем, потому что уже отправляли запрос с паролем “1”. Вот если бы были всякие “нужны заглавные буквы” и прочее, мы бы провели тесты “а если пароль ненадежный” и посмотрели на качество сообщения об ошибке, а так тесты будут как у имени:

1. Обычный пароль типа 1

2. Смесь из разных регистров, разных букв и спецсимволов — если есть ограничение по длине или составу, разобьем на разные тесты

3. 1 000 символов — ищем верхнюю границу, если она есть. Заодно смотрим, как это выглядит в интерфейсе и корректируем тест.

4. 1 000 000 символов — ищем технологическую границу

6. Остальные тесты

А дальше мы уже идем по специфике API:

• Перестановка мест слагаемых (заголовки, тело)

• Регистрозависимость (заголовки, тело)

• Well formed xml / json

На конкретных примерах мы остановимся подробнее в следующих разделах. Просто важно не забывать про эти тесты. Этим и отличается API от GUI — тут нельзя снять границу из серии “убрать maxlenght”, зато можно и нужно проверить особенности API запросов.

Что тестируем в запросе

Заголовки (Headers)

Заголовки должны где-то обрабатываться:

— на сервере;

— на клиенте;

Иначе они не нужны, только лишний трафик гонять. Мы ведь передаем сообщение по сети, если интернет плохой, то каждый байт на счету. Зачем отправлять информацию, которую никто не использует?

Так что разработчики используют «Принцип меньшего зла»: заголовок или кем-то обрабатывается, или он вообще не нужен.

Если заголовка нет:

— используется дефолтный, прописанный в коде;

— он вообще не нужен;

Язык должен указываться всегда, иначе непонятно, как вернуть ответ от сервера. Но разработчик может в код зашить русский язык, и тогда даже если вы передадите заголовок «Accept-Language: en-US», то ответ получите на русском.

Почему? Потому что разработчик игнорирует этот заголовок, он его не считывает из запроса в принципе. Его право =) 

Возможные ситуации, которые надо проверить

Заголовок не передан, как система реагирует:

— выдает ошибку → понятно ли, что мне надо сделать?

— применяет поведение по умолчанию (если язык не передан, используй русский)

Заголовок передан:

— верно

— неверно → какая ошибка?

Плюс регистрозависимость. Согласно спецификации, все заголовки должны быть регистронезависимы. И неважно, как я их передаю. Могу в CamelCase (первая буква большая, остальные мелкие), могу в верхнем регистре, причем как значение заголовка, так и его название, могу как-то ещё:

• Accept: application/json

• Accept: APPLICATION/JSON

• ACCEPT: application/json

• ACCEPT: APPLICATION/JSON

• ACcePT: APPlicATIon/JSon

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

Был случай у моих коллег — заголовок проверили, всё работает. Но проверили по доке, прислали значения «как указано». Вот Accept может быть (как передаются входные данные):

• application/json

• application/xml

А потом пользователи приходят и жалуются на ошибки «у вас плохой заголовок». При том, что заголовок они отправили правильный. Начали разбираться — запрос идет не напрямую на сервер, он проходит через прокси Nginx. А Nginx меняет заголовки на upper case: ACCEPT: APPLICATION/JSON.

Система к такому не готова, она ищет «Accept», не находит его и выдает ошибку. А переданный заголовок игнорирует. Так что проверять регистр — надо!

Итого — тестирование заголовков в API

• Заголовки из документации работают (в целом)

• А если какой-то не передать? (обязательность)

• А если передать, но неправильно? (текст ошибки)

• Позитивные тесты по доке

• Регистронезависимость заголовков

Практика на примере Users

В документации вообще ничего не сказано про заголовки. Поэтому проверяем, можно ли отправить сообщение без них. Идем на вкладку Headers и снимаем все галки, если они по каким-то причинам там стояли. Запрос сработал успешно:

Но обратите внимание, что в постмане есть ещё скрытые заголовки (hidden):

Это те заголовки, что генерирует сам постман. По сути постман — это клиент, помогающий нам отправить запрос на сервер. И у него есть какие-то свои фишечки, ограничения, заголовки опять же. 

Можно нажать на это сообщение “(цифра) hidden” и раскрыть этот список (а потом всегда можно нажать на кнопку “hide hidden”:

Это некий стандарт, дефолтные значения по умолчанию. Тот же Cache-Control, раз вы его не передаете, по факту он вам не нужен, то есть как если бы вы указали “no-cache”.

Но учтите, что если снять тут все-все-все галки, система может выдать ошибку:

Плохо ли это? Стоит ли заводить баг “в документации сказано, что можно без заголовков, а так не работает” — нет. Для начала попробуйте отправить запрос через curl и посмотрите на результат.

Помните, что Postman — это всё-таки клиент, у которого есть свои навороты. Так что пусть он их накручивает сколько влезет, эти хидден-заголовки тестировать особо не надо. А вот послать хотя бы разок честный curl — надо!

Так что прячем hidden-заголовки и проверяем без них в этом пункте. Да, doregister без заголовков работает, всё ок.

Тело запроса (body)

Что мы тут тестируем:

1. Правильное тело (пример)

2. Различные параметры (обязательность, работа параметров)

3. Бизнес-логика

4. Ошибки: бизнес-логика

5. Перестановка мест слагаемых

6. Регистрозависимость

7. Ошибки: не well formed xml / json

Пункты 1-4 мы уже обсудили выше. Идем по ТЗ и каждую строчку изучаем и проверяем. 

Перестановка мест слагаемых

Это как раз особенность API, поэтому очень важно её проверить. Бизнес-логика и проверки “а что можно ввести в такое-то поле” одинаковы для GUI и API, а вот переставить поля местами в графическом интерфейсе не получится.

При этом в API это сделать проще простого. Мы ведь передаем пары “ключ-значение”. Что будет, если мы попробуем поменять их местами? 

В идеале ничего не случится, потому что принимающая система должна из запрос цеплять информацию именно по названию ключа, а не делать “select *” и потом говорить “для первого поля из запрос проверь то, для второго сделай это…”. 

Ведь потом изменится входной запрос и у нас вся интеграция сломается! А это нехорошо… Так что смотрим как система реагирует на перестановки.

Регистрозависимость

Вы же помните о том, что регистронезависимость не появляется из воздуха? Её делает разработчик. Поэтому и проверить “как ведет себя система” — тоже надо. И в заголовках, и в теле, и в параметрах URL —  вообще везде, где есть символы.

Ошибки в ответе от сервера

Всегда обязательно изучаем ошибки. Помимо ошибок в бизнес-логике есть ещё неправильно составленный запрос. То есть не well formed. Пробуем такой послать и смотрим на адекватность ошибки

См также:

Правила Well Formed XML

Правила Well Formed JSON

Практика на примере Users

По бизнес-логике мы уже прошли, теперь пойдем по API-части:

1. Перестановка мест слагаемых

В json пробуем перестановку:

{

    "name": " Машенька{{$randomInt}}",

    "email": "test{{$randomInt}}@mail.com",    

    "password": "1"

}

Ура, работает! А как насчет form-data? Тоже всё ок, это хорошо:

2. Регистрозависимость

Мы уже поняли, что в Users регистронезависимости может и не быть. Поэтому проверим на одном поле для начала. И не email, а то с ним может быть ложная уверенность в корректной ошибке:

{

    "email": "test{{$randomInt}}@mail.com",  

    "NAME": " Машенька{{$randomInt}}",   

    "password": "1"

}

Запрос не сработал, увы: «Параметр name является обязательным!»

Названия ключей регистрозависимы. Это не очень хорошо, хотя и некритично. Такой баг разработчик может не захотеть исправлять, “пусть присылают по документации”. Ну что же, тогда единственным аргументом будет потом количество обращений в поддержку. 

Но мы, по крайней мере, получили информацию по работе системы.

3. Well formed

У нас на входе json, смотрим его правила:

1. Данные написаны в виде пар «ключ:значение»

2. Данные разделены запятыми

3. Объект находится внутри фигурных скобок {}

4. Массив — внутри квадратных []

И пытаемся сломать. Вообще самая частая ошибка — это запятая после последней пары «ключ:значение». Мы обычно скопипастим строку из середины (вместе с запятой), поставим в конец объекта, а запятую удалить забудем. Получится как-то так:

{

    "email": "test{{$randomInt}}@mailcom",

    "name": " Машенька{{$randomInt}}",

    "password": "1",

}

Отправляем такой запрос. М-м-м-м, ответ как-то не очень:

Это постман мне настойчиво подсвечивает красным лишнюю запятую, а если вызов идет из кода и там подсветки нет, то как понять, что пошло не так? Из текста сообщения об ошибке. Только вот из такого текста разработчик очень долго будет угадывать, что не понравилось системе… Нехорошо, стоит завести баг.

Попробуем другие способы сломать формат:

— не в виде пар “ключ:значение”

{

    "email": "test{{$randomInt}}@mail.com",

    "name": " Машенька{{$randomInt}}",

    "password"

}

Ответ будет такой же — «Параметр email является обязательным!»

Заметьте, что если мы “сломаем” так email, будет ложное ощущение, что система работает хорошо и правильно дает подсказку. А на самом деле нет… 

Так что если уже замечали странности раньше, проверяем на другом поле — на пароле, а не емейле. И видим, что ошибка непонятная.

— данные не разделены запятыми

{

    "email": "test{{$randomInt}}@mail.com"

    "name": " Машенька{{$randomInt}}"

    "password": "1"

}

— объект в квадратных скобках, а не фигурных

[

    "email": "test{{$randomInt}}@mail.com",

    "name": " Машенька{{$randomInt}}",

    "password": "1"

]

Ответ везде одинаковый — «Параметр email является обязательным!»

Не очень хорошо, в ожидаемый результат чек-листа проверок мы запишем что-то более «правильное» =)) Например, ошибка 400 и сообщение «Не well formed json в запросе».

URL

Там тоже могут быть параметры. Обычно это в методе GET делается, прямо в параметры URL зашивается какая-то информация. Например, идентификатор элемента, который мы хотим получить.

Тестируем точно также, как если бы параметр был в теле:

1. Правильный параметр (из примера)

2. Обязательность (что, если параметр не указать?)

3. Бизнес-логика (тест-дизайн)

4. Регистрозависимость (если параметр текстовый)

Практика на примере JIRA

Почему не на примере Users? А потому что в методе doRegister нет параметров, которые передаются в URL. Да и вообще в Users их нету, там даже get через POST сделан, но сейчас не об этом…

Поищем примеры в Jira Cloud REST API. Например, метод «Get Issue», вот какой у него URL:

GET /rest/api/3/issue/{issueIdOrKey}

Мы передаем в URL или id задачи, или её ключ. Условно говоря, это или что-то типа “13005” или “TEST-1”. 

И вот тут мы уже можем развернуться!

Правильное значение

Базовый позитивный тест, что метод в целом работает. Вызываем обязательно и так, и так:

• 13005

• TEST-1

Обязательность

Попробуем не передать параметр:

/rest/api/3/issue/

/rest/api/3/issue

Тест-дизайн

Тут стоит подумать в тему состояний объекта. Пробуем получить:

• Свежесозданную задачу

• Несколько раз измененную / отредактированную

• Заполненную по минимуму / по максимуму

• В разных статусах

• Закрытую

• Удаленную

• Не существующую (такого номера ещё нет — это отличается от “он есть в базе, но задача была закрыта”)

Регистрозависимость

При передаче issueId этот пункт не проверить, цифры сами по себе регистронезависимы. Но если мы передаем задачу через Key, то это уже символы. Значит, проверка актуальна:

/rest/api/3/issue/test-1
/rest/api/3/issue/TEst-1

Тип метода

Что будет, если мы “подменим” тип запроса?

POST → GET (совсем разные типы запросов)

POST → PUT (похожие типы)

Как система отреагирует? Она может или отработать “словно так и надо”, или выдать ошибку. И тут следим за тем, чтобы ошибка была внятной и понятной.

А ещё может показаться, что игнорирование ошибок пользователя — это хорошо. Но далеко не всегда. Например, у меня был случай, когда на проекте обновили библиотеку и она стала намного жестче с ошибкам интеграции. Тут то и выяснилось, что запросы исходные системы присылали “кто во что горазд”. 

Если бы система сразу падала, то на первичной интеграции пришлось бы поднапрячься побольше, зато дальнейшие переходы были бы бесшовными. А когда уже всё в продакшене, это будет стопить обновление релиза. Так что может, лучше заранее начать ловить за руку “ты мне какой-то треш” шлешь?

Практика на примере Users

Меняем в запросе тип метода с POST на GET — а ему всё равно, успешно!

Нельзя сказать, что это прям вау-поведение, но для Users это нормально =)

Что тестируем в ответе

Тело ответа

Чек-лист проверки:

1. Какие поля вернулись в ответе?

2. Значения в полях

3. Текст ошибок 

Поля в ответе нужно:

• сравнить с ТЗ

• сравнить между собой SOAP REST 

Если у нас есть ТЗ — то всё понятно. Читаем, как должно быть, проверяем, как есть на самом деле. Смотрим на то, что все поля из требований вернулись, и что в них правильное значение. А то вдруг я сохраняю имя “Оля”, а там всегда сохраняется “Тестовый”… Очень удобно сразу автотесты писать в том же постмане, если отдельного фреймворка нет — идем по ТЗ и каждое поле выверяем.

Если ТЗ нет, то уже сложнее. Ищем «хранителя информации», расспрашиваем, проверяем, как работает на самом деле. Думаем, есть ли проблемы в текущем поведении. Нет? Ок, значит, так и надо.

Если в ответе сообщение об ошибке, то внимательно его изучаем. В API это ещё важнее, чем просто в графическом интерфейсе. Поймет ли пользователь, что именно он сделал не так, где именно ошибся? Помните, плохое сообщение об ошибке приведет к тому, что вас будут дергать по пустякам, вырывая из контекста.

См также:

Каким должно быть сообщение об ошибке

Сообщения об ошибках — тоже документация, тестируйте их!

Если у вас в системе два интерфейса — SOAP и REST, нужно проверить оба. Обычно они должны быть идентичны. Да и в коде это обеспечивается условно говоря двойной аннотацией “сделай и soap, и rest сгенери”, разработчик не дублирует всю функциональность дважды, а просто “включает” API.

В таком случае действительно всё будет работать идентично, кроме пустых полей в ответе. Что будет, если какое-то поле не заполнено? Может легко быть такая ситуация: 

— SOAP возвращает пустые поля;

— REST нет.

Более того, это даже может быть нормально! Например, исходно писался только SOAP-интерфейс, и было правило возвращать все поля, даже пустые. Потом решили стать модными, молодежными, подключили REST. И решили там поля пустые не возвращать.

К тому же в SOAP всегда есть схема WSDL, где указаны обязательные поля. Значит, они будут возвращаться в ответе. В ресте же схема WADL необязательна, да и там любят придерживаться принципа минимальных чернил, лишнего не выводить.

В общем, проверьте обязательно, как методы срабатывают на:

• Отсутствие данных на входе (поле не пришло вообще / пришло пустое)

• Пустые поля на выходе

Если по разному, то это должно быть описано в доке!

Практика на примере Users

Сначала отправляем базовый запрос и там, и там, как в документации. Но уже по документации мы можем заметить, что набор поле в ответах разный. В SOAP перечислены все поля юзера, включая кличку кошечки, собачки итд… В REST же несколько базовых полей, и всё.

Как так вышло? Очень просто. Для реста набор полей согласовали, разработчик сделал. Потом я сказала, что хочу ещё и SOAP. А там нужна схема WSDL, разработчик с ней особо не парился. Есть сущность “user”? Ну её и вернем в ответе. А в сущности как раз много полей… 

Мне не критично, так что менять не стали, да и вообще отличный пример «да, и так бывает» же! =))

Ок, давайте теперь посмотрим на особенности API, ведь всю бизнес-логику перетестировать в SOAP смысла нет, она должна совпадать… Ну разве что вы совсем не верите своим разработчикам… Или кейсы очень важные. А так — бизнес-логику смотрим один раз, а потом переходим в особенностям API.

Перестановка мест слагаемых

Поменяем местами name и email — ой ёй ёй!

Система пишет «Некоректный  email Имечко 666». Это значит, что она ориентируется не названия полей, передаваемые в тегах, а на их порядковых номер. И это ОЧЕНЬ ПЛОХО, на такое стоит идти ставить баг. 

Тем более обоснование у нас есть — неединообразно работает. REST вот от перестановки не зависит, и SOAP не должен.

А ещё слово «Некоректный» написано неправильно, там должно быть две буквы “р”. Проверяем в REST, посылая заведомо плохой емейл — да, и там ошибка. Надо бы исправить. Текстовку ошибок вычитываем внимательно!

Регистрозависимость

Каждый тег регистрозависим сам по себе — открывающий и закрывающий должны совпадать по написанию, в том числе по регистру. Если это сломать, будет точно плохой запрос, но мы начнем с условно хорошего — оба тега в капс-локе:

<EMAIL>ggg55555@mail.com</EMAIL>

Работает!

А вот теперь попробуем разный регистр внутри тегов (в json такую проверку не сделать, это особенно XML, дублирование названия поля):

<EMAIL>ggg55555@mail.com</email>

Не работает — Bad Request. Чтож, вполне логично.

Well formed XML

Что, если сломать XML? Скажем, оставить закрывающий тег «/email» без второй угловой скобки:

     <wrap:doRegister>

         <email>ggg5555@mail.com</email

         <name>Имечко 666</name>

         <password>1</password>

      </wrap:doRegister>

Возвращается ошибка 

<faultcode>SOAP-ENV:Client</faultcode>
<faultstring>Bad Request</faultstring>

Не супер информативно, но в целом ясно, что мы где-то с запросом накосячили. И если такой текст именно на well formed, то и ладно. Тогда по нему будет сразу понятно, в чем именно проблема. Посмотрим дальше.

Статус-коды

Разработчик может использовать стандартные коды ответов,

• 2хх — все хорошо

• 4хх — ошибка на клиенте (в запросе)

• 5хх — ошибка на сервере

А может придумать свои:

• 570 — пустой ответ на поиск;

• 571 — нашли одного ФЛ;

• 572 — нашли несколько ИП;

• 573 — нашли только ИП;

• …

Если разработчик ленивый и не настроил коды, то вы будете огребать на любую ошибку стандартный код: 400 Bad Request. Неверный заголовок? Ошибка 400. Неверное тело? Ошибка 400. Проблемы в бизнес-логике? Ошибка 400… Ну и как тут разобраться, что именно надо исправлять?

Или ещё “лучше”, разработчик может сказать “всегда возвращай код 200”. И это очень нехорошо, ведь именно по коду мы ориентируемся в первую очередь: всё хорошо или что-то плохо?

Поэтому статус-код проверяем всегда, обращаем на него внимание. Ну а если в методе собственные статусы (как, например, в методе MagicSearch)

Практика на примере Users

На статус надо было обращать внимание всегда, чтобы не дублировать снова все тесты. Но сейчас просто дернем “хороший” и “плохой” запросы.

Хороший — статус 200, всё ок:

Плохой — ой, статус снова 200, хотя мы видим сообщение об ошибке:

Нехорошо! На это надо ставить баг.

Итоговый чек-лист проверки doRegister

Помним, что в первую очередь проверяем бизнес-логику. А потом уже всякие API-штучки, куда входят:

• Регистрозависимость

• Перестановка мест параметров

• Well formed запрос

Базовый тест

Базовый тест тщательно выверяет каждое поле из “корректного” ответа. Проверяет, как вызов API-метода влияет на отображение в GUI… Поэтому его пропишем текстом, а остальные тесты соберем в табличку.

1. Проверка примера из ТЗ (но имя и емейл меняем на уникальные)

{

    "email": "milli{{$randomInt}}@mail.ru",

    "name": " Машенька{{$randomInt}}",

    "password": "1"

}

ОР: 

1. Статус 200

2. В ответе следующий набор полей:

"name": " Машенька562", (то имя, что мы отправили)
"avatar": "http://users.bugred.ru//tmp/default_avatar.jpg", (в этом методе всегда такой урл стандартной аватарки)
"password": "4dff4ea340f0a823f15d3f4f01ab62eae0e5da579ccb851f8db9dfe84c58b2b37b89903a740e1ee172da793a6e79d560e5f7f9bd058a12a280433ed6fa46510a",
"birthday": 0,
"email": "milli754@mail.com", (тот емейл, мы мы отправили)
"gender": "",
"date_start": 0,
"hobby": ""

3. Пользователь добавлен в общий список. Проверяем через GUI — http://users.bugred.ru/. Ищем поиском — есть!

Проверяем все поля:

• Емейл правильный, какой мы отправляли.

• Автор «rest», что логично.

• Дата изменения — сегодня, что тоже правильно.

4. Под пользователем можно войти в систему — нажимаем “Войти”, вводим емейл из запроса, пароль из запроса, проверяем авторизацию. 

Остальные тесты 

Вывод

Тестирование API — это не страшно! По факту это всё то же самое, что в GUI + дополнительные тесты. В интерфейсе нельзя подвигать местами поля или изменить название поля. А в API можно.

Но всегда в первую очередь важен тест-дизайн. Прочитайте ТЗ и проверьте его, учитывая классы эквивалентности и граничные значения. А потом добавьте API-часть:

• Перестановка мест слагаемых в json

• Перестановка мест слагаемых в form-data

• Регистрозависимость

• Другой тип метода

• Well formed json / xml

Ну а если что-то подзабудется, то можно открыть эту статью и свериться с чек-листом отсюда! =))

PS — больше полезных статей ищите в моем блоге по метке «полезное». А полезные видео — на моем youtube-канале  

Подборка по базе: ШАБЛОН ПАКЕТА СЕРВИСНОГО ДИЗАЙНА (SDP).docx, РП ОП.17 Пакеты прикладных программ для систем организационного , 4 44 сценарий, 4класс — копия.docx, Интегрированные пакеты MS Office.doc, Диагностический пакет дефектолога 5-11 лет.pdf, Практическое занятие №5. Формирование пакета документов организа, 2.1_9 Анализаторы сетевых пакетов.doc, 3 урок Файлы и пакеты.docx, Лекции Пакеты прикладных программ.docx

Лекционное занятие

Тема: Тестовый сценарий, тестовый пакет.

Цель: Ознакомиться с практическим применением техник тест дизайна при разработке тест кейсов. Анализом требований. Определением набора тестовых данных. Разработкой шаблона теста. Написанием тест кейсов на основании первоначальных требований, тестовых данных и шагов теста.

Оборудование: персональный компьютер, мультимедиа-проектор, MS Visio, Visual Studio, MS Office, методические рекомендации к проведению лекционных занятий, Гагарина, Л. Г. Технология разработки программного обеспечения: учеб. пособие / Л. Г. Гагарина, Е. В. Кокорева, Б. Д. Виснадул; Под ред. Л. Г. Гагариной. — М.: ФОРУМ: ИНФРА-М, 2017.-400 с., инструкционная карта для проведения лекционного занятия.
Тестирование ПО (Software Testing) — проверка соответствия между реальным и ожидаемым поведением программы, проводится на наборе тестов, который выбирается некоторым образом. Чем занимаются в тестировании:

1. планированием работ (Test Management)
2. проектированием тестов (Test Design) — этап, на котором создаются тестовые сценарии (тест кейсы), в соответствии с определёнными ранее критериями. Т.е., определяется, КАК будет тестироваться продукт.
3. выполнением тестирования (Test Execution)
4. анализом результатов (Test Analysis)

Основные цели тестирования

• техническая: предоставление актуальной информации о состоянии продукта на данный момент.
• коммерческая: повышение лояльности к компании и продукту, т.к. любой обнаруженный дефект негативно влияет на доверие пользователей.

Следует уметь различать, что:

• Error — это ошибка пользователя, то есть он пытается использовать программу иным способом (например, вводит буквы в поля, где требуется вводить цифры). В качественной программе предусмотрены такие ситуации и выдаются сообщение об ошибке (error message).
• Bug (defect) — это ошибка программиста (или дизайнера или ещё кого, кто принимает участие в разработке), то есть когда в программе, что-то идёт не так, как планировалось. Например, внутри программа построена так, что изначально не соответствует тому, что от неё ожидается.
• Failure — это сбой в работе компонента, всей программы или системы (может быть как аппаратным, так и вызванным дефектом).

Тестовый пакет

Тестовый пакет является фундаментальной единицей разработки тестов. Это набор тестов, которые оценивают согласованный набор возможностей устройства, то есть те, которые имеют тесную функциональную связь.

Набор тестов – это контейнер с набором тестов, который помогает тестировщикам выполнять и сообщать о состоянии выполнения теста. Может принимать любое из трех состояний: «Активно», «Выполняется» и «Завершено».
Тестовый набор может быть добавлен в несколько наборов тестов и планов тестирования. После создания плана тестирования создаются наборы тестов, которые, в свою очередь, могут иметь любое количество тестов.
Как правило, модульные тесты и тестовые конфигурации разрабатываются самими разработчиками, основная задача тестера в этом случае — организовать все тесты в упорядоченную структуру пакетов и указать, какие пакеты должны исполняться в каких условиях. Вся иерархия тестов хранится в так называемом файле метаданных, имеющем расширение vsmdi. Этот файл находится в системе контроля версий и может быть включен в решение как отдельный элемент.
Процесс тестирования

Как отмечалось ранее, в тестировании выделяются три основных уровня, или три фазы:

1. Модульное тестирование.
2. Интеграционное тестирование.
3. Системное тестирование.

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

Фазы процесса тестирования

В процессе тестирования выделяют следующие фазы:

1. Определение целей (требований к тестированию), включающее следующую конкретизацию: какие части системы будут тестироваться, какие аспекты их работы будут выбраны для проверки, каково желаемое качество и т.п.
2. Планирование: создание графика (расписания) разработки тестов для каждой тестируемой подсистемы; оценка необходимых человеческих, программных и аппаратных ресурсов; разработка расписания тестовых циклов. Важно отметить, что расписание тестирования обязательно должно быть согласовано с расписанием разработки создаваемой системы, поскольку наличие исполняемой версии разрабатываемой системы ( Implementation Under Testing (IUT) или Application Under Testing (AUT) – часто употребляемые обозначения для тестируемой системы) является одним из необходимых условий тестирования, что создает взаимозависимость в работе команд тестировщиков и разработчиков.
3. Разработка тестов, то есть тестового кода для тестируемой системы, если необходимо — кода системы автоматизации тестирования и тестовых процедур (выполняемых вручную).
4. Выполнение тестов: реализация тестовых циклов.
5. Анализ результатов.

После анализа результатов возможно повторение процесса тестирования, начиная с пунктов 3, 2 или даже 1.

Тестовый цикл

Тестовый цикл – это цикл исполнения тестов, включающий фазы 4 и 5 тестового процесса. Тестовый цикл заключается в прогоне разработанных тестов на некотором однозначно определяемом срезе системы (состоянии кода разрабатываемой системы). Обычно такой срез системы называют build. Тестовый цикл включает следующую последовательность действий:

1. Проверка готовности системы и тестов к проведению тестового цикла включающая:
   • Проверку того, что все тесты, запланированные для исполнения на данном цикле, разработаны и помещены в систему версионного контроля.
   • Проверку того, что все подсистемы, запланированные для тестирования на данном цикле, разработаны и помещены в систему версионного контроля.
   • Проверку того, что разработана и задокументирована процедура определения и создания среза системы, или build.
   • Проверки некоторых дополнительных критериев.
2. Подготовка тестовой машины в соответствии с требованиями, определенными на этапе планирования (например, полная очистка и переустановка системного программного обеспечения). Конфигурация тестовой машины, так же, как и срез системы, должны быть однозначно воспроизводимыми.
3. Воспроизведение среза системы.
4. Прогон тестов в соответствии с задокументированными процедурами.
5. Сохранение тестовых протоколов (test log). Test log может содержать вывод системы в STDOUT, список результатов сравнения полученных при исполнении данных с эталонными или любые другие выходные данные тестов, с помощью которых можно проверить правильность работы системы.
6. Анализ протоколов тестирования и принятие решения о том прошел или не прошел каждый из тестов ( Pass/Fail ).
7. Анализ и документирование результатов цикла.

Последний перед выпуском продукта тестовый цикл не должен включать изменений кода build или кода продукта тестируемой системы. Этот цикл называется » финальным «. Таким образом обеспечивается ситуация, когда финальный цикл полностью повторяем, а выпускаемый продукт полностью совпадает с продуктом, который прошел тестирование. Финальный цикл необходим для гарантии достоверности результатов тестирования.
Что такое тестовый сценарий

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

Что такое тестирование сценария

Тестирование сценариев — это вариант тестирования программного обеспечения, в котором для тестирования используются сценарии. Сценарии помогают в более простом способе тестирования более сложных систем
Зачем создавать тестовые сценарии

Тестовые сценарии создаются по следующим причинам:

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

Когда не создать тестовый сценарий

Тестовые сценарии не могут быть созданы, когда

• Тестируемое приложение является сложным, нестабильным, и в проекте есть время.
• Проекты, которые следуют Agile методологии, такие как Scrum, Kanban, могут не создавать тестовые сценарии.
• Сценарий тестирования не может быть создан для исправления новой ошибки или регрессионного тестирования . В таких случаях сценарии тестирования должны быть уже задокументированы в предыдущих циклах тестирования. Это особенно верно для проектов технического обслуживания.

Как написать тестовые сценарии

Как тестер, вы можете выполнить следующие пять шагов для создания тестовых сценариев:

• Шаг 1 : Прочтите документы с требованиями, такие как BRS, SRS, FRS, тестируемой системы (SUT). Вы также можете сослаться на примеры использования, книги, руководства и т. Д. Приложения, подлежащего тестированию.
• Шаг 2 : Для каждого требования определите возможные действия и цели пользователей. Определить технические аспекты требования. Определите возможные сценарии злоупотребления системой и оцените пользователей с менталитетом хакера.
• Шаг 3: После прочтения Документа с требованиями и проведения надлежащего анализа перечислите различные сценарии тестирования, которые проверяют каждую функцию программного обеспечения.
• Шаг 4: После того, как вы перечислили все возможные сценарии тестирования, создается матрица отслеживания, чтобы убедиться, что каждому требованию соответствует соответствующий сценарий тестирования.
• Шаг 5: Созданные сценарии проверяются вашим руководителем. Позже они также рассматриваются другими заинтересованными сторонами в проекте.

Советы по созданию тестовых сценариев

• Каждый тестовый сценарий должен быть привязан как минимум к одному требованию или пользовательской истории в соответствии с методологией проекта.
• Перед созданием тестового сценария, который проверяет несколько требований одновременно, убедитесь, что у вас есть тестовый сценарий, который проверяет это требование изолированно.
• Избегайте создания слишком сложных тестовых сценариев, охватывающих несколько требований.
• Количество сценариев может быть большим, и запускать их все дорого. Исходя из приоритетов клиента, запускайте только выбранные тестовые сценарии

Пример 1. Сценарий тестирования для приложения электронной коммерции

Для приложения электронной коммерции несколько тестовых сценариев

Тестовый сценарий 1: проверка функциональности входа

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

1. Проверьте поведение системы при вводе действительного адреса электронной почты и пароля.
2. Проверьте поведение системы при вводе неверного идентификатора электронной почты и действительного пароля.
3. Проверьте поведение системы при вводе действительного адреса электронной почты и неверного пароля.
4. Проверьте поведение системы при вводе неверного идентификатора электронной почты и неверного пароля.
5. Проверьте поведение системы, если адрес электронной почты и пароль оставлены пустыми и введен вход.
6. Проверить Забыли пароль работает как положено
7. Проверьте поведение системы при вводе действительного / недействительного номера телефона и пароля.
8. Проверять поведение системы, когда установлен флажок «Держать меня в подписи»

Как видно, тестовые случаи являются более конкретными.
Тестовый сценарий 2. Проверка функциональности поиска

Тестовый сценарий 3: проверьте страницу описания продукта

Сценарий тестирования 4: Проверьте функциональность платежей

Тестовый сценарий 5: проверка истории заказов

Помимо этих 5 сценариев, здесь приведен список всех других сценариев.

• Проверьте поведение домашней страницы для постоянных клиентов
• Проверьте категорию / страницы продукта
• Проверьте службу поддержки / контактные страницы
• Проверьте страницы ежедневных предложений

Пример 2: Тестовые сценарии для банковского сайта

Тестовый сценарий 1 : Проверьте функциональность входа и аутентификации

Тестовый сценарий 2 : Проверить перевод денег можно

Тестовый сценарий 3. Проверьте выписку со счета.

Тестовый сценарий 4 : Проверка фиксированного депозита / периодического депозита может быть создана

И так далее…
Литература: Гагарина, Л. Г. Технология разработки программного обеспечения: учеб. пособие / Л. Г. Гагарина, Е. В. Кокорева, Б. Д. Виснадул; Под ред. Л. Г. Гагариной. — М.: ФОРУМ: ИНФРА-М, 2017.-400 с.