How to test a mobile application? Different ways to test a mobile application. A Mobile app can be tested in different strategies depending on the necessity. You will learn here what are the different test will be used for a mobile app.
Mobile Application testing
Usability testing: to make sure that the mobile app is easy to use and provides a satisfactory user experience to the customer.
Compatibility testing: Testing of the application in different mobiles devices, browsers, screen sizes and OS versions according to the requirements.
Interface testing: Testing of menu options, buttons, bookmarks, history, settings, and navigation flow of the application.
Service testing: testing the service of the application online and offline.
Low level resource testing: Testing of memory usage, auto deletion of temporary files, local databases growing issues known as low level resource testing.
Performance testing: testing the performance of the application by changing the connection from 2G, 3G to Wi-fi, Sharing the documents, battery consumption.
Installation tests: Validation of the application by installing/uninstalling it on the devices.
Security Testing: Testing an application to validate if the information system protects data or not.
- Usability testing is nothing but the user friendliness check.
- In usability testing, the application flow is tested so that a new user can understand the application easily.
- Basically, system navigation is checked in usability testing.
Goal of usability testing:
- Web page content should be correct without any spelling or grammatical error.
- All fonts should be same as per the requirements.
- All the text should be properly aligned.
- All the error messages should be correct without any spelling or grammatical errors and the error message should match with the field label.
- Tool tip text should be there for every field.
- All the fields should be properly aligned.
- Enough space should be provided between field labels, columns, rows, and error messages.
- All the buttons should be in a standard format and size.
- Home link should be greyed out.
- Check for broken links and images.
- Conformation messages should be displayed for any kind of update and delete operation.
- Check the site on different resolutions (640*480; 600*800 etc.?)
- Check the end user can run the system without frustration.
- Check the tab should work properly!
- Scroll bar should appear only if required.
- If there is an error message on submit. The information filled by the user should be there.
- Title should display on each web pages.
- All fields (Textbox, dropdown, radio button etc) and buttons should be accessible by keyboard shortcuts and the user should be able to perform all operations by using keyboard.
- Check if the dropdown data is not truncated due to the filed size and check whether the data is hardcoded or managed via administrator.
- Testing the feature and operational behaviour of a product to ensure they correspond to its specifications.
- Testing that ignores the internal mechanism of a system or component and focuses only on the outputs generated in response to selected inputs and execution conditions.
- Goal of function testing
- The goal of function testing is to verify whether your product meets the intended functional specifications mentioned in your development documentation.
Functional test scenarios:
- Test all the mandatory fields should be validated.
- Test the asterisk sign should display for all the mandatory fields.
- Test the system should not display the error message for optional fields.
- Test that leap years are validated correctly & do not cause errors/miscalculations.
- Test the numeric fields should not accept the alphabets and proper error message should display.
- Test for negative numbers if allowed for numeric fields.
- Test division by zero should be handled properly for calculations.
- Test the max length of every field to ensure the data is not truncated.
- Test the pop-up message (This field is limited to 500 characters) should display, If the data reaches the maximum size of the field.
- Test that a conformation message should display for update and delete operations.
- Test the amount values should display in current format.
- Test all inputs fields for specific characters.
- Test the timeout functionality.
- Test the sorting functionality.
- Test the functionality of buttons available.
- Test if any functionality fails the user gets redirected to the custom error page.
- Test all the uploaded documents are opened properly.
- Test the user should be able to download the uploaded files.
- Test the email functionality of the system.
- Test the java script is properly working in different browsers (IS, Firefox, Chrome, Safari, and opera)
- Test to see what happens if a user deletes cookies white in the site.
- Test all the data inside combo/list box is arranged in chronological order.
Compatibility testing is used to determine if your software is compatible with other elements of a system with which it should operate, eg Browsers, Operating systems or hardware
Goal of Compatibility Testing
The purpose of compatibility testing is to evaluate how well software performs in a particular browser, operating systems, hardware, or software.
Compatibility test scenarios:
- Test the website in different browsers (IE, Firefox, Chrome, Safari and Opera) and ensure the website is displaying properly.
- Test the HTML version being used incompatible with appropriate browser versions.
- Test the fonts are usable in different browsers.
- Test the java Script code is usable in different browsers.
- Test the animated GIF’s across different browsers.
In database testing backend records are tested which have been inserted through the web or desktop applications. The data which is displaying in the web application should match the data stored in the data base.
- The tester should understand the functional requirements, business logic, application flow and database design thoroughly.
- The tester should figure out the tables, triggers, store procedures, views and cursors used for the application.
- The tester should understand the logic of the triggers, store procedures, views and cursors created.
- The tester should figure out the tables which get affected when insert update and delete (DML) operations are performed through the web or desktop application.
Goal of database testing
- Verify the database name: The database name should match with the specifications.
- Verify the tables, columns, column types and defaults: All things should match with the specifications.
- Verify whether the columns allow a null or not.
- Verify the primary and foreign key of each table.
- Verify the stored procedure.
- Test whether the stored procedure is installed or not.
- Test the stored procedure by deleting some parameters.
- Test when the output is zero, the zero records should be affected.
- Test the stored procedure by writing simple SQL queries.
- Test whether the stored procedure returns the values.
- Test the stored procedure with sample input data.
- Verify the behaviour of each flag in the table.
- Verify the data gets properly saved into the database after each page submission.
- Verify the data if the DML (Update, Delete and insert) operations are performed.
- Check the length of every field: the filed length in the back end and front end must be same
- Verify the database names of QA, UAT and production. The names should be unique.
- Verify the encrypted data in the database.
- Verify the database size. Also test the response time of each query executed.
- Verify the data displayed on the front end and make sure it is same in the back end.
- Verify the data displayed on the front end and make sure it is same in the back end.
- Verify the triggers.
Security testing involves the test to identify any flaws and gaps from the security point of view
Goal of security testing
- Verify the web page which contains important data like password, credit card numbers, secret answers for security question etc should be submitted via HTTPS(SSL)
- Verify the important information like password, credit card numbers etc should display in encrypted format.
- Verify password rules are implemented on all authentication pages like Registration, forgot password, Change password.
- Verify password rules are implemented on all authentication pages like registration, forgot password, change password.
- Verify if the password is changed the user should not be able to login with the old password.
- Verify the error messages should not display any important information.
- Verify if the user is logged out from the system or user session was expired, the user should not be able to navigate the site.
- Verify to access the secured and non-secured webpages directly without login.
- Verify the view Source code option is disabled and should not be visible to the user.
- Verify the user account gets locked out if the user is entering the wrong password several times.
- Verify the cookies should not store password.
- Verify if, any functionality is not working, the system should not display any application, server, or database information. Instead, it should display the custom error page.
- Verify the SQL injection attacks.
- Verify the User roles and their rights. For example, the requestor should not be able to access the admin page.
- Verify the important operations are written in log files, and that information should be traceable.
- Verify the session values are in an encrypted format in the address bar.
- Verify the cookie information is stored in encrypted format.
- Verify the application for brute Force Attacks!
- To determine the performance, Stability, and scalability of an application under different load conditions
- To determine if the current architecture can support the application at peak user levels.
- To determine which configuration sizing provides the best performance level.
- To identify application and infrastructure bottlenecks
- To determine if new version of the software adversely had an impact on response time.
- To evaluate product and/or hardware to determine if it can handle projected load volumes.