automation_object 0.8.1 → 0.8.2

data/lib/automation_object/blue_print/page_object_adapter/helpers/multiple_elements_helper.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # Helper module for multiple element composite classes
+      module MultipleElementsHelper
+        # @return [Range, nil] gives range for limiting multiple elements or nil
+        def custom_range
+          custom_range = hash[:custom_range]
+
+          case custom_range
+          when String
+            integer_array = custom_range.split('..').map { |number| Integer(number) }
+            return integer_array[0]..integer_array[1]
+          when Hash
+            return custom_range[:start].to_i..custom_range[:end].to_i
+          end
+
+          nil
+        end
+
+        # @return [Symbol, nil] gives element method to remove duplicates on or nil
+        def remove_duplicates
+          remove_duplicates = hash[:remove_duplicates]
+
+          case remove_duplicates
+          when Symbol, String
+            return remove_duplicates.to_sym
+          else
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/hook.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+
+require_relative 'hook_element_requirements'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # Hook composite
+      class Hook < Composite
+        # @return [Array<HookElementRequirements>] array of element requirements
+        def live?
+          return @live if defined? @live
+
+          children = get_property(:live?)
+          children = children.is_a?(Array) ? children : []
+
+          @live = create_array_children(:live, children,
+                                        interface: HookElementRequirements,
+                                        location: location + '[live?]')
+          @live
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/hook_action.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # HockAction composite
+      class HockAction < Composite
+        # Get the order to run the hook in
+        # @return [Array<Symbol>] list of hook methods to run in given order
+        def hook_order
+          hash.keys
+        end
+
+        # Get length of hook actions
+        # @return [Integer] length of hook actions
+        def length
+          hash.keys.length
+        end
+
+        # See if hook actions are empty
+        # @return [Boolean] if hook actions are empty
+        def empty?
+          hash.keys.empty?
+        end
+
+        # @return [Symbol, nil] screen to change to
+        def change_screen
+          change_screen = hash[:change_screen]
+
+          case change_screen
+            when Symbol, String
+              return change_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Symbol, nil] new screen
+        def new_screen
+          new_screen = hash[:new_screen]
+
+          case new_screen
+            when Symbol, String
+              return new_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Boolean]
+        def close_screen
+          hash[:close_screen] ||= false
+        end
+
+        # @return [Boolean]
+        def close_modal
+          hash[:close_modal] ||= false
+        end
+
+        # @return [Boolean]
+        def change_to_previous_screen
+          hash[:change_to_previous_screen] ||= false
+        end
+
+        # @return [Symbol, nil]
+        def show_modal
+          show_modal = hash[:show_modal]
+
+          case show_modal
+            when Symbol, String
+              return show_modal.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Array]
+        def possible_screen_changes
+          return hash[:possible_screen_changes].map(&:to_sym) if hash[:possible_screen_changes].is_a?(Array)
+
+          []
+        end
+
+        # @return [Boolean] reset the screen?
+        def reset_screen
+          hash[:reset_screen] ||= false
+        end
+
+        # @return [Numeric] amount of time to sleep
+        def sleep
+          hash[:sleep] ||= 0
+        end
+
+        # Custom method for array of children instead of Hash
+        # @return [Array<HookElementRequirements>] array of wait for element children
+        def wait_for_elements
+          return @wait_for_elements if defined? @wait_for_elements
+          wait_for_elements = hash[:wait_for_elements]
+
+          children = wait_for_elements.is_a?(Array) ? wait_for_elements : []
+          @wait_for_elements = create_array_children(:wait_for_elements, children,
+                                                     interface: HookElementRequirements,
+                                                     location: location + '[wait_for_elements]')
+
+          @wait_for_elements
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/hook_element_requirements.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # HookElementRequirements composite
+      class HookElementRequirements < Composite
+        # Get the order to run the hook in
+        # @return [Array<Symbol>] list of hook methods to run in given order
+        def hook_order
+          hook_order = [:exists?] # Always put exists? first
+
+          hash.each_key do |hook_name|
+            hook_order.push(hook_name) unless %i[element_name exists?].include?(hook_name)
+          end
+
+          hook_order
+        end
+
+        # Get element requirement
+        # @param name [Symbol] name of requested requirement
+        def requirement(name)
+          hash[name] ||= nil
+        end
+
+        # Get name of the element
+        # @return [Symbol] name of element
+        def element_name
+          element_name = hash[:element_name]
+
+          case element_name
+            when Symbol, String
+              return element_name.to_sym
+            else
+              return nil
+          end
+        end
+
+        # Convience for getting element blueprints
+        # @return [AutomationObject::BluePrint::HashAdapter::Element]
+        def element_blueprints(composite_object = nil)
+          composite_object = self unless composite_object
+
+          # Traverse!
+          return composite_object.elements[element_name] if composite_object.hash[:elements].is_a?(Hash)
+
+          return element_blueprints(composite_object.parent) if composite_object.parent
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/modal.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+
+require_relative 'hook'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # Modal composite
+      class Modal < Composite
+        # Relationships
+        has_one :load, interface: Hook
+        has_one :accept, interface: Hook
+        has_one :dismiss, interface: Hook
+
+        has_many :modals, interface: Modal
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/screen.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+
+require_relative 'modal'
+require_relative 'hook'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # Screen composite
+      class Screen < Composite
+        # Relationships
+        has_one :load, interface: Hook
+        has_one :accept, interface: Hook
+        has_one :dismiss, interface: Hook
+
+        has_many :modals, interface: Modal
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        # @return [Array<Symbol>] array of screens where screen can automatically change to
+        def automatic_screen_changes
+          screen_array = get_property(:automatic_screen_changes) || []
+          screen_array.map(&:to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/blue_print/page_object_adapter/top.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'composite'
+require_relative 'screen'
+
+module AutomationObject
+  module BluePrint
+    module PageObjectAdapter
+      # Top composite
+      class Top < Composite
+        # Relationships
+        has_many :screens, interface: Screen
+
+        def initialize(defined_module)
+          super(defined_module, defined_module.const_get(:Configuration))
+        end
+
+        # @return [String, nil] base url to navigate to upon framework creation
+        def base_url
+          get_property(:base_url) || nil
+        end
+
+        # @return [Symbol, nil] default screen to be set when framework is created
+        def default_screen
+          default_screen = get_property(:default_screen)
+
+          case default_screen
+            when Symbol, String
+              return default_screen.to_sym
+            else
+              return nil
+          end
+        end
+
+        # @return [Numeric] sleep when transitioning screens
+        def screen_transition_sleep
+          get_property(:screen_transition_sleep) || 0
+        end
+
+        # @return [Hash] driver methods to throttle
+        def throttle_driver_methods
+          get_property(:throttle_driver_methods) || {}
+        end
+
+        # @return [Hash] element methods to throttle
+        def throttle_element_methods
+          get_property(:throttle_element_methods) || {}
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/dsl/_error.rb

@@ -4,24 +4,6 @@ module AutomationObject
   module Dsl
     # Errors related to interacting with the DSL
     module Error
-      # Error for automatically reaching screen
-      class AutoReachScreenError < StandardError
-        # @param name [Symbol,String] screen name
-        def initialize(name)
-          message = "#{name}, unable to automatically reach screen"
-          super(message)
-        end
-      end
-
-      # Error for automatically reaching modal
-      class AutoReachModalError < StandardError
-        # @param name [Symbol,String] screen name
-        def initialize(name)
-          message = "#{name}, unable to automatically reach modal"
-          super(message)
-        end
-      end
-
       # Error for non-existent screen
       class ScreenDoesNotExistError < StandardError
         # @param name [Symbol,String] screen name
@@ -31,15 +13,6 @@ module AutomationObject
         end
       end
 
-      # Error for non-existent modal
-      class ModalDoesNotExistError < StandardError
-        # @param name [Symbol,String] modal name
-        def initialize(name)
-          message = "#{name} modal does not exist"
-          super(message)
-        end
-      end
-
       # Error for non-existent element
       class ElementDoesNotExistError < StandardError
         # @param name [Symbol,String] element name

data/lib/automation_object/dsl/modal.rb

@@ -46,9 +46,9 @@ module AutomationObject
       # Go to this modal
       # Will try to automatically reach it, will throw error if it cannot
       # @raise [AutomationObject::Dsl::Error::AutoReachModalError]
-      # @return [void]
+      # @return [Boolean]
       def go
-        raise AutomationObject::Dsl::Error::AutoReachModalError, @name unless @state.go
+        @state.go
       end
 
       # Retrieve element from composite

data/lib/automation_object/dsl/screen.rb

@@ -55,21 +55,22 @@ module AutomationObject
       # Go to this screen
       # Will try to automatically reach it, will throw error if it cannot
       # @raise [AutomationObject::Dsl::Error::AutoReachScreenError]
-      # @return [void]
+      # @return [Boolean]
       def go
-        raise AutomationObject::Dsl::Error::AutoReachScreenError, @name unless @state.go
+        @state.go
       end
 
-      # Retrieve modal from composite
+      # Retrieve modal or self from composite
       # @param name [String, Symbol] name of modal
-      # @raise [AutomationObject::Dsl::Error::ModalDoesNotExistError]
-      # @return [AutomationObject::Dsl::ModalProxy]
+      # @return [AutomationObject::Dsl::ModalProxy, AutomationObject::Dsl::ScreenProxy]
       def modal(name)
         name = name.to_sym
         raise AutomationObject::Dsl::Error::ModalDoesNotExistError, name unless @subject.to_h.include?(name)
 
         @state.utilize
-        @subject.send(name)
+        return @subject.send(name) if @subject.send(name)
+
+        self
       end
 
       # Retrieve element from composite

data/lib/automation_object/framework.rb

@@ -54,17 +54,10 @@ module AutomationObject
 
     # BluePrints (UI configurations) wrapped in an composite
     # Composite provides a common interface for all adapters
-    # @param value [String, Hash] String to YAML files or Hash configuration
+    # @param value [String, Hash] String to YAML files, PageObject, or Hash configuration
     # @return [AutomationObject::BluePrint::Composite::Top] top composite object
     undef :blue_prints= if defined? :blue_prints=
     def blue_prints=(value)
-      case value
-      when String
-        BluePrint.adapter = :yaml
-      when Hash
-        BluePrint.adapter = :hash
-      end
-
       @blue_prints = BluePrint.create(value)
     end