testingbotclient 0.2.0

Python client library for the TestingBot REST API.

testingbotclient

Python client for the TestingBot REST API

Install

pip install testingbotclient

TestingBot

TestingBot allows you to run Selenium tests in the cloud. With access to over +2600 different browser/device combinations, you can run your browser and mobile tests in parallel on the TestingBot Grid.

Getting Started

import testingbotclient

tb = testingbotclient.TestingBotClient('key', 'secret')

Credentials can also be supplied via the TESTINGBOT_KEY / TESTINGBOT_SECRET (or TB_KEY / TB_SECRET) environment variables, or a ~/.testingbot file containing key:secret — in which case you can construct the client with no arguments:

tb = testingbotclient.TestingBotClient()

An optional request timeout (seconds, default 60) can be set; raise it for large Storage uploads. Transient failures (429 / 5xx) are retried automatically on idempotent requests — tune or disable with max_retries (default 3):

tb = testingbotclient.TestingBotClient('key', 'secret', timeout=120, max_retries=5)

The client pools connections via a requests.Session; use it as a context manager to close that session deterministically:

with testingbotclient.TestingBotClient('key', 'secret') as tb:
    tb.tests.get_tests()

Every API method raises testingbotclient.TestingBotException on a non-2xx response. The exception carries the failing .response (with credentials stripped from it):

try:
    tb.tests.get_test('does-not-exist')
except testingbotclient.TestingBotException as e:
    print(e.response.status_code)

Use paginate to iterate over every item of a paginated list endpoint without managing offsets yourself:

for build in testingbotclient.paginate(tb.build.get_builds):
    print(build)

API reference: https://testingbot.com/support/api

Tests — tb.tests

# List tests (filters are all optional)
tb.tests.get_tests(offset=0, limit=10, since=None, browser_id=None,
                   group=None, build=None, skip_fields=None)
tb.tests.get_test_ids()
tb.tests.get_test(sessionId, skip_fields=None)

# Update a test's metadata after running it
tb.tests.update_test(sessionId, name=None, passed=None,
                     status_message=None, build=None)

tb.tests.stop_test(sessionId)
tb.tests.delete_test(sessionId)

# Create a record for a manual / external test result
tb.tests.create_test(name, success=None, status_message=None,
                     extra=None, build=None)

Builds — tb.build

tb.build.get_builds(offset=0, limit=10)
tb.build.get_tests_for_build(buildId)
tb.build.delete_build(buildId)

Storage — tb.storage

Upload app binaries (.apk / .ipa) and reference them later via the returned tb://<appkey> URL.

tb.storage.upload_local_file(localFilePath)
tb.storage.upload_remote_file(remoteUrl)

# Replace the binary behind an existing app_url (the app_url stays the same)
tb.storage.replace_local_file(app_url, localFilePath)
tb.storage.replace_remote_file(app_url, remoteUrl)

tb.storage.get_stored_file(app_url)
tb.storage.get_stored_files(offset=0, limit=10)
tb.storage.remove_file(app_url)

Browsers & devices — tb.information

tb.information.get_browsers(type=None)          # type: 'webdriver' | 'rc'
tb.information.get_devices(platform=None)        # platform: 'android' | 'ios' | 'real_android' | 'real_ios'
tb.information.get_available_devices()
tb.information.get_device(deviceId)

Screenshots — tb.screenshots

Capture a URL across multiple browsers.

batch = tb.screenshots.take_screenshots(
    url, resolution, browsers,        # browsers: list of browser_id values
    wait_time=0, full_page=None, callback_url=None)
tb.screenshots.get_screenshots(offset=0, limit=10)
tb.screenshots.get_screenshot(screenshotId, exclude_ids=None)

Codeless tests — tb.lab

Create, schedule, and run no-code (recorded) tests. trigger / trigger_all return a job_id you poll with tb.jobs.

tb.lab.get_tests(offset=0, limit=10)
tb.lab.get_test(testId)

# Create from a target URL, or import a Selenium IDE .side export
tb.lab.create_test(name=None, url=None, cron=None, screenshot=None, video=None,
                   idletimeout=None, screenresolution=None, ai_prompt=None, file=None)
tb.lab.update_test(testId, name=None, url=None, cron=None, enabled=None)
tb.lab.delete_test(testId)

tb.lab.trigger(testId, url=None)
tb.lab.trigger_all(url=None)

tb.lab.get_steps(testId, offset=0, limit=10)
tb.lab.set_steps(testId, steps)          # list of {order, cmd, locator, value}

tb.lab.schedule(testId, type, day=None, hour=None, cron_format=None)  # type: once|daily|weekly|custom
tb.lab.stop(testId, browser_id=None)

tb.lab.add_alert(testId, kind, level, content)   # kind: EMAIL|API|SMS, level: IMMEDIATELY|DAILY
tb.lab.update_alert(testId, kind=None, level=None, content=None)
tb.lab.add_report(testId, email, cron=None)
tb.lab.update_report(testId, email=None, cron=None)

tb.lab.get_browsers(testId)
tb.lab.set_browsers(testId, browser_ids)  # list or comma-separated string

Codeless suites — tb.labsuites

Group Codeless tests so they can be triggered and reported on together.

tb.labsuites.get_suites(offset=0, limit=10)
tb.labsuites.get_suite(suiteId)
tb.labsuites.create_suite(name, cron=None, screenshot=None, video=None,
                          idletimeout=None, screenresolution=None)
tb.labsuites.delete_suite(suiteId)
tb.labsuites.trigger(suiteId)            # returns a job_id

tb.labsuites.get_tests(suiteId, offset=0, limit=10)
tb.labsuites.add_tests(suiteId, test_ids)     # list or comma-separated string
tb.labsuites.remove_test(suiteId, testId)

tb.labsuites.get_browsers(suiteId)
tb.labsuites.set_browsers(suiteId, browser_ids)

Jobs — tb.jobs

Poll asynchronous jobs returned by Codeless triggers.

job = tb.lab.trigger(123)
tb.jobs.get_job(job['job_id'])
tb.jobs.wait_for_job(job['job_id'], timeout=600, interval=5)  # blocks until FINISHED

Tunnels — tb.tunnel

tb.tunnel.get_tunnels()
tb.tunnel.delete_tunnel(tunnelId)

Team management — tb.team

tb.team.get_concurrency()
tb.team.get_users(offset=0, limit=10)
tb.team.get_user(userId)
tb.team.create_user(email, password, first_name=None, last_name=None,
                    concurrency=None, concurrency_physical=None)
tb.team.update_user(userId, first_name=None, last_name=None, email=None,
                    password=None, credits=None, device_credits=None,
                    concurrency=None, concurrency_physical=None)
tb.team.get_client_key(userId)
tb.team.reset_keys(userId)

Configuration — tb.configuration

tb.configuration.get_ip_ranges()   # TestingBot IPs for firewall whitelisting

User — tb.user

tb.user.get_user_information()
tb.user.update_user_information(userInformation)

Sharing

Calculate the authentication hash needed to share a test. https://testingbot.com/support/other/sharing

tb.get_share_link(sessionId)

Test

Unit tests are mocked and need no credentials:

python -m unittest tests.test_unit

The live integration tests hit the real API and require TB_KEY and TB_SECRET:

python -m unittest tests.test_client

More documentation

Check out the TestingBot REST API for more information.