jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/test/controller/api/conditional_get_test.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/integer/time"
+require "active_support/core_ext/numeric/time"
+
+class ConditionalGetApiController < ActionController::API
+  before_action :handle_last_modified_and_etags, only: :two
+
+  def one
+    if stale?(last_modified: Time.now.utc.beginning_of_day, etag: [:foo, 123])
+      render plain: "Hi!"
+    end
+  end
+
+  def two
+    render plain: "Hi!"
+  end
+
+  private
+
+    def handle_last_modified_and_etags
+      fresh_when(last_modified: Time.now.utc.beginning_of_day, etag: [ :foo, 123 ])
+    end
+end
+
+class ConditionalGetApiTest < ActionController::TestCase
+  tests ConditionalGetApiController
+
+  def setup
+    @last_modified = Time.now.utc.beginning_of_day.httpdate
+  end
+
+  def test_request_gets_last_modified
+    get :two
+    assert_equal @last_modified, @response.headers["Last-Modified"]
+    assert_response :success
+  end
+
+  def test_request_obeys_last_modified
+    @request.if_modified_since = @last_modified
+    get :two
+    assert_response :not_modified
+  end
+
+  def test_last_modified_works_with_less_than_too
+    @request.if_modified_since = 5.years.ago.httpdate
+    get :two
+    assert_response :success
+  end
+
+  def test_request_not_modified
+    @request.if_modified_since = @last_modified
+    get :one
+    assert_equal 304, @response.status.to_i
+    assert_predicate @response.body, :blank?
+    assert_equal @last_modified, @response.headers["Last-Modified"]
+  end
+end

data/vendor/rails/actionpack/test/controller/api/data_streaming_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module TestApiFileUtils
+  def file_path() __FILE__ end
+  def file_data() @data ||= File.open(file_path, "rb") { |f| f.read } end
+end
+
+class DataStreamingApiController < ActionController::API
+  include TestApiFileUtils
+
+  def one; end
+  def two
+    send_data(file_data, {})
+  end
+end
+
+class DataStreamingApiTest < ActionController::TestCase
+  include TestApiFileUtils
+  tests DataStreamingApiController
+
+  def test_data
+    response = process("two")
+    assert_kind_of String, response.body
+    assert_equal file_data, response.body
+  end
+end

data/vendor/rails/actionpack/test/controller/api/force_ssl_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ForceSSLApiController < ActionController::API
+  force_ssl
+
+  def one; end
+  def two
+    head :ok
+  end
+end
+
+class ForceSSLApiTest < ActionController::TestCase
+  tests ForceSSLApiController
+
+  def test_redirects_to_https
+    get :two
+    assert_response 301
+    assert_equal "https://test.host/force_ssl_api/two", redirect_to_url
+  end
+end

data/vendor/rails/actionpack/test/controller/api/implicit_render_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ImplicitRenderAPITestController < ActionController::API
+  def empty_action
+  end
+end
+
+class ImplicitRenderAPITest < ActionController::TestCase
+  tests ImplicitRenderAPITestController
+
+  def test_implicit_no_content_response
+    get :empty_action
+    assert_response :no_content
+  end
+end

data/vendor/rails/actionpack/test/controller/api/params_wrapper_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class ParamsWrapperForApiTest < ActionController::TestCase
+  class UsersController < ActionController::API
+    attr_accessor :last_parameters
+
+    wrap_parameters :person, format: [:json]
+
+    def test
+      self.last_parameters = params.except(:controller, :action).to_unsafe_h
+      head :ok
+    end
+  end
+
+  class Person; end
+
+  tests UsersController
+
+  def test_specify_wrapper_name
+    @request.env["CONTENT_TYPE"] = "application/json"
+    post :test, params: { "username" => "sikachu" }
+
+    expected = { "username" => "sikachu", "person" => { "username" => "sikachu" } }
+    assert_equal expected, @controller.last_parameters
+  end
+end

data/vendor/rails/actionpack/test/controller/api/redirect_to_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class RedirectToApiController < ActionController::API
+  def one
+    redirect_to action: "two"
+  end
+
+  def two; end
+end
+
+class RedirectToApiTest < ActionController::TestCase
+  tests RedirectToApiController
+
+  def test_redirect_to
+    get :one
+    assert_response :redirect
+    assert_equal "http://test.host/redirect_to_api/two", redirect_to_url
+  end
+end

