Category:

Importance of Unit Testing

September 13th, 2023 by

In the dynamic world of software development, ensuring the reliability and stability of your application is of utmost importance. Unit testing stands as a first line of defense against bugs and errors, playing a crucial role in securing the application’s robustness. Let’s delve deeper into the intriguing world of unit testing, beginning with what it is and then exploring its indispensable role in modern app development.

 

Level of testing

 

What is Unit testing?

Unit testing, a fundamental practice in app development, is the process of testing individual units or components of a software application. It is generally conducted during the development phase, primarily by developers, to validate that each unit of the software performs as designed.


A “unit” in this context refers to the smallest part of a software system that can be tested in isolation. It might be a function, method, procedure, or an individual module, depending on the complexity of the software. The primary goal is to validate that each unit functions correctly and meets its design specifications.

 

Importance of Unit Testing

Below, we delve into the importance of unit testing in the realms of web and mobile applications:

 

1. Early Bug Detection

Unit testing allows developers to identify bugs early in the development cycle, which not only saves time but also significantly reduces the cost of bug fixing. Early bug detection ensures that issues are nipped in the bud before they escalate to more critical stages.

 

2. Facilitating Changes and Refactoring

With a well-established unit testing practice, developers can make changes to the code or refactor it with confidence. Unit tests act as a safety net, helping to identify unforeseen impacts of the modifications, thus ensuring the consistency of the application.

 

3. Enhanced Code Quality

When developers write unit tests, it naturally leads to better code quality. Developers are more likely to write testable, modular, and maintainable code, fostering an environment of excellence in code craftsmanship.

 

4. Improved Developer Productivity


Unit testing can significantly improve developer productivity. Since bugs are caught early, developers spend less time debugging and more time building new features. Moreover, the immediate feedback provided by unit tests helps streamline the development process.

 

5. Simplified Debugging


When a unit test fails, it is much easier to identify and fix the issue, as you only need to consider the latest changes. This contrasts sharply with higher-level tests where a failure might be the result of a myriad of factors, making debugging a complex and time-consuming task.

 

6. Seamless Integration


Unit tests facilitate smoother integration processes. When integrating various components or modules, unit tests can quickly pinpoint issues at the unit level, making the integration process more efficient and less error-prone.

 

7. Robust Security


In web and mobile applications, security is paramount. Unit testing helps in identifying vulnerabilities at the code level, allowing developers to fortify the application against potential security breaches, thus safeguarding user data and privacy.

 

8. Customer Satisfaction


By ensuring the stability and reliability of web and mobile applications through unit testing, developers can significantly enhance customer satisfaction. A bug-free, smooth-running application is more likely to earn user trust and build a loyal customer base.

 

How to Perform Unit Testing

 

Performing unit testing is an essential practice in ensuring the robustness and reliability of your application. Whether you are working on a mobile or web application, incorporating unit testing into your development process can help you deliver a high-quality product. Here is a step-by-step guide to effectively performing unit testing on apps:

 

Step 1: Understanding the Codebase

 

Before you start with unit testing, familiarize yourself with the codebase and understand the functionalities of different units. Having a clear picture will aid in writing more effective and relevant tests.

 

Step 2: Setting Up the Testing Environment

Set up a separate testing environment where the unit tests will be executed. This environment should be isolated from production to avoid any unintended consequences. Utilize unit testing frameworks suitable for your programming language to streamline the process.

 

Step 3: Writing Unit Tests

3.1 Choose the Units to be Tested

 

Identify the critical components that need testing. Start with the core functionalities that form the backbone of your application.

 

3.2 Create Test Cases

 

For each unit, create test cases that cover various scenarios including edge cases. Each test case should focus on a single functionality.

 

3.3 Mock External Dependencies

 

Use mocking frameworks to simulate external dependencies, ensuring the unit is tested in isolation. This helps in pinpointing the issues more accurately.

 

Step 4: Executing the Tests

 

Run the tests using the testing framework. Ensure to cover different cases including:

 

Positive Cases: Where the input meets the expected criteria.

 

Negative Cases: Testing with inputs that are supposed to fail, to ensure proper error handling.

 

Edge Cases: Testing the limits of the input parameters.

 

Step 5: Analyzing the Results

After execution, analyze the results thoroughly. If a test fails, investigate the cause and fix the issue before proceeding.

 

Step 6: Integrating with Continuous Integration (CI) Systems

 

Integrate the unit tests into a Continuous Integration system to automate the testing process. The CI system should be configured to run the unit tests automatically each time code is pushed to the repository.

 

Step 7: Maintenance of Test Cases

As the application evolves, continually update the test cases to mirror the changes in the application. Remove obsolete tests and add new ones for the newly added functionalities.

 

Step 8: Documentation

Maintain a well-documented record of all the test cases, including the input parameters and expected outcomes. This documentation will serve as a reference and aid in understanding the expected behavior of the application units.

 

Step 9: Team Collaboration

 

Encourage collaboration in the team where code and test cases are reviewed by peers to ensure the quality and effectiveness of the unit tests.

 

Step 10: Training and Learning

Continuously improve your unit testing skills through training and learning. Stay updated with the latest trends and best practices in unit testing to enhance the quality of your tests.

 

Unit Test Life Cycle

 

Best Practices in Unit Testing


The process of unit testing can be substantially improved by adhering to a set of best practices and methodologies. These practices not only streamline the testing process but also enhance the overall quality and reliability of the software product. Here are several strategies to consider for optimizing your unit testing efforts:

 

1. Adopt Consistent Naming Conventions


Implement a coherent and descriptive naming convention for your test cases. This facilitates easier identification and understanding of the tests, fostering smoother collaboration and maintenance.

 

2. Test Singular Units of Code Independently


Focus on testing individual units of code separately to isolate potential issues effectively. This strategy ensures that each component functions correctly in isolation, paving the way for a more robust application.

 

3. Develop Corresponding Test Cases During Code Changes


Whenever there is a modification in the code, ensure to create or update the corresponding unit test cases. This practice helps maintain the relevance and effectiveness of your test suite, allowing for the timely detection of issues introduced by the changes.

 

4. Prompt Bug Resolution


Prioritize the immediate resolution of identified bugs before progressing to the next development phase. Quick bug resolution minimizes the potential for escalating issues and maintains the stability of the codebase.

 

5. Integrate Testing with the Code Commit Cycle


Integrate unit testing into your code commit cycle to foster a test-driven development environment. Conducting tests as you commit code helps in the early detection of issues, reducing the chances of errors proliferating through the codebase.

 

6. Focus on Behavior-Driven Testing


Concentrate your testing efforts on scenarios that significantly influence the system’s behavior. Adopt a behavior-driven testing approach to ensure that the application behaves as expected under various conditions, enhancing reliability and user satisfaction.

 

7. Utilize Virtualized Environments for Testing


Leverage virtualized environments, such as online Android emulators, to conduct unit tests in scenarios that closely resemble real-world conditions. These environments offer a convenient platform to test the application under different settings without the need for physical devices.

 

8. Implement Continuous Integration


Incorporate unit testing into a continuous integration (CI) pipeline to automate the testing process. CI allows for the regular and systematic execution of unit tests, ensuring that the codebase remains stable and bug-free as it evolves.

 

9. Encourage Peer Reviews


Promote the practice of peer reviews for both code and test cases. Reviews foster collaboration and knowledge sharing, enhancing the overall quality and robustness of the application.

 

Disadvantages of Unit Testing


1. Limited Scope of Testing


A notable limitation of unit testing is its inability to verify all execution paths and detect broader system or integration errors. Since unit tests focus on individual components, they might overlook issues that only emerge during the interaction between different units or systems.

 

2. Potential for Missing Complex Errors

 

Unit testing might not be comprehensive enough to identify complex errors that are generally captured during integration or system testing. It is, therefore, essential to complement unit tests with other testing methodologies for a well-rounded verification of the software.

 

