ronin-exploits 0.3.1 → 1.0.0.beta2

data/spec/mixins/html_spec.rb

@@ -0,0 +1,772 @@
+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