watirmark 5.14.16

data/lib/watirmark/controller/actions.rb

@@ -0,0 +1,172 @@
+module Watirmark
+  module Actions
+
+    attr_accessor :records
+
+    def run(*actions)
+      begin
+        run_callback_method :before_all
+        record_list.each do |record|
+          create_model_if_hash(record)
+          execute_actions(actions)
+        end
+        run_callback_method :after_all
+      ensure
+        clear_record_list
+      end
+    end
+
+    def search_for_record
+      if @search
+        search_controller = @search.new(@supermodel)
+        if search_controller.respond_to?(:current_record_visible?)
+          return if search_controller.current_record_visible?
+        end
+        search_controller.create
+      end
+    end
+
+    # Navigate to the View's edit page and for every value in
+    # the models hash, verify that the html element has
+    # the proper value for each keyword
+    def verify
+      search_for_record
+      @view.edit @model
+      verify_data
+    end
+
+    # Navigate to the View's edit page and
+    # verify all values in the models hash
+    def edit
+      search_for_record
+      @view.edit @model
+      populate_data
+    end
+
+    # Navigate to the View's create page and
+    # populate with values from the models hash
+    def create
+      @view.create @model
+      populate_data
+    end
+
+    def verify_until(&block)
+      run_with_stop_condition(:verify, block)
+    end
+
+    def edit_until(&block)
+      run_with_stop_condition(:edit, block)
+    end
+
+    def create_until(&block)
+      run_with_stop_condition(:create, block)
+    end
+
+    # Navigate to the View's create page and
+    # populate with values from the models hash
+    def get
+      unless @view.exists? @model
+        @view.create @model
+        populate_data
+      end
+    end
+
+    def delete
+      @view.delete @model
+    end
+
+    def copy
+      @view.copy @model
+    end
+
+    def restore
+      @view.restore @model
+    end
+
+    def archive
+      @view.archive @model
+    end
+
+    def publish
+      @view.publish @model
+    end
+
+    def unpublish
+      @view.unpublish @model
+    end
+
+    def activate
+      @view.activate @model
+    end
+
+    def deactivate
+      @view.deactivate @model
+    end
+
+    def locate_record
+      @view.locate_record @model
+    end
+
+    # Navigate to the View's create page and verify
+    # against the models hash. This is useful for making
+    # sure that the create page has the proper default
+    # values and contains the proper elements
+    def check_defaults
+      @view.create @model
+      verify_data
+    end
+    alias :check_create_defaults :check_defaults
+
+
+    # A helper function for translating a string into a
+    # pattern match for the beginning of a string
+    def starts_with(x)
+      /^#{Regexp.escape(x)}/
+    end
+
+    # Stubs so converted XLS->RSPEC files don't fail
+    def before_all; end
+    def before_each; end
+    def after_all; end
+    def after_each; end
+
+    private
+
+    def run_with_stop_condition(method, block)
+      catch :stop_condition_met do
+        begin
+          Watirmark::Session.instance.stop_condition_block = block
+          send(method)
+        ensure
+          Watirmark::Session.instance.stop_condition_block = Proc.new{}
+        end
+        raise Watirmark::TestError, "Expected a stop condition but no stop conditon met!"
+      end
+    end
+
+    def record_list
+      @records << @model if records.empty?
+      @records
+    end
+
+    def clear_record_list
+      @records = []
+    end
+
+    def run_callback_method name
+      send name if respond_to?(name)
+    end
+
+    def execute_actions(actions)
+      actions.each do |action|
+        run_callback_method :before_each
+        send(action)
+        run_callback_method :after_each
+      end
+    end
+
+    def create_model_if_hash(model)
+      @model = hash_to_model(model) if model.kind_of?(Hash)
+    end
+  end
+end

data/lib/watirmark/controller/assertions.rb

