automation_object 0.5.0 → 0.5.1

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+require_relative 'action_loop'
+
+module AutomationObject
+  module State
+    module Composite
+      # Reset screen hook loop
+      class ResetScreen < ActionLoop
+        def single_run
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Show modal hook loop
       class ShowModal < ActionLoop
         def initialize(args = {})
           super
@@ -10,11 +12,11 @@ module AutomationObject
         end
 
         def single_run
-          new_modal = self.composite.screen.modals[@new_modal_name]
+          new_modal = 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
+            composite.screen.current_modal = @new_modal_name
+            composite.screen.modal = new_modal
             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/sleep.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Sleep hook loop
       class Sleep < ActionLoop
         def initialize(args = {})
           super
@@ -15,4 +17,4 @@ module AutomationObject
       end
     end
   end
-end
+end

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

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
 require_relative 'action_loop'
 
 module AutomationObject
   module State
-    module BluePrintAdapter
+    module Composite
+      # Wait for elements hook loop
       class WaitForElements < ActionLoop
         def single_run
-          self.blue_prints.each { |hook_element_requirement|
+          blue_prints.each do |hook_element_requirement|
             hook_element_requirement = ElementRequirement.new(blue_prints: hook_element_requirement,
                                                               composite: self,
                                                               loops: 1)
             return false unless hook_element_requirement.run
-          }
+          end
 
-          return true
+          true
         end
       end
     end
   end
-end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '../error'
+
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module State
+    module Composite
+      # Modal composite for managing state
+      class Modal < Base
+        has_one :load, interface: Hook
+
+        has_many :elements, interface: Element
+        has_many :element_arrays, interface: ElementArray
+        has_many :element_hashes, interface: ElementHash
+
+        def get(type, name)
+          case type
+          when :element
+            elements[name].load
+          when :element_array
+            element_arrays[name].load
+          when :element_hash
+            element_hashes[name].load
+          else
+            raise AutomationObject::State::UndefinedLoadTypeError
+          end
+        end
+
+        # Whether or not modal is active
+        # @return [Boolean]
+        attr_accessor :active
+
+        undef :active if defined? :active
+        # @return [Boolean] screen is active or not
+        def active
+          @active ||= false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require_relative '_base'
+require_relative '../error'
+
+require_relative 'modal'
+require_relative 'hook'
+require_relative 'element'
+require_relative 'element_array'
+require_relative 'element_hash'
+
+module AutomationObject
+  module State
+    module Composite
+      # Screen composite for managing state
+      class Screen < Base
+        attr_accessor :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
+
+        def use(name)
+          self.modal = name
+        end
+
+        def get(type, name)
+          return modals[modal].get(type, name) if modal
+
+          case type
+          when :element
+            return elements[name].load
+          when :element_array
+            return element_arrays[name].load
+          when :element_hash
+            return element_hashes[name].load
+          else
+            raise AutomationObject::State::UndefinedLoadTypeError
+          end
+        end
+
+        # Whether or not modal is active
+        # @return [Boolean]
+        attr_accessor :active
+
+        undef :active if defined? :active
+        # @return [Boolean] screen is active or not
+        def active
+          @active ||= false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require_relative '../error'
+
+require_relative '_base'
+require_relative 'screen'
+
+require_relative 'helpers/window_manager'
+
+module AutomationObject
+  module State
+    module Composite
+      # Top composite for managing state
+      class Top < Base
+        include WindowManager
+
+        # Children for this composite
+        has_many :screens, interface: Screen
+
+        def initialize(*args)
+          super(*args)
+
+          driver.get(blue_prints.base_url) if blue_prints.base_url
+          new_window(initial_screen)
+        end
+
+        def current_screen
+          screens[window.name]
+        end
+
+        # Get the initial screen
+        # @raise [AutomationObject::State::NoInitialScreenError] if no initial screen
+        # @return [Symbol] screen name
+        def initial_screen
+          # If default screen then check if its live and set it
+          if blue_prints.default_screen
+            default_name = blue_prints.default_screen
+            return default_name if screens[default_name].load.live? != false
+
+            raise AutomationObject::State::NoInitialScreenError
+          end
+
+          screens.each do |screen_name, screen|
+            return screen_name if screen.load.live?
+          end
+
+          raise AutomationObject::State::NoInitialScreenError
+        end
+      end
+    end
+  end
+end

