robot framework: Reuse existing Browser Window between Tests

A selenium driver instance has two properties characterizing its connection to a selenium webdriver - a connection url, and session id. By setting those to the values of an already running one, you effectively "hijack" it, and can use freely.

Disclaimer - the solution uses internal SE structures, so can break on newer versions. Also, as you are connecting to the running webdriver as to aRemote one, you cannot close it even if you want to - thus this can lead to resources leakage on the machine that it runs on; e.g. that webdriver has to be eventually terminated manually by a task manager.

So first things first - you have a running browser instance, and you need to get its properties for future connections. They are 2 - driver.command_executor._url, and driver.session_id where driver is the object name of the running instance. This python code will do just that:

from robot.libraries.BuiltIn import BuiltIn

def return_driver_props()
    seLib = BuiltIn().get_library_instance('SeleniumLibrary')

    # the driver is instantiated in the SeleniumLibrary, but not provided publicly, thus accessing it through this py code 
    remote_url = seLib.driver.command_executor._url  # for local instance, this is a value in the form 'http://localhost:57856'
    session_id = seLib.driver.session_id

    return remote_url, session_id

Importing that file as a Library, by calling the function/method you'll have the 2 props:

${conn_url}  ${session_id}=    Return Driver Props
# and do whatever is needed to make them known - log, store in a file, DB, etc.

Now in the second run that needs to reattach, and with the 2 values in hand, you just use the keyword Open Browser and specify a remote connection:

 Open Browser    about:about     remote_url=${that_known_url}   browser=${the_used_browser_type} # the last args - chrome|firefox|edge - whatever you're connecting two

The tricky part - the moment you connect to a remote server, selenium automatically starts a new session - which is a second browser instance (this started somewhere around selenium3, though I'm not sure on the exact timing). E.g. if you start using it right now - that is not the browser you wanted, but a brand new. That's also the reason why I gave as target address "about:about" - so it loads a dummy page, very fast.

Two things must happen at this point - a) you have to get rid of the "dummy" SE session, and b) switch to the previous one:

def set_driver_session_id(sesion_id):
    """ Sets the sessoin_id of the current driver insance to the provided one. """
    seLib = BuiltIn().get_library_instance('SeleniumLibrary')

    if seLib.driver.session_id != sesion_id:  # this is pretty much guaranteed to be the case
        seLib.driver.close()  # this closes the session's window
        seLib.driver.quit()  # for remote connections (like ours), this deletes the session, but doesn't stop the SE

    # set to the session that's already running
    seLib.driver.session_id = sesion_id

This function/keyword is called with the known session id:

Set Driver Session ID    ${session_id}

,and voilà, you are now in control of the previous browser, with its full state - the url it was at, cookies, localStorage, etc.

I'm leaving as an exercise to the reader how to automatically pass the url and the session id.
What I myself am doing is storing them in a file in a temp folder after running the first piece, and reading from there in the follow-up runs, with some error handling around it - missing or bad file, the connection cannot happen, and so on, with fallbacks to new instance creation.

Actually it is absolute possible to do however you have to organise your tests in testsuites testsuites/ __init__.robot test1.robot test2.robot test3.robot

in __init__.robot you have to open browser in suite setup and destroy it in suite teardown f.e.

*** Settings ***
Suite Setup   Open Browser
Suite Teardown    Close Browser

and run tests pybot ./testsuites

I don't know how effcient it is but I needed the same process and I used code like this to complete this...

open browser  ${HOMEPAGE}  ${BROWSER}
#opens the browser to the homepage using the browser of my choice
maximize browser window
#maximizes the window
(DOES STUFF)
#completes some processes
select window  title=calendar
#selects the window with the name calendar
(DOES MORE STUFF)

This worked for me, try it out. If you need any information on 'select window' look here: http://rtomac.github.io/robotframework-selenium2library/doc/Selenium2Library.html#Select%20Window

Or you can always try

switch browser  1

I'm new to robotframework, but I hope this helped.

There's an open issue for new functionality to re-use existing browser session. There are some workaround mentions and custom code modifications that seem to achieve this.

In my case, I was setting off warning emails from the target website, about logging in from a new device, every time I logged in during testing. Instead, I wanted to log in a single time and then resume the same (authenticated) browser session during subsequent runs.

To do this, the key is that you need to point the webdriver to the same user data directory so that subsequent runs can resume the browser session. For my needs, I created a local directory called user-data.

I then defined:

Open Browser Profiled
   [Arguments]    ${url}
   ${options}=    Evaluate    sys.modules['selenium.webdriver'].ChromeOptions()    sys, selenium.webdriver
   Call Method    ${options}    add_argument    --user-data-dir\=${./user-data}
   Create WebDriver    Chrome    chrome_options=${options}
   Go To    ${url}

And:

Log In
    Open Browser Profiled   ${LOGIN_URL}
    Input Text              email         ${EMAIL}
    Input Password          password      ${password}
    Click Button            Log in

Then, on the first execution, I run:

Do The Things
    Log In
    # Open Browser Profiled   ${AFTER_LOGIN_URL}
    ...

And, on subsequent executions:

Do The Things
    # Log In
    Open Browser Profiled   ${AFTER_LOGIN_URL}
    ...

For extra points, you can also make this more dynamic and detect whether a log in is needed so that you do not have to modify the script, e.g.:

Do The Things
    Log In or Open
    ...

Log In or Open
    Open Browser Profiled   ${AFTER_LOGIN_URL}
    Sleep   2   # Wait for page to settle
    ${logged_in}=    Run Keyword And Return Status   Title Should Be   ${AFTER_LOGIN_TITLE}
    Run Keyword Unless    ${logged_in}    Log In

Special thanks to this post, which outlined the method I used to resume the browser session.