Parameters are extemely useful for engineers to deploy in their testing practice. MaxTAF’s parameter system is highly integrated into its diverse range of tools and structures, amplifying their utility much moreso than a home-made automation framework could.
In a nutshell, parameters are used in test automation to provide flexibility to a test framework and it’s scripts. Instead of hardcoding values within the script, implementing a parameter in place of a value allows an engineer or tester to feed data to the script from a more manageable source. This opens up opportunities for more effective automation, as well as new techniques such as data driven testing.
Parameters are extremely useful for controlling data input into an automated test script without having to change any code - this reduces the chance of introducing any errors into the script, which can be a real bottleneck.
Here’s how MaxTAF’s parameter system system works (and why it’s so good):
Maximum flexibility/configurability to test data, even at the point of test execution.
Parameters allow you to control the data that gets fed into the test script. While it is perfectly reasonable to declare all data within the script it is more effective to parameterise this data to save time when changes need to be made.
For a very basic example, take an ecommerce site. You may wish to check that the prices are correct for various items. Instead of creating a new test script per item, it is possible to parameterize the url, and then change that url per item that we wish to check the prices of. This sort of example shows how parameters can save a large amount of time in a fully fleshed out automation regime.
Simple test configuration controls
In addition to values, MaxTAF’s parameters provide an effective way to control the configuration of your test execution. There are many examples of this, but a good one would be that you can change the destination environment of your test without having to enter the script.
This can be achieved on the multiple levels mentioned in the next point. So for example, if you wish to run a suite of tests against a dev environment, and then quickly shift over to a QAT environment, this can all be managed effectively through the simple change of a parameter on the suite level.
MaxTAF employs a hierarchical system of parameters to both allow granular and broad control of data and configuration across it’s multiple ‘layers’.
To briefly explain this concept of layers, MaxTAF provides a lot of utility for test case and project organisation, and also provides a lot of control at every level of organisation available. Parameters can be applied to an entire project, a suite (batch) of tests, an individual test case, per user, per schedule or even on a single test run. This allows data to be controlled at both extremely high and extremely fine levels.
Engaging parameters on all of these multiple layers provide a simple and effective way to control data no matter how you want to implement your test.
Getting team members without coding skill involved
MaxTAF allows restrictions for certain users to be unable to make code changes to your project. This may be done to prevent accidental script breakage in untrained hands.
However, while team members can be restricted from code changes, they can be permitted to make parameter changes. This opens up the opportunity for non-engineers to manage day-to-day execution of test scripts while posing no risk to actual code itself.
This can help streamline business processes surrounding test automation, enabling teams to more effectively make usage of their time. Engineers can get on with coding, while testers can get on with testing.
Teamwork makes the dream work after all.
With parameters, maximum control of your tests and data are in your hands.