watirmark 5.27.2 → 5.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cd92d1a9b252f89b9bd5d392fd880321ea5eee0
-  data.tar.gz: 87d2a5c9088b3c8eaa7fe58fdc51618de4b56c19
+  metadata.gz: e78eaa4edbdd389f9e45df9a84d9c31cc6d67768
+  data.tar.gz: 8801907ff42e5266d2b5a7756fbe70ce780353eb
 SHA512:
-  metadata.gz: ffd2177cd8b04c599fb803f4ab52e611b85da37a3ac8c72547549d693475084b342c43c769eee7a3c3a449e9196bedea140d43765462400826333770c9d3ec2d
-  data.tar.gz: 9b45889cebcc93fb2c6f5124e9d191f152c6443e2e94ec32cd9b6b23c04aea862c9b3df5113aebff0296be548301d9ac1ce47c660657f62dab7a7068e036051e
+  metadata.gz: a3f23b508646544a92d9a9bc8df2aa7b1d4ad54d9c1795e526c2d2bb7b4a064f621f6628746bf210f58c5ccbe36eb11fe5f1315e312acd09d5367a41d1bac87c
+  data.tar.gz: e687c597de0e65e999969bd4f7bd862faa9487396a1a2133921a8c15d344308dc9e6f1c97a7c641411a77a040ac9c3a5549b6e2cb548aedf88ec9c843f14ed22

data/lib/watirmark/configuration.rb

@@ -23,6 +23,10 @@ module Watirmark
         :uuid               => nil,
         :webdriver          => :firefox,
         :headless           => false,
+        :always_locate      => true,
+        :prefer_css         => false,
+        :watir_timeout      => 30,
+        :http_timeout       => 60,
         # database
         :dbhostname         => nil,
         :dbusername         => nil,

data/lib/watirmark/controller/controller.rb

@@ -123,14 +123,16 @@ module Watirmark
 
       def populate_keyword_value(keyed_element)
         call_method_if_exists("populate_#{keyed_element.keyword}") do
-          # for the first element on a page we populate, wait for it to appear
-          @view.send(keyed_element.keyword).send(:wait_until_present) unless @seen_value
+          @view.send(keyed_element.keyword).wait_until_present unless @view.send(keyed_element.keyword).kind_of? Watir::Radio
           @view.send("#{keyed_element.keyword}=", value(keyed_element))
         end
       end
 
       def verify_keyword_value(keyed_element)
-        call_method_if_exists("verify_#{keyed_element.keyword}") {assert_equal(keyed_element.get, value(keyed_element))}
+        call_method_if_exists("verify_#{keyed_element.keyword}") do
+          keyed_element.get.wait_until_present
+          assert_equal(keyed_element.get, value(keyed_element))
+        end
       end
 
       def keyword_value(keyed_element)

data/lib/watirmark/controller/dialogs.rb

@@ -1,33 +1,32 @@
 module Watirmark
   module Dialogs
+
+    def current_window_index
+      current_window = Page.browser.window
+      Page.browser.windows.find_index(current_window)
+    end
+
     def modal_exists?
-      !!(Page.browser.windows.size > 1)
+      Page.browser.window(index: current_window_index+1).exists?
     end
 
-    def with_modal_dialog
+    def wait_for_modal_dialog
+      Watir::Wait.until { modal_exists? }
+    rescue TimeoutError
+      raise Watirmark::TestError, 'Timed out while waiting for modal dialog to open'
+    end
+
+    def with_modal_dialog &blk
       wait_for_modal_dialog
-      parent_window = (Page.browser.windows.size) - 2
-      begin
-        Page.browser.windows.last.use
-        Page.browser.wait
-        yield
-      ensure
-        Page.browser.windows[parent_window].use
-      end
+      Page.browser.windows.last.use &blk
     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
+    def close_chrome_windows
+      Page.browser.windows(url: /chrome-extension/).each {|win| win.close}
+    end
+
+    def close_modal_window
+      Page.browser.window(index: current_window_index+1).close if Page.browser.windows.size >= current_window_index
     end
   end
