hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/slices/slice_loading_spec.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-
-RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures do
-  let(:app_modules) { %i[TestApp Admin Main] }
-
-  describe "loading specific slices with config.slices" do
-    describe "setup app" do
-      it "ignores any explicitly registered slices not included in load_slices" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-                config.slices = %w[admin]
-              end
-            end
-          RUBY
-
-          require "hanami/setup"
-
-          expect { Hanami.app.register_slice :main }.not_to(change { Hanami.app.slices.keys })
-          expect { Main }.to raise_error(NameError)
-
-          expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
-          expect(Admin::Slice).to be
-        end
-      end
-
-      describe "nested slices" do
-        it "ignores any explicitly registered slices not included in load_slices" do
-          with_tmp_directory(Dir.mktmpdir) do
-            write "config/app.rb", <<~'RUBY'
-              require "hanami"
-
-              module TestApp
-                class App < Hanami::App
-                  config.slices = %w[admin.shop]
-                end
-              end
-            RUBY
-
-            require "hanami/setup"
-
-            expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
-
-            expect { Admin::Slice.register_slice :editorial }.not_to(change { Admin::Slice.slices.keys })
-            expect { Admin::Slice.register_slice :shop }.to change { Admin::Slice.slices.keys }.to [:shop]
-            expect(Admin::Shop::Slice).to be
-          end
-        end
-      end
-    end
-
-    describe "prepared app" do
-      it "loads only the slices included in load_slices" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-                config.slices = %w[admin]
-              end
-            end
-          RUBY
-
-          write "slices/admin/.keep"
-          write "slices/main/.keep"
-
-          require "hanami/prepare"
-
-          expect(Hanami.app.slices.keys).to eq [:admin]
-          expect(Admin::Slice).to be
-          expect { Main }.to raise_error(NameError)
-        end
-      end
-
-      it "ignores unknown slices in load_slices" do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-                config.slices = %w[admin meep morp]
-              end
-            end
-          RUBY
-
-          write "slices/admin/.keep"
-          write "slices/main/.keep"
-
-          require "hanami/prepare"
-
-          expect(Hanami.app.slices.keys).to eq [:admin]
-        end
-      end
-
-      describe "nested slices" do
-        it "loads only the dot-delimited nested slices (and their parents) included in load_slices" do
-          with_tmp_directory(Dir.mktmpdir) do
-            write "config/app.rb", <<~'RUBY'
-              require "hanami"
-
-              module TestApp
-                class App < Hanami::App
-                  config.slices = %w[admin.shop]
-                end
-              end
-            RUBY
-
-            write "slices/admin/.keep"
-            write "slices/admin/slices/shop/.keep"
-            write "slices/admin/slices/editorial/.keep"
-            write "slices/main/.keep"
-
-            require "hanami/prepare"
-
-            expect(Hanami.app.slices.keys).to eq [:admin]
-            expect(Admin::Slice.slices.keys).to eq [:shop]
-
-            expect(Admin::Slice).to be
-            expect(Admin::Shop::Slice).to be
-
-            expect { Admin::Editorial }.to raise_error(NameError)
-            expect { Main }.to raise_error(NameError)
-          end
-        end
-      end
-    end
-  end
-
-  describe "using ENV vars" do
-    before do
-      @orig_env = ENV.to_h
-    end
-
-    after do
-      ENV.replace(@orig_env)
-    end
-
-    it "uses HANAMI_SLICES" do
-      ENV["HANAMI_SLICES"] = "admin"
-
-      with_tmp_directory(Dir.mktmpdir) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "slices/admin/.keep"
-        write "slices/main/.keep"
-
-        require "hanami/setup"
-
-        expect(Hanami.app.config.slices).to eq %w[admin]
-
-        require "hanami/prepare"
-
-        expect(Hanami.app.slices.keys).to eq [:admin]
-      end
-    end
-  end
-end

