Add support run async keywords with first complete keywords (#51)

* init asnyc with first result

* Add suport run async with first complete

* Add demo exception cases

* Update wait for page contain element async keywords

* Fix missing async error

Author: atthaboon

Examples/form-handler/iframe.robot

@@ -13,9 +13,6 @@ ${HOME_PAGE_URL}    http://127.0.0.1:7272/basic-html-elements.html
 Interact with iframe element
     Wait Until Page Contains Element    id=ifrm
     Select Frame    id=ifrm
-    # Input Text not support iframe
-    # Input Text    id=exampleInputEmail1    demo@qahive.com
-    # Input Text    id=exampleInputPassword1    123456789
     Click Element    id=exampleCheck1
 
 *** Keywords ***

Examples/utilities/asyncio.robot

@@ -0,0 +1,29 @@
+*** Settings ***
+Library    PuppeteerLibrary
+Test Setup    Open browser to test page
+Test Teardown    Close All Browser
+Suite Teardown    Close Puppeteer
+
+*** Variables ***
+${HOME_PAGE_URL}    http://127.0.0.1:7272/basic-html-elements.html
+
+
+*** Test Cases ***
+Run Async Keywords and wait for first completed keyword
+    ${result} =    Run Async Keywords And Return First Completed
+    ...    Click Element    id=non_existing_id    AND
+    ...    Click Element    id=get_ajax
+    Should Be Equal As Integers    1    ${result}    
+    Run Keyword If    ${result} == 0    Log    first keyword completed
+    Run Keyword If    ${result} == 1    Log    second keyword completed
+    
+Ignore error Run Async Keywords and Return First Complete if no keyword success
+    Run Keyword And Expect Error    All async keywords failed*    Run Async Keywords And Return First Completed
+    ...    Click Element    id=non_existing_id    AND
+    ...    Click Element    id=non_existing_id2
+
+*** Keywords ***
+Open browser to test page
+    ${HEADLESS}     Get variable value    ${HEADLESS}    ${False}
+    &{options} =    create dictionary   headless=${HEADLESS}
+    Open browser    ${HOME_PAGE_URL}   options=${options}

PuppeteerLibrary/keywords/utility.py

@@ -6,15 +6,57 @@
 
 class UtilityKeywords(LibraryComponent):
 
+    @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
+        
+        ``Return`` Array of result for each keywords based on index
+
+        Example
+        | `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)))
+            index += 1
+        statements = org_statements
+        error_stack_trace = ''
+        while True:
+            done, pending = await asyncio.wait(statements, return_when=asyncio.FIRST_COMPLETED)
+            statements = pending
+            for future in done:
+                try:
+                    # Raise an exception if coroutine failed
+                    result_index = future.result()
+                    # Force cancel all pending
+                    for p in pending:
+                        p.cancel()
+                    return result_index
+                except Exception as e:
+                    error_stack_trace += str(e)+'\n'
+                    continue
+            if len(pending) == 0:
+                raise Exception("All async keywords failed \r\n"+ error_stack_trace)
+        
     @keyword
     def run_async_keywords(self, *keywords):
-        # Ensure that script load async keywords before run async keywords function
         """Executes all the given keywords in a asynchronous and wait until all keyword is completed
 
-        ``Return`` Array of return for reach keywords based on index
+        ``Return`` Array of result for each keywords based on index
 
         Example:
-
         | Open browser         | ${HOME_PAGE_URL}      | options=${options}          |     |
         | `Run Async Keywords` | Click Element         | id:login_button             | AND |
         | ...                  | Wait for response url | ${HOME_PAGE_URL}/home.html  |     |
@@ -23,7 +65,7 @@ def run_async_keywords(self, *keywords):
         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))) )
-
+        
     async def _run_async_keywords(self, iterable):
         statements = []
         for kw, args in iterable:

PuppeteerLibrary/keywords/waiting.py

@@ -100,7 +100,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_for_selenium_selector(locator, timeout))
+        return self.loop.run_until_complete(self.async_func.wait_until_page_contains_element_async(locator, timeout))
 
     @keyword
     def wait_until_element_is_hidden(self, locator, timeout=None):

PuppeteerLibrary/keywords/waiting_async.py

@@ -70,7 +70,11 @@ async def wait_for_navigation_async(self, timeout=None):
     @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)
-        await self.ctx.get_current_page().waitForSelector_with_selenium_locator(selenium_locator, timeout, visible, hidden)
+        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)
 
     @keyword
     async def wait_until_element_is_hidden_async(self, locator, timeout=None):