Robot Framework

Robot Framework is a generic open source automation framework for acceptance testing, acceptance test driven development (ATDD), and robotic process automation (RPA). It is based on Python or Java and allows us to test a wide range of distributed applications. It has easy-to-use tabular test data syntax and it utilizes the keyword-driven testing approach. Simnovus can create new higher-level keywords from existing ones using the same syntax that is used for creating test cases.

Robot Framework itself is open source software released under Apache License 2.0, and most of the libraries and tools in the ecosystem are also open source. The framework was initially developed at Nokia Networks and it is nowadays sponsored by Robot Framework Foundation.

Why use Robot Framework to test applications?
As previously mentioned, the framework is open source (meaning it brings all the advantages associated with that type of code). Robot Framework is also greatly valued because it is independent from the platform and application to be tested. Users do not need to use any sort of programming language to implement and run tests.

The Robot Framework tool itself provides a wide range of libraries (Android, database, etc.) to test all kinds of applications. An API library will also be provided in order to create proprietary test libraries that can be run in both Java and Python. A command line and output files that are readable in XML format are also provided. These can be used later on to build log and report files (in HTML format) containing a great deal of accurate information presented in a pretty simple and intuitive manner.

Robot’s Nuts and Bolts
Robot Framework’s intended objective is to automate acceptance testing, also called ATDD, or acceptance test-driven development. Tabular formatted data files contain the keywords and arguments for implementing test cases. The pivotal technology feature of Robot Framework is modularity. Libraries from many standard languages can be included and extended in this open source framework. SeleniumLibrary is actually required as a dependency of Robot Framework, and both require the Python interpreter.

Robot Framework, Python, and SeleniumLibrary plus its various dependencies can be installed with the pip package manager. Once installed, Robot Framework tests are data-driven, and use keywords which are specified in Test Templates and called by invoking their arguments in code. A theme inherent in Robot scripting, which is done in its own native IDE called RIDE, is the implementation of a workflow that is consistent with generic acceptance testing models. That is, Robot enables a repeatable pattern of testing which can be modified with new code changes. In practice, keyword testing divides the testing process into two phases: design and development plus test execution. Let’s look at a design and development example script provided by the architects.

    *** Test Cases ***
    Invalid Username
    Invalid Password
    Invalid Username and Password
    Empty Username
    Empty Password
    Empty Username and Password
    USER NAME PASSWORD
    invalid ${VALID PASSWORD}
    ${VALID USER} invalid
    invalid whatever
    ${EMPTY} ${VALID PASSWORD}
    ${VALID USER} ${EMPTY}
    ${EMPTY} ${EMPTY}
Keyword-Driven/Table-Driven TESTING
Keyword-driven testing or some call it table-driven testing are the notions widely applied to an application-independent automation. The tester needs to develop data tables with keywords, independent of the test automation framework or any other tool used to run them. Then it is required to code the test script that will, in its turn “drive" the tested application and the data. Tables in a keyword-driven test will contain the information on the functionality of the tested application and step-by-step instructions for each test. Overall, we can speak of:
      • Higher-level keywords: They are used to test a specific aspect of the system.
      • Lower-level keywords: To keep the test cases minimal and concise the required functionality testing is separated into several lower-level keywords.
      • Technical keywords: They are implemented into the test to actually access the system and run the tests.
Services offerings
Our expertise team use robot framework for testing python code and also implement in variety of testing tasks, including:
  • RESTful API testing
  • SOAP service testing
  • Website testing
  • Database testing
  • Desktop application testing
  • Mobile application testing (with selenium and 3rd party drivers)
  • Unit and integration testing (though, there are often better tools for that job)
  • Manual testing - scenarios can be written as if they were automated, they can prompt the user rather than perform a task.
The configuration simplifies writing test cases by offering tunable configurations for different aspects of test suites that can be automatically updated or edited via a GUI.

Writing Test Cases
Moving on to the test cases, Robot has all its test cases in tables. We save them either in HTML or table-separated value (TSV) files.

