SurfCustomCalabash 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5783c8d5dd0f7b7aa8faf7e231b7c550b4c32bdd
-  data.tar.gz: b0e76a7a96c1d707d3b627789b334c8502e07f5f
+SHA256:
+  metadata.gz: 10324a3851f0d2c8a774575861c3489d6519d9a6fed70ac48244565ed9c03da6
+  data.tar.gz: 70572d7c07b601e2407cc9cf8e0d3317a680b919afb56faca9be2d3cb9f68f04
 SHA512:
-  metadata.gz: 384d562cfc65bd410888bbeb61e8e7b9814d62ec680617254381442239939b6ca90f85b696226d7a43bfb42e979e602766d4bfd51195a80b6aa3f515745b3b27
-  data.tar.gz: 045a65d035bab415b2f99c1428446f23d97f0dd5f3db3e0bcd1dd7c677ffa12dba6e8e5793c7297d281bf51d2911ae568d59f66276b742cc65eeb1fa9cac0e8b
+  metadata.gz: 4092df2ff8c18a451ad3e0132accbb3eae2c66ee24526e43d7c0adfa51f17e47234f8573999d248df0de0eb24a91f264fed8cd1310a8784309e44eb5776bdc57
+  data.tar.gz: 89d7c2269fd6aa04b72eb58ace406dad941a2dcaf2ae84559729802ff1ea65e65e39db5d1902577e70df131b35f5e4e13f8abdebfe3b2054e798caa336eac22d

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+
+## v1.0.0 - 28.08.2020
+### Added
+- Changelog.md
+- Added template file for initializing a new autotest project (use **SurfCustomCalabash gen**)
+
+### Changed
+- method close_keybord can now be called with optional parameters **x_start** and **y_start** (by default **x_start:** 100, **y_start:** 150) 

data/README.md

@@ -21,11 +21,75 @@ Or install it yourself as:
 
 This gem provides methods for easier use Calabash.
 
-Install gem in your project, add require 'SurfCustomCalabash/IosCommon' and 'SurfCustomCalabash/DroidCommon' in your ios or android ruby files.
+Install gem in your exist project, add in your ios or android ruby files.
 
-IosCommon contains custom swipe methods for ios.
+    $require 'SurfCustomCalabash/IosCommon' 
+    
+    $require 'SurfCustomCalabash/DroidCommon' 
+
+**IosCommon** contains custom swipe methods for ios.
+ 
+**DroidCommon** contains custom swipe methods for android.
+
+**CommonMethods** contains different methods (taps, swipes, waits and other) for both platforms.
+
+### Create new project
+You should move to the directory which would contains folder with your tests. 
+surf-calabash will create it by itself with the name **Change_it_to_your_own_project_name**: 
+    
+    $ SurfCustomCalabash gen
+    
+After that you'll see many folders inside them. Each of them will be describe below. 
+
+#### ci 
+
+It is used for all scripts for continuous integration. In Surfstudio we have .groovy files for them.
  
-DroidCommon contains custom swipe methods for android.
+ 
+#### config
+
+Contains only cucumber.yml file. It named arguments are called profiles - e.g. iOS or Android for run.
+
+
+#### features 
+
+Main folder of all project. Every feature, step definition, support files and page objects are here. You can read about it more in each file of this folder.
+
+
+#### irbrcs
+
+Our own shtick. We change calabash-android console and calabash-ios console a little, so you can write your own complex functions, which you'll implement in the step_definitions or in page objects. So for the correct work we had to change irbrc-files of gems too. 
+
+#### reports 
+
+Folder with screenshots of errors.
+
+
+#### test_servers
+
+Standard calabash-android folder with signed apk-files. 
+
+#### TestFolder 
+
+Contains some additional files, e.g. jpg-pictures or other data which can be used in tests. 
+
+#### Backdoors list
+
+We use backdoors for our applications for get around the limit of nativity of calabash.
+
+#### Gemfile 
+
+All required gems for surf-calabash. You should run installing all gems by bundle after initializing project when you rename **Change_it_to_your_own_project_name** to your own name.
+
+    $bundle install
+
+#### Scripts 
+
+Some shell scripts which can help to start tests faster because of typing smaller count of symbols. :) 
+Also it shows some integration with Xray Jira plugin. 
+
+#### start.sh
 
-CommonMethods contains different methods (taps, swipes, waits and other) for both platforms.
+Shell script for useful launch all helpful scripts of folder above.
 
+ 

data/SurfCustomCalabash.gemspec

