jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/test/controller/new_base/render_test.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module Render
+  class BlankRenderController < ActionController::Base
+    self.view_paths = [ActionView::FixtureResolver.new(
+      "render/blank_render/index.html.erb"                  => "Hello world!",
+      "render/blank_render/access_request.html.erb"         => "The request: <%= request.method.to_s.upcase %>",
+      "render/blank_render/access_action_name.html.erb"     => "Action Name: <%= action_name %>",
+      "render/blank_render/access_controller_name.html.erb" => "Controller Name: <%= controller_name %>",
+      "render/blank_render/overridden_with_own_view_paths_appended.html.erb"  => "parent content",
+      "render/blank_render/overridden_with_own_view_paths_prepended.html.erb" => "parent content",
+      "render/blank_render/overridden.html.erb"             => "parent content",
+      "render/child_render/overridden.html.erb"             => "child content"
+    )]
+
+    def index
+      render
+    end
+
+    def access_request
+      render action: "access_request"
+    end
+
+    def render_action_name
+      render action: "access_action_name"
+    end
+
+    def overridden_with_own_view_paths_appended
+    end
+
+    def overridden_with_own_view_paths_prepended
+    end
+
+    def overridden
+    end
+
+    private
+
+      def secretz
+        render plain: "FAIL WHALE!"
+      end
+  end
+
+  class DoubleRenderController < ActionController::Base
+    def index
+      render plain: "hello"
+      render plain: "world"
+    end
+  end
+
+  class ChildRenderController < BlankRenderController
+    append_view_path ActionView::FixtureResolver.new("render/child_render/overridden_with_own_view_paths_appended.html.erb" => "child content")
+    prepend_view_path ActionView::FixtureResolver.new("render/child_render/overridden_with_own_view_paths_prepended.html.erb" => "child content")
+  end
+
+  class RenderTest < Rack::TestCase
+    test "render with blank" do
+      with_routing do |set|
+        set.draw do
+          ActiveSupport::Deprecation.silence do
+            get ":controller", action: "index"
+          end
+        end
+
+        get "/render/blank_render"
+
+        assert_body "Hello world!"
+        assert_status 200
+      end
+    end
+
+    test "rendering more than once raises an exception" do
+      with_routing do |set|
+        set.draw do
+          ActiveSupport::Deprecation.silence do
+            get ":controller", action: "index"
+          end
+        end
+
+        assert_raises(AbstractController::DoubleRenderError) do
+          get "/render/double_render", headers: { "action_dispatch.show_exceptions" => false }
+        end
+      end
+    end
+  end
+
+  class TestOnlyRenderPublicActions < Rack::TestCase
+    # Only public methods on actual controllers are callable actions
+    test "raises an exception when a method of Object is called" do
+      assert_raises(AbstractController::ActionNotFound) do
+        get "/render/blank_render/clone", headers: { "action_dispatch.show_exceptions" => false }
+      end
+    end
+
+    test "raises an exception when a private method is called" do
+      assert_raises(AbstractController::ActionNotFound) do
+        get "/render/blank_render/secretz", headers: { "action_dispatch.show_exceptions" => false }
+      end
+    end
+  end
+
+  class TestVariousObjectsAvailableInView < Rack::TestCase
+    test "The request object is accessible in the view" do
+      get "/render/blank_render/access_request"
+      assert_body "The request: GET"
+    end
+
+    test "The action_name is accessible in the view" do
+      get "/render/blank_render/render_action_name"
+      assert_body "Action Name: render_action_name"
+    end
+
+    test "The controller_name is accessible in the view" do
+      get "/render/blank_render/access_controller_name"
+      assert_body "Controller Name: blank_render"
+    end
+  end
+
+  class TestViewInheritance < Rack::TestCase
+    test "Template from child controller gets picked over parent one" do
+      get "/render/child_render/overridden"
+      assert_body "child content"
+    end
+
+    test "Template from child controller with custom view_paths prepended gets picked over parent one" do
+      get "/render/child_render/overridden_with_own_view_paths_prepended"
+      assert_body "child content"
+    end
+
+    test "Template from child controller with custom view_paths appended gets picked over parent one" do
+      get "/render/child_render/overridden_with_own_view_paths_appended"
+      assert_body "child content"
+    end
+
+    test "Template from parent controller gets picked if missing in child controller" do
+      get "/render/child_render/index"
+      assert_body "Hello world!"
+    end
+  end
+end

