automation_object 0.0.4

data/lib/automation_object/framework/print_objects.rb

@@ -0,0 +1,67 @@
+module AutomationObject
+  module FrameworkPrintObjects
+    def print_objects(requested_screen_name = false)
+      puts 'Screens:'.colorize(:green)
+
+      self.instance_variables.each { |automation_variable|
+        automation_variable_value = self.instance_variable_get(automation_variable)
+        next unless automation_variable_value.class == Screen
+
+        screen_name = self.translate_class_to_string(automation_variable).gsub('@', '')
+
+        if requested_screen_name
+          next unless requested_screen_name == screen_name
+        end
+
+        screen_class_symbol = self.translate_string_to_class(screen_name)
+
+        puts "\t#{screen_name}".colorize(:blue)
+
+        self.send(screen_class_symbol).instance_variables.each { |screen_variable|
+          screen_object_name = self.translate_class_to_string(screen_variable).gsub('@', '')
+          screen_object_symbol = self.translate_string_to_class(screen_object_name)
+
+          output = "\t\t#{screen_object_name}".colorize(:magenta)
+
+          begin
+            object_class = self.send(screen_class_symbol).send(screen_object_symbol).class.to_s
+            case object_class
+              when 'AutomationObject::Element'
+                puts output + ' (Element)'.colorize(:green)
+              when 'AutomationObject::ElementHash'
+                puts output + ' (Element Hash)'.colorize(:red)
+              when 'AutomationObject::ElementArray'
+                puts output + ' (Element Array)'.colorize(:blue)
+              when 'AutomationObject::Modal'
+                puts output + ' (Modal)'.colorize(:cyan)
+
+                self.send(screen_class_symbol).send(screen_object_symbol).instance_variables.each { |modal_variable|
+                  modal_object_name = self.translate_class_to_string(modal_variable).gsub('@', '')
+                  modal_object_symbol = self.translate_string_to_class(modal_object_name)
+
+                  modal_output = "\t\t\t#{modal_object_name}".colorize(:magenta)
+                  #puts modal_output
+                  begin
+                    modal_object_class = self.send(screen_class_symbol).send(screen_object_symbol).send(modal_object_symbol).class.to_s
+
+                    case modal_object_class
+                      when 'AutomationObject::Element'
+                        puts modal_output + ' (Element)'.colorize(:green)
+                      when 'AutomationObject::ElementHash'
+                        puts modal_output + ' (Element Hash)'.colorize(:red)
+                      when 'AutomationObject::ElementArray'
+                        puts modal_output + ' (Element Array)'.colorize(:blue)
+                    end
+                  rescue
+                    next
+                  end
+                }
+            end
+          rescue
+            next
+          end
+        }
+      }
+    end
+  end
+end

data/lib/automation_object/framework/screen_monitor.rb

@@ -0,0 +1,55 @@
+module AutomationObject
+  module FrameworkScreenMonitor
+    def screen_monitor_thread_method(screen_class_symbol)
+      Thread.abort_on_exception = true
+
+      auto_screens_array = self.send(screen_class_symbol).configuration['automatic_screen_changes']
+      unless auto_screens_array.is_a?(Array)
+        raise "Expecting #{screen_class_symbol} screen to have automatic_screen_changes as an Array"
+      end
+
+      if auto_screens_array.length == 0
+        raise "Expecting #{screen_class_symbol} screen to have automatic_screen_changes count larger than 0"
+      end
+
+      if self.previous_screen_class
+        if self.screen_monitor_thread[self.previous_screen_class].class == Thread
+          AutomationObject::Logger::add("Attempting to kill previous screen threads for screen #{self.previous_screen_class}")
+
+          previous_thread = self.screen_monitor_thread[self.previous_screen_class]
+          Thread.kill(previous_thread)
+          self.screen_monitor_thread[self.previous_screen_class] = nil
+        end
+      end
+
+      AutomationObject::Logger::add("Running thread listener for screen #{screen_class_symbol}")
+
+      possible_screen_change_symbol = nil
+      possible_screen_change_name = nil
+
+      screen_live = false
+
+      #Todo: window switching while checking for live?
+      until screen_live
+        self.screen_monitor_mutex_object.synchronize do
+          auto_screens_array.each { |possible_screen_change_name|
+            possible_screen_change_symbol = self.translate_string_to_class(possible_screen_change_name)
+
+            start_time = Time.now.to_f
+            screen_live = self.send(possible_screen_change_symbol).live?
+            end_time = Time.now.to_f
+
+            AutomationObject::Logger::add("Automatic screen check of #{possible_screen_change_name} took (#{end_time-start_time})S")
+
+            break if screen_live
+          }
+        end
+      end
+
+      if screen_live
+        AutomationObject::Logger::add("Automatic screen change to #{possible_screen_change_name} found")
+        self.set_current_screen(possible_screen_change_symbol)
+      end
+    end
+  end
+end

