watirmark 5.14.16

data/lib/watirmark/controller/dialogs.rb

@@ -0,0 +1,33 @@
+module Watirmark
+  module Dialogs
+    def modal_exists?
+      !!(Page.browser.windows.size > 1)
+    end
+
+    def with_modal_dialog(&block)
+      wait_for_modal_dialog
+      parent_window = (Page.browser.windows.size) - 2
+      begin
+        Page.browser.windows.last.use
+        Page.browser.wait
+        block.call
+      ensure
+        Page.browser.windows[parent_window].use
+      end
+    end
+
+    def wait_for_modal_dialog
+      begin
+        Timeout::timeout(30) {
+          until modal_exists?
+            sleep 0.002
+          end
+          Page.browser.wait
+          sleep 0.02
+        }
+      rescue Timeout::Error
+        raise Watirmark::TestError, 'Timed out while waiting for modal dialog to open'
+      end
+    end
+  end
+end

data/lib/watirmark/controller/matcher.rb

@@ -0,0 +1,19 @@
+module Watirmark
+  class Matcher
+    class << self
+      @@matchers = {}
+
+      def add_matcher(name, &block)
+        @@matchers[name] = block
+      end
+
+      def exists?(name)
+        @@matchers.has_key?(name)
+      end
+
+      def matches?(element, expected, actual)
+        instance_exec(element, actual, &@@matchers[expected])
+      end
+    end
+  end
+end

data/lib/watirmark/cucumber/cuke_helper.rb

@@ -0,0 +1,150 @@
+require_relative '../models/cucumber_helper'
+
+module CukeHelper
+  include Watirmark::Model::CucumberHelper
+
+  def log
+    Watirmark::Configuration.instance.logger
+  end
+
+  def eval_keywords(hash)
+    hash.each do |key, value|
+      hash[key] = format_value(value)
+    end
+    hash
+  end
+
+  # when the input is an array, eval each element
+  def eval_raw_record(row)
+    row.each_index do |col|
+      row[col] = format_value(row[col])
+    end
+    row
+  end
+
+  # calls the models method if of the pattern <name>.method
+  def call_model_methods(hash)
+    hash.each { |key, value| hash[key] = eval(value[1..value.length]) if value[0, 1].eql?("=") }
+    hash
+  end
+
+  # return {:foo=1, :bar=2} from {'foo' =>1, 'bar' =>2}
+  def colonize(hash)
+    newhash = {}
+    hash.each { |k, v| newhash[k.to_sym] = v }
+    newhash
+  end
+
+  # returns [{:foo=1, :bar=2}, {:foo=3, :bar=4}] list of hash records
+  # from table table where first row headers are keys and each row values
+  # | foo | bar |
+  # | 1   | 2   |
+  # | 3   | 4   |
+  def hash_record_list table
+    table.map_headers! { |h| h.to_sym }
+    records = table.hashes
+    records.map { |record| eval_keywords(record) }
+  end
+
+  # returns {:foo=1, :bar=2}  hash record
+  # from a key, value 2 column table
+  # | foo | 1 |
+  # | bar | 2 |
+  def hash_record table
+    colonize eval_keywords(table.rows_hash)
+  end
+
+  # returns .raw but still handles eval-ing the keywords
+  def raw_record table
+    table.raw.map { |record| eval_raw_record(record) }
+  end
+
+  #Given a list of keys or strings (call it key), return a string composed of
+  #record_hash[key] or the string is key isn't really a key.  Yea, screwy I know
+  def compose_string_from(record_hash, key_list)
+    result = ''
+    key_list.each do |key|
+      if record_hash[key]
+        result += record_hash[key]
+      elsif key.is_a? String
+        result += key
+      end
+    end
+    result
+  end
+
+# Allows expected values for a cucumber table field to be different
+# based on whether you are using Service Bus or DataSync. Use case is
+# for a bug in DataSync that was not replicated in Service Bus
+# In this example: DataSync incorrectly assigns 'Donation' and Service
+# Bus correctly assigns 'TeamRaiser Gift' to transaction type field
+#  # VERIFY ---------------+-------------------------------------------+
+#  | accountname           | Tr01_Hellraiser Eventdonor Household      |
+#  | type                  | Individual Gift                           |
+#  | transactiontype       | =syncmode('TeamRaiser Gift','Donation')   |
+  def syncmode(expected_bus, expected_datasync)
+    if ENV['SYNCMODE'] == 'DataSync'
+      expected_datasync
+    else
+      expected_bus
+    end
+  end
+
+# if a block provided raises VerificationException we verify again
+# this method acts as a gateway to prevent false negatives in testing CRM objects that we expect to change their values after being
+# updated by the service bus
+# motivation:
+# After serivce bus sends a message to a CRM it takes a while sometimes for the updates to the object to occur.
+# When we verify the state of the object we may still look at old values.
+# We want to introduce a pooling mechanism that would re-verify one or more times after a duration of time
+# and only fail after the specified count of tries.
+# usage:
+#   verify_failure { controller.verify } #=>  provide block that can fail with VerificationException
+  def verify_failure(tries_count=6, seconds_between_tries=30)
+    counter = 0
+    loop do
+      counter += 1
+      begin
+        yield
+      rescue Watirmark::VerificationException => e
+        Watirmark.logger.warn "*** reverifying failure: #{e}"
+        raise e if counter >= tries_count
+        sleep seconds_between_tries
+      else
+        break
+      end
+    end
+  end
+
+# given a hash and list of keys, make the values into a float if they exist
+# FIXME: this is a work around until the Cucumber tests use a new matcher
+# in convio_watir by making strings into floats
+#
+# record={:amountreceived => "10.00", :probability => "100"}
+# floatify(record, [:amountreceived, :probability])
+# changes record into
+# record={:amountreceived => 10.0, :probability => 100.0}
+  def floatify(record_hash, key_list)
+    key_list.each do |key|
+      record_hash[key] = record_hash[key].to_f if record_hash[key]
+    end
+    record_hash
+  end
+
+# merges sequentially a list of hashes
+  def multimerge *hashes
+    hashes.inject({}) { |memo, hash| hash.nil? ? memo : memo.merge(hash) }
+  end
+
+  def create_ts(with_separators=true)
+    if with_separators
+      Time.now.strftime "%Y:%m:%d:%H:%M:%S"
+    else
+      Time.now.strftime "%Y%m%d%H%M%S"
+    end
+  end
+
+end
+
+
+