-end
+end

data/lib/watirmark/cucumber/cuke_helper.rb

@@ -8,10 +8,11 @@ module CukeHelper
   end
 
   def eval_keywords(hash)
+    newhash = {}
     hash.each do |key, value|
-      hash[key] = format_value(value)
+      newhash[key] = format_value(value)
     end
-    hash
+    newhash
   end
 
   # when the input is an array, eval each element

data/lib/watirmark/cucumber/email_helper.rb

@@ -27,20 +27,36 @@ module EmailHelper
       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)
+      def read_email(model, options_hash, timeout=30)
+        Kernel.raise ArgumentError, 'The options provided are not in the form of a hash, i.e. {:subject => "subject"}' unless options_hash.is_a?(Hash)
+        search_array = options_hash_to_array(options_hash)
+        email_content = qa_inbox(model).get_email_text(search_array, timeout)
         email[model.model_name] = EmailBody.new(email_content)
       end
 
+      def options_hash_to_array(hash_of_search_params)
+        converted_array = Array.new
+        hash_of_search_params.each do | search_key, search_value |
+          converted_array << search_key.to_s.upcase
+          converted_array << search_value.to_s
+        end
+        converted_array
+      end
+
       def read_email_from(model, from, timeout=30)
-        email_content = qa_inbox(model).get_email_text(["FROM", from, "TO", model.email], timeout)
-        email[model.model_name] = EmailBody.new(email_content)
+        Kernel.warn(self.to_s + ':>' + Kernel.__callee__.to_s + ': This method is deprecated, please use read_email')
+        read_email(model, {:from => from, :to => model.email}, timeout)
       end
 
       def read_email_replyto(model, from, timeout=30)
         qa_inbox(model).get_email_replyto(["FROM", from, "TO", model.email], timeout)
       end
 
+      def read_email_subject_and_from(model, from, subject, timeout=30)
+        Kernel.warn(self.to_s + ':>' + Kernel.__callee__.to_s + ': This method is deprecated, please use read_email')
+        read_email(model, {:from => from, :to => model.email, :subject => subject}, timeout)
+      end
+
       def log_email(model)
         Watirmark.logger.info "Email Received"
         Watirmark.logger.info email[model.model_name].body.inspect

data/lib/watirmark/extensions/webdriver_extensions.rb

@@ -1,38 +1,7 @@
 require 'watir-webdriver/extensions/select_text'
 
-Watir::always_locate = false
-
 module Watir
 
-  class Browser
-    # for modal dialogs that close on submission, these might
-    # fail to run because the window has been destroyed
-    alias :old_run_checkers :run_checkers
-
-    # this is basically a check to make sure we're not
-    # running the checkers on a modal dialog that has closed
-    # by the time the checkers have run
-    def run_checkers
-      @error_checkers.each do |checker|
-        begin
-          checker.call(self)
-        rescue Selenium::WebDriver::Error::UnknownError, Selenium::WebDriver::Error::NoSuchWindowError => e
-          Watirmark.logger.warn "Unable to run checker: #{e.message}"
-          break
-        end
-      end
-    end
-  end
-
-  # Trigger checkers when manually submitting a form
-  class Form < HTMLElement
-    alias :old_submit :submit
-    def submit
-      old_submit
-      browser.run_checkers
-    end
-  end
-
   module Container
     alias :row :tr
     alias :cell :td
@@ -79,6 +48,11 @@ module Watir
     end
   end
 
+  module Atoms
+    ATOMS[:getPreviousSibling] = File.read(File.expand_path("../atoms/getPreviousSibling.js", __FILE__))
+    ATOMS[:getNextSibling] = File.read(File.expand_path("../atoms/getNextSibling.js", __FILE__))
+  end
+
   class Table < HTMLElement
     def each
       rows.each { |x| yield x }
@@ -136,30 +110,85 @@ module Watir
   end
 
   class Element
