You can use MarathonITE and reduce the effort required for creating resilient test suites. Use MarathonITE‘s recorder to create test scripts and replay them either through the UI or batch. Use the included extract method refactoring to reuse your test scripts. Perform exploratory or semi-automatic testing through MarathonITE and share the test scripts with the development team.
Marathon consists of a recorder that allows you to easily create test scripts. Marathon records semantic actions on components rather than the raw actions like mouse clicks or keystrokes. Optionally, you can choose to record raw mouse/keyboard actions by switching the recording into raw mode. During recording Marathon allows you to insert assertions, checklists, module methods. You can also pause recording or use the script console to access the application.
There is no need to learn a specific language to develop MarathonITE scripts. MarathonITE scripts are just JRuby/Jython scripts. JRuby/Jython are implementation of popular Ruby/Python scripting languages on to the Java virtual machine. Both the implementations provide easy access to Java classes. You can invoke Java from JRuby/Jython using their native syntax.
MarathonITE provides multiple mechanisms of object recognition. MarathonITE object naming and recognition is handled by Naming Strategy – a pluggable interface. MarathonITE ships with two naming strategies. The older one
MarathonNamingStrategy depends on the unique properties of each object to identify the component and name it. The strategy currently used by default is the
ObjectMapNamingStrategy delinks the naming of the object from it’s recognition and provides the maximum flexibility. You can refer to the same component even when the name is changed. This allows in creating names that are domain specific, rather than depending on application internals.
MarathonITE’s exploratory testing mode provides recording of test session in the background and also allows you to capture screenshots and annotate them for noting the findings. Once the test session is complete, MarathonITE creates a test report with your findings. You can also share the test script which can be replayed by the developer to reproduce the failures.
It is not possible to automate all tests in any given test project. There are always tests that require manual intervention and specifically subjective validation. Even in these cases, it is possible to automate some parts of the application execution and then accept tester input to complete the test case.
MarathonITE facilitates such Semi Automated tests through checklists. While recording a test case, at some point, you can insert a checklist. When this test case is executed and this point is reached, MarathonITE displays the checklist and waits for user validation before proceeding.
There are many ways in which a Java application can be distributed and most application developers make use of this. Java applications can be wrapped as native executables, executable JAR files, applets or as distributed online using Java webstart. MarathonITE provides
Application Launchers to cover all these cases.
Data-driven testing is the creation of test scripts to run together with their related data sets in a Marathon test script. The test script is reused for different sets of data input through a CSV file. Input and result (test criteria) data values can be stored in a CSV file. Test scripts can be easily converted to Data Driven Tests using MarathonITE by just refactoring the recorded script and selecting the fields to which data has to be fed from a CSV file. Using in-built support for converting test scripts to data driven tests, multiple scenarios can be tested with a single test script.
Decomposing a test script into methods allows for better readability of the script itself, as well as reusability. MarathonITE provides
Convert to Module Method refactoring which is handy for creating such reusable script-lets. Marathon’s recorder has special handling for these module methods. While recording you can insert a module method into the script. You can parameterise the module methods, there by enhancing the reusability of these methods.
An Object map or GUI object map provides a mapping from the name of a component (as known to Marathon) to its identification (in the AUT context). This will ease the maintenance of test scripts, as the AUT changes the object’s properties, you only need to modify the object map to make Marathon aware of the changes. Marathon stores the object map information in text files in YAML format.
MarathonITE includes an object map creator and editor to ease the maintenance of these files.
MarathonITE comes bundled with support for all standard Java/Swing components. If your application uses custom components, they might still be supported by MarathonITE as long as they implement the contract expected by their parent components. MarathonITE provides APIs so that additional component resolvers can be developed for those cases where it is needed.
MarathonITE provides you with flexibility to design your test projects as you seem fit. Be it the desktop organisation, project structure, component recognition or naming components in the test scripts – MarathonITE lets you do all of these in your own way. Use the power of Ruby or Python that MarathonITE keeps at your dispensation in the test scripts.