Creating Custom Libraries and Keywords in Robot Framework

Robot Framework is a popular open-source test automation framework that provides a flexible and extensible platform for creating automated tests. One of the key benefits of Robot Framework is the ability to create custom libraries and keywords, allowing users to extend the functionality of the framework to suit their specific needs.

In this article, we will explore the process of creating custom libraries and keywords in Robot Framework, including examples and code snippets to demonstrate the concepts.

What are Custom Libraries and Keywords?

In Robot Framework, libraries are modules that contain reusable functions or methods that can be used in test cases. Keywords are the individual steps that make up a test case, and are typically defined in libraries.

Custom libraries and keywords are simply libraries and keywords that are created by the user, rather than being included in the built-in Robot Framework libraries. This allows users to create custom functionality that is tailored to their specific testing needs.

Creating a Custom Library

• Creating a custom library in Robot Framework is a simple process. To get started, create a new Python module with the name of the library. For example, if we wanted to create a library called "SampleLibrary", we would create a file called "SampleLibrary.py".
• Within the module, we can define functions or methods that will be used as keywords in our test cases. For example, let's create a simple function that divides two numbers:

class CustomStringLibrary:
    ROBOT_LIBRARY_SCOPE = 'GLOBAL'

    def divide (self, a,b):
        c= int(a)/int(b)
        return c

• Once we have defined our function, we need to create a Robot Framework library file that references our custom library. To do this, create a new text file with the same name as the library, but with a ".robot" extension.
• For example, if our library is called "SampleLibrary", our Robot Framework library file would be called "SampleLibrary.robot".
• In the Robot Framework library file, we need to specify the name of our library module and the name of the function that we want to use as a keyword. For example:

*** Settings ***
Library     C:\\Users\\****\\SampleLibrary.py

*** Test Cases ***
Divide Numbers
        ${result}         divide     4            2
        log    ${result}

In this example, we have created a test case called "Divide Numbers". The first line of the test case specifies the name of the keyword we want to use ("divide"), which matches the name of the function we defined in our custom library. The arguments to the keyword ("4" and "2") are passed to the function as the "a" and "b" parameters, respectively.

Creating a Keyword

• In some cases, users may need to create custom keywords that perform a specific task or set of tasks. Custom keywords can be created using Python functions and can be imported into a Robot Framework test case as a library or as a standalone keyword.
• To create a custom keyword in Robot Framework, we first need to define a Python function that performs the desired task. In this example, we will create a custom keyword that calculates the factorial of a number.

# CustomMathLibrary.py

def factorial(n):
    if n == 0:
        return 1
    else:
        return n * factorial(n-1)

In this example, we define a Python function called factorial that takes an integer as input and returns the factorial of that number.

• To use this custom keyword in a Robot Framework test case, we can import the function as a standalone keyword.

*** Keywords ***
Calculate Factorial
    [Arguments]     ${n}
    ${result}     Evaluate     CustomMathLibrary.factorial(${n})
    [Return]     ${result}

In this example, we define a custom keyword called Calculate Factorial that takes an argument ${n} and calculates the factorial of that number using the CustomMathLibrary.factorial function. The [Return] keyword is used to return the result to the test case.

• To use this custom keyword in a Robot Framework test case, we can simply call the Calculate Factorial keyword and pass in the desired argument.

*** Test Cases ***
Example Test Case
    ${result}     Calculate Factorial     5
    Should Be Equal As Integers     ${result}     120

In this example, we use the Calculate Factorial keyword to calculate the factorial of 5 and store the result in the ${result} variable. We then use the Should Be Equal As Integers keyword to assert that the result is equal to 120.

Conclusion

Creating custom libraries and keywords in Robot Framework can be a powerful way to extend the functionality of the framework and meet specific testing needs. By defining custom libraries and keywords in Python, users can create reusable code that can be imported into any test case and used to perform specific tasks.

In this article, we explored how to create custom libraries and keywords in Robot Framework with examples and code snippets. With these tools, users can create powerful and flexible test automation solutions that meet their unique testing needs.