data/lib/watirmark/cucumber/email_helper.rb

@@ -0,0 +1,103 @@
+module EmailHelper
+
+  # Access the list of emails we've read and cached
+  def emails
+    EmailCollection
+  end
+
+  # Parse the email body into an object
+  def email_body(body)
+    EmailBody.new(body)
+  end
+
+  class EmailCollection
+    class << self
+      def email
+        @email ||= {}
+      end
+
+      # Connect to the INBOX
+      def qa_inbox(model)
+        WatirmarkEmail::QAMail.new(email_address(model) )
+      end
+
+      # Return an email if we've seen it
+      def found_email(model)
+        email[model.model_name]
+      end
+
+      # Read the contents of an email, cache it and delete the email
+      def read_email(model, subject, timeout=30)
+        email_content = qa_inbox(model).get_email_text(["SUBJECT", subject, "TO", model.email], timeout)
+        email[model.model_name] = EmailBody.new(email_content)
+      end
+
+      def log_email(model)
+        Watirmark.logger.info "Email Received"
+        Watirmark.logger.info email[model.model_name].body.inspect
+      end
+
+      # Access a cached copy of an email
+      def [](model)
+        email[model.model_name]
+      end
+
+      # Remove our cached copy of the email
+      def delete(model)
+        email[model.model_name] = nil
+      end
+
+      # Format the email address so we're always referring to the qasendmail domain
+      def email_address(model)
+        model.email.gsub(/\+.+/,'').gsub(/@.+/, '@qasendmail.corp.convio.com')
+      end
+    end
+  end
+
+  class EmailLink
+    attr_accessor :href, :text
+
+    def initialize(doc)
+      @href = doc['href']
+      @text = doc.content
+    end
+  end
+
+  class EmailBody
+    attr_accessor :doc, :body
+
+    def initialize(body)
+      @body = body
+      @doc = ::Nokogiri::HTML.parse body
+    end
+
+    def links
+      unless @links
+        @links = []
+        @doc.xpath('//a').each do |link|
+          @links << EmailLink.new(link)
+        end
+      end
+      @links
+    end
+
+    def link(how, matcher)
+      links.each do |link|
+        case how
+          when :text
+            return link if /#{matcher}/.matches link.text
+          when :href
+            return link if /#{matcher}/.matches link.href
+        end
+      end
+      nil
+    end
+
+    def inspect
+      @doc.to_s
+    end
+
+  end
+end
+
+

data/lib/watirmark/cucumber/env.rb

@@ -0,0 +1,9 @@
+require 'watirmark/cucumber/cuke_helper'
+require 'watirmark/cucumber/email_helper'
+require 'watirmark/cucumber/model_helper'
+require 'watirmark/cucumber/transforms'
+require 'watirmark/cucumber/hooks'
+
+World CukeHelper
+World EmailHelper
+World ModelHelper

data/lib/watirmark/cucumber/hooks.rb