Conclusion

 

In light of the above discussion, it becomes unequivocally clear that unit testing stands as a cornerstone in safeguarding the integrity and reliability of software development. Steering clear of it is not only detrimental to the code quality but could potentially escalate the costs and efforts involved in the later stages of development.

 

Adopting a Test-Driven Development (TDD) approach further amplifies the benefits of unit testing. In this paradigm, developers construct tests before writing the corresponding code, thereby ensuring that the codebase develops with testing at its core. This not only engrains a quality-first mindset but also facilitates a workflow that is more organized and less prone to errors.

 

Moreover, the utilization of appropriate tools and frameworks can streamline the unit testing process substantially, making it less cumbersome and more efficient. These tools can automate various aspects of testing, helping to detect issues swiftly and reducing manual effort considerably.

 

As we navigate through an era where software forms the backbone of many critical systems, the role of unit testing in fostering robust, secure, and reliable applications cannot be understated. It emerges not as an option but a necessity, carving pathways for innovations that are both groundbreaking and resilient.

 

By embracing unit testing as an integral part of the development cycle, developers are not only upholding the quality and reliability of their applications but are also taking a step towards crafting products that stand the test of time, offering optimal performance and user satisfaction.

Why Choose Automation for Cross Browser Testing

May 19th, 2023 by

It is necessary to check cross-browser compatibility to ensure that the app is working fine on all the web browsers. Sometimes when you open an app on a web browser it might not look or feel convenient and there might be some issues like image/test overlapping, navigation, alignment, etc. These issues degrade the user experience which will eventually lead to low traffic and existing user attrition. This is why cross-browser testing is an integral part of the QA process and should not be avoided.

 

What is Cross Browser Testing?

 

  • Browser compatibility testing can be automated or done manually.
  • In manual cross-browser testing, the testers have to test the app on multiple OS, device and browser combinations. This is why it is a time-consuming process.
  • The main issues are with the UI and the main features are tested on different screen sizes to check if the look and feel are similar to what was expected.
  • In automated cross-browser testing, there is a need to create the test script initially then there is minimal human supervision is required.
  • Efficient automation tools will take much less time to perform the testing.

 

Automation for Cross Browser Testing

Automation has reduced the time and effort put into cross-browser testing by 80 percent. The only human work goes into writing the initial test script and selecting the tool. Let’s look at the reasons why we should automate cross-browser testing.

Run Multiple tests simultaneously: When it comes to regression testing and running multiple tests for an app, automated testing saves the day. So if your app is already in the market and you launch a new version then automated cross-browser testing helps you to deliver faster. When a new feature is to be launched in the app and the build is sent to the testing team, they will take some weeks to perform all types of testing. This time can be reduced to a few hours using Automation testing tools.

Improved test accuracy: Even the experienced testers can make an error while testing the app manually. Although in Automation testing the accuracy is very high and the detailed reports are recorded. Testers can review the testing process and create new Automated test with the help of those reports.

Save Time and Money: Cross-browser testing require repetitive tests and so it can be a boring and time-consuming process. These repetitive tests can be automated to save time, effort and return on investment. You just need to make sure that everything is included in the test script to avoid gray areas in the app functioning.

Better Test Coverage: The time taken to perform any web app testing is dependent on the type of feature or functionality you have to test. The length of the test affects the cross-browser testing process. For example, end to end testing can be difficult if done manually. It will take much time and effort to do so. This why automation testing can be used if you have to run the test on multiple devices with multiple browser-OS combinations.

Feasibility of Local Test Environment

There are many types of devices in the market with different screen sizes, OS versions, Browsers, etc. To create the desired test environment, you will have to have all these combinations and you will have to set up a device lab. This will take huge investments and efforts to maintain the lab. Also, there is an issue of geographically distributed teams accessing the devices. Apart from that, you will have minimum flexibility as scaling up or down will be difficult.

Advantages of Cloud-Based Cross Browser Testing

There are many Cloud-based cross-browser testing tools in the market which will help you achieve your testing goal without investing a lot. This is one of the reasons why cloud-based cross-browser testing is better than setting up a local test environment. Let’s have a look at some other advantages which will give you a reason to opt for cloud-based option.

Multiple Test Environment Support: Heterogeneity in the operating system versions, device screen sizes, browser versions makes it necessary to perform tests on many combinations of device/OS/browser. This means a lot of effort will be put in to test the functions of an app on multiple devices. This could be avoided by testing the app on a cloud-based device platform.

In the cloud-based testing platform, you will be able to select the devices of your choice and perform parallel testing on multiple devices without buying one. This will save you money and effort to put up a device lab. While running the test in parallel on multiple devices with different OS browser combination will save time, it will also increase the accuracy significantly as compared to testing the app feature manually.

All time access to resources: The testing team can access the tool at any time by just logging into the tool and selecting the devices according to the market research report on popular devices in the region. Testing can be performed at any time which means there is no foundation and this comes in handy when the deadline is near. Having all time access to the device cloud will contribute to continuous testing and ensure faster deployment.

Scalability: While handling multiple projects the team might have needed many devices at times and very few on some occasions. This means that most of the devices in your device lab might rarely be used and sometimes you might have to buy more to add in the environment. This improper management of resources can be avoided by using Cloud-based device platform. Here you can select the devices which you actually need to perform the cross-browser testing and as all the devices are virtual, there is no worry of managing the extra devices.

Collaboration: There are tools to communicate and collaborate with the team which impacts on your productivity in a good way. Test reports can be generated which are elaborate and provides all the information about the health of the app. These reports can be shared with the team online to analyze and resolve the issue.

Initial time and cost: To set up an actual device lab you will require dedicated cloud/network expertise and suitable infrastructure. On the contrary, if you use cloud-based platform for cross-browser testing then you don’t have to worry about the infrastructure and initial setup cost. Also, you will save a lot on maintenance cost and everything is preconfigured.

Comprehensive testing: To perform thorough cross-browser testing, you need a permutation and combination of mobile devices with different screen size, OS, browser, other features relevant to the app function. This will make a big hole in your pocket if you wish to buy that many devices. This is why cloud-based testing platforms are the best option.

Cross Browser Testing

Types of Cross Browser Functional Testing

There are three types of cross-browser functional testing, multi-browser testing, multi-version testing, and concurrent testing. Let’s get familiar with all three of them.

Multi-Browser Testing: The application under test is opened on different browsers like Chrome, Safari, Opera, UC Browser, etc to check if the app works consistently across all the browsers. The app feature can be tested on multiple devices of different configurations and browser combinations.

Multi-Version Testing: In this type of testing the AUT is tested with different versions of any browser to check if the functioning is smooth. So if your app supports chrome version 40.0.2214, then the app must be tested on all the versions of chrome after 40 to check the functionality. One tester can perform the task and multiple devices will be used to perform the testing.

Concurrent Testing: In this, the application under test is checked simultaneously on different web browsers. There are four variations of this testing – single browser distributed concurrent testing, multi-browser distributed concurrent testing, Multi-browser concurrent testing, and single browser and single browser concurrent testing.

Conclusion

Cross browser testing combined with cross-platform testing will ensure that the app works smoothly in any type of environment. Especially for web apps, cross-browser testing cannot be avoided. Studies have suggested that people uninstall the app after using it once if the UI is not user-friendly. Even the app ratings on App Store and Play Store are affected by the user experience, leading to a lower number of downloads. Enterprises can save a lot of money and build a good report among the users by proactively testing their app thoroughly.

Related Articles:

Code Review in a Startup: Balancing Perfectionism and Sanity at the Speed of Thought

May 18th, 2023 by

Code Review in a Startup

Here I bring to you the 5th blog in the DevOps series showcasing our learning while #scalingup. Read our previous blog to know about the bunch of tactics that we used at different times during our evolution to achieve a successful clockwork during our DevOps journey.

