We control the quality of our services continually and incessantly. Quality assurance isn’t a job assigned to our QA department only. It involves each member of the team engaged with the project development. By following our standards we achieve consistent and stable architecture in the project, reusable code, and excellent user experience.
Developers just like the rest of us have their own handwriting style, which creates difficulties, once somebody else tries to untangle the lines of code they wrote. What is more, the quality of code tends to worsen if it never gets reviewed by other developers. We can’t permit that. That’s why every project in our agency needs at least two developers to ensure the quality of code in the first place.
We do code reviews using Gitlab merge requests after completing a small logically complete slice of functionality, such as feature, task, bug fix, improvement, etc.
Code review brings a number of benefits to the project. It ensures bugs and other issues get detected and corrected on time and don’t accumulate in the system. All developers on the team know every line of code in the project and effectively share their knowledge. So even if one of them goes on vacation or has a sick leave, the project won’t come to a standstill, but will go on without any serious hindrances.
2. Streamlined workflow
We streamline our workflow by using Continuous Integration practice and bringing each project’s source code to the agreed standard.
— Continuous integration
We really hate it when integration issues knock a project off-schedule. Continuous integration prevents that from happening. It implies frequent integration of builds into a shared repository and their quick automatic verification. Our team can view the current build and test it without having to wait for weeks until all the features planned in one iteration are ready. Increased visibility results in better interaction with quality assurance engineers, which in its turn, allows to nip the issues in the bud. Continuous Integration doesn’t get rid of bugs, but it does make them dramatically easier to find and remove.
— Code standard and Gitflow
In order to avoid mess and entanglement in the source code and bring clarity to our developers’ coding effort, we lead each project to a single standard. A team of developers from our agency agrees on that standard during a project planning meeting.
We use Gitflow for all our projects. It helps to follow the standard and provides high-level repository operations allowing all developers to get a general understanding of the processes of branching and merging inherent in the project development. Whenever any change is made, everybody will be notified about it. Gitflow creates an elegant model of the project, easy to understand and effective to adhere to.
As a result, we spend less time debugging, deliver our work in due season and avoid mess in the source code.
3. Unit testing
Unit testing provides a number of benefits. First and foremost, it creates an efficient testing architecture needed to produce perfect code. Unit testing reduces the number of bugs by making sure they get detected much earlier and easier to fix. We can go back at any time and see where exactly the bug is, without having to dismantle the whole system. There is no need for us to wait a month for all the pieces of the system to come together. Unit testing allows to demonstrate concrete progress even without a fully working system. What is more, applying Unit tests enables implementation of powerful refactorings.
4. Automatic library updates
All the libraries and frameworks in our projects get automatically updated. We use Carthage and CocoaPods for iOS and Gradle for Android. These tools allow to build dependencies automatically and retain full control over the project structure and setup. They also help to reduce maintenance work and make it much easier to follow releases of updates. Read also: App development process
5. Quality control
Our agency provides rigorous, detail-oriented testing processes across teams to examine every possible scenario on each new build and the entire project.
— Test cases and test plan
Our quality assurance department uses the most effective approaches, a large range of devices and a variety of types of testing. Testing procedure is always reflected in a test plan which we provide before the project starts. It describes which modules (features) of the application will be tested along with deadlines, testing environment (operating systems and devices) and types of testing applied for a particular case. The test plan generalizes our testing approach.
Other than that, we also outline test cases at the beginning of each iteration. In a nutshell, they describe the steps of testing according to a so-called check set — a group of testing procedures to examine each slice of functionality. We have a suite of elaborated techniques for testing different types of functionality like validation of the format of credentials at the registration process and login, for example.
— Testing at different stages
We do not only test the project when it comes to an end. Our agency carries out testing at different stages because it helps to validate the assumptions we make during the creation process. While each iteration ends up with testing and bug fixing, we also do intermediate testing when part of the functionality planned for the current iteration is completed. It gives a chance to address emerging issues and helps to make sure that no critical or major bugs come up in the build at the end of the iteration.
— Impact testing
Some parts of the functionality in the project are interconnected. That’s why building a new feature on top or doing bug fixing may cause issues in the already developed areas. Impact testing helps to identify connections between different features in the software. It helps to localize possible issues earlier, faster and less costly to fix. Impact testing is followed by targeted regression testing, after which developers get down to fixing bugs if any of them have been detected.
— Regression testing
When all builds are tested and all bugs have been fixed, there is still a probability that bug fixing or each new part of functionality affected other parts of the software. To avoid system crashes or other undesirable behavior we do regression testing. Its purpose is to uncover new bugs in existing functional areas. Regression testing is followed by a verification test to ensure all the bugs have been fixed and a smoke test to determine whether the recent bug fixing process didn’t affect other parts of the software.
Bug fixing doesn’t guarantee the absence of bugs. Some bugs can be very rare and hard to identify, some can come up with a new version of the operating system or on a certain device, which is a usual issue for Android. That’s why we integrate Crashlytics, a crash reporting system that helps to address those issues when the app is launched. Crashlytics sends a report called a stack trace, which shows exact steps which led to system crashes. It also provides other important information, such as device, country, app version, language, etc.
— Compatibility testing
Compatibility testing examines if the current version of the operating system is compatible with the previous ones. Unfortunately, not all app owners pay attention to thorough compatibility testing performed before each update is rolled out. This leads to crashes and other issues resulting in users leaving the app. We make sure this never happens to our clients’ products.
Read also: Yalantis story
Quality is a distinctive feature of our app development services. That’s why assuring quality of all our projects is a top priority for us.