jets 1.9.7 → 1.9.8

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

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

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

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

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

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

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

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

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

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

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

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