hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/container/application_routes_helper_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-
-RSpec.describe "App routes helper", :app_integration do
-  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
-            root to: "home.index"
-          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 world"
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(TestApp::App["routes"].path(:root)).to eq "/"
-      expect(TestApp::App["routes"].url(:root).to_s).to match /http:\/\/.*\//
-    end
-  end
-end

data/spec/integration/container/auto_injection_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container auto-injection (aka \"Deps\") mixin", :app_integration do
-  # rubocop:disable Metrics/MethodLength
-  def with_app
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "app/some_service.rb", <<~'RUBY'
-        module TestApp
-          class SomeService
-          end
-        end
-      RUBY
-
-      write "app/some_operation.rb", <<~'RUBY'
-        module TestApp
-          class SomeOperation
-            include Deps["some_service"]
-          end
-        end
-      RUBY
-
-      yield
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-
-  specify "Dependencies are auto-injected in a booted app" do
-    with_app do
-      require "hanami/boot"
-
-      op = TestApp::App["some_operation"]
-      expect(op.some_service).to be_a TestApp::SomeService
-    end
-  end
-
-  specify "Dependencies are lazily resolved and auto-injected in an unbooted app" do
-    with_app do
-      require "hanami/prepare"
-
-      op = TestApp::App["some_operation"]
-      expect(op.some_service).to be_a TestApp::SomeService
-    end
-  end
-end

data/spec/integration/container/auto_registration_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container auto-registration", :app_integration do
-  specify "Auto-registering files in slice source directories" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.inflections do |inflections|
-              inflections.acronym "NBA"
-            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/nba_rosters/index.rb", <<~RUBY
-        module TestApp
-          module Actions
-            module NBARosters
-              class Index < TestApp::Action
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/nba_jam/get_that_outta_here.rb", <<~RUBY
-        module Admin
-          module NBAJam
-            class GetThatOuttaHere
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/setup"
-      Hanami.boot
-
-      expect(TestApp::App["actions.nba_rosters.index"]).to be_an TestApp::Actions::NBARosters::Index
-      expect(Admin::Slice["nba_jam.get_that_outta_here"]).to be_an Admin::NBAJam::GetThatOuttaHere
-    end
-  end
-
-  it "Unbooted app resolves components lazily from the lib/ directories" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.inflections do |inflections|
-              inflections.acronym "NBA"
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/nba_jam/get_that_outta_here.rb", <<~RUBY
-        module Admin
-          module NBAJam
-            class GetThatOuttaHere
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(Admin::Slice.keys).not_to include("nba_jam.get_that_outta_here")
-      expect(Admin::Slice["nba_jam.get_that_outta_here"]).to be_an Admin::NBAJam::GetThatOuttaHere
-      expect(Admin::Slice.keys).to include("nba_jam.get_that_outta_here")
-    end
-  end
-end

data/spec/integration/container/autoloader_spec.rb

@@ -1,82 +0,0 @@
-RSpec.describe "App autoloader", :app_integration do
-  specify "Classes are autoloaded through direct reference, including through components resolved from the container" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            # Use a custom inflection to ensure this is respected by the autoloader
-            config.inflections do |inflections|
-              inflections.acronym "NBA"
-            end
-          end
-        end
-      RUBY
-
-      write "lib/non_app/thing.rb", <<~RUBY
-        module NonApp
-          class Thing
-          end
-        end
-      RUBY
-
-      write "lib/test_app/nba_jam/get_that_outta_here.rb", <<~RUBY
-        module TestApp
-          module NBAJam
-            class GetThatOuttaHere
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/operations/create_game.rb", <<~RUBY
-        module Admin
-          module Operations
-            class CreateGame
-              def call
-                Entities::Game.new
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/entities/game.rb", <<~RUBY
-        # auto_register: false
-
-        module Admin
-          module Entities
-            class Game
-            end
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/entities/quarter.rb", <<~RUBY
-        # auto_register: false
-
-        module Admin
-          module Entities
-            class Quarter
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(require("non_app/thing")).to be true
-      expect(NonApp::Thing).to be
-
-      expect(TestApp::NBAJam::GetThatOuttaHere).to be
-      expect(TestApp::App.autoloader.tag).to eq("hanami.app.test_app")
-
-      expect(Admin::Slice["operations.create_game"]).to be_an_instance_of(Admin::Operations::CreateGame)
-      expect(Admin::Slice["operations.create_game"].call).to be_an_instance_of(Admin::Entities::Game)
-
-      expect(Admin::Entities::Quarter).to be
-      expect(Admin::Slice.autoloader.tag).to eq("hanami.slices.admin")
-    end
-  end
-end

data/spec/integration/container/imports_spec.rb

@@ -1,253 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container imports", :app_integration do
-  xspecify "App container is imported into slice containers by default" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-          end
-        end
-      RUBY
-
-      require "hanami/setup"
-
-      Hanami.prepare
-
-      shared_service = Object.new
-      TestApp::App.register("shared_service", shared_service)
-
-      Hanami.boot
-
-      expect(Admin::Slice["shared_service"]).to be shared_service
-    end
-  end
-
-  specify "Slices can import other slices" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-            import from: :search
-          end
-        end
-      RUBY
-
-      write "slices/search/lib/index_entity.rb", <<~RUBY
-        module Search
-          class IndexEntity
-          end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      expect(Admin::Slice["search.index_entity"]).to be_a Search::IndexEntity
-
-      # Ensure a slice's imported components (e.g. from "app") are not then
-      # exported again when that slice is imported, which would result in redundant
-      # components
-      expect(Search::Slice.key?("logger")).to be true
-      expect(Admin::Slice.key?("logger")).to be true
-      expect(Admin::Slice.key?("search.logger")).to be false
-    end
-  end
-
-  specify "Slices can import specific components from other slices" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-            import(
-              keys: ["query"],
-              from: :search
-            )
-          end
-        end
-      RUBY
-
-      write "slices/search/lib/index_entity.rb", <<~RUBY
-        module Search
-          class IndexEntity; end
-        end
-      RUBY
-
-      write "slices/search/lib/query.rb", <<~RUBY
-        module Search
-          class Query; end
-        end
-      RUBY
-
-      require "hanami/setup"
-      Hanami.boot
-
-      expect(Admin::Slice["search.query"]).to be_a Search::Query
-    end
-  end
-
-  specify "Slices can import from other slices with a custom import key namespace" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-            import(
-              keys: ["query"],
-              from: :search,
-              as: :search_engine
-            )
-          end
-        end
-      RUBY
-
-      write "slices/search/lib/index_entity.rb", <<~RUBY
-        module Search
-          class IndexEntity; end
-        end
-      RUBY
-
-      write "slices/search/lib/query.rb", <<~RUBY
-        module Search
-          class Query; end
-        end
-      RUBY
-
-      require "hanami/boot"
-
-      expect(Admin::Slice["search_engine.query"]).to be_a Search::Query
-    end
-  end
-
-  specify "Imported components from another slice are lazily resolved in unbooted apps" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-            import from: :search
-          end
-        end
-      RUBY
-
-      write "slices/admin/lib/admin/test_op.rb", <<~RUBY
-        module Admin
-          class TestOp
-          end
-        end
-      RUBY
-
-      write "slices/search/lib/index_entity.rb", <<~RUBY
-        module Search
-          class IndexEntity
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(Hanami.app).not_to be_booted
-
-      expect(Admin::Slice.keys).not_to include "search.index_entity"
-      expect(Admin::Slice["search.index_entity"]).to be_a Search::IndexEntity
-      expect(Admin::Slice.keys).to include "search.index_entity"
-
-      expect(Admin::Slice).not_to be_booted
-      expect(Admin::Slice.container).not_to be_finalized
-      expect(Search::Slice).not_to be_booted
-      expect(Search::Slice.container).not_to be_finalized
-    end
-  end
-
-  specify "Slices can configure specific exports" 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/admin.rb", <<~RUBY
-        module Admin
-          class Slice < Hanami::Slice
-            import(
-              keys: %w[index_entity query],
-              from: :search
-            )
-          end
-        end
-      RUBY
-
-      write "config/slices/search.rb", <<~RUBY
-        module Search
-          class Slice < Hanami::Slice
-            export(%w[query])
-          end
-        end
-      RUBY
-
-      write "slices/search/lib/index_entity.rb", <<~RUBY
-        module Search
-          class IndexEntity; end
-        end
-      RUBY
-
-      write "slices/search/lib/query.rb", <<~RUBY
-        module Search
-          class Query; end
-        end
-      RUBY
-
-      require "hanami/setup"
-      Hanami.boot
-
-      expect(Admin::Slice.key?("search.query")).to be true
-      expect(Admin::Slice.key?("search.index_entity")).to be false
-    end
-  end
-end

data/spec/integration/container/prepare_container_spec.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container / prepare_container", :app_integration do
-  # (Most of) the examples below make their expectations on a `container_to_prepare`,
-  # which is the container yielded to the `Slice.prepare_container` block _at the moment
-  # it is called_.
-  #
-  # This around hook ensures the examples are run at the right time and container is
-  # available to each.
-  around(in_prepare_container: true) do |example|
-    # Eagerly capture @loaded_features here (see spec/support/app_integration.rb) since
-    # around hooks are run before any before hooks (where we ordinarily capture
-    # @loaded_features), and by invoking `example_group_instance.subject` below, we're
-    # making requires that we want to ensure are properly cleaned between examples.
-    @loaded_features = $LOADED_FEATURES.dup
-
-    slice = example.example_group_instance.subject
-
-    slice.prepare_container do |container|
-      example.example.example_group.let(:container_to_prepare) { container }
-      example.run
-    end
-
-    # The prepare_container block is called when the slice is prepared
-    slice.prepare
-
-    autoloaders_teardown!
-  end
-
-  describe "in app", :in_prepare_container do
-    before :context do
-      with_directory(@dir = make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "app/.keep", ""
-      end
-    end
-
-    subject {
-      with_directory(@dir) { require "hanami/setup" }
-      Hanami.app
-    }
-
-    it "receives the container for the app" do
-      expect(container_to_prepare).to be TestApp::Container
-    end
-
-    specify "the container has been already configured by the app" do
-      expect(container_to_prepare.config.component_dirs.dir("app")).to be
-    end
-
-    specify "the container is not yet marked as configured" do
-      expect(container_to_prepare).not_to be_configured
-    end
-
-    describe "after app is prepared", in_prepare_container: false do
-      before do
-        subject.prepare_container do |container|
-          container.config.name = :custom_name
-        end
-      end
-
-      it "preserves any container configuration changes made via the block" do
-        expect { subject.prepare }
-          .to change { subject.container.config.name }
-          .to :custom_name
-
-        expect(subject.container).to be_configured
-      end
-    end
-  end
-
-  describe "in slice", :in_prepare_container do
-    before :context do
-      with_directory(@dir = make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "slices/main/.keep", ""
-      end
-    end
-
-    subject {
-      with_directory(@dir) { require "hanami/setup" }
-      Hanami.app.register_slice(:main)
-    }
-
-    it "receives the container for the slice" do
-      expect(container_to_prepare).to be Main::Container
-    end
-
-    specify "the container has been already configured by the slice" do
-      expect(container_to_prepare.config.component_dirs.dir("")).to be
-    end
-
-    specify "the container is not yet marked as configured" do
-      expect(container_to_prepare).not_to be_configured
-    end
-
-    describe "after slice is prepared", in_prepare_container: false do
-      before do
-        subject.prepare_container do |container|
-          container.config.name = :custom_name
-        end
-      end
-
-      it "preserves any container configuration changes made via the block" do
-        expect { subject.prepare }
-          .to change { subject.container.config.name }
-          .to :custom_name
-
-        expect(subject.container).to be_configured
-      end
-    end
-  end
-end

data/spec/integration/container/provider_environment_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container / Provider environment", :app_integration do
-  let!(:app) {
-    module TestApp
-      class App < Hanami::App
-        class << self
-          attr_accessor :test_provider_target
-        end
-      end
-    end
-
-    before_prepare if respond_to?(:before_prepare)
-
-    Hanami.app.prepare
-    Hanami.app
-  }
-
-  context "app provider" do
-    before do
-      Hanami.app.register_provider :test_provider, namespace: true do
-        start do
-          Hanami.app.test_provider_target = target
-        end
-      end
-    end
-
-    it "exposes the app as the provider target" do
-      Hanami.app.start :test_provider
-      expect(Hanami.app.test_provider_target).to be Hanami.app
-    end
-  end
-
-  context "slice provider" do
-    def before_prepare
-      Hanami.app.register_slice :main
-    end
-
-    before do
-      Main::Slice.register_provider :test_provider, namespace: true do
-        start do
-          Hanami.app.test_provider_target = target
-        end
-      end
-    end
-
-    it "exposes the slice as the provider target" do
-      Main::Slice.start :test_provider
-      expect(Hanami.app.test_provider_target).to be Main::Slice
-    end
-  end
-end