async def test_open_jira_page(self):
from osbot_aws.apis.Secrets import Secrets
self.api = API_Browser(headless=False)
login_needed = False
self.secrets_id = 'GS_BOT_GS_JIRA'
(server, username, password) = Secrets(
self.secrets_id).value_from_json_string().values()
if login_needed:
Dev.pprint(server, username, password)
await self.api.open(server + '/login.jsp')
page = await self.api.page()
await page.type('#login-form-username', username)
await page.type('#login-form-password', password)
await page.click('#login-form-submit')
#await self.api.open(server + '/browse/GSP-95')
#page = await self.api.page()
#await self.api.js_execute("$('#show-more-links-link').click()")
#from time import sleep
#sleep(1)
await self.api.page_size(2000, 3000)
await self.api.screenshot(
file_screenshot='/tmp/tmp-jira-screenshot.png', full_page=True)
def __init__(self, web_page, headless=True):
self.web_page = web_page
self.title = 'browser view'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
class test_API_Browser(TestCase):
def setUp(self):
self.api = API_Browser(headless=False)
#@unittest.skip("bug: needs to load markdow page first")
@sync
async def test_js_eval(self):
text = "some_text"
text_base64 = base64.b64encode(text.encode()).decode()
assert await self.api.js_eval("btoa('{0}')".format(text)
) == text_base64
assert await self.api.js_eval("atob('{0}')".format(text_base64)
) == text
@sync
async def test_html(self):
await self.api.open('https://www.google.com')
html = await self.api.html()
assert len(html) > 100
@sync
async def test_open(self):
(headers, status, url,
browser) = await self.api.open('https://www.google.com')
assert headers['x-frame-options'] == 'SAMEORIGIN'
assert status == 200
assert url == 'https://www.google.com/'
@sync
async def test_page(self):
url = 'https://www.google.com/404'
await self.api.open(url)
page = await self.api.page()
assert page.url == url
@sync
async def test_screenshot(self):
await self.api.open('https://news.bbc.co.uk')
file_jpg = await self.api.screenshot()
assert Files.exists(file_jpg)
#exec_open(file_jpg)
@sync
@pytest.mark.skip("needs to run in Headless mode")
async def test_pdf(self):
# note: only works when headless = True . See https://github.com/puppeteer/puppeteer/issues/1829#issuecomment-657930419
await self.api.open('https://news.bbc.co.uk')
file_pdf = await self.api.pdf()
assert Files.exists(file_pdf)
exec_open(file_pdf)
def test_open_settings(self):
page = 'chrome://settings/help'
self.api.sync__open(page)
class Temp_Browser:
api_browser: API_Browser
browser: Chrome
def __init__(self, headless=True, auto_close=True, open_page=None):
self.headless = headless
self.auto_close = auto_close
self.open_page = open_page
self.temp_screenshot_file = '/tmp/temp_browser_screenshot.png'
def __enter__(self):
self.api_browser = API_Browser(headless=self.headless)
self.browser = self.api_browser.sync__browser()
if self.open_page:
self.api_browser.sync__open(self.open_page)
return self
def __exit__(self, exc_type, exc_val, exc_tb):
if self.auto_close is True:
self.api_browser.sync__close_browser(
) # todo see if this really only continues when the process process has terminated
def links(self):
return self.py_query().query('a').indexed_by_attribute(
'href', return_unique_list=True)
def screenshot(self, save_to=None):
if save_to is None:
save_to = self.temp_screenshot_file
return self.api_browser.sync__screenshot(file_screenshot=save_to)
def html(self):
return self.api_browser.sync__html_raw()
def open(self, url):
return self.api_browser.sync__open(url)
def open_google(self):
return self.open('https://www.google.com')
def page(self):
return self.api_browser.sync__page()
def url(self):
return self.api_browser.sync__url()
def py_query(self):
return Py_Query(self.html())
def set_auto_close(self, value):
self.auto_close = value
def run(event, context=None):
load_dependencies('syncer,requests,pyppeteer2,websocket-client')
from osbot_browser.browser.API_Browser import API_Browser
url = event.get('url')
#return url
# error in this line: Read-only file system: '/home/sbx_user1051
api_browser = API_Browser().sync__setup_browser()
# we don't get here
if url:
api_browser.sync__open(url)
return api_browser.sync__screenshot_base64()
class test_workflows_API_Browser(TestCase):
def setUp(self):
self.api = API_Browser(headless=False)
self.png_file = '/tmp/tmp-jira-screenshot.png'
def test_open_jira_slack(self):
#url = 'https://os-summit.slack.com/messages/DJ8UA0RFT/'
url = 'https://os-summit.slack.com/messages/CK475UCJY/'
self.api.sync__open(url)
email = '*****@*****.**'
password = "******"
js_code = """$('#email').val('{0}')
$('#password').val('{1}')
$('#signin_btn').click()
""".format(email, password)
self.api.sync__js_execute(js_code)
#await self.api.screenshot(file_screenshot=self.png_file)
@sync
async def test_open_jira_page(self):
from osbot_aws.apis.Secrets import Secrets
self.api = API_Browser(headless=False)
login_needed = False
self.secrets_id = 'GS_BOT_GS_JIRA'
(server, username, password) = Secrets(
self.secrets_id).value_from_json_string().values()
if login_needed:
Dev.pprint(server, username, password)
await self.api.open(server + '/login.jsp')
page = await self.api.page()
await page.type('#login-form-username', username)
await page.type('#login-form-password', password)
await page.click('#login-form-submit')
#await self.api.open(server + '/browse/GSP-95')
#page = await self.api.page()
#await self.api.js_execute("$('#show-more-links-link').click()")
#from time import sleep
#sleep(1)
await self.api.page_size(2000, 3000)
await self.api.screenshot(
file_screenshot='/tmp/tmp-jira-screenshot.png', full_page=True)
def __init__(self, headless=True):
self.web_page = '/vivagraph/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
def setup(self):
login_details = json.loads(Secrets(self.aws_secrets_id).value())
self.username = login_details.get('username')
self.password = login_details.get('password')
self.server_url = login_details.get('server_url')
if self._browser is None:
self._browser = API_Browser(headless=self.headless).sync__setup_browser()
return self._browser
def setup(self):
self.load_browser_dependencies()
from osbot_browser.browser.API_Browser import API_Browser
from osbot_browser.browser.Render_Page import Render_Page
self.api_browser = API_Browser(
headless=self.headless).sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root())
return self
def __init__(self, headless=True):
self.web_page = '/vivagraph/simple.html'
self.jira_icons = '/vivagraph/icons'
self.web_root = path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.browser_width = None
self.render_wait = None
self.web_server = None # Web_Server(self.web_root)
def __init__(self,
target_server,
headless=True,
api_browser=None,
path_screenshot=None,
user_agent=None):
self.api_browser = api_browser or API_Browser(headless=headless)
self.user_agent = user_agent or 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36'
self.path_screenshot = path_screenshot
self.target_server = target_server
def __init__(self):
self.web_page = '/datatables/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser().sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root)
self.table_width = '100%'
self.columns_defs = None
self.table_title = None
def __init__(self, headless=True):
self.web_page = '/gs/risk/risks-dashboard.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.headless = headless
self.api_browser = API_Browser(self.headless,
self.headless).sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root)
self.graph_name = None
self.jira_key = None
def __init__(self, headless=True):
self.web_page = '/vis-js/simple.html'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
chrome = Chrome().headless(headless)
self.api_browser = API_Browser(chrome.sync().browser())
self.render_page = Render_Page(api_browser=self.api_browser,
web_root=self.web_root)
self.bot_name = 'GS_Bot'
self.options = None
def __init__(self,
api_browser=None,
headless=True,
web_root=None,
web_server=None):
if web_server:
self.web_server = web_server
else:
self.web_server = Web_Server(web_root)
if api_browser:
self.api_browser = api_browser
else:
self.api_browser = API_Browser(headless=headless)
def setup(self):
if os.getenv('AWS_REGION'):
load_dependency('syncer')
load_dependency('requests')
#self.setup_AWS()
# else:
# self.setup_local()
from osbot_browser.browser.API_Browser import API_Browser
from osbot_browser.browser.Render_Page import Render_Page
self.api_browser = API_Browser(headless=self.headless).sync__setup_browser()
self.render_page = Render_Page(api_browser=self.api_browser, web_root=self.web_root())
return self
def setUp(self):
self.api = API_Browser(headless=True)
def __init__(self):
self.browser = API_Browser()
def __enter__(self):
self.api_browser = API_Browser(headless=self.headless)
self.browser = self.api_browser.sync__browser()
if self.open_page:
self.api_browser.sync__open(self.open_page)
return self
def setUp(self):
self.api = API_Browser(headless=False)
class Base_View_Helpers:
def __init__(self, web_page, headless=True):
self.web_page = web_page
self.title = 'browser view'
self.web_root = Files.path_combine(Files.parent_folder(__file__),
'../web_root')
self.api_browser = API_Browser(headless=headless).sync__setup_browser()
self.web_server = Web_Server(self.web_root)
self.render_page = Render_Page(api_browser=self.api_browser,
web_server=self.web_server)
# common methods (move to base class)
def browser(self):
return self.api_browser
def browser_width(self, value, height=None):
self.browser().sync__browser_width(value, height)
return self
def load_page(self, reload=False):
if reload or self.web_page not in self.browser().sync__url():
self.render_page.open_file_in_browser(self.web_page)
return self
def create_dashboard_screenshot(self, clip=None):
#clip = {'x': 1, 'y': 1, 'width': 945, 'height': 465}
#clip = None
return self.browser().sync__screenshot(clip=clip)
def send_screenshot_to_slack(self, team_id=None, channel=None, clip=None):
png_file = self.create_dashboard_screenshot(clip)
return Browser_Lamdba_Helper().send_png_file_to_slack(
team_id, channel, self.title, png_file)
def get_graph_data(self, graph_name):
params = {'params': ['raw_data', graph_name, 'details'], 'data': {}}
data = Lambda('lambdas.gsbot.gsbot_graph').invoke(params)
if type(data) is str:
s3_key = data
s3_bucket = 'gs-lambda-tests'
tmp_file = S3().file_download_and_delete(s3_bucket, s3_key)
data = Json.load_json_and_delete(tmp_file)
return data
return data
def exec_js(self, js_code):
return self.browser().sync__js_execute(js_code)
def invoke_js(self, name, params):
return self.browser().sync_js_invoke_function(name, params)
def assign_variable_js(self, variable, data):
return self.browser().sync_js_assign_variable(variable, data)
def set_browser_width_based_on_nodes(self, nodes):
if len(nodes) < 30: self.browser().sync__browser_width(800)
elif len(nodes) < 100: self.browser().sync__browser_width(1500)
elif len(nodes) < 200: self.browser().sync__browser_width(2000)
else: self.browser().sync__browser_width(3000)
def render(self,
nodes,
edges,
js_code=None,
options=None,
team_id=None,
channel=None,
sleep_for=None,
width=None):
if len(nodes) > 0:
if width:
self.browser().sync__browser_width(width)
else:
self.set_browser_width_based_on_nodes(nodes)
# if len(nodes) < 50 : sleep_for = 2
# elif 50 < len(nodes) < 100: self.browser().sync__browser_width(1000) ; sleep_for = 3
# elif 100 < len(nodes) < 200: self.browser().sync__browser_width(2000) ; sleep_for = 5
# elif len(nodes) > 200: self.browser().sync__browser_width(3000) ; sleep_for = 10
self.create_graph(nodes, edges, options)
self.api_browser.sync__js_execute(js_code)
if sleep_for: sleep(sleep_for)
return self.send_screenshot_to_slack(team_id, channel)
class test_API_Browser(TestCase):
def setUp(self):
self.api = API_Browser(headless=False)
@sync
async def test_browser_connect(self):
browser = await self.api.browser_connect()
assert WS_is_open(browser.wsEndpoint)
def test_get_set_last_chrome_session(self):
self.api.file_tmp_last_chrome_session = Files.temp_file()
data = {
'chrome_devtools':
'ws://127.0.0.1:64979/devtools/browser/75fbaab9-33eb-41ee-afd9-4aed65166791'
}
self.api.set_last_chrome_session(data)
assert self.api.get_last_chrome_session() == data
Files.delete(self.api.file_tmp_last_chrome_session)
@unittest.skip("bug: needs to load markdow page first")
@sync
async def test_js_eval(self):
markdown = """
# some title "with double quotes"
some text and 'single quotes'
"""
encoded_text = base64.b64encode(markdown.encode()).decode()
js_script = "convert(atob('{0}'))".format(encoded_text)
result = await self.api.js_eval(js_script)
#Dev.pprint(result)
@unittest.skip("bug: needs to load markdow page first")
@sync
async def test_invoke_js_function(self):
markdown = """
# changed title "via js function"
some text and 'single quotes'
"""
result = await self.api.js_invoke_function('convert', markdown)
#Dev.pprint(result)
@sync
async def test_html(self):
await self.api.open('https://www.google.com')
content = await self.api.html()
assert len(content.html()) > 100
@sync
async def test_open(self):
(headers, status, url,
browser) = await self.api.open('https://www.google.com')
assert headers['x-frame-options'] == 'SAMEORIGIN'
assert status == 200
assert url == 'https://www.google.com/'
@sync
async def test_page(self):
page = await self.api.page()
assert "http" in page.url
@sync
async def test_screenshot(self):
await self.api.open('https://news.bbc.co.uk')
file = await self.api.screenshot()
assert Files.exists(file)
def api_browser(
self
): # todo: figure out if this is the best way to expose this object
from osbot_browser.browser.API_Browser import API_Browser
return API_Browser(self.browser())
def setUp(self):
self.api = API_Browser(headless=False)
self.png_file = '/tmp/tmp-jira-screenshot.png'
