ronin-exploits 1.0.0.beta1 → 1.0.0.beta3

data/spec/mixins/html_spec.rb

@@ -1,772 +0,0 @@
-require 'spec_helper'
-require 'ronin/exploits/mixins/html'
-
-require 'ronin/exploits/exploit'
-
-describe Ronin::Exploits::Mixins::HTML do
-  module TestHTMLMixin
-    class TestExploit < Ronin::Exploits::Exploit
-      include Ronin::Exploits::Mixins::HTML
-    end
-  end
-
-  let(:test_exploit) { TestHTMLMixin::TestExploit }
-  subject { test_exploit.new }
-
-  describe "#attr_name" do
-    let(:name) { 'foo' }
-
-    it "must return the name as is" do
-      expect(subject.attr_name(name)).to eq(name)
-    end
-
-    context "when given a Symbol" do
-      let(:name) { :foo }
-
-      it "must return the String version of the Symbol" do
-        expect(subject.attr_name(name)).to eq(name.to_s)
-      end
-    end
-
-    context "when given `name_case: :lower`" do
-      let(:name) { 'FOO' }
-
-      it "must convert the name to lower-case" do
-        expect(subject.attr_name(name, name_case: :lower)).to eq(name.downcase)
-      end
-    end
-
-    context "when given `name_case: :upper`" do
-      it "must convert the name to upper-case" do
-        expect(subject.attr_name(name, name_case: :upper)).to eq(name.upcase)
-      end
-    end
-
-    context "when given `name_case: :random`" do
-      it "must randomize the case of the name" do
-        expect(subject.attr_name(name, name_case: :random)).to match(
-          /\A(?:Foo|fOo|foO|FOo|FoO|fOO|FOO)\z/
-        )
-      end
-    end
-  end
-
-  describe "#attr" do
-    let(:name)  { 'foo' }
-    let(:value) { 'bar' }
-
-    it "must return name=\"value\"" do
-      expect(subject.attr(name,value)).to eq("#{name}=\"#{value}\"")
-    end
-
-    context "when given a Symbol for the name" do
-      let(:name) { :foo }
-
-      it "must accept a Symbol for the name" do
-        expect(subject.attr(name,value)).to eq("#{name}=\"#{value}\"")
-      end
-    end
-
-    context "when given a non-String for the value" do
-      let(:value) { 42 }
-
-      it "must accept a non-String for the value" do
-        expect(subject.attr(name,value)).to eq("#{name}=\"#{value}\"")
-      end
-    end
-
-    context "when given `name_case: :lower`" do
-      let(:name) { 'FOO' }
-
-      it "must convert the name to lower-case" do
-        expect(subject.attr(name,value, name_case: :lower)).to eq(
-          "#{name.downcase}=\"#{value}\""
-        )
-      end
-    end
-
-    context "when given `name_case: :upper`" do
-      it "must convert the name to upper-case" do
-        expect(subject.attr(name,value, name_case: :upper)).to eq(
-          "#{name.upcase}=\"#{value}\""
-        )
-      end
-    end
-
-    context "when given `name_case: :random`" do
-      it "must randomize the case of the name" do
-        expect(subject.attr(name,value, name_case: :random)).to match(
-          /\A(?:Foo|fOo|foO|FOo|FoO|fOO|FOO)=\"#{value}\"\z/
-        )
-      end
-    end
-
-    context "when given `quote: double`" do
-      it "must quote the value with double quotes" do
-        expect(subject.attr(name,value, quote: :double)).to eq(
-          "#{name}=\"#{value}\""
-        )
-      end
-
-      context "and when the value contains a double quote" do
-        let(:value) { "bar\"baz" }
-
-        it "must replace any double quotes with &quot;" do
-          expect(subject.attr(name,value)).to eq("#{name}=\"bar&quot;baz\"")
-        end
-      end
-    end
-
-    context "when given `quote: single`" do
-      it "must quote the value with single quotes" do
-        expect(subject.attr(name,value, quote: :single)).to eq(
-          "#{name}='#{value}'"
-        )
-      end
-
-      context "and when the value contains a single quote" do
-        let(:value) { "bar'baz" }
-
-        it "must replace any double quotes with &#39;;" do
-          expect(subject.attr(name,value, quote: :single)).to eq(
-            "#{name}='bar&#39;baz'"
-          )
-        end
-      end
-    end
-
-    context "when given `quote: backtick`" do
-      it "must quote the value with backticks" do
-        expect(subject.attr(name,value, quote: :backtick)).to eq(
-          "#{name}=`#{value}`"
-        )
-      end
-    end
-
-    context "when given `quote: nil`" do
-      it "must not quote the value" do
-        expect(subject.attr(name,value, quote: nil)).to eq(
-          "#{name}=#{value}"
-        )
-      end
-
-      context "and when the value contains a space" do
-        let(:value) { "bar baz" }
-
-        it "must replace any spaces with &#nbsp;;" do
-          expect(subject.attr(name,value, quote: nil)).to eq(
-            "#{name}=bar&nbsp;baz"
-          )
-        end
-      end
-    end
-  end
-
-  describe "#attr_list" do
-    let(:name1)  { 'foo' }
-    let(:value1) { 'bar' }
-    let(:name2)  { 'baz' }
-    let(:value2) { 'qux' }
-    let(:attrs)  { {name1 => value1, name2 => value2} }
-
-    it "must return name=\"value\" ..." do
-      expect(subject.attr_list(attrs)).to eq(
-        "#{name1}=\"#{value1}\" #{name2}=\"#{value2}\""
-      )
-    end
-
-    context "when the attributes have Symbol names" do
-      let(:name1) { :foo }
-      let(:name2) { :baz }
-
-      it "must accept Symbols for attribute names" do
-        expect(subject.attr_list(attrs)).to eq(
-          "#{name1}=\"#{value1}\" #{name2}=\"#{value2}\""
-        )
-      end
-    end
-
-    context "when the attributes contains non-String values" do
-      let(:value1) { 42   }
-      let(:value2) { :qux }
-
-      it "must accept non-Strings for attribute values" do
-        expect(subject.attr_list(attrs)).to eq(
-          "#{name1}=\"#{value1}\" #{name2}=\"#{value2}\""
-        )
-      end
-    end
-
-    context "when given `name_case: :lower`" do
-      let(:name1) { 'FOO' }
-      let(:name2) { 'BAZ' }
-
-      it "must convert the attribute names to lower-case" do
-        expect(subject.attr_list(attrs, name_case: :lower)).to eq(
-          "#{name1.downcase}=\"#{value1}\" #{name2.downcase}=\"#{value2}\""
-        )
-      end
-    end
-
-    context "when given `name_case: :upper`" do
-      it "must convert the attribute names to upper-case" do
-        expect(subject.attr_list(attrs, name_case: :upper)).to eq(
-          "#{name1.upcase}=\"#{value1}\" #{name2.upcase}=\"#{value2}\""
-        )
-      end
-    end
-
-    context "when given `name_case: :random`" do
-      it "must randomize the case of each attribute name" do
-        expect(subject.attr_list(attrs, name_case: :random)).to match(
-          /\A(?:Foo|fOo|foO|FOo|FoO|fOO|FOO)=\"#{value1}\" (?:Baz|bAz|baZ|BAz|BaZ|bAZ|BAZ)=\"#{value2}\"\z/
-        )
-      end
-    end
-
-    context "when given `quote: double`" do
-      it "must quote the attribute values with double quotes" do
-        expect(subject.attr_list(attrs, quote: :double)).to eq(
-          "#{name1}=\"#{value1}\" #{name2}=\"#{value2}\""
-        )
-      end
-
-      context "and when an attribute value contains a double quote" do
-        let(:value1) { "bar\"baz" }
-
-        it "must replace any double quotes with &quot;" do
-          expect(subject.attr_list(attrs)).to eq(
-            "#{name1}=\"bar&quot;baz\" #{name2}=\"#{value2}\""
-          )
-        end
-      end
-    end
-
-    context "when given `quote: single`" do
-      it "must quote the attribute values with single quotes" do
-        expect(subject.attr_list(attrs, quote: :single)).to eq(
-          "#{name1}='#{value1}' #{name2}='#{value2}'"
-        )
-      end
-
-      context "and when an attribute value contains a single quote" do
-        let(:value1) { "bar'baz" }
-
-        it "must replace any double quotes with &#39;;" do
-          expect(subject.attr_list(attrs, quote: :single)).to eq(
-            "#{name1}='bar&#39;baz' #{name2}='#{value2}'"
-          )
-        end
-      end
-    end
-
-    context "when given `quote: backtick`" do
-      it "must quote the attribute values with backticks" do
-        expect(subject.attr_list(attrs, quote: :backtick)).to eq(
-          "#{name1}=`#{value1}` #{name2}=`#{value2}`"
-        )
-      end
-    end
-
-    context "when given `quote: nil`" do
-      it "must not quote the attribute values" do
-        expect(subject.attr_list(attrs, quote: nil)).to eq(
-          "#{name1}=#{value1} #{name2}=#{value2}"
-        )
-      end
-
-      context "and when the value contains a space" do
-        let(:value1) { "bar baz" }
-
-        it "must replace any spaces with &#nbsp;;" do
-          expect(subject.attr_list(attrs, quote: nil)).to eq(
-            "#{name1}=bar&nbsp;baz #{name2}=#{value2}"
-          )
-        end
-      end
-    end
-  end
-
-  describe "#tag_name" do
-    let(:name) { 'foo' }
-
-    it "must return the name as is" do
-      expect(subject.tag_name(name)).to eq(name)
-    end
-
-    context "when given a Symbol" do
-      let(:name) { :foo }
-
-      it "must return the String version of the Symbol" do
-        expect(subject.tag_name(name)).to eq(name.to_s)
-      end
-    end
-
-    context "when given `name_case: :lower`" do
-      let(:name) { 'FOO' }
-
-      it "must convert the name to lower-case" do
-        expect(subject.tag_name(name, name_case: :lower)).to eq(name.downcase)
-      end
-    end
-
-    context "when given `name_case: :upper`" do
-      it "must convert the name to upper-case" do
-        expect(subject.tag_name(name, name_case: :upper)).to eq(name.upcase)
-      end
-    end
-
-    context "when given `name_case: :random`" do
-      it "must randomize the case of the name" do
-        expect(subject.tag_name(name, name_case: :random)).to match(
-          /\A(?:Foo|fOo|foO|FOo|FoO|fOO|FOO)\z/
-        )
-      end
-    end
-  end
-
-  describe "#tag" do
-    let(:name) { 'div' }
-
-    context "when no block or the `text:` keyword argument is given" do
-      it "must return <name/>" do
-        expect(subject.tag(name)).to eq("<#{name}/>")
-      end
-
-      context "when given a Symbol" do
-        let(:name) { :div }
-
-        it "must return the String version of the Symbol" do
-          expect(subject.tag(name)).to eq("<#{name}/>")
-        end
-      end
-
-      context "when given `tag_case: :lower`" do
-        let(:name) { 'DIV' }
-
-        it "must convert the name to lower-case" do
-          expect(subject.tag(name, tag_case: :lower)).to eq("<#{name.downcase}/>")
-        end
-      end
-
-      context "when given `tag_case: :upper`" do
-        it "must convert the name to upper-case" do
-          expect(subject.tag(name, tag_case: :upper)).to eq("<#{name.upcase}/>")
-        end
-      end
-
-      context "when given `tag_case: :random`" do
-        it "must randomize the case of the name" do
-          expect(subject.tag(name, tag_case: :random)).to match(
-            /\A<(?:Div|dIv|diV|DIv|DiV|dIV|DIV)\/>\z/
-          )
-        end
-      end
-
-      context "when additional attributes are given" do
-        let(:attr1)  { :foo  }
-        let(:value1) { 'bar' }
-        let(:attr2)  { :baz  }
-        let(:value2) { 'qux' }
-        let(:attrs) do
-          {attr1 => value1, attr2 => value2}
-        end
-
-        it "must add an attributes list after the tag name" do
-          expect(subject.tag(name,**attrs)).to eq("<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\"/>")
-        end
-
-        context "when given `attr_case: :lower`" do
-          let(:attr1) { :FOO }
-          let(:attr2) { :BAZ }
-
-          it "must convert the attribute names to lower-case" do
-            expect(subject.tag(name, **attrs, attr_case: :lower)).to eq(
-              "<#{name} #{attr1.downcase}=\"#{value1}\" #{attr2.downcase}=\"#{value2}\"/>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :upper`" do
-          it "must convert the attribute names to upper-case" do
-            expect(subject.tag(name, **attrs, attr_case: :upper)).to eq(
-              "<#{name} #{attr1.upcase}=\"#{value1}\" #{attr2.upcase}=\"#{value2}\"/>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :random`" do
-          it "must randomize the case of each attribute name" do
-            expect(subject.tag(name, **attrs, attr_case: :random)).to match(
-              /\A<#{name} (?:Foo|fOo|foO|FOo|FoO|fOO|FOO)=\"#{value1}\" (?:Baz|bAz|baZ|BAz|BaZ|bAZ|BAZ)=\"#{value2}\"\/>\z/
-            )
-          end
-        end
-
-        context "when given `attr_quote: double`" do
-          it "must quote the attribute values with double quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :double)).to eq(
-              "<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\"/>"
-            )
-          end
-
-          context "and when an attribute value contains a double quote" do
-            let(:value1) { "bar\"baz" }
-
-            it "must replace any double quotes with &quot;" do
-              expect(subject.tag(name, **attrs)).to eq(
-                "<#{name} #{attr1}=\"bar&quot;baz\" #{attr2}=\"#{value2}\"/>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: single`" do
-          it "must quote the attribute values with single quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :single)).to eq(
-              "<#{name} #{attr1}='#{value1}' #{attr2}='#{value2}'/>"
-            )
-          end
-
-          context "and when an attribute value contains a single quote" do
-            let(:value1) { "bar'baz" }
-
-            it "must replace any double quotes with &#39;;" do
-              expect(subject.tag(name, **attrs, attr_quote: :single)).to eq(
-                "<#{name} #{attr1}='bar&#39;baz' #{attr2}='#{value2}'/>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: :backtick`" do
-          it "must quote the attribute values with backticks" do
-            expect(subject.tag(name, **attrs, attr_quote: :backtick)).to eq(
-              "<#{name} #{attr1}=`#{value1}` #{attr2}=`#{value2}`/>"
-            )
-          end
-        end
-
-        context "when given `attr_quote: nil`" do
-          it "must not quote the attribute values" do
-            expect(subject.tag(name, **attrs, attr_quote: nil)).to eq(
-              "<#{name} #{attr1}=#{value1} #{attr2}=#{value2}/>"
-            )
-          end
-
-          context "and when the value contains a space" do
-            let(:value1) { "bar baz" }
-
-            it "must replace any spaces with &#nbsp;;" do
-              expect(subject.tag(name, **attrs, attr_quote: nil)).to eq(
-                "<#{name} #{attr1}=bar&nbsp;baz #{attr2}=#{value2}/>"
-              )
-            end
-          end
-        end
-      end
-    end
-
-    context "when given the `text:` keyword argument" do
-      let(:inner_text) { 'loren ipsum' }
-
-      it "must return <name>...</name>" do
-        expect(subject.tag(name, text: inner_text)).to eq(
-          "<#{name}>#{inner_text}</#{name}>"
-        )
-      end
-
-      context "when given a Symbol" do
-        let(:name) { :div }
-
-        it "must return the String version of the Symbol" do
-          expect(subject.tag(name, text: inner_text)).to eq(
-            "<#{name}>#{inner_text}</#{name}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :lower`" do
-        let(:name) { 'DIV' }
-
-        it "must convert the tag names to lower-case" do
-          expect(subject.tag(name, tag_case: :lower, text: inner_text)).to eq(
-            "<#{name.downcase}>#{inner_text}</#{name.downcase}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :upper`" do
-        it "must convert the tag names to upper-case" do
-          expect(subject.tag(name, tag_case: :upper, text: inner_text)).to eq(
-            "<#{name.upcase}>#{inner_text}</#{name.upcase}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :random`" do
-        it "must randomize the case of the tag names" do
-          expect(subject.tag(name, tag_case: :random, text: inner_text)).to match(
-            /\A<(?:Div|dIv|diV|DIv|DiV|dIV|DIV)>#{inner_text}<\/(?:Div|dIv|diV|DIv|DiV|dIV|DIV)>\z/
-          )
-        end
-      end
-
-      context "when additional attributes are given" do
-        let(:attr1)  { :foo  }
-        let(:value1) { 'bar' }
-        let(:attr2)  { :baz  }
-        let(:value2) { 'qux' }
-        let(:attrs) do
-          {attr1 => value1, attr2 => value2}
-        end
-
-        it "must add an attributes list after the tag name" do
-          expect(subject.tag(name,**attrs, text: inner_text)).to eq(
-            "<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\">#{inner_text}</#{name}>"
-          )
-        end
-
-        context "when given `attr_case: :lower`" do
-          let(:attr1) { :FOO }
-          let(:attr2) { :BAZ }
-
-          it "must convert the attribute names to lower-case" do
-            expect(subject.tag(name, **attrs, attr_case: :lower, text: inner_text)).to eq(
-              "<#{name} #{attr1.downcase}=\"#{value1}\" #{attr2.downcase}=\"#{value2}\">#{inner_text}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :upper`" do
-          it "must convert the attribute names to upper-case" do
-            expect(subject.tag(name, **attrs, attr_case: :upper, text: inner_text)).to eq(
-              "<#{name} #{attr1.upcase}=\"#{value1}\" #{attr2.upcase}=\"#{value2}\">#{inner_text}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :random`" do
-          it "must randomize the case of each attribute name" do
-            expect(subject.tag(name, **attrs, attr_case: :random, text: inner_text)).to match(
-              /\A<#{name} (?:Foo|fOo|foO|FOo|FoO|fOO|FOO)=\"#{value1}\" (?:Baz|bAz|baZ|BAz|BaZ|bAZ|BAZ)=\"#{value2}\">#{inner_text}<\/#{name}>\z/
-            )
-          end
-        end
-
-        context "when given `attr_quote: double`" do
-          it "must quote the attribute values with double quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :double, text: inner_text)).to eq(
-              "<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\">#{inner_text}</#{name}>"
-            )
-          end
-
-          context "and when an attribute value contains a double quote" do
-            let(:value1) { "bar\"baz" }
-
-            it "must replace any double quotes with &quot;" do
-              expect(subject.tag(name, **attrs, text: inner_text)).to eq(
-                "<#{name} #{attr1}=\"bar&quot;baz\" #{attr2}=\"#{value2}\">#{inner_text}</#{name}>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: single`" do
-          it "must quote the attribute values with single quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :single, text: inner_text)).to eq(
-              "<#{name} #{attr1}='#{value1}' #{attr2}='#{value2}'>#{inner_text}</#{name}>"
-            )
-          end
-
-          context "and when an attribute value contains a single quote" do
-            let(:value1) { "bar'baz" }
-
-            it "must replace any double quotes with &#39;;" do
-              expect(subject.tag(name, **attrs, attr_quote: :single, text: inner_text)).to eq(
-                "<#{name} #{attr1}='bar&#39;baz' #{attr2}='#{value2}'>#{inner_text}</#{name}>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: :backtick`" do
-          it "must quote the attribute values with backticks" do
-            expect(subject.tag(name, **attrs, attr_quote: :backtick, text: inner_text)).to eq(
-              "<#{name} #{attr1}=`#{value1}` #{attr2}=`#{value2}`>#{inner_text}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_quote: nil`" do
-          it "must not quote the attribute values" do
-            expect(subject.tag(name, **attrs, attr_quote: nil, text: inner_text)).to eq(
-              "<#{name} #{attr1}=#{value1} #{attr2}=#{value2}>#{inner_text}</#{name}>"
-            )
-          end
-
-          context "and when the value contains a space" do
-            let(:value1) { "bar baz" }
-
-            it "must replace any spaces with &#nbsp;;" do
-              expect(subject.tag(name, **attrs, attr_quote: nil, text: inner_text)).to eq(
-                "<#{name} #{attr1}=bar&nbsp;baz #{attr2}=#{value2}>#{inner_text}</#{name}>"
-              )
-            end
-          end
-        end
-      end
-    end
-
-    context "when given a block" do
-      let(:inner_html) { '<a href="http://example.com/>link</a>' }
-
-      it "must return <name>...</name>" do
-        expect(subject.tag(name) { inner_html }).to eq(
-          "<#{name}>#{inner_html}</#{name}>"
-        )
-      end
-
-      context "when given a Symbol" do
-        let(:name) { :div }
-
-        it "must return the String version of the Symbol" do
-          expect(subject.tag(name) { inner_html }).to eq(
-            "<#{name}>#{inner_html}</#{name}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :lower`" do
-        let(:name) { 'DIV' }
-
-        it "must convert the tag names to lower-case" do
-          expect(subject.tag(name, tag_case: :lower) { inner_html }).to eq(
-            "<#{name.downcase}>#{inner_html}</#{name.downcase}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :upper`" do
-        it "must convert the tag names to upper-case" do
-          expect(subject.tag(name, tag_case: :upper) { inner_html }).to eq(
-            "<#{name.upcase}>#{inner_html}</#{name.upcase}>"
-          )
-        end
-      end
-
-      context "when given `tag_case: :random`" do
-        it "must randomize the case of the tag names" do
-          expect(subject.tag(name, tag_case: :random) { inner_html }).to match(
-            /\A<(?:Div|dIv|diV|DIv|DiV|dIV|DIV)>#{inner_html}<\/(?:Div|dIv|diV|DIv|DiV|dIV|DIV)>\z/
-          )
-        end
-      end
-
-      context "when additional attributes are given" do
-        let(:attr1)  { :foo  }
-        let(:value1) { 'bar' }
-        let(:attr2)  { :baz  }
-        let(:value2) { 'qux' }
-        let(:attrs) do
-          {attr1 => value1, attr2 => value2}
-        end
-
-        it "must add an attributes list after the tag name" do
-          expect(subject.tag(name,**attrs) { inner_html }).to eq(
-            "<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\">#{inner_html}</#{name}>"
-          )
-        end
-
-        context "when given `attr_case: :lower`" do
-          let(:attr1) { :FOO }
-          let(:attr2) { :BAZ }
-
-          it "must convert the attribute names to lower-case" do
-            expect(subject.tag(name, **attrs, attr_case: :lower) { inner_html }).to eq(
-              "<#{name} #{attr1.downcase}=\"#{value1}\" #{attr2.downcase}=\"#{value2}\">#{inner_html}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :upper`" do
-          it "must convert the attribute names to upper-case" do
-            expect(subject.tag(name, **attrs, attr_case: :upper) { inner_html }).to eq(
-              "<#{name} #{attr1.upcase}=\"#{value1}\" #{attr2.upcase}=\"#{value2}\">#{inner_html}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_case: :random`" do
-          it "must randomize the case of each attribute name" do
-            expect(subject.tag(name, **attrs, attr_case: :random) { inner_html }).to match(
-              /\A<#{name} (?:Foo|fOo|foO|FOo|FoO|fOO|FOO)=\"#{value1}\" (?:Baz|bAz|baZ|BAz|BaZ|bAZ|BAZ)=\"#{value2}\">#{inner_html}<\/#{name}>\z/
-            )
-          end
-        end
-
-        context "when given `attr_quote: double`" do
-          it "must quote the attribute values with double quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :double) { inner_html }).to eq(
-              "<#{name} #{attr1}=\"#{value1}\" #{attr2}=\"#{value2}\">#{inner_html}</#{name}>"
-            )
-          end
-
-          context "and when an attribute value contains a double quote" do
-            let(:value1) { "bar\"baz" }
-
-            it "must replace any double quotes with &quot;" do
-              expect(subject.tag(name, **attrs) { inner_html }).to eq(
-                "<#{name} #{attr1}=\"bar&quot;baz\" #{attr2}=\"#{value2}\">#{inner_html}</#{name}>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: single`" do
-          it "must quote the attribute values with single quotes" do
-            expect(subject.tag(name, **attrs, attr_quote: :single) { inner_html }).to eq(
-              "<#{name} #{attr1}='#{value1}' #{attr2}='#{value2}'>#{inner_html}</#{name}>"
-            )
-          end
-
-          context "and when an attribute value contains a single quote" do
-            let(:value1) { "bar'baz" }
-
-            it "must replace any double quotes with &#39;;" do
-              expect(subject.tag(name, **attrs, attr_quote: :single) { inner_html }).to eq(
-                "<#{name} #{attr1}='bar&#39;baz' #{attr2}='#{value2}'>#{inner_html}</#{name}>"
-              )
-            end
-          end
-        end
-
-        context "when given `attr_quote: :backtick`" do
-          it "must quote the attribute values with backticks" do
-            expect(subject.tag(name, **attrs, attr_quote: :backtick) { inner_html }).to eq(
-              "<#{name} #{attr1}=`#{value1}` #{attr2}=`#{value2}`>#{inner_html}</#{name}>"
-            )
-          end
-        end
-
-        context "when given `attr_quote: nil`" do
-          it "must not quote the attribute values" do
-            expect(subject.tag(name, **attrs, attr_quote: nil) { inner_html }).to eq(
-              "<#{name} #{attr1}=#{value1} #{attr2}=#{value2}>#{inner_html}</#{name}>"
-            )
-          end
-
-          context "and when the value contains a space" do
-            let(:value1) { "bar baz" }
-
-            it "must replace any spaces with &#nbsp;;" do
-              expect(subject.tag(name, **attrs, attr_quote: nil) { inner_html }).to eq(
-                "<#{name} #{attr1}=bar&nbsp;baz #{attr2}=#{value2}>#{inner_html}</#{name}>"
-              )
-            end
-          end
-        end
-      end
-    end
-  end
-end