data/lib/automation_object/framework/screen_routing.rb

@@ -0,0 +1,310 @@
+module AutomationObject
+  module FrameworkScreenRouting
+    def route_to_screen(from_screen, to_screen)
+      AutomationObject::Logger::add("Trying to automatically route to screen: #{to_screen}", [from_screen])
+
+      @from_screen = from_screen
+      @to_screen = to_screen
+      #Add @avoid_elements[screen_class_symbol].push(element_name),
+      #to be added later if elements are invisible or disabled
+      #Kind of a fail safe if elements are only sometimes disabled, try to find a new route after in this method if
+      #route found isn't working
+      @avoid_elements = Hash.new
+      @screen_map = self.map_screens
+      @route = nil
+
+      self.recursive_route_map
+
+      unless @route.class == Array
+        AutomationObject::Logger::add("Unable to find route to screen: #{to_screen}", [from_screen])
+        raise "Unable to find route between screen (#{@from_screen}) and screen (#{@to_screen})"
+      end
+
+      route_found = self.execute_route(@route)
+
+      unless route_found
+        @from_screen = self.current_screen_class
+        @screen_map = self.map_screens
+
+        self.recursive_route_map
+
+        unless @route.class == Array
+          raise "Unable to find route between screen (#{@from_screen}) and screen (#{@to_screen})"
+        end
+
+        self.execute_route(@route)
+      end
+
+      #Reset these variables
+      @avoid_elements = nil
+      @from_screen = nil
+      @to_screen = nil
+      @screen_map = nil
+      @route = nil
+    end
+
+    #TODO, enable for all elements, will break except for click, accept, dismiss
+    def execute_route(route)
+      route.each { |direction|
+        screen_configuration = self.send(self.current_screen_class).configuration
+
+        if screen_configuration['accept'].class == Hash
+          possible_change_screen = self.find_possible_change_screen(screen_configuration['accept'])
+          if possible_change_screen == direction
+            self.send(self.current_screen_class).accept
+            next
+          end
+        end
+
+        if screen_configuration.has_key?('dismiss')
+          possible_change_screen = self.find_possible_change_screen(screen_configuration['dismiss'])
+          if possible_change_screen == direction
+            self.send(self.current_screen_class).dismiss
+            next
+          end
+        end
+
+        route_found = false
+
+        #Try modals
+        if screen_configuration['modals'].is_a?(Hash)
+          screen_configuration['modals'].each { |modal_name, modal_configuration|
+            next unless modal_configuration.is_a?(Hash)
+            next unless modal_configuration['elements'].is_a?(Hash)
+
+            modal_configuration['elements'].each { |element_name, element_configuration|
+              next unless element_configuration.class == Hash
+              next unless element_configuration['click'].class == Hash
+
+              possible_change_screen = self.find_possible_change_screen(element_configuration['click'])
+              if possible_change_screen == direction
+                #If the elements, don't work then don't use them
+                #Will implement method to try to find another way to the screen
+                element_object = self.send(self.current_screen_class).send(modal_name).send(element_name)
+                element_object = element_object.sample if element_object.class == ElementArray
+                element_object = element_object[element_object.keys.sample] if element_object.class == ElementHash
+
+                unless element_object.visible?
+                  @avoid_elements[self.current_screen_class] = Array.new unless @avoid_elements[self.current_screen_class].class == Array
+                  @avoid_elements[self.current_screen_class].push(element_name)
+                  next
+                end
+
+                unless element_object.exists?
+                  @avoid_elements[self.current_screen_class] = Array.new unless @avoid_elements[self.current_screen_class].class == Array
+                  @avoid_elements[self.current_screen_class].push(element_name)
+                  next
+                end
+
+                element_object.click
+                route_found = true
+                break #Stop from looping through other elements
+              end
+            }
+            break if route_found
+          }
+
+          next if route_found
+        end
+
+        next unless screen_configuration['elements'].class == Hash
+
+        screen_configuration['elements'].each { |element_name, element_configuration|
+          next unless element_configuration.class == Hash
+          next unless element_configuration['click'].class == Hash
+
+          possible_change_screen = self.find_possible_change_screen(element_configuration['click'])
+          if possible_change_screen == direction
+            #If the elements, don't work then don't use them
+            #Will implement method to try to find another way to the screen
+            element_object = self.send(self.current_screen_class).send(element_name)
+            element_object = element_object.sample if element_object.class == ElementArray
+            element_object = element_object[element_object.keys.sample] if element_object.class == ElementHash
+
+            unless element_object.visible?
+              @avoid_elements[self.current_screen_class] = Array.new unless @avoid_elements[self.current_screen_class].class == Array
+              @avoid_elements[self.current_screen_class].push(element_name)
+              next
+            end
+
+            unless element_object.exists?
+              @avoid_elements[self.current_screen_class] = Array.new unless @avoid_elements[self.current_screen_class].class == Array
+              @avoid_elements[self.current_screen_class].push(element_name)
+              next
+            end
+
+            element_object.click
+            route_found = true
+            break #Stop from looping through other elements
+          end
+        }
+
+        return route_found unless route_found
+      }
+
+      true
+    end
+
+    def recursive_route_map
+      @depth = 0 unless @depth.class == Fixnum
+      @routes_array = Array.new unless @routes_array
+
+      #Get where we are and start there adding every possible direction to start with
+      if @depth == 0
+        @screen_map[@from_screen].each { |possible_direction|
+          new_route = Array.new
+          new_route.push(possible_direction)
+          @routes_array.push(new_route)
+        }
+
+        @depth += 1
+      end
+
+      #Better Check
+      #Do validation of @routes_array find if route found and break out
+      @routes_array.each { |route|
+        #Get the last direction and see if its the destination
+        if route.last == @to_screen
+          @route = route
+          @depth = nil
+          @routes_array = nil
+          return
+        end
+      }
+
+      tmp_routes_array = Array.new
+      @routes_array.each { |route|
+        last_direction = route.last
+        next unless @screen_map[last_direction]
+        @screen_map[last_direction].each { |possible_direction|
+          #Skip loops?
+          next if route.include?(possible_direction)
+          #Skip from screen
+          next if possible_direction == @from_screen
+
+          new_route = route.clone
+          new_route.push(possible_direction)
+
+          unless @routes_array.include?(new_route)
+            tmp_routes_array.push(new_route)
+          end
+        }
+
+        unless last_direction == @to_screen
+          #@routes_array.delete(route)
+        end
+      }
+
+      @routes_array += tmp_routes_array
+
+      @depth += 1
+
+      if @depth > 100
+        ap @routes_array
+        raise 'Could not complete route, runaway depth for from screen (' + @from_screen.to_s + ') to screen (' + @to_screen.to_s + ')'
+      end
+
+      self.recursive_route_map
+    end
+
+    def map_screens
+      screen_map = Hash.new
+      return screen_map unless self.configuration['screens'].class == Hash
+
+      self.configuration['screens'].each_key { |screen_name|
+        screen_class_symbol = self.translate_string_to_class(screen_name)
+
+        next unless self.respond_to?(screen_class_symbol)
+        next unless self.send(screen_class_symbol).configuration.class == Hash
+
+        screen_map[screen_class_symbol] = Array.new unless screen_map[screen_class_symbol].class == Array
+
+        screen_configuration = self.send(screen_class_symbol).configuration
+
+        if screen_configuration['accept'].class == Hash
+          possible_change_screen = self.find_possible_change_screen(screen_configuration['accept'])
+          screen_map[screen_class_symbol].push(possible_change_screen) if possible_change_screen
+        end
+
+        if screen_configuration.has_key?('dismiss')
+          possible_change_screen = self.find_possible_change_screen(screen_configuration['dismiss'])
+          screen_map[screen_class_symbol].push(possible_change_screen) if possible_change_screen
+        end
+
+        #Check modals
+        if screen_configuration['modals'].is_a?(Hash)
+          screen_configuration['modals'].each { |modal_name, modal_configuration|
+            next unless modal_configuration.is_a?(Hash)
+            next unless modal_configuration['elements'].is_a?(Hash)
+
+            modal_configuration['elements'].each { |element_name, element_configuration|
+              next unless element_configuration.class == Hash
+              #next if not element_configuration['click'].class == Hash
+
+              if @avoid_elements.has_key?(screen_class_symbol)
+                next if @avoid_elements[screen_class_symbol].include?(element_name)
+              end
+
+              element_configuration.each { |key, sub_configuration|
+                next unless sub_configuration.class == Hash
+                next if key == 'custom_methods'
+                next if key == 'xpath'
+                next if key == 'css'
+                next if key == 'multiple'
+
+                possible_change_screen = self.find_possible_change_screen(sub_configuration)
+                screen_map[screen_class_symbol].push(possible_change_screen) if possible_change_screen
+              }
+            }
+          }
+        end
+
+        next unless screen_configuration['elements'].class == Hash
+
+        screen_configuration['elements'].each { |element_name, element_configuration|
+          next unless element_configuration.class == Hash
+          #next if not element_configuration['click'].class == Hash
+
+          if @avoid_elements.has_key?(screen_class_symbol)
+            next if @avoid_elements[screen_class_symbol].include?(element_name)
+          end
+
+          element_configuration.each { |key, sub_configuration|
+            next unless sub_configuration.class == Hash
+            next if key == 'custom_methods'
+            next if key == 'xpath'
+            next if key == 'css'
+            next if key == 'multiple'
+
+            possible_change_screen = self.find_possible_change_screen(sub_configuration)
+            screen_map[screen_class_symbol].push(possible_change_screen) if possible_change_screen
+          }
+        }
+
+        screen_map[screen_class_symbol] = screen_map[screen_class_symbol].uniq
+      }
+
+      screen_map
+    end
+
+    def find_possible_change_screen(configuration)
+      if configuration['before'].class == Hash
+        if configuration['before'].has_key?('change_screen')
+          if configuration['before']['change_screen']
+            return self.translate_string_to_class(configuration['before']['change_screen'])
+          end
+        end
+      end
+
+      if configuration['after'].class == Hash
+        if configuration['after'].has_key?('change_screen')
+          if configuration['after']['change_screen']
+            return self.translate_string_to_class(configuration['after']['change_screen'])
+          end
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/automation_object/framework/window_helpers.rb