-    begin
-      alias :prev_sibling :previous_sibling
-      alias :prevsibling :previous_sibling
-      alias :nextsibling :next_sibling
-    rescue NameError
-      # not using convio-specific webdriver. Ignore and continue
+
+    def next_sibling
+      e = locate_dom_element(:getNextSibling)
+      e.nil? ? element(xpath: './following-sibling::*') : e
+    end
+    alias_method :nextsibling, :next_sibling
+
+    def previous_sibling
+      e = locate_dom_element(:getPreviousSibling)
+      e.nil? ? element(xpath: './preceding-sibling::*') : e
+    end
+    alias_method :prev_sibling, :previous_sibling
+    alias_method :prevsibling, :previous_sibling
+
+    def locate_dom_element(method)
+      assert_exists
+
+      e = element_call { execute_atom method, @element }
+
+      if e.kind_of?(Selenium::WebDriver::Element)
+        Watir.element_class_for(e.tag_name.downcase).new(@parent, :element => e)
+      end
+    end
+
+    alias_method :old_element_call, :element_call
+    def element_call &block
+      old_element_call &block
+    rescue Selenium::WebDriver::Error::UnknownError => ex
+      raise unless ex.message.include?("Element is not clickable at point")
+      reset!
+      assert_exists
+      retry
+    end
+
+    alias_method :old_text, :text
+    def text
+      old_text.strip
     end
 
     def click_if_exists
       click if exists?
     end
 
-    alias :click_no_wait :click
+    alias_method :click_no_wait, :click
   end
 
   class TextFieldLocator
-    def validate_element(element)
+    def check_deprecation(element)
       if element.tag_name.downcase == 'textarea'
         warn "Locating textareas with '#text_field' is deprecated. Please, use '#textarea' method instead for #{@selector}"
       end
-      super
     end
   end
 
+  class IFrame < HTMLElement
+    alias_method :old_switch_to!, :switch_to!
+    def switch_to!
+      retry_attempts ||= 0
+      old_switch_to!
+    rescue Watir::Exception::UnknownFrameException
+      # UnknownFrameException is workaround for- https://code.google.com/p/chromedriver/issues/detail?id=948
+      retry_attempts += 1
+      retry if retry_attempts == 1
+    end
+  end
+
+  class Alert
+    alias_method :old_text, :text
+    def text
+      old_text.strip
+    end
+  end
+
+  class Browser
+    alias_method :old_text, :text
+    def text
+      old_text.strip
+    end
+  end
 
 end
 
@@ -182,4 +211,4 @@ module Selenium
       end
     end
   end
-end
+end

data/lib/watirmark/models/cucumber_helper.rb

@@ -24,7 +24,9 @@ module Watirmark
       end
 
       def insert_model(text)
-        return text unless text.class == String || text.class == Cucumber::Ast::DocString
+        # cucumber 2.0 defines a Core module between Cucumber and Ast
+        doc_class = Cucumber::Ast.const_defined?(:DocString) ? Cucumber::Ast::DocString : Cucumber::Core::Ast::DocString
+        return text unless text.is_a?(String) || text.is_a?(doc_class)
         result = text
         method_regexp = /\[([^\[\]]+)\]\.(\w+)/
         model_regexp = /\[([^\[\]]+)\]/

data/lib/watirmark/models/factory.rb

@@ -109,6 +109,7 @@ module Watirmark
         hash.each_pair { |key, value| send "#{key}=", value }
         self
       end
+      alias :has :update
 
 
       # Update the model using the provided hash but only if exists (TODO: may not be needed any more)

data/lib/watirmark/models/factory_methods.rb

@@ -47,7 +47,9 @@ module Watirmark
       end
 
       def keywords(*args)
-        @keys = [*args].flatten
+        @keys ||= []
+        @keys += [*args].flatten
+        @keys = @keys.uniq
       end
 
       private

data/lib/watirmark/page/keyed_element.rb

@@ -21,6 +21,7 @@ module Watirmark
     def get *args
       @process_page.activate
       watir_object = @context.instance_exec(*args, &@block)
+      return if watir_object.nil?
       watir_object.extend(KeywordMethods)
       watir_object.radio_map = @map if @map
       watir_object.keyword = @keyword
