SurfCustomCalabash 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc36d47dbb465e8902af53b0d6519f9caf644ef1
-  data.tar.gz: b6fab405830127ae15c75932c68ec40114b4cd74
+  metadata.gz: 9e4de4a6c1d6a35f5de695fa6b77244fef2274f8
+  data.tar.gz: 46d22f0d943ea780e1473260c9c417ac25ced891
 SHA512:
-  metadata.gz: 41d1423cf682108dbde016efebcfa9a36b7ab6ac77d409aafc01bede5a1dd5209d93440f9225fe64ed04a7724380925b7d01ea43b1c19815db8eeafc2051a307
-  data.tar.gz: 739e4e246b6c0f2b40691b7f8d75b61cc4059748a316d156906faf1b2b62533d772b0efc3e80134f83352e7b3ff760c6ce1e02fec1d199f4b35618a665eb156e
+  metadata.gz: 63b95cd838c704068f02b7cb151e7a6bc2f7fb720edd861bc6f0e3f71d299acf16564105a28e096ed2b763c53d9d6966e9c546e1f905b8a3cad75365231cf549
+  data.tar.gz: 80f508a5a6e11806174305f88206a0f6ad76a5056b20dcf27bcab795c2833cb50c485a8baaf7a4857d140b068a94168628ccaf189a793c221b248a70003b7323

data/lib/SurfCustomCalabash/CommonMethods.rb

@@ -7,9 +7,9 @@ require 'rspec/expectations'
 
   # ----------------------------------------------Custom Taps-----------------------------------------------------------
   # wait element and tap
-  def tap_on(element)
-    wait_for_elements_exist(element, :timeout=>15, :retry_frequency=>5)
-    sleep(0.5)
+def tap_on(element, timeout_duration: 15, sleep_duration: 0.5)
+    wait_for_elements_exist(element, :timeout=>timeout_duration, :retry_frequency=>5)
+    sleep(sleep_duration)
     touch(element)
   end
 
@@ -18,90 +18,92 @@ require 'rspec/expectations'
   end
 
   # if element exists - tap, if not - swipe until element exists and tap
-  def tap_or_swipe(element)
+def tap_or_swipe(element, timeout_duration: 30)
     if element_exists(element)
-      sleep(1)
+      sleep(2)
       touch(element)
     else
-      until_element_exists(element,:action => lambda{light_swipe('down')},  :timeout => 30)
+      until_element_exists(element,:action => lambda{light_swipe('down')},  :timeout => timeout_duration)
       light_swipe('down')
-      sleep(1)
+      sleep(2)
       touch(element)
     end
   end
 
   # ----------------------------------------------------Custom Waits----------------------------------------------------
-  def wait_element(element)
-    wait_for_element_exists(element, :timeout=>15)
+  def wait_element(element, timeout_duration: 15)
+    wait_for_element_exists(element, :timeout=>timeout_duration)
   end
 
-  def wait_no_element(element)
-    wait_for_element_does_not_exist(element, :timeout=>15)
+  def wait_no_element(element, timeout_duration: 15)
+    wait_for_element_does_not_exist(element, :timeout=>timeout_duration)
   end
 
   # wait trait-element on screen
-  def wait_for_screen
-    wait_for_elements_exist(trait, :timeout=>25)
+  def wait_for_screen(timeout_duration: 25)
+    wait_for_elements_exist(trait, :timeout=>timeout_duration)
   end
 
   # ----------------------------------------------------Custom Swipe----------------------------------------------------
-  def strong_swipe_until_not_exist(dir, element_destination)
+  def strong_swipe_until_not_exist(dir, element_destination, timeout_duration: 40)
     until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{strong_swipe(dir)})
+                                 :action =>  lambda{strong_swipe(dir)}, :timeout => timeout_duration)
   end
 
-  def normal_swipe_until_not_exist(dir, element_destination)
+  def normal_swipe_until_not_exist(dir, element_destination, timeout_duration: 40)
     until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{normal_swipe(dir)})
+                                 :action =>  lambda{normal_swipe(dir)}, :timeout => timeout_duration)
   end
 
-  def light_swipe_until_not_exist(dir, element_destination)
+  def light_swipe_until_not_exist(dir, element_destination, timeout_duration: 40)
     until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe( dir)})
+                                 :action =>  lambda{light_swipe( dir)}, :timeout => timeout_duration)
   end
 
-  def strong_swipe_until_exists(dir, element_destination)
+  def strong_swipe_until_exists(dir, element_destination, timeout_duration: 40)
     until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe( dir)})
+                         :action =>  lambda{strong_swipe( dir)}, :timeout => timeout_duration)
   end
 
-  def normal_swipe_until_exists(dir, element_destination)
+  def normal_swipe_until_exists(dir, element_destination, sleep_duration: 2, timeout_duration: 40)
     until_element_exists(element_destination,
-                         :action =>  lambda{normal_swipe( dir); sleep(2)}, :timeout=>40)
+                         :action =>  lambda{normal_swipe( dir); sleep(sleep_duration)}, :timeout=>timeout_duration)
   end
 
