jets 1.4.11 → 1.5.0

data/vendor/rails/actionpack/test/dispatch/mount_test.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "rails/engine"
+
+class TestRoutingMount < ActionDispatch::IntegrationTest
+  Router = ActionDispatch::Routing::RouteSet.new
+
+  class AppWithRoutes < Rails::Engine
+    def self.routes
+      @routes ||= ActionDispatch::Routing::RouteSet.new
+    end
+  end
+
+  # Test for mounting apps that respond to routes, but aren't Rails-like apps.
+  class SinatraLikeApp
+    def self.routes; Object.new; end
+
+    def self.call(env)
+      [200, { "Content-Type" => "text/html" }, ["OK"]]
+    end
+  end
+
+  Router.draw do
+    SprocketsApp = lambda { |env|
+      [200, { "Content-Type" => "text/html" }, ["#{env["SCRIPT_NAME"]} -- #{env["PATH_INFO"]}"]]
+    }
+
+    mount SprocketsApp, at: "/sprockets"
+    mount SprocketsApp => "/shorthand"
+
+    mount SinatraLikeApp, at: "/fakeengine", as: :fake
+    mount SinatraLikeApp, at: "/getfake", via: :get
+
+    scope "/its_a" do
+      mount SprocketsApp, at: "/sprocket"
+    end
+
+    resources :users do
+      mount AppWithRoutes, at: "/fakeengine", as: :fake_mounted_at_resource
+    end
+
+    mount SprocketsApp, at: "/", via: :get
+  end
+
+  APP = RoutedRackApp.new Router
+  def app
+    APP
+  end
+
+  def test_app_name_is_properly_generated_when_engine_is_mounted_in_resources
+    assert Router.mounted_helpers.method_defined?(:user_fake_mounted_at_resource),
+          "A mounted helper should be defined with a parent's prefix"
+    assert Router.named_routes.key?(:user_fake_mounted_at_resource),
+          "A named route should be defined with a parent's prefix"
+  end
+
+  def test_mounting_at_root_path
+    get "/omg"
+    assert_equal " -- /omg", response.body
+  end
+
+  def test_mounting_sets_script_name
+    get "/sprockets/omg"
+    assert_equal "/sprockets -- /omg", response.body
+  end
+
+  def test_mounting_works_with_nested_script_name
+    get "/foo/sprockets/omg", headers: { "SCRIPT_NAME" => "/foo", "PATH_INFO" => "/sprockets/omg" }
+    assert_equal "/foo/sprockets -- /omg", response.body
+  end
+
+  def test_mounting_works_with_scope
+    get "/its_a/sprocket/omg"
+    assert_equal "/its_a/sprocket -- /omg", response.body
+  end
+
+  def test_mounting_with_shorthand
+    get "/shorthand/omg"
+    assert_equal "/shorthand -- /omg", response.body
+  end
+
+  def test_mounting_works_with_via
+    get "/getfake"
+    assert_equal "OK", response.body
+
+    post "/getfake"
+    assert_response :not_found
+  end
+
+  def test_with_fake_engine_does_not_call_invalid_method
+    get "/fakeengine"
+    assert_equal "OK", response.body
+  end
+end

data/vendor/rails/actionpack/test/dispatch/prefix_generation_test.rb

