Checkpoint Lab — Collections, String, DateTime, OperatingSystem, Process, and XML Libraries

1. Checkpoint charter

Your team receives a synthetic XML artifact manifest and a short text note. The Robot task must normalize component data, attach a UTC observation time, write only to a unique temporary workspace, launch a local verifier, inspect its rc/stdout/stderr, query XML fields, produce a summary text file, and clean the workspace. Robot result artifacts must remain outside the scratch directory.

2. Predict before execution

3. Checkpoint files

rf08-checkpoint/
├── suites/
│   └── checkpoint.robot
├── fixtures/
│   └── manifest.xml
└── evidence/

<manifest>
  <artifact id="RF08-001">
    <name>synthetic-package</name>
    <count>2</count>
  </artifact>
</manifest>

4. Implement the checkpoint suite

*** Settings ***
Library    Collections
Library    String
Library    DateTime
Library    OperatingSystem
Library    Process
Library    XML

Suite Setup       Create Checkpoint Workspace
Suite Teardown    Remove Checkpoint Workspace

*** Variables ***
${RUN_ID}       checkpoint-001
${PYTHON}       python
${WORKSPACE}    ${TEMPDIR}/rf08-checkpoint-${RUN_ID}
${MANIFEST}     ${CURDIR}/../fixtures/manifest.xml

*** Test Cases ***
Build Evidence Summary
    ${original}=     Create List    api    worker
    ${expected}=     Create List    api    worker
    ${working}=      Copy List    ${original}
    Append To List    ${working}    verifier
    Lists Should Be Equal    ${original}    ${expected}

    ${joined}=       Catenate    SEPARATOR=|    @{working}
    ${joined}=       Convert To Lower Case    ${joined}
    Should Be Equal    ${joined}    api|worker|verifier

    ${observed}=     Get Current Date    time_zone=UTC    result_format=%Y-%m-%dT%H:%M:%S
    ${observed}=     Catenate    SEPARATOR=    ${observed}    Z

    ${root}=         Parse XML    ${MANIFEST}
    ${name}=         Get Element Text    ${root}    artifact/name
    ${count}=        Get Element Text    ${root}    artifact/count
    ${artifact_id}=  Get Element Attribute    ${root}    id    xpath=artifact
    Should Be Equal    ${name}    synthetic-package
    Should Be Equal    ${count}    2
    Should Be Equal    ${artifact_id}    RF08-001

    ${proc}=         Run Process
    ...    ${PYTHON}
    ...    -c
    ...    import sys; print("artifact-ok"); print("no-errors", file=sys.stderr)
    ...    timeout=10 seconds
    Should Be Equal As Integers    ${proc.rc}    0
    Should Be Equal    ${proc.stdout}    artifact-ok
    Should Be Equal    ${proc.stderr}    no-errors

    ${summary}=      Join Path    ${WORKSPACE}    summary.txt
    Create File      ${summary}    id=${artifact_id}\nname=${name}\ncomponents=${joined}\nobserved=${observed}\nrc=${proc.rc}\n
    File Should Exist    ${summary}
    ${saved}=         Get File    ${summary}    encoding=UTF-8
    Should Contain    ${saved}    id=RF08-001
    Should Contain    ${saved}    rc=0

    ${items}=         List Directory    ${WORKSPACE}
    List Should Contain Value    ${items}    summary.txt

*** Keywords ***
Create Checkpoint Workspace
    Guard Checkpoint Path
    Directory Should Not Exist    ${WORKSPACE}
    Create Directory    ${WORKSPACE}
    Directory Should Exist    ${WORKSPACE}

Remove Checkpoint Workspace
    Guard Checkpoint Path
    Remove Directory    ${WORKSPACE}    recursive=True
    Directory Should Not Exist    ${WORKSPACE}

Guard Checkpoint Path
    ${candidate}=    Normalize Path    ${WORKSPACE}    case_normalize=True
    ${temp}=         Normalize Path    ${TEMPDIR}    case_normalize=True
    Should Start With    ${candidate}    ${temp}${/}
    Should Contain       ${candidate}    rf08-checkpoint-

5. Preflight and clean run

python --version
robot --version
robot --dryrun --outputdir evidence/dryrun suites/checkpoint.robot
robot --variable RUN_ID:clean-001 --variable PYTHON:python --outputdir evidence/clean suites/checkpoint.robot

After the clean run, confirm that evidence/clean/ still contains Robot artifacts but ${TEMPDIR}/rf08-checkpoint-clean-001 no longer exists.

6. Controlled failure injection

Copy the suite to checkpoint_broken.robot. Change the Python child to import sys; print("artifact-bad"); sys.exit(7) and keep the assertion ${proc.rc} == 0. Run into a separate evidence directory.

robot --variable RUN_ID:fail-001 --outputdir evidence/failure suites/checkpoint_broken.robot

Expected: FAIL with preserved process evidence. Teardown should still remove only the guarded workspace. Do not immediately rerun over evidence/failure; inspect log.html and output.xml first.

7. Diagnose the failure without hiding it

1. Confirm Robot/Python versions and executed file.
2. Find the Run Process keyword in log.html.
3. Confirm the child produced rc=7 and expected synthetic output.
4. Confirm the assertion—not parsing, XML, or cleanup—caused the failure.
5. Confirm teardown still proved workspace absence.
6. Restore the child to exit 0 and run into evidence/repaired.

Do not wrap the failed process assertion in Run Keyword And Ignore Error or add retries. The injected failure is deterministic and should remain visible.

8. Evidence packet

9. Final verification checklist

• All six standard libraries are imported explicitly and each is used for its own capability.
• No OperatingSystem deprecated process-running keyword is used.
• No shell command is built by concatenating untrusted data.
• Scratch state has a unique run ID and normalized deletion guard.
• Mutable data is copied before intentional test-local mutation.
• Text encoding and UTC timestamp convention are explicit.
• Process rc/stdout/stderr are asserted separately.
• XML fields are queried structurally.
• First-failure evidence is preserved.
• Cleanup removes only the lab-owned workspace.

10. Production operating model added by Chapter 08

Chapter 08 adds a concrete side-effect discipline to the Robot Framework operating model: every standard-library capability has an owner, every mutable/external state change is bounded, process commands and outputs are structured, path/time/encoding conventions are explicit, and evidence survives cleanup. These are prerequisites for the lifecycle controls in Chapter 09, where setup, teardown, tags, timeouts, and suite-level execution policy become first-class design concerns.

11. Knowledge check

12. Checkpoint complete

You can now use Robot Framework’s standard libraries without blurring in-memory data, host filesystem state, child processes, XML models, and Robot result evidence. The chapter’s core production rule is simple: prefer explicit capability boundaries, verify every side effect, and clean only what the run owns.

Further reading

• Robot Framework 7.4.2 Collections — list/dictionary mutation, copying, comparison, and current type-conversion behavior.
• Robot Framework 7.4.2 String — text/bytes transformation and encoding-related keywords.
• Robot Framework 7.4.2 DateTime — timestamps, time intervals, conversion, LOCAL/UTC handling, and result formats.
• Robot Framework 7.4.2 OperatingSystem — portable file/directory/environment operations and deprecated process-running keywords.
• Robot Framework 7.4.2 Process — structured process invocation, result objects, output redirection, timeouts, and cleanup.
• Robot Framework 7.4.2 XML — parsing, XPath-style element lookup, verification, mutation, and explicit save semantics.
• Robot Framework 7.4.2 release — stable release baseline used in these lessons.