World Wide Workshop Wednesday 2025

Description

Unlock the power of Robot Framework’s lesser-known dynamic and hybrid library APIs.

As automated testing scales across large, integrated systems, test frameworks must strike a balance between clean usability for testers and modular maintainability for developers. In this workshop, we’ll explore how Robot Framework’s dynamic library API enables just that.

Imagine testing dozens of RESTful services: user, orders, payments and many, many more. You also need to deal with authentication & authorization. With static libraries, you'd need a tangle of imports and exposed implementation details in every test suite. Instead, we’ll show how to build a single, unified RF library that dynamically loads service-specific Python modules at runtime. This allows test authors to use concise, readable test cases like Create New User or Verify Payment Received through one import, regardless of where the logic lives under the hood.

You’ll learn when and why to choose dynamic (or hybrid) libraries over static ones, how to implement them cleanly, and how this approach empowers cross-functional teams to scale their test automation without creating a mess.

This workshop is designed for test engineers and automation developers who want to move beyond simple static libraries and build flexible, scalable, and maintainable keyword libraries. Through a hands-on example based on REST API testing, you’ll learn how dynamic libraries work under the hood, when and why to use them, and how to structure Python-based libraries that expose clean, unified interfaces to test authors.

Key Takeaways

• Understand the differences between static, dynamic, and hybrid libraries in Robot Framework.
• Learn when and why to use dynamic or hybrid libraries in real-world test automation projects.
• See how Robot Framework discovers and executes keywords at runtime through the dynamic and hybrid API.
• Build maintainable dynamic and hybrid libraries that pulls together multiple Python modules under one import.
• Write clean, high-level test cases while keeping the complexity hidden in well-structured code.

Knowledge Level

• Robot Framework: Intermediate (understanding of test case syntax, keyword usage, and test suite structure)
• Python: Intermediate (modules, classes, methods, basic Python syntax)
• HTTP/REST APIs: Basic understanding of REST concepts and HTTP verbs (GET, POST, PUT, DELETE)
• Python Requests Library: Preferable, but not required (we will walk through usage in examples)

Agenda

1. Introduction

• 1.1 Why RF scripting isn't always enough
• 1.2 Introduction to the RF library APIs: Static vs. Dynamic vs. Hybrid
• 1.3 Taking a peek under the hood

2. Use Case: REST API Testing Framework

• 2.1 Overview of the demo application (multi-service REST API)

3. Static Library

• 3.1 Build the library
• 3.2 Using the Library in Tests
• 3.3 Limitations of the static approach

4. Building a Dynamic Library

• 4.1 Implementing get_keyword_names() and run_keyword()
• 4.2 Aggregating keywords from multiple modules
• 4.3 Structuring for maintainability
• 4.4 Using the Library in Tests

5. Building a Hybrid Library

• 5.1 Reuse our static library
• 5.2 Implementing get_keyword_names() and getattr()
• 5.3 Using the Library in Tests

6. PythonLibCore

• 6.1 Using DynamicCore and HybridCore
• 6.2 Easy Library Structuring with PythonLibCore

Preparation and Technical Requirements

• Computer: Capable of running Python 3 and Robot Framework with internet access
• Software:
• Python >= 3.8

• Robot Framework >= 6.1

• Editor: Any Python/RF-compatible IDE (VSCode recommended)

• Optional Tools: curl or Postman (for exploring APIs)
• Accounts: None required (public API will be used)
• Test Setup: A GitHub repo or downloadable ZIP will be provided with the project structure and stub code