@@ -0,0 +1,116 @@
+module Watirmark
+  module Assertions
+
+    private
+
+    def assert_equal(element, expected)
+      return if expected.nil?
+      
+      element.extend KeywordMethods
+      if map = element.radio_map
+        expected = map.lookup(expected)
+      end
+
+      actual = actual_value element, expected
+      compare_values(element, expected, actual)
+    end
+
+    # Returns the user visible value of the element.
+    def actual_value element, expected=nil
+      case element
+        when Watir::Select
+          element.selected_options.first.text
+        when Watir::CheckBox
+          element.set?
+        when Watir::Radio
+          if element.set?(expected)
+            expected
+          else
+            element.value
+          end
+        when Watir::TextField
+          element.value
+        else
+          if element.respond_to?(:value) && element.value != ''
+            element.value
+          else
+            element.text
+          end
+      end
+    end
+    
+    def assert(result)
+      unless result
+        raise Watirmark::VerificationException, "Expected true got #{result}"
+      end
+    end
+    
+    def compare_values(element, expected, actual)
+      if Matcher.exists?(expected)
+        fail(element, expected, actual) unless Matcher.matches?(element, expected, actual)
+      else
+        fail(element, expected, actual) unless matches?(expected, actual)
+      end
+    end
+
+    def fail(element, expected, actual)
+      error = Watirmark::VerificationException.new(error_message(element, expected, actual))
+      error.actual = actual
+      error.expected = expected
+      raise error
+    end
+
+    def error_message(element, expected, actual)
+      kwd = element.keyword if element.respond_to?(:keyword)
+      message = "#{ kwd || element.class}: expected '#{expected.to_s}' (#{expected.class})"
+      message += " got '#{actual.to_s}' (#{actual.class})"
+    end
+
+    def is_number?(object)
+      true if Float(object) rescue false
+    end
+
+    def matches?(expected, actual)
+      expected = expected.to_f if is_number?(expected)
+      case expected
+        when Regexp
+          should_match_regexp(expected, actual)
+        when Float, Fixnum, Bignum, Integer, Rational
+          should_match_number(expected, actual)
+        else
+          if normalize_value(expected.to_s) == normalize_value(actual.to_s)
+            true
+          else
+            false
+          end
+      end
+    end
+
+    def normalize_value(x)
+      result = x.dup
+      if result.strip != ''
+        result.gsub!("\r\n","\n")
+        result.strip!
+      end
+
+      # handle dates
+      if result =~ /^[0-9]{1,2}[-\/][0-9]{1,2}[-\/][0-9]{2,4}$/ || result =~ /^[0-9]{2,4}[-\/][0-9]{1,2}[-\/][0-9]{1,2}$/ # translate dates to a Date object
+        result = Date.parse(result)
+      end
+
+      # strip sign from dollar amounts
+      if result =~ /^\$([\d\.]+)/
+        result = $1
+      end
+      result
+    end
+
+    def should_match_regexp(expected, actual)
+      expected.matches(actual.to_s)
+    end
+
+    def should_match_number(expected, actual)
+      expected == actual.to_s.gsub(/[,$]/,'').to_f
+    end
+  end
+end

data/lib/watirmark/controller/controller.rb