Proper optimized code review is something that many startups miss. Some take the easy way out and ignore it and others spend years discussing the best practices, conventions and styles without ever committing code. Both these are slightly over exaggerated examples of paths to failure, but I am sure you can relate to these if you have ever tried to answer the all important question about code review “Exactly how much code review should your team do?”

For perfectionists, the answer is that code should always be reviewed and you should always be refactoring code and improving it wherever you see a scope. I have worked in companies, where people used to spend almost as many hours reviewing code as much as they would writing them. There are some practices like pair programming, which has maximizing code review as one of the results. So this is not exactly a wrong direction of thinking. The problem however is that when you are working with time constrained environments like that of a startup, you will not have a luxury where you can keep revisiting and improving code beyond a reasonable amount of time. And I have seen that surprisingly many people altogether avoid code review because timelines are constrained. I don’t even need to mention how risky this is and how dangerous this course of action is. However it seems many people do exactly that.

In this blog post, I will attempt to throw light on our experiences in deciding how much is enough. We too, like other startups have a time constrained environment, and a few (thankfully only a few) customers who want every feature done yesterday. So as a culture, we too try to make sure that we finish everything faster. Development faster, Testing Faster, Deployment to various environments faster. But we do not ignore code review. We ensure that we do code review. We have a few principles that we followed to make sure that code review happens all the time, and is neither too less nor too much. Here are they. What we have seen is that if you follow all these steps, then you have a sane code review process and you can guarantee a stable flow of god code into your repository. These points are in no particular order of importance.

You should do code review: The first principle is not a lame attempt at a joke. The idea is that code review should happen come what may. Without this principle being followed, every other principle in this list breaks down. We use git-flow as one of our developer methodologies with git. One of the advantages of this system is that code review is built in. Unless code is approved by a designated reviewer, the code does not go to the next level be it Testing or Production. The Approver is as responsible for a piece of code as the original developer. This way the reviewer spends more time reviewing and the original coder also reviews and corrects his code in advance to preempt the reviewer. This adds more points in the system where code review can happen and makes sure that code always gets reviewed and the review is not forgotten.

Requirement Matching: Does your code do what the requirements ask it to do? Are we doing less? Are we doing more? A quick inspection reveals mismatches if any. This goes a long way in finding out if there are any problems in the code.

Readability: There is an apocryphal statement that says that code is written once and read hundreds of times. While the statement may not be accurate, you may write more than once, and may not read hundreds of times, you still do get the picture. The basic premise is that code does get read many far more times than it gets written. Also once written, your code will also be read for review, bug fixes, enhancements, etc and not always by you. Also in the IT Sector, jobs switches happen a lot, so a new person should be able to understand and work with the code as soon as possible.. So it makes sense that whoever looks at your code after you have left is able to understand your code well and can alter if needed and maintain the code well till the product lifetime completes.

Reviewability: A further subset of this is that the code should also be reviewable, you and your code should be able to convey to the reviewer what the code is supposed to do and what the reviewer is supposed to review.

Scalability: Will your code be able to stand frequent and/or continuous requirement changes in the future? Will it be able to handle a reasonable amount of requirement change without having to have to rewrite the entire thing? Overall applications are live, especially in the Agile era, your requirements are never frozen, and hence the code also should never be frozen. It should be able to handle changes in requirements. A word of caution here, do not overdo this. While your code should be able to handle requirement changes, you cannot (and should not) make your code so generic that it can handle the proverbial ‘everything under the sun’. Your code should be reasonably scalable. Too much scalability also is as bad as too little. How much to go down this path will depend on your specific business needs. However it is not a bad idea to talk about specifics to your business stakeholders. They can tell you how and more importantly how much a feature will be used. You can then decide how scalable you want the code for that feature to be. The process of arriving at how much is just right, takes time to set, but once done, you will thank yourselves for the foreseeable future.

Improvements: This is one of the basic purposes of code review. This answers the question, “Can we do the same thing in a better way?”. Better way could mean one or more among, faster performance, better readability, more modularity, and others. You need to keep asking this question in a code review. If you can, then your code review is not complete, if you cannot improve any longer, then probably the code reached here after many rounds of reviews. Or was copied from well reviewed code. Again this is one of those things that has the potential to be overdone, so think carefully how far do you want to go down this rabbit hole without losing your wits.

BNBR: This is lifted from one of the policies of Quora, It means Be Nice, Be Right. The point is that while reviewing , you need to be nice and be right. Being Nice First. The point of a code review is to see if things can be done better by putting multiple heads instead of one. It is not to hurt or massage egos. What can be done by just pointing out issues with data should not descend into a shouting match (verbally or through the keyboard). Make sure that your comments are politely worded and are correct.

Code Scanners: Before you give your code for review, your code should be scanned by tools to make sure that basic checks are done for issues like parenthesis matching, formatting, typos, indentation, naming convention etc. Your reviewers will have a tougher time navigating your code if you do not fix these. If your reviewer finds these issues and not a code scanner, then you have not prepared for your review well.

The Unhappy Path: The code works fine, but some scenarios were not tested. How do you know if your code is able to handle most of the basic errors or exceptions. Your review should make sure that this is in place well before time. Again you need to use this judiciously. You should not overdo it.

Timeliness: Your code review should have a deadline. You cannot indefinitely keep reviewing the code, your review should finish within a deadline. If you ship years late, how will better code help you ?

Dark Spots: Every reviewer may not be able to review all aspects of the code. So it is a good practice to tell in the review comments what aspects were reviewed and what were not, so that everyone knows the extent of the code review. If everyone says it looks good to me, but everyone only happened to review the naming conventions, then it probably was better if only one person reviewed. If each reviewer mentioned this small info, then everyone knows in advance if there were any dark spots in that particular review and they will be able to redress it.

Fatigue: Do not review too many pieces of code at a time. If you happen to be spending a long time reviewing, then probably the code under review is too large or you are reviewing too many PRs at the same time. Reviewing is a thought intensive process and you need to make sure that it is done properly. So please take breaks, if you are tired of reviews and are still somehow powering through that will reflect in the quality of the reviews. A rule of thumb is to not review more than 60 minutes at a time or around 400 lines of code at a time.

Checklists: One good shortcut is to use checklist to review a PR or a piece of code against. These checklists ensure that your mind does not wander, wondering what you have missed and you will also be reviewing against pre decided metrics.

Defects: What do you do with the issues you found ? Not every issue needs to be or can be fixed immediately. You have to decide what to do with each review comment. Whether you will be fixing them, ignoring them or putting back into your backlog. Make sure this is a separate backlog for technical debt.

Overall these are the things that we follow while doing code review. Many of these helped us a lot to make sure that we are reviewing just enough to keep our process wrooming along while at the same time, not ignoring major issues.

17 Best Tips To Write Effective Test Cases

May 17th, 2023 by

Test cases are the first step in any testing cycle and are very important for any project. If anything goes wrong at this step, the impact gets proliferated in the entire software testing process. This can be avoided if the testers use proper procedure and guidelines while creating the test case template.

In this blog, I am going to share some simple yet effective tips which you could use for writing effective test cases. These tips will save you time and effort while optimizing the use of resources.

How to write test cases in a better way

Let’s have a look a the tips to write better test case template.

1. Detailed Domain Knowledge

Domain knowledge in information technology means deep knowledge of business and operational dynamics, the risks involved and the opportunities in that particular project. It is required to follow the best practices in the domain.

2. Break long test cases into many smaller ones

It is better to break the test case into a group of smaller ones if it has too many steps. It would be easier for the developer to backtrack and repeat the test steps if an error occurs somewhere in the test script. If not done than there are high chances that the developer will miss the bug.

3. Preconditions

Before starting on the test case it is suggested confirm all the assumptions that apply to the test and the preconditions that must be met before execution. There can be data dependency or the dependencies on the test environment or any other test cases.

