watirmark 5.14.16

data/lib/watirmark/screenshot.rb

@@ -0,0 +1,127 @@
+require 'watirmark/configuration'
+Watirmark::Configuration.instance.defaults = {:create_master_snapshots => false}
+
+module Watirmark
+  module Screenshot
+
+    class << self
+      def take
+        CurrentScreenShots.new
+      end
+
+      def compare_screenshots(masters, currents)
+        raise ArgumentError, "Passed invalid arguments to compare_screenshots" unless masters.kind_of?(MasterAlbum) && currents.kind_of?(CurrentScreenShots)
+
+        if Watirmark::Configuration.instance.snapshotwidth.kind_of?(Fixnum)
+          compare_specific_screenshot_size(currents, masters)
+        else
+          compare_standard_screenshot_sizes(currents, masters)
+        end
+      end
+
+      def compare_specific_screenshot_size(currents, masters)
+         unless currents.screenshots.md5 == masters.album.md5
+           report_failure(currents.screenshots.filename, masters.album.filename)
+         end
+      end
+
+      def compare_standard_screenshot_sizes(currents, masters)
+        masters.album.each_with_index do |master, index|
+          unless currents.screenshots[index].md5  == master.md5
+            report_failure(currents.screenshots[index].filename, masters.filename)
+          end
+        end
+      end
+
+      def report_failure(current, master)
+        Watirmark.logger.info "Checking Snapshot:\n   master: #{master}\n   screenshot: #{current}"
+        raise ArgumentError, "Master snapshot: #{File.expand_path(master)} does not match current snapshot: #{File.expand_path(current)}"
+      end
+    end
+
+    class CurrentScreenShots
+      attr_accessor :screenshots
+
+      def initialize
+        if Watirmark::Configuration.instance.snapshotwidth.kind_of?(Fixnum)
+          @screenshots = Current.new
+        else
+          widths = Watirmark::Configuration.instance.snapshotwidth.split(",").map {|s| s.to_i}
+          @screenshots = []
+          widths.each {|width| @screenshots << Current.new(width) }
+        end
+      end
+    end
+
+    class MasterAlbum
+      attr_accessor :album
+
+      def initialize(filename, screenshot)
+        if Watirmark::Configuration.instance.snapshotwidth.kind_of?(Fixnum)
+          @album = Master.new(filename, screenshot.screenshots)
+        else
+          widths = Watirmark::Configuration.instance.snapshotwidth.split(",").map {|s| s.to_i}
+          @album = []
+          widths.each_with_index do |width, index|
+            @album << Master.new(filename.sub(/\.png/, "_width_#{width}.png"), screenshot.screenshots[index])
+          end
+        end
+      end
+    end
+
+    class Current
+      attr_accessor :filename, :screenwidth, :screenheight
+
+      def initialize(snapshotwidth=Watirmark::Configuration.instance.snapshotwidth)
+        get_screen_size
+        FileUtils.mkdir_p('reports/screenshots')
+        take_screen_shot(snapshotwidth)
+        revert_window_size
+      end
+
+      def take_screen_shot(snapshotwidth)
+        update_window_size(snapshotwidth)
+        @filename = "reports/screenshots/#{UUID.new.generate(:compact)}.png"
+        focus_browser
+        Page.browser.screenshot.save @filename
+      end
+
+      def md5
+        Digest::MD5.hexdigest(File.read(@filename))
+      end
+
+      def update_window_size(width)
+        Page.browser.window.resize_to(width, Watirmark::Configuration.instance.snapshotheight)
+      end
+
+      def get_screen_size
+        size = Page.browser.window.size
+        @screenwidth = size.width
+        @screenheight = size.height
+      end
+
+      def revert_window_size
+        Page.browser.window.resize_to(@screenwidth, @screenheight)
+      end
+
+      def focus_browser
+        Page.browser.element.click
+      end
+    end
+
+    class Master < Current
+      def initialize(filename, screenshot)
+        @filename = filename
+        update(screenshot) if Watirmark::Configuration.instance.create_master_snapshots
+      end
+
+      def update(screenshot)
+        FileUtils.mkdir_p(File.dirname(@filename))
+        File.unlink(@filename) if File.exists?(@filename)
+        FileUtils.copy_file(screenshot.filename, @filename)
+        Watirmark.logger.info "Created new master: #@filename"
+      end
+    end
+  end
+end
+

