kelp 0.1.9 → 0.2.0

data/lib/kelp/helper.rb

@@ -1,3 +1,5 @@
+require 'kelp/exceptions'
+
 module Kelp
   module Helper
     # Convert a Cucumber::Ast::Table or multiline string into
@@ -14,11 +16,16 @@ module Kelp
     # A slightly friendlier version of Capybara's `find_field`, which actually
     # tells you which locator failed to match (instead of giving a useless
     # Unable to find '#<XPath::Union:0xXXXXXXX>' message).
+    #
+    # @raise [Kelp::FieldNotFound]
+    #   If no field with the given locator could be found
+    #
     def nice_find_field(locator)
       begin
         field = find_field(locator)
       rescue Capybara::ElementNotFound
-        raise "Could not find field with locator: '#{locator}'"
+        raise Kelp::FieldNotFound,
+          "Could not find field: '#{locator}'"
       end
     end
 

data/lib/kelp/navigation.rb

@@ -76,6 +76,9 @@ module Kelp
     #   Human-readable page name (mapped to a pathname by your `path_to` function),
     #   or an absolute path beginning with `/`.
     #
+    # @raise [Kelp::Unexpected]
+    #   If actual page path doesn't match the expected path
+    #
     # @since 0.1.9
     #
     def should_be_on_page(page_name_or_path)
@@ -88,10 +91,10 @@ module Kelp
         expect_path = page_name_or_path
       end
       actual_path = URI.parse(current_url).path
-      if actual_path.respond_to? :should
-        actual_path.should == expect_path
-      else
-        assert_equal actual_path, expect_path
+      if actual_path != expect_path
+        raise Kelp::Unexpected,
+          "Expected to be on page: '#{expect_path}'" + \
+          "\nActually on page: '#{actual_path}'"
       end
     end
 
@@ -101,6 +104,9 @@ module Kelp
     # @param [Hash] params
     #   Key => value parameters, as they would appear in the URL
     #
+    # @raise [Kelp::Unexpected]
+    #   If actual query parameters don't match expected parameters
+    #
     # @since 0.1.9
     #
     def should_have_query(params)
@@ -110,10 +116,10 @@ module Kelp
       params.each_pair do |k,v|
         expected_params[k] = v.split(',')
       end
-      if actual_params.respond_to? :should
-        actual_params.should == expected_params
-      else
-        assert_equal expected_params, actual_params
+      if actual_params != expected_params
+        raise Kelp::Unexpected,
+          "Expected query params: '#{expected_params.inspect}'" + \
+          "\nActual query params: '#{actual_params.inspect}'"
       end
     end
 

data/lib/kelp/scoping.rb

@@ -12,10 +12,8 @@ module Kelp
         # by features/support/selectors.rb, generated by cucumber-rails.
         if defined? selector_for
           within(*selector_for(locator)) { yield }
-        # Otherwise, remove any surrounding double-quotes
-        # and fall back on the Capybara locator syntax (CSS or XPath)
+        # Otherwise, fall back on the Capybara locator syntax (CSS or XPath)
         else
-          locator.gsub!(/^"(.*?)"$/, '\1')
           if locator =~ /\.?\//
             within(:xpath, locator) { yield }
           else

data/lib/kelp/visibility.rb

@@ -12,6 +12,28 @@ module Kelp
     include Scoping
     include XPaths
 
+    # Return `true` if the current page contains the given text or regular expression,
+    # or `false` if it does not.
+    #
+    # @param [String, Regexp] text_or_regexp
+    #   Text or regular expression to look for
+    #
+    # @raise [ArgumentError]
+    #   If the given argument isn't a String or Regexp
+    #
+    # @since 0.2.0
+    #
+    def page_contains?(text_or_regexp)
+      if text_or_regexp.class == String
+        return page.has_content?(text_or_regexp)
+      elsif text_or_regexp.class == Regexp
+        return page.has_xpath?('.//*', :text => text_or_regexp)
+      else
+        raise ArgumentError, "Expected String or Regexp, got #{text_or_regexp.class}"
+      end
+    end
+
+
     # Verify the presence of content on the page. Passes when all the given items
     # are found on the page, and fails if any of them are not found.
     #
