hanami 2.1.1 → 2.2.0.beta2

data/spec/integration/db/provider_config_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Provider / Config", :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
+
+  describe "default config" do
+    it "provides default plugins and extensions" 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/db/.keep", ""
+
+        ENV["DATABASE_URL"] = "sqlite::memory"
+
+        require "hanami/prepare"
+
+        Hanami.app.prepare :db
+
+        plugins = Hanami.app["db.config"].setup.plugins
+        expect(plugins).to match [
+          an_object_satisfying {
+            _1.name == :instrumentation && _1.type == :relation &&
+              _1.config.notifications == Hanami.app["notifications"]
+          },
+          an_object_satisfying { _1.name == :auto_restrictions && _1.type == :relation }
+        ]
+
+        extensions = Hanami.app["db.gateway"].options[:extensions]
+        expect(extensions).to eq [:caller_logging, :error_sql, :sql_comments]
+      end
+    end
+  end
+
+  it "evaluates plugin config blocks in the context of the provider" 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/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.adapter :sql do |a|
+            a.skip_defaults :plugins
+
+            a.plugin relations: :instrumentation do |plugin|
+              plugin.notifications = target["custom_notifications"]
+            end
+          end
+        end
+      RUBY
+
+      write "app/custom_notifications.rb", <<~RUBY
+        module TestApp
+          class CustomNotifications
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      plugin = Hanami.app["db.config"].setup.plugins.find { _1.name == :instrumentation }
+      expect(plugin.config.notifications).to be_an_instance_of TestApp::CustomNotifications
+    end
+  end
+end

data/spec/integration/db/provider_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Provider", :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 "is registered when only a config/db/ dir exists" 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/db/.keep", ""
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      expect(Hanami.app["db.gateway"]).to be
+    end
+  end
+end

data/spec/integration/db/relations_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Relations", :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 nested relations" 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/nested/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            module Nested
+              class Posts < Hanami::DB::Relation
+                schema :posts, infer: true
+              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
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES ('Hi from nested relation')")
+
+      post = TestApp::App["relations.posts"].to_a[0]
+      expect(post[:title]).to eq "Hi from nested relation"
+    end
+  end
+end

data/spec/integration/db/repo_spec.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Repo", :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
+
+  specify "repos have a root inferred from their name, or can set their own" 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/repo.rb", <<~RUBY
+        module TestApp
+          class Repo < Hanami::DB::Repo
+          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/repos/post_repo.rb", <<~RUBY
+        module TestApp
+          module Repos
+            class PostRepo < Repo
+              def get(id)
+                posts.by_pk(id).one!
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/repos/no_implicit_root_relation_repo.rb", <<~RUBY
+        module TestApp
+          module Repos
+            class NoImplicitRootRelationRepo < Repo
+            end
+          end
+        end
+      RUBY
+
+      write "app/repos/explicit_root_relation_repo.rb", <<~RUBY
+        module TestApp
+          module Repos
+            class ExplicitRootRelationRepo < Repo[:posts]
+            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 = Hanami.app["db.gateway"]
+      migration = gateway.migration do
+        change do
+          # drop_table? :posts
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      # Repos use a matching root relation automatically
+      repo = Hanami.app["repos.post_repo"]
+      expect(repo.get(1).title).to eq "Together breakfast"
+      expect(repo.root).to eql Hanami.app["relations.posts"]
+
+      # Non-matching repos still work, just with no root relation
+      repo = Hanami.app["repos.no_implicit_root_relation_repo"]
+      expect(repo.root).to be nil
+
+      # Repos can provide an explicit root relation
+      repo = Hanami.app["repos.explicit_root_relation_repo"]
+      expect(repo.root).to eql Hanami.app["relations.posts"]
+    end
+  end
+
+  specify "repos use relations and structs only from their own slice" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      write "slices/admin/db/struct.rb", <<~RUBY
+        module Admin
+          module DB
+            class Struct < Hanami::DB::Struct
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/relations/posts.rb", <<~RUBY
+        module Admin
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/repo.rb", <<~RUBY
+        module Admin
+          class Repo < Hanami::DB::Repo
+          end
+        end
+      RUBY
+
+      write "slices/admin/repos/post_repo.rb", <<~RUBY
+        module Admin
+          module Repos
+            class PostRepo < Repo
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/structs/post.rb", <<~RUBY
+        module Admin
+          module Structs
+            class Post < DB::Struct
+            end
+          end
+        end
+      RUBY
+
+      write "slices/main/relations/posts.rb", <<~RUBY
+        module Main
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "slices/main/repo.rb", <<~RUBY
+        module Main
+          class Repo < Hanami::DB::Repo
+          end
+        end
+      RUBY
+
+      write "slices/main/repos/post_repo.rb", <<~RUBY
+        module Main
+          module Repos
+            class PostRepo < Repo
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      Admin::Slice.prepare :db
+
+      # Manually run a migration
+      gateway = Admin::Slice["db.gateway"]
+      migration = gateway.migration do
+        change do
+          # drop_table? :posts
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      expect(Admin::Slice["repos.post_repo"].posts).to eql Admin::Slice["relations.posts"]
+      expect(Admin::Slice["repos.post_repo"].posts.by_pk(1).one!.class).to be < Admin::Structs::Post
+
+      expect(Main::Slice["repos.post_repo"].posts).to eql Main::Slice["relations.posts"]
+      # Slice struct namespace used even when no concrete struct classes are defined
+      expect(Main::Slice["repos.post_repo"].posts.by_pk(1).one!.class).to be < Main::Structs::Post
+    end
+  end
+end

