hanami 2.1.1 → 2.2.0.beta1

data/spec/integration/db/db_inflector_spec.rb

@@ -0,0 +1,57 @@
+# 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

data/spec/integration/db/db_slices_spec.rb

@@ -0,0 +1,327 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB / Slices", :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 "slices using the same database_url and extensions share a gateway/connection" 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 "slices/admin/relations/.keep", ""
+      write "slices/main/relations/.keep", ""
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      expect(Admin::Slice["db.rom"].gateways[:default]).to be Main::Slice["db.rom"].gateways[:default]
+    end
+  end
+
+  specify "slices using the same database_url but different extensions have distinct gateways/connections" 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 "slices/admin/config/providers/db.rb", <<~RUBY
+        Admin::Slice.configure_provider :db do
+          config.adapter :sql do |a|
+            a.extensions.clear
+          end
+        end
+      RUBY
+
+      write "slices/main/config/providers/db.rb", <<~RUBY
+        Main::Slice.configure_provider :db do
+          config.adapter :sql do |a|
+            a.extensions.clear
+            a.extension :error_sql
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite::memory"
+
+      require "hanami/prepare"
+
+      # Different gateways, due to the distinct extensions
+      expect(Admin::Slice["db.rom"].gateways[:default]).not_to be Main::Slice["db.rom"].gateways[:default]
+
+      # Even though their URIs are the same
+      expect(Admin::Slice["db.rom"].gateways[:default].connection.opts[:uri])
+        .to eq Main::Slice["db.rom"].gateways[:default].connection.opts[:uri]
+    end
+  end
+
+  specify "using separate relations per slice, while sharing config from the app" 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/db/.keep", ""
+
+      write "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          config.adapter :sql do |a|
+            # a.skip_defaults
+            # a.plugin relation: :auto_restrictions
+            a.extension :exclude_or_null
+          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/relations/authors.rb", <<~RUBY
+        module Admin
+          module Relations
+            class Authors < Hanami::DB::Relation
+              schema :authors, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "slices/main/config/providers/db.rb", <<~RUBY
+        Main::Slice.configure_provider :db do
+          config.adapter :sql do |a|
+            a.extensions.clear
+          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
+
+      ENV["DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("database.db").to_s
+
+      require "hanami/prepare"
+
+      Main::Slice.prepare :db
+
+      expect(Main::Slice["db.config"]).to be_an_instance_of ROM::Configuration
+      expect(Main::Slice["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+
+      expect(Admin::Slice.registered?("db.config")).to be false
+
+      Admin::Slice.prepare :db
+
+      expect(Admin::Slice["db.config"]).to be_an_instance_of ROM::Configuration
+      expect(Admin::Slice["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+
+      # Manually run a migration and add a test record
+      gateway = Admin::Slice["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')")
+
+      # Admin slice has appropriate relations registered, and can access data
+      expect(Admin::Slice["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Admin::Slice["relations.posts"]).to be Admin::Slice["db.rom"].relations[:posts]
+      expect(Admin::Slice["relations.authors"]).to be Admin::Slice["db.rom"].relations[:authors]
+
+      # Main slice can access data, and only has its own relations (no crossover from admin slice)
+      expect(Main::Slice["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Main::Slice["relations.posts"]).to be Main::Slice["db.rom"].relations[:posts]
+      expect(Main::Slice["db.rom"].relations.elements.keys).not_to include :authors
+      expect(Main::Slice["relations.posts"]).not_to be Admin::Slice["relations.posts"]
+
+      # Config in the app's db provider is copied to child slice providers
+      expect(Admin::Slice["db.gateway"].options[:extensions]).to eq [
+        :exclude_or_null,
+        :caller_logging,
+        :error_sql,
+        :sql_comments,
+      ]
+      # Except when it has been explicitly configured in a child slice provider
+      expect(Main::Slice["db.gateway"].options[:extensions]).to eq []
+
+      # Plugins configured in the app's db provider are copied to child slice providers
+      expect(Admin::Slice["db.config"].setup.plugins.length).to eq 2
+      expect(Admin::Slice["db.config"].setup.plugins).to include an_object_satisfying { |plugin|
+        plugin.type == :relation && plugin.name == :auto_restrictions
+      }
+      expect(Admin::Slice["db.config"].setup.plugins).to include an_object_satisfying { |plugin|
+        plugin.type == :relation && plugin.name == :instrumentation
+      }
+
+      expect(Main::Slice["db.config"].setup.plugins).to eq Admin::Slice["db.config"].setup.plugins
+    end
+  end
+
+  specify "disabling sharing of config from the app" 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 :exclude_or_null
+          end
+        end
+      RUBY
+
+      write "config/slices/admin.rb", <<~RUBY
+        module Admin
+          class Slice < Hanami::Slice
+            config.db.configure_from_parent = false
+          end
+        end
+      RUBY
+
+      write "slices/admin/config/providers/db.rb", <<~RUBY
+        Admin::Slice.configure_provider :db do
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("database.db").to_s
+
+      require "hanami/prepare"
+
+      expect(Admin::Slice["db.gateway"].options[:extensions]).not_to include :exclude_or_null
+    end
+  end
+
+  specify "slices using separate databases" 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 "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/slices/super/relations/posts.rb", <<~RUBY
+        module Admin
+          module Super
+            module Relations
+              class Posts < Hanami::DB::Relation
+                schema :posts, infer: true
+              end
+            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
+
+      ENV["ADMIN__DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("admin.db").to_s
+      ENV["ADMIN__SUPER__DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("admin_super.db").to_s
+      ENV["MAIN__DATABASE_URL"] = "sqlite://" + Pathname(@dir).realpath.join("main.db").to_s
+
+      require "hanami/prepare"
+
+      Admin::Slice.prepare :db
+      Admin::Super::Slice.prepare :db
+      Main::Slice.prepare :db
+
+      # Manually run a migration and add a test record in each slice's database
+      gateways = [
+        Admin::Slice["db.gateway"],
+        Admin::Super::Slice["db.gateway"],
+        Main::Slice["db.gateway"]
+      ]
+      gateways.each do |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)
+      end
+      gateways[0].connection.execute("INSERT INTO posts (title) VALUES ('Gem glow')")
+      gateways[1].connection.execute("INSERT INTO posts (title) VALUES ('Cheeseburger backpack')")
+      gateways[2].connection.execute("INSERT INTO posts (title) VALUES ('Together breakfast')")
+
+      expect(Admin::Slice["relations.posts"].to_a).to eq [{id: 1, title: "Gem glow"}]
+      expect(Admin::Super::Slice["relations.posts"].to_a).to eq [{id: 1, title: "Cheeseburger backpack"}]
+      expect(Main::Slice["relations.posts"].to_a).to eq [{id: 1, title: "Together breakfast"}]
+    end
+  end
+end

data/spec/integration/db/db_spec.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+RSpec.describe "DB", :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 "sets up ROM and reigsters relations" 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"
+
+      Hanami.app.prepare :db
+
+      expect(Hanami.app["db.config"]).to be_an_instance_of ROM::Configuration
+      expect(Hanami.app["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+
+      # 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')")
+
+      Hanami.app.boot
+
+      expect(Hanami.app["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Hanami.app["relations.posts"]).to be Hanami.app["db.rom"].relations[:posts]
+    end
+  end
+
+  it "provides access in a non-booted app" 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"
+
+      Hanami.app.prepare :db
+
+      expect(Hanami.app["db.config"]).to be_an_instance_of ROM::Configuration
+      expect(Hanami.app["db.gateway"]).to be_an_instance_of ROM::SQL::Gateway
+
+      # 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')")
+
+      expect(Hanami.app["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Hanami.app["relations.posts"]).to be Hanami.app["db.rom"].relations[:posts]
+    end
+  end
+
+  it "raises an error when no database URL is provided" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.inflections do |inflections|
+            end
+          end
+        end
+      RUBY
+
+      write "app/relations/.keep", ""
+
+      require "hanami/prepare"
+
+      expect { Hanami.app.prepare :db }.to raise_error(Hanami::ComponentLoadError, /database_url/)
+    end
+  end
+
+  it "allows the user to configure 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 "app/relations/posts.rb", <<~RUBY
+        module TestApp
+          module Relations
+            class Posts < Hanami::DB::Relation
+              schema :posts, infer: true
+            end
+          end
+        end
+      RUBY
+
+      write "config/providers/db.rb", <<~RUBY
+        Hanami.app.configure_provider :db do
+          configure do |config|
+            # In this test, we're not setting an ENV["DATABASE_URL"], and instead configuring
+            # it via the provider source config, to prove that this works
+
+            config.database_url = "sqlite::memory"
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+      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')")
+
+      Hanami.app.boot
+
+      expect(Hanami.app["db.rom"].relations[:posts].to_a).to eq [{id: 1, title: "Together breakfast"}]
+      expect(Hanami.app["relations.posts"]).to be Hanami.app["db.rom"].relations[:posts]
+    end
+  end
+
+  it "transforms the database URL in test mode" 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["HANAMI_ENV"] = "test"
+      ENV["DATABASE_URL"] = "sqlite://./development.db"
+
+      require "hanami/prepare"
+
+      Hanami.app.prepare :db
+
+      expect(Hanami.app["db.gateway"].connection.url).to eq "sqlite://./test.db"
+    end
+  end
+end