Saravanan666/pypi-org huggingface dataset:
Package: robotframework-rammbock
IntroductionInstallation instructionsPrecondiditonsInstallationExamplesDocumentationIntroductionGeneric network protocol test library for Robot Framework, which offers an easy way to specify network packets and inspect the results of sent / received packets. Library offers Domain Specific Language for packet specification.Downloads are available athttps://pypi.python.org/pypi/robotframework-rammbockInstallation instructionsPrecondiditonsYou need to have Robot Framework installed as a precondition.InstallationWith PIP Installer:pip install robotframework-rammbockWith Setup.py Download and extract .zip or .tar.gz. Execute command in extracted folder:python setup.py installExamplesWe have examples from following protocols:GTPv2DiameterDNSExamples can be found from our acceptance test cases:https://github.com/robotframework/Rammbock/tree/master/atestDocumentationSee the userguide athttps://github.com/robotframework/Rammbock/wiki/RammbockUserGuideSee keyword documentation athttps://robotframework.github.com/Rammbock/index.html
Package: robotframework-rammbock-py3
IntroductionInstallation instructionsPrecondiditonsInstallationExamplesDocumentationIntroductionGeneric network protocol test library for Robot Framework, which offers an easy way to specify network packets and inspect the results of sent / received packets. Library offers Domain Specific Language for packet specification.This is a version of robotframework-rammbock updated for better Python 3 support.Downloads are available athttps://pypi.python.org/pypi/robotframework-rammbock-py3Installation instructionsPrecondiditonsYou need to have Robot Framework installed as a precondition.InstallationWith PIP Installer:pip install robotframework-rammbock-py3With Setup.py Download and extract .zip or .tar.gz. Execute command in extracted folder:python setup.py installExamplesWe have examples from following protocols:GTPv2DiameterDNSExamples can be found from our acceptance test cases:https://github.com/peterservice-rnd/Rammbock/tree/master/atestDocumentationSee the userguide athttps://github.com/robotframework/Rammbock/wiki/RammbockUserGuideSee keyword documentation athttps://robotframework.github.com/Rammbock/index.html
Package: robotframework-randomlibrary
This repository details a collection ofrandom utilities that can be used within tests written using RobotFramework. As of this moment, there is no detailed documentation yet on the modules and keywords available, but the expectation is to fix this over time.Installation and Usagepip install robotframework-randomlibraryshould do the trick!ContributorsArun Venkatram (https://github.com/svyzz)Raghavendra Kumar (https://github.com/dotIN)
Package: robotframework-react
IntroductionReactLibrary is a Robot Framework library for React. It currently provides a single ‘Wait for React’ keyword that makes sure your React application has been fully loaded and can be interacted with.InstallationInstall robotframework-react with pip:$ pip install robotframework-reactUsageIn order to write your first robot test, make sure that you include SeleniumLibrary and ReactLibrary. Create a test.robot file with the following content:*** Settings ***

Library         SeleniumLibrary  timeout=10  implicit_wait=0
Library         React Library
Suite Setup     Open browser  https://airbnb.com  chrome
Suite Teardown  Close browser


*** Test Cases ***

Scenario: Wait for react
  Go To  https://airbnb.com
  Wait for react
  Page Should Contain  Airbnb Book unique homes

Scenario: Wait for react with reducer
  Go To  https://airbnb.com
  Wait for react  reducer=headlines
  Page Should Contain  Airbnb Book unique homesKeywordsrobotframework-react currently only provides a single keyword “Wait for React”.
The keyword makes sure the React app is fully loaded.Plain React ExampleWhen used without any parameter, “Wait for react” expects the React app to
set a global variable named “window.appStatus” to true when the app is fully
loaded.To make this work with your React app, add a global window.appStatus to your
index.js:window.appStatus = false
const updateStatus = () => {
  window.appStatus = true
}

ReactDOM.render(<App updateStatus={updateStatus} />, document.getElementById('root'));Add an “isLoading” state to your App and update it on componentDidMount and componentDidUpdate (App.js):class App extends Component {
  state = {
    isLoading: true,
  }

  componentDidMount() {
    wait(2000).then(() => {
      this.setState({ isLoading: false })
    })
  }

  componentDidUpdate() {
    if (!this.state.isLoading) {
      this.props.updateStatus()
    }
  }
  ...
}You can find a full working example here:https://github.com/kitconcept/robotframework-react/tree/master/tests/create-react-appRobot Test:https://github.com/kitconcept/robotframework-react/blob/master/tests/create-react-app/test.robotReduxWhen working with Redux, you have to pass the name of the reducer to the ‘Wait for React’ keyword:Wait for react  reducer=headlinesThe reducer should implement an “isFetching” attribute in the Redux state:const initialState = {
  isFetching: false,
  ...
};Instead of adding “isFetching”, you can also name the attribute whatever you want, and pass in the “stateName” parameter to the ‘Wait for react’ keyboard:Wait for react  reducer=headlines  stateName=isLoadingYou can find a full working example here:https://github.com/kitconcept/robotframework-react/tree/master/tests/create-react-app-with-reduxRobot Test with Redux:https://github.com/kitconcept/robotframework-react/blob/master/tests/create-react-app-with-redux/test.robot1.0.0a2 (2018-07-10)Switch from robotframework-selenium2library to robotframework-seleniumlibrary.
[timo]Add a parameter called “stateName” to allow configurable attribute name so “isFetching” is not required for Redux functionality
[bxie1]1.0.0a1 (2018-03-08)Initial release.
[timo, davidrf]
Package: robotframework-redislibrary
RedisLibraryRedisLibraryis aRobot Frameworktest library which provides keywords for manipulating in-memory data stores inRedisRedisis an open-source software project that implements data structure servers. It is networked, in-memory, and stores keys with optional durability.You can add, get, update and delete your data from Redis. The keywords are implemented usingredis-pyUsageInstallrobotframework-redislibraryviapipcommandpipinstall-Urobotframework-redislibraryExample Test Case*** Settings ***LibraryRedisLibrary*** Test Cases ***TestRedisSample${redis_conn}=Connect To Redismyredis-dev.comport=6379${data}=Get From Redis${redis_conn}BARCODE|1234567Should Be Equal As Strings${data}TestExpectedData${obj_to_add}=Create Dictionaryname=testFullNameAppend To Redis${redis_conn}BARCOE|1234567${object_to_add}@{key_list}=Get All Match Keys${redis_conn}BARCODE*1000DocumentationFor the detail keyword documentation. Go to this following link:https://robotframework-thailand.github.io/robotframework-redislibrary/RedisLibrary.htmlHelp & IssuesMention me on Twitter@nottyo
Package: robotframework-remotetransfer
robotframework-remotetransferVery small keyword library to allow transfering log files like screenshots
between host running a robotframework and robotremoteserverUsage:Load remotetransfer library into python remote server and into robot framework.UseTransfer Fileskeyword to load files from output directory and save
the results into a dict variable.UseSave Filesto store those back into output directory.This works by providing a library prefix to the keyword do denote where files are
transfered from and save to, like this:*** Settings ***
Library       Remote    http://127.0.0.1:8270
Library       RemoteTransfer

