hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/db/mappers_spec.rb

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

data/spec/integration/db/provider_config_spec.rb

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

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

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

@@ -1,300 +0,0 @@
-# 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
-
-      write "app/repo.rb", <<~RUBY
-        module TestApp
-          class Repo < Hanami::DB::Repo
-          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 < TestApp::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 < TestApp::Repo
-          end
-        end
-      RUBY
-
-      write "slices/main/repos/post_repo.rb", <<~RUBY
-        module Main
-          module Repos
-            class PostRepo < Repo
-            end
-          end
-        end
-      RUBY
-
-      write "slices/main/repositories/post_repository.rb", <<~RUBY
-        module Main
-          module Repositories
-            class PostRepository < 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"].root).to eql Admin::Slice["relations.posts"]
-      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"]
-      expect(Main::Slice["repositories.post_repository"].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
-
-  specify "repos resolve registered container dependencies with Deps[]" do
-    with_tmp_directory(Dir.mktmpdir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            Hanami.app.register("dependency") { -> { "Hello dependency!" } }
-          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
-              include Deps["dependency"]
-
-              def test
-                dependency.call
-              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 = Hanami.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)
-
-      repo = Hanami.app["repos.post_repo"]
-      expect(repo.test).to eq "Hello dependency!"
-    end
-  end
-end

data/spec/integration/db/slices_importing_from_parent.rb

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