hanami 2.0.0.alpha7.1 → 2.0.0.beta1.1

data/spec/new_integration/container/imports_spec.rb

@@ -0,0 +1,253 @@
+# 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/new_integration/container/prepare_container_spec.rb

@@ -0,0 +1,123 @@
+# 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
+  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/new_integration/container/shutdown_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+RSpec.describe "App shutdown", :app_integration do
+  specify "App shutdown stops providers in both the app and slices" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        # frozen_string_literal: true
+
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "config/providers/connection.rb", <<~RUBY
+        # frozen_string_literal: true
+
+        Hanami.app.register_provider :connection do
+          prepare do
+            module TestApp
+              class Connection
+                attr_reader :connected
+
+                def initialize
+                  @connected = true
+                end
+
+                def disconnect
+                  @connected = false
+                end
+              end
+            end
+          end
+
+          start do
+            register("connection", TestApp::Connection.new)
+          end
+
+          stop do
+            container["connection"].disconnect
+          end
+        end
+      RUBY
+
+      write "slices/main/config/providers/connection.rb", <<~RUBY
+        # frozen_string_literal: true
+
+        Main::Slice.register_provider :connection do
+          prepare do
+            module Main
+              class Connection
+                attr_reader :connected
+
+                def initialize
+                  @connected = true
+                end
+
+                def disconnect
+                  @connected = false
+                end
+              end
+            end
+          end
+
+          start do
+            register "connection", Main::Connection.new
+          end
+
+          stop do
+            container["connection"].disconnect
+          end
+        end
+      RUBY
+
+      require "hanami/boot"
+
+      app_connection = Hanami.app["connection"]
+      slice_connection = Main::Slice["connection"]
+
+      expect(app_connection.connected).to be true
+      expect(slice_connection.connected).to be true
+
+      Hanami.shutdown
+
+      expect(app_connection.connected).to be false
+      expect(slice_connection.connected).to be false
+    end
+  end
+end

data/spec/new_integration/container/standard_bootable_components_spec.rb

@@ -0,0 +1,124 @@
+RSpec.describe "Container / Standard bootable components", :app_integration do
+  specify "Standard components are available on booted container" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      Hanami.boot
+
+      expect(Hanami.app.key?(:settings)).to be false
+      expect(Hanami.app["inflector"]).to eql Hanami.app.inflector
+      expect(Hanami.app["logger"]).to be_a_kind_of(Hanami::Logger)
+      expect(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
+    end
+  end
+
+  specify "Standard components are resolved lazily on non-booted container" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      Hanami.prepare
+
+      expect(Hanami.app.key?(:settings)).to be false
+      expect(Hanami.app["inflector"]).to eql Hanami.app.inflector
+      expect(Hanami.app["logger"]).to be_a_kind_of(Hanami::Logger)
+      expect(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
+    end
+  end
+
+  specify "Settings component is available when settings 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 "config/settings.rb", <<~RUBY
+        require "hanami/settings"
+
+        module TestApp
+          class Settings < Hanami::Settings
+            setting :session_secret
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      Hanami.boot
+
+      expect(Hanami.app.key?(:settings)).to be true
+      expect(Hanami.app[:settings]).to respond_to :session_secret
+    end
+  end
+
+  specify "Standard components can be replaced by custom bootable components (on booted container)" 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/providers/logger.rb", <<~RUBY
+        Hanami.app.register_provider :logger do
+          start do
+            register :logger, "custom logger"
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      Hanami.boot
+
+      expect(Hanami.app[:logger]).to eq "custom logger"
+    end
+  end
+
+  specify "Standard components can be replaced by custom bootable components resolved lazily (on non-booted container)" 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/providers/logger.rb", <<~RUBY
+        Hanami.app.register_provider :logger do
+          start do
+            register :logger, "custom logger"
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      Hanami.prepare
+
+      expect(Hanami.app[:logger]).to eq "custom logger"
+    end
+  end
+end