data/vendor/rails/actionpack/test/controller/new_base/render_xml_test.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module RenderXml
+  # This has no layout and it works
+  class BasicController < ActionController::Base
+    self.view_paths = [ActionView::FixtureResolver.new(
+      "render_xml/basic/with_render_erb" => "Hello world!"
+    )]
+  end
+end

data/vendor/rails/actionpack/test/controller/output_escaping_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class OutputEscapingTest < ActiveSupport::TestCase
+  test "escape_html shouldn't die when passed nil" do
+    assert_predicate ERB::Util.h(nil), :blank?
+  end
+
+  test "escapeHTML should escape strings" do
+    assert_equal "&lt;&gt;&quot;", ERB::Util.h("<>\"")
+  end
+
+  test "escapeHTML shouldn't touch explicitly safe strings" do
+    assert_equal "<", ERB::Util.h("<".html_safe)
+  end
+end

data/vendor/rails/actionpack/test/controller/parameter_encoding_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ParameterEncodingController < ActionController::Base
+  skip_parameter_encoding :test_bar
+  skip_parameter_encoding :test_all_values_encoding
+
+  def test_foo
+    render body: params[:foo].encoding
+  end
+
+  def test_bar
+    render body: params[:bar].encoding
+  end
+
+  def test_all_values_encoding
+    render body: ::JSON.dump(params.values.map(&:encoding).map(&:name))
+  end
+end
+
+class ParameterEncodingTest < ActionController::TestCase
+  tests ParameterEncodingController
+
+  test "properly transcodes UTF8 parameters into declared encodings" do
+    post :test_foo, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+
+    assert_response :success
+    assert_equal "UTF-8", @response.body
+  end
+
+  test "properly encodes ASCII_8BIT parameters into binary" do
+    post :test_bar, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+
+    assert_response :success
+    assert_equal "ASCII-8BIT", @response.body
+  end
+
+  test "properly encodes all ASCII_8BIT parameters into binary" do
+    post :test_all_values_encoding, params: { "foo" => "foo", "bar" => "bar", "baz" => "baz" }
+
+    assert_response :success
+    assert_equal ["ASCII-8BIT"], JSON.parse(@response.body).uniq
+  end
+
+  test "does not raise an error when passed a param declared as ASCII-8BIT that contains invalid bytes" do
+    get :test_bar, params: { "bar" => URI.parser.escape("bar\xE2baz".b) }
+
+    assert_response :success
+    assert_equal "ASCII-8BIT", @response.body
+  end
+end