data/lib/automation_object/state/error.rb

@@ -1,14 +1,39 @@
+# frozen_string_literal: true
 module AutomationObject
   module State
-    class UndefinedLoadTypeError < StandardError;
+    # Cannot navigate back error
+    class CannotNavigateBack < StandardError
+      def initialize(message = 'Cannot navigate backwards in history')
+        super
+      end
+    end
+
+    # Cannot navigate forward error
+    class CannotNavigateForward < StandardError
+      def initialize(message = 'Cannot navigate forwards in history')
+        super
+      end
     end
 
+    # More than one expected new windows
+    class UnexpectedExtraWindowError < StandardError
+      def initialize(message = 'Expecting only 1 extra window')
+        super
+      end
+    end
+
+    # Undefined load type called on the State object
+    class UndefinedLoadTypeError < StandardError
+    end
+
+    # No initial screen to start from
     class NoInitialScreenError < StandardError
       def initialize(message = 'No initial screen to be set to')
         super
       end
     end
 
+    # Screen is not currently active
     class ScreenNotActiveError < StandardError
       def initialize(screen)
         message = "#{screen} is not currently active"
@@ -16,9 +41,23 @@ module AutomationObject
       end
     end
 
-    class ModalNotActiveError < StandardError; end
-    class ModalParentExpected < StandardError; end
-    class ScreenParentExpected < StandardError; end
-    class MoreThenOneScreenCreated < StandardError; end
+    # Modal isn't active error
+    class ModalNotActiveError < StandardError
+    end
+
+    # Modal parent error
+    class ModalParentExpected < StandardError
+    end
+
+    # Screen parent error
+    class ScreenParentExpected < StandardError
+    end
+
+    # More than one screen created error
+    class MoreThenOneScreenCreated < StandardError
+    end
+
+    class NoActiveWindows < StandardError
+    end
   end
-end
+end

data/lib/automation_object/state/session.rb

@@ -1,38 +1,40 @@
+# frozen_string_literal: true
 require_relative 'error'
 
+require_relative 'composite/top'
+
 module AutomationObject
   module State
-    #Store session details, methods for controlling viewing current driver session.
+    # Session manages the DSL state
     class Session
-      attr_accessor :driver, :composite
+      # @return [AutomationObject::Driver::Driver]
+      attr_accessor :driver
+
+      # @return [AutomationObject::BluePrint::Composite::Top]
+      attr_accessor :blue_prints
 
-      def initialize(args={})
-        self.driver = args.fetch :driver
-        self.composite = args.fetch :composite
+      # @return [AutomationObject::State::Composite::Top]
+      attr_accessor :composite
 
-        self.composite.create
+      # @param [AutomationObject::Driver::Driver] driver
+      # @param [AutomationObject::BluePrint::Composite::Top] blue_prints
+      def initialize(driver, blue_prints)
+        self.driver = driver
+        self.composite = Composite::Top.new(self, driver, blue_prints)
       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
+        when :screen
+          composite.use(name)
+        when :modal
+          composite.current_screen.use(name)
+        when :element, :element_array, :element_hash
+          return composite.current_screen.get(type, name)
+        else
+          raise AutomationObject::State::UndefinedLoadTypeError
         end
       end
     end
   end
-end
+end

data/lib/automation_object/step_definitions.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
 module AutomationObject
-  #Require step definitons at run-time, only when running in a Cucumber context
+  # Require step definitons at run-time, only when running in a Cucumber context
   module StepDefinitions
-    extend self
+    module_function
 
     def load