data/spec/integration/db/slices_importing_from_parent.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Slices / Importing from app", :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
+
+  specify "app DB components do not import into slices 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 "app/relations/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/.keep", ""
+
+      require "hanami/prepare"
+
+      expect { Admin::Slice.start :db }.to raise_error Dry::System::ProviderNotFoundError
+    end
+  end
+
+  specify "importing app DB components into slices via config.db.import_from_parent = true" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.db.import_from_parent = true
+          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 "slices/admin/.keep", ""
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      # Manually run a migration and add a test record
+      gateway = Hanami.app["db.gateway"]
+      migration = gateway.migration do
+        change do
+          # drop_table? :posts
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      Admin::Slice.start :db
+
+      expect(Admin::Slice["db.rom"]).to be(Hanami.app["db.rom"])
+      expect(Admin::Slice["relations.posts"]).to be(Hanami.app["relations.posts"])
+
+      expect(Admin::Slice["relations.posts"].to_a).to eq [{id: 1, title: "Together breakfast"}]
+    end
+  end
+
+  specify "disabling import of the DB components within a specific slice" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.db.import_from_parent = true
+          end
+        end
+      RUBY
+
+      write "config/slices/admin.rb", <<~RUBY
+        module Admin
+          class Slice < Hanami::Slice
+            config.db.import_from_parent = false
+          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
+
+      require "hanami/prepare"
+
+      expect { Admin::Slice.start :db }.to raise_error Dry::System::ProviderNotFoundError
+    end
+  end
+end

data/spec/integration/slices/slice_configuration_spec.rb

@@ -12,7 +12,7 @@ RSpec.describe "Slices / Slice configuration", :app_integration do
           class App < Hanami::App
             config.logger.stream = StringIO.new
 
-            config.no_auto_register_paths << "structs"
+            config.no_auto_register_paths = ["structs"]
           end
         end
       RUBY
@@ -34,9 +34,9 @@ RSpec.describe "Slices / Slice configuration", :app_integration do
 
       require "hanami/prepare"
 
-      expect(TestApp::App.config.no_auto_register_paths).to eq %w[entities structs]
-      expect(Main::Slice.config.no_auto_register_paths).to eq %w[entities structs schemas]
-      expect(Search::Slice.config.no_auto_register_paths).to eq %w[entities structs]
+      expect(TestApp::App.config.no_auto_register_paths).to eq %w[structs]
+      expect(Main::Slice.config.no_auto_register_paths).to eq %w[structs schemas]
+      expect(Search::Slice.config.no_auto_register_paths).to eq %w[structs]
     end
   end
 end

data/spec/support/app_integration.rb

@@ -118,6 +118,9 @@ RSpec.configure do |config|
     Hanami.instance_variable_set(:@_bundled, {})
     Hanami.remove_instance_variable(:@_app) if Hanami.instance_variable_defined?(:@_app)
 
+    # Clear cached DB gateways across slices
+    Hanami::Providers::DB.cache.clear
+
     $LOAD_PATH.replace(@load_paths)
 
     # Remove example-specific LOADED_FEATURES added when running each example

data/spec/unit/hanami/config/db_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "hanami/config"
+
+RSpec.describe Hanami::Config, "#db" do
+  let(:config) { described_class.new(app_name: app_name, env: :development) }
+  let(:app_name) { "MyApp::App" }
+
+  subject(:db) { config.db }
+
+  context "hanami-router is bundled" do
+    it "is a full router configuration" do
+      is_expected.to be_an_instance_of(Hanami::Config::DB)
+
+      is_expected.to respond_to(:import_from_parent)
+    end
+
+    it "can be finalized" do
+      is_expected.to respond_to(:finalize!)
+    end
+  end
+
+  context "hanami-db is not bundled" do
+    before do
+      allow(Hanami).to receive(:bundled?).and_call_original
+      allow(Hanami).to receive(:bundled?).with("hanami-db").and_return(false)
+    end
+
+    it "does not expose any settings" do
+      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
+      is_expected.not_to respond_to(:import_from_parent)
+    end
+
+    it "can be finalized" do
+      is_expected.to respond_to(:finalize!)
+    end
+  end
+end

