rspec-html-matchers 0.8.0 → 0.9.3

data/lib/rspec-html-matchers/have_tag.rb

@@ -0,0 +1,274 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'nokogiri'
+
+module RSpecHtmlMatchers
+  # @api
+  # @private
+  class HaveTag # rubocop:disable Metrics/ClassLength
+    DESCRIPTIONS = {
+      :have_at_least_1 => %(have at least 1 element matching "%s"),
+      :have_n          => %(have %i element(s) matching "%s"),
+    }.freeze
+
+    MESSAGES = {
+      :expected_tag         => %(expected following:\n%s\nto #{DESCRIPTIONS[:have_at_least_1]}, found 0.),
+      :unexpected_tag       => %(expected following:\n%s\nto NOT have element matching "%s", found %s.),
+
+      :expected_count       => %(expected following:\n%s\nto #{DESCRIPTIONS[:have_n]}, found %s.),
+      :unexpected_count     => %(expected following:\n%s\nto NOT have %i element(s) matching "%s", but found.),
+
+      :expected_btw_count   => %(expected following:\n%s\nto have at least %i and at most %i element(s) matching "%s", found %i.),
+      :unexpected_btw_count => %(expected following:\n%s\nto NOT have at least %i and at most %i element(s) matching "%s", but found %i.),
+
+      :expected_at_most     => %(expected following:\n%s\nto have at most %i element(s) matching "%s", found %i.),
+      :unexpected_at_most   => %(expected following:\n%s\nto NOT have at most %i element(s) matching "%s", but found %i.),
+
+      :expected_at_least    => %(expected following:\n%s\nto have at least %i element(s) matching "%s", found %i.),
+      :unexpected_at_least  => %(expected following:\n%s\nto NOT have at least %i element(s) matching "%s", but found %i.),
+
+      :expected_blank       => %(expected following template to contain empty tag %s:\n%s),
+      :unexpected_blank     => %(expected following template to contain tag %s with other tags:\n%s),
+
+      :expected_regexp      => %(%s regexp expected within "%s" in following template:\n%s),
+      :unexpected_regexp    => %(%s regexp unexpected within "%s" in following template:\n%s\nbut was found.),
+
+      :expected_text        => %("%s" expected within "%s" in following template:\n%s),
+      :unexpected_text      => %("%s" unexpected within "%s" in following template:\n%s\nbut was found.),
+
+      :wrong_count_error    => %(:count with :minimum or :maximum has no sence!),
+      :min_max_error        => %(:minimum should be less than :maximum!),
+      :bad_range_error      => %(Your :count range(%s) has no sence!),
+    }.freeze
+
+    def initialize tag, options = {}, &block
+      @tag = tag.to_s
+      @options = options
+      @block = block
+
+      if with_attrs = @options.delete(:with)
+        if classes = with_attrs.delete(:class)
+          @tag += '.' + classes_to_selector(classes)
+        end
+        selector = with_attrs.inject('') do |html_attrs_string, (k, v)|
+          html_attrs_string += "[#{k}='#{v}']"
+          html_attrs_string
+        end
+        @tag += selector
+      end
+
+      if without_attrs = @options.delete(:without)
+        if classes = without_attrs.delete(:class)
+          @tag += ":not(.#{classes_to_selector(classes)})"
+        end
+      end
+
+      validate_options!
+      organize_options!
+    end
+
+    attr_reader :failure_message
+    attr_reader :failure_message_when_negated
+    attr_reader :current_scope
+
+    def matches? src, &block
+      @block = block if block
+
+      src = src.html if defined?(Capybara::Session) && src.is_a?(Capybara::Session)
+
+      case src
+      when String
+        parent_scope = Nokogiri::HTML::DocumentFragment.parse(src)
+        @document    = src
+      else
+        parent_scope  = src.current_scope
+        @document     = parent_scope.to_html
+      end
+
+      @current_scope = begin
+                         parent_scope.css(tag)
+                         # on jruby this produce exception if css was not found:
+                         # undefined method `decorate' for nil:NilClass
+                       rescue NoMethodError
+                         Nokogiri::XML::NodeSet.new(Nokogiri::XML::Document.new)
+                       end
+      if tag_presents? && proper_content? && count_right?
+        @block.call(self) if @block
+        true
+      else
+        false
+      end
+    end
+
+    def description
+      # TODO: should it be more complicated?
+      if options.key?(:count)
+        format(DESCRIPTIONS[:have_n], options[:count], tag)
+      else
+        DESCRIPTIONS[:have_at_least_1] % tag
+      end
+    end
+
+    private
+
+    attr_reader :tag
+    attr_reader :options
+    attr_reader :document
+
+    def classes_to_selector classes
+      case classes
+      when Array
+        classes.join('.')
+      when String
+        classes.gsub(/\s+/, '.')
+      end
+    end
+
+    def tag_presents?
+      if current_scope.first
+        @count = current_scope.count
+        match_succeeded! :unexpected_tag, document, tag, @count
+      else
+        match_failed! :expected_tag, document, tag
+      end
+    end
+
+    def count_right? # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      case options[:count]
+      when Integer
+        if @count == options[:count]
+          match_succeeded! :unexpected_count, document, @count, tag
+        else
+          match_failed! :expected_count, document, options[:count], tag, @count
+        end
+      when Range
+        if options[:count].member? @count
+          match_succeeded! :unexpected_btw_count, document, options[:count].min, options[:count].max, tag, @count
+        else
+          match_failed! :expected_btw_count, document, options[:count].min, options[:count].max, tag, @count
+        end
+      when nil
+        if options[:maximum]
+          if @count <= options[:maximum]
+            match_succeeded! :unexpected_at_most, document, options[:maximum], tag, @count
+          else
+            match_failed! :expected_at_most, document, options[:maximum], tag, @count
+          end
+        elsif options[:minimum]
+          if @count >= options[:minimum]
+            match_succeeded! :unexpected_at_least, document, options[:minimum], tag, @count
+          else
+            match_failed! :expected_at_least, document, options[:minimum], tag, @count
+          end
+        else
+          true
+        end
+      end
+    end
+
+    def proper_content?
+      if options.key?(:blank)
+        maybe_empty?
+      else
+        text_right?
+      end
+    end
+
+    def maybe_empty?
+      if options[:blank] && current_scope.children.empty?
+        match_succeeded! :unexpected_blank, tag, document
+      else
+        match_failed! :expected_blank, tag, document
+      end
+    end
+
+    def text_right?
+      return true unless options[:text]
+
+      case text = options[:text]
+      when Regexp
+        new_scope = current_scope.css(':regexp()', NokogiriRegexpHelper.new(text))
+        if new_scope.empty?
+          match_failed! :expected_regexp, text.inspect, tag, document
+        else
+          @count = new_scope.count
+          match_succeeded! :unexpected_regexp, text.inspect, tag, document
+        end
+      else
+        new_scope = current_scope.css(':content()', NokogiriTextHelper.new(text, options[:squeeze_text]))
+        if new_scope.empty?
+          match_failed! :expected_text, text, tag, document
+        else
+          @count = new_scope.count
+          match_succeeded! :unexpected_text, text, tag, document
+        end
+      end
+    end
+
+    def validate_options!
+      validate_text_options!
+      validate_count_presence!
+      validate_count_when_set_min_max!
+      validate_count_when_set_range!
+    end
+
+    def validate_text_options!
+      # TODO: test these options validations
+      if options.key?(:blank) && options[:blank] && options.key?(:text) # rubocop:disable Style/GuardClause, Style/IfUnlessModifier
+        raise ':text option is not accepted when :blank => true'
+      end
+    end
+
+    def validate_count_presence!
+      raise 'wrong :count specified' unless [Range, NilClass].include?(options[:count].class) || options[:count].is_a?(Integer)
+
+      [:min, :minimum, :max, :maximum].each do |key|
+        raise MESSAGES[:wrong_count_error] if options.key?(key) && options.key?(:count)
+      end
+    end
+
+    def validate_count_when_set_min_max!
+      raise MESSAGES[:min_max_error] if options[:minimum] > options[:maximum]
+    rescue NoMethodError # nil > 4 # rubocop:disable Lint/HandleExceptions
+    rescue ArgumentError # 2 < nil # rubocop:disable Lint/HandleExceptions
+    end
+
+    def validate_count_when_set_range!
+      begin
+        raise format(MESSAGES[:bad_range_error], options[:count].to_s) if count_is_range_but_no_min?
+      rescue ArgumentError, 'comparison of String with' # if options[:count] == 'a'..'z' # rubocop:disable Lint/RescueType
+        raise format(MESSAGES[:bad_range_error], options[:count].to_s)
+      end
+    rescue TypeError # fix for 1.8.7 for 'rescue ArgumentError, "comparison of String with"' stroke
+      raise format(MESSAGES[:bad_range_error], options[:count].to_s)
+    end
+
+    def count_is_range_but_no_min?
+      options[:count].is_a?(Range) &&
+        (options[:count].min.nil? || (options[:count].min < 0))
+    end
+
+    def organize_options!
+      @options[:minimum] ||= @options.delete(:min)
+      @options[:maximum] ||= @options.delete(:max)
+
+      @options[:text] = @options[:text].to_s if @options.key?(:text) && !@options[:text].is_a?(Regexp)
+
+      if @options.key?(:seen) && !@options[:seen].is_a?(Regexp) # rubocop:disable Style/GuardClause
+        @options[:text] = @options[:seen].to_s
+        @options[:squeeze_text] = true
+      end
+    end
+
+    def match_succeeded! message, *args
+      @failure_message_when_negated = format MESSAGES[message], *args
+      true
+    end
+
+    def match_failed! message, *args
+      @failure_message = format MESSAGES[message], *args
+      false
+    end
+  end
+end

data/lib/rspec-html-matchers/nokogiri_regexp_helper.rb

@@ -0,0 +1,17 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module RSpecHtmlMatchers
+  # @api
+  # @private
+  # for nokogiri regexp matching
+  class NokogiriRegexpHelper
+    def initialize regex
+      @regex = regex
+    end
+
+    def regexp node_set
+      node_set.find_all { |node| node.content =~ @regex }
+    end
+  end
+end

data/lib/rspec-html-matchers/nokogiri_text_helper.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module RSpecHtmlMatchers
+  # @api
+  # @private
+  class NokogiriTextHelper
+    NON_BREAKING_SPACE = "\u00a0"
+
+    def initialize text, squeeze_text = false
+      @text = text
+      @squeeze_text = squeeze_text
+    end
+
+    def content node_set
+      node_set.find_all do |node|
+        actual_content = node.content.gsub(NON_BREAKING_SPACE, ' ')
+        actual_content = node.content.gsub(/\s+/, ' ').strip if @squeeze_text
+
+        actual_content == @text
+      end
+    end
+  end
+end

data/lib/rspec-html-matchers/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RSpecHtmlMatchers
+  VERSION = '0.9.3'
+end

data/spec/form_matchers_spec.rb

@@ -1,299 +1,301 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "have_form" do
+describe 'have_form' do
   asset 'form'
 
-  context "without &block" do
-    it "should find form" do
+  context 'without &block' do
+    it 'should find form' do
       # sanity check
-      expect(rendered).to have_form("/books", :post)
-      expect(rendered).to have_form("/books", "post", with: { id: "new_book", class: %w(book formtastic) })
+      expect(rendered).to have_form('/books', :post)
+      expect(rendered).to have_form('/books', 'post', :with => { :id => 'new_book', :class => %w[book formtastic] })
     end
 
-    it "should not find form" do
-      expect(rendered).to_not have_form("/some_url", :post)
-      expect(rendered).to_not have_form("/books", :get)
+    it 'should not find form' do
+      expect(rendered).to_not have_form('/some_url', :post)
+      expect(rendered).to_not have_form('/books', :get)
     end
   end
 
-  context "with &block" do
-    context "with_select" do
-      it "should find select" do
-        expect(rendered).to have_form("/books", :post) do
-          with_select("book[publisher_id]", with: { id: "book_publisher_id" })
-          with_select("book[publisher_id]", with: { id: "book_publisher_id" })
+  context 'with &block' do
+    context 'with_select' do
+      it 'should find select' do
+        expect(rendered).to have_form('/books', :post) do
+          with_select('book[publisher_id]', :with => { :id => 'book_publisher_id' })
+          with_select('book[publisher_id]', :with => { :id => 'book_publisher_id' })
         end
       end
 
-      it "should not find select" do
-        expect(rendered).to have_form("/books", :post) do
-          without_select("book[publisher_id]", with: { id: "other_id" })
-          without_select("koob[publisher_id]", with: { id: "book_publisher_id" })
+      it 'should not find select' do
+        expect(rendered).to have_form('/books', :post) do
+          without_select('book[publisher_id]', :with => { :id => 'other_id' })
+          without_select('koob[publisher_id]', :with => { :id => 'book_publisher_id' })
         end
       end
 
-      context "with_option" do
-        it "should find options" do
-          expect(rendered).to have_form("/books", :post) do
-            with_select("book[publisher_id]") do
+      context 'with_option' do
+        it 'should find options' do
+          expect(rendered).to have_form('/books', :post) do
+            with_select('book[publisher_id]') do
               with_option(nil)
-              with_option("The Pragmatic Bookshelf", selected: true)
-              with_option(/sitepoint/,2)
-              with_option("O'Reilly", 3, selected: false)
+              with_option('The Pragmatic Bookshelf', :selected => true)
+              with_option(/sitepoint/, 2)
+              with_option("O'Reilly", 3, :selected => false)
             end
           end
         end
 
-        it "should not find options" do
-          expect(rendered).to have_form("/books", :post) do
-            with_select("book[publisher_id]") do
-              without_option("blah blah")
-              without_option("O'Reilly", 3, selected: true)
+        it 'should not find options' do
+          expect(rendered).to have_form('/books', :post) do
+            with_select('book[publisher_id]') do
+              without_option('blah blah')
+              without_option("O'Reilly", 3, :selected => true)
               without_option("O'Reilly", 100500)
             end
           end
         end
       end
 
-      context "with_button" do
-        it "should find button" do
-          expect(rendered).to have_form("/books", :post) do
-            with_button("Cancel Book")
+      context 'with_button' do
+        it 'should find button' do
+          expect(rendered).to have_form('/books', :post) do
+            with_button('Cancel Book')
           end
         end
 
-        it "should not find button" do
-          expect(rendered).to have_form("/books", :post) do
-            without_button("Create Book")
+        it 'should not find button' do
+          expect(rendered).to have_form('/books', :post) do
+            without_button('Create Book')
           end
         end
       end
     end
 
-    context "with_hidden_field" do
-      it "should find hidden field" do
-        expect(rendered).to have_form("/books", :post) do
-          with_hidden_field("authenticity_token")
-          with_hidden_field("authenticity_token", '718WaH76RAbIVhDlnOidgew62ikn8IUCOyWLEqjw1GE=')
+    context 'with_hidden_field' do
+      it 'should find hidden field' do
+        expect(rendered).to have_form('/books', :post) do
+          with_hidden_field('authenticity_token')
+          with_hidden_field('authenticity_token', '718WaH76RAbIVhDlnOidgew62ikn8IUCOyWLEqjw1GE=')
         end
       end
 
-      it "should not find hidden field" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find hidden field' do
+        expect(rendered).to have_form('/books', :post) do
           without_hidden_field('user_id')
           without_hidden_field('authenticity_token', 'blabla')
         end
       end
     end
 
-    context "with_text_field" do
-      it "should find text field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_text_field' do
+      it 'should find text field' do
+        expect(rendered).to have_form('/books', :post) do
           with_text_field('book[title]')
-          with_text_field('book[title]',nil)
-          with_text_field('book[author]','Authorname')
+          with_text_field('book[title]', nil)
+          with_text_field('book[author]', 'Authorname')
         end
       end
 
-      it "should not find text field" do
-        expect(rendered).to have_form("/books", :post) do
-          without_text_field('book[title]','title does not exist')
+      it 'should not find text field' do
+        expect(rendered).to have_form('/books', :post) do
+          without_text_field('book[title]', 'title does not exist')
           without_text_field('book[authoRR]')
           without_text_field('book[blabla]')
         end
       end
     end
 
-    context "with_email_field" do
-      it "should find email field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_email_field' do
+      it 'should find email field' do
+        expect(rendered).to have_form('/books', :post) do
           with_email_field('user[email]')
           with_email_field('user[email]', 'email@example.com')
           with_email_field('user[email_confirmation]', nil)
         end
       end
 
-      it "should not find email field" do
-        expect(rendered).to have_form("/books", :post) do
-          without_email_field('book[author]','Authorname')
+      it 'should not find email field' do
+        expect(rendered).to have_form('/books', :post) do
+          without_email_field('book[author]', 'Authorname')
           without_email_field('user[emaiL]')
           without_email_field('user[apocalyptiq]')
         end
       end
     end
 
-    context "with_url_field" do
-      it "should find url field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_url_field' do
+      it 'should find url field' do
+        expect(rendered).to have_form('/books', :post) do
           with_url_field('user[url]')
           with_url_field('user[url]', 'http://user.com')
         end
       end
 
-      it "should not find url field" do
-        expect(rendered).to have_form("/books", :post) do
-          without_url_field('user[url]','Authorname')
+      it 'should not find url field' do
+        expect(rendered).to have_form('/books', :post) do
+          without_url_field('user[url]', 'Authorname')
           without_url_field('user[emaiL]')
           without_url_field('user[apocalyptiq]')
         end
       end
     end
 
-    context "with_number_field" do
-      it "should find number field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_number_field' do
+      it 'should find number field' do
+        expect(rendered).to have_form('/books', :post) do
           with_number_field('number')
           with_number_field('number_defined', 3)
           with_number_field('number_defined', '3')
         end
       end
 
-      it "should not find number field" do
-        expect(rendered).to have_form("/books", :post) do
-          without_number_field('number',400)
-          without_number_field('number','400')
+      it 'should not find number field' do
+        expect(rendered).to have_form('/books', :post) do
+          without_number_field('number', 400)
+          without_number_field('number', '400')
           without_number_field('user[emaiL]')
           without_number_field('user[apocalyptiq]')
         end
       end
     end
 
-    context "with_range_field" do
-      it "should find range field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_range_field' do
+      it 'should find range field' do
+        expect(rendered).to have_form('/books', :post) do
           with_range_field('range1', 1, 3)
-          with_range_field('range1','1','3')
-          with_range_field('range2', 1, 3, with: { value: 2 } )
-          with_range_field('range2', 1, 3, with: { value: '2' } )
+          with_range_field('range1', '1', '3')
+          with_range_field('range2', 1, 3, :with => { :value => 2 })
+          with_range_field('range2', 1, 3, :with => { :value => '2' })
         end
       end
 
-      it "should not find range field" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find range field' do
+        expect(rendered).to have_form('/books', :post) do
           without_range_field('number')
           without_range_field('range1', 1, 5)
-          without_range_field('range2', 1, 3, with: { value: 5 } )
+          without_range_field('range2', 1, 3, :with => { :value => 5 })
         end
       end
     end
 
-    context "with_date_field" do
-      it "should find date field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_date_field' do
+      it 'should find date field' do
+        expect(rendered).to have_form('/books', :post) do
           with_date_field(:date)
           with_date_field(:date, 'book_date')
-          with_date_field(:month, 'book_month', with: { value: 5 })
-          with_date_field(:week,'book_week')
+          with_date_field(:month, 'book_month', :with => { :value => 5 })
+          with_date_field(:week, 'book_week')
           with_date_field(:time, 'book_time')
           with_date_field(:datetime, 'book_datetime')
           with_date_field('datetime-local', 'book_datetime_local')
         end
       end
 
-      it "should not find date field" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find date field' do
+        expect(rendered).to have_form('/books', :post) do
           without_date_field(:date, 'book_something')
-          without_date_field(:month, 'book_month', with: { value: 100500 })
+          without_date_field(:month, 'book_month', :with => { :value => 100500 })
         end
       end
 
-      it "should raise exception if wrong date field type specified" do
+      it 'should raise exception if wrong date field type specified' do
         expect do
-          expect(rendered).to have_form("/books", :post) do
+          expect(rendered).to have_form('/books', :post) do
             without_date_field(:unknown, 'book_something')
           end
         end.to raise_error('unknown type `unknown` for date picker')
         expect do
-          expect(rendered).to have_form("/books", :post) do
+          expect(rendered).to have_form('/books', :post) do
             with_date_field(:unknown, 'book_something')
           end
         end.to raise_error('unknown type `unknown` for date picker')
       end
     end
 
-    context "with_password_field" do
-      it "should find password field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_password_field' do
+      it 'should find password field' do
+        expect(rendered).to have_form('/books', :post) do
           with_password_field('user[password]')
         end
       end
 
-      it "should not find password field" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find password field' do
+        expect(rendered).to have_form('/books', :post) do
           without_password_field('account[password]')
         end
       end
     end
 
-    context "with_file_field" do
-      it "should find file field" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_file_field' do
+      it 'should find file field' do
+        expect(rendered).to have_form('/books', :post) do
           with_file_field('form[file]')
         end
       end
 
-      it "should not find file field" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find file field' do
+        expect(rendered).to have_form('/books', :post) do
           without_file_field('user[file]')
         end
       end
     end
 
-    context "with_text_area" do
-      it "should find text area" do
-        expect(rendered).to have_form("/books", :post) do
+    context 'with_text_area' do
+      it 'should find text area' do
+        expect(rendered).to have_form('/books', :post) do
           with_text_area('book[description]')
         end
       end
 
-      it "should not find text area" do
-        expect(rendered).to have_form("/books", :post) do
+      it 'should not find text area' do
+        expect(rendered).to have_form('/books', :post) do
           without_text_area('user[bio]')
         end
       end
     end
 
-    context "with_check_box" do
-      it "should find check box" do
-        expect(rendered).to have_form("/books", :post) do
-          with_checkbox("book[still_in_print]")
-          with_checkbox("book[still_in_print]","1")
+    context 'with_check_box' do
+      it 'should find check box' do
+        expect(rendered).to have_form('/books', :post) do
+          with_checkbox('book[still_in_print]')
+          with_checkbox('book[still_in_print]', '1')
         end
       end
 
-      it "should not find check box" do
-        expect(rendered).to have_form("/books", :post) do
-          without_checkbox("book[book]")
-          without_checkbox("book[still_in_print]","500")
+      it 'should not find check box' do
+        expect(rendered).to have_form('/books', :post) do
+          without_checkbox('book[book]')
+          without_checkbox('book[still_in_print]', '500')
         end
       end
     end
 
-    context "with_radio_button" do
-      it "should find radio button" do
-        expect(rendered).to have_form("/books", :post) do
-          with_radio_button("form[name]","true")
+    context 'with_radio_button' do
+      it 'should find radio button' do
+        expect(rendered).to have_form('/books', :post) do
+          with_radio_button('form[name]', 'true')
         end
       end
 
-      it "should not find radio button" do
-        expect(rendered).to have_form("/books", :post) do
-          without_radio_button("form[name]","100500")
-          without_radio_button("form[item]","false")
+      it 'should not find radio button' do
+        expect(rendered).to have_form('/books', :post) do
+          without_radio_button('form[name]', '100500')
+          without_radio_button('form[item]', 'false')
         end
       end
     end
 
-    context "with_submit" do
-      it "should find submit" do
-        expect(rendered).to have_form("/books", :post) do
-          with_submit("Create Book")
+    context 'with_submit' do
+      it 'should find submit' do
+        expect(rendered).to have_form('/books', :post) do
+          with_submit('Create Book')
         end
       end
 
-      it "should not find submit" do
-        expect(rendered).to have_form("/books", :post) do
-          without_submit("Destroy Book")
+      it 'should not find submit' do
+        expect(rendered).to have_form('/books', :post) do
+          without_submit('Destroy Book')
         end
       end
     end