hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/rack_app/non_booted_rack_app_spec.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-require "stringio"
-
-RSpec.describe "Running a Rack app for a non-booted app", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  it "lazy loads only the components required for any accessed routes" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        require "hanami/routes"
-
-        module TestApp
-          class Routes < Hanami::Routes
-            slice :main, at: "/" do
-              root to: "home.show"
-              get "/articles", to: "articles.index"
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/lib/action.rb", <<~RUBY
-        # auto_register: false
-
-        require "hanami/action"
-
-        module Main
-          class Action < Hanami::Action
-          end
-        end
-      RUBY
-
-      write "slices/main/lib/article_repo.rb", <<~RUBY
-        module Main
-          class ArticleRepo < Hanami::Action
-          end
-        end
-      RUBY
-
-      write "slices/main/lib/greeter.rb", <<~RUBY
-        module Main
-          class Greeter
-            def greeting
-              "Hello world"
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/actions/home/show.rb", <<~RUBY
-        module Main
-          module Actions
-            module Home
-              class Show < Main::Action
-                include Deps["greeter"]
-
-                def handle(req, res)
-                  res.body = greeter.greeting
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/actions/articles/index.rb", <<~RUBY
-        module Main
-          module Actions
-            module Articles
-              class Index < Main::Action
-                include Deps["article_repo"]
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      get "/"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Hello world"
-
-      expect(Hanami.app).not_to be_booted
-      expect(Main::Slice.keys).to include(*%w[actions.home.show greeter])
-      expect(Main::Slice.keys).not_to include(*%w[actions.articles.index article_repo])
-    end
-  end
-end

data/spec/integration/rack_app/rack_app_spec.rb

@@ -1,442 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-require "stringio"
-
-RSpec.describe "Hanami web app", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  specify "Hanami.app returns a rack builder" do
-    with_tmp_directory do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            root to: ->(env) { [200, {}, ["OK"]] }
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      expect(app).to be(TestApp::App)
-    end
-  end
-
-  specify "Routing to actions based on their container identifiers" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            get "/health", to: "health.show"
-
-            get "/inline" do
-              "Inline"
-            end
-
-            slice :main, at: "/" do
-              root to: "home.index"
-            end
-
-            slice :admin, at: "/admin" do
-              get "/dashboard", to: "dashboard.show"
-            end
-          end
-        end
-      RUBY
-
-      write "app/actions/health/show.rb", <<~RUBY
-        require "hanami/action"
-
-        module TestApp
-          module Actions
-            module Health
-              class Show < Hanami::Action
-                def handle(*, res)
-                  res.body = "Health, OK"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/actions/home/index.rb", <<~RUBY
-        require "hanami/action"
-
-        module Main
-          module Actions
-            module Home
-              class Index < Hanami::Action
-                def handle(*, res)
-                  res.body = "Hello world"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/actions/dashboard/show.rb", <<~RUBY
-        require "hanami/action"
-
-        module Admin
-          module Actions
-            module Dashboard
-              class Show < Hanami::Action
-                def handle(*, res)
-                  res.body = "Admin dashboard here"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      get "/"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Hello world"
-
-      get "/inline"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Inline"
-
-      get "/health"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Health, OK"
-
-      get "/admin/dashboard"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Admin dashboard here"
-    end
-  end
-
-  # TODO: is this test even needed, given this is standard hanami-router behavior?
-  specify "It gives priority to the last declared route" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            root to: "home.index"
-
-            slice :main, at: "/" do
-              root to: "home.index"
-            end
-          end
-        end
-      RUBY
-
-      write "app/actions/home/index.rb", <<~RUBY
-        require "hanami/action"
-
-        module TestApp
-          module Actions
-            module Home
-              class Index < Hanami::Action
-                def handle(*, res)
-                  res.body = "Hello from App"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/actions/home/index.rb", <<~RUBY
-        require "hanami/action"
-
-        module Main
-          module Actions
-            module Home
-              class Index < Hanami::Action
-                def handle(*, res)
-                  res.body = "Hello from Slice"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      get "/"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Hello from Slice"
-    end
-  end
-
-  specify "It does not choose actions from slice to route in app" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = StringIO.new
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            get "/feedbacks", to: "feedbacks.index"
-
-            slice :api, at: "/api" do
-              get "/people", to: "people.index"
-            end
-          end
-        end
-      RUBY
-
-      write "app/action.rb", <<~RUBY
-        # auto_register: false
-        require "hanami/action"
-
-        module TestApp
-          class Action < Hanami::Action
-          end
-        end
-      RUBY
-
-      write "app/actions/feedbacks/index.rb", <<~RUBY
-        module TestApp
-          module Actions
-            module Feedbacks
-              class Index < TestApp::Action
-                def handle(*, res)
-                  res.body = "Feedbacks"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/api/action.rb", <<~RUBY
-        module API
-          class Action < TestApp::Action
-          end
-        end
-      RUBY
-
-      write "slices/api/actions/people/index.rb", <<~RUBY
-        module API
-          module Actions
-            module People
-              class Index < API::Action
-                def handle(*, res)
-                  res.body = "People"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      get "/api/people"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "People"
-    end
-  end
-
-  specify "For a booted app, rack_app raises an exception if a referenced action isn't registered in the app" 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/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            get "/missing", to: "missing.action"
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      expect { Hanami.app.rack_app }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
-        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in TestApp::App")
-        expect(exception.message).to include("define the action class TestApp::Actions::Missing::Action in app/actions/missing/action.rb")
-      end
-    end
-  end
-
-  specify "For a booted app, rack_app raises an error if a referenced action isn't registered in a slice" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            register_slice :admin
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            slice :admin, at: "/admin" do
-              get "/missing", to: "missing.action"
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      expect { Hanami.app.rack_app }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
-        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in Admin::Slice")
-        expect(exception.message).to include("define the action class Admin::Actions::Missing::Action in slices/admin/actions/missing/action.rb")
-      end
-    end
-  end
-
-  specify "For a non-booted app, rack_app does not raise an error if a referenced action isn't registered in the app" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.render_detailed_errors = false
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            get "/missing", to: "missing.action"
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect { Hanami.app.rack_app }.not_to raise_error
-
-      expect { get "/missing" }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
-        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in TestApp::App")
-        expect(exception.message).to match(%r{define the action class TestApp::Actions::Missing::Action.+actions/missing/action.rb})
-      end
-    end
-  end
-
-  specify "For a non-booted app, rack_app does not raise an error if a referenced action isn't registered in a slice" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.render_detailed_errors = false
-
-            register_slice :admin
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            slice :admin, at: "/admin" do
-              get "/missing", to: "missing.action"
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect { Hanami.app.rack_app }.not_to raise_error
-
-      expect { get "/admin/missing" }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
-        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in Admin::Slice")
-        expect(exception.message).to match(%r{define the action class Admin::Actions::Missing::Action.+slices/admin/actions/missing/action.rb})
-      end
-    end
-  end
-
-  specify "rack_app raises an error if a referenced slice is not registered" 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/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            slice :foo, at: "/foo" do
-              get "/bar", to: "bar.index"
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect { Hanami.app.rack_app }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::SliceLoadError)
-        expect(exception.message).to include("Slice 'foo' not found")
-      end
-    end
-  end
-end