data/spec/unit/hanami/config/router_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Hanami::Config, "#router" do
   context "hanami-router is not bundled" do
     before do
       allow(Hanami).to receive(:bundled?).and_call_original
-      expect(Hanami).to receive(:bundled?).with("hanami-router").and_return(false)
+      allow(Hanami).to receive(:bundled?).with("hanami-router").and_return(false)
     end
 
     it "does not expose any settings" do

data/spec/unit/hanami/helpers/form_helper_spec.rb

@@ -393,6 +393,29 @@ RSpec.describe Hanami::Helpers::FormHelper do
 
       expect(html).to eq_html(expected)
     end
+
+    context "with base name" do
+      let(:params) { {book: {categories: [{name: "foo"}, {name: "bar"}]}} }
+
+      it "renders" do
+        html = render(<<~ERB)
+          <%= form_for("book", "/books") do |f| %>
+            <% f.fields_for_collection "categories" do |fa| %>
+              <%= fa.text_field :name %>
+            <% end %>
+          <% end %>
+        ERB
+
+        expected = <<~HTML
+          <form action="/books" accept-charset="utf-8" method="POST">
+            <input type="text" name="book[categories][][name]" id="book-categories-0-name" value="foo">
+            <input type="text" name="book[categories][][name]" id="book-categories-1-name" value="bar">
+          </form>
+        HTML
+
+        expect(html).to eq_html(expected)
+      end
+    end
   end
 
   describe "#label" do
@@ -404,6 +427,14 @@ RSpec.describe Hanami::Helpers::FormHelper do
       expect(html).to include %(<label for="book-free-shipping">Free shipping</label>)
     end
 
+    it "accepts a symbol" do
+      html = form_for("/books") do |f|
+        f.label :free_shipping
+      end
+
+      expect(html).to include %(<label for="free-shipping">Free shipping</label>)
+    end
+
     it "accepts a string as custom content" do
       html = form_for("/books") do |f|
         f.label "Free Shipping!", for: "book.free_shipping"
@@ -2628,7 +2659,7 @@ RSpec.describe Hanami::Helpers::FormHelper do
           f.select "book.store", option_values, options: {prompt: "Select a store"}
         end
 
-        expect(html).to include %(<select name="book[store]" id="book-store"><option disabled="disabled">Select a store</option><option value="it">Italy</option><option value="us">United States</option></select>)
+        expect(html).to include %(<select name="book[store]" id="book-store"><option>Select a store</option><option value="it">Italy</option><option value="us">United States</option></select>)
       end
 
       it "allows blank string" do
@@ -2636,7 +2667,7 @@ RSpec.describe Hanami::Helpers::FormHelper do
           f.select "book.store", option_values, options: {prompt: ""}
         end
 
-        expect(html).to include %(<select name="book[store]" id="book-store"><option disabled="disabled"></option><option value="it">Italy</option><option value="us">United States</option></select>)
+        expect(html).to include %(<select name="book[store]" id="book-store"><option></option><option value="it">Italy</option><option value="us">United States</option></select>)
       end
 
       context "with values" do
@@ -2648,7 +2679,7 @@ RSpec.describe Hanami::Helpers::FormHelper do
             f.select "book.store", option_values, options: {prompt: "Select a store"}
           end
 
-          expect(html).to include %(<select name="book[store]" id="book-store"><option disabled="disabled">Select a store</option><option value="it" selected="selected">Italy</option><option value="us">United States</option></select>)
+          expect(html).to include %(<select name="book[store]" id="book-store"><option>Select a store</option><option value="it" selected="selected">Italy</option><option value="us">United States</option></select>)
         end
       end
 
@@ -2662,7 +2693,7 @@ RSpec.describe Hanami::Helpers::FormHelper do
               f.select "book.store", option_values, options: {prompt: "Select a store"}
             end
 
-            expect(html).to include %(<select name="book[store]" id="book-store"><option disabled="disabled">Select a store</option><option value="it" selected="selected">Italy</option><option value="us">United States</option></select>)
+            expect(html).to include %(<select name="book[store]" id="book-store"><option>Select a store</option><option value="it" selected="selected">Italy</option><option value="us">United States</option></select>)
           end
         end