capybara 2.0.3 → 2.1.0.beta1

data/lib/capybara/spec/session/click_link_spec.rb

@@ -66,6 +66,17 @@ Capybara::SpecHelper.spec '#click_link' do
     end
   end
 
+  context "with :href option given" do
+    it "should find links with valid href" do
+      @session.click_link('labore', :href => '/with_simple_html')
+      @session.should have_content('Bar')
+    end
+
+    it "should raise error if link wasn't found" do
+      expect { @session.click_link('labore', :href => 'invalid_href') }.to raise_error(Capybara::ElementNotFound)
+    end
+  end
+
   it "should follow relative links" do
     @session.visit('/')
     @session.click_link('Relative')
@@ -116,4 +127,17 @@ Capybara::SpecHelper.spec '#click_link' do
       @session.click_link('No Href')
     end.to raise_error(Capybara::ElementNotFound)
   end
+
+  context "with :exact option" do
+    it "should accept partial matches when false" do
+      @session.click_link('abo', :exact => false)
+      @session.should have_content('Bar')
+    end
+
+    it "should not accept partial matches when true" do
+      expect do
+        @session.click_link('abo', :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/current_scope_spec.rb

@@ -0,0 +1,29 @@
+Capybara::SpecHelper.spec '#current_scope' do
+  before do
+    @session.visit('/with_scope')
+  end
+  
+  context "when not in a #within block" do
+    it "should return the document" do
+      @session.current_scope.should be_kind_of Capybara::Node::Document
+    end
+  end
+  
+  context "when in a #within block" do
+    it "should return the element in scope" do
+      @session.within(:css, "#simple_first_name") do
+        @session.current_scope[:name].should eq 'first_name'
+      end
+    end
+  end
+  
+  context "when in a nested #within block" do
+    it "should return the element in scope" do
+      @session.within("//div[@id='for_bar']") do
+        @session.within(".//input[@value='Peter']") do
+          @session.current_scope[:name].should eq 'form[first_name]'
+        end
+      end
+    end
+  end
+end

data/lib/capybara/spec/session/fill_in_spec.rb

@@ -138,4 +138,18 @@ Capybara::SpecHelper.spec "#fill_in" do
       end.to raise_error(Capybara::ElementNotFound)
     end
   end
+
+  context "with :exact option" do
+    it "should accept partial matches when false" do
+      @session.fill_in("Explanation", :with => "Dude", :exact => false)
+      @session.click_button("awesome")
+      extract_results(@session)["name_explanation"].should == "Dude"
+    end
+
+    it "should not accept partial matches when true" do
+      expect do
+        @session.fill_in("Explanation", :with => "Dude", :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/find_button_spec.rb

@@ -17,4 +17,16 @@ Capybara::SpecHelper.spec '#find_button' do
       @session.find_button('Does not exist')
     end.to raise_error(Capybara::ElementNotFound)
   end
+
+  context "with :exact option" do
+    it "should accept partial matches when false" do
+      @session.find_button('What an Awesome', :exact => false)[:value].should == "awesome"
+    end
+
+    it "should not accept partial matches when true" do
+      expect do
+        @session.find_button('What an Awesome', :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/find_by_id_spec.rb

@@ -5,7 +5,6 @@ Capybara::SpecHelper.spec '#find_by_id' do
 
   it "should find any element by id" do
     @session.find_by_id('red').tag_name.should == 'a'
-    @session.find_by_id('hidden_via_ancestor').tag_name.should == 'div'
   end
 
   it "casts to string" do
@@ -17,4 +16,16 @@ Capybara::SpecHelper.spec '#find_by_id' do
       @session.find_by_id('nothing_with_this_id')
     end.to raise_error(Capybara::ElementNotFound)
   end
+
+  context "with :visible option" do
+    it "finds invisible elements when `false`" do
+      @session.find_by_id("hidden_via_ancestor", :visible => false).text(:all).should =~ /with hidden ancestor/
+    end
+
+    it "finds invisible elements when `false`" do
+      expect do
+        @session.find_by_id("hidden_via_ancestor", :visible => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/find_field_spec.rb

@@ -25,4 +25,34 @@ Capybara::SpecHelper.spec '#find_field' do
       @session.field_labeled('Does not exist')
     end.to raise_error(Capybara::ElementNotFound)
   end
+
+  context "with :exact option" do
+    it "should accept partial matches when false" do
+      @session.find_field("Explanation", :exact => false)[:name].should == "form[name_explanation]"
+    end
+
+    it "should not accept partial matches when true" do
+      expect do
+        @session.find_field("Explanation", :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
+
+  context "with :disabled option" do
+    it "should find disabled fields when true" do
+      @session.find_field("Disabled Checkbox", :disabled => true)[:name].should == "form[disabled_checkbox]"
+    end
+
+    it "should not find disabled fields when false" do
+      expect do
+        @session.find_field("Disabled Checkbox", :disabled => false)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+
+    it "should not find disabled fields by default" do
+      expect do
+        @session.find_field("Disabled Checkbox")
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/find_link_spec.rb

@@ -17,4 +17,16 @@ Capybara::SpecHelper.spec '#find_link' do
       @session.find_link('Does not exist')
     end.to raise_error(Capybara::ElementNotFound)
   end
+
+  context "with :exact option" do
+    it "should accept partial matches when false" do
+      @session.find_link('abo', :exact => false).text.should == "labore"
+    end
+
+    it "should not accept partial matches when true" do
+      expect do
+        @session.find_link('abo', :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+  end
 end

data/lib/capybara/spec/session/find_spec.rb

@@ -27,6 +27,30 @@ Capybara::SpecHelper.spec '#find' do
     @session.find(:css, "a#has-been-clicked").text.should include('Has been clicked')
   end
 
+  context "with :wait option", :requires => [:js] do
+    it "should not wait for asynchronous load when `false` given" do
+      @session.visit('/with_js')
+      @session.click_link('Click me')
+      expect do
+        @session.find(:css, "a#has-been-clicked", :wait => false)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+
+    it "should not find element if it appears after given wait duration" do
+      @session.visit('/with_js')
+      @session.click_link('Slowly')
+      expect do
+        @session.find(:css, "a#slow-clicked", :wait => 0.2)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+
+    it "should find element if it appears before given wait duration" do
+      @session.visit('/with_js')
+      @session.click_link('Click me')
+      @session.find(:css, "a#has-been-clicked", :wait => 0.9).text.should include('Has been clicked')
+    end
+  end
+
   context "with frozen time", :requires => [:js] do
     it "raises an error suggesting that Capybara is stuck in time" do
       @session.visit('/with_js')
@@ -41,6 +65,10 @@ Capybara::SpecHelper.spec '#find' do
       @session.find(:css, 'h1').text.should == 'This is a test'
       @session.find(:css, "input[id='test_field']")[:value].should == 'monkey'
     end
+
+    it "should support pseudo selectors" do
+      @session.find(:css, 'input:disabled').value.should == 'This is disabled'
+    end
   end
 
   context "with xpath selectors" do
@@ -52,43 +80,72 @@ Capybara::SpecHelper.spec '#find' do
 
   context "with custom selector" do
     it "should use the custom selector" do
-      Capybara.add_selector(:monkey) do
-        xpath { |name| ".//*[@id='#{name}_monkey']" }
+      Capybara.add_selector(:beatle) do
+        xpath { |name| ".//*[@id='#{name}']" }
       end
-      @session.find(:monkey, 'john').text.should == 'Monkey John'
-      @session.find(:monkey, 'paul').text.should == 'Monkey Paul'
+      @session.find(:beatle, 'john').text.should == 'John'
+      @session.find(:beatle, 'paul').text.should == 'Paul'
     end
   end
 
   context "with custom selector with :for option" do
     it "should use the selector when it matches the :for option" do
-      Capybara.add_selector(:monkey) do
-        xpath { |num| ".//*[contains(@id, 'monkey')][#{num}]" }
+      Capybara.add_selector(:beatle) do
+        xpath { |num| ".//*[contains(@class, 'beatle')][#{num}]" }
         match { |value| value.is_a?(Fixnum) }
       end
-      @session.find(:monkey, '2').text.should == 'Monkey Paul'
-      @session.find(1).text.should == 'Monkey John'
-      @session.find(2).text.should == 'Monkey Paul'
+      @session.find(:beatle, '2').text.should == 'Paul'
+      @session.find(1).text.should == 'John'
+      @session.find(2).text.should == 'Paul'
       @session.find('//h1').text.should == 'This is a test'
     end
   end
 
   context "with custom selector with custom filter" do
     before do
-      Capybara.add_selector(:monkey) do
-        xpath { |num| ".//*[contains(@id, 'monkey')][#{num}]" }
-        filter(:name) { |node, name| node.text == name }
+      Capybara.add_selector(:beatle) do
+        xpath { |name| ".//li[contains(@class, 'beatle')][contains(text(), '#{name}')]" }
+        filter(:type) { |node, type| node[:class].split(/\s+/).include?(type) }
+      end
+    end
+
+    it "should find elements that match the filter" do
+      @session.find(:beatle, 'Paul', :type => 'drummer').text.should == 'Paul'
+      @session.find(:beatle, 'Ringo', :type => 'drummer').text.should == 'Ringo'
+    end
+
+    it "ignores filter when it is not given" do
+      @session.find(:beatle, 'Paul').text.should == 'Paul'
+      @session.find(:beatle, 'John').text.should == 'John'
+    end
+
+    it "should not find elements that don't match the filter" do
+      expect { @session.find(:beatle, 'John', :type => 'drummer') }.to raise_error(Capybara::ElementNotFound)
+      expect { @session.find(:beatle, 'George', :type => 'drummer') }.to raise_error(Capybara::ElementNotFound)
+    end
+  end
+
+  context "with custom selector with custom filter and default" do
+    before do
+      Capybara.add_selector(:beatle) do
+        xpath { |name| ".//li[contains(@class, 'beatle')][contains(text(), '#{name}')]" }
+        filter(:type, :default => "drummer") { |node, type| node[:class].split(/\s+/).include?(type) }
       end
     end
 
     it "should find elements that match the filter" do
-      @session.find(:monkey, '1', :name => 'Monkey John').text.should == 'Monkey John'
-      @session.find(:monkey, '2', :name => 'Monkey Paul').text.should == 'Monkey Paul'
+      @session.find(:beatle, 'Paul', :type => 'drummer').text.should == 'Paul'
+      @session.find(:beatle, 'Ringo', :type => 'drummer').text.should == 'Ringo'
+    end
+
+    it "should use default value when filter is not given" do
+      @session.find(:beatle, 'Paul').text.should == 'Paul'
+      expect { @session.find(:beatle, 'John') }.to raise_error(Capybara::ElementNotFound)
     end
 
     it "should not find elements that don't match the filter" do
-      expect { @session.find(:monkey, '2', :name => 'Monkey John') }.to raise_error(Capybara::ElementNotFound)
-      expect { @session.find(:monkey, '1', :name => 'Monkey Paul') }.to raise_error(Capybara::ElementNotFound)
+      expect { @session.find(:beatle, 'John', :type => 'drummer') }.to raise_error(Capybara::ElementNotFound)
+      expect { @session.find(:beatle, 'George', :type => 'drummer') }.to raise_error(Capybara::ElementNotFound)
     end
   end
 
@@ -113,6 +170,185 @@ Capybara::SpecHelper.spec '#find' do
     @session.find(@xpath).value.should == 'John'
   end
 
+  context "with :exact option" do
+    it "matches exactly when true" do
+      @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("test_field")], :exact => true).value.should == "monkey"
+      expect do
+        @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("est_fiel")], :exact => true)
+      end.to raise_error(Capybara::ElementNotFound)
+    end
+
+    it "matches loosely when false" do
+      @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("test_field")], :exact => false).value.should == "monkey"
+      @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("est_fiel")], :exact => false).value.should == "monkey"
+    end
+
+    it "defaults to `Capybara.exact`" do
+      Capybara.exact = true
+      expect do
+        @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("est_fiel")])
+      end.to raise_error(Capybara::ElementNotFound)
+      Capybara.exact = false
+      @session.find(:xpath, XPath.descendant(:input)[XPath.attr(:id).is("est_fiel")])
+    end
+  end
+
+  context "with :match option" do
+    context "when set to `one`" do
+      it "raises an error when multiple matches exist" do
+        expect do
+          @session.find(:css, ".multiple", :match => :one)
+        end.to raise_error(Capybara::Ambiguous)
+      end
+      it "raises an error even if there the match is exact and the others are inexact" do
+        expect do
+          @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular")], :exact => false, :match => :one)
+        end.to raise_error(Capybara::Ambiguous)
+      end
+      it "returns the element if there is only one" do
+        @session.find(:css, ".singular", :match => :one).text.should == "singular"
+      end
+      it "raises an error if there is no match" do
+        expect do
+          @session.find(:css, ".does-not-exist", :match => :one)
+        end.to raise_error(Capybara::ElementNotFound)
+      end
+    end
+
+    context "when set to `first`" do
+      it "returns the first matched element" do
+        @session.find(:css, ".multiple", :match => :first).text.should == "multiple one"
+      end
+      it "raises an error if there is no match" do
+        expect do
+          @session.find(:css, ".does-not-exist", :match => :first)
+        end.to raise_error(Capybara::ElementNotFound)
+      end
+    end
+
+    context "when set to `smart`" do
+      context "and `exact` set to `false`" do
+        it "raises an error when there are multiple exact matches" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("multiple")], :match => :smart, :exact => false)
+          end.to raise_error(Capybara::Ambiguous)
+        end
+        it "finds a single exact match when there also are inexact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular")], :match => :smart, :exact => false)
+          result.text.should == "almost singular"
+        end
+        it "raises an error when there are multiple inexact matches" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singul")], :match => :smart, :exact => false)
+          end.to raise_error(Capybara::Ambiguous)
+        end
+        it "finds a single inexact match" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular but")], :match => :smart, :exact => false)
+          result.text.should == "almost singular but not quite"
+        end
+        it "raises an error if there is no match" do
+          expect do
+            @session.find(:css, ".does-not-exist", :match => :smart, :exact => false)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+      end
+
+      context "with `exact` set to `true`" do
+        it "raises an error when there are multiple exact matches" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("multiple")], :match => :smart, :exact => true)
+          end.to raise_error(Capybara::Ambiguous)
+        end
+        it "finds a single exact match when there also are inexact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular")], :match => :smart, :exact => true)
+          result.text.should == "almost singular"
+        end
+        it "raises an error when there are multiple inexact matches" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singul")], :match => :smart, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+        it "raises an error when there is a single inexact matches" do
+          expect do
+            result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular but")], :match => :smart, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+        it "raises an error if there is no match" do
+          expect do
+            @session.find(:css, ".does-not-exist", :match => :smart, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+      end
+    end
+
+    context "when set to `prefer_exact`" do
+      context "and `exact` set to `false`" do
+        it "picks the first one when there are multiple exact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("multiple")], :match => :prefer_exact, :exact => false)
+          result.text.should == "multiple one"
+        end
+        it "finds a single exact match when there also are inexact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular")], :match => :prefer_exact, :exact => false)
+          result.text.should == "almost singular"
+        end
+        it "picks the first one when there are multiple inexact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singul")], :match => :prefer_exact, :exact => false)
+          result.text.should == "almost singular but not quite"
+        end
+        it "finds a single inexact match" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular but")], :match => :prefer_exact, :exact => false)
+          result.text.should == "almost singular but not quite"
+        end
+        it "raises an error if there is no match" do
+          expect do
+            @session.find(:css, ".does-not-exist", :match => :prefer_exact, :exact => false)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+      end
+
+      context "with `exact` set to `true`" do
+        it "picks the first one when there are multiple exact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("multiple")], :match => :prefer_exact, :exact => true)
+          result.text.should == "multiple one"
+        end
+        it "finds a single exact match when there also are inexact matches" do
+          result = @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular")], :match => :prefer_exact, :exact => true)
+          result.text.should == "almost singular"
+        end
+        it "raises an error if there are multiple inexact matches" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singul")], :match => :prefer_exact, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+        it "raises an error if there is a single inexact match" do
+          expect do
+            @session.find(:xpath, XPath.descendant[XPath.attr(:class).is("almost_singular but")], :match => :prefer_exact, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+        it "raises an error if there is no match" do
+          expect do
+            @session.find(:css, ".does-not-exist", :match => :prefer_exact, :exact => true)
+          end.to raise_error(Capybara::ElementNotFound)
+        end
+      end
+    end
+
+    it "defaults to `Capybara.match`" do
+      Capybara.match = :one
+      expect do
+        @session.find(:css, ".multiple")
+      end.to raise_error(Capybara::Ambiguous)
+      Capybara.match = :first
+      @session.find(:css, ".multiple").text.should == "multiple one"
+    end
+
+    it "raises an error when unknown option given" do
+      expect do
+        @session.find(:css, ".singular", :match => :schmoo)
+      end.to raise_error(ArgumentError)
+    end
+  end
+
   context "within a scope" do
     before do
       @session.visit('/with_scope')
@@ -123,5 +359,11 @@ Capybara::SpecHelper.spec '#find' do
         @session.find('.//li[1]').text.should =~ /With Simple HTML/
       end
     end
+
+    it "should support pseudo selectors" do
+      @session.within(:xpath, "//div[@id='for_bar']") do
+        @session.find(:css, 'input:disabled').value.should == 'James'
+      end
+    end
   end
 end