@@ -0,0 +1,191 @@
+require 'watirmark/controller/actions'
+require 'watirmark/controller/dialogs'
+require 'watirmark/controller/assertions'
+require 'watirmark/controller/matcher'
+
+module Watirmark
+  module WebPage
+
+    class Controller
+      attr_reader :model, :supermodel
+      include Watirmark::Assertions
+      include Watirmark::Dialogs
+      include Watirmark::Actions
+
+      class << self
+        attr_accessor :view, :model, :search
+
+        def inherited(klass)
+          klass.view ||= @view if @view
+          klass.model ||= @model if @model
+          klass.search ||= @search if @search
+        end
+      end
+
+      def initialize(data = {})
+        initialize_model(data)
+        @records ||= []
+        @cache = {}
+        @view = self.class.view.new browser if self.class.view
+        @search = self.class.search
+      end
+
+      def browser
+        Page.browser
+      end
+
+      def model=(data)
+        initialize_model(data)
+      end
+
+      def populate_data
+        submit_process_page(@last_process_page.underscored_name) {submit} if populate_values
+      end
+
+      def populate_values
+        @seen_value = false
+        @last_process_page = nil
+        keyed_elements.each do |k|
+          next unless k.populate_allowed?
+          submit_process_page_when_page_changes(k)
+          before_process_page(k)
+          populate_keyword(k)
+        end
+        @seen_value
+      end
+
+      def verify_data
+        @verification_errors = []
+        keyed_elements.each { |k| verify_keyword(k) if k.verify_allowed? }
+        raise Watirmark::VerificationException, @verification_errors.join("\n  ") unless @verification_errors.empty?
+      end
+
+    private
+
+      def initialize_model(x)
+        @supermodel = x
+        @model = locate_model @supermodel
+      end
+
+      def populate_keyword(keyed_element)
+        begin
+          @seen_value = true
+          before_keyword(keyed_element)
+          populate_keyword_value(keyed_element)
+          after_keyword(keyed_element)
+        rescue => e
+          Watirmark.logger.warn "Unable to populate '#{keyed_element.keyword}'"
+          raise e
+        end
+      end
+
+      def verify_keyword(keyed_element)
+        begin
+          verify_keyword_value(keyed_element)
+        rescue Watirmark::VerificationException => e
+          @verification_errors.push e.to_s
+        end
+      end
+
+      def submit_process_page_when_page_changes(keyed_element)
+        return unless process_page_changed?(keyed_element) && @seen_value
+        if @last_process_page
+          submit_process_page(@last_process_page.underscored_name) {@view.process_page(@last_process_page.name).submit}
+        else
+          @view.process_page(@view.to_s).submit
+        end
+        @seen_value = false
+      end
+
+      def call_method_if_exists(override, &block)
+        if respond_to?(override)
+          send(override)
+        else
+          block.call if block
+        end
+      end
+
+      def process_page_defined?(keyed_element)
+        !keyed_element.process_page.underscored_name.empty?
+      end
+
+      def process_page_changed?(keyed_element)
+        !!(@last_process_page && @last_process_page.underscored_name != keyed_element.process_page.underscored_name)
+      end
+
+      def before_keyword(keyed_element)
+        call_method_if_exists("before_#{keyed_element.keyword}")
+      end
+
+      def after_keyword(keyed_element)
+        call_method_if_exists("after_#{keyed_element.keyword}")
+      end
+
+      def populate_keyword_value(keyed_element)
+        call_method_if_exists("populate_#{keyed_element.keyword}") {@view.send("#{keyed_element.keyword}=", value(keyed_element))}
+      end
+
+      def verify_keyword_value(keyed_element)
+        call_method_if_exists("verify_#{keyed_element.keyword}") {assert_equal(keyed_element.get, value(keyed_element))}
+      end
+
+      def keyword_value(keyed_element)
+        call_method_if_exists("#{keyed_element.keyword}_value") {@model.send(keyed_element.keyword)}
+      end
+
+      def before_process_page(keyed_element)
+        if process_page_defined?(keyed_element) && (@last_process_page.nil? || process_page_changed?(keyed_element))
+          call_method_if_exists("before_process_page_#{keyed_element.process_page.underscored_name}")
+        end
+        @last_process_page = keyed_element.process_page
+      end
+
+      def submit_process_page(name, &block)
+        call_method_if_exists("submit_process_page_#{name}", &block)
+      end
+
+      def value(keyed_element)
+        @cache[keyed_element] ||= keyword_value(keyed_element)
+      end
+
+      def keyed_elements
+        @cache = {}
+        @view.keyed_elements.select{|e| !value(e).nil?}
+      end
+
+      def locate_model(supermodel)
+        case supermodel
+          when Hash
+            if self.class.model
+              self.class.model.new supermodel
+            else
+              hash_to_model supermodel
+            end
+          else
+            if self.class.model
+              if supermodel.model_type == self.class.model
+                supermodel
+              else
+                supermodel.find(self.class.model) || supermodel
+              end
+            else
+              supermodel
+            end
+        end
+      end
+
+      # This is for legacy tests that still pass in a hash. We
+      # convert these to models fo now
+      def hash_to_model(hash)
+        model = ModelOpenStruct.new
+        hash.each_pair { |key, value| model.send "#{key}=", value }
+        model
+      end
+
+      def submit
+        Watirmark.logger.warn "Unable to automatically post form. Please defined a submit method in your controller"
+      end
+    end
+
+  end
+end