testcentricity_mobile 4.0.0

data/lib/testcentricity_mobile/data_objects/environment.rb

@@ -0,0 +1,416 @@
+module TestCentricity
+  class EnvironData < TestCentricity::DataSource
+    attr_accessor	:current
+    attr_accessor :data_source_type
+    attr_accessor	:generic_data
+    attr_accessor	:environ_specific_data
+
+    def self.find_environ(environ_name, source_type = :yaml)
+      raise 'No environment specified' if environ_name.nil?
+
+      @data_source_type = source_type
+      data = case source_type
+             when :yaml
+               # read generic test data from data.yml file
+               @generic_data ||= YAML.load_file(YML_PRIMARY_DATA_FILE)
+               # read environment specific test data
+               data_file = "#{PRIMARY_DATA_PATH}#{environ_name}_data.yml"
+               @environ_specific_data = if File.exist?(data_file)
+                                          YAML.load_file(data_file)
+                                        else
+                                          {}
+                                        end
+               read('Environments', environ_name)
+             when :json
+               # read generic test data from data.json file
+               raw_data = File.read(JSON_PRIMARY_DATA_FILE)
+               @generic_data = JSON.parse(raw_data)
+               # read environment specific test data
+               data_file = "#{PRIMARY_DATA_PATH}#{environ_name}_data.json"
+               @environ_specific_data = if File.exist?(data_file)
+                                          raw_data = File.read(data_file)
+                                          JSON.parse(raw_data)
+                                        else
+                                          {}
+                                        end
+
+               read('Environments', environ_name)
+             else
+               raise "#{source_type} is not a supported data source type"
+             end
+      @current = Environ.new(data)
+      Environ.current = @current
+    end
+
+    def self.read(key_name, node_name)
+      if @environ_specific_data.key?(key_name) && @environ_specific_data[key_name].key?(node_name)
+        node_data = @environ_specific_data[key_name][node_name]
+      else
+        raise "No key named #{key_name} in generic and environment-specific data" unless @generic_data.key?(key_name)
+        raise "No node named #{node_name} in #{key_name} section of generic and environment-specific data" unless @generic_data[key_name].key?(node_name)
+
+        node_data = @generic_data[key_name][node_name]
+      end
+
+      if node_data.is_a?(Hash)
+        node_data.each do |key, value|
+          node_data[key] = calculate_dynamic_value(value) if value.to_s.start_with?('eval!')
+        end
+      end
+      node_data
+    end
+  end
+
+
+  class Environ < TestCentricity::DataObject
+    @session_id = Time.now.strftime('%d%H%M%S%L')
+    @session_time_stamp = Time.now.strftime('%Y%m%d%H%M%S')
+    @test_environment = ENV['TEST_ENVIRONMENT']
+    @a11y_standard = ENV['ACCESSIBILITY_STANDARD'] || 'best-practice'
+    @locale = ENV['LOCALE'] || 'en'
+    @language = ENV['LANGUAGE'] || 'English'
+    @screen_shots = []
+
+    attr_accessor :test_environment
+    attr_accessor :session_state
+    attr_accessor :session_code
+    attr_accessor :app_session_id
+    attr_accessor :os
+    attr_accessor :device
+    attr_accessor :device_name
+    attr_accessor :device_type
+    attr_accessor :device_os
+    attr_accessor :device_os_version
+    attr_accessor :device_orientation
+    attr_accessor :screen_size
+    attr_accessor :platform
+    attr_accessor :driver
+    attr_accessor :driver_name
+    attr_accessor :appium_driver
+    attr_accessor :tunneling
+    attr_accessor :locale
+    attr_accessor :language
+
+    attr_accessor :parallel
+    attr_accessor :process_num
+
+    attr_accessor :signed_in
+    attr_accessor :portal_status
+    attr_accessor :portal_context
+
+    attr_accessor :user_id
+    attr_accessor :password
+    attr_accessor :app_id
+    attr_accessor :api_key
+    attr_accessor :option1
+    attr_accessor :option2
+    attr_accessor :option3
+    attr_accessor :option4
+    attr_accessor :dns
+    attr_accessor :db_username
+    attr_accessor :db_password
+
+    attr_accessor :ios_app_path
+    attr_accessor :ios_ipa_path
+    attr_accessor :ios_bundle_id
+    attr_accessor :ios_test_id
+    attr_accessor :android_apk_path
+    attr_accessor :android_app_id
+    attr_accessor :android_test_id
+    attr_accessor :default_max_wait_time
+    attr_accessor :deep_link_prefix
+
+    def initialize(data)
+      @user_id	     = data['USER_ID']
+      @password	     = data['PASSWORD']
+      @app_id 	     = data['APP_ID']
+      @api_key	     = data['API_KEY']
+      @option1	     = data['OPTIONAL_1']
+      @option2	     = data['OPTIONAL_2']
+      @option3	     = data['OPTIONAL_3']
+      @option4	     = data['OPTIONAL_4']
+      @dns	         = data['DNS']
+      @db_username   = data['DB_USERNAME']
+      @db_password   = data['DB_PASSWORD']
+      @ios_app_path  = data['IOS_APP_PATH']
+      @ios_ipa_path  = data['IOS_IPA_PATH']
+      @ios_bundle_id = data['IOS_BUNDLE_ID']
+      @ios_test_id   = data['IOS_TEST_ID']
+      @android_apk_path = data['ANDROID_APK_PATH']
+      @android_app_id   = data['ANDROID_APP_ID']
+      @android_test_id  = data['ANDROID_TEST_ID']
+      @deep_link_prefix = data['DEEP_LINK_PREFIX']
+
+      super
+    end
+
+    def self.new_app_session
+      @app_session_id = Time.now.strftime('%Y%m%d%H%M%S%L')
+    end
+
+    def self.app_session_id
+      @app_session_id
+    end
+
+    def self.session_code
+      if @session_code.nil?
+        characters = ('a'..'z').to_a
+        @session_code = (0..12).map { characters.sample }.join
+      end
+      @session_code
+    end
+
+    def self.session_id
+      @session_id
+    end
+
+    def self.session_time_stamp
+      @session_time_stamp
+    end
+
+    def self.parallel=(state)
+      @parallel = state
+    end
+
+    def self.parallel
+      @parallel
+    end
+
+    def self.process_num=(num)
+      @process_num = num
+    end
+
+    def self.process_num
+      @process_num
+    end
+
+    def self.test_environment
+      if @test_environment.blank?
+        nil
+      else
+        @test_environment.downcase.to_sym
+      end
+    end
+
+    def self.default_max_wait_time=(timeout)
+      @default_max_wait_time = timeout
+    end
+
+    def self.default_max_wait_time
+      @default_max_wait_time
+    end
+
+    def self.session_state=(session_state)
+      @session_state = session_state
+    end
+
+    def self.session_state
+      @session_state
+    end
+
+    def self.os=(os)
+      @os = os
+    end
+
+    def self.os
+      @os
+    end
+
+    def self.device=(device)
+      @device = device
+    end
+
+    def self.device
+      @device
+    end
+
+    def self.is_device?
+      @device == :device
+    end
+
+    def self.is_simulator?
+      @device == :simulator
+    end
+
+    def self.is_web?
+      @device == :web
+    end
+
+    def self.device_type=(type)
+      type = type.downcase.to_sym if type.is_a?(String)
+      @device_type = type
+    end
+
+    def self.device_type
+      @device_type
+    end
+
+    def self.device_name=(name)
+      @device_name = name
+    end
+
+    def self.device_name
+      @device_name
+    end
+
+    def self.device_os=(os)
+      @device_os = os.downcase.to_sym
+    end
+
+    def self.device_os
+      @device_os
+    end
+
+    def self.device_os_version=(version)
+      @device_os_version = version
+    end
+
+    def self.device_os_version
+      @device_os_version
+    end
+
+    def self.is_ios?
+      @device_os == :ios
+    end
+
+    def self.is_android?
+      @device_os == :android
+    end
+
+    def self.device_orientation=(orientation)
+      orientation = orientation.downcase.to_sym if orientation.is_a?(String)
+      @device_orientation = orientation
+    end
+
+    def self.device_orientation
+      @device_orientation
+    end
+
+    def self.screen_size=(size)
+      @screen_size = size
+    end
+
+    def self.screen_size
+      @screen_size
+    end
+
+    def self.driver=(type)
+      @driver = type
+    end
+
+    def self.driver
+      @driver
+    end
+
+    def self.driver_name=(name)
+      name = name.downcase.to_sym if name.is_a?(String)
+      @driver_name = name
+    end
+
+    def self.driver_name
+      @driver_name
+    end
+
+    def self.appium_driver=(driver_instance)
+      @appium_driver = driver_instance
+    end
+
+    def self.appium_driver
+      @appium_driver
+    end
+
+    def self.tunneling=(state)
+      @tunneling = state
+    end
+
+    def self.tunneling
+      @tunneling
+    end
+
+    def self.language=(language)
+      @language = language
+    end
+
+    def self.language
+      @language
+    end
+
+    def self.locale=(locale)
+      @locale = locale
+    end
+
+    def self.locale
+      @locale
+    end
+
+    def self.platform=(platform)
+      @platform = platform
+    end
+
+    def self.platform
+      @platform
+    end
+
+    def self.is_mobile?
+      @platform == :mobile
+    end
+
+    def self.set_signed_in(signed_in)
+      @signed_in = signed_in
+    end
+
+    def self.is_signed_in?
+      @signed_in
+    end
+
+    def self.portal_state=(portal_state)
+      @portal_status = portal_state
+    end
+
+    def self.portal_state
+      @portal_status
+    end
+
+    def self.portal_context=(portal_context)
+      @portal_context = portal_context
+    end
+
+    def self.portal_context
+      @portal_context
+    end
+
+    def self.set_external_page(state)
+      @external_page = state
+    end
+
+    def self.save_screen_shot(screen_shot)
+      @screen_shots.push(screen_shot)
+    end
+
+    def self.get_screen_shots
+      @screen_shots
+    end
+
+    def self.reset_contexts
+      @screen_shots = []
+    end
+
+    # :nocov:
+    def self.report_header
+      # build the Cucumber HTML report header
+      report_header = "\n<b><u>TEST ENVIRONMENT</u>:</b> #{ENV['TEST_ENVIRONMENT']}\n"
+      report_header = "#{report_header}  <b>Driver:</b>\t #{Environ.driver}\n" if Environ.driver
+      report_header = "#{report_header}  <b>Driver Name:</b>\t #{Environ.driver_name}\n" if Environ.driver_name
+      report_header = "#{report_header}  <b>Platform:</b>\t #{Environ.platform}\n" if Environ.platform
+      report_header = "#{report_header}  <b>Device:</b>\t #{Environ.device_name}\n" if Environ.device_name
+      report_header = "#{report_header}  <b>Device OS:</b>\t #{Environ.device_os} #{Environ.device_os_version}\n" if Environ.device_os
+      report_header = "#{report_header}  <b>Device type:</b>\t #{Environ.device_type}\n" if Environ.device_type
+      report_header = "#{report_header}  <b>OS:</b>\t\t #{Environ.os}\n" if Environ.os
+      report_header = "#{report_header}  <b>Locale:</b>\t #{Environ.locale}\n" if Environ.locale
+      report_header = "#{report_header}  <b>Language:</b>\t #{Environ.language}\n" if Environ.language
+      report_header = "#{report_header}  <b>Country:</b>\t #{ENV['COUNTRY']}\n" if ENV['COUNTRY']
+      "#{report_header}\n\n"
+    end
+    # :nocov:
+  end
+end

