automation_object 0.6.0 → 0.7.5

data/lib/automation_object/state/{error.rb → _error.rb}

@@ -43,6 +43,10 @@ module AutomationObject
 
     # Modal isn't active error
     class ModalNotActiveError < StandardError
+      def initialize(modal)
+        message = "#{modal} is not currently active"
+        super(message)
+      end
     end
 
     # Modal parent error

data/lib/automation_object/state/element.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    # Element composite for managing state
+    class Element < Base
+      include CommonElement
+
+      # @return [AutomationObject::State::ElementProxy] Selenium proxy
+      def utilize
+        # return self.cache if self.cache
+
+        element = driver.find_element(*blue_prints.selector_params)
+        @active = true
+        self.cache = ElementProxy.new(self, element)
+      end
+    end
+  end
+end

data/lib/automation_object/state/element_array.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    # Element array composite for managing state
+    class ElementArray < Base
+      include CommonElement
+
+      # @return [Array<AutomationObject::State::ElementProxy>] Selenium proxy
+      def utilize
+        # return self.cache if self.cache
+
+        elements = driver.find_elements(*blue_prints.selector_params)
+
+        @active = true
+        self.cache = elements.map do |element|
+          ElementProxy.new(self, element)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/element_hash.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '_common_element'
+
+require_relative 'element_proxy'
+
+module AutomationObject
+  module State
+    # Element hash composite for managing state
+    class ElementHash < Base
+      include CommonElement
+
+      # @return [Hash<String, AutomationObject::State::ElementProxy>] Selenium proxy
+      def utilize
+        # return self.cache if self.cache
+
+        elements = driver.find_elements(*blue_prints.selector_params)
+        self.cache = {}
+
+        elements.each do |element|
+          # Want to wrap element, before sending for method!
+          # That will help us include custom methods, etc...
+          wrapped_element = ElementProxy.new(self, element)
+          hash_key = wrapped_element.send(blue_prints.define_elements_by) # Send to wrapped state proxy
+
+          cache[hash_key] = wrapped_element
+        end
+
+        @active = true
+        cache
+      end
+    end
+  end
+end

data/lib/automation_object/state/element_proxy.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative '../proxy/proxy'
+
+module AutomationObject
+  module State
+    # Proxy class to allow for usage of hooks
+    class ElementProxy < ::AutomationObject::Proxy::Proxy
+      def initialize(composite, element)
+        @composite = composite
+        @subject = 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)
+
+        subject_return
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @subject.respond_to_missing?(method, include_private)
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require_relative '_base'
+
+require_relative 'hook_action'
+require_relative 'hook_actions/element_requirement'
+
+module AutomationObject
+  module State
+    # Hook composite for managing state
+    class Hook < Base
+      # @return [Boolean, nil] return nil if no live? check, otherwise boolean
+      def live?
+        before
+
+        return nil if blue_prints.live?.empty?
+
+        blue_prints.live?.each do |element_requirement_blueprints|
+          hook_element_requirement = ElementRequirement.new(self, driver, element_requirement_blueprints, 1)
+          return false unless hook_element_requirement.run
+        end
+
+        after
+
+        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 blue_prints.before.empty?
+
+        hook_action = HookAction.new(driver,
+                                     blue_prints.before,
+                                     :hook_action, self, location + '[hook_action]')
+
+        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 blue_prints.after.empty?
+
+        hook_action = HookAction.new(driver,
+                                     blue_prints.after,
+                                     :hook_action, self, location + '[hook_action]')
+        hook_action.run
+      end
+    end
+  end
+end

data/lib/automation_object/state/{composite/hook_action.rb → hook_action.rb}

@@ -14,21 +14,19 @@ require_relative 'hook_actions/new_screen'
 
 module AutomationObject
   module State
-    module Composite
-      # Hook action composite for managing state
-      class HookAction < Base
-        # @return [Boolean] run success or not
-        def run
-          blue_prints.hook_order.each do |hook_name|
-            hook_action_class = AutomationObject::State::Composite.const_get(hook_name.to_s.pascalize)
-            blue_prints = self.blue_prints.send(hook_name)
+    # Hook action composite for managing state
+    class HookAction < Base
+      # @return [Boolean] run success or not
+      def run
+        blue_prints.hook_order.each do |hook_name|
+          hook_action_class = AutomationObject::State.const_get(hook_name.to_s.pascalize)
+          blue_prints = self.blue_prints.send(hook_name)
 
-            hook_action = hook_action_class.new(self, driver, blue_prints)
-            return false if hook_action.run == false # Use long form, can return nil!
-          end
-
-          true
+          hook_action = hook_action_class.new(self, driver, blue_prints)
+          return false if hook_action.run == false # Use long form, can return nil!
         end
+
+        true
       end
     end
   end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module AutomationObject
