testcentricity 2.3.13

data/lib/testcentricity/data_objects/data_objects_helper.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+require 'json'
+
+
+module TestCentricity
+
+  XL_PRIMARY_DATA_PATH ||= 'features/test_data/'
+  XL_PRIMARY_DATA_FILE ||= "#{XL_PRIMARY_DATA_PATH}data.xls"
+
+
+  class DataObject
+    attr_accessor :current
+    attr_accessor :context
+    attr_accessor :hash_table
+
+    def initialize(data)
+      @hash_table = data
+    end
+
+    # @deprecated Please use {#current=} instead
+    def self.set_current(current)
+      warn "[DEPRECATION] 'TestCentricity::DataObject.set_current' is deprecated.  Please use 'current=' instead."
+      @current = current
+    end
+
+    def self.current
+      @current
+    end
+
+    def self.current=(current)
+      @current = current
+    end
+  end
+
+
+  class DataSource
+    attr_accessor :current
+
+    def read_yaml_node_data(file_name, node_name)
+      data = YAML.load_file("#{XL_PRIMARY_DATA_PATH}#{file_name}")
+      data[node_name]
+    end
+
+    def read_json_node_data(file_name, node_name)
+      raw_data = File.read("#{XL_PRIMARY_DATA_PATH}#{file_name}")
+      data = JSON.parse(raw_data)
+      data[node_name]
+    end
+  end
+
+
+  class ExcelDataSource < TestCentricity::DataSource
+    def pick_excel_data_source(sheet, row_spec)
+      if ENV['TEST_ENVIRONMENT']
+        environment = ENV['TEST_ENVIRONMENT']
+        data_file = "#{XL_PRIMARY_DATA_PATH}#{environment}_data.xls"
+        data_file = XL_PRIMARY_DATA_FILE unless ExcelData.rowspec_exists?(data_file, sheet, row_spec)
+      else
+        data_file = XL_PRIMARY_DATA_FILE
+      end
+      data_file
+    end
+
+    def read_excel_row_data(sheet, row_name, parallel = false)
+      parallel == :parallel && ENV['PARALLEL'] ? row_spec = "#{row_name}#{ENV['TEST_ENV_NUMBER']}" : row_spec = row_name
+      ExcelData.read_row_data(pick_excel_data_source(sheet, row_spec), sheet, row_spec)
+    end
+
+    def read_excel_pool_data(sheet, row_name, parallel = false)
+      parallel == :parallel && ENV['PARALLEL'] ? row_spec = "#{row_name}#{ENV['TEST_ENV_NUMBER']}" : row_spec = row_name
+      ExcelData.read_row_from_pool(pick_excel_data_source(sheet, row_name), sheet, row_spec)
+    end
+
+    def read_excel_range_data(sheet, range_name)
+      ExcelData.read_range_data(pick_excel_data_source(sheet, range_name), sheet, range_name)
+    end
+  end
+end

data/lib/testcentricity/data_objects/environment.rb