data/lib/testcentricity_mobile/exception_queue_helper.rb

@@ -0,0 +1,160 @@
+module TestCentricity
+  class ExceptionQueue
+    attr_accessor :error_queue
+    attr_accessor :active_ui_element
+
+    def self.enqueue_assert_equal(expected, actual, error_message)
+      is_equal = if expected.is_a?(String) && actual.is_a?(String)
+                   expected.downcase.strip == actual.downcase.strip
+                 else
+                   expected == actual
+                 end
+      unless is_equal
+        enqueue("#{error_message} to be\n  '#{expected}'\nbut found\n  '#{actual}'")
+        enqueue_screenshot
+      end
+    end
+
+    def self.enqueue_assert_not_equal(expected, actual, error_message)
+      unless expected != actual
+        enqueue("#{error_message} to not be equal to '#{expected}'")
+        enqueue_screenshot
+      end
+    end
+
+    def self.enqueue_exception(error_message)
+      enqueue(error_message)
+    end
+
+    def self.post_exceptions(preample_message = nil)
+      unless @error_queue.nil?
+        unless preample_message.nil?
+          @error_queue = "#{preample_message} - The following errors were found:\n_____________________________\n#{@error_queue}"
+        end
+        raise @error_queue
+      end
+    ensure
+      @error_queue = nil
+      @active_ui_element = nil
+    end
+
+    def self.enqueue_comparison(ui_object, state, actual, error_msg)
+      @active_ui_element = ui_object
+      if state.is_a?(Hash) && state.length == 1
+        state.each do |key, value|
+          case key
+          when :lt, :less_than
+            enqueue_exception("#{error_msg} be less than #{value} but found '#{actual}'") unless actual < value
+          when :lt_eq, :less_than_or_equal
+            enqueue_exception("#{error_msg} be less than or equal to #{value} but found '#{actual}'") unless actual <= value
+          when :gt, :greater_than
+            enqueue_exception("#{error_msg} be greater than #{value} but found '#{actual}'") unless actual > value
+          when :gt_eq, :greater_than_or_equal
+            enqueue_exception("#{error_msg} be greater than or equal to  #{value} but found '#{actual}'") unless actual >= value
+          when :starts_with
+            enqueue_exception("#{error_msg} start with '#{value}' but found '#{actual}'") unless actual.start_with?(value)
+          when :ends_with
+            enqueue_exception("#{error_msg} end with '#{value}' but found '#{actual}'") unless actual.end_with?(value)
+          when :contains
+            enqueue_exception("#{error_msg} contain '#{value}' but found '#{actual}'") unless actual.include?(value)
+          when :not_contains, :does_not_contain
+            enqueue_exception("#{error_msg} not contain '#{value}' but found '#{actual}'") if actual.include?(value)
+          when :not_equal
+            enqueue_exception("#{error_msg} not equal '#{value}' but found '#{actual}'") if actual == value
+          when :like, :is_like
+            actual_like = actual.delete("\n")
+            actual_like = actual_like.delete("\r")
+            actual_like = actual_like.delete("\t")
+            actual_like = actual_like.delete(' ')
+            actual_like = actual_like.downcase
+            expected    = value.delete("\n")
+            expected    = expected.delete("\r")
+            expected    = expected.delete("\t")
+            expected    = expected.delete(' ')
+            expected    = expected.downcase
+            enqueue_exception("#{error_msg} be like '#{value}' but found '#{actual}'") unless actual_like.include?(expected)
+          when :translate
+            expected = translate(value)
+            enqueue_assert_equal(expected, actual, error_msg)
+          when :translate_upcase
+            expected = translate(value)
+            expected = expected.is_a?(Array) ? expected.map(&:upcase) : expected.upcase
+            enqueue_assert_equal(expected, actual, error_msg)
+          when :translate_downcase
+            expected = translate(value)
+            expected = expected.is_a?(Array) ? expected.map(&:downcase) : expected.downcase
+            enqueue_assert_equal(expected, actual, error_msg)
+          when :translate_capitalize
+            expected = translate(value)
+            expected = expected.is_a?(Array) ? expected.map(&:capitalize) : expected.capitalize
+            enqueue_assert_equal(expected, actual, error_msg)
+          when :translate_titlecase
+            expected = translate(value)
+            expected = if expected.is_a?(Array)
+                         result = []
+                         expected.each do |item|
+                           result.push("#{item.split.each{ |item| item.capitalize! }.join(' ')}")
+                         end
+                         result
+                       else
+                         "#{expected.split.each{ |expected| expected.capitalize! }.join(' ')}"
+                       end
+            enqueue_assert_equal(expected, actual, error_msg)
+          else
+            raise "#{key} is not a valid comparison key"
+          end
+        end
+      else
+        enqueue_assert_equal(state, actual, error_msg)
+      end
+    end
+
+    private
+
+    def self.enqueue(message)
+      @error_queue = "#{@error_queue}#{message}\n\n"
+    end
+
+    def self.enqueue_screenshot
+      timestamp = Time.now.strftime('%Y%m%d%H%M%S%L')
+      filename = "Screenshot-#{timestamp}.png"
+      path = File.join Dir.pwd, 'reports/screenshots/', filename
+      # take screenshot
+      AppiumConnect.take_screenshot(path)
+      # add screenshot to queue
+      puts "Screenshot saved at #{path}"
+      screen_shot = {path: path, filename: filename}
+      Environ.save_screen_shot(screen_shot)
+    end
+
+    def self.translate(*args, **opts)
+      opts[:locale] ||= I18n.locale
+      opts[:raise] = true
+      I18n.translate(*args, **opts)
+    rescue I18n::MissingTranslationData => err
+      puts err
+      opts[:locale] = :en
+
+      # fallback to en if the translation is missing. If the translation isn't
+      # in en, then raise again.
+      disable_enforce_available_locales do
+        I18n.translate(*args, **opts)
+      end
+    end
+
+    def self.disable_enforce_available_locales
+      saved_enforce_available_locales = I18n.enforce_available_locales
+      I18n.enforce_available_locales = false
+      yield
+    ensure
+      I18n.enforce_available_locales = saved_enforce_available_locales
+    end
+  end
+
+
+  class ObjectNotFoundError < StandardError
+    def initialize(message)
+      super(message)
+    end
+  end
+end