-  def light_swipe_until_exists(dir, element_destination)
+  def light_swipe_until_exists(dir, element_destination, sleep_duration: 2, timeout_duration: 40)
     until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe( dir); sleep(2)}, :timeout=>60)
+                         :action =>  lambda{light_swipe( dir); sleep(sleep_duration)}, :timeout=>timeout_duration)
 
   end
 
-  def strong_swipe_element_until_exists(dir, element, element_destination)
+  def strong_swipe_element_until_exists(dir, element, element_destination, timeout_duration: 40)
     until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe_element(element, dir)})
+                         :action =>  lambda{strong_swipe_element(element, dir)}, :timeout=>timeout_duration)
   end
 
-  def light_swipe_element_until_exists(dir, element, element_destination)
+  def light_swipe_element_until_exists(dir, element, element_destination, timeout_duration: 40)
     until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+                         :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>timeout_duration)
   end
 
-  def strong_swipe_element_until_not_exists(dir, element, element_destination)
+  def strong_swipe_element_until_not_exists(dir, element, element_destination, timeout_duration: 40)
     until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{pan(element, dir)})
+                                 :action =>  lambda{pan(element, dir)}, :timeout=>timeout_duration)
   end
 
-  def light_swipe_element_until_not_exists(dir, element, element_destination)
+  def light_swipe_element_until_not_exists(dir, element, element_destination, timeout_duration: 40)
     until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+                                 :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>timeout_duration)
   end
 
-  def swipe_to_text(dir, text)
+  def swipe_to_text(dir, text, timeout_duration: 60)
     sleep(1)
-    if dir == 'вверх'
-      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('up'); sleep(1)}, :timeout => 60)
-    elsif dir == 'вниз'
-      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('down'); sleep(1.5)}, :timeout => 60)
+    if dir == 'up'
+      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('up');
+      sleep(1)}, :timeout => timeout_duration)
+    elsif dir == 'down'
+      until_element_exists("* {text CONTAINS'#{text}'}", :action =>  lambda{light_swipe('down');
+      sleep(1.5)}, :timeout => timeout_duration)
     end
   end
 
@@ -110,7 +112,7 @@ require 'rspec/expectations'
     begin
       expect(element1).to eq(element2)
       true
-    rescue Exception => e
+    rescue RSpec::Expectations::ExpectationNotMetError
       false
     end
   end
@@ -169,8 +171,8 @@ require 'rspec/expectations'
   end
 
   # get text from first element
-  def remember(element)
-    wait_for_element_exists(element, :timeout => 5)
+  def remember(element, timeout_duration: 5)
+    wait_for_element_exists(element, :timeout => timeout_duration)
     sleep(1.5)
     name = query(element)
     save_name = name.first['text']
@@ -179,8 +181,8 @@ require 'rspec/expectations'
   end
 
   # get text from last element
-  def remember_last_text(element)
-    wait_for_element_exists(element, :timeout => 5)
+  def remember_last_text(element, timeout_duration: 5)
+    wait_for_element_exists(element, :timeout => timeout_duration)
     sleep(1.5)
     name = query(element)
     save_name = name.last['text']
@@ -189,12 +191,12 @@ require 'rspec/expectations'
   end
 
   # wait text
-  def check_text(text)
-    wait_for_element_exists("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 2)
+  def check_text(text, timeout_duration: 5)
+    wait_for_element_exists("* {text CONTAINS'#{text}'}", :timeout => timeout_duration, :retry_frequency => 2)
   end
 
-  def no_check_text(text)
-    wait_for_element_does_not_exist("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 5)
+  def no_check_text(text, timeout_duration: 5)
+    wait_for_element_does_not_exist("* {text CONTAINS'#{text}'}", :timeout => timeout_duration, :retry_frequency => 5)
   end
 
   # get element's coordinates

data/lib/SurfCustomCalabash/DroidMethods.rb

@@ -77,9 +77,9 @@ require 'SurfCustomCalabash/CommonMethods'
   end
 
   # swipe trait-element from element_destination
-  def light_swipe_trait_until_exists(dir, element_destination)
+  def light_swipe_trait_until_exists(dir, element_destination, timeout_duration: 50)
     until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe_element(trait, dir)}, :timeout=>50)
+                         :action =>  lambda{light_swipe_element(trait, dir)}, :timeout=>timeout_duration)
   end
 
   # pull-to-refresh screen

data/lib/SurfCustomCalabash/version.rb

@@ -1,3 +1,3 @@
 module SurfCustomCalabash
-  VERSION = "0.1.7"
+  VERSION = "0.1.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: SurfCustomCalabash
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Alexey Hripunov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-27 00:00:00.000000000 Z
+date: 2019-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler