watirmark 5.14.16 → 5.27.2

data/spec/controller_actions_spec.rb

@@ -13,6 +13,9 @@ describe Watirmark::Actions do
       def create
       end
 
+      def create_until(&block)
+      end
+
       def edit
       end
 
@@ -32,8 +35,8 @@ describe Watirmark::Actions do
     class ActionModel < Watirmark::Model::Factory
       keywords :a, :b
       defaults do
-        a {1}
-        b {2}
+        a { 1 }
+        b { 2 }
       end
     end
   end
@@ -69,8 +72,8 @@ describe Watirmark::Actions do
 
   it 'records should be processed separately' do
     controller = ActionController.new
-    controller.records << {a:1, b:2}
-    controller.records << {c:3, d:4}
+    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
@@ -81,11 +84,71 @@ describe Watirmark::Actions do
   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.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
 
+  it 'records can be assigned models' do
+    controller = ActionController.new
+    controller.records << ModelOpenStruct.new(:a => 1, :b => 2)
+    controller.run :create
+    controller.model.a.should == 1
+    controller.model.b.should == 2
+  end
+
+  it 'records should be processed separately when models are given' do
+    controller = ActionController.new
+    controller.records << ModelOpenStruct.new(:a => 1, :b => 2)
+    controller.records << ModelOpenStruct.new(:c => 3, :d => 4)
+    controller.run :create
+    controller.model.a.should == nil
+    controller.model.b.should == nil
+    controller.model.c.should == 3
+    controller.model.d.should == 4
+  end
+
+  it 'run can accept a block for the stop_until methods' do
+    @controller.expects(:before_all).once
+    @controller.expects(:after_all).once
+    @controller.run(:create_until){ eval "true"}
+  end
+
+  module ControllerActionsTest
+    class Element
+      attr_accessor :value
+
+      def wait_until_present
+        true
+      end
+    end
+
+    class ActionCreateView < Page
+      keyword(:a) { Element.new }
+      keyword(:b) { Element.new }
+
+      def create(*args)
+      end
+
+    end
+
+    class ActionCreateController < Watirmark::WebPage::Controller
+      @view = ActionCreateView
+    end
+
+    class ActionCreateControllerWithOverride < ActionCreateController
+      def populate_data
+      end
+    end
+  end
+
+  it 'should not throw an exception if anything is populated' do
+    expect { ControllerActionsTest::ActionCreateController.new(:a => 1).create }.not_to raise_error
+  end
+
+  it 'should not throw an exception if populate_data is overridden' do
+    lambda { ControllerActionsTest::ActionCreateControllerWithOverride.new.create }.should_not raise_error
+  end
 end

data/spec/controller_spec.rb

@@ -3,13 +3,14 @@ require_relative 'spec_helper'
 describe Watirmark::WebPage::Controller do
 
   class TestView < Page
-    keyword(:text_field)  {browser.text_field(:name, 'text_field')}
-    keyword(:select_list) {browser.select_list(:name, 'select_list')}
-    keyword(:another_text_field)   {browser.text_field(:id, 'validate1')}
+    keyword(:text_field) { browser.text_field(:name, 'text_field') }
+    keyword(:select_list) { browser.select_list(:name, 'select_list') }
+    keyword(:another_text_field) { browser.text_field(:id, 'validate1') }
   end
 
   class TestController < Watirmark::WebPage::Controller
     @view = TestView
+
     def initialize(*args)
       super
       @model.text_field = 'foobar'
@@ -17,49 +18,57 @@ describe Watirmark::WebPage::Controller do
   end
 
   class VerifyView < Page
-    keyword(:validate1)   {browser.text_field(:id, 'validate1')}
-    keyword(:validate2)   {browser.text_field(:id, 'validate2')}
-    keyword(:validate3)   {browser.text_field(:id, 'validate3')}
-    keyword(:validate4)   {browser.select_list(:id, 'validate3')}
-    keyword(:checkbox)    {browser.checkbox(:id, 'checkbox')}
+    keyword(:validate1) { browser.text_field(:id, 'validate1') }
+    keyword(:validate2) { browser.text_field(:id, 'validate2') }
+    keyword(:validate3) { browser.text_field(:id, 'validate3') }
+    keyword(:validate4) { browser.select_list(:id, 'validate3') }
+    keyword(:checkbox) { browser.checkbox(:id, 'checkbox') }
 
-    verify_keyword(:label1)      {browser.td(:id, 'label1')}
-    verify_keyword(:value1)      {browser.td(:id, 'value1')}
-    populate_keyword(:populate1) {browser.text_field(:id, 'validate4')}
-    populate_keyword(:populate2) {browser.td(:id, 'value1')}
+    verify_keyword(:label1) { browser.td(:id, 'label1') }
+    verify_keyword(:value1) { browser.td(:id, 'value1') }
+    populate_keyword(:populate1) { browser.text_field(:id, 'validate4') }
+    populate_keyword(:populate2) { browser.td(:id, 'value1') }
 