@@ -6,7 +6,7 @@ require "SurfCustomCalabash/version"
 Gem::Specification.new do |spec|
   spec.name          = "SurfCustomCalabash"
   spec.version       = SurfCustomCalabash::VERSION
-  spec.authors       = ["Alexey Hripunov"]
+  spec.authors       = ["Alexey Hripunov", "Igor Tolubaev"]
   spec.email         = ["hripunov@surfstudio.ru"]
 
   spec.summary       = "Custom methods for calabash ios and android"
@@ -32,9 +32,9 @@ Gem::Specification.new do |spec|
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  # spec.bindir        = "exe"
+  spec.executables   = ["SurfCustomCalabash"]
+  # spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.17"
   spec.add_development_dependency "rake", "~> 10.0"

data/bin/SurfCustomCalabash

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'rbconfig'
+
+# for ruby 1.9.1 and earlier
+unless defined? RbConfig.ruby
+  def RbConfig.ruby
+    File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"] + RbConfig::CONFIG["EXEEXT"])
+  end
+end
+
+require File.join(File.dirname(__FILE__), "surf-calabash-helpers")
+
+@hierarchy = File.join(FileUtils.pwd, "Change_it_to_your_own_project_name")
+@source_dir = File.join(File.dirname(__FILE__), '..', 'sources')
+
+if ARGV.length == 0
+  print_usage
+else
+  cmd = ARGV.shift
+
+  case cmd
+    when 'help'
+      print_help
+    when 'gen'
+      gen = File.join(File.dirname(__FILE__), "surf-calabash-gen")
+      require gen
+      surf_gen
+    when 'android_console'
+      require 'calabash-android/helpers'
+      require 'calabash-android/utils'
+      require 'calabash-android/java_keystore'
+      require 'calabash-android/env'
+      require File.join(File.dirname(__FILE__), "surf-calabash-console")
+
+      if ARGV.empty? or not is_apk_file?(ARGV.first)
+        Kernel.puts "The first parameter must be the path to the apk file."
+        exit 1
+      else
+        android_console(relative_to_full_path(ARGV.shift))
+      end
+
+    when 'ios_console'
+      require File.join(File.dirname(__FILE__), "surf-calabash-console")
+      ios_console
+    when 'version'
+      require_relative '../lib/SurfCustomCalabash/version'
+      Kernel.puts SurfCustomCalabash::VERSION
+    else
+      Kernel.puts "Invalid command '#{cmd}'"
+      print_usage
+  end
+end

data/bin/surf-calabash-console.rb

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'rbconfig'
+
+def android_console(app_path = nil)
+  test_server_path = test_server_path(app_path)
+
+  path = ENV['CALABASH_IRBRC']
+  Kernel.puts(path)
+
+  unless path
+    if File.exist?('irbrc')
+      path = File.expand_path('irbrc')
+    end
+  end
+
+  unless path
+    path = File.expand_path(File.join(File.dirname(__FILE__), '../sources/irbrcs/android', 'irbrc'))
+  end
+
+  ENV['IRBRC'] = path
+  Kernel.puts(path)
+
+  unless ENV['APP_PATH']
+    ENV['APP_PATH'] = app_path
+  end
+
+  unless ENV['TEST_APP_PATH']
+    ENV['TEST_APP_PATH'] = test_server_path
+  end
+
+  build_test_server_if_needed(app_path)
+
+  Kernel.puts 'Starting calabash-android console...'
+  Kernel.puts "Loading #{ENV['IRBRC']}"
+  Kernel.puts 'Running irb...'
+  exec('irb')
+end
+
+def is_apk_file?(file_path)
+  file_path.end_with? ".apk" and File.exist? file_path
+end
+
+def relative_to_full_path(file_path)
+  File.expand_path(file_path)
+end
+
+def ios_console
+  path = ENV['CALABASH_IRBRC']
+  unless path
+    if File.exist?('.irbrc')
+      path = File.expand_path('.irbrc')
+    end
+  end
+  unless path
+    path = File.expand_path(File.join(File.dirname(__FILE__), '../sources/irbrcs/ios', 'irbrc'))
+  end
+  ENV['IRBRC'] = path
+  puts "Running irb..."
+  exec("irb")
+end

data/bin/surf-calabash-gen.rb

