hanami 2.1.1 → 2.2.0.beta1

data/spec/integration/db/logging_spec.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Logging", :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 "logs SQL queries" 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/setup"
+
+      logger_stream = StringIO.new
+      Hanami.app.config.logger.stream = logger_stream
+
+      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
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+
+          create_table :authors do
+            primary_key :id
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      relation = Hanami.app["relations.posts"]
+      expect(relation.select(:title).to_a).to eq [{:title=>"Together breakfast"}]
+
+      logger_stream.rewind
+      log_lines = logger_stream.read.split("\n")
+
+      expect(log_lines.length).to eq 1
+      expect(log_lines.first).to match /Loaded :sqlite in \d+ms SELECT `posts`.`title` FROM `posts` ORDER BY `posts`.`id`/
+    end
+  end
+
+  describe "slices sharing app db config" do
+    it "logs SQL queries" 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
+          end
+        RUBY
+
+        ENV["DATABASE_URL"] = "sqlite::memory"
+
+        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/main/relations/posts.rb", <<~RUBY
+          module Main
+            module Relations
+              class Posts < Hanami::DB::Relation
+                schema :posts, infer: true
+              end
+            end
+          end
+        RUBY
+
+        require "hanami/setup"
+
+        logger_stream = StringIO.new
+        Hanami.app.config.logger.stream = logger_stream
+
+        require "hanami/prepare"
+
+        Admin::Slice.prepare :db
+
+        # Manually run a migration
+        gateway = Admin::Slice["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)
+        gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+        Hanami.app.boot
+
+        # Booting the app will have the ROM schemas infer themself via some `PRAGMA` queries to the
+        # database, which themselves will emit logs. Clear those logs, since we want to focus on
+        # individual query logging in this test.
+        logger_stream.truncate(0)
+
+        relation = Admin::Slice["relations.posts"]
+        relation.select(:title).to_a
+
+        log_lines = logger_stream.string.split("\n")
+        expect(log_lines.length).to eq 1
+        expect(log_lines.last).to match /Loaded :sqlite in \d+ms SELECT `posts`.`title` FROM `posts` ORDER BY `posts`.`id`/
+
+        relation = Main::Slice["relations.posts"]
+        relation.select(:id).to_a
+
+        log_lines = logger_stream.string.split("\n")
+        expect(log_lines.length).to eq 2
+        expect(log_lines.last).to match /Loaded :sqlite in \d+ms SELECT `posts`.`id` FROM `posts` ORDER BY `posts`.`id`/
+      end
+    end
+  end
+
+  describe "slices with independent db config" do
+    # This is the same test as above, except without the config/providers/db.rb file.
+    it "logs SQL queries" 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/relations/posts.rb", <<~RUBY
+          module Admin
+            module Relations
+              class Posts < Hanami::DB::Relation
+                schema :posts, infer: true
+              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
+
+        require "hanami/setup"
+
+        logger_stream = StringIO.new
+        Hanami.app.config.logger.stream = logger_stream
+
+        require "hanami/prepare"
+
+        Admin::Slice.prepare :db
+
+        # Manually run a migration
+        gateway = Admin::Slice["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)
+        gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+        Hanami.app.boot
+
+        # Booting the app will have the ROM schemas infer themself via some `PRAGMA` queries to the
+        # database, which themselves will emit logs. Clear those logs, since we want to focus on
+        # individual query logging in this test.
+        logger_stream.truncate(0)
+
+        relation = Admin::Slice["relations.posts"]
+        relation.select(:title).to_a
+
+        log_lines = logger_stream.string.split("\n")
+        expect(log_lines.length).to eq 1
+        expect(log_lines.last).to match /Loaded :sqlite in \d+ms SELECT `posts`.`title` FROM `posts` ORDER BY `posts`.`id`/
+
+        relation = Main::Slice["relations.posts"]
+        relation.select(:id).to_a
+
+        log_lines = logger_stream.string.split("\n")
+        expect(log_lines.length).to eq 2
+        expect(log_lines.last).to match /Loaded :sqlite in \d+ms SELECT `posts`.`id` FROM `posts` ORDER BY `posts`.`id`/
+      end
+    end
+  end
+end

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/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