4. Attach Artifacts

Relevant artifacts should be attached to the test cases. This can be done using a test management tool. At the time of product delivery, It will help to track the changes in the application. I will be easy to understand the flow of the function when there is a change at any step which will not be easy to relate otherwise.

5. Test data input

While writing a new test case a tester can share test data wherever applicable to be used for the Test Case within the test case description or add with the specific test case step. This will save time as there is no need to look for the test data anywhere else.

If the values are to be verified then testers can specify the value range or describe what values are to be tested for a particular field. Choose a few values from each class which will give good coverage for your test.
It’s better not to mention the real test data value but the type of data which is required to run the test. In projects where multiple teams use the test data and it keeps changing, mentioning only the type of data will be a wise choice.

6. Organize your work

Use a test management tool to manages your test cases instead of using a spreadsheet. There are many test management tools that can be used to organize the test cases in one place which will increase the productivity of the team.

7. Stop Assuming

It is better to refer to the specification document. Assumptions about the features or functionalities can lead to disagreements between the client and the developers. This gap between the client’s requirement and the application under development will impact the business.

8. Test Case Naming Conventions

To write tests which are easy to understand, we have to stop coding on autopilot and pay attention to the naming conventions. It is required to name our test classes, fields of our test classes, test methods and the local variables while writing automated tests for our application.

It does not matter which team member wrote the test, others will know what feature is tested under what scenario without even looking at the test code.

9. Meet Customer’s Requirements

If the testers miss a bug or write test cases that do not relate to the real world scenarios then it’s just a waste of resources and time. The goal is to meet the customer’s expectations and that can be attained only if the testers think from the users perspective.

10. Cover All Verification Points

It is important to write well-defined test case verification steps covering all the verification points for the feature under test. To make sure that the test Case covers all the verification points match your test case steps with the artifacts given for your project.

11. Avoid Repetitions

Do test automation when needed as it will reduce the manual effort and save a lot of time. The test scripts should be written in such a way that they can be used afterward for some other project.

12. Make it Reusable

Create test case template which could be re-used in the future by other teams. Also, before writing a new test case for your module, find out if there are similar test cases written already for some other project. Doing this you will avoid any redundancies in your test management tools. Call the existing test case in pre-conditions or at a specific design step if there is a need for a particular test case to execute some other test case.

13. All-Inclusive Test Coverage

Test cases should include all the features and functionalities mentioned in the software requirement. Requirement traceability matrix will help in finding the untested functions of the application.

14. Group Similar Test Cases

A test run is a collection of test cases that testers should execute in a particular order. Test cases are often grouped in test runs. It’s preferred to put preconditions at the beginning of a test run rather than inserting them into each test case.

Actually, only a few of the test cases need preconditions, so the field is often left empty. A test management tool will help to customize your forms and create a test case template which will save your time and effort when writing test cases. Another thing to keep in mind is to avoid writing the same instructions several times by moving repeated preconditions to a test run.

15. Easy to Understand

The test cases should be well defined with comments where ever needed so that any other software tester can work on it in the future. Whatever project you work on, when designing test cases, you should always consider that the test cases will not always be executed by the one who designs them. Therefore, the tests should be easily understandable and to-the-point.

In a scenario where the person who wrote all those test cases leaves for some reason and you have a completely new testing team to work with, the entire effort spent during the design phase could go down the drain.

16. Test Case Description

In the description, the testers need to mention all the details about what is going to be tested, what needs to be verified, the test environment and test data.

The information mentioned below should be there in a well-written test case description:

  • Test to be carried out
  • Testing tools
  • Test Environment Details
  • Behavior being verified
  • Any dependencies like preconditions and assumptions
  • Test Data to be used

 

17. Maintenance and Update

All the test cases should be updated with the new requirements so it’s easier to execute them in the future if there is a need. Even if some other tester wants to use the test case he/she wouldn’t have to go through the details of the script.

Conclusion

The tester needs to have good domain knowledge and should write presentable test cases from the users perspective. A good test case template will make it easier for testers to write good test cases. If there are only a few test steps, consider making a checklist instead and have a look at some relevant test case examples before working on your test case. A test case example will be helpful in creating test case templates too. A test management tool will definitely help in improving the way test cases are created and managed.

Related Articles:

Mobile App Testing Strategies

May 4th, 2023 by

In the year 2028, there will be around 7.8 Billion mobile users which accounts for 70% of the world population. More mobile users mean more apps and more competition and to lead the competition we need to make sure that our app is flawless. If nearly half of the bugs in your mobile app are discovered by the users, your app’s ratings are going to decline and so are the downloads. This is why the right choice of mobile app testing techniques must be followed in the decision-making process.

Mobile App Testing Strategies

Today, the mobile app market is highly competitive. To be better every day and survive for long, the QA team has to follow a mix of plans that would be responsible for taking the right testing decisions. The testers have to formulate testing strategies to face every situation fearlessly and immaculately. Mobile apps have to be perfect before reaching to the end users so there have to be certain decisions to be taken regarding the testing plan. The following model of mobile app testing plans can be considered for better execution.

In the planning Stage, decisions like Selection of Device matrix, Test Infrastructure (In-house vs. Cloud, Simulator vs. Real device), Testing scope, Testing Tools, Automation (Framework/Tool) are taken. Since it is the first stage, it is the most important one as all the further stages would depend on these decisions. In the next stage which is execution and review, decisions regarding Test Case Design, Testing of user stories, testing types as per Sprint Objective, Progressive Automation, Regression Testing, Review and course correction are taken.

We are going to discuss the planning stage aspects more elaborately

Device Matrix:

It is an important factor, choosing the device as per your target audience’s behavior matters in decisions regarding resting. There are different approaches to the selection of the device matrix.

Approach 1- Selection of Devices based on market research.

Determine the set of devices with your target operating System that will have the highest occurrence of accessing your application by using app purchase data and analytics. For Example- if you support both Android and iOS, and your application will be used across millions of Samsung, Google Nexus and Moto G devices but only thousands of iPhones, you prioritize testing on the Google Nexus and Moto G above the iPhone device. So, this test plan will consist of testing on devices which are prioritized by your market analysis.

Approach 2: Categorize the devices based on Key mobile aspects

This approach highlights the categorization of the devices based on certain mobile aspects which can be considered in formulating the testing strategy. The categorization goes as:
Mobile device categorisation

Test infrastructure

This is another element of the planning stage. This focuses on Strategizing on the Infrastructure components like hardware, software, and network which are an integral part of test infrastructure. It ensures that the applications are managed in a controlled way.

Real device, Emulators or Mobile cloud-Where to test?

Choosing the right platform to test as per the testing needs is very important i.e whether to test on the Real device or an emulator or on the cloud

Real Devices

Testing on a real device is anytime more reliable than testing on a simulator. The results are accurate as real-time testing takes place on the device in a live environment. It carries its own disadvantages as it is a costly affair and not all the organizations are able to afford a complete real device laboratory of their own.

Pros:

Reliable- Testing on Real devices always gives you an accurate result

Live Environment- Testing on real devices enables you to test your application on the actual environment on which your target audience working on. You can test your application with different network technologies like HSPDA, UMTS, LTE, Wi-Fi, etc.

User experience- Testing on Real devices is the only way to test your Real-time User experience. It cannot be tested through Emulators or devices Available on Cloud.

Cons:
Maintaining the matrix- You cannot maintain such a huge matrix of mobile devices in your own test lab.
Maintenance- Maintaining these physical devices is a big challenge for organizations.
Network providers- There are more than 400 network providers all over the world. Covering all these network providers in their own test lab is impossible.
Locations- You cannot test how your application behaves when it is used in different locations.

Emulators

The emulator is another option to test mobile apps. These are free, open source and can be easily connected with the IDE for testing. The emulator simulates the real device environment and certain types of testing can be run on it easily. However, we cannot say that the results of emulators are as good as those of real devices. It is slower and cannot test issues like network connection, overheating, battery behavior, etc.