@@ -0,0 +1,17 @@
+def surf_gen
+  if File.exists?(@hierarchy)
+    Kernel.puts "hierarchy is already created. Stopping..."
+    exit 1
+  end
+  msg("Question") do
+    Kernel.puts "I'm about to create a subdirectory called sources."
+    Kernel.puts "Please change name of it to name of your own project."
+    Kernel.puts "Please hit return to confirm that's what you want."
+  end
+  exit 2 unless STDIN.gets.chomp == ''
+
+  FileUtils.cp_r(@source_dir, @hierarchy)
+  msg("Info") do
+      Kernel.puts "hierarchy was created. \n"
+  end
+end

data/bin/surf-calabash-helpers.rb

@@ -0,0 +1,34 @@
+require 'tempfile'
+require 'json'
+require "rubygems"
+
+def msg(title, &block)
+  Kernel.puts "\n" + "-"*10 + title + "-"*10
+  block.call
+  Kernel.puts "-"*10 + "-------" + "-"*10 + "\n"
+end
+
+def print_usage
+  Kernel.puts <<EOF
+  Usage: SurfCustomCalabash <command-name> [parameters] [options]
+  <command-name> can be one of
+    help
+      prints more detailed help information.
+    gen
+      generate a features folder structure.
+    version
+      prints the gem version
+
+  <options> can be
+    -v, --verbose
+      Turns on verbose logging
+EOF
+end
+
+def print_help
+  print_usage
+end
+
+def is_json?(str)
+  str[0..0] == '{'
+end

data/lib/SurfCustomCalabash/CommonMethods.rb

@@ -1,280 +1,365 @@
 require 'rspec/expectations'
 
-module CommonMethods
-
+def enter_text_from_keyboard(text, timeout_duration: 5)
+  wait_for_keyboard(timeout: timeout_duration)
+  keyboard_enter_text(text)
+end
 
-  def enter_text(text)
-    wait_for_keyboard(:timeout=>5)
-    keyboard_enter_text(text)
-  end
+# ----------------------------------------------Custom Taps-----------------------------------------------------------
+# wait element and tap
+def tap_on(element, timeout_duration: 15, sleep_duration: 0.5)
+  wait_element(element, timeout_duration: timeout_duration, sleep_duration: sleep_duration)
+  touch(element)
+end
 
-  # ----------------------------------------------Custom Taps-----------------------------------------------------------
-  # wait element and tap
-  def tap_on(element)
-    wait_for_elements_exist(element, :timeout=>15, :retry_frequency=>5)
-    sleep(0.5)
-    touch(element)
-  end
+def tap_on_text(text, timeout_duration: 15, sleep_duration: 0.5)
+  tap_on("* {text CONTAINS'#{text}'}", timeout_duration: timeout_duration, sleep_duration: sleep_duration)
+end
 
-  def tap_on_text(text)
-    tap_on("* {text CONTAINS'#{text}'}")
+# if element exists - tap, if not - swipe until element exists and tap
+def tap_or_swipe(element, timeout_duration: 30, sleep_duration: 0.5)
+  if element_does_not_exist(element)
+    light_swipe_until_exists('down', element, timeout_duration: timeout_duration)
   end
+  tap_on(element, sleep_duration: sleep_duration)
+end
 
-  # if element exists - tap, if not - swipe until element exists and tap
-  def tap_or_swipe(element)
-    if element_exists(element)
-      sleep(1)
-      touch(element)
-    else
-      until_element_exists(element,:action => lambda{light_swipe('down')},  :timeout => 30)
-      light_swipe('down')
-      sleep(1)
-      touch(element)
-    end
-  end
+# ----------------------------------------------------Custom Waits----------------------------------------------------
+def wait_element(element, timeout_duration: 15, sleep_duration: 0, retry_frequency: 0.3)
+  wait_for_element_exists(element, timeout: timeout_duration, retry_frequency: retry_frequency)
+  sleep(sleep_duration)
+end
 
-  # ----------------------------------------------------Custom Waits----------------------------------------------------
-  def wait_element(element)
-    wait_for_element_exists(element, :timeout=>15)
-  end
+def wait_no_element(element, timeout_duration: 15, sleep_duration: 0, retry_frequency: 0.3)
+  wait_for_element_does_not_exist(element, timeout: timeout_duration, retry_frequency: retry_frequency)
+  sleep(sleep_duration)
+end
 
-  def wait_no_element(element)
-    wait_for_element_does_not_exist(element, :timeout=>15)
-  end
+# wait trait-element on screen
+def wait_for_screen(timeout_duration: 30, sleep_duration: 0, retry_frequency: 0.3)
+  wait_element(trait, sleep_duration: sleep_duration, timeout_duration: timeout_duration, retry_frequency: retry_frequency)
+end
 
