jets 1.9.7 → 1.9.8

data/vendor/rails/actionview/test/template/html_test.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class HTMLTest < ActiveSupport::TestCase
-  test "formats returns symbol for recognized MIME type" do
-    assert_equal [:html], ActionView::Template::HTML.new("", :html).formats
-  end
-
-  test "formats returns string for recognized MIME type when MIME does not have symbol" do
-    foo = Mime::Type.lookup("foo")
-    assert_nil foo.to_sym
-    assert_equal ["foo"], ActionView::Template::HTML.new("", foo).formats
-  end
-
-  test "formats returns string for unknown MIME type" do
-    assert_equal ["foo"], ActionView::Template::HTML.new("", "foo").formats
-  end
-end

data/vendor/rails/actionview/test/template/javascript_helper_test.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-
-class JavaScriptHelperTest < ActionView::TestCase
-  tests ActionView::Helpers::JavaScriptHelper
-
-  attr_accessor :output_buffer
-  attr_reader :request
-
-  setup do
-    @old_escape_html_entities_in_json = ActiveSupport.escape_html_entities_in_json
-    ActiveSupport.escape_html_entities_in_json = true
-    @template = self
-    @request = Class.new do
-      def send_early_hints(links) end
-    end.new
-  end
-
-  def teardown
-    ActiveSupport.escape_html_entities_in_json = @old_escape_html_entities_in_json
-  end
-
-  def test_escape_javascript
-    assert_equal "", escape_javascript(nil)
-    assert_equal %(This \\"thing\\" is really\\n netos\\'), escape_javascript(%(This "thing" is really\n netos'))
-    assert_equal %(backslash\\\\test), escape_javascript(%(backslash\\test))
-    assert_equal %(dont <\\/close> tags), escape_javascript(%(dont </close> tags))
-    assert_equal %(unicode &#x2028; newline), escape_javascript(%(unicode \342\200\250 newline).dup.force_encoding(Encoding::UTF_8).encode!)
-    assert_equal %(unicode &#x2029; newline), escape_javascript(%(unicode \342\200\251 newline).dup.force_encoding(Encoding::UTF_8).encode!)
-
-    assert_equal %(dont <\\/close> tags), j(%(dont </close> tags))
-  end
-
-  def test_escape_javascript_with_safebuffer
-    given = %('quoted' "double-quoted" new-line:\n </closed>)
-    expect = %(\\'quoted\\' \\"double-quoted\\" new-line:\\n <\\/closed>)
-    assert_equal expect, escape_javascript(given)
-    assert_equal expect, escape_javascript(ActiveSupport::SafeBuffer.new(given))
-    assert_instance_of String, escape_javascript(given)
-    assert_instance_of ActiveSupport::SafeBuffer, escape_javascript(ActiveSupport::SafeBuffer.new(given))
-  end
-
-  def test_javascript_tag
-    self.output_buffer = "foo"
-
-    assert_dom_equal "<script>\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
-      javascript_tag("alert('hello')")
-
-    assert_equal "foo", output_buffer, "javascript_tag without a block should not concat to output_buffer"
-  end
-
-  # Setting the :extname option will control what extension (if any) is appended to the url for assets
-  def test_javascript_include_tag
-    assert_dom_equal "<script src='/foo.js'></script>",  javascript_include_tag("/foo")
-    assert_dom_equal "<script src='/foo'></script>",     javascript_include_tag("/foo", extname: false)
-    assert_dom_equal "<script src='/foo.bar'></script>", javascript_include_tag("/foo", extname: ".bar")
-  end
-
-  def test_javascript_tag_with_options
-    assert_dom_equal "<script id=\"the_js_tag\">\n//<![CDATA[\nalert('hello')\n//]]>\n</script>",
-      javascript_tag("alert('hello')", id: "the_js_tag")
-  end
-
-  def test_javascript_cdata_section
-    assert_dom_equal "\n//<![CDATA[\nalert('hello')\n//]]>\n", javascript_cdata_section("alert('hello')")
-  end
-end

data/vendor/rails/actionview/test/template/log_subscriber_test.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "active_support/log_subscriber/test_helper"
-require "action_view/log_subscriber"
-require "controller/fake_models"
-
-class AVLogSubscriberTest < ActiveSupport::TestCase
-  include ActiveSupport::LogSubscriber::TestHelper
-
-  def setup
-    super
-
-    view_paths     = ActionController::Base.view_paths
-    lookup_context = ActionView::LookupContext.new(view_paths, {}, ["test"])
-    renderer       = ActionView::Renderer.new(lookup_context)
-    @view          = ActionView::Base.new(renderer, {})
-
-    ActionView::LogSubscriber.attach_to :action_view
-
-    unless Rails.respond_to?(:root)
-      @defined_root = true
-      def Rails.root; :defined_root; end # Minitest `stub` expects the method to be defined.
-    end
-  end
-
-  def teardown
-    super
-
-    ActiveSupport::LogSubscriber.log_subscribers.clear
-
-    # We need to undef `root`, RenderTestCases don't want this to be defined
-    Rails.instance_eval { undef :root } if defined?(@defined_root)
-  end
-
-  def set_logger(logger)
-    ActionView::Base.logger = logger
-  end
-
-  def set_cache_controller
-    controller = ActionController::Base.new
-    controller.perform_caching = true
-    controller.cache_store = ActiveSupport::Cache::MemoryStore.new
-    @view.controller = controller
-  end
-
-  def set_view_cache_dependencies
-    def @view.view_cache_dependencies; []; end
-    def @view.combined_fragment_cache_key(*); "ahoy `controller` dependency"; end
-  end
-
-  def test_render_file_template
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(file: "test/hello_world")
-      wait
-
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering test\/hello_world\.erb/, @logger.logged(:info).first)
-      assert_match(/Rendered test\/hello_world\.erb/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_text_template
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(plain: "TEXT")
-      wait
-
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering text template/, @logger.logged(:info).first)
-      assert_match(/Rendered text template/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_inline_template
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(inline: "<%= 'TEXT' %>")
-      wait
-
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendering inline template/, @logger.logged(:info).first)
-      assert_match(/Rendered inline template/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_partial_with_implicit_path
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(Customer.new("david"), greeting: "hi")
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered customers\/_customer\.html\.erb/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_partial_with_cache_missed
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-      set_cache_controller
-
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_partial_with_cache_hitted
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-      set_cache_controller
-
-      # Second render should hit cache.
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-
-      assert_equal 2, @logger.logged(:info).size
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_uncached_outer_partial_with_inner_cached_partial_wont_mix_cache_hits_or_misses
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-      set_cache_controller
-
-      @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
-      wait
-      *, cached_inner, uncached_outer = @logger.logged(:info)
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, cached_inner)
-      assert_match(/Rendered test\/_nested_cached_customer\.erb \(.*?ms\)$/, uncached_outer)
-
-      # Second render hits the cache for the _cached_customer partial. Outer template's log shouldn't be affected.
-      @view.render(partial: "test/nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
-      wait
-      *, cached_inner, uncached_outer = @logger.logged(:info)
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, cached_inner)
-      assert_match(/Rendered test\/_nested_cached_customer\.erb \(.*?ms\)$/, uncached_outer)
-    end
-  end
-
-  def test_render_cached_outer_partial_with_cached_inner_partial
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-      set_cache_controller
-
-      @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
-      wait
-      *, cached_inner, cached_outer = @logger.logged(:info)
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, cached_inner)
-      assert_match(/Rendered test\/_cached_nested_cached_customer\.erb (.*) \[cache miss\]/, cached_outer)
-
-      # One render: inner partial skipped, because the outer has been cached.
-      assert_difference -> { @logger.logged(:info).size }, +1 do
-        @view.render(partial: "test/cached_nested_cached_customer", locals: { cached_customer: Customer.new("Stan") })
-        wait
-      end
-      assert_match(/Rendered test\/_cached_nested_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_partial_with_cache_hitted_and_missed
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-      set_cache_controller
-
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
-
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("david") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache hit\]/, @logger.logged(:info).last)
-
-      @view.render(partial: "test/cached_customer", locals: { cached_customer: Customer.new("Stan") })
-      wait
-      assert_match(/Rendered test\/_cached_customer\.erb (.*) \[cache miss\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_collection_template
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render(partial: "test/customer", collection: [ Customer.new("david"), Customer.new("mary") ])
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of test\/_customer.erb \[2 times\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_collection_with_implicit_path
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render([ Customer.new("david"), Customer.new("mary") ], greeting: "hi")
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[2 times\]/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_collection_template_without_path
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      @view.render([ GoodCustomer.new("david"), Customer.new("mary") ], greeting: "hi")
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of templates/, @logger.logged(:info).last)
-    end
-  end
-
-  def test_render_collection_with_cached_set
-    Rails.stub(:root, File.expand_path(FIXTURE_LOAD_PATH)) do
-      set_view_cache_dependencies
-
-      @view.render(partial: "customers/customer", collection: [ Customer.new("david"), Customer.new("mary") ], cached: true,
-        locals: { greeting: "hi" })
-      wait
-
-      assert_equal 1, @logger.logged(:info).size
-      assert_match(/Rendered collection of customers\/_customer\.html\.erb \[0 \/ 2 cache hits\]/, @logger.logged(:info).last)
-    end
-  end
-end

data/vendor/rails/actionview/test/template/lookup_context_test.rb

@@ -1,289 +0,0 @@
-# frozen_string_literal: true
-
-require "abstract_unit"
-require "abstract_controller/rendering"
-
-class LookupContextTest < ActiveSupport::TestCase
-  def setup
-    @lookup_context = ActionView::LookupContext.new(FIXTURE_LOAD_PATH, {})
-    ActionView::LookupContext::DetailsKey.clear
-  end
-
-  def teardown
-    I18n.locale = :en
-  end
-
-  test "allows to override default_formats with ActionView::Base.default_formats" do
-    begin
-      formats = ActionView::Base.default_formats
-      ActionView::Base.default_formats = [:foo, :bar]
-
-      assert_equal [:foo, :bar], ActionView::LookupContext.new([]).default_formats
-    ensure
-      ActionView::Base.default_formats = formats
-    end
-  end
-
-  test "process view paths on initialization" do
-    assert_kind_of ActionView::PathSet, @lookup_context.view_paths
-  end
-
-  test "normalizes details on initialization" do
-    assert_equal Mime::SET.to_a, @lookup_context.formats
-    assert_equal :en, @lookup_context.locale
-  end
-
-  test "allows me to freeze and retrieve frozen formats" do
-    @lookup_context.formats.freeze
-    assert_predicate @lookup_context.formats, :frozen?
-  end
-
-  test "provides getters and setters for variants" do
-    @lookup_context.variants = [:mobile]
-    assert_equal [:mobile], @lookup_context.variants
-  end
-
-  test "provides getters and setters for formats" do
-    @lookup_context.formats = [:html]
-    assert_equal [:html], @lookup_context.formats
-  end
-
-  test "handles */* formats" do
-    @lookup_context.formats = ["*/*"]
-    assert_equal Mime::SET.to_a, @lookup_context.formats
-  end
-
-  test "handles explicitly defined */* formats fallback to :js" do
-    @lookup_context.formats = [:js, Mime::ALL]
-    assert_equal [:js, *Mime::SET.symbols], @lookup_context.formats
-  end
-
-  test "adds :html fallback to :js formats" do
-    @lookup_context.formats = [:js]
-    assert_equal [:js, :html], @lookup_context.formats
-  end
-
-  test "provides getters and setters for locale" do
-    @lookup_context.locale = :pt
-    assert_equal :pt, @lookup_context.locale
-  end
-
-  test "changing lookup_context locale, changes I18n.locale" do
-    @lookup_context.locale = :pt
-    assert_equal :pt, I18n.locale
-  end
-
-  test "delegates changing the locale to the I18n configuration object if it contains a lookup_context object" do
-    begin
-      I18n.config = ActionView::I18nProxy.new(I18n.config, @lookup_context)
-      @lookup_context.locale = :pt
-      assert_equal :pt, I18n.locale
-      assert_equal :pt, @lookup_context.locale
-    ensure
-      I18n.config = I18n.config.original_config
-    end
-
-    assert_equal :pt, I18n.locale
-  end
-
-  test "find templates using the given view paths and configured details" do
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hello world!", template.source
-
-    @lookup_context.locale = :da
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hey verden", template.source
-  end
-
-  test "find templates with given variants" do
-    @lookup_context.formats  = [:html]
-    @lookup_context.variants = [:phone]
-
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hello phone!", template.source
-
-    @lookup_context.variants = [:phone]
-    @lookup_context.formats  = [:text]
-
-    template = @lookup_context.find("hello_world", %w(test))
-    assert_equal "Hello texty phone!", template.source
-  end
-
-  test "found templates respects given formats if one cannot be found from template or handler" do
-    assert_called(ActionView::Template::Handlers::Builder, :default_format, returns: nil) do
-      @lookup_context.formats = [:text]
-      template = @lookup_context.find("hello", %w(test))
-      assert_equal [:text], template.formats
-    end
-  end
-
-  test "adds fallbacks to view paths when required" do
-    assert_equal 1, @lookup_context.view_paths.size
-
-    @lookup_context.with_fallbacks do
-      assert_equal 3, @lookup_context.view_paths.size
-      assert_includes @lookup_context.view_paths, ActionView::FallbackFileSystemResolver.new("")
-      assert_includes @lookup_context.view_paths, ActionView::FallbackFileSystemResolver.new("/")
-    end
-  end
-
-  test "add fallbacks just once in nested fallbacks calls" do
-    @lookup_context.with_fallbacks do
-      @lookup_context.with_fallbacks do
-        assert_equal 3, @lookup_context.view_paths.size
-      end
-    end
-  end
-
-  test "generates a new details key for each details hash" do
-    keys = []
-    keys << @lookup_context.details_key
-    assert_equal 1, keys.uniq.size
-
-    @lookup_context.locale = :da
-    keys << @lookup_context.details_key
-    assert_equal 2, keys.uniq.size
-
-    @lookup_context.locale = :en
-    keys << @lookup_context.details_key
-    assert_equal 2, keys.uniq.size
-
-    @lookup_context.formats = [:html]
-    keys << @lookup_context.details_key
-    assert_equal 3, keys.uniq.size
-
-    @lookup_context.formats = nil
-    keys << @lookup_context.details_key
-    assert_equal 3, keys.uniq.size
-  end
-
-  test "gives the key forward to the resolver, so it can be used as cache key" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Now we are going to change the template, but it won't change the returned template
-    # since we will hit the cache.
-    @lookup_context.view_paths.first.hash["test/_foo.erb"] = "Bar"
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # This time we will change the locale. The updated template should be picked since
-    # lookup_context generated a new key after we changed the locale.
-    @lookup_context.locale = :da
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
-
-    # Now we will change back the locale and it will still pick the old template.
-    # This is expected because lookup_context will reuse the previous key for :en locale.
-    @lookup_context.locale = :en
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Foo", template.source
-
-    # Finally, we can expire the cache. And the expected template will be used.
-    @lookup_context.view_paths.first.clear_cache
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal "Bar", template.source
-  end
-
-  test "can disable the cache on demand" do
-    @lookup_context.view_paths = ActionView::FixtureResolver.new("test/_foo.erb" => "Foo")
-    old_template = @lookup_context.find("foo", %w(test), true)
-
-    template = @lookup_context.find("foo", %w(test), true)
-    assert_equal template, old_template
-
-    assert @lookup_context.cache
-    template = @lookup_context.disable_cache do
-      assert !@lookup_context.cache
-      @lookup_context.find("foo", %w(test), true)
-    end
-    assert @lookup_context.cache
-
-    assert_not_equal template, old_template
-  end
-
-  test "responds to #prefixes" do
-    assert_equal [], @lookup_context.prefixes
-    @lookup_context.prefixes = ["foo"]
-    assert_equal ["foo"], @lookup_context.prefixes
-  end
-end
-
-class LookupContextWithFalseCaching < ActiveSupport::TestCase
-  def setup
-    @resolver = ActionView::FixtureResolver.new("test/_foo.erb" => ["Foo", Time.utc(2000)])
-    @lookup_context = ActionView::LookupContext.new(@resolver, {})
-  end
-
-  test "templates are always found in the resolver but timestamp is checked before being compiled" do
-    ActionView::Resolver.stub(:caching?, false) do
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      # Now we are going to change the template, but it won't change the returned template
-      # since the timestamp is the same.
-      @resolver.hash["test/_foo.erb"][0] = "Bar"
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      # Now update the timestamp.
-      @resolver.hash["test/_foo.erb"][1] = Time.now.utc
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Bar", template.source
-    end
-  end
-
-  test "if no template was found in the second lookup, with no cache, raise error" do
-    ActionView::Resolver.stub(:caching?, false) do
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-
-      @resolver.hash.clear
-      assert_raise ActionView::MissingTemplate do
-        @lookup_context.find("foo", %w(test), true)
-      end
-    end
-  end
-
-  test "if no template was cached in the first lookup, retrieval should work in the second call" do
-    ActionView::Resolver.stub(:caching?, false) do
-      @resolver.hash.clear
-      assert_raise ActionView::MissingTemplate do
-        @lookup_context.find("foo", %w(test), true)
-      end
-
-      @resolver.hash["test/_foo.erb"] = ["Foo", Time.utc(2000)]
-      template = @lookup_context.find("foo", %w(test), true)
-      assert_equal "Foo", template.source
-    end
-  end
-end
-
-class TestMissingTemplate < ActiveSupport::TestCase
-  def setup
-    @lookup_context = ActionView::LookupContext.new("/Path/to/views", {})
-  end
-
-  test "if no template was found we get a helpful error message including the inheritance chain" do
-    e = assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(parent child))
-    end
-    assert_match %r{Missing template parent/foo, child/foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-
-  test "if no partial was found we get a helpful error message including the inheritance chain" do
-    e = assert_raise ActionView::MissingTemplate do
-      @lookup_context.find("foo", %w(parent child), true)
-    end
-    assert_match %r{Missing partial parent/_foo, child/_foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-
-  test "if a single prefix is passed as a string and the lookup fails, MissingTemplate accepts it" do
-    e = assert_raise ActionView::MissingTemplate do
-      details = { handlers: [], formats: [], variants: [], locale: [] }
-      @lookup_context.view_paths.find("foo", "parent", true, details)
-    end
-    assert_match %r{Missing partial parent/_foo with .* Searched in:\n  \* "/Path/to/views"\n}, e.message
-  end
-end