*** Test Cases ***
Try Out Remote Transfer
  ${results}=   Remote.Transfer Files  *.png
  RemoteTransfer.Save Files  ${results}Library uses base64 encoding to transfer files over robot's rpc interface - so keep
that in mind - filetransfers can grow pretty large.
Package: robotframework-remotetransfer-sf
robotframework-remotetransferVery small keyword library to allow transfering log files like screenshots
between host running a robotframework and robotremoteserverUsage:Load remotetransfer library into python remote server and into robot framework.UseTransfer Fileskeyword to load files from output directory and save
the results into a dict variable.UseSave Filesto store those back into output directory.This works by providing a library prefix to the keyword do denote where files are
transfered from and save to, like this:*** Settings ***
Library       Remote    http://127.0.0.1:8270
Library       RemoteTransfer

*** Test Cases ***
Try Out Remote Transfer
  ${results}=   Remote.Transfer Files  *.png
  RemoteTransfer.Save Files  ${results}Library uses base64 encoding to transfer files over robot's rpc interface - so keep
that in mind - filetransfers can grow pretty large.
Package: robotframework-reportportal-ng
Short DescriptionRobot Framework listener module for integration with Report Portal.Installationpip install robotframework-reportportal-ngUsageThis listener requires specified robot framework context variables to be
set up. Some of them are required for execution and some are not.Parameters list:RP_UUID - unique id of user in Report Portal profile..
RP_ENDPOINT - <protocol><hostname>:<port> for connection with Report Portal.
              Example: http://reportportal.local:8080/
