testcentricity 2.4.1 → 3.0.0

data/lib/testcentricity/app_core/screen_sections_helper.rb

@@ -1,491 +0,0 @@
-require 'test/unit'
-
-module TestCentricity
-  class ScreenSection
-    include Test::Unit::Assertions
-
-    attr_reader   :context, :name
-    attr_accessor :locator
-    attr_accessor :parent
-    attr_accessor :parent_list
-    attr_accessor :list_index
-
-    def initialize(name, parent, locator, context)
-      @name        = name
-      @parent      = parent
-      @locator     = locator
-      @context     = context
-      @parent_list = nil
-      @list_index  = nil
-    end
-
-    def get_locator
-      if @locator.zero? && defined?(section_locator)
-        my_locator = section_locator
-      else
-        my_locator = @locator
-      end
-      locators = []
-      if @context == :section && !@parent.nil?
-        locators.push(@parent.get_locator)
-      end
-
-      if @parent_list.nil?
-        locators.push(my_locator)
-      else
-        locators.push(@parent_list.get_locator)
-        if @list_index.nil?
-          locators.push(my_locator)
-        else
-          list_key = my_locator.keys[0]
-          list_value = "#{my_locator.values[0]}[#{@list_index}]"
-          locators.push( { list_key => list_value } )
-        end
-      end
-      locators
-    end
-
-    def set_list_index(list, index = 1)
-      @parent_list = list unless list.nil?
-      @list_index  = index
-    end
-
-    def get_item_count
-      raise 'No parent list defined' if @parent_list.nil?
-      @parent_list.get_item_count
-    end
-
-    def get_list_items
-      items = []
-      (1..get_item_count).each do |item|
-        set_list_index(nil, item)
-        items.push(get_value)
-      end
-      items
-    end
-
-    def get_object_type
-      :section
-    end
-
-    def get_name
-      @name
-    end
-
-    def set_parent(parent)
-      @parent = parent
-    end
-
-    def self.trait(trait_name, &block)
-      define_method(trait_name.to_s, &block)
-    end
-
-    # def self.element(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppUIElement.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.element(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppUIElement.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.elements(element_hash)
-      element_hash.each do |element_name, locator|
-        element(element_name, locator)
-      end
-    end
-
-    # def self.button(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppButton.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.button(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppButton.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.buttons(element_hash)
-      element_hash.each do |element_name, locator|
-        button(element_name, locator)
-      end
-    end
-
-    # def self.textfield(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppTextField.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.textfield(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppTextField.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.textfields(element_hash)
-      element_hash.each do |element_name, locator|
-        textfield(element_name, locator)
-      end
-    end
-
-    # def self.switch(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppSwitch.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.switch(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppSwitch.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.switches(element_hash)
-      element_hash.each do |element_name, locator|
-        switch(element_name, locator)
-      end
-    end
-
-    # def self.checkbox(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppCheckBox.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.checkbox(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppCheckBox.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.checkboxes(element_hash)
-      element_hash.each do |element_name, locator|
-        checkbox(element_name, locator)
-      end
-    end
-
-    # def self.label(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppLabel.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.label(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppLabel.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.labels(element_hash)
-      element_hash.each do |element_name, locator|
-        label(element_name, locator)
-      end
-    end
-
-    # def self.list(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppList.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.list(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppList.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.lists(element_hash)
-      element_hash.each do |element_name, locator|
-        list(element_name, locator)
-      end
-    end
-
-    # def self.selectlist(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppSelectList.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.selectlist(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppSelectList.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.selectlists(element_hash)
-      element_hash.each do |element_name, locator|
-        selectlist(element_name, locator)
-      end
-    end
-
-    # def self.image(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppImage.new("#{element_name}", self, #{locator}, :section);end))
-    # end
-
-    def self.image(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppImage.new(element_name, self, locator, :section))
-      end
-    end
-
-    def self.images(element_hash)
-      element_hash.each do |element_name, locator|
-        image(element_name, locator)
-      end
-    end
-
-    # def self.alert(element_name, locator)
-    #   class_eval(%(def #{element_name};@#{element_name} ||= TestCentricity::AppAlert.new("#{element_name}", self, #{locator}, :page);end))
-    # end
-
-    def self.alert(element_name, locator)
-      define_method(element_name) do
-        ivar_name = "@#{element_name}"
-        ivar = instance_variable_get(ivar_name)
-        return ivar if ivar
-        instance_variable_set(ivar_name, TestCentricity::AppAlert.new(element_name, self, locator, :page))
-      end
-    end
-
-    def self.section(section_name, class_name, locator = 0)
-      class_eval(%(def #{section_name};@#{section_name} ||= #{class_name}.new("#{section_name}", self, #{locator}, :section);end))
-    end
-
-    def self.sections(section_hash)
-      section_hash.each do |section_name, class_name|
-        section(section_name, class_name)
-      end
-    end
-
-
-    def click
-      section = find_section
-      section_not_found_exception(section)
-      section.click
-    end
-
-    def tap
-      section = find_section
-      section_not_found_exception(section)
-      x = section.location.x
-      y = section.location.y
-      tap_action = Appium::TouchAction.new.tap(element: section, x: x, y: y)
-      tap_action.perform
-    end
-
-    def double_tap
-      section = find_section
-      section_not_found_exception(section)
-      x = section.location.x
-      y = section.location.y
-      tap_action = Appium::TouchAction.new.double_tap(element: section, x: x, y: y)
-      tap_action.perform
-    end
-
-    def exists?
-      section = find_section
-      section != nil
-    end
-
-    def enabled?
-      section = find_section
-      section_not_found_exception(section)
-      section.enabled?
-    end
-
-    def disabled?
-      section = find_section
-      section_not_found_exception(section)
-      section.enabled?
-    end
-
-    def visible?
-      if exists?
-        section.displayed?
-      else
-        false
-      end
-    end
-
-    def hidden?
-      !visible?
-    end
-
-    def wait_until_exists(seconds = nil)
-      timeout = seconds.nil? ? Environ.default_max_wait_time : seconds
-      wait = Selenium::WebDriver::Wait.new(timeout: timeout)
-      wait.until { exists? }
-    rescue
-      raise "Could not find Section object '#{get_name}' (#{get_locator}) after #{timeout} seconds" unless exists?
-    end
-
-    def wait_until_gone(seconds = nil)
-      timeout = seconds.nil? ? Environ.default_max_wait_time : seconds
-      wait = Selenium::WebDriver::Wait.new(timeout: timeout)
-      wait.until { !exists? }
-    rescue
-      raise "Section object '#{get_name}' (#{get_locator}) remained visible after #{timeout} seconds" if exists?
-    end
-
-    def wait_until_visible(seconds = nil)
-      timeout = seconds.nil? ? Environ.default_max_wait_time : seconds
-      wait = Selenium::WebDriver::Wait.new(timeout: timeout)
-      wait.until { visible? }
-    rescue
-      raise "Could not find Section object '#{get_name}' (#{get_locator}) after #{timeout} seconds" unless visible?
-    end
-
-    def wait_until_hidden(seconds = nil)
-      timeout = seconds.nil? ? Environ.default_max_wait_time : seconds
-      wait = Selenium::WebDriver::Wait.new(timeout: timeout)
-      wait.until { hidden? }
-    rescue
-      raise "Section object '#{get_name}' (#{get_locator}) remained visible after #{timeout} seconds" if visible?
-    end
-
-
-    def width
-      section = find_section
-      section_not_found_exception(section)
-      section.size.width
-    end
-
-    def height
-      section = find_section
-      section_not_found_exception(section)
-      section.size.height
-    end
-
-    def x_loc
-      section = find_section
-      section_not_found_exception(section)
-      section.location.x
-    end
-
-    def y_loc
-      section = find_section
-      section_not_found_exception(section)
-      section.location.y
-    end
-
-
-    def verify_ui_states(ui_states)
-      ui_states.each do |ui_object, object_states|
-        object_states.each do |property, state|
-
-          puts "#{ui_object.get_name} - #{property} = #{state}" if ENV['DEBUG']
-
-          case property
-          when :class
-            actual = ui_object.get_attribute(:class)
-          when :exists
-            actual = ui_object.exists?
-          when :enabled
-            actual = ui_object.enabled?
-          when :disabled
-            actual = ui_object.disabled?
-          when :visible
-            actual = ui_object.visible?
-          when :hidden
-            actual = ui_object.hidden?
-          when :checked
-            actual = ui_object.checked?
-          when :selected
-            actual = ui_object.selected?
-          when :value
-            actual = ui_object.get_value
-          when :caption
-            actual = ui_object.get_caption
-          when :name
-            actual = ui_object.tag_name
-          when :placeholder
-            actual = ui_object.get_placeholder
-          when :readonly
-            actual = ui_object.read_only?
-          when :maxlength
-            actual = ui_object.get_max_length
-          when :items
-            actual = ui_object.get_list_items
-          when :itemcount
-            actual = ui_object.get_item_count
-          when :width
-            actual = ui_object.width
-          when :height
-            actual = ui_object.height
-          when :x
-            actual = ui_object.x_loc
-          when :y
-            actual = ui_object.y_loc
-          end
-          error_msg = "Expected UI object '#{ui_object.get_name}' (#{ui_object.get_locator}) #{property} property to"
-          ExceptionQueue.enqueue_comparison(state, actual, error_msg)
-        end
-      end
-    rescue ObjectNotFoundError => e
-      ExceptionQueue.enqueue_exception(e.message)
-    ensure
-      ExceptionQueue.post_exceptions
-    end
-
-    def populate_data_fields(data, wait_time = nil)
-      timeout = wait_time.nil? ? 5 : wait_time
-      data.each do |data_field, data_param|
-        unless data_param.blank?
-          # make sure the intended UI target element is visible before trying to set its value
-          data_field.wait_until_visible(timeout)
-          if data_param == '!DELETE'
-            data_field.clear
-          else
-            case data_field.get_object_type
-            when :checkbox
-              data_field.set_checkbox_state(data_param.to_bool)
-            when :textfield
-              data_field.clear
-              data_field.set("#{data_param}\t")
-            end
-          end
-        end
-      end
-    end
-
-    private
-
-    def find_section
-      obj = nil
-      locators = get_locator
-      locators.each do |loc|
-        if obj.nil?
-          obj = find_element(loc.keys[0], loc.values[0])
-          puts "Found object #{loc}" if ENV['DEBUG']
-        else
-          obj = obj.find_element(loc.keys[0], loc.values[0])
-          puts "Found object #{loc}" if ENV['DEBUG']
-        end
-      end
-      obj
-    rescue
-      nil
-    end
-
-    def section_not_found_exception(obj)
-      raise ObjectNotFoundError.new("Section object '#{get_name}' (#{get_locator}) not found") unless obj
-    end
-  end
-end

data/lib/testcentricity/browser_helper.rb

@@ -1,174 +0,0 @@
-require 'yaml'
-
-
-module TestCentricity
-  module Browsers
-    include Capybara::DSL
-
-    # Sets the size of the browser window.
-    #
-    # @param resolution [Array] the desired [width, height]
-    # @example
-    #   Browsers.set_browser_window_size([1024, 768])
-    #
-    def self.set_browser_window_size(resolution)
-      resolution = resolution.split(',') if resolution.is_a?(String)
-      window = Capybara.current_session.driver.browser.manage.window
-      window.resize_to(resolution[0], resolution[1])
-      Environ.browser_size = [resolution[0].to_i, resolution[1].to_i]
-    end
-
-    # Maximizes the selenium browser window.
-    #
-    # @example
-    #   Browsers.maximize_browser
-    #
-    def self.maximize_browser
-      window = Capybara.current_session.driver.browser.manage.window
-      window.maximize
-    end
-    # Sets the position of the browser window.
-    #
-    # @param x [Integer] the desired x coordinate
-    # @param y [Integer] the desired y coordinate
-    # @example
-    #   Browsers.set_browser_window_position([100, 300])
-    #
-    def self.set_browser_window_position(x, y)
-      window = Capybara.current_session.driver.browser.manage.window
-      window.move_to(x, y)
-    end
-
-    # Refreshes the selenium browser.
-    #
-    # @example
-    #   Browsers.refresh_browser
-    #
-    def self.refresh_browser
-      Capybara.page.driver.browser.navigate.refresh
-    end
-
-    # Emulates clicking the web browser's Back button. Navigates back by one page on the browser’s history.
-    #
-    # @example
-    #   Browsers.navigate_back
-    #
-    def self.navigate_back
-      Capybara.page.driver.browser.navigate.back
-    end
-
-    # Emulates clicking the web browser's Forward button. Navigates forward by one page on the browser’s history.
-    #
-    # @example
-    #   Browsers.navigate_forward
-    #
-    def self.navigate_forward
-      Capybara.page.driver.browser.navigate.forward
-    end
-
-    def self.switch_to_new_browser_instance
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.browser.window_handles.last)
-    end
-
-    def self.close_all_browser_instances
-      Capybara.page.driver.browser.window_handles.each do |handle|
-        page.driver.browser.switch_to.window(handle)
-        page.driver.browser.close
-      end
-    end
-
-    def self.num_browser_instances
-      Capybara.page.driver.browser.window_handles.count
-    end
-
-    def self.close_current_browser_instance
-      Capybara.page.driver.browser.close
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.browser.window_handles.last)
-    end
-
-    def self.close_old_browser_instance
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.browser.window_handles.first)
-      Capybara.page.driver.browser.close
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.browser.window_handles.last)
-    end
-
-    def self.close_named_browser_instance(name)
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.find_window(name))
-      Capybara.page.driver.browser.close
-      Capybara.page.driver.browser.switch_to.window(Capybara.page.driver.browser.window_handles.last)
-    end
-
-    def self.suppress_js_alerts
-      Capybara.page.execute_script('window.alert = function() {}')
-    end
-
-    def self.suppress_js_leave_page_modal
-      Capybara.page.execute_script('window.onbeforeunload = null')
-    end
-
-    def self.delete_all_cookies
-      if Capybara.current_driver == :selenium
-        browser = Capybara.current_session.driver.browser
-        if browser.respond_to?(:manage) && browser.manage.respond_to?(:delete_all_cookies)
-          browser.manage.delete_all_cookies
-        else
-          raise 'Could not clear cookies.'
-        end
-      end
-    end
-
-    def self.set_device_orientation(orientation)
-      if Environ.is_mobile? && !Environ.is_device?
-        Browsers.set_browser_window_size(Browsers.browser_size(Environ.browser.to_s, orientation))
-      else
-        puts '***** Cannot change device orientation of desktop web browsers or remote devices *****'
-      end
-    end
-
-    def self.mobile_device_agent(device)
-      device_name = device.gsub(/\s+/, '').downcase.to_sym
-      device = get_devices[device_name]
-      agent_string = device[:user_agent]
-      raise "Device '#{device}' is not defined" unless agent_string
-      agent_string
-    end
-
-    def self.mobile_device_name(device)
-      device_name = device.gsub(/\s+/, '').downcase.to_sym
-      device = get_devices[device_name]
-      name = device[:name]
-      raise "Device '#{device}' is not defined" unless name
-      Environ.device_os = device[:os]
-      Environ.device_type = device[:type]
-      name
-    end
-
-    def self.browser_size(browser, orientation)
-      device_name = browser.gsub(/\s+/, '').downcase.to_sym
-      device = get_devices[device_name]
-      if device
-        width = device[:css_width]
-        height = device[:css_height]
-        default_orientation = device[:default_orientation].to_sym
-        if orientation
-          Environ.device_orientation = orientation
-          orientation.downcase.to_sym == default_orientation ?
-              size = [width, height] :
-              size = [height, width]
-        else
-          Environ.device_orientation = device[:default_orientation]
-          size = [width, height]
-        end
-      else
-        size = [1650, 1000]
-      end
-      size
-    end
-
-    private
-
-    def self.get_devices
-      YAML.load_file File.expand_path('../../devices/devices.yml', __FILE__)
-    end
-  end
-end