automation_object 0.5.0 → 0.5.1

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module Composite
+      # Window class
+      class Window
+        # @param [AutomationObject::Driver::Driver] driver
+        # @param [String] handle
+        # @param [Symbol] screen
+        def initialize(driver, handle, screen)
+          @driver = driver
+          @handle = handle
+
+          # Use to control history
+          @position = 0
+          @history = [screen]
+        end
+
+        # @return [Symbol] current screen
+        def name
+          @history[@position]
+        end
+
+        # @return [void]
+        def use
+          return if @driver.window_handle == @handle
+          @driver.window_handle = @handle
+        end
+
+        # @return [void]
+        def back
+          raise CannotNavigateBack if @position.zero?
+
+          @driver.back
+          @position -= 1
+        end
+
+        # @return [void]
+        def forward
+          raise CannotNavigateForward if @position >= @history.length
+
+          @driver.forward
+          @position += 1
+        end
+
+        # @return [Boolean]
+        def closed?
+          !@driver.window_handles.include?(window_handle)
+        end
+
+        # Close the window
+        # @return [void]
+        def close
+          @driver.close
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/composite/helpers/window_manager.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require_relative 'window'
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module Composite
+      # Collection to manage Window objects
+      module WindowManager
+        attr_accessor :window
+
+        # @param name [Symbol] name of window to use
+        # @return [void]
+        def use(name)
+          raise AutomationObject::State::ScreenNotActiveError, name unless live_screens.include?(name)
+
+          windows.each do |window|
+            next if window.name != name
+            return if window == self.window
+
+            self.window = window
+            self.window.use
+          end
+        end
+
+        def window
+          raise AutomationObject::State::Error::NoActiveWindows unless @window
+          @window
+        end
+
+        # @return [Array<Window>]
+        def windows
+          @windows ||= []
+        end
+
+        # @return [Array<String>] list of stored window handles
+        def window_handles
+          windows.map(&:handle)
+        end
+
+        # @return [Array<String>] list of stored screen names
+        def live_screens
+          windows.map(&:name)
+        end
+
+        # @return [void]
+        def new_window(name)
+          driver_handles = driver.window_handles
+          diff_handles = driver_handles - window_handles
+
+          # Should only have one extra window
+          raise UnexpectedExtraWindowError if diff_handles.length > 1
+
+          self.window = Window.new(driver, diff_handles.first, name)
+          windows << window
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require_relative '_base'
+
+require_relative 'hook_action'
+require_relative 'hook_actions/element_requirement'
+
+module AutomationObject
+  module State
+    module Composite
+      # 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(element_requirement_blueprints,
+                                                              driver, self, 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(session,
+                                       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(session,
+                                       driver,
+                                       blue_prints.after,
+                                       :hook_action, self, location + '[hook_action]')
+          hook_action.run
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
-require_relative 'composite'
+# frozen_string_literal: true
+require_relative '_base'
 
 require_relative 'hook_actions/change_screen'
 require_relative 'hook_actions/change_to_previous_screen'
@@ -13,21 +14,22 @@ require_relative 'hook_actions/new_screen'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
-      class HookAction < AutomationObject::State::BluePrintAdapter::Composite
+    module Composite
+      # Hook action composite for managing state
+      class HookAction < Base
         # @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.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 = hook_action_class.new(blue_prints: blue_prints, composite: self)
             return false if hook_action.run == false
-          }
+          end
 
-          return true
+          true
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module AutomationObject
+  module State
+    module Composite
+      # Composite action loop base class
+      class ActionLoop
+        attr_accessor :composite, :blue_prints, :loops
+
+        def initialize(blue_prints, driver, composite, loops = 30)
+          self.blue_prints = blue_prints
+          self.driver = driver
+          self.composite = composite
+          self.loops = loops
+        end
+
+        def driver
+          composite.driver
+        end
+
+        # @return [Boolean] run success or not
+        def run
+          loops.times do
+            return true if single_run
+          end
+
+          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 → composite}/hook_actions/change_screen.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Change screen hook loop
       class ChangeScreen < ActionLoop
         def initialize(args = {})
           super
@@ -10,11 +12,11 @@ module AutomationObject
         end
 
         def single_run
-          self.driver.document_complete_wait
+          return false unless driver.document_complete?
 
-          new_screen = self.composite.top.screens[@new_screen_name]
+          new_screen = composite.top.screens[@new_screen_name]
           if new_screen.load.live?
-            self.composite.top.set_screen(@new_screen_name)
+            composite.top.set_screen(@new_screen_name)
             return true
           else
             return false
@@ -23,4 +25,4 @@ module AutomationObject
       end
     end
   end
-end
+end

data/lib/automation_object/state/{blue_print_adapter → composite}/hook_actions/change_to_previous_screen.rb

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Change to previous screen hook loop
       class ChangeToPreviousScreen < ActionLoop
         def single_run
-          self.driver.document_complete_wait
+          return false unless driver.document_complete?
 
-          new_screen = self.composite.top.current_window.previous_screen_name
+          new_screen = composite.top.current_window.previous_screen_name
           if new_screen.load.live?
-            self.composite.top.set_screen(new_screen)
+            composite.top.set_screen(new_screen)
             return true
           else
             return false
@@ -18,4 +20,4 @@ module AutomationObject
       end
     end
   end
-end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module Composite
+      # Close modal hook loop
+      class CloseModal < ActionLoop
+        def single_run
+          return false unless driver.document_complete?
+
+          raise ModalParentExpected unless composite.parent.is_a?(Modal)
+
+          modal = composite.parent
+          modal.active = modal.live?
+
+          return false unless modal.active?
+
+          composite.screen.modal = nil
+          composite.screen.current_modal = nil
+          composite.top.destroy_modal
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module Composite
+      # Close screen hook loop
+      class CloseScreen < ActionLoop
+        def single_run
+          raise ScreenParentExpected unless composite.screen
+
+          screen_name = composite.screen.name
+          composite.top.window_closed?(screen_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module Composite
+      # 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
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module Composite
+      # New screen hook loop
+      class NewScreen < ActionLoop
+        def initialize(args = {})
+          super
+        end
+
+        def single_run
+          new_screen_name = blue_prints
+          new_screen = composite.top.screens[new_screen_name]
+
+          stored_window_handles = composite.top.window_handles
+          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
+
+          composite.top.create_screen(new_screen_name)
+          composite.top.use_screen(new_screen_name)
+
+          return false unless driver.document_complete?
+
+          new_screen.load.live?
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/{blue_print_adapter → composite}/hook_actions/possible_screen_changes.rb

@@ -1,21 +1,22 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Possible screen changes hook loop
       class PossibleScreenChanges < ActionLoop
         def single_run
-          self.blue_prints.each { |possible_screen_name|
-            new_screen = self.composite.top.screens[possible_screen_name]
+          blue_prints.each do |possible_screen_name|
             if possible_screen_name.load.live?
-              self.composite.top.set_screen(possible_screen_name)
+              composite.top.set_screen(possible_screen_name)
               return true
             end
-          }
+          end
 
-          return false
+          false
         end
       end
     end
   end
-end
+end