better_html 1.0.16 → 2.0.0

data/test/better_html/parser_test.rb

@@ -1,314 +0,0 @@
-require 'test_helper'
-require 'better_html/parser'
-require 'ast'
-
-module BetterHtml
-  class ParserTest < ActiveSupport::TestCase
-    include ::AST::Sexp
-
-    test "parse empty document" do
-      tree = Parser.new(buffer(''))
-
-      assert_equal s(:document), tree.ast
-    end
-
-    test "parser errors" do
-      tree = Parser.new(buffer('<>'))
-
-      assert_equal 1, tree.parser_errors.size
-      assert_equal "expected '/' or tag name", tree.parser_errors[0].message
-      assert_equal 1...2, tree.parser_errors[0].location.range
-      assert_equal <<~EOF.strip, tree.parser_errors[0].location.line_source_with_underline
-        <>
-         ^
-      EOF
-    end
-
-    test "consume cdata nodes" do
-      code = "<![CDATA[ foo ]]>"
-      tree = Parser.new(buffer(code))
-
-      assert_equal s(:document, s(:cdata, ' foo ')), tree.ast
-      assert_equal code, tree.ast.loc.source
-    end
-
-    test "unterminated cdata nodes are consumed until end" do
-      code = "<![CDATA[ foo"
-      tree = Parser.new(buffer(code))
-
-      assert_equal s(:document, s(:cdata, ' foo')), tree.ast
-      assert_equal code, tree.ast.loc.source
-    end
-
-    test "consume cdata with interpolation" do
-      code = "<![CDATA[ foo <%= bar %> baz ]]>"
-      tree = Parser.new(buffer(code))
-
-      assert_equal s(:document,
-        s(:cdata,
-          " foo ",
-          s(:erb, s(:indicator, '='), nil, s(:code, " bar "), nil),
-          " baz "
-        )),
-        tree.ast
-      assert_equal code, tree.ast.loc.source
-    end
-
-    test "consume comment nodes" do
-      tree = Parser.new(buffer("<!-- foo -->"))
-
-      assert_equal s(:document, s(:comment, ' foo ')), tree.ast
-    end
-
-    test "unterminated comment nodes are consumed until end" do
-      tree = Parser.new(buffer("<!-- foo"))
-
-      assert_equal s(:document, s(:comment, ' foo')), tree.ast
-    end
-
-    test "consume comment with interpolation" do
-      tree = Parser.new(buffer("<!-- foo <%= bar %> baz -->"))
-
-      assert_equal s(:document,
-        s(:comment,
-          " foo ",
-          s(:erb, s(:indicator, "="), nil, s(:code, " bar "), nil),
-          " baz "
-        )),
-        tree.ast
-    end
-
-    test "consume tag nodes" do
-      tree = Parser.new(buffer("<div>"))
-      assert_equal s(:document, s(:tag, nil, s(:tag_name, "div"), nil, nil)), tree.ast
-    end
-
-    test "tag without name" do
-      tree = Parser.new(buffer("foo < bar"))
-      assert_equal s(:document,
-        s(:text, "foo "),
-        s(:tag, nil, nil,
-          s(:tag_attributes,
-            s(:attribute, s(:attribute_name, 'bar'), nil, nil)
-          ),
-          nil
-        )
-      ), tree.ast
-    end
-
-    test "consume tag nodes with solidus" do
-      tree = Parser.new(buffer("</div>"))
-      assert_equal s(:document, s(:tag, s(:solidus), s(:tag_name, "div"), nil, nil)), tree.ast
-    end
-
-    test "sets self_closing when appropriate" do
-      tree = Parser.new(buffer("<div/>"))
-      assert_equal s(:document, s(:tag, nil, s(:tag_name, "div"), nil, s(:solidus))), tree.ast
-    end
-
-    test "consume tag nodes until name ends" do
-      tree = Parser.new(buffer("<div/>"))
-      assert_equal s(:document, s(:tag, nil, s(:tag_name, "div"), nil, s(:solidus))), tree.ast
-
-      tree = Parser.new(buffer("<div "))
-      assert_equal s(:document, s(:tag, nil, s(:tag_name, "div"), nil, nil)), tree.ast
-    end
-
-    test "consume tag nodes with interpolation" do
-      tree = Parser.new(buffer("<ns:<%= name %>-thing>"))
-      assert_equal s(:document,
-        s(:tag,
-          nil,
-          s(:tag_name, "ns:", s(:erb, s(:indicator, "="), nil, s(:code, " name "), nil), "-thing"),
-          nil,
-          nil
-        )), tree.ast
-    end
-
-    test "consume tag attributes with erb" do
-      tree = Parser.new(buffer("<div class=foo <%= erb %> name=bar>"))
-      assert_equal s(:document,
-        s(:tag, nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "class"),
-              s(:equal),
-              s(:attribute_value, "foo")
-            ),
-            s(:erb, s(:indicator, "="), nil,
-              s(:code, " erb "), nil),
-            s(:attribute,
-              s(:attribute_name, "name"),
-              s(:equal),
-              s(:attribute_value, "bar")
-            ),
-          ),
-          nil
-        )), tree.ast
-    end
-
-    test "consume tag attributes nodes unquoted value" do
-      tree = Parser.new(buffer("<div foo=bar>"))
-      assert_equal s(:document,
-        s(:tag, nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "foo"),
-              s(:equal),
-              s(:attribute_value, "bar")
-            )
-          ),
-          nil
-        )), tree.ast
-    end
-
-    test "consume attributes without name" do
-      tree = Parser.new(buffer("<div 'thing'>"))
-      assert_equal s(:document,
-        s(:tag, nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              nil,
-              nil,
-              s(:attribute_value, s(:quote, "'"), "thing", s(:quote, "'"))
-            )
-          ),
-          nil
-        )), tree.ast
-    end
-
-    test "consume tag attributes nodes quoted value" do
-      tree = Parser.new(buffer("<div foo=\"bar\">"))
-      assert_equal s(:document,
-        s(:tag, nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "foo"),
-              s(:equal),
-              s(:attribute_value, s(:quote, "\""), "bar", s(:quote, "\""))
-            )
-          ),
-          nil
-        )), tree.ast
-    end
-
-    test "consume tag attributes nodes interpolation in name and value" do
-      tree = Parser.new(buffer("<div data-<%= foo %>=\"some <%= value %> foo\">"))
-      assert_equal s(:document,
-        s(:tag, nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "data-", s(:erb, s(:indicator, "="), nil, s(:code, " foo "), nil)),
-              s(:equal),
-              s(:attribute_value,
-                s(:quote, "\""),
-                "some ",
-                s(:erb, s(:indicator, "="), nil, s(:code, " value "), nil),
-                " foo",
-                s(:quote, "\""),
-              ),
-            )
-          ),
-          nil
-        )), tree.ast
-    end
-
-    test "consume text nodes" do
-      tree = Parser.new(buffer("here is <%= some %> text"))
-
-      assert_equal s(:document,
-        s(:text,
-          "here is ",
-          s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " text"
-        )), tree.ast
-    end
-
-    test "javascript template parsing works" do
-      tree = Parser.new(buffer("here is <%= some %> text"), template_language: :javascript)
-
-      assert_equal s(:document,
-        s(:text,
-          "here is ",
-          s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " text"
-        )), tree.ast
-    end
-
-    test "javascript template does not consume html tags" do
-      tree = Parser.new(buffer("<div <%= some %> />"), template_language: :javascript)
-
-      assert_equal s(:document,
-        s(:text,
-          "<div ",
-          s(:erb, s(:indicator, "="), nil, s(:code, " some "), nil),
-          " />"
-        )), tree.ast
-    end
-
-    test "lodash template parsing works" do
-      tree = Parser.new(buffer('<div class="[%= foo %]">'), template_language: :lodash)
-
-      assert_equal s(:document,
-        s(:tag,
-          nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "class"),
-              s(:equal),
-              s(:attribute_value,
-                s(:quote, "\""),
-                s(:lodash, s(:indicator, "="), s(:code, " foo ")),
-                s(:quote, "\"")
-              )
-            )
-          ),
-          nil
-        )
-      ), tree.ast
-    end
-
-    test "nodes are all nested under document" do
-      tree = Parser.new(buffer(<<~HTML))
-        some text
-        <!-- a comment -->
-        some more text
-        <%= an erb tag -%>
-        <div class="foo">
-          content
-        </div>
-      HTML
-
-      assert_equal s(:document,
-        s(:text, "some text\n"),
-        s(:comment, " a comment "),
-        s(:text,
-          "\nsome more text\n",
-          s(:erb, s(:indicator, '='), nil, s(:code, ' an erb tag '), s(:trim)),
-          "\n"
-        ),
-        s(:tag,
-          nil,
-          s(:tag_name, "div"),
-          s(:tag_attributes,
-            s(:attribute,
-              s(:attribute_name, "class"),
-              s(:equal),
-              s(:attribute_value, s(:quote, "\""), "foo", s(:quote, "\""))
-            )
-          ),
-          nil
-        ),
-        s(:text, "\n  content\n"),
-        s(:tag, s(:solidus), s(:tag_name, 'div'), nil, nil),
-        s(:text, "\n"),
-      ), tree.ast
-    end
-  end
-end