@@ -30,20 +52,16 @@ module Kelp
     #   If any of the expected text strings are not seen in the given scope
     #
     def should_see(texts, scope={})
-      texts = [texts] if (texts.class == String || texts.class == Regexp)
-      unexpected = []
       in_scope(scope) do
-        texts.each do |text|
-          begin
-            page_should_contain text
-          rescue rspec_unexpected
-            unexpected << text
-          end
+        texts = [texts] if (texts.class == String || texts.class == Regexp)
+        # Select all expected values that don't appear on the page
+        unexpected = texts.select do |text|
+          !page_contains?(text)
+        end
+        if !unexpected.empty?
+          raise Kelp::Unexpected,
+            "Expected to see: #{texts.inspect}\nDid not see: #{unexpected.inspect}"
         end
-      end
-      if !unexpected.empty?
-        raise Kelp::Unexpected,
-          "Expected to see: #{texts.inspect}\nDid not see: #{unexpected.inspect}"
       end
     end
 
@@ -52,7 +70,7 @@ module Kelp
     # items are found on the page, and fails if any of them are found.
     #
     # @param [String, Regexp, Array] texts
-    #   Text(s) or regexp(s) to look for
+    #   Text(s) or Regexp(s) to look for
     # @param [Hash] scope
     #   Scoping keywords as understood by {#in_scope}
     #
@@ -60,149 +78,16 @@ module Kelp
     #   If any of the expected text strings are seen in the given scope
     #
     def should_not_see(texts, scope={})
-      texts = [texts] if (texts.class == String || texts.class == Regexp)
-      unexpected = []
       in_scope(scope) do
-        texts.each do |text|
-          begin
-            page_should_not_contain text
-          rescue rspec_unexpected
-            unexpected << text
-          end
-        end
-      end
-      if !unexpected.empty?
-        raise Kelp::Unexpected,
-          "Expected not to see: #{texts.inspect}\nDid see: #{unexpected.inspect}"
-      end
-    end
-
-
-    # Ensure that the current page content includes a String or Regexp.
-    #
-    # @param [String, Regexp] text_or_regexp
-    #   Content you expect to be on the page
-    #
-    def page_should_contain(text_or_regexp)
-      if text_or_regexp.class == String
-        page_should_contain_text(text_or_regexp)
-      elsif text_or_regexp.class == Regexp
-        page_should_contain_regexp(text_or_regexp)
-      else
-        raise ArgumentError, "Expected String or Regexp, got #{text_or_regexp.class}"
-      end
-    end
-
-
-    # Ensure that the current page content does not include a String or Regexp.
-    #
-    # @param [String, Regexp] text_or_regexp
-    #   Content you expect to be missing from the page
-    #
-    def page_should_not_contain(text_or_regexp)
-      if text_or_regexp.class == String
-        page_should_not_contain_text(text_or_regexp)
-      elsif text_or_regexp.class == Regexp
-        page_should_not_contain_regexp(text_or_regexp)
-      else
-        raise ArgumentError, "Expected String or Regexp, got #{text_or_regexp.class}"
-      end
-    end
-
-
-    # Ensure that the current page content includes a String.
-    #
-    # @param [String] text
-    #   Content you expect to be on the page
-    #
-    def page_should_contain_text(text)
-      if Kelp.driver == :capybara
-        if page.respond_to? :should
-          page.should have_content(text)
-        else
-          assert page.has_content?(text)
-        end
-      elsif Kelp.driver == :webrat
-        if defined?(Spec::Rails::Matchers)
-          response.should contain(text)
-        else
-          assert_contain text
-        end
-      else
-        raise NotImplementedError, "Unsupported driver: #{Kelp.driver}"
-      end
-    end
-
-
-    # Ensure that the current page content matches a Regexp.
-    #
-    # @param [Regexp] regexp
-    #   Content you expect to match
-    #
-    def page_should_contain_regexp(regexp)
-      if Kelp.driver == :capybara
-        if page.respond_to? :should
-          page.should have_xpath('.//*', :text => regexp)
-        else
-          assert page.has_xpath?('.//*', :text => regexp)
-        end
-      elsif Kelp.driver == :webrat
-        if defined?(Spec::Rails::Matchers)
-          response.should contain(regexp)
-        else
-          assert_match(regexp, response_body)
-        end
-      else
-        raise NotImplementedError, "Unsupported driver: #{Kelp.driver}"
-      end
-    end
-
-
-    # Ensure that the current page content does not include a String.
-    #
-    # @param [String] text
-    #   Content you expect to be missing from the page
-    #
-    def page_should_not_contain_text(text)
-      if Kelp.driver == :capybara
-        if page.respond_to? :should
-          page.should have_no_content(text)
-        else
-          assert page.has_no_content?(text)
-        end
-      elsif Kelp.driver == :webrat
-        if defined?(Spec::Rails::Matchers)
-          response.should_not contain(text)
-        else
-          hc = Webrat::Matchers::HasContent.new(text)
-          assert !hc.matches?(content), hc.negative_failure_message
-        end
-      else
-        raise NotImplementedError, "Unsupported driver: #{Kelp.driver}"
-      end
-    end
-
-
-    # Ensure that the current page content does not match a Regexp.
-    #
-    # @param [Regexp] regexp
-    #   Content you expect to fail matching
-    #
-    def page_should_not_contain_regexp(regexp)
-      if Kelp.driver == :capybara
-        if page.respond_to? :should
-          page.should have_no_xpath('.//*', :text => regexp)
-        else
-          assert page.has_no_xpath?('.//*', :text => regexp)
+        texts = [texts] if (texts.class == String || texts.class == Regexp)
+        # Select all unexpected values that do appear on the page
+        unexpected = texts.select do |text|
+          page_contains?(text)
         end