data/lib/watirmark/session.rb

@@ -0,0 +1,115 @@
+module Watirmark
+
+  # This functionality allows us to ignore and buffer
+  # post failures and then compare on a cucumber step
+  module CucumberPostFailureBuffering
+    @@buffer_post_failure = false
+
+    def post_failure
+      @@post_failure
+    end
+
+    def post_failure=(x)
+      @@post_failure = x
+    end
+
+    def buffer_post_failure
+      @@buffer_post_failure
+    end
+
+    def catch_post_failures(&block)
+      @@post_failure = nil
+      @@buffer_post_failure = true
+      block.call
+      @@buffer_post_failure = false
+      @@post_failure
+    end
+  end
+
+  class Session
+    include Singleton
+    include CucumberPostFailureBuffering
+
+    POST_WAIT_CHECKERS = []
+
+    def browser
+      Page.browser
+    end
+
+    def browser=(x)
+      Page.browser = x
+    end
+
+    def config
+      Watirmark::Configuration.instance
+    end
+
+    # set up the global variables, reading from the config file
+    def initialize
+      Watirmark.add_exit_task {
+        closebrowser if config.closebrowseronexit
+      }
+      config.firefox_profile = default_firefox_profile if config.webdriver.to_s == 'firefox'
+    end
+
+    def default_firefox_profile
+      if Configuration.instance.default_firefox_profile
+        Watirmark.logger.info "Using firefox profile: #{Configuration.instance.default_firefox_profile}"
+        profile = Selenium::WebDriver::Firefox::Profile.from_name Configuration.instance.default_firefox_profile
+      else
+        profile = Selenium::WebDriver::Firefox::Profile.new
+      end
+      profile.native_events = false
+      if Configuration.instance.projectpath
+        download_directory = File.join(Configuration.instance.projectpath, "reports", "downloads")
+        download_directory.gsub!("/", "\\") if Selenium::WebDriver::Platform.windows?
+        profile['browser.download.folderList'] = 2 # custom location
+        profile['browser.download.dir'] = download_directory
+        profile['browser.helperApps.neverAsk.saveToDisk'] = "text/csv,application/pdf"
+      end
+      profile
+    end
+
+    def newsession
+      closebrowser
+      openbrowser
+    end
+
+    def openbrowser
+      Page.browser = new_watir_browser
+      initialize_page_checkers
+      initialize_screenshots
+      Page.browser
+    end
+
+    def closebrowser
+      begin
+        Page.browser.close
+      rescue Errno::ECONNREFUSED
+        # browser already closed or unavailable
+      ensure
+        Page.browser = nil
+      end
+    end
+
+    private
+
+    def new_watir_browser
+      config.webdriver ||= :firefox
+      if config.webdriver.to_sym == :firefox
+        Watir::Browser.new config.webdriver.to_sym, :profile => config.firefox_profile
+      else
+        Watir::Browser.new config.webdriver.to_sym
+      end
+    end
+
+    def initialize_screenshots
+      Page.browser.screenshot.base64
+    end
+
+    def initialize_page_checkers
+      POST_WAIT_CHECKERS.each { |p| Page.browser.add_checker p }
+    end
+
+  end
+end

data/lib/watirmark/version.rb

@@ -0,0 +1,5 @@
+module Watirmark
+  module Version
+    STRING = '5.14.16'
+  end
+end

data/spec/assertions_spec.rb