data/test/better_html/test_helper/ruby_node_test.rb

@@ -1,288 +0,0 @@
-require 'test_helper'
-require 'better_html/test_helper/ruby_node'
-
-module BetterHtml
-  module TestHelper
-    class RubyNodeTest < ActiveSupport::TestCase
-      include ::AST::Sexp
-
-      test "simple call" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance call" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo.bar")
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance call with arguments" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo(x).bar")
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo, s(:send, nil, :x)), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance call with parenthesis" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("(foo).bar")
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:begin,  s(:send, nil, :foo)), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance call with parenthesis 2" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("(foo)")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "command call" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo bar")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :bar)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "command call with block" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo bar do")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :bar)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "call with parameters" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo(bar)")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :bar)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance call with parameters" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo.bar(baz, x)")
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :baz), s(:send, nil, :x)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "call with parameters with if conditional modifier" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo(bar) if something?")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :bar)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "call with parameters with unless conditional modifier" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("foo(bar) unless something?")
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :foo, expr.return_values.first.method_name
-        assert_equal [s(:send, nil, :bar)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "expression call in ternary" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("something? ? foo : bar")
-        assert_equal 2, expr.return_values.count
-        refute_predicate expr, :static_return_value?
-
-        assert_nil expr.return_values.to_a[0].receiver
-        assert_equal :foo, expr.return_values.to_a[0].method_name
-        assert_equal [], expr.return_values.to_a[0].arguments
-
-        assert_nil expr.return_values.to_a[1].receiver
-        assert_equal :bar, expr.return_values.to_a[1].method_name
-        assert_equal [], expr.return_values.to_a[1].arguments
-      end
-
-      test "expression call with args in ternary" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("something? ? foo(x) : bar(x)")
-        assert_equal 2, expr.return_values.count
-
-        assert_nil expr.return_values.to_a[0].receiver
-        assert_equal :foo, expr.return_values.to_a[0].method_name
-        assert_equal [s(:send, nil, :x)], expr.return_values.to_a[0].arguments
-
-        assert_nil expr.return_values.to_a[1].receiver
-        assert_equal :bar, expr.return_values.to_a[1].method_name
-        assert_equal [s(:send, nil, :x)], expr.return_values.to_a[1].arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "string without interpolation" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('"foo"')
-        assert_equal 1, expr.return_values.count
-        assert_equal [s(:str, "foo")], expr.return_values.to_a
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "string with interpolation" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('"foo #{bar}"')
-        method_calls = expr.return_values.select(&:method_call?)
-        assert_equal 1, method_calls.count
-        assert_nil method_calls.first.receiver
-        assert_equal :bar, method_calls.first.method_name
-        assert_equal [], method_calls.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "ternary in string with interpolation" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('"foo #{foo? ? bar : baz}"')
-        method_calls = expr.return_values.select(&:method_call?)
-        assert_equal 2, method_calls.count
-
-        assert_nil method_calls.first.receiver
-        assert_equal :bar, method_calls.first.method_name
-        assert_equal [], method_calls.first.arguments
-
-        assert_nil method_calls.last.receiver
-        assert_equal :baz, method_calls.last.method_name
-        assert_equal [], method_calls.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "assignment to variable" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('x = foo.bar')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "assignment to variable with command call" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('raw x = foo.bar')
-        assert_equal 1, expr.return_values.count
-        assert_nil expr.return_values.first.receiver
-        assert_equal :raw, expr.return_values.first.method_name
-        assert_equal [s(:lvasgn, :x, s(:send, s(:send, nil, :foo), :bar))], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "assignment with instance call" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('(x = foo).bar')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:begin, s(:lvasgn, :x, s(:send, nil, :foo))), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "assignment to multiple variables" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('x, y = foo.bar')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "safe navigation operator" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('foo&.bar')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :foo), expr.return_values.to_a[0].receiver
-        assert_equal :bar, expr.return_values.to_a[0].method_name
-        assert_equal [], expr.return_values.to_a[0].arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance variable" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('@foo')
-        assert_equal 0, expr.return_values.select(&:method_call?).count
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "instance method on variable" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('@foo.bar')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:ivar, :@foo), expr.return_values.first.receiver
-        assert_equal :bar, expr.return_values.first.method_name
-        assert_equal [], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "index into array" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('local_assigns[:text_class] if local_assigns[:text_class]')
-        assert_equal 1, expr.return_values.count
-        assert_equal s(:send, nil, :local_assigns), expr.return_values.first.receiver
-        assert_equal :[], expr.return_values.first.method_name
-        assert_equal [s(:sym, :text_class)], expr.return_values.first.arguments
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for ivar" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('@foo')
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for str" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("'str'")
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for int" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("1")
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for bool" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("true")
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for nil" do
-        expr = BetterHtml::TestHelper::RubyNode.parse("nil")
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for dstr without interpolate" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('"str"')
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? for dstr with interpolate" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('"str #{foo}"')
-        refute_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? with safe ternary" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('foo ? \'a\' : \'b\'')
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? with safe conditional" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('\'foo\' if bar?')
-        assert_predicate expr, :static_return_value?
-      end
-
-      test "static_return_value? with safe assignment" do
-        expr = BetterHtml::TestHelper::RubyNode.parse('x = \'foo\'')
-        assert_predicate expr, :static_return_value?
-      end
-    end
-  end
-end