@@ -0,0 +1,181 @@
+module AutomationObject
+  module FrameworkWindowHelpers
+    def get_window_handles
+      window_handles = Array.new
+      return window_handles unless self.is_browser?
+
+      unless self.is_mobile?
+        #Window handles for Selenium are simpler
+        return self.driver_object.window_handles
+      end
+
+      #Remove everything except the WEBVIEW
+      if self.driver_object.device_is_android?
+        window_handles = self.driver_object.window_handles
+      else
+        available_contexts = self.driver_object.available_contexts
+        available_contexts.each { |context|
+          window_handles.push(context) if context.match(/^WEBVIEW_\d+$/)
+        }
+      end
+
+      return window_handles
+    end
+
+    def get_current_window_handle
+      #Selenium
+      unless self.is_mobile?
+        return self.driver_object.window_handle
+      end
+
+      #Appium
+      if self.driver_object.device_is_android?
+        return self.driver_object.window_handle
+      else
+        return self.driver_object.current_context
+      end
+    end
+
+    def switch_to_window(window_handle)
+      unless self.is_mobile?
+        #Selenium
+        return self.driver_object.switch_to.window(window_handle)
+      end
+
+      #Appium
+      if self.driver_object.device_is_android?
+        return self.driver_object.switch_to.window(window_handle)
+      else
+        return self.driver_object.set_context(window_handle)
+      end
+    end
+
+    def check_closed_windows
+      window_handles = self.get_window_handles
+
+      self.current_screen_hash.each { |current_window_handle, current_screen_symbol|
+        next if window_handles.include?(current_window_handle)
+
+        #Delete current screen hash key
+        self.current_screen_hash.delete(current_window_handle)
+        self.reset_screen(current_screen_symbol)
+        self.previous_screen_hash.delete(current_window_handle)
+
+        if current_screen_symbol == self.current_screen_class
+          self.previous_screen_class = nil
+        end
+      }
+    end
+
+    def wait_for_window_load
+      AutomationObject::Logger::add('Waiting for window to load via document.readyState')
+      loops = 0
+
+      sleep(2)
+      until self.document_complete?
+        loops += 1
+
+        if loops > 30
+          break #Fuck it for now, just see what happens if we don't wait for this
+          raise Net::ReadTimeout, 'Error waiting too long for page to load'
+        end
+
+        sleep(3)
+      end
+    end
+
+    def document_complete?
+      AutomationObject::Logger::add('Running document_complete? command')
+      return self.driver_object.execute_script('return document.readyState;') == 'complete'
+    end
+
+    def wait_for_stable_body_size
+      AutomationObject::Logger::add('Going to wait for body element size to stabilize before continuing')
+      body_element_object = self.driver_object.find_element(:css, 'body')
+
+      begin
+        current_body_size = body_element_object.size
+      rescue Selenium::WebDriver::Error::StaleElementReferenceError, Errno::ECONNREFUSED
+        body_element_object = self.driver_object.find_element(:css, 'body')
+        current_body_size = body_element_object.size
+      end
+
+      previous_width = current_body_size[:width]
+      previous_height = current_body_size[:height]
+
+      sleep(2)
+
+      30.times do
+        sizes_string = "before: #{current_body_size[:width]}x#{current_body_size[:height]}"
+
+        begin
+          current_body_size = body_element_object.size
+        rescue Selenium::WebDriver::Error::StaleElementReferenceError, Errno::ECONNREFUSED
+          body_element_object = self.driver_object.find_element(:css, 'body')
+          current_body_size = body_element_object.size
+        end
+
+        if previous_width == current_body_size[:width] and previous_height == current_body_size[:height]
+          break
+        end
+
+        sizes_string << ", after: #{current_body_size[:width]}x#{current_body_size[:height]}"
+        AutomationObject::Logger::add("Running another loop for body size stabilization. #{sizes_string}")
+
+        previous_width = current_body_size[:width]
+        previous_height = current_body_size[:height]
+
+        sleep(2)
+      end
+    end
+
+    def set_window_size(x, y)
+      self.driver_object.manage.window.resize_to(x, y)
+    end
+
+    def close_window(screen_name, skip_close = false)
+      AutomationObject::Logger::add("Attempting to close window for screen #{screen_name}")
+
+      screen_class_symbol = self.translate_string_to_class(screen_name)
+      remove_current_handle = nil
+
+      self.current_screen_hash.each { |window_handle, current_screen_symbol|
+        next if current_screen_symbol != screen_class_symbol
+        remove_current_handle = window_handle
+
+        #Kill the thread
+        self.screen_monitor_thread.each { |key, thread|
+          next unless key == screen_class_symbol
+          break unless thread.class == Thread
+          Thread.kill(thread)
+
+          AutomationObject::Logger::add("Killed any threads belonging to window for screen #{screen_name}")
+          break
+        }
+
+        self.screen_monitor_thread[current_screen_symbol] = nil
+
+        #Close the window if needed
+        if skip_close == false
+          self.switch_to_window(window_handle)
+          self.driver_object.close
+        end
+
+        break
+      }
+
+      if remove_current_handle
+        self.current_screen_hash.delete(remove_current_handle)
+        self.screen_history_hash.delete(remove_current_handle)
+      end
+
+      self.current_screen_hash.each { |window_handle, current_screen_symbol|
+        self.switch_to_window(window_handle)
+        self.current_screen_class = current_screen_symbol
+        break
+      }
+
+      self.send(screen_class_symbol).reset_screen
+    end
+  end
+end