def __init__(self):
self._secrets = Secrets()
self._key = None
listener = RobotLogListener()
listener.register_protected_keywords(
["RPA.Crypto.generate_key", "RPA.Crypto.use_encryption_key"]
)
def get_wicksly_info(tracking_number):
secrets = Secrets()
USER_NAME = secrets.get_secret("credentials")["PLATFORM_USERNAME"]
PASSWORD = secrets.get_secret("credentials")["PLATFORM_PASS"]
with sync_playwright() as playwright:
browser = playwright.chromium.launch(headless=False)
wicksly_context = browser.newContext()
w_page = wicksly_context.newPage()
w_page.goto(os.environ.get('PLATFORM_URL'))
w_page.fill('#id_username', USER_NAME)
w_page.fill('#id_password', PASSWORD)
with w_page.expect_navigation():
w_page.click('input[type=submit]')
w_page.goto(os.environ.get('PLATFORM_URL'))
w_page.fill('#searchbar', tracking_number)
with w_page.expect_navigation():
w_page.click('text=Search')
w_page.querySelectorAll('table#result_list tbody tr a')[0].click()
street = w_page.getAttribute('#id_street1', 'value')
city = w_page.getAttribute('#id_city', 'value')
state = w_page.getAttribute('#id_state', 'value')
postal_code = w_page.getAttribute('#id_postal_code', 'value')
return {
'street': street,
'city': city,
'state': state,
'postal_code': postal_code
}
def _init_client(
self,
service_name: str,
aws_key_id: str = None,
aws_key: str = None,
region: str = None,
use_robocloud_vault: bool = False,
):
if region is None:
region = self.region
if use_robocloud_vault:
vault = Secrets()
vault_items = vault.get_secret(self.robocloud_vault_name)
vault_items = {k.upper(): v for (k, v) in vault_items.items()}
aws_key_id = vault_items["AWS_KEY_ID"]
aws_key = vault_items["AWS_KEY"]
else:
if aws_key_id is None or aws_key_id.strip() == "":
aws_key_id = required_env("AWS_KEY_ID")
if aws_key is None or aws_key.strip() == "":
aws_key = required_env("AWS_KEY")
if (aws_key_id is None or aws_key_id.strip() == "" or aws_key is None
or aws_key.strip() == ""):
raise KeyError("AWS key ID and secret access key are required "
" to use AWS cloud service: %s" % service_name)
client = boto3.client(
service_name,
region_name=region,
aws_access_key_id=aws_key_id,
aws_secret_access_key=aws_key,
)
self._set_service(service_name, client)
def _set_subscription_key(self, service_name, use_robocloud_vault):
common_key = "AZURE_SUBSCRIPTION_KEY"
service_key = f"AZURE_{service_name.upper()}_KEY"
sub_key = None
if use_robocloud_vault:
vault = Secrets()
vault_items = vault.get_secret(self.robocloud_vault_name)
vault_items = {k.upper(): v for (k, v) in vault_items.items()}
if service_key in vault_items and vault_items[service_key].strip(
) != "":
sub_key = vault_items[service_key]
elif common_key in vault_items and vault_items[common_key].strip(
) != "":
sub_key = vault_items[common_key]
if sub_key is None:
raise KeyError(
"The 'robocloud_vault_name' is required to access "
"Robocloud Vault. Set them in library "
"init or with `set_robocloud_vault` keyword.")
else:
sub_key = os.getenv(service_key)
if sub_key is None or sub_key.strip() == "":
sub_key = os.getenv(common_key)
if sub_key is None or sub_key.strip() == "":
raise KeyError(
"Azure service key is required to use Azure Cloud "
"service: %s" % service_name)
self.services[service_name] = sub_key
def login(page):
page.goto(sales_navigator_login_url)
page.waitForLoadState('load')
secrets = Secrets()
USER_NAME = secrets.get_secret("credentials")["LINKEDIN_EMAIL"]
PASSWORD = secrets.get_secret("credentials")["LINKEDIN_PASSWORD"]
page.fill('input#username', USER_NAME)
page.fill('input#password', PASSWORD)
page.click('button[type=submit]')
def test_file_secret_manager(monkeypatch):
monkeypatch.setenv("RPA_SECRET_MANAGER",
"RPA.Robocloud.Secrets.FileSecrets")
monkeypatch.setenv("RPA_SECRET_FILE", "tests/resources/secrets.json")
from RPA.Robocloud.Secrets import Secrets
sm = Secrets()
assert sm.secretmanager == "RPA.Robocloud.Secrets.FileSecrets"
secrets = sm.get_secret("credentials")
assert secrets["sap"]["login"] == "robot"
assert secrets["sap"]["password"] == "secret"
assert secrets["google"]["apikey"] == "1234567890"
def _get_service_account_from_robocloud(self):
temp_filedesc = None
if self.robocloud_vault_name is None or self.robocloud_vault_secret_key is None:
raise KeyError(
"Both 'robocloud_vault_name' and 'robocloud_vault_secret_key' "
"are required to access Robocloud Vault. Set them in library "
"init or with `set_robocloud_vault` keyword."
)
vault = Secrets()
vault_items = vault.get_secret(self.robocloud_vault_name)
secret = json.loads(vault_items[self.robocloud_vault_secret_key].strip())
with tempfile.NamedTemporaryFile(mode="w", delete=False) as temp_filedesc:
json.dump(secret, temp_filedesc, ensure_ascii=False)
return temp_filedesc.name
def _init_with_robocloud(self, client_object, service_name):
temp_filedesc = None
if self.robocloud_vault_name is None or self.robocloud_vault_secret_key is None:
raise KeyError(
"Both 'robocloud_vault_name' and 'robocloud_vault_secret_key' "
"are required to access Robocloud Vault. Set them in library "
"init or with `set_robocloud_vault` keyword."
)
vault = Secrets()
try:
vault_items = vault.get_secret(self.robocloud_vault_name)
secret = json.loads(vault_items[self.robocloud_vault_secret_key].strip())
with tempfile.NamedTemporaryFile(mode="w", delete=False) as temp_filedesc:
json.dump(secret, temp_filedesc, ensure_ascii=False)
client = client_object.from_service_account_json(temp_filedesc.name)
self._set_service(service_name, client)
finally:
if temp_filedesc:
os.remove(temp_filedesc.name)
import os
from pathlib import Path
import shutil
import sys
from RPA.Archive import Archive
from RPA.Browser import Browser
from RPA.FileSystem import FileSystem
from RPA.PDF import PDF
from RPA.Robocloud.Secrets import Secrets
from RPA.Robocloud.Items import Items
archive = Archive()
browser = Browser()
pdf = PDF()
secretmanager = Secrets()
workitems = Items()
files = FileSystem()
output_dir = Path(".") / "output"
image_dir = output_dir / "images"
pdf_dir = output_dir / "pdfs"
def main():
"""Robot workflow actions."""
all_steps_done = False
try:
clear_previous_run() # this can be skipped
open_page()
log_in()
def test_secrets_adapter_invalid_baseclass(mock_env_default):
with pytest.raises(ValueError):
Secrets(default_adapter=InvalidBaseClass)
def test_secrets_adapter_missing_import(monkeypatch):
monkeypatch.setenv("RPA_SECRET_MANAGER", "RPA.AdapterNotExist")
with pytest.raises(ValueError):
Secrets()
def test_secrets_custom_adapter_get_secret(mock_env_default):
MockAdapter.value = "mock-secret"
library = Secrets(default_adapter=MockAdapter)
assert library.get_secret("mock-name") == "mock-secret"
assert MockAdapter.name == "mock-name"
def test_secrets_custom_adapter_arguments(mock_env_default):
library = Secrets("pos-value",
key="key-value",
default_adapter=MockAdapter)
library.get_secret("not-relevant") # Adapter created on first request
assert MockAdapter.args == (("pos-value", ), {"key": "key-value"})
def test_secrets_vault_missing_token(mock_env_default, mock_env_vault,
monkeypatch):
monkeypatch.delenv("RC_API_SECRET_TOKEN", raising=False)
library = Secrets()
with pytest.raises(KeyError):
_ = library.adapter
def test_secrets_vault_as_default(mock_env_default, mock_env_vault):
library = Secrets()
assert isinstance(library.adapter, RobocloudVault)
'''
Variables for Robot Framework goes here.
'''
import calendar
from datetime import date
from RPA.Robocloud.Secrets import Secrets
WEEK_DAY_NAME = calendar.day_name[date.today().weekday()]
secrets = Secrets()
GA_UCC_USERNAME = secrets.get_secret("ga_ucc_creds")["username"]
GA_UCC_PASSWORD = secrets.get_secret("ga_ucc_creds")["password"]
def test_not_existing_class_as_secret_manager(monkeypatch):
monkeypatch.setenv("RPA_SECRET_MANAGER", "RPA.NotExistingSecretManager")
from RPA.Robocloud.Secrets import Secrets
with pytest.raises(Exception):
Secrets()
def test_invalid_base_class_as_secret_manager(monkeypatch):
monkeypatch.setenv("RPA_SECRET_MANAGER", "RPA.Trollo")
from RPA.Robocloud.Secrets import Secrets
with pytest.raises(Exception):
Secrets()
def __init__(self):
super().__init__()
self.dbx = dropbox.Dropbox(
Secrets().get_secret("Dropbox")["ACCESS_TOKEN"])
def test_use_secret_manager_when_environment_is_not_set(monkeypatch):
monkeypatch.delenv("RPA_SECRET_MANAGER", raising=False)
from RPA.Robocloud.Secrets import Secrets
sm = Secrets()
assert sm.secretmanager == "RPA.Robocloud.Secrets.RobocloudVault"
def get_and_display_secrets(credential: str):
secrets = Secrets()
user_details = secrets.get_secret(credential)["username"]
print(user_details)