@@ -0,0 +1,16 @@
+Around('@catch-post-failure') do |scenario, block|
+  Watirmark::Session.instance.catch_post_failures(&block)
+end
+
+# Initialize post failures so we don't get leakage between scenarios
+Before('~@catch-post-failure') do
+  Watirmark::Session.instance.post_failure = nil
+end
+
+After do |scenario|
+  image = "#{Time.now.to_i}-#{UUID.new.generate(:compact)}.png"
+  path = "reports/screenshots"
+  FileUtils.mkdir_p path unless File.directory? path
+  Page.browser.screenshot.save "#{path}/#{image}"
+  embed "screenshots/#{image}", 'image/png'
+end

data/lib/watirmark/cucumber/model_helper.rb

@@ -0,0 +1,34 @@
+module ModelHelper
+  def add_model_debug_values(table)
+    table.raw.each do |row|
+      DebugModelValues[row[0]][row[1]] = row[2]
+    end
+  end
+
+  def update_model(model, table)
+    model.update(hash_record(table))
+  end
+
+  def with_updated_model(model, table, &block)
+    unless model.includes?(hash_record(table))
+      update_model(model, table)
+      block.call
+      Watirmark.logger.info "Updated models '#{model.model_name}':\n#{hash_record(table).inspect}"
+    end
+  end
+
+# Perform an action using a models and update
+# the models if that action is successful
+  def with_model(model, table, &block)
+    orig_model = model.clone
+    update_model(model, table)
+    block.call
+    if Watirmark::Session.instance.post_failure
+      Watirmark.logger.info  "Reverting Model #{Watirmark::Session.instance.post_failure}"
+      model.update(orig_model.to_h) # revert models on failure
+    elsif model.to_h != orig_model.to_h
+      Watirmark.logger.info "Updated model '#{model.model_name}' #{hash_record(table).inspect}"
+    end
+  end
+end
+

data/lib/watirmark/cucumber/transforms.rb

@@ -0,0 +1,55 @@
+# This is a globally accessible static hash to
+# store all models declared by the test automation. Making it available
+# allows us to use the models values as table parameters in the gherkin!
+DataModels = {}
+
+
+module Watirmark
+  module Transforms
+    class << self
+      def new_model model_name, user_defined_name
+        if model_exists?(user_defined_name) && !temporary_model?(user_defined_name)
+          DataModels[user_defined_name]
+        else
+          DataModels[user_defined_name] = model_class(model_name).new(:model_name => user_defined_name)
+        end
+      end
+
+      private
+
+      def model_exists?(name)
+        DataModels.key?(name)
+      end
+
+      def model_class(name)
+        model_class_name(name).split('::').inject(Kernel) {|context, x| context.const_get x}
+      end
+
+      def model_class_name(name)
+        "#{name.split.map(&:camelize).join}Model"
+      end
+
+      def temporary_model?(user_defined_name)
+        DataModels[user_defined_name].kind_of?(ModelOpenStruct)
+      end
+    end
+  end
+end
+
+# Create a new models and add it to the DataModels hash
+NEW_MODEL = Transform /^\[new (\S+) (\S+)\]$/ do |model_name, user_defined_name|
+  model_name.chop! if model_name.end_with?(':')
+  Watirmark::Transforms.new_model model_name, user_defined_name
+end
+
+OLD_STYLE_MODEL = Transform /^\[new ([^:]+): (\S+)\]$/ do |model_name, user_defined_name|
+  model_name = model_name.camelize
+  model_name.chop! if model_name.end_with?(':')
+  Watirmark::Transforms.new_model model_name, user_defined_name
+end
+
+# Return the models from the collection of existing models
+MODEL = Transform /^\[(\S+)\]$/ do |model_name|
+  DataModels[model_name] ||= ModelOpenStruct.new(:model_name => model_name)
+end
+

data/lib/watirmark/exceptions.rb

@@ -0,0 +1,15 @@
+module Watirmark
+  class Watirmark::MatcherNotFound < RuntimeError ;end
+  class Watirmark::TestError < RuntimeError ;end
+  class Watirmark::TestFailure < RuntimeError ;end
+  class Watirmark::PostFailure < RuntimeError ;end
+  class Watirmark::TDPage < RuntimeError; end
+  class Watirmark::SecurityIssue < RuntimeError; end
+  class Watirmark::WebPageElementNotFound < RuntimeError ;end
+  class Watirmark::ModelNotFound < RuntimeError ;end
+  class Watirmark::ModelCreationError < RuntimeError ;end
+  class Watirmark::InvalidConfigurationFile < RuntimeError ;end
+  class Watirmark::VerificationException < RuntimeError
+    attr_accessor :actual, :expected
+  end
+end