data/lib/testcentricity_mobile/utility_helpers.rb

@@ -0,0 +1,48 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+
+  def boolean?
+    [true, false].include? self
+  end
+end
+
+
+class String
+  def to_bool
+    return true if self == true || self =~ (/(true|t|yes|y|x|1)$/i)
+    return false if self == false || self.blank? || self =~ (/(false|f|no|n|0)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+  end
+
+  def string_between(marker1, marker2)
+    self[/#{Regexp.escape(marker1)}(.*?)#{Regexp.escape(marker2)}/m, 1]
+  end
+
+  def format_date_time(date_time_format)
+    return if self.blank?
+    new_date = DateTime.parse(self)
+    if ENV['LOCALE'] && date_time_format.is_a?(Symbol)
+      I18n.l(new_date, format: date_time_format)
+    else
+      new_date.strftime(date_time_format)
+    end
+  end
+
+  def titlecase
+    "#{self.split.each{ |text| text.capitalize! }.join(' ')}"
+  end
+
+  def is_int?
+    Integer(self) && true rescue false
+  end
+
+  def is_float?
+    Float(self) && true rescue false
+  end
+end

data/lib/testcentricity_mobile/version.rb

@@ -0,0 +1,3 @@
+module TestCentricityMobile
+  VERSION = '4.0.0'
+end

data/lib/testcentricity_mobile/world_extensions.rb

@@ -0,0 +1,61 @@
+module WorldData
+  def environs
+    @environs ||= TestCentricity::EnvironData
+  end
+
+  # instantiate and register all data objects specified in data_objects method
+  #
+  def instantiate_data_objects
+    # return if data objects have already been instantiated and registered
+    return if TestCentricity::DataManager.loaded?
+
+    # instantiate all data objects
+    @data = {}
+    data_objects.each do |data_type, data_class|
+      @data[data_type] = data_class.new unless @data.has_key?(data_type)
+      # define data object accessor method
+      define_method(data_type) do
+        if instance_variable_defined?(:"@#{data_type}")
+          instance_variable_get(:"@#{data_type}")
+        else
+          instance_variable_set(:"@#{data_type}", TestCentricity::DataManager.find_data_object(data_type))
+        end
+      end
+    end
+    # register all data objects with DataManager
+    TestCentricity::DataManager.register_data_objects(@data)
+  end
+end
+
+
+module WorldScreens
+  # instantiate and register all screen objects specified in screen_objects method
+  #
+  def instantiate_screen_objects
+    # return if screen objects have already been instantiated and registered
+    return if TestCentricity::ScreenManager.loaded?
+
+    # instantiate all screen objects
+    @screens = {}
+    screen_objects.each do |screen_object, screen_class|
+      obj = screen_class.new
+      @screens[screen_object] = obj unless @screens.has_key?(screen_object)
+      screen_names = obj.screen_name
+      screen_names = Array(screen_names) if screen_names.is_a? String
+      screen_names.each do |name|
+        screen_key = name.gsub(/\s+/, '').downcase.to_sym
+        @screens[screen_key] = obj unless @screens.has_key?(screen_key)
+      end
+      # define screen object accessor method
+      define_method(screen_object) do
+        if instance_variable_defined?(:"@#{screen_object}")
+          instance_variable_get(:"@#{screen_object}")
+        else
+          instance_variable_set(:"@#{screen_object}", TestCentricity::ScreenManager.find_screen(screen_object))
+        end
+      end
+    end
+    # register all screen objects with ScreenManager
+    TestCentricity::ScreenManager.register_screen_objects(@screens)
+  end
+end