data/vendor/rails/actionpack/test/controller/api/renderers_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/core_ext/hash/conversions"
+
+class RenderersApiController < ActionController::API
+  class Model
+    def to_json(options = {})
+      { a: "b" }.to_json(options)
+    end
+
+    def to_xml(options = {})
+      { a: "b" }.to_xml(options)
+    end
+  end
+
+  def one
+    render json: Model.new
+  end
+
+  def two
+    render xml: Model.new
+  end
+
+  def plain
+    render plain: "Hi from plain", status: 500
+  end
+end
+
+class RenderersApiTest < ActionController::TestCase
+  tests RenderersApiController
+
+  def test_render_json
+    get :one
+    assert_response :success
+    assert_equal({ a: "b" }.to_json, @response.body)
+  end
+
+  def test_render_xml
+    get :two
+    assert_response :success
+    assert_equal({ a: "b" }.to_xml, @response.body)
+  end
+
+  def test_render_plain
+    get :plain
+    assert_response :internal_server_error
+    assert_equal("Hi from plain", @response.body)
+  end
+end

data/vendor/rails/actionpack/test/controller/api/url_for_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class UrlForApiController < ActionController::API
+  def one; end
+  def two; end
+end
+
+class UrlForApiTest < ActionController::TestCase
+  tests UrlForApiController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+  end
+
+  def test_url_for
+    get :one
+    assert_equal "http://www.example.com/url_for_api/one", @controller.url_for
+  end
+end

data/vendor/rails/actionpack/test/controller/api/with_cookies_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+class WithCookiesController < ActionController::API
+  include ActionController::Cookies
+
+  def with_cookies
+    render plain: cookies[:foobar]
+  end
+end
+
+class WithCookiesTest < ActionController::TestCase
+  tests WithCookiesController
+
+  def test_with_cookies
+    request.cookies[:foobar] = "bazbang"
+
+    get :with_cookies
+
+    assert_equal "bazbang", response.body
+  end
+end