@@ -0,0 +1,281 @@
+module TestCentricity
+  class EnvironData < TestCentricity::ExcelDataSource
+    attr_accessor	:current
+
+    WKS_ENVIRONS ||= 'Environments'
+
+    def find_environ(environ_name, source_type = :excel)
+      case source_type
+      when :excel
+        data = ExcelData.read_row_data(XL_PRIMARY_DATA_FILE, WKS_ENVIRONS, environ_name)
+      when :yaml
+        data = read_yaml_node_data('environments.yml', environ_name)
+      when :json
+        data = read_json_node_data('environments.json', environ_name)
+      end
+      @current = Environ.new(data)
+      Environ.current = @current
+    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')
+    @session_code
+    @test_environment = ENV['TEST_ENVIRONMENT']
+    @screen_shots = []
+
+    attr_accessor :test_environment
+    attr_accessor :browser
+    attr_accessor :browser_size
+    attr_accessor :session_state
+    attr_accessor :os
+    attr_accessor :device
+    attr_accessor :device_name
+    attr_accessor :device_type
+    attr_accessor :device_os
+    attr_accessor :device_orientation
+    attr_accessor :platform
+    attr_accessor :driver
+    attr_accessor :tunneling
+
+    attr_accessor :signed_in
+    attr_accessor :portal_status
+    attr_accessor :portal_context
+    attr_accessor :external_page
+
+    attr_accessor :default_max_wait_time
+
+    attr_accessor :protocol
+    attr_accessor :hostname
+    attr_accessor :base_url
+    attr_accessor :user_id
+    attr_accessor :password
+    attr_accessor :append
+    attr_accessor :option1
+    attr_accessor :option2
+    attr_accessor :dns
+    attr_accessor :db_username
+    attr_accessor :db_password
+    attr_accessor :ios_app_path
+    attr_accessor :ios_ipa_path
+    attr_accessor :android_apk_path
+
+    def initialize(data)
+      @protocol     	  = data['PROTOCOL']
+      @hostname         = data['HOST_NAME']
+      @base_url         = data['BASE_URL']
+      @user_id	        = data['USER_ID']
+      @password	        = data['PASSWORD']
+      @append	          = data['APPEND']
+      @option1	        = data['OPTIONAL_1']
+      @option2	        = data['OPTIONAL_2']
+      @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']
+      @android_apk_path = data['ANDROID_APK_PATH']
+      super
+    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.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
+
+      Capybara.default_max_wait_time = timeout if driver == :webdriver
+    end
+
+    def self.default_max_wait_time
+      @default_max_wait_time
+    end
+
+    def self.browser=(browser)
+      @browser = browser.downcase.to_sym
+    end
+
+    def self.browser
+      @browser
+    end
+
+    def self.browser_size=(size)
+      @browser_size = size
+    end
+
+    def self.browser_size
+      @browser_size
+    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)
+      @device_type = type.downcase.to_sym
+    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.is_ios?
+      @device_os == :ios
+    end
+
+    def self.is_android?
+      @device_os == :android
+    end
+
+    def self.device_orientation=(orientation)
+      @device_orientation = orientation.downcase.to_sym
+    end
+
+    def self.device_orientation
+      @device_orientation
+    end
+
+    def self.driver=(type)
+      @driver = type
+    end
+
+    def self.driver
+      @driver
+    end
+
+    def self.tunneling=(state)
+      @tunneling = state
+    end
+
+    def self.tunneling
+      @tunneling
+    end
+
+    def self.platform=(platform)
+      @platform = platform
+    end
+
+    def self.is_mobile?
+      @platform == :mobile
+    end
+
+    def self.is_desktop?
+      @platform == :desktop
+    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.external_page
+      @external_page
+    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
+  end
+end

data/lib/testcentricity/data_objects/excel_helper.rb