-    private_keyword(:private_validate1)  {browser.text_field(:id, 'validate1')}
-    navigation_keyword(:click_submit)    {browser.button(:id, 'Submit').click}
+    private_keyword(:private_validate1) { browser.text_field(:id, 'validate1') }
+    navigation_keyword(:click_submit) { browser.button(:id, 'Submit').click }
   end
 
   class VerifyController < Watirmark::WebPage::Controller
-      @view = VerifyView
+    @view = VerifyView
   end
 
-  class TestControllerSubclass < TestController; end
+  class TestControllerSubclass < TestController;
+  end
 
   class Element
     attr_accessor :value
+
     def initialize(x)
       @value = x
     end
+
+    # stub this out because we're not actually
+    # using a real HTML page for these tests
+    def wait_until_present
+      self
+    end
   end
 
   class ProcessPageControllerView < Page
 
-    keyword(:a) {Element.new :a}
+    keyword(:a) { Element.new :a }
     process_page('Page 1') do
-      keyword(:b) {Element.new :b}
+      keyword(:b) { Element.new :b }
     end
     process_page('Page 2') do
-      keyword(:c) {Element.new :c}
-      keyword(:d) {Element.new :d}
+      keyword(:c) { Element.new :c }
+      keyword(:d) { Element.new :d }
     end
-    keyword(:e) {method :e}
+    keyword(:e) { method :e }
     keyword(:radio_map,
-      ['M'] => 'male',
-      [/f/i] => 'female'
-    )                {Page.browser.radio(:name, 'sex')}
+            ['M'] => 'male',
+            [/f/i] => 'female'
+    ) { Page.browser.radio(:name, 'sex') }
   end
 
   class TestProcessPageController < Watirmark::WebPage::Controller
@@ -80,27 +89,27 @@ describe Watirmark::WebPage::Controller do
     Page.browser.refresh #reset page before each test
   end
 
-  it 'should supportradio maps in controllers' do
-    lambda{
+  specify 'should supportradio maps in controllers' do
+    lambda {
       TestProcessPageController.new(:radio_map => 'f').populate_data
     }.should_not raise_error
   end
 
-  it 'should be able to create and use a new keyword' do
-    @keyword.should == :text_field
-    TestView.new.send("#{@keyword}=", 'test')
-    lambda{ @controller.check(@keyword, 'test')}.should_not raise_error(Watirmark::VerificationException)
+  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
   end
 
-  it 'should be able to populate' do
+  specify 'should be able to populate' do
     module ControllerTest
       class PopulateController < Watirmark::WebPage::Controller
         @view = TestView
       end
     end
     ControllerTest::PopulateController.new(
-        :text_field=>'test',
-        :select_list=>'b',
+        :text_field => 'test',
+        :select_list => 'b',
         :another_text_field => 'nil'
     ).populate_data
     v = TestView.new
@@ -109,11 +118,11 @@ describe Watirmark::WebPage::Controller do
     v.another_text_field.value.should == ''
   end
 
-  it 'should be be able to interpret use value' do
+  specify 'should be be able to interpret use value' do
     @controller.value(@keyed_element).should == 'foobar'
   end
 
-  it 'should support override method to value' do
+  specify 'should support override method to value' do
     class TestController
       def text_field_value
         'override'
@@ -122,120 +131,133 @@ describe Watirmark::WebPage::Controller do
     @controller.value(Watirmark::KeyedElement.new(TestController.new, :keyword => @keyword)).should == 'override'
   end
 
-  it 'should support override method for verification' do
-    def @controller.verify_text_field; 'verify';  end
+  specify 'should support override method for verification' do
+    def @controller.verify_text_field;
+      'verify';
+    end
+
     @controller.expects(:verify_text_field).returns('verify').once
     @controller.verify_data
   end
 
-  it 'should support keyword before and after methods' do
-    def @controller.before_text_field; 'before'; end
-    def @controller.after_text_field; 'after';  end
+  specify 'should support keyword before and after methods' do
+    def @controller.before_text_field;
+      'before';
+    end
+
+    def @controller.after_text_field;
+      'after';
+    end
+
     @controller.expects(:before_text_field).returns('before').once
     @controller.expects(:after_text_field).returns('after').once
     @controller.populate_data {}
   end
 
-  it 'should propogate page declaration to subclasses' do
+  specify 'should propogate page declaration to subclasses' do
     TestControllerSubclass.view.should == TestView
   end
 
-  it 'should support before methods for process pages' do
-    c = TestProcessPageController.new({:a=>1, :b=>1, :c=>1, :d=>1})
-    def c.before_process_page_page_1; true; end
+  specify 'should support before methods for process pages' do
+    c = TestProcessPageController.new({:a => 1, :b => 1, :c => 1, :d => 1})
+
+    def c.before_process_page_page_1;
+      true;
+    end
+
     c.expects(:before_process_page_page_1).returns('true').once
     c.populate_data
   end
 
-  it 'should throw a Watirmark::VerificationException when a verification fails' do
+  specify 'should throw a Watirmark::VerificationException when a verification fails' do
     lambda {
       VerifyController.new(:validate1 => '2').verify_data
-    }.should raise_error(Watirmark::VerificationException,"validate1: expected '2' (String) got '1' (String)")
+    }.should raise_error(Watirmark::VerificationException, "validate1: expected '2' (String) got '1' (String)")
   end
 