data/vendor/rails/actionpack/test/controller/api/with_helpers_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+
+module ApiWithHelper
+  def my_helper
+    "helper"
+  end
+end
+
+class WithHelpersController < ActionController::API
+  include ActionController::Helpers
+  helper ApiWithHelper
+
+  def with_helpers
+    render plain: self.class.helpers.my_helper
+  end
+end
+
+class SubclassWithHelpersController < WithHelpersController
+  def with_helpers
+    render plain: self.class.helpers.my_helper
+  end
+end
+
+class WithHelpersTest < ActionController::TestCase
+  tests WithHelpersController
+
+  def test_with_helpers
+    get :with_helpers
+
+    assert_equal "helper", response.body
+  end
+end
+
+class SubclassWithHelpersTest < ActionController::TestCase
+  tests WithHelpersController
+
+  def test_with_helpers
+    get :with_helpers
+
+    assert_equal "helper", response.body
+  end
+end

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

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/logger"
+require "controller/fake_models"
+
+# Provide some controller to run the tests on.
+module Submodule
+  class ContainedEmptyController < ActionController::Base
+  end
+end
+
+class EmptyController < ActionController::Base
+end
+
+class SimpleController < ActionController::Base
+  def hello
+    self.response_body = "hello"
+  end
+end
+
+class NonEmptyController < ActionController::Base
+  def public_action
+    head :ok
+  end
+end
+
+class DefaultUrlOptionsController < ActionController::Base
+  def from_view
+    render inline: "<%= #{params[:route]} %>"
+  end
+
+  def default_url_options
+    { host: "www.override.com", action: "new", locale: "en" }
+  end
+end
+
+class OptionalDefaultUrlOptionsController < ActionController::Base
+  def show
+    head :ok
+  end
+
+  def default_url_options
+    { format: "atom", id: "default-id" }
+  end
+end
+
+class UrlOptionsController < ActionController::Base
+  def from_view
+    render inline: "<%= #{params[:route]} %>"
+  end
+
+  def url_options
+    super.merge(host: "www.override.com")
+  end
+end
+
+class RecordIdentifierIncludedController < ActionController::Base
+  include ActionView::RecordIdentifier
+end
+
+class ActionMissingController < ActionController::Base
+  def action_missing(action)
+    render plain: "Response for #{action}"
+  end
+end
+
+class ControllerClassTests < ActiveSupport::TestCase
+  def test_controller_path
+    assert_equal "empty", EmptyController.controller_path
+    assert_equal EmptyController.controller_path, EmptyController.new.controller_path
+    assert_equal "submodule/contained_empty", Submodule::ContainedEmptyController.controller_path
+    assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
+  end
+
+  def test_controller_name
+    assert_equal "empty", EmptyController.controller_name
+    assert_equal "contained_empty", Submodule::ContainedEmptyController.controller_name
+  end
+
+  def test_no_deprecation_when_action_view_record_identifier_is_included
+    record = Comment.new
+    record.save
+
+    dom_id = nil
+    assert_not_deprecated do
+      dom_id = RecordIdentifierIncludedController.new.dom_id(record)
+    end
+
+    assert_equal "comment_1", dom_id
+
+    dom_class = nil
+    assert_not_deprecated do
+      dom_class = RecordIdentifierIncludedController.new.dom_class(record)
+    end
+    assert_equal "comment", dom_class
+  end
+end
+
+class ControllerInstanceTests < ActiveSupport::TestCase
+  def setup
+    @empty = EmptyController.new
+    @empty.set_request!(ActionDispatch::Request.empty)
+    @empty.set_response!(EmptyController.make_response!(@empty.request))
+    @contained = Submodule::ContainedEmptyController.new
+    @empty_controllers = [@empty, @contained]
+  end
+
+  def test_performed?
+    assert_not_predicate @empty, :performed?
+    @empty.response_body = ["sweet"]
+    assert_predicate @empty, :performed?
+  end
+
+  def test_action_methods
+    @empty_controllers.each do |c|
+      assert_equal Set.new, c.class.action_methods, "#{c.controller_path} should be empty!"
+    end
+  end
+
+  def test_temporary_anonymous_controllers
+    name = "ExamplesController"
+    klass = Class.new(ActionController::Base)
+    Object.const_set(name, klass)
+
+    controller = klass.new
+    assert_equal "examples", controller.controller_path
+  end
+
+  def test_response_has_default_headers
+    original_default_headers = ActionDispatch::Response.default_headers
+
+    ActionDispatch::Response.default_headers = {
+      "X-Frame-Options" => "DENY",
+      "X-Content-Type-Options" => "nosniff",
+      "X-XSS-Protection" => "1;"
+    }
+
+    response_headers = SimpleController.action("hello").call(
+      "REQUEST_METHOD" => "GET",
+      "rack.input" => -> {}
+    )[1]
+
+    assert response_headers.key?("X-Frame-Options")
+    assert response_headers.key?("X-Content-Type-Options")
+    assert response_headers.key?("X-XSS-Protection")
+  ensure
+    ActionDispatch::Response.default_headers = original_default_headers
+  end
+end
+
+class PerformActionTest < ActionController::TestCase
+  def use_controller(controller_class)
+    @controller = controller_class.new
+
+    # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
+    # a more accurate simulation of what happens in "real life".
+    @controller.logger = ActiveSupport::Logger.new(nil)
+
+    @request.host = "www.nextangle.com"
+  end
+
+  def test_process_should_be_precise
+    use_controller EmptyController
+    exception = assert_raise AbstractController::ActionNotFound do
+      get :non_existent
+    end
+    assert_equal "The action 'non_existent' could not be found for EmptyController", exception.message
+  end
+
+  def test_action_missing_should_work
+    use_controller ActionMissingController
+    get :arbitrary_action
+    assert_equal "Response for arbitrary_action", @response.body
+  end
+end
+
+class UrlOptionsTest < ActionController::TestCase
+  tests UrlOptionsController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+  end
+
+  def test_url_for_query_params_included
+    rs = ActionDispatch::Routing::RouteSet.new
+    rs.draw do
+      get "home" => "pages#home"
+    end
+
+    options = {
+      action: "home",
+      controller: "pages",
+      only_path: true,
+      params: { "token" => "secret" }
+    }
+
+    assert_equal "/home?token=secret", rs.url_for(options)
+  end
+
+  def test_url_options_override
+    with_routing do |set|
+      set.draw do
+        get "from_view", to: "url_options#from_view", as: :from_view
+
+        ActiveSupport::Deprecation.silence do
+          get ":controller/:action"
+        end
+      end
+
+      get :from_view, params: { route: "from_view_url" }
+
+      assert_equal "http://www.override.com/from_view", @response.body
+      assert_equal "http://www.override.com/from_view", @controller.send(:from_view_url)
+      assert_equal "http://www.override.com/default_url_options/index", @controller.url_for(controller: "default_url_options")
+    end
+  end
+
+  def test_url_helpers_does_not_become_actions
+    with_routing do |set|
+      set.draw do
+        get "account/overview"
+      end
+
+      assert_not_includes @controller.class.action_methods, "account_overview_path"
+    end
+  end
+end
+
+class DefaultUrlOptionsTest < ActionController::TestCase
+  tests DefaultUrlOptionsController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+  end
+
+  def test_default_url_options_override
+    with_routing do |set|
+      set.draw do
+        get "from_view", to: "default_url_options#from_view", as: :from_view
+
+        ActiveSupport::Deprecation.silence do
+          get ":controller/:action"
+        end
+      end
+
+      get :from_view, params: { route: "from_view_url" }
+
+      assert_equal "http://www.override.com/from_view?locale=en", @response.body
+      assert_equal "http://www.override.com/from_view?locale=en", @controller.send(:from_view_url)
+      assert_equal "http://www.override.com/default_url_options/new?locale=en", @controller.url_for(controller: "default_url_options")
+    end
+  end
+
+  def test_default_url_options_are_used_in_non_positional_parameters
+    with_routing do |set|
+      set.draw do
+        scope("/:locale") do
+          resources :descriptions
+        end
+
+        ActiveSupport::Deprecation.silence do
+          get ":controller/:action"
+        end
+      end
+
+      get :from_view, params: { route: "description_path(1)" }
+
+      assert_equal "/en/descriptions/1", @response.body
+      assert_equal "/en/descriptions", @controller.send(:descriptions_path)
+      assert_equal "/pl/descriptions", @controller.send(:descriptions_path, "pl")
+      assert_equal "/pl/descriptions", @controller.send(:descriptions_path, locale: "pl")
+      assert_equal "/pl/descriptions.xml", @controller.send(:descriptions_path, "pl", "xml")
+      assert_equal "/en/descriptions.xml", @controller.send(:descriptions_path, format: "xml")
+      assert_equal "/en/descriptions/1", @controller.send(:description_path, 1)
+      assert_equal "/pl/descriptions/1", @controller.send(:description_path, "pl", 1)
+      assert_equal "/pl/descriptions/1", @controller.send(:description_path, 1, locale: "pl")
+      assert_equal "/pl/descriptions/1.xml", @controller.send(:description_path, "pl", 1, "xml")
+      assert_equal "/en/descriptions/1.xml", @controller.send(:description_path, 1, format: "xml")
+    end
+  end
+end
+
+class OptionalDefaultUrlOptionsControllerTest < ActionController::TestCase
+  def test_default_url_options_override_missing_positional_arguments
+    with_routing do |set|
+      set.draw do
+        get "/things/:id(.:format)" => "things#show", :as => :thing
+      end
+      assert_equal "/things/1.atom", thing_path("1")
+      assert_equal "/things/default-id.atom", thing_path
+    end
+  end
+end
+
+class EmptyUrlOptionsTest < ActionController::TestCase
+  tests NonEmptyController
+
+  def setup
+    super
+    @request.host = "www.example.com"
+  end
+
+  def test_ensure_url_for_works_as_expected_when_called_with_no_options_if_default_url_options_is_not_set
+    get :public_action
+    assert_equal "http://www.example.com/non_empty/public_action", @controller.url_for
+  end
+
+  def test_named_routes_with_path_without_doing_a_request_first
+    @controller = EmptyController.new
+    @controller.request = @request
+
+    with_routing do |set|
+      set.draw do
+        resources :things
+      end
+
+      assert_equal "/things", @controller.send(:things_path)
+    end
+  end
+end