---
title: Knowledge check | Robot Framework Tutorial for Web Testing
description: Ten questions on the decisions that matter in a real Robot Framework
  suite. Each answer comes with a short explanation, so a wrong answer points you
  back to…
source_url:
  html: https://testingbot.com/resources/courses/robot-framework/knowledge-check
  md: https://testingbot.com/resources/courses/robot-framework/knowledge-check.md
---

Course

[Robot Framework Tutorial for Web Testing](https://testingbot.com/resources/courses/robot-framework)

Chapter 10 of 10

1. [1 Robot Framework Tutorial for Beginners](https://testingbot.com/resources/courses/robot-framework)
2. [2 Install Robot Framework in a Python virtual environment](https://testingbot.com/resources/courses/robot-framework/install-robot-framework)
3. [3 Your first Robot Framework test with SeleniumLibrary](https://testingbot.com/resources/courses/robot-framework/first-test-with-seleniumlibrary)
4. [4 Variables, resource files and user keywords](https://testingbot.com/resources/courses/robot-framework/variables-resources-and-keywords)
5. [5 Run Robot Framework tests on TestingBot](https://testingbot.com/resources/courses/robot-framework/run-robot-framework-on-testingbot)
6. [6 Robot Framework Browser library: Playwright on TestingBot](https://testingbot.com/resources/courses/robot-framework/browser-library-playwright)
7. [7 Data-driven tests with Robot Framework templates](https://testingbot.com/resources/courses/robot-framework/data-driven-tests-with-templates)
8. [8 Tags and parallel test runs with Pabot](https://testingbot.com/resources/courses/robot-framework/tags-and-parallel-runs-with-pabot)
9. [9 Robot Framework reports, CI and test status on TestingBot](https://testingbot.com/resources/courses/robot-framework/reports-ci-and-test-status)
10. [10 Knowledge check](https://testingbot.com/resources/courses/robot-framework/knowledge-check)

[Exit course](https://testingbot.com/resources/courses)

 Chapter 10 of 10 Beginner 7 min read Updated Nov 2026 

# Knowledge check

Ten questions on the decisions that matter in a real Robot Framework suite. Each answer comes with a short explanation, so a wrong answer points you back to the right chapter.

1. A team of testers who do not write Python and two developers will maintain a suite covering a web app and its REST API. Why is Robot Framework a reasonable fit here?

 It is the only framework that can test web and API in one project It runs tests faster than Python test runners Keyword-driven tests are readable without programming, libraries cover web and API with one syntax, and the developers can add Python keywords where needed It needs no libraries to drive a browser

Readability for non-programmers plus one syntax and report across layers is the framework's strength. It is not the only way to test web and API together, it is not faster, and browsers always need a library such as SeleniumLibrary or Browser.

2. A CI agent runs the suite with a globally installed `robotframework-browser` that someone upgraded last week. Since then every Browser test fails on its first keyword. What setup would have avoided this?

 A virtual environment per project with pinned versions in `requirements.txt`, and `rfbrowser init` rerun on every upgrade Installing the Browser library with `sudo` Switching to SeleniumLibrary Running `npx playwright install` before each run

Pinned versions in a per-project environment make upgrades deliberate, and the Browser library's Node side must be cleaned and initialised again after every upgrade. The library does not use a separately installed Playwright.

3. After clicking "Save", a SeleniumLibrary test checks `Page Should Contain Saved`. It passes on your laptop and fails about one run in five in CI. What is the right fix?

 `Sleep 5s` before the check Raise the SeleniumLibrary `timeout` on import Rerun failed tests automatically `Wait Until Page Contains Saved`

`Should` keywords check once, so the library timeout does not affect them. The `Wait Until` variant retries until the text appears and finishes as soon as it does. A sleep only guesses, and reruns hide the problem.

4. Ten test files each contain the same three lines that log in with locators. The login form's markup changes. What structure would have made this a one-line fix?

 Putting all tests into one big file A `Log In As` user keyword in a `login.resource` file that every test imports Storing the locators in environment variables Using XPath locators everywhere

A user keyword in a resource file keeps the how in one place; tests only say what they do. One big file still repeats the steps, and the locator type does not remove the duplication.

5. The suite should run on Chrome locally and on Safari on TestingBot in CI, without editing any file. Which mechanism does that?

 Two copies of the suite, one per browser An `IF` on the machine's hostname in every test Defaults in the Variables section, overridden with `--variable GRID:True --variable BROWSER:safari --variable PLATFORM:SEQUOIA` in CI A different `requirements.txt` in CI

Command-line variables override those defined in files, so the same suite runs anywhere and the choice lives in the command. Copies drift apart, and hostname checks spread environment logic through the tests.

6. All tests pass in Robot's report, but in the TestingBot dashboard none of the sessions shows passed or failed. What is missing?

 A teardown step that sends the result, such as `Execute Javascript tb:test-result=passed`, before the browser closes A `build` name in `tb:options` The `--xunit` option A TestingBot Tunnel

The grid only sees browser commands, never your assertions, so the result has to be reported. The build name only groups sessions; xunit output is for CI; the tunnel is for private sites.

7. A Browser library suite builds the TestingBot capabilities with `&{tb}= Create Dictionary key=%{TB_KEY} secret=%{TB_SECRET}`. The tests pass. What is the problem?

 `Create Dictionary` cannot read environment variables TestingBot rejects capabilities built in Robot syntax There is none, as long as the secret is not in the repository The assignment is logged, so the secret ends up in `output.xml` and `log.html`, which CI uploads as artifacts

Robot Framework logs variable assignments at the default log level. Building the capabilities and connecting inside a Python keyword keeps the secret out of every result file.

8. Twelve rows of a templated login test cover invalid inputs. One row's expected value should be an empty string, but the test fails with "expected 3 arguments, got 2". What fixes it?

 Leave more spaces in the empty column Write `${EMPTY}` in that cell Convert the template to a FOR loop Remove the column header line

Cells are separated by runs of spaces, so an empty cell disappears no matter how many spaces you leave. `${EMPTY}` passes an explicit empty string.

9. Your TestingBot plan allows 4 parallel sessions. A colleague sets `pabot --processes 16` in CI to finish faster. What happens?

 The suite finishes four times faster Pabot reduces the processes to 4 automatically At most 4 sessions run at once; the others wait in TestingBot's queue, so the run is not faster and can hit connection timeouts TestingBot raises the limit for that build

The plan's parallel limit decides how many browsers run. Extra processes only queue, and a queued Browser library connection still counts against its connect timeout. Match `--processes` to the plan.

10. The GitHub Actions job fails on a Robot test, but the uploaded results artifact is missing. Which step is wrong?

 The upload step lacks `if: always()`, so it is skipped after the failing test step `robot` only writes `log.html` when all tests pass `TB_BUILD` was not set `rfbrowser init --skip-browsers` deletes the results

GitHub Actions skips later steps after a failure unless they opt in. Robot always writes the log and report; the upload must run regardless of the result.

Check answers

## Where to go next[#](https://testingbot.com#where-to-go-next)

- Take the **TestingBot Robot Framework certification** : an exam on the topics of this course, plus a practical task in which your suite runs on the TestingBot grid in a build named `certificate-robot-framework`.
- Testing native apps? The [Appium and Robot Framework guide](https://testingbot.com/support/app-automate/appium/robotframework) uses the same structure with AppiumLibrary, and the [mobile app testing course](https://testingbot.com/resources/courses/mobile-app-testing) covers the strategy.
- The [page object model](https://testingbot.com/resources/courses/page-object-model) and [flaky tests](https://testingbot.com/resources/courses/flaky-tests) courses go deeper into the two topics that decide whether a suite stays maintainable.

[Previous · Chapter 9 Robot Framework reports, CI and test status on TestingBot](https://testingbot.com/resources/courses/robot-framework/reports-ci-and-test-status)
## You finished Robot Framework Tutorial for Web Testing

Put what you learned into practice. Run your tests on 6100+ real browsers and physical iOS and Android devices.

[Start free trial](https://testingbot.com/users/sign_up) [See pricing](https://testingbot.com/pricing) [Browse other courses](https://testingbot.com/resources/courses)

## TestingBot Robot Framework Certification

Turn this course into a free, resume-worthy credential: pass the exam, run the course suite on TestingBot, and get a verifiable certificate for your LinkedIn profile.

[How it works](https://testingbot.com/resources/courses/robot-framework/certification)