-  # wait trait-element on screen
-  def wait_for_screen
-    wait_for_elements_exist(trait, :timeout=>25)
+# ----------------------------------------------------Custom Swipe----------------------------------------------------
+def strong_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      strong_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  # ----------------------------------------------------Custom Swipe----------------------------------------------------
-  def strong_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{strong_swipe(dir)})
+def normal_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      normal_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def normal_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{normal_swipe(dir)})
+def light_swipe_until_not_exist(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      light_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_until_not_exist(dir, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe( dir)})
+def strong_swipe_until_exists(dir, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      strong_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe( dir)})
+def normal_swipe_until_exists(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      normal_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def normal_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{normal_swipe( dir); sleep(2)}, :timeout=>40)
+def light_swipe_until_exists(dir, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      light_swipe(dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_until_exists(dir, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe( dir); sleep(2)}, :timeout=>60)
-
+def strong_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      strong_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_element_until_exists(dir, element, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{strong_swipe_element(element, dir)})
+def normal_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      normal_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_element_until_exists(dir, element, element_destination)
-    until_element_exists(element_destination,
-                         :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+def light_swipe_element_until_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_does_not_exist(element_destination) do
+      light_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def strong_swipe_element_until_not_exists(dir, element, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{pan(element, dir)})
+def strong_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.5, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      strong_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def light_swipe_element_until_not_exists(dir, element, element_destination)
-    until_element_does_not_exist(element_destination,
-                                 :action =>  lambda{light_swipe_element(element, dir)}, :timeout=>70)
+def normal_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      normal_swipe_element(element, dir, sleep_duration: sleep_duration)
+    end
   end
+end
 
-  def swipe_to_text(dir, text)
-    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)
+def light_swipe_element_until_not_exists(dir, element, element_destination, sleep_duration: 0.2, timeout_duration: 30)
+  Timeout::timeout(timeout_duration) do
+    while element_exists(element_destination) do
+      light_swipe_element(element, dir, sleep_duration: sleep_duration)
     end
   end
+end
 
-  # Drag element from one place to place of other element
-  def drag_element(element_from , element_to)
-    x_from = get_coordinate_x(element_from)
-    y_from = get_coordinate_y(element_from)
+def swipe_to_text(dir, text, sleep_duration:0.2, timeout_duration: 30)
+  light_swipe_until_exists(dir, "* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-    x_to = get_coordinate_x(element_to)
-    y_to = get_coordinate_y(element_to)
-    drag_coordinates(x_from, y_from, x_to, y_to, 10, 0.5, 0.5)
+# -------------------------------------------------Asserts------------------------------------------------------------
+def assert_eql_with_rescue(element1, element2)
+  begin
+    expect(element1).to eq(element2)
+    true
+  rescue RSpec::Expectations::ExpectationNotMetError
+    false
   end
+end
 
-  # -------------------------------------------------Asserts------------------------------------------------------------
-  def assert_eql_with_rescue(element1, element2)
-    begin
-      expect(element1).to eq(element2)
-      true
-    rescue Exception => e
-      false
-    end
-  end
+def assert_eql(element1, element2)
+  expect(element1).to eq(element2)
+end
 
-  def assert_eql(element1, element2)
-    expect(element1).to eq(element2)
-  end
+def assert_not_eql(element1, element2)
+  expect(element1).not_to eql(element2)
+end
 
-  def assert_not_eql(element1, element2)
-    expect(element1).not_to eql(element2)
-  end
+def assert_true(element)
+  expect(element).to be true
+end
 
-  def assert_true(element)
-    expect(element).to be true
-  end
+def assert_false(element)
+  expect(element).to be false
+end
 
-  def assert_false(element)
-    expect(element).to be false
-  end
+def assert_nil(element)
+  expect(element).to be_nil
+end
 
-  def assert_nil(element)
-    expect(element).to be_nil
-  end
+# ------------------------------------------Generate String-----------------------------------------------------------
+def get_random_num_string(length)
+  source = (0..9).to_a
+  key = ""
+  length.times{ key += source[rand(source.size)].to_s }
+  return key
+end
 
-  # ------------------------------------------Generate String-----------------------------------------------------------
-  def get_random_num_string(length)
-    source=(0..9).to_a
-    key=""
-    length.times{ key += source[rand(source.size)].to_s }
-    return key
-  end
+def get_random_text_string(length)
+  source = ("a".."z").to_a
+  key = ""
+  length.times{ key += source[rand(source.size)].to_s }
+  return key
+end
 
-  def get_random_text_string(length)
-    source=("a".."z").to_a
-    key=""
-    length.times{ key += source[rand(source.size)].to_s }
-    return key
-  end
+def get_random_email
+  return get_random_text_string(7) + "@" + get_random_text_string(2) + ".test"
+end
 
-  def get_random_email
-    return get_random_text_string(7) + "@" + get_random_text_string(2) + ".test"
-  end
+# get first digital from string
+def extract_num_from_str(text)
+  text.gsub!(/[[:space:]]/, '')
+  num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).first
+  p num
+end
 
-  # get first digital from string
-  def extract_num_from_str(text)
-    text.gsub!(/[[:space:]]/, '')
-    num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).first
-    p num
-  end
+# get last digital from string
+def extract_last_num_from_str(text)
+  text.gsub!(/[[:space:]]/, '')
+  num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).last
+  p num
+end
 
