automation_object 0.0.4 → 0.5.0

data/lib/automation_object/state/blue_print_adapter/element.rb

@@ -0,0 +1,20 @@
+require_relative 'composite'
+require_relative 'helpers/element_helper'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Element < AutomationObject::State::BluePrintAdapter::Composite
+        include ElementHelper
+
+        # @return [AutomationObject::State::BluePrintAdapter::ElementProxy] Selenium proxy
+        def load
+          element = self.driver.find_element(*self.blue_prints.selector_params)
+          ElementProxy.new(composite: self, element: element)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/element_array.rb

@@ -0,0 +1,25 @@
+require_relative 'composite'
+require_relative 'helpers/element_helper'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ElementArray < AutomationObject::State::BluePrintAdapter::Composite
+        include ElementHelper
+
+        # @return [Array<AutomationObject::State::BluePrintAdapter::ElementProxy>] Selenium proxy
+        def load
+          elements = self.driver.find_elements(*self.blue_prints.selector_params)
+
+          wrapped_elements = elements.map { |element|
+            ElementProxy.new(composite: self, element: element)
+          }
+
+          return wrapped_elements
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/element_hash.rb

@@ -0,0 +1,31 @@
+require_relative 'composite'
+require_relative 'helpers/element_helper'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ElementHash < AutomationObject::State::BluePrintAdapter::Composite
+        include ElementHelper
+
+        # @return [Hash<String, AutomationObject::State::BluePrintAdapter::ElementProxy>] Selenium proxy
+        def load
+          elements = self.driver.find_elements(*self.blue_prints.selector_params)
+          elements_hash = {}
+
+          elements.each { |element|
+            #Want to wrap element, before sending for method!
+            #That will help us include custom methods, etc...
+            wrapped_element = ElementProxy.new(composite: self, element: element)
+            hash_key = wrapped_element.send(self.blue_prints.define_elements_by) #Send to wrapped state proxy
+
+            elements_hash[hash_key] = wrapped_element
+          }
+
+          return elements_hash
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/element_proxy.rb

@@ -0,0 +1,28 @@
+require_relative '../../proxies/proxy'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      #Proxy class to allow for usage of hooks
+      class ElementProxy < AutomationObject::Proxies::Proxy
+        def initialize(args = {})
+          @composite = args.fetch :composite
+          @subject = args.fetch :element
+        end
+
+        #Overiding base method to run possible hooks
+        def method_missing(method_symbol, *args, &block)
+          #Run before hook if needed
+          @composite.method_hooks[method_symbol].before if @composite.method_hook?(method_symbol)
+
+          subject_return = @subject.send(method_symbol, *args, &block)
+
+          #Run after hook if needed
+          @composite.method_hooks[method_symbol].after if @composite.method_hook?(method_symbol)
+
+          return subject_return
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/helpers/element_helper.rb

@@ -0,0 +1,31 @@
+require_relative '../hook'
+
+module AutomationObject
+  module State
+    #Helper module for Element composite classes
+    module BluePrintAdapter
+      module ElementHelper
+        def method_hook?(name)
+          return self.blue_prints.method_hooks.has_key?(name)
+        end
+
+        # @return [Hash<Hook>] array of Hook that are defined under the element
+        def method_hooks
+          return @method_hooks if @method_hooks
+
+          @method_hooks = {}
+          self.blue_prints.method_hooks.each { |key, blue_prints|
+            @method_hooks[key] = Hook.new(blue_prints,
+                                          self.driver,
+                                          key,
+                                          self,
+                                          self.location + "[#{key}]")
+          }
+
+          return @method_hooks
+        end
+      end
+    end
+  end
+end
+

data/lib/automation_object/state/blue_print_adapter/helpers/screen_manager.rb

@@ -0,0 +1,137 @@
+require_relative 'window'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      module ScreenManager
+        # @return [Array<Window>]
+        def windows
+          @windows ||= []
+        end
+
+        # @return [Array<String>] list of stored window handles
+        def window_handles
+          handles = []
+          self.windows.each { |window|
+            handles.push(window.window_handle)
+          }
+          return handles
+        end
+
+        def window_closed?(screen)
+          self.windows.each { |window|
+            if window.name == screen && window.closed?
+              self.delete_screen(screen)
+              return true
+            end
+          }
+        end
+
+        def set_screen(name)
+          current_window_handle = self.driver.window_handle
+          previous_window = nil
+
+          self.windows.each { |window|
+            if window.window_handle == current_window_handle
+              previous_window = self.windows.delete(window)
+              break
+            end
+          }
+
+          self.windows << Window.new(name: name,
+                                     window_handle: current_window_handle,
+                                     previous_window: previous_window,
+                                     driver: self.driver)
+        end
+
+        def create_screen(name)
+          driver_handles = self.driver.window_handles
+          diff_handles = driver_handles - self.window_handles
+
+          #Should only have one extra window
+          if diff_handles.length > 1
+            raise "Expecting only one extra window, got #{diff_handles.length}"
+          end
+
+          self.windows << Window.new(name: name, window_handle: diff_handles.first, driver: self.driver)
+        end
+
+        def use_screen(name)
+          current_window_handle = self.driver.window_handle
+          self.windows.each { |window|
+            next unless window.name == name
+
+            break if window.window_handle == current_window_handle
+
+            self.driver.window_handle = window.window_handle
+          }
+
+          @current_screen_name = name
+        end
+
+        def use_modal(modal_name)
+          current_window.active_modal = modal_name
+        end
+
+        def delete_screen(name)
+          self.windows.each { |window|
+            self.windows.delete(name) if window.name == name
+          }
+        end
+
+        def screen_exists?(name)
+          self.windows.each { |window|
+            return true if window.name == name
+          }
+
+          return false
+        end
+
+        def destroy_modal
+          current_window.active_modal = nil
+        end
+
+        # @return [Window, nil]
+        def current_window
+          return nil unless @current_screen_name
+          return self.get_window(@current_screen_name)
+        end
+
+        def get_window(name)
+          self.windows.each { |window|
+            return window if name == window.name
+          }
+
+          return nil
+        end
+
+        def current_composite
+          if current_window.active_modal
+            return self.screens[@current_screen_name].modals[current_window.active_modal]
+          end
+
+          return self.screens[@current_screen_name]
+        end
+
+        def current_screen
+          @current_screen_name
+        end
+
+        def get_object(type, name)
+          object = nil
+
+          case type
+            when :element
+              object = self.current_composite.elements[name]
+            when :element_array
+              object = self.current_composite.element_arrays[name]
+            when :element_hash
+              object = self.current_composite.element_hashes[name]
+          end
+
+          return object.load
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/helpers/window.rb