@@ -29,7 +30,6 @@ module Watirmark
 
     def set val
       return if val.nil?
-      @process_page.activate
       element = get
       val = @map.lookup(val) if @map
       case val

data/lib/watirmark/session.rb

@@ -117,6 +117,10 @@ module Watirmark
     end
 
     def openbrowser
+      Watir.default_timeout = config.watir_timeout
+      Watir.prefer_css = config.prefer_css
+      Watir.always_locate = config.always_locate
+
       use_headless_display if config.headless
       Page.browser = new_watir_browser
       initialize_page_checkers
@@ -162,15 +166,16 @@ module Watirmark
     end
 
     def new_watir_browser
-      config.webdriver ||= :firefox
-      if config.webdriver.to_sym == :firefox
-        Watir::Browser.new config.webdriver.to_sym, :profile => config.firefox_profile
-      elsif config.webdriver.to_sym == :firefox_proxy
-        Watir::Browser.new :firefox, :profile => config.firefox_profile
-      elsif config.webdriver.to_sym == :sauce
+      client = Selenium::WebDriver::Remote::Http::Default.new
+      client.timeout = config.http_timeout
+
+      case config.webdriver.to_sym
+      when :firefox, :firefox_proxy
+        Watir::Browser.new :firefox, profile: config.firefox_profile, http_client: client
+      when :sauce
         Watir::Browser.new use_sauce
       else
-        Watir::Browser.new config.webdriver.to_sym
+        Watir::Browser.new config.webdriver.to_sym, http_client: client
       end
     end
 

data/lib/watirmark/version.rb

@@ -1,5 +1,5 @@
 module Watirmark
   module Version
-    STRING = '5.27.2'
+    STRING = '5.28.0'
   end
 end

data/spec/controller_spec.rb

@@ -96,9 +96,8 @@ describe Watirmark::WebPage::Controller do
   end
 
   specify 'should be able to create and use a new keyword' do
-    view = TestView.new
-    view.send("#{@keyword}=", 'test')
-    expect(view.send(@keyword).value == 'test' ).to be_true
+    TestView.new.send("#{@keyword}=", 'test')
+    expect { @controller.send(@keyword).value == 'text' }.to be_true
   end
 
   specify 'should be able to populate' do

data/spec/helper_methods_spec.rb

@@ -0,0 +1,29 @@
+require_relative 'spec_helper'
+
+describe "Testing helpers for email_helper's read_email method" do
+
+  it "should return an array of options given a hash" do
+      test_collection = EmailHelper::EmailCollection
+      option_hash = {:from => "foo@bar.com",
+                     :to => "bar@foo.com",
+                     :subject => "Foo Bar"}
+      transformed_options = test_collection.options_hash_to_array(option_hash)
+      transformed_options.is_a?(Array).should == true
+      option_hash.each_with_index do | keyvalue, index |
+          key = keyvalue[0]
+          value = keyvalue[1]
+         transformed_options[index*2].downcase.to_sym.should == key
+         transformed_options[index*2].should == key.to_s.upcase
+         transformed_options[index*2 + 1].should == value
+      end
+  end
+
+  it "should throw an argument exception because of the options parameter" do
+     test_collection = EmailHelper::EmailCollection
+     option_hash = ["Subject", "subject"]
+     dummy_model = Watirmark::Model::Factory.new
+     expect { test_collection.read_email(dummy_model,option_hash) }.to raise_error(ArgumentError)
+     expect { test_collection.read_email(dummy_model, nil)}.to raise_error(ArgumentError)
+  end
+
+end

data/spec/model_factory_spec.rb

@@ -520,6 +520,22 @@ describe "keywords" do
           last_name { "Last #{uuid}" }
         end
       end
+
+      class MultipleKeywordsModel < Watirmark::Model::Factory
+        keywords :first_name
+        keywords :last_name
+        defaults do
+          first_name { "First" }
+          last_name {"Last"}
+        end
+      end
+
+      class DuplicateKeywordsModel < Watirmark::Model::Factory
+        keywords :first_name, :first_name
+        defaults do
+          first_name { "First" }
+        end
+      end
     end
   end
 