RP_LAUNCH - name of launch to be used in Report Portal.
RP_PROJECT - project name for new launches.
RP_LAUNCH_DOC - documentation of new launch.
RP_LAUNCH_TAGS - additional tags to mark new launch.ExampleExample command to run test using pabot with report portal listener.pybot--listenerreportportal_listener--escapequot:Q\--variableRP_ENDPOINT:http://reportportal.local:8080\--variableRP_UUID:73628339-c4cd-4319-ac5e-6984d3340a41\--variableRP_LAUNCH:"Demo Tests"\--variableRP_PROJECT:DEMO_USER_PERSONALtest_folderLicenseApache License 2.0
Package: robotframework-requests
🏠RequestsLibraryis aRobot Frameworklibrary
aimed to provide HTTP api testing functionalities by wrapping the well knownPython Requests Library.Install stable versionpipinstallrobotframework-requests🤖 Quick start*** Settings ***LibraryRequestsLibrary*** Test Cases ***Quick Get Request Test${response}=GEThttps://www.google.comQuick Get Request With Parameters Test${response}=GEThttps://www.google.com/searchparams=query=ciaoexpected_status=200Quick Get A JSON Body Test${response}=GEThttps://jsonplaceholder.typicode.com/posts/1Should Be Equal As Strings1${response.json()}[id]What's new in 0.9Sessionless keywords are now available, you can justGET,POST, etc.. no need to create a session anymore!${resp}=GEThttps://www.google.comStatus Should BeandRequest Should Be Successfullcan use the last response, no need to pass the response anymore!GEThttps://www.google.comStatus Should Be200What's new in 0.8New keywords structure:All requests keywords have been rewritten because of many not backward compatible changes
and to allow in the near future requests keywords without a session.
ExampleGet RequestbecomeGET On Sessionand soon there will be also justGETwhen a session is not needed.
Old keywords* Requestare now deprecated and will be removed in 1.0.0 version.Implicit assert on status code:* On Sessionkeywords automatically fail if an error status code is returned.expect_status=could be used to specify a status code (201,OK,Bad request)
oranyif you want to evaluate the response in any case.Closer to the original Requests library:New keywords have the same parameter orders and structure as the original.
Lot of pre-parsing / encoding has been removed to have a more accurate and unchanged behaviour.Cleaner project architecture:Main keywords file has been split with a more logic division to allow better and faster maintenance.🤖 More examples*** Settings ***LibraryCollectionsLibraryRequestsLibrarySuite SetupCreate Sessionjsonplaceholderhttps://jsonplaceholder.typicode.com*** Test Cases ***Get Request TestCreate Sessiongooglehttp://www.google.com${resp_google}=GET On Sessiongoogle/expected_status=200${resp_json}=GET On Sessionjsonplaceholder/posts/1Should Be Equal As Strings${resp_google.reason}OKDictionary Should Contain Value${resp_json.json()}sunt aut facere repellat providentPost Request Test&{data}=Create dictionarytitle=Robotframework requestsbody=This is a test!userId=1${resp}=POST On Sessionjsonplaceholder/postsjson=${data}expected_status=anythingStatus Should Be201${resp}📖 Keywords documentationRobotframework-requests offers a wide set of keywords which can be found in theKeywords documentation🔬 Test examplesYou can find many test examples inside theatestsfolder.🤝 Contributing ✍️Feel free to contribute and open an issue in order to discuss it. Before doing it take a look at thecontribution guidelines.📢 Get in touch with the community via slack and Users groupRobot Framework Slack #requests channelRobot Framework Users Group
Package: robotframework-requestschecker
Short DescriptionRobot Frameworklibrary for checking HTTP response status code, based onRequestslibrary.Installationpip install robotframework-requestscheckerDocumentationSee keyword documentation for robotframework-requestschecker library in
folderdocs.ExampleTest casesActionArgumentArgumentArgumentSimple TestRequestsLibrary.Create sessionAliashttp://www.example.com${response}=RequestsLibrary.Get requestAlias/RequestsChecker.Check Response Status${response}204LicenseApache License 2.0
Package: robotframework-requestslogger
Short DescriptionRobot Frameworklibrary for logging HTTP requests and responses, based onRequestslibrary.Installationpip install robotframework-requestsloggerDocumentationSee keyword documentation for robotframework-requestslogger library in
folderdocs.ExampleTest casesActionArgumentArgumentArgumentSimple TestRequestsLibrary.Create sessionAliashttp://www.example.com${response}=RequestsLibrary.Get requestAlias/RequestsLogger.Write log${response}LicenseApache License 2.0
Package: robotframework-requirements
Requirements checking library for Robot FrameworkIntroductionRobotframework-requirements is a library that verifies all packages in
requirements.txt are installed and correct version. If missing or incorrect
versions of packages are found, warning is shownUsageIt should be enough to add library to Settings part of your suite and it will
give warnings for incorrect requirements.*** Settings ***
    Library    RequirementsLibraryIn case you have requirements.txt in a different folder, you can give path to