-  # get last digital from string
-  def extract_last_num_from_str(text)
-    text.gsub!(/[[:space:]]/, '')
-    num = text.scan(/\d+/).first.nil? ? "0" : text.scan(/\d+/).last
-    p num
-  end
+# get text from first element
+def remember(element, sleep_duration: 1, timeout_duration: 5)
+  wait_element(element, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+  name = query(element)
+  save_name = name.first['text']
+  Kernel.puts(save_name)
+  return save_name
+end
 
-  # get text from first element
-  def remember(element)
-    wait_for_element_exists(element, :timeout => 5)
-    sleep(1.5)
-    name = query(element)
-    save_name = name.first['text']
-    puts(save_name)
-    return save_name
-  end
+# get text from last element
+def remember_last_text(element, sleep_duration: 1, timeout_duration: 5)
+  wait_element(element, sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+  name = query(element)
+  save_name = name.last['text']
+  Kernel.puts(save_name)
+  return save_name
+end
 
-  # get text from last element
-  def remember_last_text(element)
-    wait_for_element_exists(element, :timeout => 5)
-    sleep(1.5)
-    name = query(element)
-    save_name = name.last['text']
-    puts(save_name)
-    return save_name
-  end
+# wait text
+def check_text(text, sleep_duration: 0, timeout_duration: 5)
+  wait_element("* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-  # wait text
-  def check_text(text)
-    wait_for_element_exists("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 2)
-  end
+def no_check_text(text, timeout_duration: 5)
+  warn "Deprecated with 0.1.9 version SurfCustomCalabash, use check_no_text intead"
+  check_no_text(text, timeout_duration: timeout_duration)
+end
 
-  def no_check_text(text)
-    wait_for_element_does_not_exist("* {text CONTAINS'#{text}'}", :timeout => 5, :retry_frequency => 5)
-  end
+def check_no_text(text, sleep_duration: 0, timeout_duration: 5)
+  wait_no_element("* {text CONTAINS'#{text}'}", sleep_duration: sleep_duration, timeout_duration: timeout_duration)
+end
 
-  # get element's coordinates
-  def get_coordinate_x(element)
-    el = query(element)
-    coordinate = el[0]['rect']['center_x']
-    # puts(coordinate)
-    return coordinate.to_i
-  end
+# get element's coordinates
+def get_coordinate_x(element)
+  el = query(element)
+  coordinate = el[0]['rect']['center_x']
+  return coordinate.to_i
+end
 
-  def get_coordinate_y(element)
-    el = query(element)
-    coordinate = el[0]['rect']['center_y']
-    # puts(coordinate)
-    return coordinate.to_i
-  end
+def get_coordinate_y(element)
+  el = query(element)
+  coordinate = el[0]['rect']['center_y']
+  return coordinate.to_i
+end
 
+# Drag element from one place to place of other element
+def drag_element(element_from , element_to)
+  x_from = get_coordinate_x(element_from)
+  y_from = get_coordinate_y(element_from)
 
-  # if elements cross - return true, if not - false
-  def cross_coordinate(element_front, element_behind)
-    cross = false
+  x_to = get_coordinate_x(element_to)
+  y_to = get_coordinate_y(element_to)
+  drag_coordinates(x_from, y_from, x_to, y_to, 10, 0.5, 0.5)
+end
+
+# if elements cross - return true, if not - false
+def cross_coordinate(element_front, element_behind, delta: 100)
+  cross = false
 
-    if element_exists(element_front) && element_exists(element_behind)
-      coordinate_front = get_coordinate_y(element_front)
-      coordinate_behind = get_coordinate_y(element_behind)
-      delta = 100
+  if element_exists(element_front) && element_exists(element_behind)
+    coordinate_front = get_coordinate_y(element_front)
+    coordinate_behind = get_coordinate_y(element_behind)
 
-      if coordinate_front < coordinate_behind + delta
-        cross = true
-      else
-        cross = false
-      end
+    if coordinate_front < coordinate_behind + delta
+      cross = true
+    else
+      cross = false
     end
-    # puts(cross)
-    return cross
   end
+  # Kernel.puts(cross)
+  return cross
+end
 
-  # swipe down if two element cross
-  def swipe_if_cross(element_front, element_behind)
-    if cross_coordinate(element_front, element_behind)
-      light_swipe("down")
+# swipe down if two element cross
+def swipe_if_cross(element_front, element_behind, timeout_duration: 30, sleep_duration: 1)
+  Timeout::timeout(timeout_duration) do
+    while cross_coordinate(element_front, element_behind) do
+      light_swipe("down", sleep_duration: sleep_duration)
     end
-    sleep(1)
   end
+end
 
-  # if apps support two localization, this method check exists text in different locations
-  def text_with_locale(text_locale1, text_locale2)
-    if element_exists("* {text BEGINSWITH '#{text_locale2}'}")
-      puts (element_exists("* {text BEGINSWITH '#{text_locale2}'}"))
-      return "* {text BEGINSWITH '#{text_locale2}'}"
-    elsif element_exists("* {text BEGINSWITH '#{text_locale1}'}")
-      puts(element_exists("* {text BEGINSWITH '#{text_locale1}'}"))
-      return "* {text BEGINSWITH '#{text_locale1}'}"
+# --------------------------------------------------Localization------------------------------------------------------
+# get locale apps - Ru or Eng
+# parameter - element with text
+def get_app_location(element, sleep_duration: 1)
+  sleep(sleep_duration)
+  if element_exists(element)
+    text_element = remember(element)
+    if check_cyrillic(text_element)
+      locale = 'RUS'
     else
-      return ("No such query!")
+      locale = 'ENG'
     end
+  else
+    p "Fail localization"
+    locale = ''
   end
+  p locale
+  return locale
+end
+
+# check cyrillic symbols in string
+def check_cyrillic(str)
+  regexp = /\p{Cyrillic}+.*?\.?/
+  if str.match(regexp).nil?
+    return false
+  else
+    return true
+  end
+end
+
+# if apps support two localization, this method check exists text in different locations
+def text_with_locale(text_locale1, text_locale2, sleep_duration: 1)
+  sleep(sleep_duration)
+
+  # $locale is global variables
+  # $locale setup in first app launch
+  if !$locale.nil?
+    if check_cyrillic(text_locale1)
+      rus_locale = "* {text CONTAINS '#{text_locale1}'}"
+      eng_locale = "* {text CONTAINS '#{text_locale2}'}"
+    elsif check_cyrillic(text_locale2)
+      rus_locale = "* {text CONTAINS '#{text_locale2}'}"
+      eng_locale = "* {text CONTAINS '#{text_locale1}'}"
+    end
 
-  # if apps support two localization, this method check exists label in different locations
-  def label_with_locale(mark1, mark2)
-    if element_exists("* marked:'#{mark1}'")
-      return "* marked:'#{mark1}'"
-    elsif element_exists("* marked:'#{mark2}'")
-      return "* marked:'#{mark2}'"
+    if $locale == "RUS"
+      return rus_locale
+    elsif $locale == "ENG"
+      return eng_locale
+    end
+  else
+    # if $locale is not Rus or Eng
+    # wait element on screen with text_locale1 or text_locale2
+    locale_el1 = "* {text CONTAINS '#{text_locale1}'}"
+    locale_el2 = "* {text CONTAINS '#{text_locale2}'}"
+
+    if element_exists(locale_el1)
+      return locale_el1
+    elsif element_exists(locale_el2)
+      return locale_el2
     else
-      return false
+      return ("No such query!")
     end
   end
+end
 
+# if apps support two localization, this method check exists label in different locations
+def label_with_locale(mark1, mark2)
+  if element_exists("* marked:'#{mark1}'")
+    return "* marked:'#{mark1}'"
+  elsif element_exists("* marked:'#{mark2}'")
+    return "* marked:'#{mark2}'"
+  else
+    return false
+  end
 end
+