@@ -541,6 +557,18 @@ describe "keywords" do
     FactoryTest::SomeModel.new.keywords.sort.should == [:first_name, :middle_name, :last_name].sort
   end
 
+  specify "should be able to support multiple calls to keywords method" do
+    a = FactoryTest::MultipleKeywordsModel.new
+    a.first_name.should == "First"
+    a.keywords.include?(:last_name).should == true
+    a.last_name.should == "Last"
+  end
+
+  specify "should not contain duplicate values in the keywords" do
+    a = FactoryTest::DuplicateKeywordsModel.new
+    a.keywords.size.should == 1
+  end
+
 end
 
 describe "subclassing" do
@@ -549,6 +577,10 @@ describe "subclassing" do
       trait :some_trait do
         full_name { "full_name" }
       end
+
+      trait :new_trait do
+        dog_name {"sugar"}
+      end
     end
     module FactoryTest
       class BaseModel < Watirmark::Model::Factory
@@ -572,6 +604,19 @@ describe "subclassing" do
 
       class NoDefaultModel < BaseModel
       end
+
+      class KeywordsSubModel < BaseModel
+        keywords :middle_name, :cat_name, :dog_name
+        traits :new_trait
+        defaults do
+          middle_name {'middle_name'}
+          cat_name {'Annie'}
+        end
+      end
+
+      class DuplicateKeywordsSubModel < BaseModel
+        keywords :first_name
+      end
     end
   end
 
@@ -588,10 +633,25 @@ describe "subclassing" do
   end
 
   specify "submodel should be able to override defaults" do
-    FactoryTest::SubModel.new.first_name.should == 'sub_first_name'
-    FactoryTest::SubModel.new.last_name.should == 'sub_last_name'
-    FactoryTest::SubModel.new.attr_test.should == 'I came from SubModel'
-    FactoryTest::SubModel.new.base_attr.should == 'This is a base attribute'
+    a = FactoryTest::SubModel.new
+    a.first_name.should == 'sub_first_name'
+    a.last_name.should == 'sub_last_name'
+    a.attr_test.should == 'I came from SubModel'
+    a.base_attr.should == 'This is a base attribute'
+  end
+
+  specify "submodel should be able to add new keywords to the inherited set" do
+    a = FactoryTest::KeywordsSubModel.new
+    a.middle_name.should == 'middle_name'
+    a.keywords.include?(:first_name).should == true
+    a.cat_name.should == 'Annie'
+    a.first_name.should == 'base_first_name'
+    a.dog_name.should == 'sugar'
+  end
+
+  specify "should not have duplicate keywords after inheritance" do
+    a = FactoryTest::DuplicateKeywordsSubModel.new
+    a.keywords.select{|x| x == :first_name}.size.should == 1
   end
 
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 lib_dir = File.join(File.dirname(__FILE__), '..', 'lib')
 $: << File.expand_path(lib_dir)
+$: << File.expand_path(lib_dir + '/watirmark/cucumber')
 
 ENV['WEBDRIVER'] = 'firefox'
 
@@ -7,6 +8,7 @@ ENV['WEBDRIVER'] = 'firefox'
 require 'rspec/autorun'
 require 'watirmark'
 require 'watirmark/configuration'
+require 'watirmark/cucumber/email_helper'
 
 Watirmark.logger.level = Logger::FATAL
 

data/spec/watir_webdriver_spec.rb