@@ -0,0 +1,39 @@
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Window
+        attr_accessor :name, :window_handle, :previous_window, :driver, :active_modal
+
+        def initialize(args = {})
+          self.name = args.fetch :name
+          self.driver = args.fetch :driver
+          self.window_handle = args.fetch :window_handle
+
+          self.previous_window = args.fetch :previous_window, nil
+        end
+
+        # @return [Symbol, nil] name of screen or nil
+        def previous_screen_name
+          return (self.previous_window) ? self.previous_window.name : nil
+        end
+
+        #Change properties to the previous window if it exists
+        def back
+          return unless self.previous_window
+
+          self.name = self.previous_window.name
+
+          if self.previous_window.previous_window
+            self.previous_window = self.previous_window.previous_window
+          else
+            self.previous_window = nil
+          end
+        end
+
+        def closed?
+          return !self.driver.window_handles.include?(self.window_handle)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/hook.rb

@@ -0,0 +1,56 @@
+require_relative 'composite'
+
+require_relative 'hook_action'
+require_relative 'hook_actions/element_requirement'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Hook < AutomationObject::State::BluePrintAdapter::Composite
+        # @return [Boolean, nil] return nil if no live? check, otherwise boolean
+        def live?
+          self.before
+
+          return nil if self.blue_prints.live?.empty?
+
+          self.blue_prints.live?.each { |element_requirement_blueprints|
+            hook_element_requirement = ElementRequirement.new(blue_prints: element_requirement_blueprints,
+                                                              composite: self,
+                                                              loops: 1)
+            return false unless hook_element_requirement.run
+          }
+
+          self.after
+
+          return true
+        end
+
+        #Runs the before hook
+        # @return [Boolean, nil] return nil unless there is a hook, otherwise boolean depending on success of hook
+        def before
+          return nil if self.blue_prints.before.empty?
+
+          hook_action = HookAction.new(self.blue_prints.before,
+                                       self.driver,
+                                       :hook_action,
+                                       self,
+                                       self.location + '[hook_action]')
+          return hook_action.run
+        end
+
+        #Runs the after hook
+        # @return [Boolean, nil] return nil unless there is a hook, otherwise boolean depending on success of hook
+        def after
+          return nil if self.blue_prints.after.empty?
+
+          hook_action = HookAction.new(self.blue_prints.after,
+                                       self.driver,
+                                       :hook_action,
+                                       self,
+                                       self.location + '[hook_action]')
+          return hook_action.run
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/hook_action.rb

@@ -0,0 +1,33 @@
+require_relative 'composite'
+
+require_relative 'hook_actions/change_screen'
+require_relative 'hook_actions/change_to_previous_screen'
+require_relative 'hook_actions/close_modal'
+require_relative 'hook_actions/close_screen'
+require_relative 'hook_actions/possible_screen_changes'
+require_relative 'hook_actions/reset_screen'
+require_relative 'hook_actions/show_modal'
+require_relative 'hook_actions/sleep'
+require_relative 'hook_actions/wait_for_elements'
+require_relative 'hook_actions/new_screen'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class HookAction < AutomationObject::State::BluePrintAdapter::Composite
+        # @return [Boolean] run success or not
+        def run
+          self.blue_prints.hook_order.each { |hook_name|
+            hook_action_class = AutomationObject::State::BluePrintAdapter.const_get(hook_name.to_s.pascalize)
+            blue_prints = self.blue_prints.send(hook_name)
+
+            hook_action = hook_action_class.new(blue_prints: blue_prints, composite: self)
+            return false if hook_action.run == false
+          }
+
+          return true
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/blue_print_adapter/hook_actions/action_loop.rb

@@ -0,0 +1,35 @@
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ActionLoop
+        attr_accessor :composite, :blue_prints, :loops
+
+        def initialize(args = {})
+          self.blue_prints = args.fetch(:blue_prints)
+          self.composite = args.fetch(:composite)
+          self.loops = args.fetch(:loops, 30)
+        end
+
+        def driver
+          return self.composite.driver
+        end
+
+        # @return [Boolean] run success or not
+        def run
+          self.loops.times do
+            if self.single_run
+              return true
+            end
+          end
+
+          return false
+        end
+
+        # @return [Boolean] success or not
+        def single_run
+          raise 'Abstract Issue'
+        end
+      end
+    end
+  end
+end