Pros:

Price- Mobile emulators are completely free and are provided as part of the SDK on every new OS release.

Fast- As Emulators are available on the local machine so they run faster and with less latency than Real devices connected to a local network or devices available on the cloud.

Cons:

The wrong impression- Even if you have executed all test cases on emulators, you cannot be 100 % sure it will actually work in the real environment.

Testing Gestures- Gestures like Pinching, Swipe or drag, long press using the mouse on simulators are different in using these gestures on real devices. We cannot test these functionalities on emulators.
Can’t test Network Interoperability- With the help of Simulators you cannot test your application with different network technologies. Like HSPDA, UMTS, LTE, Wi-Fi, etc.

Testing on Mobile Cloud

Mobile cloud testing can overcome the cost challenges like purchasing and maintaining mobile devices. It has all different sets of device types are available in the cloud to test, deploy and manage mobile applications. The tests run virtually with the benefit of choosing the right type device-OS combinations. Privacy, security, and dependency on the internet can be a challenge in this case but it has many benefits that can cater to different testing scenarios.
Mobile cloud

The organization can choose the right mix of above-mentioned platforms as every platform carries its own advantages and disadvantages. Sometimes a combination of real and emulators is preferred and sometimes all three can be considered as per the testing strategy.

Pros:

Devices Availability- Availability of Devices and network providers is a big gain for cloud users.
Maintenance- When you are using cloud services. Forget about maintenance. These providers take responsibility for maintaining these devices.
Pay per use- You don’t need to buy a device. You only have to pay for the duration you use that device.

Parallel Execution- You can test your complete test suite on multiple devices.

Cons:
Cost- Some providers are a bit costly

Automation Tools for Mobile App Testing on Android and iOS

Nowadays, there are so many automation tools available in the market. Some are expensive and some are freely available in the market. Every tool has its own pros and cons. Choosing the right tool for testing would reduce the QA team effort providing seamless performance at the same time. We will discuss the best mobile app testing automation tools for iOS and Android platforms in 2018.

1. Appium: It is one of the preferred MAT tools by testers. It is open source and free tool available for Android and iOS. It automates any mobile app across many languages and testing frameworks like TestNG. It supports programming languages like Java, C# and other Webdriver languages. It provides access to complete back end APIs and database of the test codes.
Top Features:
-Appium supports Safari on Ios and Other browsers on Android
-Many Webdriver compatible languages can be used such as Java, Objective-C, JavaScript to write test cases
-Support languages like Ruby, Java, PHP, Node, Python.

2. Robotium: It is a free Android UI testing tool. It supports in writing powerful black box test cases for Android Applications. It supports Android version 1.6 and above. The tests are written in Java language and basically, Robotium contains a library of unit tests. Apart from this, Robotium takes a little more effort in preparing tests, one must work with program source code to automate tests. Robotium does not have play record and screenshot function.

Top Features:
-The tests can be created with minimum knowledge of the project
-Numerous android exercises can be executed simultaneously.
-Syncronises easily with Ant or Maven to run tests.

3. Calabash: It is an open source MAT tool allowing testers to write and execute tests for Android and iOS. Its libraries enable the test codes to interact with native and hybrid apps. It supports cucumber framework which makes it understandable to non-tech staff. It can be configured for Android and Ios devices. It works well with languages like Ruby, Java, .NET, Flex and many others. It runs automated functional testing for Android and ios. It is a framework that is maintained by Xamarin and Calabash.

4. Espresso: It is a mobile app testing automation tool for Android. It allows writing precise and reliable Android UI tests. It is a tool targeted for developers who believer automated testing is an important part of CI CD process. Espresso framework is provided by the Android X Test and it provides APIs for writing UI tests to simulate user interactions on the target app. Espresso tests can run on Android 2.33 and above. Provides automatic sync of test actions with the app UI.

5. Selendroid: An open source automation framework which drives off the UI of Android native, hybrid and mobile web application. A powerful testing tool that can be used on emulators and real devices. And because it still reuses the existing infrastructure for web, you can write tests using the Selenium 2 client APIs.

6. Frank: Is an open source automation testing tool for the only iOS with combined features of cucumber and JSON. The app code needs not to be modified in this tool. It includes Symboite live app inspector tool and allows to write structured acceptance tests. It is tough to use directly on the device but is flexible for web and native apps. It can run test both on simulator and device. It shows the app in action by showing its recorded video of test runs.

Above are a few promising, popular and most commonly used and mobile app testing automation tools. Choice of tools certainly resolves many testing-related problems faster and efficiently. Implementing these tools requires skill and experience and so an organization needs to have a proper testing team in place to make all of this possible.
Related Articles:

Challenges in Mobile App Testing

March 20th, 2023 by

Today, there are many smartphone users in the world and so is the popularity of mobile apps. In order to be competent enough, mobile apps have to be unique and should provide the best user experience to increase the user base. With the users getting more informed and intelligent, the apps built should keep up with the pace. In order to be impeccable, the mobile app should undergo a rigorous testing process and during that process, the testing team faces many challenges in this aspect which will be covered in this blog. But before we dive in, let’s look at the different types of apps that are available in the market.

Types of mobile applications

The creation of mobile applications is a fantastic approach to boost brand recognition, attract new clients, and improve the user experience for existing customers. In light of this, let’s examine the three primary categories of mobile apps: native, web, and hybrid.

Native apps:

Native mobile applications are ones created exclusively for a given operating system. As a result, software created for one System cannot be used on another, and vice versa. Native applications are more effective, quick, and offer greater phone-specific functionality. Thus, the difficulties of testing mobile apps for compatibility with native user interfaces of devices involve ensuring that such traits are preserved strictly.

Web apps:

Similar to native apps, web applications do not require users to download them. Instead, the users’ web browsers on their phones can access these apps because they are incorporated within the website. So, it is envisaged that web applications will operate flawlessly across all platforms. Testing teams must carefully examine the application on a wide range of real devices and browsers to ensure high app quality. Yet in addition to taking a lot of time, this operation is essential because failing to work on a few devices can severely reduce the app quality and incur heavy losses when the app doesn’t function as required.

Hybrid apps:

The features of both online and native apps are available in hybrid apps. These are essentially web applications that mimic native apps in design. These applications are easy to maintain and load quickly. Teams that test mobile apps are in charge of making sure hybrid applications don’t lag on some devices. Any operating systems with the capacity to support the said features have access to all their functionality.

While each of these app types are slightly similar to each other the technical teams face a different challenge with each type of mobile application. Combining these challenges greatly increases the complexity, making the entire procedure laborious and time-consuming. Let’s quickly look into what some of these challenges are?

Challenges in Mobile App Testing


Different Operating Systems and their versions

There are different types of operating systems available in the market such as iOS, Android, Windows etc. Also, these OS have different versions too. So, it becomes challenging to test so many versions of the mobile app in a shorter period of time. One app that works well in one type of OS may not work well in the other. It is very important to test the application with all supported platforms and their version because we don’t know where the user is going to install the application. As per research, iOS users upgrade quickly as compared to Android but in Android the device fragmentation is larger. That means the developers have to support older versions and APIs and testers also have to test accordingly.

2019-03-27 (1)


Device Variations: Based on Screen size

Android comes with a mix of features and variations in pixels densities and ratios which varies in each screen size. Even in the case of Apple, the screen new size was introduced with the launch of the iPhone 6. Now, it is not just about being picture perfect screen design rather designing an adaptive screen design. Well with such a variety in screen sizes, the role of the tester becomes serious as they need to check if all the features are working well in different screens and pixel and aspect ratios are maintained well.

devices-screen-sizes


Based on the number of Devices