-      elsif Kelp.driver == :webrat
-        if defined?(Spec::Rails::Matchers)
-          response.should_not contain(regexp)
-        else
-          assert_not_contain(regexp)
+        if !unexpected.empty?
+          raise Kelp::Unexpected,
+            "Expected not to see: #{texts.inspect}\nDid see: #{unexpected.inspect}"
         end
-      else
-        raise NotImplementedError, "Unsupported driver: #{Kelp.driver}"
       end
     end
 
@@ -221,12 +106,13 @@ module Kelp
     # @param [Hash] scope
     #   Scoping keywords as understood by {#in_scope}
     #
+    # @raise [Kelp::Unexpected]
+    #   If no row is found containing all strings in `texts`
+    #
     def should_see_in_same_row(texts, scope={})
       in_scope(scope) do
-        if Kelp.driver == :capybara
-          page.should have_xpath(xpath_row_containing(texts))
-        elsif Kelp.driver == :webrat
-          raise NotImplementedError, "Not implemented yet"
+        if !page.has_xpath?(xpath_row_containing(texts))
+          raise Kelp::Unexpected, "Expected, but did not see: #{texts.inspect} in the same row"
         end
       end
     end
@@ -245,12 +131,13 @@ module Kelp
     # @param [Hash] scope
     #   Scoping keywords as understood by {#in_scope}
     #
+    # @raise [Kelp::Unexpected]
+    #   If a row is found containing all strings in `texts`
+    #
     def should_not_see_in_same_row(texts, scope={})
       in_scope(scope) do
-        if Kelp.driver == :capybara
-          page.should have_no_xpath(xpath_row_containing(texts))
-        elsif Kelp.driver == :webrat
-          raise NotImplementedError, "Not implemented yet"
+        if page.has_xpath?(xpath_row_containing(texts))
+          raise Kelp::Unexpected, "Did not expect, but did see: #{texts.inspect} in the same row"
         end
       end
     end
