What are the different types of Test Automation Frameworks?

Test automation frame work has got its own importance in the field of software testing. It can be defined as a set that consists of concepts, tools and assumptions that can be used to support the automated software testing. The basic advantage of using a test automation frame work is that maintenance costs are reduced by large margins. If any changes to the test case are made then there is a need to update only the test case files. No updates are to be made to the following two scripts:

1. Startup script and
2. Driver script

In some ideal cases there is no need of even updating the scripts in case changes are made to the application software. In order to have all the advantages of using a test automation framework it is important that you select the right one otherwise you will face the problem the other way round. 

There are various frame work techniques that are used namely:

1. Key word driven

2. Data driven

3. Structured

4. Linear

5. Hybrid and so on.

Purpose of Test Automation Framework

1. Defining of format for expressing the expectations
2. Creation of a mechanism for driving the application under a particular test.
3. Execution of the tests
4. Reporting of the results.

A test automation frame work consists of the following four components namely:

1. Test automation interface
2. Interface engine
3. Interface environment
4. Object repository

Types of Test Automation Frameworks

1. Ad-hoc test automation framework: 

- The scripting involved in this is developed in reactionary mode with the purpose of testing a single issue only. 

- The test case steps form part of each action script and exhibit low re-usability and call for high maintenance. 

- This frame work consists of some data inputs that are stored in the data sheet of the test script.

2. Data driven test automation frame work: 

- In this framework the scripts are considered to be an assembly of the function calls. 

- Data for the tests is supplied from the external source such as ODBC database, spreadsheets and so on. 

- Results are captured externally for each script separately.

3. Keyword driven test automation frame work: 

- A sequence of the key word prompted actions are used to be express the test cases. 

- Action scripts which serve the purpose of calling functions are executed by the driver script. 

- For this frame work no special scripting knowledge is required.

4. Model driven test automation framework: 

- This test automation framework makes use of descriptive programming for testing the dynamic applications inclusive of the web applications and sites. 

- The parametric code defines the objects and the work flow capabilities are enhanced by the custom functions.

5. 3^rd party test automation frame work like HP’s quick test professional: 

- This test automation frame work is also key word driven but its control is taken by the HP quality center data base. 

- It can be used in projects where there is a requirement for collaborative work efforts. 

- This framework has high level test requirements and the tests are defined as scripted components.

6. Intelligent query driven test automation frameworks: 

- This framework is object oriented and works on the agile principles. 

- It was constructed as a series of framework layers which compiles data at the run time with the help of data mining techniques which can be combined based up on the cope of the requirements of the test.

What ingredients are necessary to achieve component composition?

Component based software development or CBSD is nowadays becoming a very common practice when it comes to re- using the already existing practice components that have already been validated. This practice has shortened the development cycle gradually and has enhanced the quality of the software products or artifacts. This approach of software development is focussed up on the development of new software systems and applications through the selection and assembling components that belonged to the pre- existing software components. 

Furthermore, CBSD development methodology helps to:

1. Accelerates the productivity of the software development
2. Reduces the overall development cost
3. Reduces maintenance efforts
4. Enhances flexibility
5. Enhances maintainability
6. Assembles system rapidly
7. Reduces the time to market

Usually no wear and tear occurs to the software system but there is a need to change or modify the software in accordance with the changes in business needs and complexity. Since the system keeps on acquiring more and more complexity, and hence more and more errors are introduced. 

This whole concept of component based software development is based up on components and the success of this development approach is highly affected by the composition of the software components that are being used.

What is a Component?

- A component as we know can be defined as a re- usable unit of deployment which has its access through a graphical user interface. 

- Component can be thought of as an independent entity that possesses its own complete functionality that can be distributed separately and shows no problem in upgrading from time to time. 

- Certain standards have been defined according to which the components are developed and are re- used. 

- Smaller pieces of software are aggregated at a high level and this aggregation is what that forms a component.  

Types of ingredients in Component Based Software Development

1. An ideal component consists of the implementation detail obtained from the environment that can be re used by the interfaces of those components. This is essential as re- usability of the components is very much important for the component based software development.
2. The second most important ingredient is the service or functionality that is to be provided by the component.
3. Quality aspects like predictability, component reliability, usability and so on.
4. The composition of the components requires meta information regarding the interfaces of the components and properties so as to support the tools during the process of the component composition. This meta information is obtained from the implementation/ interface repositories, type libraries or introspection or dedicated info classes etc.

Different Means of Component Composition

- Though the implementation inheritance works for most of the object oriented frame works, it does not prove useful for the component composition.

- The composition of the components takes place on a binary level. 

- There are 4 means of component composition:

1. Scripting or glue languages
2. Component frame works
3. System languages
4. Visual programming

All the above mentioned means have their own advantages and disadvantages but, they all are considered to be useful when used in combination. 

- Mostly scripting languages like tcl, visual basic etc are used for component composition rather than using system languages like java, Pascal, C++ etc. 

- The scripting languages are found convenient for this purpose because they are intended for plugging components together operating on a high abstraction level as compared to the system languages. 

