hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/container/provider_lifecycle_spec.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Container / Provider lifecycle", :app_integration do
-  let!(:slice) {
-    module TestApp
-      class App < Hanami::App
-        register_provider :connection do
-          prepare do
-            module ::TestApp
-              class Connection
-                def initialize
-                  @connected = true
-                end
-
-                def disconnect
-                  @connected = false
-                end
-
-                def connected?
-                  @connected
-                end
-              end
-            end
-          end
-
-          start do
-            register("connection", TestApp::Connection.new)
-          end
-
-          stop do
-            container["connection"].disconnect
-          end
-        end
-      end
-    end
-
-    TestApp::App
-  }
-
-  before do
-    require "hanami/setup"
-  end
-
-  specify "individual providers can be prepared, started and stopped" do
-    expect { TestApp::Connection }.to raise_error NameError
-
-    slice.prepare :connection
-
-    expect(TestApp::Connection).to be
-    expect(slice.container.registered?("connection")).to be false
-
-    slice.start :connection
-
-    expect(slice.container.registered?("connection")).to be true
-    expect(slice["connection"]).to be_connected
-
-    slice.stop :connection
-
-    expect(slice["connection"]).not_to be_connected
-  end
-end

data/spec/integration/container/shutdown_spec.rb

@@ -1,91 +0,0 @@
-# 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/integration/container/standard_providers/rack_provider_spec.rb

@@ -1,44 +0,0 @@
-RSpec.describe "Container / Standard providers / Rack", :app_integration do
-  specify "Rack provider is loaded when rack is bundled" 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(Hanami.app["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
-      expect(Main::Slice["rack.monitor"]).to be_a_kind_of(Dry::Monitor::Rack::Middleware)
-    end
-  end
-
-  specify "Rack provider is not loaded when rack is not bundled" do
-    allow(Hanami).to receive(:bundled?).and_call_original
-    allow(Hanami).to receive(:bundled?).with("rack").and_return false
-
-    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(Hanami.app.key?("rack.monitor")).to be false
-      expect(Main::Slice.key?("rack.monitor")).to be false
-    end
-  end
-end

data/spec/integration/container/standard_providers_spec.rb

@@ -1,124 +0,0 @@
-RSpec.describe "Container / Standard providers", :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(Dry::Logger::Dispatcher)
-      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(Dry::Logger::Dispatcher)
-      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

data/spec/integration/db/auto_registration_spec.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "DB / auto-registration", :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
-
-  it "does not auto-register files in entities/, structs/, or db/" do
-    with_tmp_directory(@dir = Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "app/db/changesets/update_posts.rb", ""
-      write "app/entities/post.rb", ""
-      write "app/structs/post.rb", ""
-
-      ENV["DATABASE_URL"] = "sqlite::memory"
-
-      require "hanami/boot"
-
-      expect(Hanami.app.keys).not_to include(*[
-        "db.changesets.update_posts",
-        "entities.post",
-        "structs.post"
-      ])
-    end
-  end
-end

data/spec/integration/db/commands_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "DB / Commands", :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
-
-  it "registers custom commands" do
-    with_tmp_directory(@dir = Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = File::NULL
-          end
-        end
-      RUBY
-
-      write "app/relations/posts.rb", <<~RUBY
-        module TestApp
-          module Relations
-            class Posts < Hanami::DB::Relation
-              schema :posts, infer: true
-            end
-          end
-        end
-      RUBY
-
-      write "app/db/commands/nested/create_post_with_default_title.rb", <<~RUBY
-        module TestApp
-          module DB
-            module Commands
-              module Nested
-                class CreatePostWithDefaultTitle < ROM::SQL::Commands::Create
-                  relation :posts
-                  register_as :create_with_default_title
-                  result :one
-
-                  before :set_title
-
-                  def set_title(tuple, *)
-                    tuple[:title] ||= "Default title from command"
-                    tuple
-                  end
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      ENV["DATABASE_URL"] = "sqlite::memory"
-
-      require "hanami/prepare"
-
-      Hanami.app.prepare :db
-
-      # Manually run a migration and add a test record
-      gateway = TestApp::App["db.gateway"]
-      migration = gateway.migration do
-        change do
-          create_table :posts do
-            primary_key :id
-            column :title, :text, null: false
-          end
-        end
-      end
-      migration.apply(gateway, :up)
-
-      post = TestApp::App["relations.posts"].command(:create_with_default_title).call({})
-      expect(post[:title]).to eq "Default title from command"
-    end
-  end
-end

data/spec/integration/db/db_inflector_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system"
-
-RSpec.describe "ROM::Inflector", :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
-
-  around :each do |example|
-    inflector = ROM::Inflector
-    ROM.instance_eval {
-      remove_const :Inflector
-      const_set :Inflector, Dry::Inflector.new
-    }
-    example.run
-  ensure
-    ROM.instance_eval {
-      remove_const :Inflector
-      const_set :Inflector, inflector
-    }
-  end
-
-  it "replaces ROM::Inflector with the Hanami inflector" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-          end
-        end
-      RUBY
-
-      write "app/relations/posts.rb", <<~RUBY
-        module TestApp
-          module Relations
-            class Posts < Hanami::DB::Relation
-              schema :posts, infer: true
-            end
-          end
-        end
-      RUBY
-
-      ENV["DATABASE_URL"] = "sqlite::memory"
-
-      require "hanami/prepare"
-
-      expect { Hanami.app.prepare :db }.to change { ROM::Inflector == Hanami.app["inflector"] }.from(false).to(true)
-    end
-  end
-end