How do we test in UKAD
How do we test in UKAD
As every professional software development company, UKAD pays much attention to the quality of our solutions. We asked one of our Quality Assurance experts to explain the way from a raw piece of code to an excellent product.
Testing is an integral part of software development, the purpose of which is to provide timely information on product quality to the development team and Customers. In other words, the task of the QC department is to identify and tell about changes in the quality of the product as soon as possible. While the task of the QA department is not only to detect errors on time but also to prevent the delivery of a poor-quality product to the Client through interaction. That's why QA plays an impact not only on the delivered product but also on the development process.
Our Approach to Quality Assurance
At UKAD, we have established the next development and testing model. Utilizing many software development methodologies, we always use 4 environments:
- Client demo
Now a bit more details in the context of testing.
- Is used to test functionality during the development process. It is the main testing environment.
- Any data manipulation in the database is allowed.
- Is used for final functional testing using 'real data'.
- Manual data modification in the database is prohibited. The database is an anonymous copy of the database Live environment updated every night.
- Allows you to check the behavior of the system with current user data
- Is used to demonstrate new/changed functionality to the client, as well as acceptance testing.
- The environment with which end users interact directly.
Development and Staging environments are used for basic activity tests.
Testing itself consists of several stages:
- Analysis and testing of requirements
- Test documentation development
- Test runs
- Regression Scenarios Automation
Analysis and testing of requirements
In the era of flexible methodologies, technical specifications are “unacceptable luxury” and sketches, user scenarios and so on are used as requirements. the main task of the testing department at this stage is to prevent discrepancies in requirements.
Test documentation development
As the requirements are prepared and the development process is started, the QA team is preparing for testing and writing test documentation, in particular test cases. It helps us to start testing the functionality as soon as it meets start requirements.
As soon as the developed functionality enters the development environment, dynamic testing starts using the prepared documentation. As a result of the test run, we get preliminary information about the quality of the developed functionality in the form of a report on passed test cases and open bugs. After fixing the bugs found, a new iteration starts and the next iteration until the functional reach the criteria for the end of testing. At this stage, we mainly use manual and semi-automated testing using tools such as Xenu, Postman, Fiddler and so on. After testing on the development environment, critical functional tests are repeated on the staging environment with anonymized user data, which allows us to make sure that the behavior of the developed functionality remains expected in real-life scenarios.
Regression Scenarios Automation
As the development process and manual testing finished, test case automation - the most technologically advanced testing process - begins. Based on previously created test cases, a set of test scenarios for automation is formed. Regression and specific scenarios are mainly automated. Regression scenarios are used to cover all the main options for using the functionality to obtain guarantees that the changes did not violate the existing functions. Also in automated test scenarios, we add specific scenarios that are difficult to verify manually. We use Java to write autotests in conjunction with the Selenium Selenide framework. Using Selenide allows you to concentrate on the business logic of tests instead of solving standard problems inherent in Selenium, such as waiting and searching for items, “soft asserts”, etc. For the convenience of using ready-made test suites, we use a continuous integration system such as Jenkins which allows you to configure the automatic launch of tests after each product update, and also simplifies the procedure for using automated test cases by any member of the team, because running tests comes down to a couple of clicks.
To run the tests, Selenoid is used, which is an excellent implementation of Selenium Hub code, which uses separate Docker containers to launch browsers, which allows you to run each test in isolation in a 'clean' browser. Selenoid also allows you to monitor the execution of individual test scenarios and, if necessary, interact with the browser using a VNC connection.
Selenoid also allows you to save videos with passing tests. Video recordings help in locating the cause of a failed test.
But for the successful use of automated testing, you need a report on the passed test cases. For this, we use Allure, which allows using the annotations in the code to generate an informative report that will be useful for each team member from an ordinary tester to PM.
Close interactions between development and testing teams, the use of modern approaches and tools, timely finding and fixing errors - all this allows you to deliver a quality product on time.
Author: Vikentiy Kelevich
- Test automation
- Quality Assurance