@@ -0,0 +1,242 @@
+require 'time'
+require 'chronic'
+require 'faker'
+require 'spreadsheet'
+
+
+module TestCentricity
+  class ExcelData
+    @mru = {}
+
+    def self.worksheet_exists?(file, sheet)
+      exists = false
+      if File.exist?(file)
+        work_book  = Spreadsheet.open file
+        worksheets = work_book.worksheets
+        worksheets.each do |worksheet|
+          if worksheet.name == sheet
+            exists = true
+            break
+          end
+        end
+      end
+      exists
+    end
+
+    def self.rowspec_exists?(file, sheet, rowspec)
+      exists = false
+      if worksheet_exists?(file, sheet)
+        work_book  = Spreadsheet.open file
+        work_sheet = work_book.worksheet sheet
+        # get column headings from row 0 of worksheet
+        headings = work_sheet.row(0)
+        # if rowspec is a string then we have to find a matching row name
+        if rowspec.is_a? String
+          column_number = 0
+          exists = false
+          headings.each do |heading|
+            if heading == 'ROW_NAME'
+              exists = true
+              break
+            end
+            column_number += 1
+          end
+          raise "Could not find a column named ROW_NAME in worksheet #{sheet}" unless exists
+          # find first cell in ROW_NAME column containing a string that matches the rowspec parameter
+          exists = false
+          row_number = 0
+          work_sheet.each do |row|
+            if row[column_number] == rowspec
+              exists = true
+              break
+            end
+            row_number += 1
+          end
+        end
+      end
+      exists
+    end
+
+    def self.read_row_from_pool(file, sheet, rowspec, columns = nil)
+      raise "File #{file} does not exists" unless File.exist?(file)
+      work_book  = Spreadsheet.open file
+      work_sheet = work_book.worksheet sheet
+
+      pool_spec_key = "#{sheet}:#{rowspec}"
+      if @mru.key?(pool_spec_key)
+        pool_spec = @mru[pool_spec_key]
+        row_start = pool_spec[:start_row]
+        row_end   = pool_spec[:num_rows]
+        pool_rows = (row_start..row_start + row_end - 1).to_a
+        mru_rows  = pool_spec[:used_rows]
+        new_row   = pool_rows.sample.to_i
+        if mru_rows.size == pool_spec[:num_rows]
+          mru_rows = [new_row]
+        else
+          while mru_rows.include?(new_row)
+            new_row = pool_rows.sample.to_i
+          end
+          mru_rows.push(new_row)
+          mru_rows.sort!
+        end
+
+        pool_spec = {
+            :start_row => row_start,
+            :num_rows  => row_end,
+            :used_rows => mru_rows
+        }
+      else
+        # get column headings from row 0 of worksheet
+        headings      = work_sheet.row(0)
+        column_number = 0
+        found         = false
+        headings.each do |heading|
+          if heading == 'ROW_NAME'
+            found = true
+            break
+          end
+          column_number += 1
+        end
+        raise "Could not find a column named ROW_NAME in worksheet #{sheet}" unless found
+        # find cell(s) in ROW_NAME column containing a string that matches the rowspec parameter
+        found      = []
+        row_number = 0
+        work_sheet.each do |row|
+          if row[column_number] == rowspec
+            found.push(row_number)
+          elsif !found.empty?
+            break
+          end
+          row_number += 1
+        end
+        raise "Could not find a row named '#{rowspec}' in worksheet #{sheet}" if found.empty?
+
+        new_row   = found.sample.to_i
+        pool_spec = {
+            :start_row => found[0],
+            :num_rows  => found.size,
+            :used_rows => [new_row]
+        }
+      end
+      @mru[pool_spec_key] = pool_spec
+
+      read_row_data(file, sheet, new_row, columns)
+    end
+
+    def self.read_row_data(file, sheet, rowspec, columns = nil)
+      raise "File #{file} does not exists" unless File.exist?(file)
+      work_book  = Spreadsheet.open file
+      work_sheet = work_book.worksheet sheet
+      # get column headings from row 0 of worksheet
+      headings = work_sheet.row(0)
+      # if rowspec is a string then we have to find a matching row name
+      if rowspec.is_a? String
+        column_number = 0
+        found = false
+        headings.each do |heading|
+          if heading == 'ROW_NAME'
+            found = true
+            break
+          end
+          column_number += 1
+        end
+        raise "Could not find a column named ROW_NAME in worksheet #{sheet}" unless found
+        # find first cell in ROW_NAME column containing a string that matches the rowspec parameter
+        found = false
+        row_number = 0
+        work_sheet.each do |row|
+          if row[column_number] == rowspec
+            found = true
+            break
+          end
+          row_number += 1
+        end
+        raise "Could not find a row named '#{rowspec}' in worksheet #{sheet}" unless found
+        data = work_sheet.row(row_number)
+        # if rowspec is a number then ensure that it doesn't exceed the number of available rows
+      elsif rowspec.is_a? Numeric
+        raise "Row # #{rowspec} is greater than number of rows in worksheet #{sheet}" if rowspec > work_sheet.last_row_index
+        data = work_sheet.row(rowspec)
+      end
+
+      # if no columns have been specified, return all columns
+      columns = headings if columns.nil?
+      # create results hash table
+      result = Hash.new
+      columns.each do |column|
+        column_number = 0
+        found = false
+        headings.each do |heading|
+          if column == heading
+            value = data[column_number].to_s
+            value = calculate_dynamic_value(value) if value.start_with? 'eval!'
+            result[column] = value
+            found = true
+            break
+          end
+          column_number += 1
+        end
+        raise "Could not find a column named '#{column}' in worksheet #{sheet}" unless found
+      end
+      result
+    end
+
+    def self.read_range_data(file, sheet, rangespec)
+      raise "File #{file} does not exists" unless File.exist?(file)
+      work_book  = Spreadsheet.open file
+      work_sheet = work_book.worksheet sheet
+      # get column headings from row 0 of worksheet
+      headings = work_sheet.row(0)
+      column_number = 0
+      found = false
+      headings.each do |heading|
+        if heading == 'ROW_NAME'
+          found = true
+          break
+        end
+        column_number += 1
+      end
+      raise "Could not find a column named ROW_NAME in worksheet #{sheet}" unless found
+      # find cell(s) in ROW_NAME column containing a string that matches the rangespec parameter
+      found      = []
+      row_number = 0
+      work_sheet.each do |row|
+        if row[column_number] == rangespec
+          found.push(row_number)
+        elsif !found.empty?
+          break
+        end
+        row_number += 1
+      end
+      raise "Could not find a row named '#{rangespec}' in worksheet #{sheet}" if found.empty?
+
+      result = []
+      found.each do |row|
+        result.push(read_row_data(file, sheet, row))
+      end
+      result
+    end
+
+    private
+
+    def self.calculate_dynamic_value(value)
+      test_value = value.split('!', 2)
+      parameter = test_value[1].split('.', 2)
+      case parameter[0]
+      when 'Date'
+        result = eval("Chronic.parse('#{parameter[1]}')")
+      when 'FormattedDate', 'FormatDate'
+        date_time_params = parameter[1].split(' format! ', 2)
+        date_time = eval("Chronic.parse('#{date_time_params[0].strip}')")
+        result = date_time.to_s.format_date_time("#{date_time_params[1].strip}")
+      else
+        if Faker.constants.include?(parameter[0].to_sym)
+          result = eval("Faker::#{parameter[0]}.#{parameter[1]}")
+        else
+          result = eval(test_value[1])
+        end
+      end
+      result.to_s
+    end
+  end
+end