@@ -276,9 +163,7 @@ module Kelp
     def should_see_button(button_text, scope={})
       in_scope(scope) do
         xpath = XPath::HTML.button(button_text)
-        begin
-          page.should have_xpath(xpath)
-        rescue rspec_unexpected
+        if !page.has_xpath?(xpath)
           raise Kelp::Unexpected, "Expected to see button '#{button_text}', but button does not exist."
         end
       end
@@ -305,14 +190,114 @@ module Kelp
     def should_not_see_button(button_text, scope={})
       in_scope(scope) do
         xpath = XPath::HTML.button(button_text)
-        begin
-          page.should have_no_xpath(xpath)
-        rescue rspec_unexpected
+        if page.has_xpath?(xpath)
           raise Kelp::Unexpected, "Did not expect to see button '#{button_text}', but button exists."
         end
       end
     end
 
+
+    # -------------------------------------------------------------------
+    # DEPRECATED METHODS
+    # These will be removed in a future release of Kelp. Do not use them.
+    # -------------------------------------------------------------------
+
+
+    # Ensure that the current page content includes a String or Regexp.
+    #
+    # @deprecated
+    #   Use {#should_see} instead
+    #
+    # @param [String, Regexp] text_or_regexp
+    #   Content you expect to be on the page
+    #
+    def page_should_contain(text_or_regexp)
+      warn "WARNING: page_should_contain is deprecated. Use should_see instead."
+      if !page_contains?(text_or_regexp)
+        raise Kelp::Unexpected
+      end
+    end
+
+
+    # Ensure that the current page content does not include a String or Regexp.
+    #
+    # @deprecated
+    #   Use {#should_not_see} instead
+    #
+    # @param [String, Regexp] text_or_regexp
+    #   Content you expect to be missing from the page
+    #
+    def page_should_not_contain(text_or_regexp)
+      warn "WARNING: page_should_not_contain is deprecated. Use should_not_see instead."
+      if page_contains?(text_or_regexp)
+        raise Kelp::Unexpected
+      end
+    end
+
+
+    # Ensure that the current page content includes a String.
+    #
+    # @deprecated
+    #   Use {#should_see} instead
+    #
+    # @param [String] text
+    #   Content you expect to be on the page
+    #
+    def page_should_contain_text(text)
+      warn "WARNING: page_should_contain_text is deprecated. Use should_see instead."
+      if !page.has_content?(text)
+        raise Kelp::Unexpected
+      end
+    end
+
+
+    # Ensure that the current page content matches a Regexp.
+    #
+    # @deprecated
+    #   Use {#should_see} instead
+    #
+    # @param [Regexp] regexp
+    #   Content you expect to match
+    #
+    def page_should_contain_regexp(regexp)
+      warn "WARNING: page_should_contain_regexp is deprecated. Use should_see instead."
+      if !page.has_xpath?('.//*', :text => regexp)
+        raise Kelp::Unexpected
+      end
+    end
+
+
+    # Ensure that the current page content does not include a String.
+    #
+    # @deprecated
+    #   Use {#should_not_see} instead
+    #
+    # @param [String] text
+    #   Content you expect to be missing from the page
+    #
+    def page_should_not_contain_text(text)
+      warn "WARNING: page_should_not_contain_text is deprecated. Use should_not_see instead."
+      if page.has_content?(text)
+        raise Kelp::Unexpected
+      end
+    end
+
+
+    # Ensure that the current page content does not match a Regexp.
+    #
+    # @deprecated
+    #   Use {#should_not_see} instead
+    #
+    # @param [Regexp] regexp
+    #   Content you expect to fail matching
+    #
+    def page_should_not_contain_regexp(regexp)
+      warn "WARNING: page_should_not_contain_regexp is deprecated. Use should_not_see instead."
+      if page.has_xpath?('.//*', :text => regexp)
+        raise Kelp::Unexpected
+      end
+    end
+
   end
 end