Software Testing Frameworks used at InApp

Software testing at InApp is tailored to meet client-specific needs, manage critical testing processes and ensure consistent high quality through repeatable processes. The software testing methods employed here are as follows:

  • Unified Selenium API Automation Framework
  • Robot Framework
  • QTP Modular Framework
  • In-house automation Frameworks

Unified Selenium API Automation Framework

In Unified Selenium API Automation Framework all objects that will be used to perform actions will be identified and grouped under different nodes, in an XML file. Updating the locator in the XML file will reflect changes in all the areas the locator is referred to. The advantage of this framework is the ease of maintenance.


  • API is modeled after human language – If it looks like a button, we call it a button, regardless of implementation
  • Test code does not use locators verbatim – Locators are aliased through the .xml file
  • usAPI exposes locators by UI element type – E.g., button, link, tab, tree node, etc.
  • usAPI transparently handles timing issues, logging, setup/tearDown

All tests will be derived from org.usapi.BaseSeleniumTest. This will expose (among others) an object named ‘app’, which is of the type BaseApplication. All interactions with the GUI utilize this ‘app’ object, at no time should there be any need to invoke selenium methods directly.

BaseSeleniumTest configures, starts, and stops the selenium client transparently to the test developer. BaseSeleniumTest provides generic methods for use in tests, such as assertTrue, assertFalse, isElementPresent, etc. Note that these methods are application-agnostic. Methods required for a particular application (e.g. to execute SQL queries) do not belong in this class.

Robot Framework

Robot Framework is a generic test automation framework for acceptance testing and acceptance test-driven development (ATDD). Robot Framework has a modular architecture that can be extended with bundled and self-made test libraries.


Test data is defined in files, a file containing test cases creates a test suite, and placing these files into directories creates a nested structure of test suites.

When test execution is started, the framework first parses the test data. It then utilizes keywords provided by the test libraries to interact with the system under test. Libraries can communicate with the system either directly or using other test tools as drivers.

Test execution is started from the command line or continuous integration tools like Jenkins, Hudson, and the like. As a result, you get the report and log in HTML format as well as an XML output. These provide an extensive look into what your system does.

QTP Modular Framework

QTP Modular Framework (also known as Functional Decomposition Framework) is the approach where you first identify the reusable code from your test cases. Then you write this reusable code inside different functions and call these functions wherever required. The advantage of this approach is that the reusable code would always stay in one place and thus it would be easy to maintain the code because you would have to make the changes in a single place only. To reuse this piece of code, all you have to do is call the function wherever required. The only challenging part here is to identify the reusable portions in your test case flow. Once that is done, you have to just create functions and use them wherever required.

In addition to these popular frameworks, we customize and use frameworks based on client needs such as combining Unified Selenium API Automation Framework with hash maps to use as temporary buffer space and auto email program.

Have questions? Contact the software testing experts at InApp to learn more.