data/test/better_html/test_helper/safe_erb/allowed_script_type_test.rb

@@ -1,46 +0,0 @@
-require 'test_helper'
-require 'better_html/parser'
-require 'better_html/test_helper/safe_erb/allowed_script_type'
-
-module BetterHtml
-  module TestHelper
-    module SafeErb
-      class AllowedScriptTypeTest < ActiveSupport::TestCase
-        setup do
-          @config = BetterHtml::Config.new(
-            javascript_safe_methods: ['j', 'escape_javascript', 'to_json'],
-            javascript_attribute_names: [/\Aon/i, 'data-eval'],
-          )
-        end
-
-        test "allowed script type" do
-          errors = validate(<<-EOF).errors
-            <script type="text/javascript">
-            </script>
-          EOF
-
-          assert_predicate errors, :empty?
-        end
-
-        test "disallowed script types" do
-          errors = validate(<<-EOF).errors
-            <script type="text/bogus">
-            </script>
-          EOF
-
-          assert_equal 1, errors.size
-          assert_equal 'type="text/bogus"', errors.first.location.source
-          assert_equal "text/bogus is not a valid type, valid types are text/javascript, text/template, text/html", errors.first.message
-        end
-
-        private
-        def validate(data, template_language: :html)
-          parser = BetterHtml::Parser.new(buffer(data), template_language: template_language)
-          tester = BetterHtml::TestHelper::SafeErb::AllowedScriptType.new(parser, config: @config)
-          tester.validate
-          tester
-        end
-      end
-    end
-  end
-end