The picture below shows the number of devices in the market by different brands. The number of device manufacturers has increased. According to OpenSignal, there are around 1294 distinct Android phone manufacturers alone, imagine if we add up other brands. The pace with which this data is increasing is a bit alarming for the testers as the testers have to check the app performances on different devices, they would probably need a device library to do the same. The challenge remains in context to functionalities like Complex user interactions on touch screen and keypad devices as well. Having a device library is certainly is a costly affair unless emulation is adopted which can simulate multiple device types and testing can run easily on it.

OpenSignal-Brand-Fragmentation

Image Source: venturebeat.com


Various Networks

The QA team also faces challenges when it has to test the devices connected to different networks. Generally, there are 2G, 3G,4G mobile data available. These provide different data transfer speed and transmission. These varying speeds of the networks by various providers remain a challenge for the testers even today. In this case, testers have to check that the app must perform well at different network speeds and connectivity quality and a check on bandwidth usage of the app. This remains a challenge as it is partially controllable based on different network providers and connectivity access in different geographies.

 

Frequent OS releases

Mobile Operating Systems keeps changing. Both Android and iOS have more than 10 versions of their operating systems. They keep enhancing and updating their versions for better performance and user experiences. This frequent OS release comes as a testing challenge as the testers needs to validate the complete application with each of new OS release. It is very important to test the application with the latest OS release otherwise the app performance would be a major issue and consequently loss of users using the app.

screen-shot-2018-07-12-at-1.35.22-pm

Script Execution

Another major challenge of mobile testing is what we call scripting, the method of defining a test. Script execution can either be manual or automated. You can write down the scripts in a document, which is then used by a test engineer who manually interacts with the test environment to determine the result, else you can run automated scripts that in turn drive interaction with the device and app, and record the results.

 

Automated scripting needs to be kept away from the device to be of any real use because there are so many different devices with different interface options. A script that follows strict keystrokes on an Apple iPhone would not have any chance of working on a Samsung device, because the UI is different. Fortunately, most real device automated testing software provides high-level scripting that operates on the text, image, or object layer. Device emulators can automate testexecution using a higher-level, abstracted scripting language that is not device dependent. When you use automated scripting, the cost of setting up the script will typically be higher than the cost of a single manual execution of a test. But if it is a test script that you run on a periodic basis, every time that you subsequently run the script, the more time and effort you will save. You will eventually recover the cost of initial scripting If you run the script enough.

 

So to conclude, to build a better user experience, an app tester needs to work had in overcoming the challenges of testing. By adopting some analytical skills and methods, testers can really cope up with these situations. For eg. Testing only those apps and OS which are mostly used by their user segment, by adopting a strong testing strategy to take situational decisions eg. Decisions regarding when to choose Automation and manual testing. Strategically, the challenges can be overcome.

 

Screen Size

The Android world is not simple. The variety of different aspect ratios and pixel densities can be overwhelming. With the launch of iPhone Xs Max which has a screen size of 6.5 inches, Apple brings new screen sizes to the iOS world as well. Though iOS developers are used to pixel perfect screen design, they now need to change their mindset to the adaptive screen design instead. For testing, it means that we need to check on various devices that all the necessary screen elements are accessible with different screen sizes and aspect ratios. There are many phones with a screen size of 5 inches which are still popular.

 

2019-03-28

Security Issues

Traditional testing tools like selenium and QTP weren’t designed with cross-platform in mind. Automation tools for web apps and mobile apps are different. Operating systems especially Android further adds to the complexity with API level fragmentation. The most common automation testing tools for mobile app automation testing are Appium and calabash. Each tool has it’s own advantages and disadvantages and you need to choose on the basis for your app’s functioning.

Weak Hosting Controls is one of the most common issues. The server on which your app is hosted should have security measures to prevent unauthorized users Weak Encryptions can lead to data theft which will impact the trust factor of the users. Most of the mobile apps require user data such as email ID, password, age, location etc. This data should be encrypted and stored with proper security. Hackers often use this kind of data to get money out of users account online. Encryption will make it difficult for anyone unauthorized to intrude and retrieve that data rather than keeping it in plain text.

Power consumption and battery life

We haven’t seen much innovations in the mobile battery but the mobile usage and specifications are increasing rapidly. People are using more apps nowadays and the apps are more complex than ever. This is why testers need to test the apps power consumption because if the apps use lots of CPU cycles and some apps will also run in the background than the battery will drain out quickly. We need to make sure that the app uses less battery power so that users can use it for a longer period of time.

2019-03-27

Conclusion

Mobile apps are evolving with device technology and user expectations. Developers are emphasizing on reducing the app size and battery usage. Testers play a major role to ensure that the app works smoothly and does not crash or have bugs. This is why testers must be aware of the latest trends in mobile app testing to deal with the mobile app testing challenges.


whitepaper

Related Articles:

5 Ways To Create Better App Experience For Your Users With Remote Testing

April 2nd, 2020 by

As the world battles with turbulent, uncertain times, most of the workforce across the globe is working remotely. Organizations have acknowledged the importance of remote working as it helps in maintaining business continuity. But in some scenarios, it is difficult to maintain business continuity or distribute resources within the teams while the team is working remotely.
 
For instance, if you have some physical device infrastructure to test your app on multiple mobile devices, how would you do it? How would you share the devices with other testers and developers in your team working from different locations? Most importantly, how will you make sure that the app works smoothly on all the popular devices? We will address these issues in this blog, so buckle up for some interesting insights into the remote testing advantages that can ensure a better app experience for your users.

1. Abate device fragmentation and ensure better app compatibility with remote testing

 
Device fragmentation is any testers Achilles heel as it limits their potential of extensive testing. Testing from a physical device lab at this global lockdown situation is not feasible, and testing on a few devices won’t yield good results. But this issue can be rectified by testing on a device cloud. In pCloudy, users can test on multiple devices based on the popularity of devices in a particular region and its penetration to get the optimum device coverage.
 
Both manual and automation testing can be performed with unlimited parallel test runs remotely on hundreds of real devices. This is also convenient for globally distributed teams, as the users won’t have to wait for the devices to be available for testing.

2. Deliver Better Quality App with Rapid Automation

 
Enterprises can ensure better quality apps without missing out on any deliveries by leveraging remote devices for automation testing. pCloudy helps in speeding up automation testing with codeless scripting and test orchestration using integrated tools like Jenkins. Capability configurator is a feature in pCloudy that generates the desired capability based on a set of filters, which saves time and effort while performing test automation. Integration with popular automation and collaboration tools like Appium, Espresso, Jira, etc., makes it convenient for users to perform automated testing on remote devices.
 
Mobile device lab

3. Better collaboration and continuous feedback

 
In pCloudy, users can manage teams and distribute credits among themselves. The user management feature allows managers to become the system administrator and create teams to allocate the credits to the members according to the task assigned. This helps in user and task as the hierarchy is maintained to distribute workload systematically.
 
Once the tests are complete, detailed test reports are generated automatically, which can be easily shared across the team. The progressive reports also show the tests failed, passed, and those with errors. This helps in focusing only on the tests that failed and doing a root cause analysis to rectify the issues. Continuous access to a range of devices available for remote testing will provide stability to your CI/CD pipeline.

4. Assured data privacy and security

 
Enterprise-grade security gives assurance to our users that their data is safe on the cloud platform. Our data centers comply with internationally recognized security standards like ISO27001, SOC2, and SSAE-16. Keeping your security issues in concern, we have another useful feature called Wildnet. This feature enables you to test your internal sites or apps on your local network, keeping all your data and information secure.

5. Advanced features to improve manual testing

 
Take advantage of next-gen features like Certifaya, an AI-powered autonomous testing bot to save time and effort. FollowMe is another feature that enables the user to run a test on multiple devices in parallel. This will save your resources while reducing the testing time by multifold. Apart from this, there are many features in pCloudy, like taking screenshots, recording the test video, cross-browser testing, etc. that will make manual app testing a piece of cake.