@@ -0,0 +1,95 @@
+require_relative 'spec_helper'
+
+describe Watirmark::Assertions do
+  include Watirmark::Assertions
+  
+  it 'can compare simple elements' do
+    element = stub(:exists? => true, :value => 'giant vampire squid', :radio_map => nil)
+    assert_equal element, 'giant vampire squid'
+  end
+  
+  it 'compare integer' do
+    element = stub(:exists? => true, :value => '100')
+    assert_equal element, 100
+  end
+
+  it 'compare string integer' do
+    element = stub(:exists? => true, :value => '100')
+    assert_equal element, '100'
+  end
+
+  it 'expecting value with with percent' do
+    element = stub(:exists? => true, :value => '100%')
+    assert_equal element, '100%'
+  end
+
+  it 'expecting value with with a currency symbol' do
+    element = stub(:exists? => true, :value => '$123.45')
+    assert_equal element, '$123.45'
+  end
+
+  it 'expecting integer value should strip the dollar sign' do
+    element = stub(:exists? => true, :value => '$25')
+    assert_equal element, '25'
+    assert_equal element, '$25'
+    lambda { assert_equal element, '25%' }.should raise_error
+  end
+
+  it 'symbol in wrong place needs to match exactly or fail' do
+    element = stub(:exists? => true, :value => '25$')
+    lambda { assert_equal element, '$25' }.should raise_error
+    assert_equal element, '25$'
+
+    element = stub(:exists? => true, :value => '%50')
+    lambda { assert_equal element, '50%' }.should raise_error
+    lambda { assert_equal element, '50' }.should raise_error
+    assert_equal element, '%50'
+  end
+
+  it 'should detect two different numbers are different' do
+    element = stub(:exists? => true, :value => '50')
+    lambda { assert_equal element, '51' }.should raise_error
+    lambda { assert_equal element, '50.1' }.should raise_error
+    lambda { assert_equal element, 49.9 }.should raise_error
+    lambda { assert_equal element, 49 }.should raise_error
+    assert_equal element, 50.0
+  end
+
+  it 'should let a number match a number with a $ before or % after' do
+    element = stub(:exists? => true, :value => '$26', :name => 'unittest')
+    assert_equal element, 26
+    element = stub(:exists? => true, :value => '27%', :name => 'unittest')
+    assert_equal element, 27.00
+  end
+
+  it 'should let a number in a string match a number with currency or percent' do
+    element = stub(:exists? => true, :value => '$36', :name => 'unittest')
+    assert_equal element, '36'
+    element = stub(:exists? => true, :value => '37%', :name => 'unittest')
+    assert_equal element, '37.00'
+  end
+
+end
+
+describe "normalize_values" do
+  include Watirmark::Assertions
+
+  specify 'normalize dates' do
+    normalize_value("1/1/2012").should == Date.parse('1/1/2012')
+    normalize_value("1/1/09").should == Date.parse('1/1/09')
+    normalize_value("01/1/09").should == Date.parse('1/1/09')
+    normalize_value("01/01/09").should == Date.parse('1/1/09')
+  end
+  specify 'normalize whitespace' do
+    normalize_value(" a").should == "a"
+    normalize_value("a ").should == "a"
+    normalize_value("a\n").should == "a"
+    normalize_value("\na").should == "a"
+    normalize_value(" a \nb").should == "a \nb"
+    normalize_value(" a \r\nb").should == "a \nb"
+    normalize_value(" a \nb\n").should == "a \nb"
+  end
+  specify 'do not normalize string of spaces' do
+    normalize_value('     ').should == '     '
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,82 @@
+require_relative 'spec_helper'
+
+shared_examples_for "configuration_file" do
+  specify 'string' do
+    @config.string.should == "foo"
+  end
+
+  specify 'true_boolean' do
+    @config.true_boolean.should be_true
+  end
+
+  specify 'false_boolean' do
+    @config.false_boolean.should be_false
+  end
+
+  specify 'symbol' do
+    @config.symbol.should == :foo
+  end
+
+  specify 'integer' do
+    @config.integer.should == 3
+  end
+
+  specify 'float' do
+    @config.float.should == 1.2
+  end
+end
+
+describe "text file" do
+ it_behaves_like  "configuration_file"
+
+  before :all do
+    @config = Watirmark::Configuration.instance
+    @config.reset
+    @config.configfile = File.dirname(__FILE__) + '/configurations/config.txt'
+    @config.read_from_file
+  end
+end
+
+describe "yaml file" do
+  it_behaves_like  "configuration_file"
+
+  before :all do
+    @config = Watirmark::Configuration.instance
+    @config.reset
+    @config.configfile = File.dirname(__FILE__) + '/configurations/config.yml'
+    @config.read_from_file
+  end
+end
+
+describe "configuration" do
+  before :all do
+    @config = Watirmark::Configuration.instance
+    @config.reset
+    @config.reload
+  end
+
+  specify 'add defaults' do
+    @config.email.should == 'devnull'
+    @config.webdriver.should == 'firefox'
+    @config.defaults = {:email => 'email-changed'}
+    @config.email.should == 'email-changed'
+    @config.webdriver.should == 'firefox'
+  end
+
+  specify 'inspect' do
+    @config.inspect.should =~ /^{.+}/
+  end
+  
+  specify 'override how a setting is set' do
+    module Watirmark
+      class Configuration
+        def hostname_value(hostname)
+          hostname + '/test'
+        end
+      end
+    end
+    Watirmark::Configuration.instance.hostname = 'www.convio.com'
+    Watirmark::Configuration.instance.hostname.should == 'www.convio.com/test'
+  end
+
+end