- The component composition requires an equivalent object oriented frame work called component frame work and in this the glue code between the classes is predefined for a specific application domain. 

What is meant by test driven development (TDD)?

Test driven development or TDD is another process in the league of the software development processes. The topic of the test driven development is in the spot light of this article. The test driven development follows from the idea of the repetition of a very short development cycles. 

Concepts of Test Driven Development (TDD)

- First of all a failing automated test case is written or created by the developer or tester which serves the purpose of defining a new function or a desired improvement. 
- Then a code to pass the above created test is also created by the developer. 
- This newly written code is then refactored in order to make it meet the acceptable standards.
- Kent Beck is credited with the discovery of the test driven development process in the year of 2003. 
- The test driven development was looked up as an encouragement for the simple designs and also as an inspiration for boosting up confidence levels.
- The test driven development has always been related to the concepts of the extreme programming which took its root in the year of 1999. 
- But, eventually it came up as an individual process with its own ways and rights. 
- The concepts of the test driven development are also employed by the programmers and developers as a measure for debugging the legacy code and improving it further. 
- The test driven development is driven by a series of automated unit tests that are created by the developer for defining the requirements of the code and then automatically produce the code for them. 
- These unit tests are comprised of assertions i.e., either true values or false values. 
- Successful passing of a test confirms the developer of the correctness of the code and that it can be further evolved and re-factored. 
- To run these automated test cases, the developers make use of the testing frame works.

Steps involved in Test Driven Development (TDD)

Addition of a Test: 
The development begins with the creation of test cases for all the features. These test cases are often expected to fail since they have been created before the implementation of those features. If these test cases do not fail then either the test case is having some defect or the proposed new feature is already in existence. Before writing the test case, the developer is supposed to fully understand the specifications and requirements of the feature using the user stories and use cases etc. This is what that makes the test driven development different from other development methodologies.


Execution of all tests in order to check the working of the new one: 
This step involves the validation of the test harness for its correct working. At this step this is also ensured that the new test is not passing without the requirement of some new code. The test itself is also tested in negative and the possibility that the newly added test will always pass out is reduced. The new test is also expected to fail because of the reason figured out.


Production of code: 
This step involves the creation of some code implementing which the code can only pass the test and does not incorporates any new functionality.


Execution of the automated tests and observing their success.


Re-factoring of code: 
This step involves the cleaning up of the code.


Repetition: 
The whole cycle is repeated for the improvement of the functionalities.

Many development styles have been developed for the test driven development like:

1. YAGNI (you ain’t gonna need it)
2. KISS (keep it simple stupid) etc.

What is a testing framework? What are different unit testing frameworks?

What is a testing framework?

- Testing framework is considered to be an object oriented approach to testing since it helps in providing suitable environment and language for testing the software system or application. 

- A testing framework can be defined as a set of concepts, assumptions and tools that are the means for providing support for testing the software systems or application. 

- The testing frameworks are generally used in the automated testing and such testing frameworks are called the test automation frameworks. 

- The main advantage here for which the testing frame works are used is that they reduce the overall testing and development cost by a large amount. 

- If any change or modification is made to the test cases, then all the tester needs to do is to update the test case file since the start-up script and the driver script will remain the same.

- This reduces the hectic task of updating the scripts when the changes have to be made to the software system or application. 

- The testing framework if chosen properly can help in reducing the development costs by a big margin and the lower cost can be maintained throughout the development process. 

- These costs are basically due to the maintenance efforts, test scripting and development processes.

- Using any approach with testing frame work has a great impact on the costs. 

Types of Testing Frameworks

1. Linear testing framework: This is commonly used for the code that is procedure oriented and is generated by the tools using techniques such as recording and playback.
2. Structured testing framework: This testing frame work is composed of the control structures and hence got the name. It is constituted by control structures such as switch, while, for, if-else condition statement etc.
3. Data driven testing framework: This testing frame work involves persisting of the data outside a test in either a spreadsheet or a database.
4. Key word driven testing framework
5. Hybrid testing framework: This type of frame work is the resultant of the combination of two or more types of above mentioned testing frame works.

What does testing framework account for?

- A testing frame work is said to account for the following things:

1. Definition of the format so that the expectations can be expressed.
2. Creation of a mechanism for driving or hooking an application that is under test.
3. Execution of the tests.
4. Reporting of the results.

- The execution of the powerful and complex tests eats up a lot of time and it also requires quite large budget when only capture tool is used. 

- Since the tests are created ad hoc, it becomes very difficult to track these functionalities and reproduce them.

- A test automation framework serves as a better support option when it comes to the automated testing. 

- The testing frameworks and other tools are incorporated in to a test automation interface for carrying out the integration as well as system testing. 

- The test automation interface is employed for the mapping of the tests without putting them in to the way of the development process.

- Test automation frameworks are known for improving flexibility and efficiency of the test scripts. 

- There are 3 main core modules of any test automation interface:

1. Interface engine: The engine lies on the top of the environment and consists of a test runner and parser.

2. Interface environment: It consists of project library and frame work library.

3. Object repository: It consists of object application data recorded by the testing tool.