hanami 2.3.2 → 3.0.0

data/spec/integration/router/resource_routes_spec.rb

@@ -1,281 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/inflector"
-require "hanami/slice/router"
-require "json"
-
-RSpec.describe "Router / Resource routes" do
-  let(:router) { Hanami::Slice::Router.new(routes:, resolver:, inflector: Dry::Inflector.new) { } }
-
-  let(:resolver) { Hanami::Slice::Routing::Resolver.new(slice:) }
-  let(:slice) {
-    Class.new(Hanami::Slice).tap { |slice|
-      allow(slice).to receive(:container) { actions_container }
-      allow(slice).to receive(:slices) { {reviews: child_slice} }
-    }
-  }
-  let(:child_slice) {
-    Class.new(Hanami::Slice).tap { |slice|
-      allow(slice).to receive(:container) { actions_container("[reviews]") }
-    }
-  }
-  def actions_container(prefix = nil)
-    Hash.new { |_hsh, key|
-      Class.new { |klass|
-        klass.define_method(:call) do |env|
-          body = key
-          body = "#{body} #{JSON.generate(env["router.params"])}" if env["router.params"].any?
-          body = "#{prefix}#{body}" if prefix
-          [200, {}, body]
-        end
-      }.new
-    }.tap { |container|
-      def container.resolve(key) = self[key]
-    }
-  end
-
-  let(:app) { Rack::MockRequest.new(router) }
-  def routed(method, url)
-    app.request(method, url).body
-  end
-
-  describe "resources" do
-    let(:routes) { proc { resources :posts } }
-
-    it "routes all RESTful actions to the resource" do
-      expect(routed("GET", "/posts")).to eq %(actions.posts.index)
-      expect(routed("GET", "/posts/new")).to eq %(actions.posts.new)
-      expect(routed("POST", "/posts")).to eq %(actions.posts.create)
-      expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
-      expect(routed("GET", "/posts/1/edit")).to eq %(actions.posts.edit {"id":"1"})
-      expect(routed("PATCH", "/posts/1")).to eq %(actions.posts.update {"id":"1"})
-      expect(routed("DELETE", "/posts/1")).to eq %(actions.posts.destroy {"id":"1"})
-
-      expect(router.path("posts")).to eq "/posts"
-      expect(router.path("new_post")).to eq "/posts/new"
-      expect(router.path("edit_post", id: 1)).to eq "/posts/1/edit"
-    end
-
-    describe "with :only" do
-      let(:routes) { proc { resources :posts, only: %i(index show) } }
-
-      it "routes only the given actions to the resource" do
-        expect(routed("GET", "/posts")).to eq %(actions.posts.index)
-        expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
-
-        expect(routed("GET", "/posts/new")).not_to eq %(actions.posts.new)
-        expect(routed("POST", "/posts")).to eq "Method Not Allowed"
-        expect(routed("GET", "/posts/1/edit")).to eq "Not Found"
-        expect(routed("PATCH", "/posts/1")).to eq "Method Not Allowed"
-        expect(routed("DELETE", "/posts/1")).to eq "Method Not Allowed"
-      end
-    end
-
-    describe "with :except" do
-      let(:routes) { proc { resources :posts, except: %i(edit update destroy) } }
-
-      it "routes all except the given actions to the resource" do
-        expect(routed("GET", "/posts")).to eq %(actions.posts.index)
-        expect(routed("GET", "/posts/new")).to eq %(actions.posts.new)
-        expect(routed("POST", "/posts")).to eq %(actions.posts.create)
-        expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
-
-        expect(routed("GET", "/posts/1/edit")).to eq "Not Found"
-        expect(routed("PATCH", "/posts/1")).to eq "Method Not Allowed"
-        expect(routed("DELETE", "/posts/1")).to eq "Method Not Allowed"
-      end
-    end
-
-    describe "with :to" do
-      let(:routes) { proc { resources :posts, to: "articles" } }
-
-      it "uses actions from the given container key namespace" do
-        expect(routed("GET", "/posts")).to eq %(actions.articles.index)
-        expect(routed("GET", "/posts/new")).to eq %(actions.articles.new)
-        expect(routed("POST", "/posts")).to eq %(actions.articles.create)
-        expect(routed("GET", "/posts/1")).to eq %(actions.articles.show {"id":"1"})
-        expect(routed("GET", "/posts/1/edit")).to eq %(actions.articles.edit {"id":"1"})
-        expect(routed("PATCH", "/posts/1")).to eq %(actions.articles.update {"id":"1"})
-        expect(routed("DELETE", "/posts/1")).to eq %(actions.articles.destroy {"id":"1"})
-      end
-    end
-
-    describe "witih :path" do
-      let(:routes) { proc { resources :posts, path: "articles" } }
-
-      it "uses the given path for the routes" do
-        expect(routed("GET", "/articles")).to eq %(actions.posts.index)
-        expect(routed("GET", "/articles/new")).to eq %(actions.posts.new)
-        expect(routed("POST", "/articles")).to eq %(actions.posts.create)
-        expect(routed("GET", "/articles/1")).to eq %(actions.posts.show {"id":"1"})
-        expect(routed("GET", "/articles/1/edit")).to eq %(actions.posts.edit {"id":"1"})
-        expect(routed("PATCH", "/articles/1")).to eq %(actions.posts.update {"id":"1"})
-        expect(routed("DELETE", "/articles/1")).to eq %(actions.posts.destroy {"id":"1"})
-      end
-    end
-  end
-
-  describe "resource" do
-    let(:routes) { proc { resource :profile } }
-
-    it "routes all RESTful actions (except index) to the resource" do
-      expect(routed("GET", "/profile/new")).to eq %(actions.profile.new)
-      expect(routed("POST", "/profile")).to eq %(actions.profile.create)
-      expect(routed("GET", "/profile")).to eq %(actions.profile.show)
-      expect(routed("GET", "/profile/edit")).to eq %(actions.profile.edit)
-      expect(routed("PATCH", "/profile")).to eq %(actions.profile.update)
-      expect(routed("DELETE", "/profile")).to eq %(actions.profile.destroy)
-
-      expect(routed("GET", "/profiles")).to eq "Not Found"
-      expect(routed("GET", "/profiles/1")).to eq "Not Found"
-      expect(routed("GET", "/profile/1")).to eq "Not Found"
-
-      expect(router.path("profile")).to eq "/profile"
-      expect(router.path("new_profile")).to eq "/profile/new"
-      expect(router.path("edit_profile")).to eq "/profile/edit"
-    end
-
-    describe "with :only" do
-      let(:routes) { proc { resource :profile, only: %i(show edit update) } }
-
-      it "routes only the given actions to the resource" do
-        expect(routed("GET", "/profile")).to eq %(actions.profile.show)
-        expect(routed("GET", "/profile/edit")).to eq %(actions.profile.edit)
-        expect(routed("PATCH", "/profile")).to eq %(actions.profile.update)
-
-        expect(routed("GET", "/profile/new")).to eq "Not Found"
-        expect(routed("POST", "/profile")).to eq "Method Not Allowed"
-        expect(routed("DELETE", "/profile")).to eq "Method Not Allowed"
-      end
-    end
-
-    describe "with :except" do
-      let(:routes) { proc { resource :profile, except: %i(edit update destroy) } }
-
-      it "routes all except the given actions to the resource" do
-        expect(routed("GET", "/profile/new")).to eq %(actions.profile.new)
-        expect(routed("POST", "/profile")).to eq %(actions.profile.create)
-        expect(routed("GET", "/profile")).to eq %(actions.profile.show)
-
-        expect(routed("GET", "/profile/edit")).to eq "Not Found"
-        expect(routed("PATCH", "/profile")).to eq "Method Not Allowed"
-        expect(routed("DELETE", "/profile")).to eq "Method Not Allowed"
-      end
-    end
-
-    describe "with :to" do
-      let(:routes) { proc { resource :profile, to: "user" } }
-
-      it "uses actions from the given container key namespace" do
-        expect(routed("GET", "/profile/new")).to eq %(actions.user.new)
-        expect(routed("POST", "/profile")).to eq %(actions.user.create)
-        expect(routed("GET", "/profile")).to eq %(actions.user.show)
-        expect(routed("GET", "/profile/edit")).to eq %(actions.user.edit)
-        expect(routed("PATCH", "/profile")).to eq %(actions.user.update)
-        expect(routed("DELETE", "/profile")).to eq %(actions.user.destroy)
-      end
-    end
-
-    describe "with :path" do
-      let(:routes) { proc { resource :profile, path: "user"} }
-
-      it "uses the given path for the routes" do
-        expect(routed("GET", "/user/new")).to eq %(actions.profile.new)
-        expect(routed("POST", "/user")).to eq %(actions.profile.create)
-        expect(routed("GET", "/user")).to eq %(actions.profile.show)
-        expect(routed("GET", "/user/edit")).to eq %(actions.profile.edit)
-        expect(routed("PATCH", "/user")).to eq %(actions.profile.update)
-        expect(routed("DELETE", "/user")).to eq %(actions.profile.destroy)
-      end
-    end
-  end
-
-  describe "nested resources" do
-    let(:routes) {
-      proc {
-        resources :cafes, only: :show do
-          resources :reviews, only: :index do
-            resources :comments, only: [:index, :new, :create]
-          end
-        end
-
-        resource :profile, only: :show do
-          resource :avatar, only: :show do
-            resources :comments, only: :index
-          end
-        end
-      }
-    }
-
-    it "routes to the nested resources" do
-      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
-      expect(routed("GET", "/cafes/1/reviews")).to eq %(actions.cafes.reviews.index {"cafe_id":"1"})
-      expect(routed("GET", "/cafes/1/reviews/2/comments")).to eq %(actions.cafes.reviews.comments.index {"cafe_id":"1","review_id":"2"})
-
-      expect(router.path("cafe", id: 1)).to eq "/cafes/1"
-      expect(router.path("cafe_reviews", cafe_id: 1)).to eq "/cafes/1/reviews"
-      expect(router.path("cafe_review_comments", cafe_id: 1, review_id: 1)).to eq "/cafes/1/reviews/1/comments"
-      expect(router.path("new_cafe_review_comment", cafe_id: 1, review_id: 1)).to eq "/cafes/1/reviews/1/comments/new"
-
-      expect(routed("GET", "/profile")).to eq %(actions.profile.show)
-      expect(routed("GET", "/profile/avatar")).to eq %(actions.profile.avatar.show)
-      expect(routed("GET", "/profile/avatar/comments")).to eq %(actions.profile.avatar.comments.index)
-    end
-  end
-
-  describe "standalone routes nested under resources" do
-    let(:routes) {
-      proc {
-        resources :cafes, only: :show do
-          get "/top-reviews", to: "cafes.top_reviews.index", as: :top_reviews
-        end
-      }
-    }
-
-    it "nests the standalone route under the resource" do
-      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
-      expect(routed("GET", "/cafes/1/top-reviews")).to eq %(actions.cafes.top_reviews.index {"cafe_id":"1"})
-
-      expect(router.path("cafe_top_reviews", cafe_id: 1)).to eq "/cafes/1/top-reviews"
-    end
-  end
-
-  describe "resources nested under scopes" do
-    let(:routes) {
-      proc {
-        scope "coffee-lovers" do
-          resources :cafes, only: :show do
-            get "/top-reviews", to: "cafes.top_reviews.index", as: :top_reviews
-          end
-        end
-      }
-    }
-
-    it "routes to the resources under the scope" do
-      expect(routed("GET", "/coffee-lovers/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
-      expect(routed("GET", "/coffee-lovers/cafes/1/top-reviews")).to eq %(actions.cafes.top_reviews.index {"cafe_id":"1"})
-
-      expect(router.path("coffee_lovers_cafe", id: 1)).to eq "/coffee-lovers/cafes/1"
-      expect(router.path("coffee_lovers_cafe_top_reviews", cafe_id: 1)).to eq "/coffee-lovers/cafes/1/top-reviews"
-    end
-  end
-
-  describe "slices nested under resources" do
-    let(:routes) {
-      proc {
-        resources :cafes, only: :show do
-          slice :reviews, at: "" do
-            resources :reviews, only: :index
-          end
-        end
-      }
-    }
-
-    it "routes to actions within the nested slice" do
-      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
-      expect(routed("GET", "/cafes/1/reviews")).to eq %([reviews]actions.cafes.reviews.index {"cafe_id":"1"})
-
-      expect(router.path("cafe_reviews", cafe_id: 1)).to eq "/cafes/1/reviews"
-    end
-  end
-end

data/spec/integration/settings/access_in_slice_class_body_spec.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Settings / Access within slice class bodies", :app_integration do
-  before do
-    @env = ENV.to_h
-    allow(Hanami::Env).to receive(:loaded?).and_return(false)
-  end
-
-  after do
-    ENV.replace(@env)
-  end
-
-  context "app class" do
-    it "provides access to the settings inside the class body" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-              @some_flag = settings.some_flag
-            end
-          end
-        RUBY
-
-        write ".env", <<~'TEXT'
-          SOME_FLAG=true
-        TEXT
-
-        write "config/settings.rb", <<~'RUBY'
-          module TestApp
-            class Settings < Hanami::Settings
-              setting :some_flag
-            end
-          end
-        RUBY
-
-        require "hanami/setup"
-
-        expect(Hanami.app.instance_variable_get(:@some_flag)).to eq "true"
-      end
-    end
-  end
-
-  context "slice class" do
-    it "provides access to the settings inside the class body" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "config/slices/main.rb", <<~'RUBY'
-          module Main
-            class Slice < Hanami::Slice
-              @some_flag = settings.some_flag
-            end
-          end
-        RUBY
-
-        write ".env", <<~'TEXT'
-          SOME_FLAG=true
-        TEXT
-
-        write "slices/main/config/settings.rb", <<~'RUBY'
-          module Main
-            class Settings < Hanami::Settings
-              setting :some_flag
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        expect(Main::Slice.instance_variable_get(:@some_flag)).to eq "true"
-      end
-    end
-  end
-end

data/spec/integration/settings/access_to_constants_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Settings / Access to constants", :app_integration do
-  before do
-    @env = ENV.to_h
-  end
-
-  after do
-    ENV.replace(@env)
-  end
-
-  specify "Settings can not access autoloadable constants" do
-    with_directory(make_tmp_directory) do
-      write "config/app.rb", <<~'RUBY'
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "config/settings.rb", <<~'RUBY'
-        module TestApp
-          class Settings < Hanami::Settings
-            setting :some_flag, constructor: TestApp::Types::Params::Bool
-          end
-        end
-      RUBY
-
-      write "app/types.rb", <<~'RUBY'
-        # auto_register: false
-
-        require "dry/types"
-
-        module TestApp
-          Types = Dry.Types()
-        end
-      RUBY
-
-      require "hanami/setup"
-
-      expect { Hanami.app.settings }.to raise_error(NameError, /TestApp::Types/)
-    end
-  end
-end

data/spec/integration/settings/loading_from_env_spec.rb

@@ -1,188 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Settings / Access to constants", :app_integration do
-  before do
-    @env = ENV.to_h
-    allow(Hanami::Env).to receive(:loaded?).and_return(false)
-  end
-
-  after do
-    ENV.replace(@env)
-  end
-
-  specify "settings are loaded from ENV" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~'RUBY'
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "config/settings.rb", <<~'RUBY'
-        module TestApp
-          class Settings < Hanami::Settings
-            setting :database_url
-          end
-        end
-      RUBY
-
-      ENV["DATABASE_URL"] = "postgres://localhost/database"
-
-      require "hanami/prepare"
-
-      expect(Hanami.app["settings"].database_url).to eq "postgres://localhost/database"
-    end
-  end
-
-  describe "settings are loaded from .env files" do
-    context "hanami env is development" do
-      it "loads settings from .env.development.local, .env.local, .env.development and .env (in this order)" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              end
-            end
-          RUBY
-
-          write "config/settings.rb", <<~'RUBY'
-            module TestApp
-              class Settings < Hanami::Settings
-                setting :from_specific_env_local
-                setting :from_base_local
-                setting :from_specific_env
-                setting :from_base
-              end
-            end
-          RUBY
-
-          write ".env.development.local", <<~'TEXT'
-            FROM_SPECIFIC_ENV_LOCAL="from .env.development.local"
-          TEXT
-
-          write ".env.local", <<~'TEXT'
-            FROM_BASE_LOCAL="from .env.local"
-
-            FROM_SPECIFIC_ENV_LOCAL=nope
-          TEXT
-
-          write ".env.development", <<~'TEXT'
-            FROM_SPECIFIC_ENV="from .env.development"
-
-            FROM_SPECIFIC_ENV_LOCAL=nope
-            FROM_BASE_LOCAL=nope
-          TEXT
-
-          write ".env", <<~'TEXT'
-            FROM_BASE="from .env"
-
-            FROM_SPECIFIC_ENV_LOCAL=nope
-            FROM_BASE_LOCAL=nope
-            FROM_SPECIFIC_ENV=nope
-          TEXT
-
-          ENV["HANAMI_ENV"] = "development"
-
-          require "hanami/prepare"
-
-          expect(Hanami.app["settings"].from_specific_env_local).to eq "from .env.development.local"
-          expect(Hanami.app["settings"].from_base_local).to eq "from .env.local"
-          expect(Hanami.app["settings"].from_specific_env).to eq "from .env.development"
-          expect(Hanami.app["settings"].from_base).to eq "from .env"
-        end
-      end
-
-      context "hanami env is test" do
-        it "loads settings from .env.development.local, .env.development and .env (in this order)" do
-          with_tmp_directory(Dir.mktmpdir) do
-            write "config/app.rb", <<~'RUBY'
-              require "hanami"
-
-              module TestApp
-                class App < Hanami::App
-                end
-              end
-            RUBY
-
-            write "config/settings.rb", <<~'RUBY'
-              module TestApp
-                class Settings < Hanami::Settings
-                  setting :from_specific_env_local
-                  setting :from_base_local
-                  setting :from_specific_env
-                  setting :from_base
-                end
-              end
-            RUBY
-
-            write ".env.test.local", <<~'TEXT'
-              FROM_SPECIFIC_ENV_LOCAL="from .env.test.local"
-            TEXT
-
-            write ".env.local", <<~'TEXT'
-              FROM_BASE_LOCAL="from .env.local"
-            TEXT
-
-            write ".env.test", <<~'TEXT'
-              FROM_SPECIFIC_ENV="from .env.test"
-
-              FROM_SPECIFIC_ENV_LOCAL=nope
-            TEXT
-
-            write ".env", <<~'TEXT'
-              FROM_BASE="from .env"
-
-              FROM_SPECIFIC_ENV_LOCAL=nope
-              FROM_SPECIFIC_ENV=nope
-            TEXT
-
-            ENV["HANAMI_ENV"] = "test"
-
-            require "hanami/prepare"
-
-            expect(Hanami.app["settings"].from_specific_env_local).to eq "from .env.test.local"
-            expect(Hanami.app["settings"].from_base_local).to be nil
-            expect(Hanami.app["settings"].from_specific_env).to eq "from .env.test"
-            expect(Hanami.app["settings"].from_base).to eq "from .env"
-          end
-        end
-      end
-    end
-  end
-
-  it "prefers ENV values are preferred over .env files" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~'RUBY'
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "config/settings.rb", <<~'RUBY'
-        module TestApp
-          class Settings < Hanami::Settings
-            setting :database_url
-          end
-        end
-      RUBY
-
-      write ".env", <<~'TEXT'
-        DATABASE_URL=nope
-      TEXT
-
-      ENV["DATABASE_URL"] = "postgres://localhost/database"
-
-      require "hanami/prepare"
-
-      expect(Hanami.app["settings"].database_url).to eq "postgres://localhost/database"
-    end
-  end
-end