@@ -0,0 +1,73 @@
+require_relative 'spec_helper'
+
+describe Watir::Element do
+  before :all do
+    @html = File.expand_path(File.dirname(__FILE__) + '/html/controller.html')
+  end
+
+  before :each do
+    Page.browser.goto "file://#{@html}"
+  end
+
+  describe '#previous_sibling' do
+    specify 'prevsibling, prev_sibling, and previous_sibling return same element' do
+      element = Page.browser.option(:text => 'b')
+      prevsibling_el = element.prevsibling
+      prev_sibling_el = element.prev_sibling
+      previous_sibling_el = element.previous_sibling
+      expect(prevsibling_el).to eq(prev_sibling_el)
+      expect(prev_sibling_el).to eq(previous_sibling_el)
+    end
+
+    specify 'can get previous sibling object even though sibling does not exist' do
+      element = Page.browser.option(:text => 'a')
+      sib = element.previous_sibling
+      expect(sib.class).to eq(Watir::HTMLElement)
+      expect(sib.exists?).to eq(false)
+    end
+
+    specify 'can get child object for nonexistent previous sibling and does not raise exception, just returns false' do
+      element = Page.browser.option(:text => 'a')
+      child = element.previous_sibling.element(:text => 'doesntmatter')
+      expect(child.class).to eq(Watir::HTMLElement)
+      expect(child.exists?).to eq(false)
+    end
+
+    specify 'can get previous sibling object and evaluate it does exist' do
+      element = Page.browser.option(:text => 'b')
+      sib = element.previous_sibling
+      expect(sib.exist?).to eq(true)
+      expect(sib.html).to eq('<option value="a">a</option>')
+    end
+  end
+
+  describe '#next_sibling' do
+    specify 'nextsibling and next_sibling return same element' do
+      element = Page.browser.option(:text => 'b')
+      nextsibling_el = element.nextsibling
+      next_sibling_el = element.next_sibling
+      expect(nextsibling_el).to eq(next_sibling_el)
+    end
+
+    specify 'can get following sibling object even though sibling does not exist' do
+      element = Page.browser.option(:text => 'c')
+      sib = element.next_sibling
+      expect(sib.class).to eq(Watir::HTMLElement)
+      expect(sib.exists?).to eq(false)
+    end
+
+    specify 'can get child object for nonexistent following sibling and does not raise exception, just returns false' do
+      element = Page.browser.option(:text => 'c')
+      child = element.next_sibling.element(:text => 'doesntmatter')
+      expect(child.class).to eq(Watir::HTMLElement)
+      expect(child.exists?).to eq(false)
+    end
+
+    specify 'can get following sibling object and evaluate it does exist' do
+      element = Page.browser.option(:text => 'b')
+      sib = element.next_sibling
+      expect(sib.exist?).to eq(true)
+      expect(sib.html).to eq('<option value="c">c</option>')
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: watirmark
 version: !ruby/object:Gem::Version
-  version: 5.27.2
+  version: 5.28.0
 platform: ruby
 authors:
 - Hugh McGowan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-21 00:00:00.000000000 Z
+date: 2015-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: watir-webdriver
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.2
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: american_date
   requirement: !ruby/object:Gem::Requirement
@@ -199,12 +199,14 @@ files:
 - spec/controller_actions_spec.rb
 - spec/controller_spec.rb
 - spec/controllers_and_models_spec.rb
+- spec/helper_methods_spec.rb
 - spec/model_factory_spec.rb
 - spec/model_traits_spec.rb
 - spec/page_spec.rb
 - spec/process_page_spec.rb
 - spec/session_spec.rb
 - spec/spec_helper.rb
+- spec/watir_webdriver_spec.rb
 homepage: http://github.com/convio/watirmark
 licenses: []
 metadata: {}
@@ -224,19 +226,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
-summary: watirmark 5.27.2
+summary: watirmark 5.28.0
 test_files:
-- spec/assertions_spec.rb
-- spec/config_spec.rb
-- spec/controller_actions_spec.rb
-- spec/controller_spec.rb
+- spec/session_spec.rb
+- spec/helper_methods_spec.rb
 - spec/controllers_and_models_spec.rb
+- spec/process_page_spec.rb
+- spec/page_spec.rb
+- spec/config_spec.rb
 - spec/model_factory_spec.rb
+- spec/controller_actions_spec.rb
 - spec/model_traits_spec.rb
-- spec/page_spec.rb
-- spec/process_page_spec.rb
-- spec/session_spec.rb
+- spec/watir_webdriver_spec.rb
 - spec/spec_helper.rb
+- spec/controller_spec.rb
+- spec/assertions_spec.rb