+      # Using minitest to run assertions
       require 'minitest/autorun'
       require 'minitest/unit'
       require 'minitest-bonus-assertions'
@@ -11,4 +13,4 @@ module AutomationObject
       Dir[File.dirname(__FILE__) + '/step_definitions/**/*.rb'].each { |file| require file }
     end
   end
-end
+end

data/lib/automation_object/step_definitions/element.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require_relative 'support/parse'
+
+# Description: Provides step definitions related to elements
+
+# For: Calling an element method
+# Examples:
+# - I click on the "home_screen" "about_button" element
+# - I hover over the "home_screen" "test_link" element
+# - I tap on "home_screen" "logo_button" element
+When(/^I (\w+|%\{[\w\d]+\}) ?(?: on| over)? (?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element$/) do |*args|
+  method, screen, element = AutomationObject::StepDefinitions::Parse.new(args).get
+  AutomationObject::Framework.get.send(screen).send(element).send(method)
+end
+
+# For: Typing into element field
+# Examples:
+# - I type "blah" into the "home_screen" "text_field" element
+# - I type "test" in the "home_screen" "text_field" element
+# - I type "blah" in "home_screen" "text_field" element
+When(/^I type "([\w\s]+|%\{[\w\d]+\})" in(?:to)? (?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element$/) do |*args|
+  text, screen, element = AutomationObject::StepDefinitions::Parse.new(args).get
+  AutomationObject::Framework.get.send(screen).send(element).send_keys(text)
+end
+
+# For: Scrolling element into focus
+# Examples:
+# - I scroll to the "home_screen" "logo_button" element
+# - I focus to the "home_screen" "logo_button" element
+# - I scroll to "home_screen" "logo_button" element
+When(/^I (?:scroll |focus )to (?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element$/) do |*args|
+  screen, element = AutomationObject::StepDefinitions::Parse.new(args).get
+  AutomationObject::Framework.get.send(screen).send(element).scroll_into_view
+end
+
+# For: Saving value from element for use later
+# Examples:
+# - I save "text" as "unique_value" from the "home_screen" "logo_button" element
+# - I save "id" as "unique_value" from "home_screen" "logo_button" element
+When(/^I save "(\w+|%\{[\w\d]+\})" as "([\w\d]+)" from (?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element$/) do |*args|
+  method, key, screen, element = AutomationObject::StepDefinitions::Parse.new(args).get
+  # Save value from called method/property
+  value = AutomationObject::Framework.get.send(screen).send(element).send(method)
+  AutomationObject::StepDefinitions::Cache.set(key, value)
+end
+
+# For: Testing if the element exists or not
+# Examples:
+# - the "home_screen" "title" element should exist
+# - the "home_screen" "title" element shouldn't exist
+# - "home_screen" "title" element should not exist
+Then(/^(?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element should ?(n't |not )?exist$/) do |*args|
+  screen, element, negative = AutomationObject::StepDefinitions::Parse.new(args).get
+
+  exists = AutomationObject::Framework.get.send(screen).send(element).exists?
+  if negative
+    assert_equal false, exists
+  else
+    assert_equal true, exists
+  end
+end
+
+# For: Testing if the element method value equals a given value
+# Examples:
+# - the "home_screen" "title" element "text" should equal "Home"
+# - "home_screen" "title" element "text" should not equal "About"
+# - the "home_screen" "title" element "text" shouldn't equal "%{saved_value}"
+Then(/^(?:the )?"(\w+|%\{[\w\d]+\})" "(\w+|%\{[\w\d]+\})" element "(\w+|%\{[\w\d]+\})" should ?(n't |not )?equal "(\w+|%\{[\w\d]+\})"$/) do |*args|
+  screen, element, method, negative, expected_value = AutomationObject::StepDefinitions::Parse.new(args).get
+
+  actual_value = AutomationObject::Framework.get.send(screen).send(element).send(method)
+  if negative
+    refute_equal expected_value, actual_value
+  else
+    assert_equal expected_value, actual_value
+  end
+end