file.*** Settings ***
    Library    RequirementsLibrary    ${CURDIR}/../requirements.txtIt is also possible to run library check during test run.*** Settings ***
    Library    RequirementsLibrary    ${CURDIR}/../requirements.txt

    *** Test Cases ***
    Test Requirements
        Check Libraries
        Check Libraries    ${CURDIR}/../requirements.txtSubmitting issuesBugs and enhancements are tracked in theissue tracker.Before submitting a new issue, it is always a good idea to check is the same bug
or enhancement already reported. If it is, please add your comments to the
existing issue instead of creating a new one.Coding styleCoding style is defined in.editorconfigfile. Configure your editor to use it.Code must pass checks from black, flake8, pylint and mypy. Markdown files must pass
pymarkdown checker.LicenseThis library is released under MIT license.
Package: robotframework-retryfailed
robotframework-retryfailedA listener to automatically retry tests or tasks based on tags.InstallationInstall with pip:pip install robotframework-retryfailedUsageAdd the listener to your robot execution, via command line arguments.
When your tests do fail and you have tagged them withtest:retry(2), it will retry the test 2 times.
Retry can be also set globally as a parameter to the listener.Attaching ListenerExample:robot --listener RetryFailed <your robot suite>

robot --listener RetryFailed:1 <robot suite>Second one will by default retry once every failing test.Tagging TestsExample:*** Test Cases ***
Test Case
    [Tags]    test:retry(2)
    Log    This test will be retried 2 times if it failsTagging tasks bytask:retry(3)should also work.
Package: robotframework-robosapiens
RoboSAPiens: SAP GUI Automation for HumansFully localized Robot Framework library for automating the SAP GUI using text locators.Available localizations:EnglishGermanRequirementsScripting must beenabled in the Application ServerScripting must beenabled in the SAP GUI clientInstallationpipinstallrobotframework-robosapiensUsageConsult theDocumentation.
Package: robotframework-robotmk
robotframework-robotmkThis is a small supplementary library forRobotmk, the Robot Framework integration project forCheckmk.Installationpip install robotframework-robotmkLinksKeyword Documentation:https://simonmeggle.github.io/robotframework-robotmk/Github:https://github.com/simonmeggle/robotframework-robotmkAuthor: Simon Megglesimon.meggle@elabit.deRobotmk:https://www.robotmk.orgCheckmk:https://checkmk.com
Package: robotframework-rosgazebolibrary
Robot Framework ROS Gazebo LibraryKeyword library for theRobot Frameworkfor accessingROSbased systems and theGazebo simulator.Copyright 2020-2022Fraunhofer FOKUSThe initial version of this software was developed at theFraunhofer Institute for Open Communication Systems (FOKUS).
Initial development was funded by the ITEA3 projecteXcellence in Variant Testing (XIVT).InstallationYou can install this library from thePython Package Indexas follows:pip install robotframework-rosgazebolibrarySee also theinstallation instructionsfor Robot Framework.DocumentationIn principle, the following command should create HTML documentation:python -m robot.libdoc src/RosGazeboLibrary docs/index.htmlUnfortunately, this does not work at the moment.
Feel free to create a pull request if you know how to fix this.LicenseThe Robot Framework Ros Gazebo Library is open source software provided under theApache License 2.0
Package: robotframework-rp-tools
robotframework-rp-toolsListener and visitor modules for integration with ReportPortalInstallationThe latest stable version of library is available on PyPI:pip install robotframework-rp-toolsUsageTo run these modules you need to set the following environment variables:REQUIRED:export RP_TOKEN="your_user_uuid"
export RP_ENDPOINT="your_reportportal_url"
export RP_LAUNCH="launch_name"
export RP_PROJECT="reportportal_project_name"NOT REQUIRED:export RP_LAUNCH_DOC="some_documentation_for_launch"
    - Description for the launch
export RP_LAUNCH_TAGS="RF Smoke"
    - Space-separated list of tags for the launch
export RP_LOG_BATCH_SIZE="10"
    - Default value is "20", affects size of async batch log requestsIf you need a listener:--listener robotframework_rp_tools.Listenerin case of visitor--prerebotmodifier robotframework_rp_tools.VisitorLicenseMIT License (see the LICENSE.txt file)
