automation_object 0.5.0 → 0.5.1

data/lib/automation_object/state/blue_print_adapter.rb

@@ -1,16 +0,0 @@
-require_relative 'blue_print_adapter/top'
-
-module AutomationObject
-  module State
-    #State adapter for building DSL framework
-    #Will work with the blueprints and adapter to accomplish the goal of maintaining the state
-    #And give control of operations via the DSL
-    module BluePrintAdapter
-      # @param args [Hash] expects :blue_prints, :driver
-      # @return [AutomationObject::State::BlueAdapter::Top]
-      def self.build(blue_prints, driver)
-        return Top.new(args.fetch(:blue_prints), args.fetch(:driver))
-      end
-    end
-  end
-end

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

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

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

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

@@ -1,28 +0,0 @@
-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/screen_manager.rb

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

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

@@ -1,56 +0,0 @@
-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_actions/action_loop.rb

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

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

@@ -1,31 +0,0 @@
-require_relative 'action_loop'
-require_relative '../modal'
-require_relative '../../error'
-
-module AutomationObject
-  module State
-    module BluePrintAdapter
-      class CloseModal < ActionLoop
-        def single_run
-          self.driver.document_complete_wait
-
-          unless self.composite.parent.is_a?(Modal)
-            raise ModalParentExpected.new
-          end
-
-          modal = self.composite.parent
-          modal.active = modal.live?
-
-          if !modal.active?
-            self.composite.screen.modal = nil
-            self.composite.screen.current_modal = nil
-            self.composite.top.destroy_modal()
-            return true
-          else
-            return false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-require_relative 'action_loop'
-require_relative '../../error'
-
-module AutomationObject
-  module State
-    module BluePrintAdapter
-      class CloseScreen < ActionLoop
-        def single_run
-          unless self.composite.screen
-            raise ScreenParentExpected.new
-          end
-
-          screen_name = self.composite.screen.name
-          return self.composite.top.window_closed?(screen_name)
-        end
-      end
-    end
-  end
-end