Managing Test Cases
There are several ways in which we organize test cases in Robot Framework. Test cases are made into test suites, which are sets of test cases, taken either from single or multiple files. Another key feature of Robot is test case tagging. Each tag (e.g. critical, quick) assigns a test case to a separate set. When executing, we run the tests based on tags, like “critical” and “quick”.

Running Test Cases
Once we’ve finished writing the test cases we need, those are executed using provided Python scripts. Since our lovely Robot Framework is system- and platform- independent - we run our tests any platform with Python: be it Windows, Linux, Unix or Mac.
The execution of our test cases is done in the following steps:
  • collecting test cases, reading and setting variables
  • running all the steps in every test case
  • providing the execution statistics (which test cases have passed/failed)
  • writing the detailed log in xml format
  • generating the report and log in html format.
Tools & Techniques
Test libraries provide the actual testing capabilities to Robot Framework by providing keywords. There are several standard libraries that are bundled in with the framework, and galore of separately developed external libraries that can be installed based on your needs.

Test libraries
  • BuiltIn: Provides a set of often needed generic keywords. Always automatically available without imports.
  • Collections: Provides a set of keywords for handling Python lists and dictionaries.
  • DateTime: Library for date and time conversions. New in Robot Framework 2.8.5.
  • Dialogs: Supports pausing the test execution and getting input from users.
  • OperatingSystem: Enables various operating system related tasks to be performed in the system where Robot Framework is running.
  • Process: Library for running processes in the system. New in Robot Framework 2.8.
  • Remote: Special library acting as a proxy between Robot Framework and test libraries elsewhere. Actual test libraries can be running on different machines and be implemented using any programming language supporting XML-RPC protocol.
  • Screenshot: Provides keywords to capture and store screenshots of the desktop.
    String: Library for generating, modifying and verifying strings.
  • Telnet: Makes it possible to connect to Telnet servers and execute commands on the opened connections.
  • XML: Library for generating, modifying and verifying XML files.
Tools
Supporting tools ease everything surrounding tests: editing, running, building and so on. Most of these tools are developed as separate projects, but some are built into the framework itself.
  • Rebot: Tool for generating logs and reports based on XML outputs and for combining multiple outputs together.
  • Libdoc: Tool for generating keyword documentation for test libraries and resource files.
  • Testdoc: Generates high level HTML documentation based on Robot Framework test cases.
  • Tidy: Tool for cleaning up and changing format of Robot Framework test data files.
Skills and Matrix
Robot Framework is very easy-to-use, yet still powerful enough to be an acceptance-level test automation framework. It is quite flexible and can extend its functionality through Python and Java modules.
Our in-depth perceptive and expertise in robot framework testing reflects in our execution methodology. We ensure that our clients get the benefits of all the powerful features offered by this framework.

  • Business Keyword driven, tabular and easy to understand syntax for test case development.
  • Allows creation of reusable higher-level keywords from the existing keywords.
  • Allows creation of custom keywords.
  • Platform and application independence.
  • Support for standard and external libraries for test automation.
  • Tagging to categorize and select test cases to be executed.
  • Easy-to-read reports and logs in HTML format.

Skills

Why Choose Simnovus

  • Technology Excellence across platforms
  • Business ideas into commercial applications
  • Domain Intensive Value Proposition
  • Significant Cost Reduction with ODC model
  • Get 2-4 weeks Risk-Free Trial before kick-start
  • Pool of expertise in Agile Teams to choose
  • Flexible work hours based on need
  • Commitment to excellence, Reliable

Key Points

  • Competitive cost Proposition
  • Wider platform coverage
  • Business application & interface development
  • Highly trained resources
  • Commitment to Quality
  • Agile methodologies & practices
  • Deep domain & functional expertise
  • Happy international clients

Skill Set

  • Software programming and testing
  • Cross-platform development skills
  • Multiple OS, tools, technology skills
  • Web, mobile & business applications
  • Automated testing across industry verticals
  • Optimized, high-productivity porting
  • Effective communication
  • International Project Management skills

Reach Us

Get in Touch
reCAPTCHA