In software testing, test automation is the use of specialized software (apart from the software being tested) to control the implementation of the test and the comparison of actual results with predicted results. Test automation can automate some repetitive tasks but need to be in an existing formal testing process, or perform additional testing that will be difficult to do manually. Test automation is essential for ongoing delivery and ongoing testing.
Video Test automation
Ikhtisar
Some software testing tasks, such as extensive low-level interface regression testing, can be exhausting and time-consuming to do manually. In addition, the manual approach may not always be effective in finding a particular defective class. Test automation offers the possibility to perform this type of testing effectively. Once the automated tests are developed, they can be run quickly and repeatedly. Many times, this can be a cost-effective method for regression testing of software products that have a long maintenance period. Even small patches during the lifetime of the app can cause broken features that work at previous time points.
There are many approaches to test automation, but below is a widely used general approach:
- Test graphical user interface . Testing framework that generates user interface events such as keystrokes and mouse clicks, and observes changes that generate user interfaces, to validate that the observable behavior of the program is correct.
- API-driven test . A testing framework that uses the programming interface to the application to validate the behavior being tested. Usually API-driven testing passes through the application's user interface altogether. It can also test public (usually) interfaces to classes, modules or libraries tested with various input arguments to validate that the returned results are correct.
Test automation tools can be expensive, and are usually used in combination with manual testing. Test automation can be cost-effective in the long run, especially when used repeatedly in regression testing. A good candidate for test automation is a test case for the general flow of the application, as it is required to be implemented (regression testing) each time an increase is made in the application. Test automation reduces the effort associated with manual testing. Manual efforts are required to develop and maintain automated checks, as well as review test results.
In automated testing a test engineer or software quality assurance person must have software coding capabilities, since the test cases are written in source code form which, when executed, produces output according to the statements that are part of it. Some test automation tools allow testing testing to be done by keywords rather than coding, which does not require programming.
One way to generate test cases automatically is model-based testing through the use of a system model for test case creation, but research continues into alternative methodologies for doing so. In some cases, the model-based approach allows non-technical users to create automated business test cases in plain English so there is no programming required to configure them for various operating systems, browsers, and smart devices.
What to automate, when to automate, or even whether someone really needs automation is an important decision that the testing team (or development) must make. A review of the multi-voice literature of 52 practitioners and 26 academic sources found that the five main factors to consider in the test automation decisions were: 1) Test Based Systems (SUT) 2) type and number of tests, 3) test equipment 4) human and organizational topics, and 5) cross-cutting factors. The individual factors most frequently identified in this study were: the need for regression testing, economic factors, and maturity of SUT.
Maps Test automation
Unit test
A growing trend in software development is the use of unit testing frameworks such as the xUnit framework (eg, JUnit and NUnit) that allow the implementation of unit tests to determine if different parts of the code act as expected under different circumstances. The test case describes the tests that need to be run on the program to verify that the program is running as expected.
Test automation mostly using unit testing is a key feature of extreme programming and agile software development, where it is known as a test-based development (TDD) or development-first test. Unit tests can be written to define functionality before code is written. However, unit tests evolved and extended during coding, problems were found and the code underwent refactoring. Only when all the tests for all the features that are required to pass are codes considered complete. Proponents argue that it produces software that is more reliable and less expensive than the code tested by manual exploration. This is considered to be more reliable because of better code coverage, and therefore run constantly during development than once at the end of the waterfall development cycle. Developers discover defects as soon as they make changes, when they are least expensive to fix. Finally, code refactoring is safer when unit testing is used; converting the code into simpler forms with fewer code duplications, but equivalent behavior, is much less likely to introduce new defects when the refactored code is covered by unit tests.
testing Graphical User Interface (GUI)
Many test automation tools provide recording and playback features that allow users to interactively record user actions and replay multiple times, comparing actual results with expected ones. The advantage of this approach is that it requires little or no software development. This approach can be applied to any app that has a graphical user interface. However, reliance on these features creates major reliability and maintenance issues. Associating a button or moving it to another part of the window may require that the test be re-recorded. Record and playback also often add irrelevant activity or misidentify some activities.
Variations on this type of tool to test websites. Here, the "interface" is a web page. However, the framework uses a completely different technique because it is HTML rendering and listening to DOM Events rather than operating system events. Headless browsers or solutions based on Selenium Web Driver are usually used for this purpose.
Another variation of this type of test automation tool is to test mobile apps. This is very useful considering the number of sizes, resolutions, and different operating systems used on the phone. For these variations, the framework is used to give examples of actions on mobile devices and to collect results from actions.
Another variation is non-script test automation that does not use record and playback, but instead builds an application model and then allows the testers to create test cases by simply entering the parameters and test conditions, which do not require scripting skills.
API-driven test
API testing is also widely used by software testers because of the difficulty of creating and maintaining GUI-based automation testing. This involves direct testing of APIs as part of integration testing, to determine whether they meet expectations for functionality, reliability, performance, and security. Because the API does not have a GUI, API testing is done in the message layer. Testing APIs is considered essential when an API serves as the main interface for application logic because GUI tests can be difficult to maintain with short release cycles and frequent changes commonly used with agile software development and DevOps.
Ongoing test
Ongoing testing is the process of performing automated testing as part of a software delivery channel to obtain immediate feedback on business risks associated with software release candidates. For Sustainable Testing, the scope of testing extends from validating bottom-up requirements or user stories to assess system requirements related to overall business objectives.
What to test
Testing tools can help automate tasks such as product installation, test data generation, GUI interaction, problem detection (consider parsing or polling agents equipped with test oracles), defect logging, etc., without the need to automate end-to-end testing.
One should still meet the popular requirements when thinking of test automation:
- Platform and OS independence
- Data-controlled capabilities (Input Data, Output Data, Metadata)
- Customization Report (DB Database Access, Crystal Reports
- Easy debugging and recording
- Friendly version control - minimal binary files
- Expandable & amp; Customization (Open APIs to integrate with other tools)
- Common Drivers (For example, in the Java development ecosystem, it means Ant or Maven and the popular IDE). This allows testing to integrate with the developer workflow.
- Supports unattended testing for integration with batch build and process. The ongoing integration server requires this.
- Email Notifications like bounce messages
- Supports distributed execution environment (distributed test bed)
- Distributed app support (SUT distributed)
Framework Approach in Automation
The test automation framework is an integrated system that defines the rules of a particular product automation. This system integrates function libraries, test data sources, object details and reusable modules. These components act as small building blocks that need to be assembled to represent a business process. This framework provides basic test automation and simplifies automation efforts.
The main advantage of the framework of assumptions, concepts and tools that provide support for automated software testing is low cost for maintenance. If there is a change in every test case then only the test case files need to be updated and the Driver Scripts and startup scripts will remain the same. Ideally, there is no need to update the script in case of changes to the application.
Choosing the right framework/scripting techniques helps in keeping costs lower. The costs associated with testing scripts are due to development and maintenance efforts. The scripting approach used during test automation has an effect on cost.
Various scripting/scripting techniques are commonly used:
- Linear (procedural code, probably generated by tools such as those using recording and playback)
- Structured (using the control structure - usually 'if-else', 'switch', 'for', 'while' conditions/condition/statements)
- Data-driven (data maintained outside testing in database, spreadsheet, or other mechanism)
- Driven keywords
- Hybrid (two or more of the above patterns are used)
- Agile automation framework
The Testing Framework is responsible for:
- specifies the format to express expectations
- creates a mechanism for connecting or pushing an application being tested
- executes the test
- report results
Automation test interface
The automation test interface is a platform that provides a single workspace to combine multiple testing tools and frameworks for testing System/Integration of applications under test. The purpose of the Test Automation Interface is to simplify the process of mapping the tests to business criteria without coding obstructing the process. Automated test interfaces are expected to improve the efficiency and flexibility of maintaining test scripts.
Test Automation Interface consists of the following core modules:
- Machine Interface
- Interface Environment
- Object Repository
Machine interface
The machine interface is built on the Environmental Interface. The engine interface consists of a parser and a test runner. The parser is present to decompile the object files that originate from the object repository into a dedicated test scripting language. The test runner executes the test script using test harness.
Object repository
Object repositories are a collection of UI/App data objects that are recorded by the testing tools while browsing the applications being tested.
Define the boundary between the automation framework and the testing tool
Tools are designed specifically for targeting certain test environments, such as Windows and web automation tools, etc. The tool serves as the driving agent for the automation process. However, the automation framework is not a tool for performing certain tasks, but rather an infrastructure that provides solutions where different tools can do their work in an integrated manner. It provides a common platform for automation engineers.
There are different types of frameworks. They are categorized based on the automation components they use. This is:
- Data-based testing
- Testing driven by modularity
- Keyword-based testing
- Hybrid test
- Model-based test
- Code driven test
- Behavior-driven development
See also
- Fuzzing
- List of GUI testing tools
- List of web testing tools
- Software testing
- System test
- Unit test
- Ongoing test
- Headless Browser
References
- Notes
External links
- Practical Experience in Automated Testing
- Test Automation: Giving Business Value
- Test Automation Snake Oil by James Bach
- When should the tests be automated? by Brian Marick
- Guide for the Automation Test template
- Advanced Test Automation
- Success Factors for Keyword Testing Driven by Hans Buwalda
- Learning Automation: Making Your Computer Work for You by Jeremy Carey-Dressler
- Testing Resources Automation & amp; Best Practices by Joe Colantonio
Source of the article : Wikipedia
0 Comments