Package: robotframework-sapguilibrary
SapGui LibraryThis library is created to automate testing the SAP GUI desktop client using the Robot Framework. It uses the native Sap Gui Scripting engine to interact with the SAP GUI interface.InstallationSapGuiLibrary can be found on PyPI:https://pypi.org/project/robotframework-sapguilibrary.To install, simply use pip:pip install robotframework-sapguilibraryDependencies are automatically installed.Importing in Robot FrameworkAs soon as installation has succeeded, you can import the library in Robot Framework:*** Settings ***
Library  SapGuiLibraryUsageFirst of all be sure you've enabled the user_scripting option on the server. I haven't done this myself so I can't give you a proven example on how to do this. I've checked it on Google and it looks like you can change this using the RZ11 transaction.When de Scripting Engine is enabled, you have to start de Sap Logon Pad. Unfortunately the scripting engine doesn't enable you to start this so you have to use something like the Process or the AutoIT library. When the Sap Logon Pad is available, you use the 'Connect to session' keyword to attach to the session.Finding locatorsFinding the locators for the elements requires you to use an extra tool to identify these locators. To best tool for that is the SAP Scripting Tracker. More information about this tool can be found atthis blogpost on the SAP websiteIf you just want to download the tool followthis link. To tool Tracker.exe is the one you want to use.Tip: Finding an element within a Shell type component requires an extra step, because the Tracker will only show you the Shell identifier. You can find the identifier by using de recorder function and than perform the actions you want to automate. After saving the recording you can find the identifiers within the recorded script.Keyword documentationFor the keyword documentationgo here.
Package: robotframework-saucelabs
Robotframework - Sauce Labs PluginThis is a plugin for the SeleniumLibrary to help with using Sauce Labs.This library is aplugin extensionof the SeleniumLibrary. That means you can (in theory!) use all the keywords in the SeleniumLibraryin addition tothe keywords added here. The keywords added are specifically meant for use with Sauce Labs.InstallationYou can install this package usingpip:pipinstallrobotframework-saucelabsThis library is powered by the PythonSauce Bindingsto connect and use Sauce Labs.A requirement of using this library is toset environment variablesfor your Sauce username and access key.Note that you must have theSeleniumLibraryinstalled as well.ExamplesSince this library is a plugin for the SeleniumLibrary, you need to add this as a plugin where you define using the SeleniumLibrary:*** Settings ***
Library  SeleniumLibrary  plugins=SauceLabsAfter defining this plugin, you can then use SauceLabs keywords in addition to SeleniumLibrary keywords:*** Test Cases ***

Web Workflow Test
    # Use a SauceLabs keyword
    Start Latest Chrome On Sauce  https://www.saucedemo.com
    # Then you can use standard SeleniumLibrary keywords
    Input text  id:user-name  standard_user
    Input text  id:password  secret_sauce
    Click button  class:btn_action
    Page should contain element  id:shopping_cart_container
    # End with closing the session on Sauce
    [Teardown]  Stop Sauce Session  ${TEST_STATUS}Seethe acceptance testfor an example of usage, and the other tests for more examples.ContributionContributors welcome! We need keywords, and if you are a robot and Sauce Labs user, please open pull requests and/or issues as needed!
Package: robotframework-scpcompat
IntroductionSCPLibrary is aRobot Frameworktest
library for performing Secure Copy (SCP) operations over SSH. Unlike
the other SCPLibrary (‘robotframework-scplibrary’), this one works
hand in hand with the Robot SSHLibrary (hence
‘robotframework-scpcompat’).I wrote this because I was frustrated that the non-compatible
SCPLibrary overwrote some SSHLibrary keywords and managed connections
itself. I did consider changing the existing library, but that would
break it for existing users.To recap, the main differences are:Relies on the standard SSHLibrary to manage connectionsDownload FileandUpload Filekeywords use the currently
active SSH connection to transfer files to the remote hostDoes not conflict with any SSHLibrary keywordsCan even use an existing connection used for other SSH commandsIt is operating system independent, but has only been tested with
Python. Strictly speaking, the underlying ‘scp’ module is also pure
Python, so let me know if you have any luck with Jython or
IronPython.SSHLibrary is open source software licensed underGNU General Public
License v3.InstallationWhen installing SCPLibrary on UNIX-like machines with Python, the
easiest approach is usingpip:pip install robotframework-scpcompatNote while this library supports both Python 2 and 3, SSHLibrary does
not. So until SSHLibrary fixesissue #144it
doesn’t make sense to use Python 3. Hopefully though, once it’s
resolved this library should also work with Python 3.DocumentationThe library is self-documenting via docstrings; additionally you can
find an example robot script in this repository. You can run it
against any host with SSH password authentication:robot -v host:xxx -v user:xxx -v pass:xxx example.robotThescp module documentationis also helpful, as this library is basically a wrapper around it.For general information about using test libraries with Robot
Framework, seeRobot Framework User Guide.