data/vendor/rails/actionpack/test/controller/parameters/accessors_test.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "action_controller/metal/strong_parameters"
+require "active_support/core_ext/hash/transform_values"
+
+class ParametersAccessorsTest < ActiveSupport::TestCase
+  setup do
+    ActionController::Parameters.permit_all_parameters = false
+
+    @params = ActionController::Parameters.new(
+      person: {
+        age: "32",
+        name: {
+          first: "David",
+          last: "Heinemeier Hansson"
+        },
+        addresses: [{ city: "Chicago", state: "Illinois" }]
+      }
+    )
+  end
+
+  test "[] retains permitted status" do
+    @params.permit!
+    assert_predicate @params[:person], :permitted?
+    assert_predicate @params[:person][:name], :permitted?
+  end
+
+  test "[] retains unpermitted status" do
+    assert_not_predicate @params[:person], :permitted?
+    assert_not_predicate @params[:person][:name], :permitted?
+  end
+
+  test "as_json returns the JSON representation of the parameters hash" do
+    assert_not @params.as_json.key? "parameters"
+    assert_not @params.as_json.key? "permitted"
+    assert @params.as_json.key? "person"
+  end
+
+  test "to_s returns the string representation of the parameters hash" do
+    assert_equal '{"person"=>{"age"=>"32", "name"=>{"first"=>"David", "last"=>"Heinemeier Hansson"}, ' \
+      '"addresses"=>[{"city"=>"Chicago", "state"=>"Illinois"}]}}', @params.to_s
+  end
+
+  test "each carries permitted status" do
+    @params.permit!
+    @params.each { |key, value| assert(value.permitted?) if key == "person" }
+  end
+
+  test "each carries unpermitted status" do
+    @params.each { |key, value| assert_not(value.permitted?) if key == "person" }
+  end
+
+  test "each returns key,value array for block with arity 1" do
+    @params.each do |arg|
+      assert_kind_of Array, arg
+      assert_equal "person", arg[0]
+      assert_kind_of ActionController::Parameters, arg[1]
+    end
+  end
+
+  test "each_pair carries permitted status" do
+    @params.permit!
+    @params.each_pair { |key, value| assert(value.permitted?) if key == "person" }
+  end
+
+  test "each_pair carries unpermitted status" do
+    @params.each_pair { |key, value| assert_not(value.permitted?) if key == "person" }
+  end
+
+  test "each_pair returns key,value array for block with arity 1" do
+    @params.each_pair do |arg|
+      assert_kind_of Array, arg
+      assert_equal "person", arg[0]
+      assert_kind_of ActionController::Parameters, arg[1]
+    end
+  end
+
+  test "empty? returns true when params contains no key/value pairs" do
+    params = ActionController::Parameters.new
+    assert_empty params
+  end
+
+  test "empty? returns false when any params are present" do
+    assert_not_empty @params
+  end
+
+  test "except retains permitted status" do
+    @params.permit!
+    assert_predicate @params.except(:person), :permitted?
+    assert_predicate @params[:person].except(:name), :permitted?
+  end
+
+  test "except retains unpermitted status" do
+    assert_not_predicate @params.except(:person), :permitted?
+    assert_not_predicate @params[:person].except(:name), :permitted?
+  end
+
+  test "fetch retains permitted status" do
+    @params.permit!
+    assert_predicate @params.fetch(:person), :permitted?
+    assert_predicate @params[:person].fetch(:name), :permitted?
+  end
+
+  test "fetch retains unpermitted status" do
+    assert_not_predicate @params.fetch(:person), :permitted?
+    assert_not_predicate @params[:person].fetch(:name), :permitted?
+  end
+
+  test "has_key? returns true if the given key is present in the params" do
+    assert @params.has_key?(:person)
+  end
+
+  test "has_key? returns false if the given key is not present in the params" do
+    assert_not @params.has_key?(:address)
+  end
+
+  test "has_value? returns true if the given value is present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert params.has_value?("Chicago")
+  end
+
+  test "has_value? returns false if the given value is not present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert_not params.has_value?("New York")
+  end
+
+  test "include? returns true if the given key is present in the params" do
+    assert @params.include?(:person)
+  end
+
+  test "include? returns false if the given key is not present in the params" do
+    assert_not @params.include?(:address)
+  end
+
+  test "key? returns true if the given key is present in the params" do
+    assert @params.key?(:person)
+  end
+
+  test "key? returns false if the given key is not present in the params" do
+    assert_not @params.key?(:address)
+  end
+
+  test "keys returns an array of the keys of the params" do
+    assert_equal ["person"], @params.keys
+    assert_equal ["age", "name", "addresses"], @params[:person].keys
+  end
+
+  test "reject retains permitted status" do
+    assert_not_predicate @params.reject { |k| k == "person" }, :permitted?
+  end
+
+  test "reject retains unpermitted status" do
+    @params.permit!
+    assert_predicate @params.reject { |k| k == "person" }, :permitted?
+  end
+
+  test "select retains permitted status" do
+    @params.permit!
+    assert_predicate @params.select { |k| k == "person" }, :permitted?
+  end
+
+  test "select retains unpermitted status" do
+    assert_not_predicate @params.select { |k| k == "person" }, :permitted?
+  end
+
+  test "slice retains permitted status" do
+    @params.permit!
+    assert_predicate @params.slice(:person), :permitted?
+  end
+
+  test "slice retains unpermitted status" do
+    assert_not_predicate @params.slice(:person), :permitted?
+  end
+
+  test "transform_keys retains permitted status" do
+    @params.permit!
+    assert_predicate @params.transform_keys { |k| k }, :permitted?
+  end
+
+  test "transform_keys retains unpermitted status" do
+    assert_not_predicate @params.transform_keys { |k| k }, :permitted?
+  end
+
+  test "transform_values retains permitted status" do
+    @params.permit!
+    assert_predicate @params.transform_values { |v| v }, :permitted?
+  end
+
+  test "transform_values retains unpermitted status" do
+    assert_not_predicate @params.transform_values { |v| v }, :permitted?
+  end
+
+  test "transform_values converts hashes to parameters" do
+    @params.transform_values do |value|
+      assert_kind_of ActionController::Parameters, value
+      value
+    end
+  end
+
+  test "transform_values without block yieds an enumerator" do
+    assert_kind_of Enumerator, @params.transform_values
+  end
+
+  test "transform_values! converts hashes to parameters" do
+    @params.transform_values! do |value|
+      assert_kind_of ActionController::Parameters, value
+    end
+  end
+
+  test "transform_values! without block yields an enumerator" do
+    assert_kind_of Enumerator, @params.transform_values!
+  end
+
+  test "value? returns true if the given value is present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert params.value?("Chicago")
+  end
+
+  test "value? returns false if the given value is not present in the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert_not params.value?("New York")
+  end
+
+  test "values returns an array of the values of the params" do
+    params = ActionController::Parameters.new(city: "Chicago", state: "Illinois")
+    assert_equal ["Chicago", "Illinois"], params.values
+  end
+
+  test "values_at retains permitted status" do
+    @params.permit!
+    assert_predicate @params.values_at(:person).first, :permitted?
+    assert_predicate @params[:person].values_at(:name).first, :permitted?
+  end
+
+  test "values_at retains unpermitted status" do
+    assert_not_predicate @params.values_at(:person).first, :permitted?
+    assert_not_predicate @params[:person].values_at(:name).first, :permitted?
+  end
+
+  test "is equal to Parameters instance with same params" do
+    params1 = ActionController::Parameters.new(a: 1, b: 2)
+    params2 = ActionController::Parameters.new(a: 1, b: 2)
+    assert(params1 == params2)
+  end
+
+  test "is equal to Parameters instance with same permitted params" do
+    params1 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
+    params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
+    assert(params1 == params2)
+  end
+
+  test "is equal to Parameters instance with same different source params, but same permitted params" do
+    params1 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
+    params2 = ActionController::Parameters.new(a: 1, c: 3).permit(:a)
+    assert(params1 == params2)
+    assert(params2 == params1)
+  end
+
+  test "is not equal to an unpermitted Parameters instance with same params" do
+    params1 = ActionController::Parameters.new(a: 1).permit(:a)
+    params2 = ActionController::Parameters.new(a: 1)
+    assert(params1 != params2)
+    assert(params2 != params1)
+  end
+
+  test "is not equal to Parameters instance with different permitted params" do
+    params1 = ActionController::Parameters.new(a: 1, b: 2).permit(:a, :b)
+    params2 = ActionController::Parameters.new(a: 1, b: 2).permit(:a)
+    assert(params1 != params2)
+    assert(params2 != params1)
+  end
+
+  test "equality with simple types works" do
+    assert(@params != "Hello")
+    assert(@params != 42)
+    assert(@params != false)
+  end
+
+  test "inspect shows both class name, parameters and permitted flag" do
+    assert_equal(
+      '<ActionController::Parameters {"person"=>{"age"=>"32", '\
+        '"name"=>{"first"=>"David", "last"=>"Heinemeier Hansson"}, ' \
+        '"addresses"=>[{"city"=>"Chicago", "state"=>"Illinois"}]}} permitted: false>',
+      @params.inspect
+    )
+  end
+
+  test "inspect prints updated permitted flag in the output" do
+    assert_match(/permitted: false/, @params.inspect)
+
+    @params.permit!
+
+    assert_match(/permitted: true/, @params.inspect)
+  end
+
+  if Hash.method_defined?(:dig)
+    test "#dig delegates the dig method to its values" do
+      assert_equal "David", @params.dig(:person, :name, :first)
+      assert_equal "Chicago", @params.dig(:person, :addresses, 0, :city)
+    end
+
+    test "#dig converts hashes to parameters" do
+      assert_kind_of ActionController::Parameters, @params.dig(:person)
+      assert_kind_of ActionController::Parameters, @params.dig(:person, :addresses, 0)
+      assert @params.dig(:person, :addresses).all? do |value|
+        value.is_a?(ActionController::Parameters)
+      end
+    end
+
+    test "mutating #dig return value mutates underlying parameters" do
+      @params.dig(:person, :name)[:first] = "Bill"
+      assert_equal "Bill", @params.dig(:person, :name, :first)
+
+      @params.dig(:person, :addresses)[0] = { city: "Boston", state: "Massachusetts" }
+      assert_equal "Boston", @params.dig(:person, :addresses, 0, :city)
+    end
+  else
+    test "ActionController::Parameters does not respond to #dig on Ruby 2.2" do
+      assert_not ActionController::Parameters.method_defined?(:dig)
+      assert_not_respond_to @params, :dig
+    end
+  end
+end