In a Nutshell

 
Remote testing is convenient, and it will help you save big bucks while you deliver a better quality app in less time. Continuous access to numerous devices helps in accelerating automation testing, as the app can be tested on multiple devices in parallel. All these advantages of remote testing make it the optimum choice for enterprises.

Scaling Up Mobile App Testing With Jira Bug Tracking Tool

December 2nd, 2019 by

By concentrating our efforts upon a few major goals, our efficiency soars, our projects are completed, we are going somewhere. This quote by Michael Korda signifies the importance of organizing our efforts to gain better efficiency at work. In mobile app testing, efficiency can be achieved by using a multifunctional tool like Jira and pCloudy. pCloudy is integrated with the Jira bug tracking tool to make it easier for testers to log bugs in Jira from pCloudy. Let’s get an overview of Jira and how it can be used for multiple purposes.
 

An Overview of Jira Bug Tracking

 
Jira is an open-source tool used for project management, bug tracking, and issue tracking. Jira has many features and functions that make issue handling easy. Customizable reporting allows you to monitor the progress of your issues with detailed graphs and charts. Jira has four major functionalities, project, issue, component, and workflow.
 
An Overview of Jira Bug Tracking
A Jira project is a collection of issues and it is identified by a name and a key. The project key is added to each issue associated with the project. Workflow helps in mapping your business process. So now let’s understand how to use the Jira bug tracking tool and its components.
 

Jira Workflow

 
Jira has a function called workflow which is used to make a blueprint of the procedure in any organization. The workflow can be customized to suit the project, issue or any subtask. The Jira defect workflow comprises of colored blocks that represent the status of the task and lines that represent transitions.
 
Jira Workflow
Users can build their own workflows from scratch or download the prebuilt workflows and then customize them. Approval requests can be set for users to make changes in the tasks and task status can be set to change with transitions automatically.
 
Status shows the position of an issue within a workflow and transitions are the bridges between the status to represent how an issue moves from one status to another. Resolution tells why an issue changed from open to close and condition control who can perform the transition. The assignee commands the responsible member for any particular issue. Validator ensures that the transition can happen given the status of the issue and Jira can recognize some properties on transitions.
 

Creating an Issue in Jira

 
An issue is the building block of the project and components are subsections of a project used to group issues in smaller parts in a project. To create an issue you need to click on the plus sign located on the left side of the screen. A new window will pop up where you need to fill in the details about the issue that you are creating.
 
Creating an Issue in Jira
The first step would be to choose the project that the issue is associated with. Just below that is the issue type where you need to select if it is a task, an epic or a story.
 
Creating an Issue in Jira
Then add a summary about the issue and assign the issue to your team members. Next, you need to choose the priority and add a label to the issue. Once that is done, You can now add a detailed description of the issue to make sure that you and your team members are on the same page.
 
Create issue automatic
Below the description, you will find Components dropdown and the Environment where you need to fill in the details appropriate for the issue like Hardware specifications, OS, software platform, etc.
 
Create issue

You can also attach files related to that particular issue by clicking on the attachment section and then click on Create to create the issue.
 

Jira Reports

 
Jira generates various types of reports on the basis of workflows, issues, task status, and other data fed in by the team. You can track the total work remaining in the burndown chart and manage the progress accordingly. A burnup chart will help in tracking the total scope independently from the total work done. In the sprint report, you get an idea about the tasks that are completed and pushed backed to the backlog in each sprint. Apart from this, there is a cumulative flow diagram, velocity chart, version report, etc.
 
Jira Reports
Users will also get an issue analysis report for a better understanding of the resolved and unresolved issues.
 

pCloudy integrated with Jira Bug Tracking

 
pCloudy has the option to log bugs, save screenshots and videos of the test actions. But if you want to use the Jira bug tracking system to log bugs then you can to that though pCloudy as well. Just click on the profile ID and the top right corner of the pCloudy screen and select the user setting from the dropdown list.
 
Jira login
In the user setting page click on the JIRA Logs tab. Enter the URL, Email, API Token and login to log bugs in Jira.
 
Jira login
This way you can maintain a separate bug log to share with the team apart from the one in pCloudy. pCloudy also generates reports like Jira and those reports can be shared across your team.
 
Jira supports both Kanban and Scrum agile methodologies. As a matter of fact, scrum is much more popular these days as it gives the project team to plan their work in detail prior to starting the project. When the scrum board is created, a list of items is added and then sprints and versions are created to move the issues from backlogs to sprints. With Kanban, users can start without having a detailed plan and in these issues can be created but that cannot be moved to sprints as we do in the scrum.
 

Conclusion

 
There are many uses of Jira in mobile app testing. It’s not just about handling issues or creating workflows, Jira project management is helping the world’s most known brands in the world. If you understand the Jira bug life cycle and follow the Jira bug tracking best practices, it becomes much easier to scale up your testing efforts. Jira bug tracking, when combined with pCloudy, can save your time and resources.

A Brief Overview Of Regression Testing

October 22nd, 2019 by

Studies have indicated that after installing a new app, only a quarter of the users return to the app on the second day. The retention rate is eminently low and the majority of the users uninstall the app after the first use. You might have guessed the reason for this. If you think the reason is scanty testing then you are correct. A lot of times testers show little interest when testing is repetitive. Although regression testing is crucial to the success of the project, it is often overlooked to some extent. So let’s understand the concept of regression testing.

What is Regression Testing

In simple terms, regression testing can be defined as retesting a computer program after some changes are made to it to ensure that the changes do not adversely affect the existing code. Regression testing increases the chance of detecting bugs caused by changes to the application. It can help catch defects early and thus reduce the cost to resolve them.
 
Regression testing ensures the proper functioning of the software so that the best version of the product is released to the market. Although, creating and maintaining a near-infinite set of regression tests is not feasible at all. This is why enterprises are focusing on automating most of the regression tests to save time and effort.

Types of Regression Testing

There are different types of regression testing for different phases of testing. Let’s understand the types of regression testing.
 
Types-of-Regression-Testing
Unit Testing: It is done when coding changes are made for a single unit and a tester re-runs all previously-passed unit tests. Often automated unit tests are built into the code to make unit testing efficient.
 
Progressive Testing: This type of testing works effectively when there are changes done in the software/application specifications as well as new test cases are designed.
 
Selective Testing: In this to cut down the retesting cost and effort, testers use a subset of the current test cases. A test unit must be rerun when there are changes in the program entities it covers.
 
Retest-All Testing: In this, we reuse all test cases even where the changes have not been made. It shouldn’t be done where there is a small change in the application as it is very time-consuming.
 
Complete Testing: Complete testing is effective when multiple changes have been done in the existing code. It is done to identify unexpected bugs and the final system can be made available to the user once complete testing is done.

How to Derive a Regression Testing Plan

Whenever there is a change in the app or a new version is released the developer carries out these tests as a part of the regression testing process.
 
First, the developer executes unit-level regression tests to validate the code that they have modified along with any new test that is created to cover any new functionality. Then the changed code is merged and integrated to create a new build of AUT. After that smoke tests are performed to assure that the build that we have created in the previous step is good before any additional testing is performed.
 
Regression-Testing-Plan

These tests can be executed automatically by continuous integration services such as Jenkins. Once we get the assurance that the build is perfect then we do the sanity testing to confirm that the functionality works as expected and known defects are resolved before conducting integration testing.
 
Integration testing is performed to verify that the units of the apps interact with each other and with backend services such as databases. The next step is to schedule regression tests depending on the size and the scope of the code either a partial or a full regression test may take place.
 
Regression-Testing-Execution
Defects are reported back to the development team and many require additional runs of regression testing to confirm the resolution. So based on the test reports you can analyze and figure out what test cases can be added for the next checking process as well and you create your report on that.

Regression Testing Challenges

Automation is always a smart move but there will be some challenges that would need your attention. Let’s have a look at the challenges that you might face in automation testing.
 