+  module State
+    # Composite action loop base class
+    class ActionLoop
+      # @return [AutomationObject::State::Base]
+      attr_accessor :composite
+      # @return [AutomationObject::Driver::Driver]
+      attr_accessor :driver
+      # @return [AutomationObject::BluePrint::Composite::Base]
+      attr_accessor :blue_prints
+      # @return [Integer]
+      attr_accessor :loops
+
+      # @param composite [AutomationObject::State::Composite::Base]
+      # @param driver [AutomationObject::Driver::Driver]
+      # @param blue_prints [AutomationObject::BluePrint::Composite::Base]
+      # @param loops [Integer]
+      def initialize(composite, driver, blue_prints, loops = 30)
+        self.composite = composite
+        self.driver = driver
+        self.blue_prints = blue_prints
+        self.loops = loops
+      end
+
+      # @return [Boolean] run success or not
+      def run
+        loops.times do
+          # Sub classes implement single run
+          return true if single_run
+        end
+
+        false
+      end
+
+      # Abstract method, override
+      # @return [Boolean] success or not
+      def single_run
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook_actions/change_screen.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    # Change screen hook loop
+    class ChangeScreen < ActionLoop
+      def single_run
+        return false unless driver.document_complete?
+
+        new_screen = composite.top.screens[blue_prints]
+        return false if new_screen.load.live? == false # Need strict
+
+        new_screen.previous_screen_name = composite.screen.name
+
+        composite.screen.deactivate
+        new_screen.activate
+
+        true
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook_actions/change_to_previous_screen.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    # Change to previous screen hook loop
+    class ChangeToPreviousScreen < ActionLoop
+      def single_run
+        return false unless driver.document_complete?
+
+        new_screen = composite.top.screens[composite.screen.previous_screen_name]
+        # Need strict check, can be nil
+        return false if new_screen.load.live? == false
+
+        new_screen.previous_screen_name = composite.screen.name
+        composite.screen.deactivate
+        new_screen.activate
+
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../_error'
+
+module AutomationObject
+  module State
+    # Close modal hook loop
+    class CloseModal < ActionLoop
+      def single_run
+        return false unless driver.document_complete?
+
+        raise ModalParentExpected unless composite.parent.is_a?(Modal)
+
+        return false if modal.live? == false
+
+        modal.deactivate
+        true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../_error'
+
+module AutomationObject
+  module State
+    # Close screen hook loop
+    class CloseScreen < ActionLoop
+      def single_run
+        raise ScreenParentExpected unless composite.screen
+
+        return false unless composite.screen.closed?
+
+        composite.screen.deactivate
+
+        true
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook_actions/element_requirement.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    # Element requirement hook loop
+    class ElementRequirement < ActionLoop
+      def element
+        @element ||= driver.find_element(*blue_prints.element_blueprints.selector_params)
+      end
+
+      def single_run
+        blue_prints.hook_order.each do |requirement_name|
+          next if blue_prints.requirement(requirement_name).nil?
+
+          requirement_value = blue_prints.requirement(requirement_name)
+
+          case requirement_name
+          when :exists?
+            return false if requirement_value != driver.exists?(*blue_prints.element_blueprints.selector_params)
+          else
+            return false if requirement_value != element.send(requirement_name)
+          end
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook_actions/new_screen.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../_error'
+
+module AutomationObject
+  module State
+    # New screen hook loop
+    class NewScreen < ActionLoop
+      # @param composite [AutomationObject::State::Base]
+      # @param driver [AutomationObject::Driver::Driver]
+      # @param blue_prints [AutomationObject::BluePrint::Composite::Base]
+      # @param loops [Integer]
+      def initialize(composite, driver, blue_prints, loops = 1)
+        self.composite = composite
+        self.driver = driver
+        self.blue_prints = blue_prints
+        self.loops = loops
+      end
+
+      def single_run
+        new_screen = composite.top.screens[blue_prints]
+        stored_window_handles = composite.top.screens.values
+                                         .each_with_object([]) do |screen, a|
+          a.push(screen.window_handle) unless screen.window_handle.nil?
+          a
+        end
+
+        driver_handles = driver.window_handles
+
+        return false if driver_handles.length <= stored_window_handles.length
+        raise MoreThenOneScreenCreated if (driver_handles.length - stored_window_handles.length) > 1
+
+        new_window_handle = (driver_handles - stored_window_handles)[0]
+        driver.window_handle = new_window_handle
+
+        30.times do
+          next unless driver.document_complete?
+          next if new_screen.load.live? == false
+
+          new_screen.activate
+
+          return true
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/automation_object/state/hook_actions/possible_screen_changes.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    # Possible screen changes hook loop
+    class PossibleScreenChanges < ActionLoop
+      def single_run
+        return false unless driver.document_complete?
+
+        blue_prints.each do |possible_screen_name|
+          new_screen = composite.top.screens[possible_screen_name]
+          next unless new_screen.load.live? != false
+          composite.screen.deactivate
+          new_screen.activate
+          return true
+        end
+
+        false
+      end
+    end
+  end
+end