@@ -0,0 +1,463 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "rack/test"
+require "rails/engine"
+
+module TestGenerationPrefix
+  class Post
+    extend ActiveModel::Naming
+
+    def to_param
+      "1"
+    end
+
+    def self.model_name
+      klass = "Post".dup
+      def klass.name; self end
+
+      ActiveModel::Name.new(klass)
+    end
+
+    def to_model; self; end
+    def persisted?; true; end
+  end
+
+  class WithMountedEngine < ActionDispatch::IntegrationTest
+    class BlogEngine < Rails::Engine
+      routes.draw do
+        get "/posts/:id", to: "inside_engine_generating#show", as: :post
+        get "/posts", to: "inside_engine_generating#index", as: :posts
+        get "/url_to_application", to: "inside_engine_generating#url_to_application"
+        get "/polymorphic_path_for_engine", to: "inside_engine_generating#polymorphic_path_for_engine"
+        get "/conflicting_url", to: "inside_engine_generating#conflicting"
+        get "/foo", to: "never#invoked", as: :named_helper_that_should_be_invoked_only_in_respond_to_test
+
+        get "/relative_path_root",       to: redirect("")
+        get "/relative_path_redirect",   to: redirect("foo")
+        get "/relative_option_root",     to: redirect(path: "")
+        get "/relative_option_redirect", to: redirect(path: "foo")
+        get "/relative_custom_root",     to: redirect { |params, request| "" }
+        get "/relative_custom_redirect", to: redirect { |params, request| "foo" }
+
+        get "/absolute_path_root",       to: redirect("/")
+        get "/absolute_path_redirect",   to: redirect("/foo")
+        get "/absolute_option_root",     to: redirect(path: "/")
+        get "/absolute_option_redirect", to: redirect(path: "/foo")
+        get "/absolute_custom_root",     to: redirect { |params, request| "/" }
+        get "/absolute_custom_redirect", to: redirect { |params, request| "/foo" }
+      end
+    end
+
+    class RailsApplication < Rails::Engine
+      routes.draw do
+        scope "/:omg", omg: "awesome" do
+          mount BlogEngine => "/blog", :as => "blog_engine"
+        end
+        get "/posts/:id", to: "outside_engine_generating#post", as: :post
+        get "/generate", to: "outside_engine_generating#index"
+        get "/polymorphic_path_for_app", to: "outside_engine_generating#polymorphic_path_for_app"
+        get "/polymorphic_path_for_engine", to: "outside_engine_generating#polymorphic_path_for_engine"
+        get "/polymorphic_with_url_for", to: "outside_engine_generating#polymorphic_with_url_for"
+        get "/conflicting_url", to: "outside_engine_generating#conflicting"
+        get "/ivar_usage", to: "outside_engine_generating#ivar_usage"
+        root to: "outside_engine_generating#index"
+      end
+    end
+
+    # force draw
+    RailsApplication.routes.define_mounted_helper(:main_app)
+
+    class ::InsideEngineGeneratingController < ActionController::Base
+      include BlogEngine.routes.url_helpers
+      include RailsApplication.routes.mounted_helpers
+
+      def index
+        render plain: posts_path
+      end
+
+      def show
+        render plain: post_path(id: params[:id])
+      end
+
+      def url_to_application
+        path = main_app.url_for(controller: "outside_engine_generating",
+                                action: "index",
+                                only_path: true)
+        render plain: path
+      end
+
+      def polymorphic_path_for_engine
+        render plain: polymorphic_path(Post.new)
+      end
+
+      def conflicting
+        render plain: "engine"
+      end
+    end
+
+    class ::OutsideEngineGeneratingController < ActionController::Base
+      include BlogEngine.routes.mounted_helpers
+      include RailsApplication.routes.url_helpers
+
+      def index
+        render plain: blog_engine.post_path(id: 1)
+      end
+
+      def polymorphic_path_for_engine
+        render plain: blog_engine.polymorphic_path(Post.new)
+      end
+
+      def polymorphic_path_for_app
+        render plain: polymorphic_path(Post.new)
+      end
+
+      def polymorphic_with_url_for
+        render plain: blog_engine.url_for(Post.new)
+      end
+
+      def conflicting
+        render plain: "application"
+      end
+
+      def ivar_usage
+        @blog_engine = "Not the engine route helper"
+        render plain: blog_engine.post_path(id: 1)
+      end
+    end
+
+    class EngineObject
+      include ActionDispatch::Routing::UrlFor
+      include BlogEngine.routes.url_helpers
+    end
+
+    class AppObject
+      include ActionDispatch::Routing::UrlFor
+      include RailsApplication.routes.url_helpers
+    end
+
+    def app
+      RailsApplication.instance
+    end
+
+    attr_reader :engine_object, :app_object
+
+    def setup
+      RailsApplication.routes.default_url_options = {}
+      @engine_object = EngineObject.new
+      @app_object = AppObject.new
+    end
+
+    include BlogEngine.routes.mounted_helpers
+
+    # Inside Engine
+    test "[ENGINE] generating engine's url use SCRIPT_NAME from request" do
+      get "/pure-awesomeness/blog/posts/1"
+      assert_equal "/pure-awesomeness/blog/posts/1", response.body
+    end
+
+    test "[ENGINE] generating application's url never uses SCRIPT_NAME from request" do
+      get "/pure-awesomeness/blog/url_to_application"
+      assert_equal "/generate", response.body
+    end
+
+    test "[ENGINE] generating engine's url with polymorphic path" do
+      get "/pure-awesomeness/blog/polymorphic_path_for_engine"
+      assert_equal "/pure-awesomeness/blog/posts/1", response.body
+    end
+
+    test "[ENGINE] url_helpers from engine have higher priority than application's url_helpers" do
+      get "/awesome/blog/conflicting_url"
+      assert_equal "engine", response.body
+    end
+
+    test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_path_root"
+      verify_redirect "http://www.example.com/awesome/blog"
+    end
+
+    test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_path_redirect"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
+    end
+
+    test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_option_root"
+      verify_redirect "http://www.example.com/awesome/blog"
+    end
+
+    test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_option_redirect"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
+    end
+
+    test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_custom_root"
+      verify_redirect "http://www.example.com/awesome/blog"
+    end
+
+    test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
+      get "/awesome/blog/relative_custom_redirect"
+      verify_redirect "http://www.example.com/awesome/blog/foo"
+    end
+
+    test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_path_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_path_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_option_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_option_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_custom_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
+      get "/awesome/blog/absolute_custom_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    # Inside Application
+    test "[APP] generating engine's route includes prefix" do
+      get "/generate"
+      assert_equal "/awesome/blog/posts/1", response.body
+    end
+
+    test "[APP] generating engine's route includes default_url_options[:script_name]" do
+      RailsApplication.routes.default_url_options = { script_name: "/something" }
+      get "/generate"
+      assert_equal "/something/awesome/blog/posts/1", response.body
+    end
+
+    test "[APP] generating engine's url with polymorphic path" do
+      get "/polymorphic_path_for_engine"
+      assert_equal "/awesome/blog/posts/1", response.body
+    end
+
+    test "polymorphic_path_for_app" do
+      get "/polymorphic_path_for_app"
+      assert_equal "/posts/1", response.body
+    end
+
+    test "[APP] generating engine's url with url_for(@post)" do
+      get "/polymorphic_with_url_for"
+      assert_equal "http://www.example.com/awesome/blog/posts/1", response.body
+    end
+
+    test "[APP] instance variable with same name as engine" do
+      get "/ivar_usage"
+      assert_equal "/awesome/blog/posts/1", response.body
+    end
+
+    # Inside any Object
+    test "[OBJECT] proxy route should override respond_to?() as expected" do
+      assert_respond_to blog_engine, :named_helper_that_should_be_invoked_only_in_respond_to_test_path
+    end
+
+    test "[OBJECT] generating engine's route includes prefix" do
+      assert_equal "/awesome/blog/posts/1", engine_object.post_path(id: 1)
+    end
+
+    test "[OBJECT] generating engine's route includes dynamic prefix" do
+      assert_equal "/pure-awesomeness/blog/posts/3", engine_object.post_path(id: 3, omg: "pure-awesomeness")
+    end
+
+    test "[OBJECT] generating engine's route includes default_url_options[:script_name]" do
+      RailsApplication.routes.default_url_options = { script_name: "/something" }
+      assert_equal "/something/pure-awesomeness/blog/posts/3", engine_object.post_path(id: 3, omg: "pure-awesomeness")
+    end
+
+    test "[OBJECT] generating application's route" do
+      assert_equal "/", app_object.root_path
+    end
+
+    test "[OBJECT] generating application's route includes default_url_options[:script_name]" do
+      RailsApplication.routes.default_url_options = { script_name: "/something" }
+      assert_equal "/something/", app_object.root_path
+    end
+
+    test "[OBJECT] generating application's route includes default_url_options[:trailing_slash]" do
+      RailsApplication.routes.default_url_options[:trailing_slash] = true
+      assert_equal "/awesome/blog/posts", engine_object.posts_path
+    end
+
+    test "[OBJECT] generating engine's route with url_for" do
+      path = engine_object.url_for(controller: "inside_engine_generating",
+                                   action: "show",
+                                   only_path: true,
+                                   omg: "omg",
+                                   id: 1)
+      assert_equal "/omg/blog/posts/1", path
+    end
+
+    test "[OBJECT] generating engine's route with named helpers" do
+      path = engine_object.posts_path
+      assert_equal "/awesome/blog/posts", path
+
+      path = engine_object.posts_url(host: "example.com")
+      assert_equal "http://example.com/awesome/blog/posts", path
+    end
+
+    test "[OBJECT] generating engine's route with polymorphic_url" do
+      path = engine_object.polymorphic_path(Post.new)
+      assert_equal "/awesome/blog/posts/1", path
+
+      path = engine_object.polymorphic_url(Post.new, host: "www.example.com")
+      assert_equal "http://www.example.com/awesome/blog/posts/1", path
+    end
+
+    private
+      def verify_redirect(url, status = 301)
+        assert_equal status, response.status
+        assert_equal url, response.headers["Location"]
+        assert_equal expected_redirect_body(url), response.body
+      end
+
+      def expected_redirect_body(url)
+        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+      end
+  end
+
+  class EngineMountedAtRoot < ActionDispatch::IntegrationTest
+    class BlogEngine
+      def self.routes
+        @routes ||= begin
+          routes = ActionDispatch::Routing::RouteSet.new
+          routes.draw do
+            get "/posts/:id", to: "posts#show", as: :post
+
+            get "/relative_path_root",       to: redirect("")
+            get "/relative_path_redirect",   to: redirect("foo")
+            get "/relative_option_root",     to: redirect(path: "")
+            get "/relative_option_redirect", to: redirect(path: "foo")
+            get "/relative_custom_root",     to: redirect { |params, request| "" }
+            get "/relative_custom_redirect", to: redirect { |params, request| "foo" }
+
+            get "/absolute_path_root",       to: redirect("/")
+            get "/absolute_path_redirect",   to: redirect("/foo")
+            get "/absolute_option_root",     to: redirect(path: "/")
+            get "/absolute_option_redirect", to: redirect(path: "/foo")
+            get "/absolute_custom_root",     to: redirect { |params, request| "/" }
+            get "/absolute_custom_redirect", to: redirect { |params, request| "/foo" }
+          end
+
+          routes
+        end
+      end
+
+      def self.call(env)
+        env["action_dispatch.routes"] = routes
+        routes.call(env)
+      end
+    end
+
+    class RailsApplication < Rails::Engine
+      routes.draw do
+        mount BlogEngine => "/"
+      end
+    end
+
+    class ::PostsController < ActionController::Base
+      include BlogEngine.routes.url_helpers
+      include RailsApplication.routes.mounted_helpers
+
+      def show
+        render plain: post_path(id: params[:id])
+      end
+    end
+
+    def app
+      RailsApplication.instance
+    end
+
+    test "generating path inside engine" do
+      get "/posts/1"
+      assert_equal "/posts/1", response.body
+    end
+
+    test "[ENGINE] relative path root uses SCRIPT_NAME from request" do
+      get "/relative_path_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] relative path redirect uses SCRIPT_NAME from request" do
+      get "/relative_path_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] relative option root uses SCRIPT_NAME from request" do
+      get "/relative_option_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] relative option redirect uses SCRIPT_NAME from request" do
+      get "/relative_option_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] relative custom root uses SCRIPT_NAME from request" do
+      get "/relative_custom_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] relative custom redirect uses SCRIPT_NAME from request" do
+      get "/relative_custom_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] absolute path root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_path_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute path redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_path_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] absolute option root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_option_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute option redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_option_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    test "[ENGINE] absolute custom root doesn't use SCRIPT_NAME from request" do
+      get "/absolute_custom_root"
+      verify_redirect "http://www.example.com/"
+    end
+
+    test "[ENGINE] absolute custom redirect doesn't use SCRIPT_NAME from request" do
+      get "/absolute_custom_redirect"
+      verify_redirect "http://www.example.com/foo"
+    end
+
+    private
+      def verify_redirect(url, status = 301)
+        assert_equal status, response.status
+        assert_equal url, response.headers["Location"]
+        assert_equal expected_redirect_body(url), response.body
+      end
+
+      def expected_redirect_body(url)
+        %(<html><body>You are being <a href="#{url}">redirected</a>.</body></html>)
+      end
+  end
+end