-  it 'should not throw an exception when a verification succeeds' do
+  specify 'should not throw an exception when a verification succeeds' do
     VerifyController.new(:validate2 => 'a').verify_data
   end
 
-  it 'should not throw an exception when many verifications succeed' do
-    VerifyController.new(:validate1 => '1',:validate2 => 'a',:validate3 => 1.1).verify_data
+  specify 'should not throw an exception when many verifications succeed' do
+    VerifyController.new(:validate1 => '1', :validate2 => 'a', :validate3 => 1.1).verify_data
   end
 
-  it 'should only throw one validation exception when there are 3 three problems' do
+  specify 'should only throw one validation exception when there are 3 three problems' do
     lambda {
-    VerifyController.new(:validate1 => 'z',:validate2 => 'y',:validate3 => 'x').verify_data
+      VerifyController.new(:validate1 => 'z', :validate2 => 'y', :validate3 => 'x').verify_data
     }.should raise_error(Watirmark::VerificationException)
   end
 
-  it 'should throw an exception when verifying a verify_keyword fails' do
+  specify 'should throw an exception when verifying a verify_keyword fails' do
     lambda {
       VerifyController.new(:label1 => 'text').verify_data
-    }.should raise_error(Watirmark::VerificationException,"label1: expected 'text' (String) got 'numbers' (String)")
+    }.should raise_error(Watirmark::VerificationException, "label1: expected 'text' (String) got 'numbers' (String)")
   end
 
-  it 'should not throw an exception when verifying a verify_keyword succeeds' do
+  specify 'should not throw an exception when verifying a verify_keyword succeeds' do
     VerifyController.new(:label1 => 'numbers', :value1 => 1).verify_data
   end
 
-  it 'should not throw an exception when populating with a verify_keyword' do
+  specify 'should not throw an exception when populating with a verify_keyword' do
     VerifyController.new(:label1 => 'string').populate_data
   end
 
-  it 'should throw an exception when populating a populate_keyword fails' do
+  specify 'should throw an exception when populating a populate_keyword fails' do
     lambda {
       VerifyController.new(:populate2 => '32').populate_data
     }.should raise_error(NoMethodError)
   end
 
-  it 'should not throw an exception when populating a populate_keyword succeeds' do
+  specify 'should not throw an exception when populating a populate_keyword succeeds' do
     VerifyController.new(:populate1 => '3.14159').populate_data
   end
 
-  it 'should not throw an exception when verifying with a populate_keyword' do
+  specify 'should not throw an exception when verifying with a populate_keyword' do
     VerifyController.new(:populate1 => 'void').verify_data
   end
 
-  it 'should not populate a private_keyword successfully' do
+  specify 'should not populate a private_keyword successfully' do
     c = VerifyController.new(:validate1 => 'hello')
     c.populate_data
     VerifyController.new(:private_validate1 => 'goodbye').populate_data
     c.verify_data
   end
 
-  it 'should not verify a private_keyword successfully' do
+  specify 'should not verify a private_keyword successfully' do
     c = VerifyController.new(:private_validate1 => 'hello')
     VerifyController.new(:validate1 => 'goodbye').populate_data
     c.verify_data
   end
 
-  it 'should not throw an exception when populating or verifying a private_keyword fails' do
+  specify 'should not throw an exception when populating or verifying a private_keyword fails' do
     c = VerifyController.new(:private_validate1 => 'goodbye')
     c.populate_data
     c.model.update(:private_validate1 => 'hello')
     c.verify_data
   end
 
-  it 'should not throw an exception when populating or verifying a navigation_keyword fails' do
+  specify 'should not throw an exception when populating or verifying a navigation_keyword fails' do
     c = VerifyController.new(:button1 => 'Cancel')
     c.populate_data
     c.model.update(:button1 => 'Submit')
     c.verify_data
   end
 