Cost is High
In terms of business expenses, the company will have to invest a lot of time and money in repetitive testing. Also, there’s no specific return on investment that is attached to regression testing. It is a complicated process and to explain the importance of regression testing in terms of business benefits to the management is really difficult. But this has to be done to draw the budget for the testing even though it is expensive from a management point of view.
 
Unstructured Information
If new testers are recruited during the ongoing software testing project, either to speed up the process or to release some of the tasks. The existing testers in the organization might not have time to give complete details about the functionalities and features of the app, existing bugs, delivery time, etc. The new testers might have to initiate testing with inadequate data about the ongoing testing project. Challenges like these need an appropriate test strategy for efficient collaboration.
 
Time Restrictions
The focus of enterprises is on developing quality apps and delivering them faster. This is why regression testing is always time-bound. Testers always get a deadline to complete the process of regression testing. To keep pace with time, The testers might have to take chances to give more importance to the critical regression tests and skip a few tests. It is a serious challenge as it is critical to decide which tests can be skipped.
 
Maintenance and Optimization
A major challenge is to maintain and optimize the existing regression test suites. The existing regression test suites might need modification like adding, removing or editing the existing test cases, whenever there are new changes. All this need to be done before the deadline fixed for the regression testing. Therefore, optimization and maintenance is another challenge that needs attention.

Best Practices to Perform Regression Testing

Now that we are aware of the challenges in regression testing. Let’s have a look at the key changes we can do to enhance it.
 
Focus on the Frequently Used Paths
Frequently used paths also make the most frequent use cases for your app. They must include the most popular features and the basic functionality of your app. You should be aware of the core group of users and their usual interaction with the app features. The regression test cases must ensure that this core functionality is working as expected.
 
Update the Regression Pack Regularly
A regression pack is a collection of test cases that are performed when a new app version is released or if there are any new updates. The tests in a regression pack are created keeping in mind the app’s older version requirement specifications. Ad-hoc tests should be included in the regression pack to keep it up to date. You wouldn’t want to waste your time on tests to validate an old feature that is not included in the latest version of the app.
 
Create an Entry/Exit Criteria
The entry/exit criteria that we usually follow in the software development lifecycle can be implemented in regression testing as well.
As entry criteria, a fixed set of conditions need to be met like reviewing bugs and performing regression testing to fix those bugs. Exit criteria can be applied with a fixed set of conditions like making sure that all the tests are executed and no bugs remain unfixed.
 
Automate Regression Tests
Automating regression tests makes the process much more efficient and saves time and effort. Repetitive testing can make testers lethargic and testers might lose motivation. It also affects the quality of their work as the testing is repetitive. Automated regression testing will free up resources to work on the more complicated tests. When we use automation, the test cases along with the software can also be reused which increases the return on investment.

In a Nutshell

Change is hardest at the beginning, messiest in the middle and best at the end. This quote by Robin Sharma suits the importance of regression testing in delivering a smooth functioning app. As mentioned earlier in this blog, different types of regression testing can be performed at all stages of the testing life cycle. And there are ways to overcome the challenges in regression testing too.
 
One option is to use a cloud-based app testing platform which will enhance the effectiveness of regression testing by many folds. There will be hundreds of devices to perform testing in parallel and features which complement regression testing automation.

5 Benefits of Parallel Testing

June 11th, 2019 by

These days software firms are putting in a lot of effort to attain quality at speed. Whether it’s continuous testing, agile or bringing AI into automation, it is required to refine the software development process to keep up with the rapid technological changes. The best way to do that is to adopt practices like parallel testing which will save time and effort. So let’s get into the details of parallel testing and understand the benefits and challenges faced to implement it into the software development life cycle.
 

What is Parallel testing?

 

  • Parallel testing is defined as a type of software testing where multiple apps or features are tested simultaneously which reduces time consumption.
  • Mostly it is done when a new version is released for an app. There is a need to check the compatibility of the latest version of different device, browsers and OS combination.
  • For example, if there is a new version of the OS being launched, then there is a need for testing the app to check if all the features are working fine with the new OS version.
  • So parallel testing can be used when the app is to be tested on the different version of the operating system or when there is a new version of the app to be launched.

To perform parallel testing you can simply create slave projects for the different functionalities of the app and a master project that will run these projects.
 

Why and When to Perform Parallel Testing

 
Parallel testing is done to make sure if the new version of the app works fine or to check the consistency between the old and the new version. It can also be done to check the integrity of the new app and the data format between the versions. When a company is moving from the old system to new system and synchronization is performed, it becomes necessary to check the legacy data is imported from one system to another and all the outcomes are defined more accurately especially in the financial domain.
Parallel Testing

Benefits of Parallel testing

 
Parallel testing has become a need for the QA teams as the benefits cannot be neglected. Let’s have a look at some of the benefits of performing parallel testing.

  • Better Development Flow: Better reporting and quick feedback with parallel testing enable testers to share the results with the development team. This practice also boosts the Continuous Integration efforts which lead to the timely delivery of the product. Parallel testing also helps build better communication between the QA team and the developers as the testing and reporting are done in a timely manner.      
  • Less Effort: Needless to say manual testing is very important but doing regression testing again and again on different devices combinations will be time-consuming. Performing parallel testing will reduce the amount of work that you have to put in as you will have to work on one script only. That script will be replicated on multiple devices.
  • Time-Saving: Parallel testing saves your time by a lot and that time can be invested in exploratory testing. Even if you are testing your app on two devices, your testing speed increases by two times. Human error can give you incorrect data so it’s better to use parallel testing for such repetitive testing which can also be boring.
  • Better Test Coverage: The test coverage increases when you test your app on various device browser-OS combinations. The more devices you test your app on the better. This will ensure that the end user gets the best experience irrespective of the device used. In this way, parallel testing ensures better user experience which means better ROI.
  • Less script: You can just write the script once and rerun the test on multiple devices. The older and newer version of your app can be installed on different devices to check compatibility and consistency. The goal is to make sure that the newer version of the app works fine on the latest and the legacy devices similar to the older version with some updates.

 

Challenges of Parallel testing

 
Parallel testing has its own sets of challenges and It is always better to get familiar with the issues before making a decision. Although there are solutions to these challenges which are also mentioned below.
 
Infrastructure Limitations: The cost to set up the test environment can take a toll on the company’s finance as the infrastructure and maintenance will cost a lot. Mobile and networking devices will add to the cost. Also, the company will have to hire highly skilled professionals just to maintain the setup. Instead of this companies can opt for cloud-based services like pCloudy where they will get all the desired devices to test on which can be accessed from anywhere anytime.
 
Data Dependencies:  It might be difficult to make a strategy for parallel testing if the test cases are dependent on some specific data. So if we take a case of sign up page. There can be test scripts running for a user login but if not done in a sequential manner then any other script might run first which would delete the user credentials form the database. Another script might also run which will require a user to enter the data. In this case, it will be difficult to integrate the scripts into parallel testing due to data dependencies. This is why it is required to write the test scripts which are truly data independent. Therefore the test scripts should have the configured data which is required for the test run and then the scripts can be modified to run in parallel.
 

Conclusion

 
To sum up, parallel testing reduces the effort and time spent on testing the app by multiples. It also increases your test coverage and helps provide a better user experience. The best way to do parallel testing is by using the cloud platform as you will not have to invest in the infrastructure and you will be able to access the devices from anywhere anytime. So if your testing team is distributed across the globe, this will be your best option and all that extra money saved in the maintenance can be put to good use for some other feature development process.

 
Related Articles:

  • A Brief Overview Of Regression Testing
  • 5 Reasons Why pCloudy is The Simplest App Testing Platform
  • pCloudy Mobile App Testing Platform – On Boarding Guide
  • Automation Execution on Multiple Devices in Parallel
  • Testing Mobile Apps on Different Networks