data/spec/integration/rake_tasks_spec.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-require "rake"
-require "hanami/cli/bundler"
-
-RSpec.describe "Rake tasks", :app_integration do
-  describe "assets:precompile" do
-    before do
-      allow(Hanami).to receive(:bundled?)
-      allow(Hanami).to receive(:bundled?).with("hanami-assets").and_return(hanami_assets_bundled)
-    end
-
-    context "when hanami-assets is bundled" do
-      let(:hanami_assets_bundled) { true }
-
-      xit "compiles assets" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              end
-            end
-          RUBY
-
-          write "Rakefile", <<~RUBY
-            # frozen_string_literal: true
-
-            require "hanami/rake_tasks"
-          RUBY
-
-          write "app/assets/js/app.js", <<~JS
-            console.log("Hello from index.js");
-          JS
-
-          before_prepare if respond_to?(:before_prepare)
-          require "hanami/prepare"
-
-          expect_any_instance_of(Hanami::CLI::Bundler).to receive(:hanami_exec).with("assets compile").and_return(true)
-
-          Rake::Task["assets:precompile"].invoke
-        end
-      end
-
-      it "doesn't list the task" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              end
-            end
-          RUBY
-
-          write "Rakefile", <<~RUBY
-            # frozen_string_literal: true
-
-            require "hanami/rake_tasks"
-          RUBY
-
-          before_prepare if respond_to?(:before_prepare)
-          require "hanami/prepare"
-
-          output = `bundle exec rake -T`
-          expect(output).to_not include("assets:precompile")
-        end
-      end
-    end
-
-    context "when hanami-assets is not bundled" do
-      let(:hanami_assets_bundled) { false }
-
-      it "raises error" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              end
-            end
-          RUBY
-
-          write "Rakefile", <<~RUBY
-            # frozen_string_literal: true
-
-            require "hanami/rake_tasks"
-          RUBY
-
-          write "app/assets/js/app.js", <<~JS
-            console.log("Hello from index.js");
-          JS
-
-          before_prepare if respond_to?(:before_prepare)
-          require "hanami/prepare"
-
-          expect { Rake::Task["assets:precompile"].invoke }.to raise_error do |exception|
-            expect(exception).to be_a(RuntimeError)
-            expect(exception.message).to match(/Don't know how to build task 'assets:precompile'/)
-          end
-        end
-      end
-    end
-  end
-end