data/test/better_html/test_helper/safe_erb/no_javascript_tag_helper_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-require 'better_html/test_helper/safe_erb/no_javascript_tag_helper'
-
-module BetterHtml
-  module TestHelper
-    module SafeErb
-      class NoJavascriptTagHelperTest < ActiveSupport::TestCase
-        setup do
-          @config = BetterHtml::Config.new(
-            javascript_safe_methods: ['j', 'escape_javascript', 'to_json'],
-            javascript_attribute_names: [/\Aon/i, 'data-eval'],
-          )
-        end
-
-        test "javascript_tag helper is not allowed because it parses as text and unsafe erb cannot be detected" do
-          errors = validate(<<-EOF).errors
-            <%= javascript_tag do %>
-              if (a < 1) { <%= unsafe %> }
-            <% end %>
-          EOF
-
-          assert_equal 1, errors.size
-          assert_equal '<%= javascript_tag do %>', errors.first.location.source
-          assert_includes "'javascript_tag do' syntax is deprecated; use inline <script> instead", errors.first.message
-        end
-
-        private
-        def validate(data, template_language: :html)
-          parser = BetterHtml::Parser.new(buffer(data), template_language: template_language)
-          tester = BetterHtml::TestHelper::SafeErb::NoJavascriptTagHelper.new(parser, config: @config)
-          tester.validate
-          tester
-        end
-      end
-    end
-  end
-end