automation_object 0.0.4 → 0.5.0

data/lib/automation_object/framework/events.rb

@@ -1,8 +0,0 @@
-module AutomationObject
-  module FrameworkEvents
-    def screen_change_emit(screen_class_symbol)
-      screen_name = self.translate_class_to_string(screen_class_symbol)
-      self.emit(:screen_change, screen_name)
-    end
-  end
-end

data/lib/automation_object/framework/helpers.rb

@@ -1,101 +0,0 @@
-module AutomationObject
-  module FrameworkHelpers
-    attr_accessor :is_mobile, :is_browser, :supports_contexts
-
-    def is_mobile?
-      if self.is_mobile == nil
-        self.is_mobile = self.supports_contexts?
-      end
-
-      return self.is_mobile
-    end
-
-    def is_browser?
-      unless self.is_browser == nil
-        return self.is_browser
-      end
-
-      #If Selenium the yeah we are using a browser
-      if self.supports_window_handles?
-        self.is_browser = true
-        return self.is_browser
-      end
-
-      #Now we need to check Appium's contexts to see if WEBVIEW is in available_contexts
-      available_contexts = self.driver_object.available_contexts
-      self.supports_contexts = true
-
-      available_contexts.each { |context|
-        if context.match(/^WEBVIEW_\d+$/)
-          self.is_browser = true
-          return self.is_browser
-        end
-      }
-
-      self.is_browser = false
-      return self.is_browser
-    end
-
-    #Selenium's use of window_handles
-    def supports_window_handles?
-      begin
-        self.driver_object.window_handles
-        return true
-      rescue NoMethodError, Selenium::WebDriver::Error::UnknownError
-        return false
-      end
-    end
-
-    #Appium's use of window_handles
-    def supports_contexts?
-      return self.supports_contexts if self.supports_contexts != nil
-
-      begin
-        self.driver_object.available_contexts
-        self.supports_contexts = true
-        return true
-      rescue NoMethodError
-        return false
-      end
-    end
-
-    def current_screen
-      current_screen_object = Object.new
-      current_screen_object.class.module_eval { attr_accessor :framework_object }
-      current_screen_object.framework_object = self
-
-      def current_screen_object.method_missing(method_symbol, *args, &block)
-        return self.framework_object.send(self.framework_object.get_current_screen).send(method_symbol, *args, &block)
-      end
-
-      current_screen_object
-    end
-
-    def get_current_screen
-      return self.translate_class_to_string(self.current_screen_class).to_sym
-    end
-
-    def kill_monitor_threads
-      begin
-        self.screen_monitor_thread.each_value { |thread|
-          Thread.kill(thread) if thread
-        }
-      rescue
-        # ignored
-      end
-    end
-
-    def quit
-      AutomationObject::Logger::add('Quitting the framework')
-      self.kill_monitor_threads
-
-      if self.driver_object.respond_to?(:quit)
-        self.driver_object.quit if self.driver_object.respond_to?(:quit)
-      elsif self.driver_object.respond_to?(:driver_quit)
-        self.driver_object.driver_quit if self.driver_object.respond_to?(:driver_quit)
-      else
-        raise 'Unable to find provided driver quit method'
-      end
-    end
-  end
-end

data/lib/automation_object/framework/print_objects.rb

@@ -1,67 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,310 +0,0 @@
-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