hanami 2.1.1 → 2.2.0.beta2

data/spec/integration/db/gateways_spec.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Gateways", :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 "configures gateways by detecting ENV vars" 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 "db/.keep", ""
+      write "app/relations/.keep", ""
+      write "slices/admin/relations/.keep", ""
+
+      ENV["DATABASE_URL"] = "sqlite://db/default.sqlite3"
+      ENV["DATABASE_URL__EXTRA"] = "sqlite://db/extra.sqlite3"
+      ENV["ADMIN__DATABASE_URL__DEFAULT"] = "sqlite://db/admin.sqlite3"
+      ENV["ADMIN__DATABASE_URL__SPECIAL"] = "sqlite://db/admin_special.sqlite3"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["db.rom"].gateways[:default]).to be
+      expect(Hanami.app["db.rom"].gateways[:extra]).to be
+      expect(Hanami.app["db.gateway"]).to be Hanami.app["db.rom"].gateways[:default]
+      expect(Hanami.app["db.gateways.default"]).to be Hanami.app["db.rom"].gateways[:default]
+      expect(Hanami.app["db.gateways.extra"]).to be Hanami.app["db.rom"].gateways[:extra]
+
+      expect(Admin::Slice["db.rom"].gateways[:default]).to be
+      expect(Admin::Slice["db.rom"].gateways[:special]).to be
+      expect(Admin::Slice["db.gateway"]).to be Admin::Slice["db.rom"].gateways[:default]
+      expect(Admin::Slice["db.gateways.default"]).to be Admin::Slice["db.rom"].gateways[:default]
+      expect(Admin::Slice["db.gateways.special"]).to be Admin::Slice["db.rom"].gateways[:special]
+    end
+  end
+
+  it "configures gateways from explicit config in the provider" 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 "db/.keep", ""
+
+      write "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.gateway :default do |gw|
+            gw.database_url = "sqlite://db/default.sqlite3"
+          end
+
+          config.gateway :extra do |gw|
+            gw.database_url = "sqlite://db/extra.sqlite3"
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["db.rom"].gateways[:default]).to be
+      expect(Hanami.app["db.rom"].gateways[:extra]).to be
+      expect(Hanami.app["db.gateway"]).to be Hanami.app["db.rom"].gateways[:default]
+      expect(Hanami.app["db.gateways.default"]).to be Hanami.app["db.rom"].gateways[:default]
+      expect(Hanami.app["db.gateways.extra"]).to be Hanami.app["db.rom"].gateways[:extra]
+    end
+  end
+
+
+
+  it "exposes all database URLs as #database_urls on the provider source (for CLI commands)" 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 "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.gateway :special do |gw|
+            gw.database_url = "sqlite://db/special.sqlite3"
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite://db/default.sqlite3"
+      ENV["DATABASE_URL__EXTRA"] = "sqlite://db/extra.sqlite3"
+
+      require "hanami/prepare"
+
+      database_urls = Hanami.app.container.providers[:db].source.finalize_config.database_urls
+
+      expect(database_urls).to eq(
+        default: "sqlite://db/default.sqlite3",
+        extra: "sqlite://db/extra.sqlite3",
+        special: "sqlite://db/special.sqlite3"
+      )
+    end
+  end
+
+  it "applies extensions from the default adapter to explicitly configured gateway adapters" 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 "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.adapter :sql do |a|
+            a.extension :is_distinct_from
+          end
+
+          config.gateway :default do |gw|
+            gw.adapter :sql do |a|
+              a.extension :exclude_or_null
+            end
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+      ENV["DATABASE_URL__SPECIAL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["db.gateways.default"].options[:extensions])
+        .to eq [:exclude_or_null, :is_distinct_from, :caller_logging, :error_sql, :sql_comments]
+
+      expect(Hanami.app["db.gateways.special"].options[:extensions])
+        .to eq [:is_distinct_from, :caller_logging, :error_sql, :sql_comments]
+    end
+  end
+
+  it "combines ROM plugins from the default adapter and all gateways" 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 "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.adapter :sql do |a|
+            a.plugin command: :associates
+          end
+
+          config.gateway :default do |gw|
+            gw.database_url = "sqlite::memory"
+            gw.adapter :sql do |a|
+              a.plugin relation: :nullify
+            end
+          end
+
+          config.gateway :special do |gw|
+            gw.adapter :sql do |a|
+              a.plugin relation: :pagination
+            end
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+      ENV["DATABASE_URL__SPECIAL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["db.config"].setup.plugins.length).to eq 5
+      expect(Hanami.app["db.config"].setup.plugins).to include(
+        satisfying { |plugin| plugin.type == :command && plugin.name == :associates },
+        satisfying { |plugin| plugin.type == :relation && plugin.name == :nullify },
+        satisfying { |plugin| plugin.type == :relation && plugin.name == :pagination },
+        satisfying { |plugin| plugin.type == :relation && plugin.name == :auto_restrictions },
+        satisfying { |plugin| plugin.type == :relation && plugin.name == :instrumentation }
+      )
+    end
+  end
+
+  it "configures gateway adapters for their specific database types" 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 "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.gateway :default do |gw|
+            gw.database_url = "sqlite::memory"
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+      ENV["DATABASE_URL__SPECIAL"] = "postgres://localhost/database"
+
+      require "hanami/prepare"
+
+      # Get the provider source and finalize config, because the tests here aren't set up to handle
+      # connections to a running postgres database
+      allow(Hanami).to receive(:bundled?).and_call_original
+      allow(Hanami).to receive(:bundled?).with("pg").and_return true
+      provider_source = Hanami.app.container.providers[:db].source
+      provider_source.finalize_config
+
+      expect(provider_source.config.gateways[:default].config.adapter.extensions)
+        .to eq [:caller_logging, :error_sql, :sql_comments]
+
+      expect(provider_source.config.gateways[:special].config.adapter.extensions)
+        .to eq [
+          :caller_logging, :error_sql, :sql_comments,
+          :pg_array, :pg_enum, :pg_json, :pg_range
+        ]
+    end
+  end
+
+  it "makes the gateways available to 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/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "app/relations/users.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Users < Hanami::DB::Relation
+              gateway :extra
+              schema :users, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "db/.keep", ""
+      ENV["DATABASE_URL"] = "sqlite://db/default.sqlite3"
+      ENV["DATABASE_URL__EXTRA"] = "sqlite://db/extra.sqlite3"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      # Manually run a migration and add a test record
+      default_gateway = Hanami.app["db.gateways.default"]
+      migration = default_gateway.migration do
+        change do
+          create_table :posts do
+            primary_key :id
+            column :title, :text, null: false
+          end
+        end
+      end
+      migration.apply(default_gateway, :up)
+      default_gateway.connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      extra_gateway = Hanami.app["db.gateways.extra"]
+      migration = extra_gateway.migration do
+        change do
+          create_table :users do
+            primary_key :id
+            column :name, :text, null: false
+          end
+        end
+      end
+      migration.apply(extra_gateway, :up)
+      extra_gateway.connection.execute("INSERT INTO users (name) VALUES ('Jane Doe')")
+
+      Hanami.app.boot
+
+      expect(Hanami.app["relations.posts"].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Hanami.app["relations.users"].to_a).to eq [{id: 1, name: "Jane Doe"}]
+    end
+  end
+end

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/mappers_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Mappers", :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 mappers" 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/mappers/nested/default_title_mapper.rb", <<~RUBY
+        require "rom/transformer"
+
+        module TestApp
+          module DB
+            module Mappers
+              module Nested
+                class DefaultTitleMapper < ROM::Transformer
+                  relation :posts
+                  register_as :default_title_mapper
+
+                  map do
+                    set_default_title
+                  end
+
+                  def set_default_title(row)
+                    row[:title] ||= "Default title from mapper"
+                    row
+                  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
+          end
+        end
+      end
+      migration.apply(gateway, :up)
+      gateway.connection.execute("INSERT INTO posts (title) VALUES (NULL)")
+
+      post = TestApp::App["relations.posts"].map_with(:default_title_mapper).to_a[0]
+      expect(post[:title]).to eq "Default title from mapper"
+    end
+  end
+end