automation_object 0.0.4 → 0.5.0

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

@@ -0,0 +1,26 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ChangeScreen < ActionLoop
+        def initialize(args = {})
+          super
+          @new_screen_name = args.fetch :blue_prints
+        end
+
+        def single_run
+          self.driver.document_complete_wait
+
+          new_screen = self.composite.top.screens[@new_screen_name]
+          if new_screen.load.live?
+            self.composite.top.set_screen(@new_screen_name)
+            return true
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ChangeToPreviousScreen < ActionLoop
+        def single_run
+          self.driver.document_complete_wait
+
+          new_screen = self.composite.top.current_window.previous_screen_name
+          if new_screen.load.live?
+            self.composite.top.set_screen(new_screen)
+            return true
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

@@ -0,0 +1,37 @@
+require_relative 'action_loop'
+require_relative '../../error'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class NewScreen < ActionLoop
+        def initialize(args = {})
+          super
+        end
+
+        def single_run
+          new_screen_name = self.blue_prints
+          new_screen = self.composite.top.screens[new_screen_name]
+
+          stored_window_handles = self.composite.top.window_handles
+          driver_handles = self.driver.window_handles
+
+          if driver_handles.length <= stored_window_handles.length
+            return false
+          end
+
+          if (driver_handles.length - stored_window_handles.length) > 1
+            raise MoreThenOneScreenCreated.new
+          end
+
+          self.composite.top.create_screen(new_screen_name)
+          self.composite.top.use_screen(new_screen_name)
+
+          self.driver.document_complete_wait
+
+          return new_screen.load.live?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class PossibleScreenChanges < ActionLoop
+        def single_run
+          self.blue_prints.each { |possible_screen_name|
+            new_screen = self.composite.top.screens[possible_screen_name]
+            if possible_screen_name.load.live?
+              self.composite.top.set_screen(possible_screen_name)
+              return true
+            end
+          }
+
+          return false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ResetScreen < ActionLoop
+        def single_run
+          unless self.composite.screen
+            raise ScreenParentExpected.new
+          end
+
+          screen_name = self.composite.screen.name
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class ShowModal < ActionLoop
+        def initialize(args = {})
+          super
+          @new_modal_name = args.fetch :blue_prints
+        end
+
+        def single_run
+          new_modal = self.composite.screen.modals[@new_modal_name]
+
+          if new_modal.load.live? != false
+            self.composite.screen.current_modal = @new_modal_name
+            self.composite.screen.modal = new_modal
+            return true
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Sleep < ActionLoop
+        def initialize(args = {})
+          super
+          @time = args.fetch :blue_prints
+        end
+
+        def single_run
+          sleep(@time)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class WaitForElements < ActionLoop
+        def single_run
+          self.blue_prints.each { |hook_element_requirement|
+            hook_element_requirement = ElementRequirement.new(blue_prints: hook_element_requirement,
+                                                              composite: self,
+                                                              loops: 1)
+            return false unless hook_element_requirement.run
+          }
+
+          return true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require_relative 'composite'
+
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      #TODO: refactor to container
+      class Modal < AutomationObject::State::BluePrintAdapter::Composite
+        has_one :load, interface: Hook
+
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        attr_accessor :active
+        # @return [Boolean] screen is active or not
+        def active
+          return @active ||= false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative 'composite'
+
+require_relative 'modal'
+require_relative 'hook'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Screen < AutomationObject::State::BluePrintAdapter::Composite
+        attr_accessor :modal, :current_modal
+
+        has_one :load, interface: Hook
+
+        #Children for this composite
+        has_many :modals, interface: Modal
+
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        attr_accessor :active
+        # @return [Boolean] screen is active or not
+        def active
+          return @active ||= false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require_relative 'composite'
+require_relative 'screen'
+
+require_relative 'helpers/screen_manager'
+
+require_relative '../error'
+
+module AutomationObject
+  module State
+    module BluePrintAdapter
+      class Top < AutomationObject::State::BluePrintAdapter::Composite
+        include ScreenManager
+
+        #Children for this composite
+        has_many :screens, interface: Screen
+
+        # @return [Symbol] symbol of the initial screen found
+        def create
+          self.driver.get(self.blue_prints.base_url) if self.blue_prints.base_url
+          self.set_screen(self.initial_screen)
+        end
+
+        def initial_screen
+          #If default screen then check if its live and set it
+          if self.blue_prints.default_screen
+            screen_name = self.blue_prints.default_screen
+            default_screen_live = self.screens[screen_name].load.live?
+
+            if default_screen_live == nil or default_screen_live == true
+              return screen_name
+            else
+              raise AutomationObject::State::NoInitialScreenError.new
+            end
+          end
+
+          self.screens.each { |screen_name, screen|
+            return screen_name if screen.load.live?
+          }
+
+          raise AutomationObject::State::NoInitialScreenError.new
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/error.rb

@@ -0,0 +1,24 @@
+module AutomationObject
+  module State
+    class UndefinedLoadTypeError < StandardError;
+    end
+
+    class NoInitialScreenError < StandardError
+      def initialize(message = 'No initial screen to be set to')
+        super
+      end
+    end
+
+    class ScreenNotActiveError < StandardError
+      def initialize(screen)
+        message = "#{screen} is not currently active"
+        super(message)
+      end
+    end
+
+    class ModalNotActiveError < StandardError; end
+    class ModalParentExpected < StandardError; end
+    class ScreenParentExpected < StandardError; end
+    class MoreThenOneScreenCreated < StandardError; end
+  end
+end

data/lib/automation_object/state/session.rb

@@ -0,0 +1,38 @@
+require_relative 'error'
+
+module AutomationObject
+  module State
+    #Store session details, methods for controlling viewing current driver session.
+    class Session
+      attr_accessor :driver, :composite
+
+      def initialize(args={})
+        self.driver = args.fetch :driver
+        self.composite = args.fetch :composite
+
+        self.composite.create
+      end
+
+      def load(type, name)
+        case type
+          when :screen
+            unless self.composite.screen_exists?(name)
+              raise AutomationObject::State::ScreenNotActiveError.new(name)
+            end
+
+            self.composite.use_screen(name)
+          when :modal
+            unless self.composite.screens[self.composite.current_screen].current_modal == name
+              raise AutomationObject::State::ModalNotActiveError.new(name)
+            end
+
+            self.composite.use_modal(name)
+          when :element, :element_array, :element_hash
+            return self.composite.get_object(type, name)
+          else
+            raise AutomationObject::State::UndefinedLoadTypeError.new
+        end
+      end
+    end
+  end
+end