-  it 'false should be a valid keyword value' do
+  specify 'false should be a valid keyword value' do
     c = VerifyController.new(:checkbox => true)
     c.populate_data
-    VerifyView.new.checkbox.set?.should be_true
+    VerifyView.new.checkbox.set?.should == true
     c.model.update(:checkbox => false)
     c.populate_data
-    VerifyView.new.checkbox.set?.should be_false
+    VerifyView.new.checkbox.set?.should == false
   end
 end
 
 describe "controllers should be able to detect and use embedded models" do
   before :all do
     class MyView < Page
-      keyword(:element) {@@element}
+      keyword(:element) { @@element }
     end
     @controller = Class.new Watirmark::WebPage::Controller do
       @view = MyView
@@ -254,19 +276,19 @@ describe "controllers should be able to detect and use embedded models" do
     @password = Password.new
     @login = Login.new
     @login.add_model @password
-    @model = User.new(:first_name=> 'first')
+    @model = User.new(:first_name => 'first')
     @model.add_model @login
   end
 
-  it 'should be able to see itself' do
+  specify 'should be able to see itself' do
     @model.find(User).should == @model
   end
 
-  it 'should be able to see a sub_model' do
+  specify 'should be able to see a sub_model' do
     @model.find(Login).should == @login
   end
 
-  it 'should be able to see a nested sub_model' do
+  specify 'should be able to see a nested sub_model' do
     @model.find(Password).should == @password
   end
 end
@@ -285,7 +307,7 @@ describe "controllers should create a default model if one exists" do
     end
   end
 
-  it 'should be able to see itself' do
+  specify 'should be able to see itself' do
     c = @controller.new
     c.model.should be_kind_of(MyModel)
   end
@@ -297,9 +319,9 @@ describe "Similar Models" do
   before :all do
     class ProcessPageControllerView < Page
 
-      keyword(:a) {Element.new :a}
+      keyword(:a) { Element.new :a }
       process_page('Page 1') do
-        keyword(:b) {Element.new :b}
+        keyword(:b) { Element.new :b }
       end
       process_page('Page 2') do
         keyword(:c) { Element.new :c }
@@ -365,36 +387,34 @@ describe "Similar Models" do
     class TestNoModelController < Watirmark::WebPage::Controller
       @view = ProcessPageControllerView
     end
-
-
   end
 
-  it 'should use the similar modelA' do
+  specify 'should use the similar modelA' do
     @controller = TestProcessPageController.new(ModelD.new)
     @controller.model.should be_kind_of ModelB
     @controller.supermodel.should be_kind_of ModelD
   end
 
-  it 'should use the top model' do
+  specify 'should use the top model' do
     @controller = TestProcessPageController.new(ModelB.new)
     @controller.model.should be_kind_of ModelB
     @controller.supermodel.should be_kind_of ModelB
   end
 
-  it 'should use parent model' do
+  specify 'should use parent model' do
     @controller = TestProcessPageController.new(ModelC.new)
     @controller.model.should be_kind_of ModelA
     @controller.supermodel.should be_kind_of ModelC
   end
 
-  it 'should call the smallest child similar to the model in controller' do
+  specify 'should call the smallest child similar to the model in controller' do
     @controller = TestProcessPageController.new(ModelE.new)
     @controller.model.should be_kind_of ModelB
     @controller.supermodel.should be_kind_of ModelE
 
   end
 
-  it 'should select the correct model when base model has 2 similar models' do
+  specify 'should select the correct model when base model has 2 similar models' do
     @controller = TestProcessPageController.new(ModelG.new)
     @controller.model.should be_kind_of ModelF
     @controller.supermodel.should be_kind_of ModelG
@@ -404,19 +424,19 @@ describe "Similar Models" do
     @controller.supermodel.should be_kind_of ModelF
   end
 
-  it 'should use the supermodel as a model if a controller model is not defined' do
+  specify 'should use the supermodel as a model if a controller model is not defined' do
     @controller = TestNoModelController.new(ModelE.new)
     @controller.model.should be_kind_of ModelE
     @controller.supermodel.should be_kind_of ModelE
   end
 
-  it 'should use passed in model as @model when model_type is not defined' do
+  specify 'should use passed in model as @model when model_type is not defined' do
     @controller = TestProcessPageController.new(ModelH.new)
     @controller.model.should be_kind_of ModelH
     @controller.supermodel.should be_kind_of ModelH
   end
 
-  it 'should allow us to override the default model' do
+  specify 'should allow us to override the default model' do
     @controller = TestProcessPageController.new(ModelH.new)
     @controller.model.should be_kind_of ModelH
     @controller.model = ModelA.new