data/spec/controller_actions_spec.rb

@@ -0,0 +1,91 @@
+require_relative 'spec_helper'
+
+describe Watirmark::Actions do
+  before :all do
+    class ActionView < Page
+      private_keyword(:a)
+      private_keyword(:b)
+    end
+
+    class ActionController < Watirmark::WebPage::Controller
+      @view = ActionView
+
+      def create
+      end
+
+      def edit
+      end
+
+      def before_all
+      end
+
+      def before_each
+      end
+
+      def after_each
+      end
+
+      def after_all
+      end
+    end
+
+    class ActionModel < Watirmark::Model::Factory
+      keywords :a, :b
+      defaults do
+        a {1}
+        b {2}
+      end
+    end
+  end
+
+  before :each do
+    @controller = ActionController.new(ActionModel.new)
+  end
+
+  it 'before and after' do
+    @controller.expects(:before_all).once
+    @controller.expects(:after_all).once
+    @controller.run :create
+  end
+
+  it 'before_each and after_each' do
+    @controller.expects(:before_each).once
+    @controller.expects(:after_each).once
+    @controller.run :create
+  end
+
+  it 'before_each and after_each with multiple methods passed to run' do
+    @controller.expects(:before_each).twice
+    @controller.expects(:after_each).twice
+    @controller.run :create, :edit
+  end
+
+  it 'use hashes instead of models' do
+    controller = ActionController.new(a: 1, b: 2)
+    controller.expects(:before_each).once
+    controller.expects(:after_each).once
+    controller.run :create
+  end
+
+  it 'records should be processed separately' do
+    controller = ActionController.new
+    controller.records << {a:1, b:2}
+    controller.records << {c:3, d:4}
+    controller.expects(:before_all).once
+    controller.expects(:after_all).once
+    controller.expects(:before_each).twice
+    controller.expects(:after_each).twice
+    controller.run :create
+  end
+
+  it 'records should be cleared after run' do
+    controller = ActionController.new
+    controller.records.should == []
+    controller.records << {a:1, b:2}
+    controller.records << {c:3, d:4}
+    controller.records.should == [{a:1, b:2}, {c:3, d:4}]
+    controller.run :create
+    controller.records.should == []
+  end
+
+end