Top 10 Features of today’s Automation Testing

1
62
Spread the love
  • 1
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
  •  
    1
    Share

Naming convention:
Local- Use camel casing-small letter “l” in the at the first letter of the variable.Like lFirstName. It denotes that it is a local variable.
Global-Same, if the scope is defined by global just use a small “g” at the beginning of the variable.Like-gCustomerNumber it denotes that the variable is global and accessed from anywhere.
CONST- Use all capital words for variable that are constant in nature.Like-CONST CDATE.
Functions should start with FN_ followed by function name like- FN_getDate()
Similarly for Action is QTP should be names as AN_Action name like-AN_CreateCustomer
Append a small r before function and action if they are reusable in nature.
like-
rFN_getDate() or rAN_CreateCustomer

The script name can be varied from framework to framework. Best practice is to give a module name before the script name. Like-CO_CreateCustomer(Co stands for Customer operation). It must be capital letters.

Function Library should start with FN followed by function library name and ends with a lib.like-FN_CreateOrder_lib

For a small project we may go with .mtr but when project goes big it is better to use .tsr object repository.ORs should start with the Module name like-CO_Customer.tsr

All of these infrastructure,standards will come with a cost.Management should have enough budget for such activities.Management actions often result in the death of an automation effort. Many a time automation maintenance cost and effort is ignored,thinking automation fresh development is easy. In actual it is neither easy nor cheap. You need experts to solve issues. It is just not record play back.

a structured approach is always needed to work properly in a team together. It is important to structure the test assets(name,testdata file,scripts,testcases,config file etc). Another best option to work with multiple environments is to use relative folder options.
Second approach is to share the function lists created by different automators. functions should be as generic as possible.
The best way to achieve this is to use

  1. One global function library
  2. Use business specific library

Store all the structure in the version control system.Extra folders could be-

  1. Documentation-Related to framework
  2. General-Function to initialize the framework
  3. Language-Functions specific to any language

Advanced features/Recovery Scenario:

Any technical change should be caught by framework itself and handle properly.In this way also try to capture the delayed fuse bugs like -memory leak wild pointers etc.While advancing forward , framework should have ability to handle the unexpected exceptions. Every tool has its own way of handling exceptions.Use that to configure recovery scenario.Please handle known issues with code itself. As the more intelligence you will put into a framework..it will slowdown the process. It is kind of attaching recovery Scenario to the test.

Ease of debugging, logging and feedback system:

An automation should give a easy debugging feature so that the code executed by any test engineers or a customer can debug the code easily. One of the best method could be linear code generation.

Always listen or give proper value to the feedback of the users.They may pin point lot of relevant process and practice issues.Even they may advice standards.This is very important for long term success.

Look for better ROI:

A better ROI can only obtained only if the test is executed without monitoring.Test engineers only responsible for creation of correct scripts. Execution can only happen when it is not monitored.

Easy Refactoring and update:

The maintenance process of a framework should be defined previously. The process to update a script /asset/code has to have a prior approval process and version control mechanism.Refactoring is an essential part of automation testing in order to restructure of test code or test data for ..

  • Increase internal efficiency
  • Stability
  • Support upgraded technology
  • Support change in functionality
  • Increase maintainability.

When the script is old and running for say 3/4 years .It is extremely difficult without a proper comment or explanations.At this time we try to understand from code itself what it is doing. Remember the more number of lines of code is costly during maintenance .

In agile, we often automate some flows which are unstable. Actually, there is no value add while automating unstable functionalities as maintenance overhead  is huge.

 

This is the basic building block for an automation framework. Please visit Part-2 for more advanced feature.A better communication between testers and automation engineers is necessary to ensure framework design meets testing objective. Any test framework design effort is very serious factors for project development. A good planing ,scheduling and budgeting is required. It is important to get feedback from testing team. This may lead to greater learning and idea generation. there may be many cycles before perfection.Accept the short fall and work towards it.If the project is complex ,big and we are at a tight schedule.We need to scale back .Communication is the key here.
While designing , we need to make sure-

  1. Find relevant information,code,examples from internet. It is available in different form.
  2. The automation many be developed by a group and maintained by another group. Transparency is the key.
  3. While designing the framework, we need to take care business issues,people and process issues and technical issues.