ONLINE
Worldwide 7–9 April 2027
RBCN27 ONLINE
Miikka SolmelaOpening Session – RoboCon 2027 Online
🔗10:00 AM–10:30 AM By Miikka SolmelaThe official opening of RoboCon 2027 Online by the Robot Framework Foundation. Tune in to kick off the conference with us!
Opening Session – RoboCon 2027 Online
The official opening of RoboCon 2027 Online by the Robot Framework Foundation. Tune in to kick off the conference with us!
Join us as the Robot Framework Foundation opens RoboCon 2027 Online. Tune in to this session to start the conference together and get ready for the days ahead.
More details will be announced later.
Ganesha ts
Manana KoberidzeFrom Lift to Cloud With Robot Framework
🔗10:30 AM–10:50 AM By Ganesha ts, Manana KoberidzePress a button, go up and down. What makes every elevator journey a smooth ride?
Modern elevators are more than machines that move people. They are connected IoT systems where devices continuously exchange data with cloud services for monitoring, diagnostics, and remote maintenance. In this talk, we'll show how Robot Framework helps us test the connected services behind every ride.
We'll walk through our test automation architecture, conventions, libraries and wrappers built around Robot Framework, and show how we use them to validate the journey from lift to cloud.
From Lift to Cloud With Robot Framework
Press a button, go up and down. What makes every elevator journey a smooth ride?
Modern elevators are more than machines that move people. They are connected IoT systems where devices continuously exchange data with cloud services for monitoring, diagnostics, and remote maintenance. In this talk, we'll show how Robot Framework helps us test the connected services behind every ride.
We'll walk through our test automation architecture, conventions, libraries and wrappers built around Robot Framework, and show how we use them to validate the journey from lift to cloud.
This talk presents how we use Robot Framework to test a connected elevator IoT platform spanning web applications, AWS cloud services, and connected devices.
We'll demonstrate how we validate end-to-end workflows across the UI, cloud services, and devices, and discuss challenges such as coordinating multiple devices. We'll share practical examples from a test suite of more than 1000 automated test cases.
Finally, we'll discuss lessons learned from evolving our automation solution over time, including areas we're currently exploring, such as the use of AI to support test automation activities.
Florian Löhden
Sandro VincentiReadable, Repeatable, Trustworthy: Kubernetes Performance Tests with Robot Framework
🔗11:00 AM–11:20 AM By Florian Löhden, Sandro VincentiIt started with running the tools by hand: one test at a time, no schedule, every result copied together manually. Then came an in-house tool, with Robot Framework checking the results at the end. The idea worked; the ecosystem around it didn't. Now the Robot suite is the test itself: criteria anyone can read, like Throughput Should Be At Least 950 megabits per second, and a parser that refuses anything it wouldn't run. Three generations of performance testing bare-metal Kubernetes clusters around the world for a financial customer: what broke, what we kept.
Readable, Repeatable, Trustworthy: Kubernetes Performance Tests with Robot Framework
It started with running the tools by hand: one test at a time, no schedule, every result copied together manually. Then came an in-house tool, with Robot Framework checking the results at the end. The idea worked; the ecosystem around it didn't. Now the Robot suite is the test itself: criteria anyone can read, like Throughput Should Be At Least 950 megabits per second, and a parser that refuses anything it wouldn't run. Three generations of performance testing bare-metal Kubernetes clusters around the world for a financial customer: what broke, what we kept.
What does "performs as agreed" mean?
For a customer, we validate the performance of bare-metal Kubernetes clusters in data centres around the world. Every test ends with one question: does this cluster perform as agreed? The answer has to be the same, and comparable, wherever and whenever it is asked.
This talk follows how our answer evolved over three generations, and what each one taught us.
Three generations
1. By hand. We ran the tools one at a time, without a schedule, and copied every result together manually.
2. An in-house tool. It orchestrated several performance tools across scenarios and architectures. Robot Framework evaluated the results at the end and produced the verdict and the report.
3. The Robot suite is the test. We kept what worked: one orchestrator for many tools, scenarios, and Robot's verdict and report. What changed is that the suite no longer checks results afterwards. It defines the test:
- Pass criteria are keywords anyone can read, such as Throughput Should Be At Least 950 megabits per second.
- The parser only accepts what it will actually run. A criterion hidden in an ELSE branch would pass without being checked, so it is refused.
- The same test can be written in YAML, and round-trip tests keep both formats equal.
- Every performance tool plugs in behind the same interface.
- Common measurement pitfalls are closed by design: no traffic before every pod is ready, a discarded warm-up pass, missing data is never a pass, and one run per cluster at a time.
What you will take away
Bringing Robot Framework into an existing environment is much easier than we thought. You don't have to start over:
- Start at the end. Let Robot evaluate the results your tools already produce.
- Keep your tools. iperf2, IRTT or a customer's own tool stay as they are. Robot needs their results, not a rewrite.
- Use the reporting you already have. Robot's verdicts and reports can go into the test reporting your customer already uses.
- Grow one step at a time. From checking results, to readable pass criteria, to the suite being the test, and what to watch for at each step.
- Let non-testers read it. Readable keywords let a customer review exactly what was agreed.
Who it is for
Teams with existing test tooling who wonder whether Robot Framework fits in, and anyone who has had to sign off on a performance test result.
Lukáš ProcházkaWhen Robot Framework Keywords Become a Library
🔗12:00 PM–12:20 PM By Lukáš ProcházkaWhat changes when other projects start depending on your Robot Framework keywords? The challenges extend far beyond writing reusable keywords. Our libraries are implemented as Robot Framework resource files. I'll share how such a library is created, how its development and testing are supported by CI/CD, how new versions are prepared and published to a package repository, and how they then reach dozens of teams for use in their projects. I'll also show how changes to the library's source files trigger the appropriate CI/CD verification processes and how impact analysis drives test selection.
When Robot Framework Keywords Become a Library
What changes when other projects start depending on your Robot Framework keywords? The challenges extend far beyond writing reusable keywords. Our libraries are implemented as Robot Framework resource files. I'll share how such a library is created, how its development and testing are supported by CI/CD, how new versions are prepared and published to a package repository, and how they then reach dozens of teams for use in their projects. I'll also show how changes to the library's source files trigger the appropriate CI/CD verification processes and how impact analysis drives test selection.
The talk starts with the problem that led us to create the library: how to share proven keywords across projects, reduce duplication, and keep their behavior consistent for dozens of teams. I'll show how that need gradually evolved into a separately maintained library.
I'll share our experience with a family of libraries whose reusable keywords are written directly in Robot Framework resource files, rather than as custom Python modules or library classes. Python remains an important part of the environment, including its third-party dependencies and packaging. The talk will compare the benefits and practical differences between a pure Python library and a library based on Robot Framework resource files, including when each approach is the best fit.
The main part follows the journey from resource files to a Python package that acts as the distributable wrapper for Robot Framework. I'll show how the library is built, prepared for installation, and how its resource files are then loaded by a consuming test project. This step connects Robot Framework authoring with the familiar process of distributing versioned packages.
The next part of the talk focuses on the CI/CD process that support this lifecycle. The entire process, from developing and reviewing a change through a pull request, including Robocop analysis, testing, or other checks, to building and distributing a new version, is automated. A change to the library source files determines the relevant test scope for the affected area of the library, and the selected tests are then executed
Audience: Robot Framework users who share keywords across projects or are considering doing so. Basic familiarity with resource files is enough; experience with implementing Python libraries is not required.
Takeaways: Experience and practical perspectives for deciding when resource files need their own lifecycle, maintaining such a library, and distributing it reliably across consuming projects.
Timo StordellSalesforce and Robot Framework - a match made in heaven?
🔗12:30 PM–12:50 PM By Timo StordellAfter working two years with Robot Framework for testing Salesforce, I’ve come to know there are quite many challenges that come with Salesforce. How to tackle those to get testing proceeding? Here’s my experiences and tips for you.
Salesforce and Robot Framework - a match made in heaven?
After working two years with Robot Framework for testing Salesforce, I’ve come to know there are quite many challenges that come with Salesforce. How to tackle those to get testing proceeding? Here’s my experiences and tips for you.
Test automation for Salesforce faces many challenges, for example:
- How to access the elements on a UI having dynamic code?
- How to make the testing processes reliable?
- How to make testing faster?
- What environments you need for testing?
- How to prepare for unexpected changes?
- Would AI be able to help there?
The work with such platform differs significantly from a solution implemented in-house from scratch as you won’t have control on all the content, and neither on when some of the content gets updated.
We’ve used Robot Framework for testing a new Salesforce solution that would replace company-wide legacy system. I believe the discoveries made here would be beneficial also for others wishing to do test automation for Salesforce.
Tommi OinonenRun your validation keywords (asynchronously) later
🔗02:00 PM–02:20 PM By Tommi OinonenA lot of the execution time is usually spend waiting for the tested system to reach some expected state that needs to be validated. Especially with more complex systems the state propagation can take time that could be used more efficiently.
Robot runs suites and test cases synchronously and in order. Previous test/suite needs to complete before moving to the next.
What if instead of "Wait Until Keyword Succeeds" you could use something like "Run Other Tests/Keywords Until Keyword Succeeds".
If this sound good we have a library for you!
Run your validation keywords (asynchronously) later
A lot of the execution time is usually spend waiting for the tested system to reach some expected state that needs to be validated. Especially with more complex systems the state propagation can take time that could be used more efficiently.
Robot runs suites and test cases synchronously and in order. Previous test/suite needs to complete before moving to the next.
What if instead of "Wait Until Keyword Succeeds" you could use something like "Run Other Tests/Keywords Until Keyword Succeeds".
If this sound good we have a library for you!
We have developed libraries in our project that allow you to postpone keyword executions and wish to open source them now. They employ couple of different approaches that can be used to both optimize some tests and make some easier to maintain.
I'll be presenting the open sourced libraries and how to use them. I'll give practical examples and explain how these concepts can be employed to simplify some tests. These methods allow you to think differently about how to implement some test scenarios. Maybe even start a discussion around the topic in the community and find more use cases.
This is not parallel execution like pabot but selective asynchronous execution with the help of listener libraries.
This is mostly about executing some tests/keywords/functions not where they are logically in the suite/test but actually later when the system is ready:
1. in the end of the suite
2. in the end of the test run
3. the next day
The results of these postponed executions can then be injected back to the test logs where they logically exist for reporting.
Real world use cases:
1. Validation requires waiting that could be spent testing something else
2. A batch job is part of the process under test. It is inefficient to run it for each test separately
- register all the validations in the tests
- run the batch job once
- run all the validations after that
3. Validation that need to wait for some long process to complete and requires checking after the initial test run e.g. the next day
Luis Gomez-TinocoBalancing Test Suites Across CI Workers: Bin Packing with a Robot Framework SuiteVisitor
🔗02:30 PM–02:50 PM By Luis Gomez-TinocoRunning hundreds or thousands of Robot Framework tests in CI quickly becomes a scheduling problem. Running them one after another is too slow. Pabot runs tests in parallel on one VM, but every process shares the same test server and database, which soon becomes the bottleneck. Our setup gives each worker its own VM, test server and database, which raises a new question: how do you split the suites evenly between them? This talk shows how a small SuiteVisitor, built on Robot Framework's own APIs, assigns suites to workers by how many tests each one contains.
Balancing Test Suites Across CI Workers: Bin Packing with a Robot Framework SuiteVisitor
Running hundreds or thousands of Robot Framework tests in CI quickly becomes a scheduling problem. Running them one after another is too slow. Pabot runs tests in parallel on one VM, but every process shares the same test server and database, which soon becomes the bottleneck. Our setup gives each worker its own VM, test server and database, which raises a new question: how do you split the suites evenly between them? This talk shows how a small SuiteVisitor, built on Robot Framework's own APIs, assigns suites to workers by how many tests each one contains.
Our CI pipeline runs about 621 end-to-end tests every day, organized into 52 suites. Run one after another on a single worker, that takes about 16 hours.
The usual first step is Pabot. It works well, but it runs on one VM, and all its processes share one test server and one database. Adding processes eventually makes things slower, because that shared environment becomes the bottleneck. So we went a different way. We gave each of 7 VMs its own test server and its own database, which removes the contention completely.
That created a new problem: deciding which suites go to which VM. Splitting by suite count, N suites divided across K workers, rarely balances. A suite with 40 tests and a suite with 3 tests count the same, but they are not the same amount of work. In a CI pipeline, the slowest worker sets the pace for everyone.
This talk walks through the small, production SuiteVisitor we built to solve this. It is registered as a pre-run modifier with one command-line argument that reads as "split into N parts, run part i". Before any test runs, it sees the whole suite tree. It filters out tests that shouldn't run, such as archived tests or known defects, weighs each suite by how many tests it contains, and hands the problem to a bin-packing algorithm that spreads the suites evenly across the workers. Each VM then keeps only its own share and drops the rest. No orchestration service is needed, and no changes to the tests themselves.
We'll look at:
How the visitor pattern in Robot Framework's API makes this a low-code extension rather than a custom runner.
Why, in CI, keeping the number of workers fixed and balancing the load across them beats fixing a capacity per worker and letting the number of workers grow.
Real results: the ~16-hour run dropped to about 3 hours. The average per worker was 146 minutes against a theoretical ideal of 138.
Where it still falls short: the fastest VM finished in 1h51m and the slowest in 3h05m. Whole suites can't be split, and test count is only a stand-in for how long a suite takes, since our tests range from 15 seconds to more than 7.5 minutes.
We'll finish with the next steps and their trade-offs. Weighting suites by measured execution time is one. Splitting at the test-case level is another: it promises better balance, but you lose the reuse of suite setup and teardown. You'll leave with a pattern you can adapt to your own pipeline, and a clear sense of when it's worth going beyond Pabot.
Jeff KingYou can change career paths but you can't quit Robot Framework
🔗04:00 PM–04:20 PM By Jeff KingTwo brothers took separate paths to Quality Engineering and with the changing technology landscape, both now have roles that don't have "Quality" in the title but are still Robot Framework users.
Jeff King has 20+ users in manual and automated testing and is now a Customer Success Manager.
Ryan King has 10+ years in testing and is now a Software Engineer.
Both are still avid Robot Framework users, thanks to its versatility and ease of use.
You can change career paths but you can't quit Robot Framework
Two brothers took separate paths to Quality Engineering and with the changing technology landscape, both now have roles that don't have "Quality" in the title but are still Robot Framework users.
Jeff King has 20+ users in manual and automated testing and is now a Customer Success Manager.
Ryan King has 10+ years in testing and is now a Software Engineer.
Both are still avid Robot Framework users, thanks to its versatility and ease of use.
UPDATE: We would like to do this presentation with 2 speakers - one as noted before and another who is now a software engineer who has developed a Claude skill to build Browser library Robot Framework tests into the deployment process. His notes will be in "Notes"
This talk will discuss the versatility of Robot Framework and how it can be used with AI tools.
The strengths of Robot Framework/Python and creating custom libraries, including with Claude.
Projects I've done related to a given issue:
Chaos Bot - geared toward testing Angular to Vue migration - ended up finding some bugs but more security issues.
API Test Replicator - the ability to "play" previous API data and re-run vs. replicated/test environment for trouble shooting.
Robot Framework to Artillery exporter - we wanted to be able to take API traffic and use with Artillery as our load test.
And as a "Customer Success" manager - I wrote a full API suite and tested it verses our documentation using Claude to generate tests based on reading the documentation.
Why do I choose to use Robot Framework when other tools are available?
Robot Framework and AI tools work well together - I can hand it a product design and get a vibe-coded function either as tests case with an existing library or creating a totally new library and they will work quickly.
Robot Framework does a better job of error/exception handling than other tools. Putting conditions on data/page states/etc. can be added at any point - other tools may stop the moment they get something they 'don't expect'.
Robot Framework is not just a familiar tool, but an easy one. I've gotten more into the world of API testing and used new tools for Graph QL and Rest testing.
Robot Framework is a great tool for generating output as test results, lists, data for other tests, even using Robot Framework to build new, repeatable tests from reviewing options that appear on a page!
Many KasirihaAI panel: how does AI change our work and our relevance?
🔗05:00 PM–06:00 PM By Many KasirihaA moderated panel discussion on AI. Speaker to be announced.
AI panel: how does AI change our work and our relevance?
A moderated panel discussion on AI. Speaker to be announced.
A moderated panel discussion on AI. Speaker to be announced.
Many KasirihaIntro to AI engineering with RF
🔗A practical introduction to AI-assisted work with Robot Framework using the stack the community recommends: RobotCode and Agent Skills. Many shows how to set it up and use it, in conversation with AI track chair Guido Demmenie.
Intro to AI engineering with RF
A practical introduction to AI-assisted work with Robot Framework using the stack the community recommends: RobotCode and Agent Skills. Many shows how to set it up and use it, in conversation with AI track chair Guido Demmenie.
AI coding agents can write, run and fix Robot Framework tests, but there are many ways to set them up. This session shows the one we recommend: RobotCode together with Agent Skills.
Many walks through the setup and a live demo, talks about what works and what to watch out for, and introduces Robot Framework Plugins, a shared repository of agent skills that anyone can use and contribute to. The session is a conversation with Guido, with room for your questions.
No prior AI experience needed. More details to be added.
Pekka KlärckExtending Robot Framework: Advanced Library API
🔗In this hands-on online workshop, Robot Framework creator Pekka Klärck takes you beyond the basics of the library API. You learn how to build more powerful and flexible keyword libraries in Python using features such as automatic argument type conversion and the dynamic library interface.
Extending Robot Framework: Advanced Library API
In this hands-on online workshop, Robot Framework creator Pekka Klärck takes you beyond the basics of the library API. You learn how to build more powerful and flexible keyword libraries in Python using features such as automatic argument type conversion and the dynamic library interface.
This half-day online workshop focuses on the more advanced parts of the Robot Framework library API. We cover topics such as automatic argument type conversion and the dynamic library interface used, for example, by SeleniumLibrary, and how to use them to build libraries that are powerful and easy to use.
The workshop is 100% hands-on: no slides, just learning by doing. Besides learning from the person who designed these APIs, you get the chance to ask hard questions about Robot Framework from its creator.
This workshop is one of two independent half-day workshops on extending Robot Framework. The other one, "Extending Robot Framework: Listeners and Modifiers", covers the listener API and modifying tests and results. You can join either one or both.
Knowledge level: Intermediate to Advanced
This workshop is for you if you already know the basics of using Robot Framework, including the basics of the library API (you have created simple keyword libraries in Python), and want to take your skills to the next level. You should also know Python basics such as functions, modules and classes. The basics of the library API are not covered in the workshop.
Agenda
- Advanced library API: automatic argument type conversion
- The dynamic library interface
- Hands-on exercises throughout, with time for questions
Preparation and technical requirements
- A computer with a stable internet connection, able to join the online workshop session
- Admin rights, so you can install Python modules if needed
- Python 3.10 or newer
- The latest Robot Framework version (the exact version will be confirmed before the workshop)
- An editor or IDE that supports Python and Robot Framework. VS Code or PyCharm with the RobotCode plugin is recommended.
- Workshop materials will be shared as a GitHub repository before the workshop. Cloning it with git is recommended so you can pull updates during the session, but you can also download it as a zip.
Key takeaways
- Use automatic argument type conversion in your own libraries
- Build libraries with the dynamic library interface
- Design keyword libraries that are powerful and easy to use
- Gain a deeper understanding of how Robot Framework uses libraries
- Hands-on experience directly from the framework's creator
Tim de Groot
Yuri VerweijFrom Test Runs to Trends with RobotDashboard
🔗Robot Framework logs are great for looking at a single run, but trends, flaky tests and regressions only become visible when you keep the history.
In this full-day hands-on workshop, you will build a RobotDashboard from real output.xml files, use it to investigate problems across multiple runs, and automate how new results are collected and published.
The goal is not just to build a dashboard, but to learn how to use test history to answer useful questions about your test suite.
From Test Runs to Trends with RobotDashboard
Robot Framework logs are great for looking at a single run, but trends, flaky tests and regressions only become visible when you keep the history.
In this full-day hands-on workshop, you will build a RobotDashboard from real output.xml files, use it to investigate problems across multiple runs, and automate how new results are collected and published.
The goal is not just to build a dashboard, but to learn how to use test history to answer useful questions about your test suite.
We start with a ready-made dashboard and a few questions to answer from it before installing anything. That gives everyone an idea of what the dashboard is useful for first.
After that we build things up step by step. We create dashboards from files and folders, add tags, versions and filters, and use those to compare runs and find things like tests that only fail on staging or problems that appeared in a new release.
We also look at reruns. We import results that were merged with rebot --merge and use the dashboard to see which tests only look stable because they passed on a retry.
Later in the day we set up the dashboard server and use the listener with robot, pabot and robot.toml. Participants upload their own runs to a shared dashboard and compare results.
We also want to spend part of the workshop on real problems from the results that are available during the day. That might be a regression, a slow test or keyword, a flaky test, or something else that stands out in the data. Rather than following a fixed exercise, we will use the dashboard to investigate what is actually there and work out what the results are telling us.
Towards the end we look at how to make the dashboard useful for a team: choosing a layout that shows the most important information first, sharing that layout, publishing the dashboard from GitHub, and keeping the database manageable over time.
There will also be time to import your own output.xml files and look at what the dashboard shows for your own project.
Robert Jadoenandansing
Karan92Testing AI Agents with Robot Framework: Deterministic Evidence for Probabilistic Systems
🔗AI agents are probabilistic. Test automation is expected to give deterministic evidence. So what happens when we need to test an agent that uses LLMs, RAG, APIs and tools? In this talk I show how Robot Framework can become the control and evidence layer around AI systems: Validating tool use, schemas, sources, guardrails and outcomes while keeping LLM-based evaluation in its proper place. You will leave with a practical pattern for testing AI without letting the AI decide whether it passed.
Testing AI Agents with Robot Framework: Deterministic Evidence for Probabilistic Systems
AI agents are probabilistic. Test automation is expected to give deterministic evidence. So what happens when we need to test an agent that uses LLMs, RAG, APIs and tools? In this talk I show how Robot Framework can become the control and evidence layer around AI systems: Validating tool use, schemas, sources, guardrails and outcomes while keeping LLM-based evaluation in its proper place. You will leave with a practical pattern for testing AI without letting the AI decide whether it passed.
Large language models make modern AI systems powerful, but they also introduce a testing problem: The same input can produce different outputs, while our pipelines still need an objective PASS or FAIL.
This talk shows a practical way to use Robot Framework as the deterministic control and evidence layer around an AI agent. Instead of asking another LLM whether a result "looks correct", we separate what can be tested deterministically from what genuinely requires probabilistic evaluation.
Using a small agentic/RAG example, I will show Robot Framework tests for:
- API and output-schema validation
- Verifying which tools were called and with which arguments
- Validating retrieved sources and citations
- Checking guardrails and forbidden actions
- Collecting execution evidence for CI
- Combining deterministic assertions with semantic or LLM-based evaluation where appropriate
We will also look at failure modes that are easy to miss: A fluent but unsupported answer, a correct answer produced through the wrong tool, an LLM judge that changes its verdict between runs and a self-repair mechanism that hides a real regression.
The goal is not to make Robot Framework "AI-powered". The goal is to use the strengths Robot Framework already has readable test cases, reusable keywords, libraries, reporting and deterministic assertions to make AI systems more testable.
Attendees will leave with an architecture they can apply immediately: What to assert in Robot Framework, what evidence to capture, where probabilistic evaluation belongs and where it should never be allowed to decide PASS or FAIL on its own.
Audience: Robot Framework users, test automation engineers and developers who are beginning to test LLM-, RAG-, MCP- or agent-based systems. No deep machine-learning knowledge is required.
Many Kasiriha
Guido DemmenieTesting AI Solutions: An Open Discussion
🔗How do you test a system that never gives the same answer twice? Following the talk "Testing AI agents with Robot Framework", this open session continues the conversation: how to evaluate AI solutions, from chatbots and AI-driven decisions to coding agents, agent skills and MCP servers, with and without Robot Framework. Bring your experiences, questions and ideas.
Testing AI Solutions: An Open Discussion
How do you test a system that never gives the same answer twice? Following the talk "Testing AI agents with Robot Framework", this open session continues the conversation: how to evaluate AI solutions, from chatbots and AI-driven decisions to coding agents, agent skills and MCP servers, with and without Robot Framework. Bring your experiences, questions and ideas.
AI is finding its way into more and more systems, and they all need testing. This session continues from the talk "Testing AI agents with Robot Framework: deterministic evidence for probabilistic systems" and widens the view to evaluating AI solutions in general, with and without Robot Framework.
We look at two kinds of AI solutions:
- Systems with AI capabilities, such as chatbots and systems that make decisions or give recommendations based on AI
- Coding harnesses: a coding agent combined with agent skills and MCP servers
Topics for discussion include:
- Do we really need to test these systems, even when the solution is "just Markdown", as with agent skills?
- The challenges: non-deterministic results, cost, and knowing when a result is good enough
- Practical approaches and examples from the community
This is not about presenting "the best way" to do it, but about exchanging ideas. Many Kasiriha and Guido Demmenie moderate the session and share some of their own challenges in testing MCP servers and agent skills as discussion starters, but most of the time is for you: your experiences, your questions and your approaches.
Who is this for?
Anyone who is testing, or about to test, AI-based systems, whether you use Robot Framework or not.
René RohnerThe role of test automation in the age of AI
🔗AI agents can write code, but who decides whether it does the right thing? Discover how Robot Framework’s readable, keyword-driven tests turn human expectations into executable contracts—and give coding agents a reliable feedback loop. Learn where agents help, what makes a test stack agent-ready, and why people still own quality.
The role of test automation in the age of AI
AI agents can write code, but who decides whether it does the right thing? Discover how Robot Framework’s readable, keyword-driven tests turn human expectations into executable contracts—and give coding agents a reliable feedback loop. Learn where agents help, what makes a test stack agent-ready, and why people still own quality.
Faster code generation does not automatically mean faster delivery—or the right product. As coding agents take on implementation, clear expectations and trustworthy verification become even more important.
Robot Framework’s readable, keyword-driven approach provides a valuable boundary: people define the expected behaviour in business-level tests, while agents help implement and maintain the technical keywords underneath. Those tests become executable domain knowledge that humans can discuss, review, and reuse across changing implementations.
This talk explores how to build on that foundation:
- Separate readable acceptance criteria from technical implementation.
- Use Robot Framework tests as feedback for coding agents.
- Assess readiness: command-line execution, accessible environments, machine-readable results, and maintainable libraries.
- Move from AI-assisted coding towards a closed agentic feedback loop.
- Check the tests themselves, avoiding the trap of agents generating code and tests that share the same misunderstanding.
Through keyword examples and a practical workflow, you will see where agents can reduce effort—and where human judgment remains essential.
You will leave with a clearer way to position Robot Framework in an AI-enabled development workflow: not merely as a test runner, but as a readable contract between intent, implementation, and verification.
AI can take on the work. People still own the expectations, the evidence, and the decision to release.
Dave AmiesChoosing Test Cases for RFSwarm
🔗You need to do performance or load testing testing for your application, you have a full suite of robot framework tests cases and so you decide using RFSwarm might be a good idea, but now your not sure:
- Which test cases should you chose?
- How do I justify which ones I chose and which ones I chose not to use?
- how many robots should I assign to each test?
- how long should I run the test for?
Choosing Test Cases for RFSwarm
You need to do performance or load testing testing for your application, you have a full suite of robot framework tests cases and so you decide using RFSwarm might be a good idea, but now your not sure:
- Which test cases should you chose?
- How do I justify which ones I chose and which ones I chose not to use?
- how many robots should I assign to each test?
- how long should I run the test for?
This talk will be a practical guide to how to get started with performance testing, while it will be targeted for people who have been tasked with doing performance testing and don't know how to get started, it will also hopefully have practical gems for everyone.
Pekka KlärckStart Contributing to Robot Framework Core
🔗Want to help shape the future of Robot Framework? This session shows you how to get started contributing to Robot Framework core: where the work happens, how contributions are made, and where to find help. Come hear why contributing is worth it, and join the discussion about how you can get involved.
Start Contributing to Robot Framework Core
Want to help shape the future of Robot Framework? This session shows you how to get started contributing to Robot Framework core: where the work happens, how contributions are made, and where to find help. Come hear why contributing is worth it, and join the discussion about how you can get involved.
Robot Framework is open source, and its future depends on the people who contribute to it. This session is for everyone who has thought about contributing to Robot Framework core but has not known where to start.
We cover the practical side of contributing: where development happens, which communication channels to follow, how issues and pull requests are handled, and what kinds of contributions are needed, from code and tests to documentation such as the Robot Framework User Manual. You will also hear why contributing is valuable, both for the project and for you.
The session continues from "Robot Framework core architecture" and ends with an open discussion, where you can ask questions and talk about how you could get involved.
Who is this for?
Robot Framework users and developers who are interested in contributing to Robot Framework core. No previous open source experience is needed.
Key takeaways
- Know where Robot Framework core development happens and how to follow it
- Understand how contributions are made, from issues to pull requests
- Know which kinds of contributions are needed, beyond code
- Know where to get help when you get started
- Take your first step towards becoming a Robot Framework contributor
Kelby StineBuilding A Robot Framework Project From the Test Upwards with Agents in Mind
🔗This is a re-vamp of my previous online tutorial for building an automation project from the test upwards. Building off of best practices of managing dependencies, tests/tasks, and resources.
Building a project seems difficult, but with a process that starts with the test case an automation developer can result in a model that is flexible and scalable.
Dependency management
Fundamental directory design.
Tools to consider.
Workflow from test case, to test suite, to resource creation, and finally custom libraries
How to further integrate test cases
Introduce a product centric design pattern
Building A Robot Framework Project From the Test Upwards with Agents in Mind
This is a re-vamp of my previous online tutorial for building an automation project from the test upwards. Building off of best practices of managing dependencies, tests/tasks, and resources.
Building a project seems difficult, but with a process that starts with the test case an automation developer can result in a model that is flexible and scalable.
Dependency management
Fundamental directory design.
Tools to consider.
Workflow from test case, to test suite, to resource creation, and finally custom libraries
How to further integrate test cases
Introduce a product centric design pattern
This is a working session where an attendee can start with nothing but a empty repo and walk out with a fully structured automation project for Robot Framework.
Key topics to cover will be:
- managing dependencies
- IDE tooling
- What Libraries?
- Using variables wisely
- Levels of Keyword Abstraction
- How to create the project to be Agentic friendly
- There may be references to gnomes and possibly pancakes
Pekka KlärckAsk the Creator: Open Q&A and Feature Ideas with Pekka Klärck
🔗TBA: Ask Pekka Anything + feature ideas. Ask Pekka Anything + feature ideas
Ask the Creator: Open Q&A and Feature Ideas with Pekka Klärck
TBA: Ask Pekka Anything + feature ideas. Ask Pekka Anything + feature ideas
Ask Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideasAsk Pekka Anything + feature ideas
Dirk O. SchweierGenerating High-Quality Test Data During Test Execution
🔗“Yeah, why don’t you just generate some test data?”
If you’ve heard this or something similar during a project, you’ve probably also experienced how time-consuming it was to generate the right test data.
Software systems, for example, validate whether a ZIP code and city match during data entry. The more checks there are, the more test cases fail - not because the software has a bug, but because incorrect test data is being used.
With the SynData library, you can generate random test data that is consistent at the time of test execution, and the test cases can be easily rerun using the logs.
Generating High-Quality Test Data During Test Execution
“Yeah, why don’t you just generate some test data?”
If you’ve heard this or something similar during a project, you’ve probably also experienced how time-consuming it was to generate the right test data.
Software systems, for example, validate whether a ZIP code and city match during data entry. The more checks there are, the more test cases fail - not because the software has a bug, but because incorrect test data is being used.
With the SynData library, you can generate random test data that is consistent at the time of test execution, and the test cases can be easily rerun using the logs.
Test data is required in almost every project. The requirements that projects place on test data vary greatly in terms of the data that must be included in the dataset and the structure of the individual data points.
Because of these differences, I have almost always written scripts for my projects that allowed me to generate test data as files. However, these files weren’t always helpful when it turned out that the test data could only be used once or had an expiration date due to date specifications.
During open space sessions at Robocon, it became clear that many test automation engineers face this problem. It also became evident that everyone is pursuing their own solutions to some extent, since the Robot Framework ecosystem doesn’t offer a suitable solution. When we discussed what we wanted from a solution, the following ideas were put forward:
* The data should be consistent.
* The library should be able to “remember” data generated during a test so that the test automation engineer has to work with variables as little as possible.
* A test case should be as easy as possible to repeat using the data that was randomly generated during a previous test execution.
These ideas can only be implemented if the architecture takes them into account, which is why I decided - hopefully for the last time - to write a script based on these ideas as requirements and that has reusability, at least within the Robot Framework ecosystem.
The SynData library is based on a dataset initially compiled for Germany, from which results can then be randomly generated. However, using the keyword parameters, the user can also filter the data in advance to, for example, obtain a license plate for a specific city or from a particular federal state.
The user can also set a context using a keyword. This saves the results of the keywords in the library, and when a keyword requests data related to previously generated data, the result is determined from a filtered set - so that, for example, the address matches the license plate that was previously generated for the context.
The SynData library can generate a log of the generated data during test execution. If such a file is specified when initializing the library, a test case can be re-run without further modification, and the library will return exactly the values from the keywords that are taken from the log.
In my talk at Robocon, I would like to introduce the library to a broad audience, as I am convinced that it will be helpful to many test automation engineers and that, with the involvement of additional experts, other regions can also be better supported.
Marduk BolanosFive years of robosapiens and the future of SAP automation for humans
🔗robosapiens has become the standard library for automating the SAP GUI with Robot Framework.
It has been downloaded over a 100k times and is being used all around the world. In this talk I will showcase its new recording capabilities, which radically change the way robosapiens is used. I will also present the current advances in bringing the ideas of robosapiens to the browser for automating SAP UI5. 2027 is a transition year for SAP users and now is the best time to get to know robosapiens!
Five years of robosapiens and the future of SAP automation for humans
robosapiens has become the standard library for automating the SAP GUI with Robot Framework.
It has been downloaded over a 100k times and is being used all around the world. In this talk I will showcase its new recording capabilities, which radically change the way robosapiens is used. I will also present the current advances in bringing the ideas of robosapiens to the browser for automating SAP UI5. 2027 is a transition year for SAP users and now is the best time to get to know robosapiens!
robosapiens started life in 2021 as an internal project at NRW.BANK and became publicly available in 2023. The initial motivation was to allow domain experts to automate their tests using the texts they see on screen. No inspector needed. Nowadays they can directly record their tests and robosapiens will write the .robot file for them. This is a huge time saver and also serves as a way of documenting processes. The generated HTML report resembles a .robot file, which makes it easy to read, and includes the screenshots of all windows. Previously such documentation was generated using the Windows Recorder, which is no longer available on Windows 11. By the end of 2027 SAP will no longer support its Solution Manager and with it CBTA, the test automation tool for domain experts that allows recording test cases in terms of reusable components. Moreover, SAP will also end support for SAP ECC, the third generation of its ERP Platform. This means customers have to migrate to SAP S4/HANA and regression tests will be vital to the success of that migration. For these reasons, 2027 is the best time to get to know robosapiens!
Thomas RaffelsieperI didn't write a single line: building a Robot Framework platform with AI agents
🔗What happens when you build a full Robot Framework platform without typing a single line of code? For seven months of evenings I only steered and reviewed AI coding agents. The result is RoboScope: a visual flow editor, recorder, self-healing, isolated environments, offline mode. First pure vibe coding, then the structured BMAD agent workflow. I'll show what worked, what broke, and the one habit that kept it sustainable: turn every AI mistake into a written rule plus a test that pins it.
I didn't write a single line: building a Robot Framework platform with AI agents
What happens when you build a full Robot Framework platform without typing a single line of code? For seven months of evenings I only steered and reviewed AI coding agents. The result is RoboScope: a visual flow editor, recorder, self-healing, isolated environments, offline mode. First pure vibe coding, then the structured BMAD agent workflow. I'll show what worked, what broke, and the one habit that kept it sustainable: turn every AI mistake into a written rule plus a test that pins it.
RoboScope started as an after-work experiment: can AI coding agents build a serious Robot Framework tool, not a todo app, if I only steer and review and never type code myself?
Seven months later it is an open-source web platform for Robot Framework teams: Git integration, a visual flow editor that round-trips .robot files safely, a browser recorder with robust locator synthesis, an opt-in self-healing library, execution in isolated venv or Docker environments, reports and statistics, and a fully offline mode. Every line was written by Claude Code and reviewed by me.
This talk is the honest story of how that went.
Phase 1: vibe coding. For the first eight weeks I prompted, looked and accepted. It was surprisingly fast and the first releases shipped quickly. But the agent kept repeating the same classes of mistakes, some of them subtle and very specific to Robot Framework.
Phase 2: structure with BMAD. Then I added the BMAD Method: specialised agent roles (product manager, architect, story writer, developer, adversarial reviewer, retrospective) with explicit hand-offs. I'll show where that clearly paid off, for example an adversarial review that caught a deny-list bypass allowing code execution through run arguments, and where it was overhead or created a false sense of progress, like a sprint tracker that marked work "done" before it existed.
The lesson that transfers. Every recurring AI mistake became a written rule in the agent's project memory plus a test or CI gate that pins it. I'll walk through real examples from the Robot Framework domain:
- keeping a GUI from corrupting RF syntax on a .robot round trip
- making recorded flows survive real-world pages (wait_until, Shadow DOM, strict-mode-safe locators)
- keeping self-healing as reviewable suggestions instead of silent rewrites
- treating the running suite model, not the file, as the source of truth
You will take away:
- a realistic picture of what AI coding agents can and cannot do for Robot Framework tooling, from someone who did not type the code
- when a structured agent workflow pays off compared to plain vibe coding, and when it doesn't
- a simple, reusable pattern to stop the same AI mistake from coming back
- concrete RF pitfalls to guard against in your own libraries and tools
Audience: Robot Framework users, library and tool authors, and test leads who use or consider AI coding assistants. No prior knowledge of RoboScope or BMAD needed.
Many Kasiriha
Guido DemmenieLet's talk AI: where is AI taking Robot Framework?
🔗_Where is AI taking Robot Framework, and where is it taking our work?_
In this open round table discussion, we explore the directions AI is steering us, both the broad trends we all see coming and the personal views, hands-on experiences, and struggles we've each faced amid the rapid wave of changes of recent years.
This is an open invitation: everyone is welcome to join the conversation and share their stories, ideas, and perspectives on how AI is reshaping test automation.
Let's talk AI: where is AI taking Robot Framework?
_Where is AI taking Robot Framework, and where is it taking our work?_
In this open round table discussion, we explore the directions AI is steering us, both the broad trends we all see coming and the personal views, hands-on experiences, and struggles we've each faced amid the rapid wave of changes of recent years.
This is an open invitation: everyone is welcome to join the conversation and share their stories, ideas, and perspectives on how AI is reshaping test automation.
Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?Let's talk AI: where is AI taking Robot Framework?
Pekka KlärckInside Robot Framework: Core Architecture Explained
🔗How does Robot Framework actually work under the hood? In this session, Robot Framework creator Pekka Klärck walks through the internal architecture of Robot Framework core: its main building blocks and how they fit together. The recorded talk is followed by live Q&A with Pekka.
Inside Robot Framework: Core Architecture Explained
How does Robot Framework actually work under the hood? In this session, Robot Framework creator Pekka Klärck walks through the internal architecture of Robot Framework core: its main building blocks and how they fit together. The recorded talk is followed by live Q&A with Pekka.
Robot Framework is used by thousands of teams, but few people know what happens inside the framework when tests are run. In this session, Pekka Klärck, the creator of Robot Framework, gives an overview of the internal architecture of Robot Framework core: the main components, how they work together, and the design ideas behind them.
The focus is on the big picture rather than on implementation details that change over time. The goal is to give you a mental map of the codebase that makes it easier to understand how Robot Framework behaves, to debug problems, and to find your way around the source code.
The session is a recorded talk followed by live Q&A, where you can ask Pekka your questions directly.
Who is this for?
Anyone curious about how Robot Framework works internally, and especially those interested in contributing to Robot Framework core. The session is a natural starting point for "Start contributing to RF core", which follows it in the program.
Key takeaways
- Understand the overall architecture of Robot Framework core
- Know the main components and how they work together
- Understand the design ideas behind the framework
- Find your way around the source code more easily
- Get your questions answered by the framework's creator
Linda van de VoorenA Beginner's Guide to RF (from someone still
🔗TBA A Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone still
A Beginner's Guide to RF (from someone still
TBA A Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone still
A Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone stillA Beginner's Guide to RF (from someone still
Pieter WesselingA Relative DateTime Library: make testing with date/time easy
🔗Getting the current date and time in a test is easy. Working with dates in the future or past is more challenging.
You may need to set a date, add to it, compare dates, handle different time zones, or account for daylight saving time. The Relative DateTime library makes these tasks easy. It handles dates relative to the execution date or at a fixed point in time. It can also determine the next or previous business day and account for bank holidays. Working with dates and time should not be hard and with the Relative DateTime Library it not anymore.
A Relative DateTime Library: make testing with date/time easy
Getting the current date and time in a test is easy. Working with dates in the future or past is more challenging.
You may need to set a date, add to it, compare dates, handle different time zones, or account for daylight saving time. The Relative DateTime library makes these tasks easy. It handles dates relative to the execution date or at a fixed point in time. It can also determine the next or previous business day and account for bank holidays. Working with dates and time should not be hard and with the Relative DateTime Library it not anymore.
Working with dates and times in Robot Framework tests can be challenging.
You never know exactly when a test will run, especially when your SUT depends on dates. You need to make sure dates are handled correctly, and there are many possible approaches, such as freezing time or time travel. But sometimes those approaches are not possible. You need to work with the current date and time.
That is where the Relative DateTime library, which we built for our project, comes in: it makes it easy to handle all kinds of dates and times. It uses a relative date-time format that is easy to read, such as +0,+0,+0,+0,+0,+0 for the current date and time or 2026,2,12,8,30,0 for a specific date and time. It offers functions to add days or hours to a date, compare dates, and account for non-working days and holidays when adding days. It also handles time zones and daylight saving time.
Do you need to select the first day of a month three months ago, the next hour today, or the next business day? The Relative DateTime library can handle this with one keyword.
We have used the Relative DateTime library in our project for many years, and we no longer have date-related problems. No more nightmares involving daylight saving time, time zones, weekends, or holidays. Just define the dates you need in a relative format, and your date-related troubles are history.
Pekka KlärckExtending Robot Framework: Listeners and Modifiers
🔗In this hands-on online workshop, Robot Framework creator Pekka Klärck shows you how to extend and integrate Robot Framework beyond keyword libraries. You learn to use the listener API to react to test execution, to modify tests dynamically before or during execution, and to analyze and customize results programmatically.
Extending Robot Framework: Listeners and Modifiers
In this hands-on online workshop, Robot Framework creator Pekka Klärck shows you how to extend and integrate Robot Framework beyond keyword libraries. You learn to use the listener API to react to test execution, to modify tests dynamically before or during execution, and to analyze and customize results programmatically.
This half-day online workshop covers ways to extend and integrate Robot Framework beyond keyword libraries. We start with the listener API, which lets you observe and react to test execution, for example to integrate with external systems or add custom reporting. We then look at data and result modifiers: how to modify tests dynamically before or during execution, and how to analyze and customize results using Robot Framework's execution and result models.
The workshop is 100% hands-on: no slides, just learning by doing. Besides learning from the person who designed these APIs, you get the chance to ask hard questions about Robot Framework from its creator.
This workshop is one of two independent half-day workshops on extending Robot Framework. The other one, "Extending Robot Framework: Advanced Library API", covers advanced library features. You can join either one or both. You do not need to take the library workshop first.
Knowledge level: Intermediate to Advanced
This workshop is for you if you already know the basics of using Robot Framework and want to take your skills to the next level. You should know Python basics such as functions, modules and classes. Experience in creating simple keyword libraries in Python is helpful.
Agenda
- Listeners: observing and reacting to test execution with the listener API
- Modifying tests dynamically before or during execution
- Analyzing and customizing test results programmatically
- Hands-on exercises throughout, with time for questions
Preparation and technical requirements
- A computer with a stable internet connection, able to join the online workshop session
- Admin rights, so you can install Python modules if needed
- Python 3.10 or newer
- The latest Robot Framework version (the exact version will be confirmed before the workshop)
- The Python-Markdown and Pygments modules
- An editor or IDE that supports Python and Robot Framework. VS Code or PyCharm with the RobotCode plugin is recommended.
- Workshop materials will be shared as a GitHub repository before the workshop. Cloning it with git is recommended so you can pull updates during the session, but you can also download it as a zip.
Key takeaways
- Use the listener API to observe and react to test execution
- Modify tests dynamically before or during execution
- Analyze and customize test results programmatically
- Understand Robot Framework's execution and result models
- Hands-on experience directly from the framework's creator
Linda van de VoorenToo afraid to ask: Beginner edition
🔗TBA Too afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner edition
Too afraid to ask: Beginner edition
TBA Too afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner edition
Too afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner editionToo afraid to ask: Beginner edition
Elout van LeeuwenLet’s talk libraries, tools & data
🔗New libraries, clever tools and smarter ways to handle test data: the Robot Framework ecosystem keeps growing. Join this open discussion to share what you use, what you have built and what you are still missing. Hosted by Elout van Leeuwen.
Let’s talk libraries, tools & data
New libraries, clever tools and smarter ways to handle test data: the Robot Framework ecosystem keeps growing. Join this open discussion to share what you use, what you have built and what you are still missing. Hosted by Elout van Leeuwen.
The strength of Robot Framework lies in its ecosystem: the libraries, tools and data solutions built and shared by the community. This session is an open discussion in WorkAdventure, following the talks in the Libraries, Tools & Data track.
To get things going, a few invited community members, such as library and tool maintainers, start the discussion. Then the floor is open to everyone. Bring your questions about the talks you just saw, share the libraries and tools that make your work easier, show what you have built yourself, or tell us what you are still missing.
Whether you maintain a library, are thinking about creating one, or just want to find the right tools for your project, this is the place to talk with others who care about the Robot Framework ecosystem.
The session is hosted by Elout van Leeuwen and is not recorded, so feel free to speak openly.
Elout van LeeuwenAI is killing you softly
🔗AI. Yes, again. When I started out over 10 years ago, we could turn to stack overflow, but the brightest minds of the community were all gathered at the Robot Framework Slack. You asked questions, and you got then questions back or answers from a community member. This matters because it was really engaging, sharpening minds, bringing ideas and encouraging those who started out. But now? You ask a machine and it will spit out the most likely answer. It's like instant ramen: it'll fill you up, but nothing near an artisan made. What does it require from us to keep community alive?
AI is killing you softly
AI. Yes, again. When I started out over 10 years ago, we could turn to stack overflow, but the brightest minds of the community were all gathered at the Robot Framework Slack. You asked questions, and you got then questions back or answers from a community member. This matters because it was really engaging, sharpening minds, bringing ideas and encouraging those who started out. But now? You ask a machine and it will spit out the most likely answer. It's like instant ramen: it'll fill you up, but nothing near an artisan made. What does it require from us to keep community alive?
Community is what keeps Robot Framework afloat. This session is to inspire us all and be reminded of the fact that we have to treasure this. To treasure is to invest. It may be okay to use your AI of choice - don't we all sometimes - but then again, how does that help the community? 10 years ago at the first conference, the world looked a whole lot different. But now we have to step up our game and make conscious decisions about how we want to learn.
I hope to convey some insights on how you on what the community needs to stay afloat and ways how you can contribute to it with our most valuable posessions: Time and Brainpower. You want something in Return? You become part of the community.
Elout opens with his thoughts, followed by an open discussion in WorkAdventure hosted by Guido Demmenie.
Paul TurchinetzWrite Once, Test Twice: Sharing Keywords Across Web and Windows
🔗Teams that test both a web app and a Windows app usually keep two sets of keywords for the same behaviors: logging in, opening a record, checking a total. The tests say the same thing twice, in two vocabularies that drift apart. This talk shows one behavioral keyword layer over existing web and Windows libraries, so a single test runs against both. The interesting part is where it breaks: launching the app, reading text and timing don't unify cleanly. Leave knowing which keywords can be shared, which can't, and how to tell the difference in your own suite.
Write Once, Test Twice: Sharing Keywords Across Web and Windows
Teams that test both a web app and a Windows app usually keep two sets of keywords for the same behaviors: logging in, opening a record, checking a total. The tests say the same thing twice, in two vocabularies that drift apart. This talk shows one behavioral keyword layer over existing web and Windows libraries, so a single test runs against both. The interesting part is where it breaks: launching the app, reading text and timing don't unify cleanly. Leave knowing which keywords can be shared, which can't, and how to tell the difference in your own suite.
Many products ship as both a web app and a Windows app. The behaviors under test are the same, but the automation isn't: one suite written against a web library, another against a desktop library, each with its own keywords for the same actions. Every new feature gets tested twice, and the two suites slowly stop agreeing on what the product does.
This talk shows a technique for writing the test once.
Find the shared vocabulary. Start from the behaviors, not the libraries. We'll take tests from both suites and work out which keywords describe what the user is doing and which describe how one platform does it.
Build one layer over two libraries. The shared keywords sit on top of your web library and your Windows library, with the platform chosen when the suite runs. An adapter can implement the same small keyword contract, so that the test file doesn't change.
Learn where it leaks. Some things don't unify: locators, windows versus tabs, timing, and controls that exist on only one platform. We'll go through some examples and what each one taught us about where the shared layer should stop.
Design the escape hatch. A shared layer that pretends the platforms are identical is worse than none. We'll cover how to drop to platform-specific keywords deliberately, without it spreading through the suite.
Sander van BeekLet's challenge existing good practices
🔗TBA Let's challenge existing good practicesvLet's challenge existing good practicesvLet's challenge existing good practicesLet's challenge existing good practices
Let's challenge existing good practices
TBA Let's challenge existing good practicesvLet's challenge existing good practicesvLet's challenge existing good practicesLet's challenge existing good practices
Let's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practicesLet's challenge existing good practices
Open-Space
🔗This is your time to set the agenda. Open-Space is a free “unconference,” where attendees propose and vote on topics at the start. It’s a vibrant, hands-on space for sharing ideas, learning, and getting direct help from experts in the ecosystem. Everyone is welcome!
Open-Space
This is your time to set the agenda. Open-Space is a free “unconference,” where attendees propose and vote on topics at the start. It’s a vibrant, hands-on space for sharing ideas, learning, and getting direct help from experts in the ecosystem. Everyone is welcome!