'
- ' '
- .format(src=get_link_path(path, self.log_dir), width=width), html=True)
-
-class _SafeFormatter(dict):
-
- def __missing__(self, key):
- return '{%s}' % key
diff --git a/PuppeteerLibrary/keywords/utility.py b/PuppeteerLibrary/keywords/utility.py
index 980f2a9..cef1e11 100644
--- a/PuppeteerLibrary/keywords/utility.py
+++ b/PuppeteerLibrary/keywords/utility.py
@@ -1,11 +1,36 @@
import asyncio
+from robot.utils import timestr_to_secs
from robot.libraries.BuiltIn import _RunKeyword
+from PuppeteerLibrary.keywords.browsermanagement import BrowserManagementKeywords
+from PuppeteerLibrary.playwright.async_keywords.playwright_browsermanagement import PlaywrightBrowserManagement
from PuppeteerLibrary.base.librarycomponent import LibraryComponent
from PuppeteerLibrary.base.robotlibcore import keyword
class UtilityKeywords(LibraryComponent):
+ def __init__(self, ctx):
+ super().__init__(ctx)
+
+ @keyword
+ def set_timeout(self, timeout):
+ """Sets the timeout that is used by various keywords.
+ The value can be given as a number that is considered to be seconds or as a human-readable string like 1 second.
+ The previous value is returned and can be used to restore the original value later if needed.
+ See the Timeout section above for more information.
+
+ Example:
+
+ | ${orig timeout} = | Set Timeout | 15 seconds |
+ | Open page that loads slowly | | |
+ | Set Timeout | ${orig timeout} | |
+
+ """
+ orig_timeout = self.ctx.timeout
+ self.ctx.get_current_library_context().timeout = timestr_to_secs(timeout)
+ self.info('Original timeout is ' + str(orig_timeout) + ' seconds')
+ return orig_timeout
+
@keyword
def run_async_keywords_and_return_first_completed(self, *keywords):
"""Executes all the given keywords in a asynchronous and wait until first keyword is completed
@@ -16,20 +41,16 @@ def run_async_keywords_and_return_first_completed(self, *keywords):
| `Run Async Keywords And Return First Completed` | Wait for response url | ${HOME_PAGE_URL}/login.html | AND |
| ... | Wait for response url | ${HOME_PAGE_URL}/home.html | |
"""
- self.ctx.load_async_keywords()
run_keyword = _RunKeyword()
return self.loop.run_until_complete( self._run_async_keywords_first_completed(run_keyword._split_run_keywords(list(keywords))) )
- async def _wrapped_async_keyword_return_index(self, index, future):
- await future
- return index
-
async def _run_async_keywords_first_completed(self, iterable):
org_statements = []
index = 0
for kw, args in iterable:
- kw_name = kw.lower().replace(' ', '_') + '_async'
- org_statements.append(self._wrapped_async_keyword_return_index(index, self.ctx.keywords[kw_name](*args)))
+ kw_name = kw.lower().replace(' ', '_')
+ async_keywords = self.ctx.keywords[kw_name].__self__.get_async_keyword_group()
+ org_statements.append(self._wrapped_async_keyword_return_index(index, getattr(async_keywords, kw_name)(*args) ))
index += 1
statements = org_statements
error_stack_trace = ''
@@ -49,7 +70,11 @@ async def _run_async_keywords_first_completed(self, iterable):
continue
if len(pending) == 0:
raise Exception("All async keywords failed \r\n"+ error_stack_trace)
-
+
+ async def _wrapped_async_keyword_return_index(self, index, future):
+ await future
+ return index
+
@keyword
def run_async_keywords(self, *keywords):
"""Executes all the given keywords in a asynchronous and wait until all keyword is completed
@@ -62,14 +87,24 @@ def run_async_keywords(self, *keywords):
| ... | Wait for response url | ${HOME_PAGE_URL}/home.html | |
"""
- self.ctx.load_async_keywords()
run_keyword = _RunKeyword()
- return self.loop.run_until_complete( self._run_async_keywords(run_keyword._split_run_keywords(list(keywords))) )
-
+ return self.loop.run_until_complete( self._new_run_async_keywords(run_keyword._split_run_keywords(list(keywords))) )
+
+ async def _new_run_async_keywords(self, iterable):
+ statements = []
+ for kw, args in iterable:
+ kw_name = kw.lower().replace(' ', '_')
+ async_keywords = self.ctx.keywords[kw_name].__self__.get_async_keyword_group()
+ statements.append(getattr(async_keywords, kw_name)(*args))
+ try:
+ return await asyncio.gather(*statements)
+ except Exception as err:
+ raise Exception(err)
+
async def _run_async_keywords(self, iterable):
statements = []
for kw, args in iterable:
- kw_name = kw.lower().replace(' ', '_') + '_async'
+ kw_name = kw.lower()
statements.append(self.ctx.keywords[kw_name](*args))
try:
return await asyncio.gather(*statements)
diff --git a/PuppeteerLibrary/keywords/waiting.py b/PuppeteerLibrary/keywords/waiting.py
index a79362a..ddcc951 100644
--- a/PuppeteerLibrary/keywords/waiting.py
+++ b/PuppeteerLibrary/keywords/waiting.py
@@ -1,13 +1,15 @@
-from PuppeteerLibrary.keywords.waiting_async import WaitingKeywordsAsync
-from PuppeteerLibrary.base.librarycomponent import LibraryComponent
from PuppeteerLibrary.base.robotlibcore import keyword
+from PuppeteerLibrary.ikeywords.iwaiting_async import iWaitingAsync
+from PuppeteerLibrary.base.librarycomponent import LibraryComponent
class WaitingKeywords(LibraryComponent):
def __init__(self, ctx):
super().__init__(ctx)
- self.async_func = WaitingKeywordsAsync(self.ctx)
+
+ def get_async_keyword_group(self) -> iWaitingAsync:
+ return self.ctx.get_current_library_context().get_async_keyword_group(type(self).__name__)
@keyword
def wait_for_request_url(self, url, method='GET', body=None, timeout=None):
@@ -43,7 +45,7 @@ def wait_for_request_url(self, url, method='GET', body=None, timeout=None):
| ... | `Wait For Request Url` | ${URL_API}/login | POST | username=demo |
"""
- return self.loop.run_until_complete(self.async_func.wait_for_request_url_async(url, method, body, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_for_request_url_async(url, method, body, timeout))
@keyword
def wait_for_response_url(self, url, status=200, body=None, timeout=None):
@@ -73,10 +75,10 @@ def wait_for_response_url(self, url, status=200, body=None, timeout=None):
| ... | `Wait For Response Url` | ${URL_API}/login | 200 | username=demo |
"""
- return self.loop.run_until_complete(self.async_func.wait_for_response_url_async(url, status, body, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_for_response_url(url, status, body, timeout))
@keyword
- def wait_for_navigation(self):
+ def wait_for_navigation(self, timeout=None):
"""
Waits until web page navigates to new url or reloads.
@@ -88,7 +90,7 @@ def wait_for_navigation(self):
| Run Async Keywords | Click Element | id:login_button | AND |
| ... | `Wait For Navigation` | | |
"""
- return self.loop.run_until_complete(self.async_func.wait_for_navigation_async())
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_for_navigation(timeout))
@keyword
def wait_until_page_contains_element(self, locator, timeout=None):
@@ -100,7 +102,7 @@ def wait_until_page_contains_element(self, locator, timeout=None):
| Open browser | ${HOME_PAGE_URL} | options=${options} |
| `Wait Until Page Contains Element` | id:username | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_page_contains_element_async(locator, timeout))
+ self.loop.run_until_complete(self.get_async_keyword_group().wait_until_page_contains_element(locator, timeout))
@keyword
def wait_until_element_is_hidden(self, locator, timeout=None):
@@ -113,7 +115,7 @@ def wait_until_element_is_hidden(self, locator, timeout=None):
| ... | Wait For Navigation | | |
| `Wait Until Element Is Hidden` | id:login_button | | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_element_is_hidden_async(locator, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_is_hidden(locator, timeout))
@keyword
def wait_until_element_is_visible(self, locator, timeout=None):
@@ -126,7 +128,7 @@ def wait_until_element_is_visible(self, locator, timeout=None):
| ... | Wait For Navigation | | |
| `Wait Until Element Is Visible` | id:welcome | | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_element_is_visible_async(locator, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_is_visible(locator, timeout))
@keyword
def wait_until_page_contains(self, text, timeout=None):
@@ -139,7 +141,8 @@ def wait_until_page_contains(self, text, timeout=None):
| ... | Wait For Navigation | | |
| `Wait Until Page Contains` | Invalid user name or password | | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_page_contains_async(text, timeout))
+ self.loop.run_until_complete(self.get_async_keyword_group().wait_until_page_contains(text, timeout))
+ # return self.loop.run_until_complete(self.async_func.wait_until_page_contains_async(text, timeout))
@keyword
def wait_until_page_does_not_contains(self, text, timeout=None):
@@ -152,7 +155,7 @@ def wait_until_page_does_not_contains(self, text, timeout=None):
| ... | Wait For Navigation | | |
| `Wait Until Page Does Not Contains` | Please input your user name | | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_page_does_not_contains_async(text, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_page_does_not_contains(text, timeout))
@keyword
def wait_until_element_contains(self, locator, text, timeout=None):
@@ -164,7 +167,7 @@ def wait_until_element_contains(self, locator, text, timeout=None):
| Open browser | ${HOME_PAGE_URL} | options=${options} |
| `Wait Until Element Contains` | css:#container p | Please input your user name |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_element_contains_async(locator, text, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_contains(locator, text, timeout))
@keyword
def wait_until_element_does_not_contains(self, locator, text, timeout=None):
@@ -177,7 +180,7 @@ def wait_until_element_does_not_contains(self, locator, text, timeout=None):
| ... | Wait For Navigation | | |
| `Wait Until Element Does Not Contains` | css:#container p | Please input your user name | |
"""
- return self.loop.run_until_complete(self.async_func.wait_until_element_does_not_contains_async(locator, text, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_does_not_contains(locator, text, timeout))
@keyword
def wait_until_location_contains(self, expected, timeout=None):
@@ -186,7 +189,7 @@ def wait_until_location_contains(self, expected, timeout=None):
The `expected` argument contains the expected value in url.
"""
- return self.loop.run_until_complete(self.async_func.wait_until_location_contains_async(expected, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_location_contains(expected, timeout))
@keyword
def wait_until_location_does_not_contains(self, expected, timeout=None):
@@ -195,7 +198,7 @@ def wait_until_location_does_not_contains(self, expected, timeout=None):
The `expected` argument contains the expected value must not in url.
"""
- return self.loop.run_until_complete(self.async_func.wait_until_location_does_not_contains_async(expected, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_location_does_not_contains(expected, timeout))
@keyword
def wait_until_element_is_enabled(self, selenium_locator, timeout=None):
@@ -203,8 +206,7 @@ def wait_until_element_is_enabled(self, selenium_locator, timeout=None):
Waits until the specific element is Enabled.
"""
- return self.loop.run_until_complete(
- self.async_func.wait_until_element_is_enabled_async(selenium_locator, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_is_enabled(selenium_locator, timeout))
@keyword
def wait_until_element_finished_animating(self, selenium_locator, timeout=None):
@@ -213,5 +215,4 @@ def wait_until_element_finished_animating(self, selenium_locator, timeout=None):
Check by check element position.
"""
- return self.loop.run_until_complete(
- self.async_func.wait_until_element_finished_animating_async(selenium_locator, timeout))
+ return self.loop.run_until_complete(self.get_async_keyword_group().wait_until_element_finished_animating(selenium_locator, timeout))
diff --git a/PuppeteerLibrary/library_context/__init__.py b/PuppeteerLibrary/library_context/__init__.py
new file mode 100644
index 0000000..d9f802f
--- /dev/null
+++ b/PuppeteerLibrary/library_context/__init__.py
@@ -0,0 +1 @@
+from .ilibrary_context import iLibraryContext
\ No newline at end of file
diff --git a/PuppeteerLibrary/library_context/ilibrary_context.py b/PuppeteerLibrary/library_context/ilibrary_context.py
new file mode 100644
index 0000000..bdab19c
--- /dev/null
+++ b/PuppeteerLibrary/library_context/ilibrary_context.py
@@ -0,0 +1,51 @@
+from PuppeteerLibrary.custom_elements.base_page import BasePage
+from abc import ABC, abstractmethod
+
+
+class iLibraryContext(ABC):
+
+ browser_type: str = None
+ timeout: int = 30
+
+ def __init__(self, browser_type: str):
+ self.browser_type = browser_type
+
+ @abstractmethod
+ async def start_server(self, options: dict=None):
+ pass
+
+ @abstractmethod
+ async def stop_server(self):
+ pass
+
+ @abstractmethod
+ def is_server_started(self) -> bool:
+ pass
+
+ @abstractmethod
+ async def create_new_page(self, options: dict=None) -> BasePage:
+ pass
+
+ @abstractmethod
+ def get_current_page(self) -> BasePage:
+ pass
+
+ @abstractmethod
+ def set_current_page(self, page: any) -> BasePage:
+ pass
+
+ @abstractmethod
+ async def get_all_pages(self):
+ pass
+
+ @abstractmethod
+ def get_browser_context(self):
+ pass
+
+ @abstractmethod
+ async def close_browser_context(self):
+ pass
+
+ @abstractmethod
+ def get_async_keyword_group(self, keyword_group_name: str):
+ pass
diff --git a/PuppeteerLibrary/library_context/library_context_factory.py b/PuppeteerLibrary/library_context/library_context_factory.py
new file mode 100644
index 0000000..c812910
--- /dev/null
+++ b/PuppeteerLibrary/library_context/library_context_factory.py
@@ -0,0 +1,21 @@
+from .ilibrary_context import iLibraryContext
+from PuppeteerLibrary.puppeteer.puppeteer_context import PuppeteerContext
+from PuppeteerLibrary.playwright.playwright_context import PlaywrightContext
+
+class LibraryContextFactory:
+
+ def create(self, browser_type: str) -> iLibraryContext:
+ """Return iLibraryContext based on specific browser_type
+
+ Create context based on browser type (chrome, safari, webkit)
+ """
+ if browser_type.lower() == 'chrome':
+ return PuppeteerContext(browser_type)
+ elif browser_type.lower() == 'safari':
+ return PlaywrightContext(browser_type)
+ elif browser_type.lower() == 'webkit':
+ return PlaywrightContext(browser_type)
+ elif browser_type.lower() == 'firefox':
+ return PlaywrightContext(browser_type)
+ else:
+ raise Exception('Sorry, not supported for library type '+str(browser_type)+'.')
diff --git a/PuppeteerLibrary/playwright/__init__.py b/PuppeteerLibrary/playwright/__init__.py
new file mode 100644
index 0000000..3294d71
--- /dev/null
+++ b/PuppeteerLibrary/playwright/__init__.py
@@ -0,0 +1 @@
+# Just for notify python that this is library folder for searching for
diff --git a/PuppeteerLibrary/playwright/async_keywords/__init__.py b/PuppeteerLibrary/playwright/async_keywords/__init__.py
new file mode 100644
index 0000000..31c3eb1
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/__init__.py
@@ -0,0 +1 @@
+from .playwright_browsermanagement import PlaywrightBrowserManagement
\ No newline at end of file
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_alert.py b/PuppeteerLibrary/playwright/async_keywords/playwright_alert.py
new file mode 100644
index 0000000..b3be74f
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_alert.py
@@ -0,0 +1,11 @@
+import asyncio
+from PuppeteerLibrary.ikeywords.ialert_async import iAlertAsync
+
+
+class PlaywrightAlert(iAlertAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def handle_alert(self, action, prompt_text=''):
+ pass
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_browsermanagement.py b/PuppeteerLibrary/playwright/async_keywords/playwright_browsermanagement.py
new file mode 100644
index 0000000..9a7858d
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_browsermanagement.py
@@ -0,0 +1,102 @@
+import asyncio
+import re
+import time
+from PuppeteerLibrary.utils.device_descriptors import DEVICE_DESCRIPTORS
+from PuppeteerLibrary.ikeywords.ibrowsermanagement_async import iBrowserManagementAsync
+
+
+class PlaywrightBrowserManagement(iBrowserManagementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def maximize_browser_window(self, width=1366, height=768):
+ return await self.library_ctx.get_current_page().set_viewport_size(width, height)
+
+ async def go_to(self, url):
+ return await self.library_ctx.get_current_page().goto(url)
+
+ async def go_back(self):
+ return await self.library_ctx.get_current_page().go_back()
+
+ async def reload_page(self):
+ return await self.library_ctx.get_current_page().reload_page()
+
+ async def get_window_count(self):
+ pages = await self.library_ctx.get_all_pages()
+ for page in pages:
+ # Workaround: for force pages re-cache
+ try:
+ await page.title()
+ except:
+ return -1
+ return len(await self.library_ctx.get_all_pages())
+ '''
+ pages = await self.library_ctx.get_browser().pages()
+ for page in pages:
+ # Workaround: for force pages re-cache
+ try:
+ await page.title()
+ except:
+ return -1
+ return len(await self.library_ctx.get_browser().pages())
+ '''
+
+ async def wait_for_new_window_open(self, timeout=None):
+ page_len = 0
+ # Workaround:
+ # We get length without force reset. For ensure that when we count page length.
+ # Page length still not update / same as before open new window
+ pre_page_len = len(await self.library_ctx.get_all_pages())
+ timeout = self.timestr_to_secs_for_default_timeout(timeout)
+ max_time = time.time() + timeout
+ while time.time() < max_time:
+ page_len = len(await self.library_ctx.get_all_pages())
+ if page_len > pre_page_len:
+ return
+ await asyncio.sleep(0.5)
+ raise Exception('No new page has been open. pre: ' + str(pre_page_len) + ' current: ' + str(page_len))
+
+ async def switch_window(self, locator='MAIN'):
+ pages = await self.library_ctx.get_all_pages()
+ if locator == 'MAIN':
+ page = pages[0]
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+
+ elif locator == 'NEW':
+ page = pages[-1]
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+
+ elif 'title=' in locator:
+ title = locator.replace('title=', '')
+ for page in pages:
+ page_title = await page.title()
+ if page_title == title:
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+ self.info('Title mismatch: ' + page_title)
+
+ elif 'url=' in locator:
+ url = locator.replace('url=', '')
+ for page in pages:
+ if re.match(url, page.url):
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+ self.info('Url mismatch: ' + page.url)
+ else:
+ raise Exception('Sorry Switch window support only NEW, MAIN, title and url')
+ raise Exception('Can\'t find specify page locator.')
+
+ ##############################
+ # iFrame
+ ##############################
+ async def select_frame(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ iframe = await element.contentFrame()
+ self.library_ctx.get_current_page().set_current_iframe(iframe)
+
+ def unselect_iframe(self):
+ self.library_ctx.get_current_page().unselect_iframe()
+
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_dropdown.py b/PuppeteerLibrary/playwright/async_keywords/playwright_dropdown.py
new file mode 100644
index 0000000..ddeaa14
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_dropdown.py
@@ -0,0 +1,32 @@
+from PuppeteerLibrary.ikeywords.idropdown_async import iDropdownAsync
+from PuppeteerLibrary.locators.SelectorAbstraction import SelectorAbstraction
+
+
+class PlaywrightDropdown(iDropdownAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def select_from_list_by_value(self, locator, values):
+ selector_value = SelectorAbstraction.get_selector(locator)
+ if SelectorAbstraction.is_xpath(locator):
+ await self.library_ctx.get_current_page().get_page().evaluate('''
+ element = document.evaluate('{selector_value}//option[contains(@value, "{values}")]', document, null, XPathResult.ANY_TYPE, null).iterateNext();
+ element.selected = true;
+ '''.format(selector_value=selector_value, values=values))
+ else:
+ await self.library_ctx.get_current_page().get_page().selectOption(selector_value, {
+ 'value': values
+ })
+
+ async def select_from_list_by_label(self, locator, labels):
+ selector_value = SelectorAbstraction.get_selector(locator)
+ if SelectorAbstraction.is_xpath(locator):
+ await self.library_ctx.get_current_page().get_page().evaluate('''
+ element = document.evaluate('{selector_value}//option[text()=\"{label}\"]', document, null, XPathResult.ANY_TYPE, null).iterateNext();
+ element.selected = true;
+ '''.format(selector_value=selector_value, label=labels))
+ else:
+ await self.library_ctx.get_current_page().get_page().selectOption(selector_value, {
+ 'label': labels
+ })
\ No newline at end of file
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_element.py b/PuppeteerLibrary/playwright/async_keywords/playwright_element.py
new file mode 100644
index 0000000..3514add
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_element.py
@@ -0,0 +1,70 @@
+from robot.libraries.BuiltIn import BuiltIn
+from PuppeteerLibrary.ikeywords.ielement_async import iElementAsync
+
+
+class PlaywrightElement(iElementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ ##############################
+ # Click
+ ##############################
+ async def click_element(self, locator: str):
+ return await self.library_ctx.get_current_page().click_with_selenium_locator(locator)
+
+ async def upload_file(self, locator: str, file_path: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ await element.setInputFiles(file_path)
+
+ ##############################
+ # Status
+ ##############################
+ async def element_should_be_enabled(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ is_disabled = await (await element.getProperty('disabled')).jsonValue()
+ if is_disabled:
+ raise AssertionError("Element '%s' is disabled. " % locator)
+ return element
+
+ async def element_should_be_disabled(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ is_disabled = await (await element.getProperty('disabled')).jsonValue()
+ if not is_disabled:
+ raise AssertionError("Element '%s' is enabled. " % locator)
+ return element
+
+ async def element_should_be_visible(self, locator:str):
+ try:
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(locator, 0.1, visible=True, hidden=False)
+ except:
+ raise AssertionError("Element '%s' is not be visible. " % locator)
+
+ async def element_should_not_be_visible(self, locator:str):
+ try:
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(locator, 0.1, visible=False, hidden=True)
+ except:
+ raise AssertionError("Element '%s' is visible. " % locator)
+
+ ##############################
+ # Property
+ ##############################
+ async def element_should_contain(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_contain(text, expected, ignore_case=ignore_case)
+
+ async def element_should_not_contain(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_not_contain(text, expected, ignore_case=ignore_case)
+
+ async def get_text(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ return (await (await element.getProperty('textContent')).jsonValue())
+
+ async def element_text_should_be(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_be_equal_as_strings(text, expected, ignore_case=ignore_case)
+
+ async def element_text_should_not_be(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_not_be_equal_as_strings(text, expected, ignore_case=ignore_case)
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_formelement.py b/PuppeteerLibrary/playwright/async_keywords/playwright_formelement.py
new file mode 100644
index 0000000..ad04342
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_formelement.py
@@ -0,0 +1,22 @@
+from PuppeteerLibrary.ikeywords.iformelement_async import iFormElementAsync
+from PuppeteerLibrary.locators.SelectorAbstraction import SelectorAbstraction
+
+
+class PlaywrightFormElement(iFormElementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def input_text(self, locator: str, text: str, clear=True):
+ if clear:
+ await self._clear_input_text(locator)
+ await self.library_ctx.get_current_page().type_with_selenium_locator(locator, text)
+
+ async def clear_element_text(self, locator: str):
+ await self._clear_input_text(locator)
+
+ async def _clear_input_text(self, selenium_locator):
+ await self.library_ctx.get_current_page().click_with_selenium_locator(selenium_locator, {'clickCount': 3})
+ await self.library_ctx.get_current_page().get_page().keyboard.press('Backspace')
+
+
\ No newline at end of file
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_javascript.py b/PuppeteerLibrary/playwright/async_keywords/playwright_javascript.py
new file mode 100644
index 0000000..94216b6
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_javascript.py
@@ -0,0 +1,10 @@
+from PuppeteerLibrary.ikeywords.ijavascript_async import iJavascriptAsync
+
+
+class PlaywrightJavascript(iJavascriptAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def execute_javascript(self, code):
+ return await self.library_ctx.get_current_page().get_page().evaluate(code)
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_mockresponse.py b/PuppeteerLibrary/playwright/async_keywords/playwright_mockresponse.py
new file mode 100644
index 0000000..92cc025
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_mockresponse.py
@@ -0,0 +1,26 @@
+import asyncio
+import re
+from PuppeteerLibrary.base.robotlibcore import keyword
+from PuppeteerLibrary.ikeywords.imockresponse_async import iMockResponseAsync
+
+
+class PlaywrightMockResponse(iMockResponseAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def mock_current_page_api_response(self, url, mock_response, method='GET', body=None):
+ page = self.library_ctx.get_current_page().get_page()
+ await page.route(url, lambda route, request: asyncio.ensure_future(self.mock_api_response(route, request, mock_response, method, body)))
+
+ async def mock_api_response(self, route, request, mock_response, method, body):
+ try:
+ pos_data = (await request.postData())
+ except:
+ pos_data = ''
+ if body is None or re.search(body, pos_data.replace('\n', '')):
+ await route.fulfill(
+ **mock_response
+ )
+ await request.continue_()
+
\ No newline at end of file
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_mouseevent.py b/PuppeteerLibrary/playwright/async_keywords/playwright_mouseevent.py
new file mode 100644
index 0000000..5666140
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_mouseevent.py
@@ -0,0 +1,26 @@
+from robot.libraries.BuiltIn import BuiltIn
+from PuppeteerLibrary.ikeywords.imouseevent_async import iMouseEventAsync
+
+
+class PlaywrightMouseEvent(iMouseEventAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def mouse_over(self, locator):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ await element.hover()
+
+ async def mouse_down(self, locator):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ bounding_box = await element.boundingBox()
+ await self.library_ctx.get_current_page().get_page().mouse.move(
+ bounding_box['x'] + bounding_box['width'] / 2,
+ bounding_box['y'] + bounding_box['height'] / 2)
+ await self.library_ctx.get_current_page().get_page().mouse.down()
+
+ async def mouse_up(self):
+ await self.library_ctx.get_current_page().get_page().mouse.up()
+
+ async def mouse_move(self, x, y):
+ await self.library_ctx.get_current_page().get_page().mouse.move(int(x), int(y))
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_pdf.py b/PuppeteerLibrary/playwright/async_keywords/playwright_pdf.py
new file mode 100644
index 0000000..167c6c5
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_pdf.py
@@ -0,0 +1,15 @@
+from PuppeteerLibrary.ikeywords.ipdf_async import iPDFAsync, DEFAULT_FILENAME_PAGE
+
+
+class PlaywrightPDF(iPDFAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def print_as_pdf(self, filename=DEFAULT_FILENAME_PAGE):
+ path = self._get_pdf_path(filename)
+ await self.library_ctx.get_current_page().get_page().emulateMedia('screen')
+ await self.library_ctx.get_current_page().get_page().pdf(
+ path=path
+ )
+ self.info('Print as pdf: '+path)
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_screenshot.py b/PuppeteerLibrary/playwright/async_keywords/playwright_screenshot.py
new file mode 100644
index 0000000..f814109
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_screenshot.py
@@ -0,0 +1,13 @@
+from PuppeteerLibrary.playwright.async_keywords.playwright_waiting import PlaywrightWaiting
+from PuppeteerLibrary.ikeywords.iscreenshot_async import iScreenshotAsync
+
+
+class PlaywrightScreenshot(iScreenshotAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def capture_page_screenshot(self, path: str):
+ return await self.library_ctx.get_current_page().get_page().screenshot(
+ path=f''+path
+ )
diff --git a/PuppeteerLibrary/playwright/async_keywords/playwright_waiting.py b/PuppeteerLibrary/playwright/async_keywords/playwright_waiting.py
new file mode 100644
index 0000000..f0515ac
--- /dev/null
+++ b/PuppeteerLibrary/playwright/async_keywords/playwright_waiting.py
@@ -0,0 +1,160 @@
+import asyncio
+import re
+import time
+from robot.utils.dotdict import DotDict
+from PuppeteerLibrary.ikeywords.iwaiting_async import iWaitingAsync
+
+
+class PlaywrightWaiting(iWaitingAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def wait_for_request_url(self, url, method='GET', body=None, timeout=None):
+ req = await self.library_ctx.get_current_page().get_page().waitForEvent(
+ "request", lambda request: re.search(url, request.url) is not None and request.method == method,
+ self.timestr_to_secs_for_default_timeout(timeout) * 1000
+ )
+ try:
+ pos_data = (await req.postData())
+ except:
+ pos_data = ''
+
+ if body is None or re.search(body, pos_data.replace('\n', '')):
+ log_str = 'Wait for request url: '+req.method+' - '+req.url
+ if pos_data != '':
+ log_str + '\n' + pos_data
+ self.info(log_str)
+ else:
+ raise Exception('Can\'t match request body with ' + body + ' \n ' + pos_data)
+
+ return DotDict({
+ 'url': req.url,
+ 'method': req.method,
+ 'body': pos_data
+ })
+
+ async def wait_for_response_url(self, url, status=200, body=None, timeout=None):
+ res = await self.library_ctx.get_current_page().get_page().waitForEvent(
+ "response", lambda response: re.search(url, response.url) is not None and response.status == int(status),
+ self.timestr_to_secs_for_default_timeout(timeout) * 1000
+ )
+ try:
+ res_text = (await res.text())
+ except:
+ res_text = ''
+ if body is None or re.search(body, res_text.replace('\n','')):
+ log_str = 'Wait for request url: ' + res.url
+ if res_text != '':
+ log_str += '\n' + res_text
+ self.info(log_str)
+ else:
+ raise Exception('Can\'t match response body with '+body+' \n '+res_text)
+ return DotDict({
+ 'url': res.url,
+ 'status': res.status,
+ 'body': res_text
+ })
+
+ async def wait_for_navigation(self, timeout=None):
+ await self.library_ctx.get_current_page().get_page().waitForNavigation(
+ timeout=self.timestr_to_secs_for_default_timeout(timeout) * 1000
+ )
+
+ async def wait_until_page_contains_element(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
+
+ async def wait_until_element_is_hidden(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
+
+ async def wait_until_element_is_visible(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
+
+ async def wait_until_page_contains(self, text, timeout=None):
+ locator = "xpath://*[contains(., %s)]" % self.escape_xpath_value(text)
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
+
+ async def wait_until_page_does_not_contains(self, text, timeout=None):
+ locator = "xpath://*[contains(., %s)]" % self.escape_xpath_value(text)
+ return await self._wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
+
+ async def wait_until_element_contains(self, locator, text, timeout=None):
+ locator = "xpath://*[contains(., %s)]" % self.escape_xpath_value(text)
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
+
+ async def wait_until_element_does_not_contains(self, locator, text, timeout=None):
+ async def validate_element_contains_text():
+ return (text not in (await (await ( await self.library_ctx.get_current_page().
+ querySelector_with_selenium_locator(locator)).getProperty('textContent')).jsonValue()))
+ return await self._wait_until_worker(
+ validate_element_contains_text,
+ self.timestr_to_secs_for_default_timeout(timeout))
+
+ async def wait_until_location_contains(self, expected, timeout=None):
+ async def validate_url_contains_text():
+ return expected in self.library_ctx.get_current_page().get_page().url
+ return await self._wait_until_worker(
+ validate_url_contains_text,
+ self.timestr_to_secs_for_default_timeout(timeout))
+
+ async def wait_until_location_does_not_contains(self, expected, timeout=None):
+ async def validate_url_not_contains_text():
+ return expected not in self.library_ctx.get_current_page().get_page().url
+ return await self._wait_until_worker(
+ validate_url_not_contains_text,
+ self.timestr_to_secs_for_default_timeout(timeout))
+
+ async def wait_until_element_is_enabled(self, locator, timeout=None):
+ async def validate_is_enabled():
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ is_disabled = await (await element.getProperty('disabled')).jsonValue()
+ return is_disabled == False
+ return await self._wait_until_worker(
+ validate_is_enabled,
+ self.timestr_to_secs_for_default_timeout(timeout),
+ 'Element '+locator+' was not enabled.')
+
+ async def wait_until_element_finished_animating(self, locator, timeout=None):
+ prev_rect_tmp = { 'value': None }
+ async def check_finished_animating():
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ if prev_rect_tmp['value'] is None:
+ prev_rect_tmp['value'] = await element.boundingBox()
+ return False
+ prev_rect = prev_rect_tmp['value']
+ next_rect = await element.boundingBox()
+ if next_rect['x'] == prev_rect['x'] and next_rect['y'] == prev_rect['y']:
+ return True
+ else:
+ prev_rect_tmp['value'] = next_rect
+ return False
+ return await self._wait_until_worker(
+ check_finished_animating,
+ self.timestr_to_secs_for_default_timeout(timeout),
+ 'Element '+locator+' was not enabled.')
+
+ async def _wait_for_selenium_selector(self, selenium_locator, timeout=None, visible=False, hidden=False):
+ timeout = self.timestr_to_secs_for_default_timeout(timeout)
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(selenium_locator, timeout, visible, hidden)
+
+ async def _wait_until_worker(self, condition, timeout, error=None):
+ max_time = time.time() + timeout
+ not_found = None
+ while time.time() < max_time:
+ try:
+ if await condition():
+ return
+ else:
+ not_found = None
+ except Exception as err:
+ not_found = err
+ await asyncio.sleep(0.2)
+ raise AssertionError(not_found or error)
+
+ def escape_xpath_value(self, value):
+ if '"' in value and '\'' in value:
+ parts_wo_apos = value.split('\'')
+ return "concat('%s')" % "', \"'\", '".join(parts_wo_apos)
+ if '\'' in value:
+ return "\"%s\"" % value
+ return "'%s'" % value
diff --git a/PuppeteerLibrary/playwright/custom_elements/__init__.py b/PuppeteerLibrary/playwright/custom_elements/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/PuppeteerLibrary/playwright/custom_elements/playwright_page.py b/PuppeteerLibrary/playwright/custom_elements/playwright_page.py
new file mode 100644
index 0000000..8693e46
--- /dev/null
+++ b/PuppeteerLibrary/playwright/custom_elements/playwright_page.py
@@ -0,0 +1,107 @@
+from typing import Any
+from PuppeteerLibrary.custom_elements.base_page import BasePage
+from PuppeteerLibrary.locators.SelectorAbstraction import SelectorAbstraction
+try:
+ from playwright.page import Page
+except Exception:
+ from pyppeteer.page import Page
+ print('import playwright error')
+
+class PlaywrightPage(BasePage):
+
+ def __init__(self, page: Page):
+ self.page = page
+ self.selected_iframe = None
+
+ def get_page(self) -> Page:
+ return self.page
+
+ async def goto(self, url: str):
+ return await self.page.goto(url)
+
+ async def go_back(self):
+ return await self.page.goBack()
+
+ async def reload_page(self):
+ return await self.page.reload()
+
+ async def title(self):
+ return await self.page.title()
+
+ async def set_viewport_size(self, width: int, height: int):
+ return await self.page.setViewportSize(width, height)
+
+ ############
+ # Click
+ ############
+ async def click_with_selenium_locator(self, selenium_locator: str, options: dict = None, **kwargs: Any):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if options is None:
+ options = {}
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.click(selector=selector_value, **options)
+ else:
+ return await self.page.click(selector=selector_value, **options)
+
+ ############
+ # Type
+ ############
+ async def type_with_selenium_locator(self, selenium_locator: str, text: str, options: dict = None, **kwargs: Any):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if options is None:
+ options = {}
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.type(selector=selector_value, text=text, **options)
+ else:
+ return await self.page.type(selector=selector_value, text=text, **options)
+
+ ############
+ # Wait
+ ############
+ async def waitForSelector_with_selenium_locator(self, selenium_locator: str, timeout: float, visible=False, hidden=False):
+ options = {
+ 'timeout': timeout * 1000,
+ 'state': 'visible'
+ }
+ if visible is True:
+ options['state'] = 'visible'
+ if hidden is True:
+ options['state'] = 'hidden'
+
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ return await self.get_page().waitForSelector(
+ selector=selector_value,
+ timeout=options['timeout'],
+ state=options['state'])
+
+ ############
+ # Query
+ ############
+ async def querySelector(self, selector: str):
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.querySelector(selector=selector)
+ else:
+ return await self.get_page().querySelector(selector=selector)
+
+ async def querySelectorAll_with_selenium_locator(self, selenium_locator: str):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ return await self.get_page().xpath(selector_value)
+ else:
+ return await self.get_page().querySelectorAll(selector_value)
+
+ async def querySelector_with_selenium_locator(self, selenium_locator: str):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ return (await self.get_page().xpath(selector_value))[0]
+ else:
+ return await self.get_page().querySelector(selector_value)
+
+ ##############################
+ # iframe
+ ##############################
+ def set_current_iframe(self, iframe):
+ self.selected_iframe = iframe
+
+ def unselect_iframe(self):
+ self.selected_iframe = None
diff --git a/PuppeteerLibrary/playwright/playwright_context.py b/PuppeteerLibrary/playwright/playwright_context.py
new file mode 100644
index 0000000..77516d3
--- /dev/null
+++ b/PuppeteerLibrary/playwright/playwright_context.py
@@ -0,0 +1,103 @@
+from PuppeteerLibrary.playwright.async_keywords.playwright_mockresponse import PlaywrightMockResponse
+import asyncio
+from PuppeteerLibrary.custom_elements.base_page import BasePage
+from PuppeteerLibrary.playwright.custom_elements.playwright_page import PlaywrightPage
+from PuppeteerLibrary.playwright.async_keywords.playwright_formelement import PlaywrightFormElement
+from PuppeteerLibrary.playwright.async_keywords.playwright_dropdown import PlaywrightDropdown
+from PuppeteerLibrary.playwright.async_keywords.playwright_alert import PlaywrightAlert
+from PuppeteerLibrary.playwright.async_keywords.playwright_screenshot import PlaywrightScreenshot
+from PuppeteerLibrary.playwright.async_keywords.playwright_waiting import PlaywrightWaiting
+from PuppeteerLibrary.playwright.async_keywords.playwright_element import PlaywrightElement
+from PuppeteerLibrary.playwright.async_keywords.playwright_dropdown import PlaywrightDropdown
+from PuppeteerLibrary.playwright.async_keywords.playwright_mouseevent import PlaywrightMouseEvent
+from PuppeteerLibrary.playwright.async_keywords.playwright_browsermanagement import PlaywrightBrowserManagement
+from PuppeteerLibrary.playwright.async_keywords.playwright_pdf import PlaywrightPDF
+from PuppeteerLibrary.playwright.async_keywords.playwright_javascript import PlaywrightJavascript
+from PuppeteerLibrary.library_context.ilibrary_context import iLibraryContext
+try:
+ from playwright import async_playwright
+ from playwright.playwright import Playwright as AsyncPlaywright
+ from playwright.browser import Browser
+except ImportError:
+ print('import playwright error')
+
+
+class PlaywrightContext(iLibraryContext):
+
+ playwright: any = None
+ browser: any = None
+ current_page: any = None
+ current_iframe = None
+
+ def __init__(self, browser_type: str):
+ super().__init__(browser_type)
+
+ async def start_server(self, options: dict=None):
+ self.playwright = await async_playwright().start()
+ if self.browser_type == "webkit":
+ self.browser = await self.playwright.webkit.launch(headless=False)
+ elif self.browser_type == "firefox":
+ self.browser = await self.playwright.firefox.launch(headless=False)
+
+ async def stop_server(self):
+ await self.playwright.stop()
+ self._reset_server_context()
+
+ def is_server_started(self) -> bool:
+ if self.browser is not None:
+ return True
+ return False
+
+ async def create_new_page(self, options: dict=None) -> BasePage:
+ device_options = {}
+ if 'emulate' in options:
+ device_options = self.playwright.devices[options['emulate']]
+ new_page = await self.browser.newPage(**device_options)
+ self.current_page = PlaywrightPage(new_page)
+ return self.current_page
+
+ def get_current_page(self) -> BasePage:
+ return self.current_page
+
+ def set_current_page(self, page: any) -> BasePage:
+ self.current_page = PlaywrightPage(page)
+ return self.current_page
+
+ async def get_all_pages(self):
+ return self.browser.contexts[0].pages
+
+ def get_browser_context(self):
+ return self.browser
+
+ async def close_browser_context(self):
+ if self.browser is not None:
+ try:
+ await asyncio.wait_for(self.browser.close(), timeout=3)
+ except asyncio.TimeoutError:
+ None
+ self._reset_context()
+
+ def get_async_keyword_group(self, keyword_group_name: str):
+ switcher = {
+ "AlertKeywords": PlaywrightAlert(self),
+ "BrowserManagementKeywords": PlaywrightBrowserManagement(self),
+ "DropdownKeywords": PlaywrightDropdown(self),
+ "ElementKeywords": PlaywrightElement(self),
+ "FormElementKeywords": PlaywrightFormElement(self),
+ "JavascriptKeywords": PlaywrightJavascript(self),
+ "MockResponseKeywords": PlaywrightMockResponse(self),
+ "MouseEventKeywords": PlaywrightMouseEvent(self),
+ "PDFKeywords": PlaywrightPDF(self),
+ "ScreenshotKeywords": PlaywrightScreenshot(self),
+ "WaitingKeywords": PlaywrightWaiting(self)
+ }
+ return switcher.get(keyword_group_name)
+
+ def _reset_context(self):
+ self.browser = None
+ self.current_page = None
+ self.current_iframe = None
+
+ def _reset_server_context(self):
+ self._reset_context()
+ self.playwright = None
diff --git a/PuppeteerLibrary/puppeteer/__init__.py b/PuppeteerLibrary/puppeteer/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/__init__.py b/PuppeteerLibrary/puppeteer/async_keywords/__init__.py
new file mode 100644
index 0000000..0a8411f
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/__init__.py
@@ -0,0 +1 @@
+from .puppeteer_browsermanagement import PuppeteerBrowserManagement
\ No newline at end of file
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_alert.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_alert.py
new file mode 100644
index 0000000..8696af4
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_alert.py
@@ -0,0 +1,17 @@
+import asyncio
+from PuppeteerLibrary.ikeywords.ialert_async import iAlertAsync
+
+
+class PuppeteerAlert(iAlertAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def handle_alert(self, action, prompt_text=''):
+ return self.library_ctx.get_current_page().get_page().on('dialog', lambda dialog: asyncio.ensure_future(self.handle_dialog(dialog, action, prompt_text)))
+
+ async def handle_dialog(self, dialog, action, prompt_text=''):
+ if action == 'ACCEPT':
+ await dialog.accept(prompt_text)
+ elif action == 'DISMISS':
+ await dialog.dismiss()
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_browsermanagement.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_browsermanagement.py
new file mode 100644
index 0000000..734f0b1
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_browsermanagement.py
@@ -0,0 +1,97 @@
+import asyncio
+import re
+import time
+from PuppeteerLibrary.ikeywords.ibrowsermanagement_async import iBrowserManagementAsync
+
+
+class PuppeteerBrowserManagement(iBrowserManagementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def maximize_browser_window(self, width=1366, height=768):
+ return await self.ctx.get_current_page().setViewport({
+ 'width': width,
+ 'height': height
+ })
+
+ async def go_to(self, url):
+ return await self.library_ctx.get_current_page().goto(url)
+
+ async def go_back(self):
+ return await self.library_ctx.get_current_page().go_back()
+
+ async def reload_page(self):
+ return await self.library_ctx.get_current_page().reload_page()
+
+ async def get_window_count(self):
+ pass
+
+ async def wait_for_new_window_open(self, timeout=None):
+ page_len = 0
+ # Workaround:
+ # We get length without force reset. For ensure that when we count page length.
+ # Page length still not update / same as before open new window
+ pre_page_len = len(await self.library_ctx.get_all_pages())
+ timeout = self.timestr_to_secs_for_default_timeout(timeout)
+ max_time = time.time() + timeout
+ while time.time() < max_time:
+ page_len = await self._get_window_count_async()
+ if page_len > pre_page_len:
+ return
+ await asyncio.sleep(0.5)
+ raise Exception('No new page has been open. pre: ' + str(pre_page_len) + ' current: ' + str(page_len))
+
+ async def _get_window_count_async(self):
+ pages = await self.library_ctx.get_all_pages()
+ for page in pages:
+ # Workaround: for force pages re-cache
+ try:
+ await page.title()
+ except:
+ return []
+ return len(await self.library_ctx.get_all_pages())
+
+ async def switch_window(self, locator='MAIN'):
+ pages = await self.library_ctx.get_all_pages()
+ if locator == 'MAIN':
+ page = pages[0]
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+
+ elif locator == 'NEW':
+ page = pages[-1]
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+
+ elif 'title=' in locator:
+ title = locator.replace('title=', '')
+ for page in pages:
+ page_title = await page.title()
+ if page_title == title:
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+ self.info('Title mismatch: ' + page_title)
+
+ elif 'url=' in locator:
+ url = locator.replace('url=', '')
+ for page in pages:
+ if re.match(url, page.url):
+ await page.bringToFront()
+ return self.library_ctx.set_current_page(page)
+ self.info('Url mismatch: ' + page.url)
+ else:
+ raise Exception('Sorry Switch window support only NEW, MAIN, title and url')
+ raise Exception('Can\'t find specify page locator.')
+
+ ##############################
+ # iFrame
+ ##############################
+ async def select_frame(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ iframe = await element.contentFrame()
+ self.library_ctx.get_current_page().set_current_iframe(iframe)
+
+ def unselect_iframe(self):
+ self.library_ctx.get_current_page().unselect_iframe()
+
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_dropdown.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_dropdown.py
new file mode 100644
index 0000000..66b3202
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_dropdown.py
@@ -0,0 +1,33 @@
+from PuppeteerLibrary.ikeywords.idropdown_async import iDropdownAsync
+from PuppeteerLibrary.locators.SelectorAbstraction import SelectorAbstraction
+
+
+class PuppeteerDropdown(iDropdownAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def select_from_list_by_value(self, locator, values):
+ selector_value = SelectorAbstraction.get_selector(locator)
+ if SelectorAbstraction.is_xpath(locator):
+ await self.library_ctx.get_current_page().get_page().evaluate('''
+ element = document.evaluate('{selector_value}//option[contains(@value, "{values}")]', document, null, XPathResult.ANY_TYPE, null).iterateNext();
+ element.selected = true;
+ '''.format(selector_value=selector_value, values=values))
+ else:
+ await self.library_ctx.get_current_page().get_page().select(selector_value, values)
+
+ async def select_from_list_by_label(self, locator, labels):
+ selector_value = SelectorAbstraction.get_selector(locator)
+ if SelectorAbstraction.is_xpath(locator):
+ await self.library_ctx.get_current_page().get_page().evaluate('''
+ element = document.evaluate('{selector_value}//option[text()=\"{label}\"]', document, null, XPathResult.ANY_TYPE, null).iterateNext();
+ element.selected = true;
+ '''.format(selector_value=selector_value, label=labels))
+ else:
+ await self.library_ctx.get_current_page().get_page().evaluate('''
+ selector_element = document.querySelector('{selector_value}');
+ element = document.evaluate('//option[text()=\"{label}\"]', selector_element, null, XPathResult.ANY_TYPE, null).iterateNext();
+ element.selected = true;
+ '''.format(selector_value=selector_value, label=labels))
+
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_element.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_element.py
new file mode 100644
index 0000000..c6253f8
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_element.py
@@ -0,0 +1,71 @@
+from robot.libraries.BuiltIn import BuiltIn
+from PuppeteerLibrary.ikeywords.ielement_async import iElementAsync
+
+
+class PuppeteerElement(iElementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ ##############################
+ # Click
+ ##############################
+ async def click_element(self, locator: str):
+ return await self.library_ctx.get_current_page().click_with_selenium_locator(locator)
+
+ async def upload_file(self, locator: str, file_path: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ await element.uploadFile(file_path)
+
+ ##############################
+ # Status
+ ##############################
+ async def element_should_be_enabled(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ is_disabled = await (await element.getProperty('disabled')).jsonValue()
+ if is_disabled:
+ raise AssertionError("Element '%s' is disabled. " % locator)
+ return element
+
+ async def element_should_be_disabled(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ is_disabled = await (await element.getProperty('disabled')).jsonValue()
+ if not is_disabled:
+ raise AssertionError("Element '%s' is enabled. " % locator)
+ return element
+
+ async def element_should_be_visible(self, locator:str):
+ try:
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(locator, 0.1, visible=True, hidden=False)
+ except:
+ raise AssertionError("Element '%s' is not be visible. " % locator)
+
+ async def element_should_not_be_visible(self, locator:str):
+ try:
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(locator, 0.1, visible=False, hidden=True)
+ except:
+ raise AssertionError("Element '%s' is visible. " % locator)
+
+ ##############################
+ # Property
+ ##############################
+ async def element_should_contain(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_contain(text, expected, ignore_case=ignore_case)
+
+ async def element_should_not_contain(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_not_contain(text, expected, ignore_case=ignore_case)
+
+ async def get_text(self, locator: str):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ return (await (await element.getProperty('textContent')).jsonValue())
+
+ async def element_text_should_be(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_be_equal_as_strings(text, expected, ignore_case=ignore_case)
+
+ async def element_text_should_not_be(self, locator: str, expected: str, ignore_case=False):
+ text = await self.get_text(locator)
+ return BuiltIn().should_not_be_equal_as_strings(text, expected, ignore_case=ignore_case)
+
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_formelement.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_formelement.py
new file mode 100644
index 0000000..b8dae0b
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_formelement.py
@@ -0,0 +1,20 @@
+from robot.libraries.BuiltIn import BuiltIn
+from PuppeteerLibrary.ikeywords.iformelement_async import iFormElementAsync
+
+
+class PuppeteerFormElement(iFormElementAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def input_text(self, locator: str, text: str, clear=True):
+ if clear:
+ await self._clear_input_text(locator)
+ await self.library_ctx.get_current_page().type_with_selenium_locator(locator, text)
+
+ async def clear_element_text(self, locator: str):
+ await self._clear_input_text(locator)
+
+ async def _clear_input_text(self, selenium_locator):
+ await self.library_ctx.get_current_page().click_with_selenium_locator(selenium_locator, {'clickCount': 3})
+ await self.library_ctx.get_current_page().get_page().keyboard.press('Backspace')
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_javascript.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_javascript.py
new file mode 100644
index 0000000..c54b53a
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_javascript.py
@@ -0,0 +1,10 @@
+from PuppeteerLibrary.ikeywords.ijavascript_async import iJavascriptAsync
+
+
+class PuppeteerJavascript(iJavascriptAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def execute_javascript(self, code):
+ return await self.library_ctx.get_current_page().get_page().evaluate(code)
diff --git a/PuppeteerLibrary/keywords/mockresponse_async.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mockresponse.py
similarity index 60%
rename from PuppeteerLibrary/keywords/mockresponse_async.py
rename to PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mockresponse.py
index ce91f41..b857577 100644
--- a/PuppeteerLibrary/keywords/mockresponse_async.py
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mockresponse.py
@@ -2,23 +2,22 @@
import re
from pyppeteer.network_manager import Request
from PuppeteerLibrary.base.robotlibcore import keyword
-from PuppeteerLibrary.base.librarycomponent import LibraryComponent
+from PuppeteerLibrary.ikeywords.imockresponse_async import iMockResponseAsync
-class MockResponseKeywordsAsync(LibraryComponent):
+class PuppeteerMockResponse(iMockResponseAsync):
- def __init__(self, ctx):
- self.ctx = ctx
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
- @keyword
- async def mock_current_page_api_response_async(self, url, mock_response, method='GET', body=None):
- page = self.ctx.get_current_page()
+ async def mock_current_page_api_response(self, url, mock_response, method='GET', body=None):
+ page = self.library_ctx.get_current_page().get_page()
await page.setRequestInterception(True)
page.on('request', lambda request:
asyncio.ensure_future(self.mock_api_response(request, url, mock_response, method, body)))
async def mock_api_response(self, request: Request, url, mock_response, method, body):
- if re.search(url, request.url) is not None and request.method == method:
+ if re.search(re.escape(url), request.url) is not None and request.method == method:
try:
pos_data = (await request.postData())
except:
@@ -26,4 +25,3 @@ async def mock_api_response(self, request: Request, url, mock_response, method,
if body is None or re.search(body, pos_data.replace('\n', '')):
return await request.respond(mock_response)
await request.continue_()
-
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mouseevent.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mouseevent.py
new file mode 100644
index 0000000..39ad689
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_mouseevent.py
@@ -0,0 +1,25 @@
+from PuppeteerLibrary.ikeywords.imouseevent_async import iMouseEventAsync
+
+
+class PuppeteerMouseEvent(iMouseEventAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def mouse_over(self, locator):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ await element.hover()
+
+ async def mouse_down(self, locator):
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
+ bounding_box = await element.boundingBox()
+ await self.library_ctx.get_current_page().get_page().mouse.move(
+ bounding_box['x'] + bounding_box['width'] / 2,
+ bounding_box['y'] + bounding_box['height'] / 2)
+ await self.library_ctx.get_current_page().get_page().mouse.down()
+
+ async def mouse_up(self):
+ await self.library_ctx.get_current_page().get_page().mouse.up()
+
+ async def mouse_move(self, x, y):
+ await self.library_ctx.get_current_page().get_page().mouse.move(int(x), int(y))
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_pdf.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_pdf.py
new file mode 100644
index 0000000..a7b4f2c
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_pdf.py
@@ -0,0 +1,13 @@
+from PuppeteerLibrary.ikeywords.ipdf_async import iPDFAsync, DEFAULT_FILENAME_PAGE
+
+
+class PuppeteerPDF(iPDFAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def print_as_pdf(self, filename=DEFAULT_FILENAME_PAGE):
+ path = self._get_pdf_path(filename)
+ await self.library_ctx.get_current_page().get_page().emulateMedia('screen')
+ await self.library_ctx.get_current_page().get_page().pdf({'path': path})
+ self.info('Print as pdf: '+path)
diff --git a/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_screenshot.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_screenshot.py
new file mode 100644
index 0000000..53f9290
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_screenshot.py
@@ -0,0 +1,12 @@
+from PuppeteerLibrary.ikeywords.iscreenshot_async import iScreenshotAsync
+
+
+class PuppeteerScreenshot(iScreenshotAsync):
+
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
+
+ async def capture_page_screenshot(self, path: str):
+ return await self.library_ctx.get_current_page().get_page().screenshot(
+ {'path': path}
+ )
diff --git a/PuppeteerLibrary/keywords/waiting_async.py b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_waiting.py
similarity index 56%
rename from PuppeteerLibrary/keywords/waiting_async.py
rename to PuppeteerLibrary/puppeteer/async_keywords/puppeteer_waiting.py
index 967709f..c23149b 100644
--- a/PuppeteerLibrary/keywords/waiting_async.py
+++ b/PuppeteerLibrary/puppeteer/async_keywords/puppeteer_waiting.py
@@ -1,16 +1,29 @@
import asyncio
-import time
import re
-from robot.utils import DotDict
-from PuppeteerLibrary.base.librarycomponent import LibraryComponent
-from PuppeteerLibrary.base.robotlibcore import keyword
+import time
+from robot.utils.dotdict import DotDict
+from PuppeteerLibrary.ikeywords.iwaiting_async import iWaitingAsync
+
+
+class PuppeteerWaiting(iWaitingAsync):
+ def __init__(self, library_ctx):
+ super().__init__(library_ctx)
-class WaitingKeywordsAsync(LibraryComponent):
+ async def _wait_for_selenium_selector(self, selenium_locator, timeout=None, visible=False, hidden=False):
+ timeout = self.timestr_to_secs_for_default_timeout(timeout)
+ return await self.library_ctx.get_current_page().waitForSelector_with_selenium_locator(selenium_locator, timeout, visible, hidden)
+
+ def escape_xpath_value(self, value):
+ if '"' in value and '\'' in value:
+ parts_wo_apos = value.split('\'')
+ return "concat('%s')" % "', \"'\", '".join(parts_wo_apos)
+ if '\'' in value:
+ return "\"%s\"" % value
+ return "'%s'" % value
- @keyword
- async def wait_for_request_url_async(self, url, method='GET', body=None, timeout=None):
- req = await self.ctx.get_current_page().waitForRequest(
+ async def wait_for_request_url(self, url, method='GET', body=None, timeout=None):
+ req = await self.library_ctx.get_current_page().get_page().waitForRequest(
lambda req: re.search(url, req.url) is not None
and req.method == method
, options={
@@ -36,9 +49,8 @@ async def wait_for_request_url_async(self, url, method='GET', body=None, timeout
'body': pos_data
})
- @keyword
- async def wait_for_response_url_async(self, url, status=200, body=None, timeout=None):
- res = await self.ctx.get_current_page().waitForResponse(
+ async def wait_for_response_url(self, url, status=200, body=None, timeout=None):
+ res = await self.library_ctx.get_current_page().get_page().waitForResponse(
lambda res: re.search(url, res.url) is not None
and res.status == int(status)
, options={
@@ -61,87 +73,73 @@ async def wait_for_response_url_async(self, url, status=200, body=None, timeout=
'body': res_text
})
- @keyword
- async def wait_for_navigation_async(self, timeout=None):
- await self.ctx.get_current_page().waitForNavigation(options={
+ async def wait_for_navigation(self, timeout=None):
+ await self.library_ctx.get_current_page().get_page().waitForNavigation(
+ options={
'timeout': self.timestr_to_secs_for_default_timeout(timeout) * 1000
})
- @keyword
- async def wait_for_selenium_selector(self, selenium_locator, timeout=None, visible=False, hidden=False):
- timeout = self.timestr_to_secs_for_default_timeout(timeout)
- return await self.ctx.get_current_page().waitForSelector_with_selenium_locator(selenium_locator, timeout, visible, hidden)
-
- @keyword
- async def wait_until_page_contains_element_async(self, selenium_locator, timeout=None):
- return await self.wait_for_selenium_selector(selenium_locator, timeout, visible=False, hidden=False)
+ async def wait_until_page_contains_element(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
- @keyword
- async def wait_until_element_is_hidden_async(self, locator, timeout=None):
- return await self.wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
+ async def wait_until_element_is_hidden(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
- @keyword
- async def wait_until_element_is_visible_async(self, locator, timeout=None):
- return await self.wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
+ async def wait_until_element_is_visible(self, locator, timeout=None):
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
- @keyword
- async def wait_until_page_contains_async(self, text, timeout=None):
+ async def wait_until_page_contains(self, text, timeout=None):
locator = "xpath://*[contains(., %s)]" % self.escape_xpath_value(text)
- return await self.wait_for_selenium_selector(locator, timeout)
+ return await self._wait_for_selenium_selector(locator, timeout, visible=True, hidden=False)
- @keyword
- async def wait_until_page_does_not_contains_async(self, text, timeout=None):
+ async def wait_until_page_does_not_contains(self, text, timeout=None):
locator = "xpath://*[contains(., %s)]" % self.escape_xpath_value(text)
- return await self.wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
+ return await self._wait_for_selenium_selector(locator, timeout, visible=False, hidden=True)
- @keyword
- async def wait_until_element_contains_async(self, selenium_locator, text, timeout=None):
+ async def wait_until_element_contains(self, locator, text, timeout=None):
async def validate_element_contains_text():
- return (text in (await (await ( await self.ctx.get_current_page().querySelector_with_selenium_locator(selenium_locator)).getProperty('textContent')).jsonValue()))
+ return (text in (await (await ( await self.library_ctx.get_current_page().
+ querySelector_with_selenium_locator(locator)).getProperty('textContent')).jsonValue()))
return await self._wait_until_worker(
validate_element_contains_text,
self.timestr_to_secs_for_default_timeout(timeout))
- @keyword
- async def wait_until_element_does_not_contains_async(self, selenium_locator, text, timeout=None):
+ async def wait_until_element_does_not_contains(self, locator, text, timeout=None):
async def validate_element_contains_text():
- return (text not in (await (await ( await self.ctx.get_current_page().querySelector_with_selenium_locator(selenium_locator)).getProperty('textContent')).jsonValue()))
+ return (text not in (await (await ( await self.library_ctx.get_current_page().
+ querySelector_with_selenium_locator(locator)).getProperty('textContent')).jsonValue()))
return await self._wait_until_worker(
validate_element_contains_text,
self.timestr_to_secs_for_default_timeout(timeout))
- @keyword
- async def wait_until_location_contains_async(self, expected, timeout=None):
+ async def wait_until_location_contains(self, expected, timeout=None):
async def validate_url_contains_text():
- return expected in self.ctx.get_current_page().url
+ return expected in self.library_ctx.get_current_page().get_page().url
return await self._wait_until_worker(
validate_url_contains_text,
self.timestr_to_secs_for_default_timeout(timeout))
- @keyword
- async def wait_until_location_does_not_contains_async(self, expected, timeout=None):
+ async def wait_until_location_does_not_contains(self, expected, timeout=None):
async def validate_url_not_contains_text():
- return expected not in self.ctx.get_current_page().url
+ return expected not in self.library_ctx.get_current_page().get_page().url
return await self._wait_until_worker(
validate_url_not_contains_text,
self.timestr_to_secs_for_default_timeout(timeout))
- @keyword
- async def wait_until_element_is_enabled_async(self, selenium_locator, timeout=None):
+ async def wait_until_element_is_enabled(self, locator, timeout=None):
async def validate_is_enabled():
- element = await self.ctx.get_current_page().querySelector_with_selenium_locator(selenium_locator)
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
is_disabled = await (await element.getProperty('disabled')).jsonValue()
return is_disabled == False
return await self._wait_until_worker(
validate_is_enabled,
self.timestr_to_secs_for_default_timeout(timeout),
- 'Element '+selenium_locator+' was not enabled.')
+ 'Element '+locator+' was not enabled.')
- @keyword
- async def wait_until_element_finished_animating_async(self, selenium_locator, timeout=None):
+ async def wait_until_element_finished_animating(self, locator, timeout=None):
prev_rect_tmp = { 'value': None }
async def check_finished_animating():
- element = await self.ctx.get_current_page().querySelector_with_selenium_locator(selenium_locator)
+ element = await self.library_ctx.get_current_page().querySelector_with_selenium_locator(locator)
if prev_rect_tmp['value'] is None:
prev_rect_tmp['value'] = await element.boundingBox()
return False
@@ -155,7 +153,7 @@ async def check_finished_animating():
return await self._wait_until_worker(
check_finished_animating,
self.timestr_to_secs_for_default_timeout(timeout),
- 'Element '+selenium_locator+' was not enabled.')
+ 'Element '+locator+' was not enabled.')
async def _wait_until_worker(self, condition, timeout, error=None):
max_time = time.time() + timeout
diff --git a/PuppeteerLibrary/puppeteer/custom_elements/__init__.py b/PuppeteerLibrary/puppeteer/custom_elements/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/PuppeteerLibrary/puppeteer/custom_elements/puppeteer_page.py b/PuppeteerLibrary/puppeteer/custom_elements/puppeteer_page.py
new file mode 100644
index 0000000..b1f92ca
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/custom_elements/puppeteer_page.py
@@ -0,0 +1,139 @@
+from typing import Any
+from pyppeteer.page import Page
+from PuppeteerLibrary.custom_elements.base_page import BasePage
+from PuppeteerLibrary.locators.SelectorAbstraction import SelectorAbstraction
+
+
+class PuppeteerPage(BasePage):
+
+ def __init__(self, page: Page):
+ self.page = page
+ self.selected_iframe = None
+
+ def get_page(self) -> Page:
+ return self.page
+
+ async def goto(self, url: str):
+ return await self.page.goto(url)
+
+ async def go_back(self):
+ return await self.page.goBack()
+
+ async def reload_page(self):
+ return await self.page.reload()
+
+ async def title(self):
+ return await self.page.title()
+
+ async def set_viewport_size(self, width: int, height: int):
+ self.page.setViewport({
+ width: width,
+ height: height
+ })
+
+ ############
+ # Click
+ ############
+ async def click_with_selenium_locator(self, selenium_locator: str, options: dict = None, **kwargs: Any):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ await self.click_xpath(selector_value, options, **kwargs)
+ else:
+ await self.click(selector_value, options, **kwargs)
+
+ async def click(self, selector: str, options: dict = None, **kwargs: Any):
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.click(selector=selector, options=options, kwargs=kwargs)
+ else:
+ return await self.page.click(selector=selector, options=options, kwargs=kwargs)
+
+ async def click_xpath(self, selector: str, options: dict = None, **kwargs: Any):
+ if self.selected_iframe is not None:
+ elements = await self.selected_iframe.xpath(selector)
+ return await elements[0].click(options, **kwargs)
+ else:
+ elements = await self.page.xpath(selector)
+ return await elements[0].click(options, **kwargs)
+
+ ############
+ # Type
+ ############
+ async def type_with_selenium_locator(self, selenium_locator: str, text: str, options: dict = None, **kwargs: Any):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ await self.type_xpath(selector=selector_value, text=text, options=options, kwargs=kwargs)
+ else:
+ await self.type(selector=selector_value, text=text, options=options, kwargs=kwargs)
+
+ async def type(self, selector, text: str, options: dict = None, **kwargs: Any):
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.type(selector=selector, text=text, options=options, kwargs=kwargs)
+ else:
+ return await self.page.type(selector=selector, text=text, options=options, kwargs=kwargs)
+
+ async def type_xpath(self, selector, text: str, options: dict = None, **kwargs: Any):
+ if self.selected_iframe is not None:
+ elements = await self.selected_iframe.xpath(selector)
+ await elements[0].type(text, options, **kwargs)
+ else:
+ elements = await self.page.xpath(selector)
+ await elements[0].type(text, options, **kwargs)
+
+ ############
+ # Wait
+ ############
+ async def waitForSelector_with_selenium_locator(self, selenium_locator: str, timeout: float, visible=False, hidden=False):
+ options = {
+ 'timeout': timeout * 1000,
+ 'visible': visible,
+ 'hidden': hidden
+ }
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ return await self._waitForXPath(xpath=selector_value, options=options)
+ else:
+ return await self._waitForSelector(selector=selector_value, options=options)
+
+ async def _waitForSelector(self, selector: str, options: dict = None):
+ if self.selected_iframe is None:
+ return await self.page.waitForSelector(selector=selector, options=options)
+ else:
+ return await self.selected_iframe.waitForSelector(selector=selector, options=options)
+
+ async def _waitForXPath(self, xpath: str, options: dict = None):
+ if self.selected_iframe is None:
+ return await self.page.waitForXPath(xpath=xpath, options=options)
+ else:
+ return await self.selected_iframe.waitForXPath(xpath=xpath, options=options)
+
+ ############
+ # Query
+ ############
+ async def querySelector(self, selector: str):
+ if self.selected_iframe is not None:
+ return await self.selected_iframe.querySelector(selector=selector)
+ else:
+ return await self.page.querySelector(selector=selector)
+
+ async def querySelectorAll_with_selenium_locator(self, selenium_locator: str):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ return await self.page.xpath(selector_value)
+ else:
+ return await self.page.querySelectorAll(selector_value)
+
+ async def querySelector_with_selenium_locator(self, selenium_locator: str):
+ selector_value = SelectorAbstraction.get_selector(selenium_locator)
+ if SelectorAbstraction.is_xpath(selenium_locator):
+ return (await self.page.xpath(selector_value))[0]
+ else:
+ return await self.page.querySelector(selector_value)
+
+ ##############################
+ # iframe
+ ##############################
+ def set_current_iframe(self, iframe):
+ self.selected_iframe = iframe
+
+ def unselect_iframe(self):
+ self.selected_iframe = None
diff --git a/PuppeteerLibrary/puppeteer/puppeteer_context.py b/PuppeteerLibrary/puppeteer/puppeteer_context.py
new file mode 100644
index 0000000..5301588
--- /dev/null
+++ b/PuppeteerLibrary/puppeteer/puppeteer_context.py
@@ -0,0 +1,124 @@
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_mockresponse import PuppeteerMockResponse
+import sys
+from pyppeteer import launch
+from pyppeteer.browser import Browser
+from PuppeteerLibrary.custom_elements.base_page import BasePage
+from PuppeteerLibrary.library_context.ilibrary_context import iLibraryContext
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_alert import PuppeteerAlert
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_screenshot import PuppeteerScreenshot
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_waiting import PuppeteerWaiting
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_browsermanagement import PuppeteerBrowserManagement
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_dropdown import PuppeteerDropdown
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_element import PuppeteerElement
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_formelement import PuppeteerFormElement
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_mouseevent import PuppeteerMouseEvent
+from PuppeteerLibrary.puppeteer.custom_elements.puppeteer_page import PuppeteerPage
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_pdf import PuppeteerPDF
+from PuppeteerLibrary.puppeteer.async_keywords.puppeteer_javascript import PuppeteerJavascript
+from PuppeteerLibrary.utils.device_descriptors import DEVICE_DESCRIPTORS
+
+
+class PuppeteerContext(iLibraryContext):
+
+ browser: Browser = None
+ contexts = {}
+ current_page = None
+ current_iframe = None
+
+ debug_mode: bool = False
+ debug_mode_options: dict = {
+ 'slowMo': 200,
+ 'devtools': False
+ }
+
+ def __init__(self, browser_type: str):
+ super().__init__(browser_type)
+
+ async def start_server(self, options: dict=None):
+ default_args = []
+ default_options = {
+ 'slowMo': 0,
+ 'headless': True,
+ 'devtools': False,
+ 'width': 1366,
+ 'height': 768
+ }
+ merged_options = default_options
+
+ if options is not None:
+ merged_options = {**merged_options, **options}
+
+ if self.debug_mode is True:
+ merged_options = {**merged_options, **self.debug_mode_options}
+
+ if 'win' not in sys.platform.lower():
+ default_args = ['--no-sandbox', '--disable-setuid-sandbox']
+
+ self.browser = await launch(
+ headless=merged_options['headless'],
+ slowMo=merged_options['slowMo'],
+ devtools=merged_options['devtools'],
+ defaultViewport={
+ 'width': merged_options['width'],
+ 'height': merged_options['height']
+ },
+ args=default_args)
+
+ async def stop_server(self):
+ await self.browser.close()
+ self._reset_context()
+
+ def is_server_started(self) -> bool:
+ if self.browser is not None:
+ return True
+ return False
+
+ async def create_new_page(self, options: dict=None) -> BasePage:
+ new_page = await self.browser.newPage()
+ self.current_page = PuppeteerPage(new_page)
+ if 'emulate' in options:
+ await self.current_page.get_page().emulate(DEVICE_DESCRIPTORS[options['emulate']])
+ return self.current_page
+
+ def get_current_page(self) -> BasePage:
+ return self.current_page
+
+ def set_current_page(self, page: any) -> BasePage:
+ self.current_page = PuppeteerPage(page)
+ return self.current_page
+
+ async def get_all_pages(self):
+ return await self.browser.pages()
+
+ def get_browser_context(self):
+ return self.browser
+
+ async def close_browser_context(self):
+ await self.browser.close()
+
+ def get_async_keyword_group(self, keyword_group_name: str):
+ switcher = {
+ "AlertKeywords": PuppeteerAlert(self),
+ "BrowserManagementKeywords": PuppeteerBrowserManagement(self),
+ "DropdownKeywords": PuppeteerDropdown(self),
+ "ElementKeywords": PuppeteerElement(self),
+ "FormElementKeywords": PuppeteerFormElement(self),
+ "JavascriptKeywords": PuppeteerJavascript(self),
+ "MockResponseKeywords": PuppeteerMockResponse(self),
+ "MouseEventKeywords": PuppeteerMouseEvent(self),
+ "PDFKeywords": PuppeteerPDF(self),
+ "ScreenshotKeywords": PuppeteerScreenshot(self),
+ "WaitingKeywords": PuppeteerWaiting(self)
+ }
+ return switcher.get(keyword_group_name)
+
+ def _reset_context(self):
+ browser = None
+ contexts = {}
+ current_page = None
+ current_iframe = None
+ debug_mode = False
+ debug_mode_options = {
+ 'slowMo': 200,
+ 'devtools': False
+ }
diff --git a/PuppeteerLibrary/utils/device_descriptors.py b/PuppeteerLibrary/utils/device_descriptors.py
index 5f04581..b5d4a1f 100644
--- a/PuppeteerLibrary/utils/device_descriptors.py
+++ b/PuppeteerLibrary/utils/device_descriptors.py
@@ -430,6 +430,17 @@
'isLandscape': True
}
},
+ 'iPhone 11': {
+ 'userAgent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0 Mobile/15E148 Safari/604.1',
+ 'viewport': {
+ 'width': 414,
+ 'height': 896,
+ 'deviceScaleFactor': 2,
+ 'isMobile': True,
+ 'hasTouch': True,
+ 'isLandscape': False
+ }
+ },
'JioPhone 2': {
'userAgent': 'Mozilla/5.0 (Mobile; LYF/F300B/LYF-F300B-001-01-15-130718-i;Android; rv:48.0) Gecko/48.0 Firefox/48.0 KAIOS/2.5',
'viewport': {
diff --git a/README.md b/README.md
index 2a4bfcc..e58ffb6 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
# robotframework-puppeteer
Robot Framework Puppeteer Library powered by [Pyppeteer](https://github.com/pyppeteer/pyppeteer).
-Improve automated web testing with native functionality from [Puppeteer](https://github.com/puppeteer/puppeteer) by Google.
+Improve automated web testing with chrome native functionality from [Puppeteer](https://github.com/puppeteer/puppeteer) by Google and webkit from [Playwright](https://github.com/microsoft/playwright-python).
More detail please visit [Robot Framework Puppeteer Homepage](https://qahive.github.io/robotframework-puppeteer.github.io/)
@@ -14,6 +14,15 @@ Example:
- _Intercepter javascript function_
+Browser Support
+---------------------
+| | Support | Library |
+| :--- | :---: | :---: | :---: |
+| Chromium | ✅ | Puppeteer |
+| WebKit | ✅ | Playwright |
+| Firefox | ✅ | Playwright |
+
+
Keyword documentation
---------------------
See [`keyword documentation`](https://qahive.github.io/robotframework-puppeteer/PuppeteerLibrary.html) for available keywords and more information about the library in general.
@@ -25,6 +34,7 @@ Installation
The recommended installation method is using pip_::
pip install --upgrade robotframework-puppeteerlibrary
+ python -m playwright install
Or manually install by running following command
diff --git a/requirements.txt b/requirements.txt
index 833876f..a78446c 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,5 +1,6 @@
versioneer>=0.18
robotframework>=3.2.1
+playwright==0.151.0
# pyppeteer>=0.2.2
-git+https://github.com/qahive/pyppeteer.git@dev
+git+https://github.com/qahive/pyppeteer.git@dev2
robotframework-libdoc2json>=0.4
\ No newline at end of file
diff --git a/setup.py b/setup.py
index 38ace87..e1fa57c 100644
--- a/setup.py
+++ b/setup.py
@@ -39,7 +39,8 @@
platforms='any',
install_requires=[
'robotframework>=3.2.1',
- 'pyppeteer>=0.2.2'
+ 'playwright>=0.151.0',
+ 'pyppeteer>=0.2.2',
],
# python_requires='>3.5',
# test_suite='nose.collector',
|