data/spec/integration/slices/slice_registrations_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Slice Registrations", :app_integration do
-  matcher :have_key do |name, value|
-    match do |slice|
-      slice.resolve(name) == value
-    end
-  end
-
-  specify "Registrations are loaded" 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/registrations/foo.rb", <<~RUBY
-        TestApp::App.register("foo") { "bar" }
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(Hanami.app).to have_key(:foo, "bar")
-    end
-  end
-
-  specify "Slices load their own registrations" 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/slices/main.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-          end
-        end
-      RUBY
-
-      write "config/slices/admin.rb", <<~RUBY
-        module Main
-          class Slice < Hanami::Slice
-          end
-        end
-      RUBY
-
-      write "config/registrations/foo.rb", <<~RUBY
-        TestApp::App.register("foo") { "bar" }
-      RUBY
-
-      write "slices/admin/config/registrations/bar.rb", <<~RUBY
-        Admin::Slice.register("bar") { "baz" }
-      RUBY
-
-      write "slices/main/config/registrations/baz.rb", <<~RUBY
-        Main::Slice.register("baz") { "quux" }
-      RUBY
-
-      require "hanami/prepare"
-
-      admin_slice = Hanami.app.slices[:admin]
-      main_slice  = Hanami.app.slices[:main]
-
-      aggregate_failures do
-        expect(Hanami.app).to have_key(:foo, "bar")
-        expect(admin_slice).to have_key(:bar, "baz")
-        expect(main_slice).to have_key(:baz, "quux")
-      end
-    end
-  end
-end

data/spec/integration/slices/slice_routing_spec.rb

@@ -1,219 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-require "stringio"
-
-RSpec.describe "Slices / Slice routing", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Main::Slice.rack_app }
-
-  specify "Slices have a nil router when no routes are defined" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~'RUBY'
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "slices/main/.keep", ""
-
-      require "hanami/prepare"
-
-      expect(Main::Slice.routes).to be nil
-      expect(Main::Slice.router).to be nil
-    end
-  end
-
-  specify "Slices have the app 'routes' component registered when app routes are defined but not their own" 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
-            get "home", to: "home.show", as: :home
-          end
-        end
-      RUBY
-
-      write "slices/main/.keep", ""
-
-      require "hanami/prepare"
-
-      expect(Main::Slice["routes"].path(:home)).to eq "/home"
-
-      expect(Main::Slice.router).to be nil
-      expect(TestApp::App.router).not_to be nil
-    end
-  end
-
-  specify "Slices use their own router and registered 'routes' component when their own routes are defined" 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 "slices/main/config/routes.rb", <<~'RUBY'
-        require "hanami/routes"
-
-        module Main
-          class Routes < Hanami::Routes
-            get "home", to: "home.show", as: :home
-          end
-        end
-      RUBY
-
-      write "slices/main/actions/home/show.rb", <<~'RUBY'
-        require "hanami/action"
-
-        module Main
-          module Actions
-            module Home
-              class Show < Hanami::Action
-                def handle(*, res)
-                  res.body = "Hello world"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-      Main::Slice.boot
-
-      expect(Main::Slice["routes"].path(:home)).to eq "/home"
-
-      get "/home"
-
-      expect(last_response.status).to eq 200
-      expect(last_response.body).to eq "Hello world"
-    end
-  end
-
-  describe "Mounting slice routes" do
-    before :context do
-      with_directory(@dir = make_tmp_directory) 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.show"
-
-              slice :main, at: "/main"
-            end
-          end
-        RUBY
-
-        write "app/actions/home/show.rb", <<~'RUBY'
-          require "hanami/action"
-
-          module TestApp
-            module Actions
-              module Home
-                class Show < Hanami::Action
-                  def handle(*, res)
-                    res.body = "Hello from app"
-                  end
-                end
-              end
-            end
-          end
-        RUBY
-
-        write "slices/main/config/routes.rb", <<~'RUBY'
-          module Main
-            class Routes < Hanami::Routes
-              root to: "home.show"
-            end
-          end
-        RUBY
-
-        write "slices/main/actions/home/show.rb", <<~'RUBY'
-          require "hanami/action"
-
-          module Main
-            module Actions
-              module Home
-                class Show < Hanami::Action
-                  def handle(*, res)
-                    res.body = "Hello from slice"
-                  end
-                end
-              end
-            end
-          end
-        RUBY
-      end
-    end
-
-    let(:app) { TestApp::App.app }
-
-    describe "A slice with its own router can be mounted in its parent's routes" do
-      context "prepared" do
-        before do
-          with_directory(@dir) { require "hanami/prepare" }
-        end
-
-        specify do
-          get "/"
-
-          expect(last_response.status).to eq 200
-          expect(last_response.body).to eq "Hello from app"
-
-          get "/main"
-
-          expect(last_response.status).to eq 200
-          expect(last_response.body).to eq "Hello from slice"
-        end
-      end
-
-      context "booted" do
-        before do
-          with_directory(@dir) { require "hanami/boot" }
-        end
-
-        specify do
-          get "/"
-
-          expect(last_response.status).to eq 200
-          expect(last_response.body).to eq "Hello from app"
-
-          get "/main"
-
-          expect(last_response.status).to eq 200
-          expect(last_response.body).to eq "Hello from slice"
-        end
-      end
-    end
-  end
-end