rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/commands/upsert_spec.rb

@@ -1,83 +0,0 @@
-RSpec.describe 'Commands / Postgres / Upsert', :postgres, seeds: false do
-  subject(:command) { task_commands[:create_or_update] }
-
-  include_context 'relations'
-
-  before do
-    conn.execute "ALTER TABLE tasks add CONSTRAINT tasks_title_key UNIQUE (title)"
-
-    conn[:users].insert id: 1, name: 'Jane'
-    conn[:users].insert id: 2, name: 'Joe'
-    conn[:users].insert id: 3, name: 'Jean'
-  end
-
-  describe '#call' do
-    let(:task) { { title: 'task 1', user_id: 1 } }
-    let(:excluded) { task.merge(user_id: 3) }
-
-    before do
-      command_config = self.command_config
-
-      conf.commands(:tasks) do
-        define('Postgres::Upsert') do
-          register_as :create_or_update
-          result :one
-
-          instance_exec(&command_config)
-        end
-      end
-    end
-
-    before { command.relation.upsert(task) }
-
-    context 'on conflict do nothing' do
-      let(:command_config) { -> { } }
-
-      it 'returns nil' do
-        expect(command.call(excluded)).to be nil
-      end
-    end
-
-    context 'on conflict do update' do
-      context 'with conflict target' do
-        let(:command_config) do
-          -> do
-            conflict_target :title
-            update_statement user_id: 2
-          end
-        end
-
-        it 'returns updated data' do
-          expect(command.call(excluded)).to eql(id: 1, user_id: 2, title: 'task 1')
-        end
-      end
-
-      context 'with constraint name' do
-        let(:command_config) do
-          -> do
-            constraint :tasks_title_key
-            update_statement user_id: Sequel.qualify(:excluded, :user_id)
-          end
-        end
-
-        it 'returns updated data' do
-          expect(command.call(excluded)).to eql(id: 1, user_id: 3, title: 'task 1')
-        end
-      end
-
-      context 'with where clause' do
-        let(:command_config) do
-          -> do
-            conflict_target :title
-            update_statement user_id: nil
-            update_where Sequel.qualify(:tasks, :id) => 2
-          end
-        end
-
-        it 'returns nil' do
-          expect(command.call(excluded)).to be nil
-        end
-      end
-    end
-  end
-end if PG_LTE_95

data/spec/integration/gateway_spec.rb

@@ -1,107 +0,0 @@
-RSpec.describe ROM::SQL::Gateway, :postgres do
-  include_context 'database setup'
-
-  describe 'migration' do
-    before do
-      inferrable_relations.concat %i(rabbits carrots)
-    end
-
-    context 'creating migrations inline' do
-      subject(:gateway) { container.gateways[:default] }
-
-      let(:conf) { ROM::Configuration.new(:sql, conn) }
-      let(:container) { ROM.container(conf) }
-
-      it 'allows creating and running migrations' do
-        migration = gateway.migration do
-          up do
-            create_table(:rabbits) do
-              primary_key :id
-              String :name
-            end
-          end
-
-          down do
-            drop_table(:rabbits)
-          end
-        end
-
-        migration.apply(gateway.connection, :up)
-
-        expect(gateway.connection[:rabbits]).to be_a(Sequel::Dataset)
-
-        migration.apply(gateway.connection, :down)
-
-        expect(gateway.connection.tables).to_not include(:rabbits)
-      end
-    end
-
-    context 'running migrations from a file system' do
-      before do
-        inferrable_relations.concat %i(schema_migrations)
-      end
-
-      let(:migration_dir) do
-        Pathname(__FILE__).dirname.join('../fixtures/migrations').realpath
-      end
-
-      let(:migrator) { ROM::SQL::Migration::Migrator.new(conn, path: migration_dir) }
-      let(:conf) { ROM::Configuration.new(:sql, [conn, migrator: migrator]) }
-      let(:container) { ROM.container(conf) }
-
-      it 'returns true for pending migrations' do
-        expect(container.gateways[:default].pending_migrations?).to be_truthy
-      end
-
-      it 'returns false for non pending migrations' do
-        container.gateways[:default].run_migrations
-        expect(container.gateways[:default].pending_migrations?).to be_falsy
-      end
-
-      it 'runs migrations from a specified directory' do
-        container.gateways[:default].run_migrations
-      end
-    end
-  end
-
-  describe 'transactions' do
-    before do
-      inferrable_relations.concat %i(names)
-    end
-
-    before do
-      conn.create_table(:names) do
-        String :name
-      end
-    end
-
-    let(:gw) { container.gateways[:default] }
-    let(:names) { gw.dataset(:names) }
-
-    it 'can run the code inside a transaction' do
-      names.insert name: 'Jade'
-
-      gw.transaction do |t|
-        names.insert name: 'John'
-
-        t.rollback!
-        names.insert name: 'Jack'
-      end
-
-      expect(names.to_a).to eql([name: 'Jade'])
-    end
-
-    it 'sets isolation level to read commited' do
-      gw = container.gateways[:default]
-      names = gw.dataset(:names)
-
-      gw.transaction do |t|
-        names.insert name: 'John'
-        concurrent_names = nil
-        Thread.new { concurrent_names = names.to_a }.join
-
-        expect(concurrent_names).to eql([])
-      end
-    end
-  end
-end

data/spec/integration/migration_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe ROM::SQL, '.migration' do
-  include_context 'database setup'
-
-  before do
-    inferrable_relations.concat %i(dragons schema_migrations)
-  end
-
-  with_adapters do
-    before { conf }
-
-    it 'creates a migration for a specific gateway' do
-      migration = ROM::SQL.migration(container) do
-        change do
-          create_table :dragons do
-            primary_key :id
-            column :name, String
-          end
-        end
-      end
-
-      migration.apply(conn, :up)
-
-      expect(conn.table_exists?(:dragons)).to be(true)
-    end
-  end
-
-  context 'with non-default gateway' do
-    with_adapters(:postgres) do
-      let(:conf) do
-        ROM::Configuration.new(
-          default: [:sql, conn, inferrable_relations: %i(schema_migrations)],
-          in_memory: [:sql, DB_URIS[:sqlite], inferrable_relations: %i(schema_migrations)]
-        )
-      end
-
-      let(:in_memory_connection) { container.gateways[:in_memory].connection }
-
-      it 'creates a migration for a specific gateway' do
-        in_memory_migration = ROM::SQL.migration(container, :in_memory) do
-          change do
-            create_table :turtles do
-              primary_key :id
-              column :name, String
-            end
-          end
-        end
-
-        in_memory_migration.apply(in_memory_connection, :up)
-
-        expect(in_memory_connection.table_exists?(:dragons)).to be(false)
-        expect(in_memory_connection.table_exists?(:turtles)).to be(true)
-      end
-    end
-  end
-end

data/spec/integration/plugins/associates/many_to_many_spec.rb

@@ -1,69 +0,0 @@
-RSpec.describe 'Plugins / :associates / with many-to-many', :sqlite, seeds: false do
-  include_context 'users and tasks'
-
-  let(:create_tag) { tag_commands.create }
-  let(:create_task) { task_commands.create }
-
-  let(:jane) do
-    users.by_pk(users.insert(name: 'Jane')).one
-  end
-
-  let(:john) do
-    users.by_pk(users.insert(name: 'John')).one
-  end
-
-  before do
-    conf.relation(:tasks) do
-      schema(infer: true) do
-        associations do
-          has_many :tags, through: :task_tags
-        end
-      end
-    end
-
-    conf.relation(:task_tags) do
-      schema(infer: true) do
-        associations do
-          belongs_to :tasks, as: :task
-          belongs_to :tags, as: :tag
-        end
-      end
-    end
-
-    conf.relation(:tags) do
-      schema(infer: true) do
-        associations do
-          has_many :tasks, through: :task_tags
-        end
-      end
-    end
-
-    conf.commands(:tags) do
-      define(:create) do
-        result :many
-      end
-    end
-
-    conf.commands(:tasks) do
-      define(:create) do
-        result :many
-        associates :tags
-      end
-    end
-  end
-
-  it 'associates a child with many parents' do
-    add_tags = create_tag.curry([{ name: 'red' }, { name: 'blue' }])
-    add_task = create_task.curry(user_id: jane[:id], title: "Jade's task")
-
-    command = add_tags >> add_task
-
-    result = command.call
-
-    expect(result).
-      to eql([
-               { id: 1, user_id: jane[:id], title: "Jade's task", tag_id: 1 },
-               { id: 1, user_id: jane[:id], title: "Jade's task", tag_id: 2 }
-             ])
-  end
-end

data/spec/integration/plugins/associates_spec.rb

@@ -1,250 +0,0 @@
-RSpec.describe 'Plugins / :associates', seeds: false do
-  include_context 'relations'
-
-  with_adapters do
-    context 'with Create command' do
-      let(:users) { container.commands[:users] }
-      let(:tasks) { container.commands[:tasks] }
-      let(:tags) { container.commands[:tags] }
-
-      before do
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations do
-              many_to_one :users, as: :user
-              many_to_one :users, as: :other
-              one_to_many :task_tags
-              one_to_many :tags, through: :task_tags
-            end
-          end
-        end
-
-        conf.commands(:users) do
-          define(:create) { result :one }
-        end
-      end
-
-      describe '#with_association' do
-        let(:user) do
-          users[:create].call(name: 'Jane')
-        end
-
-        let(:task) do
-          { title: 'Task one' }
-        end
-
-        before do
-          conf.commands(:users) do
-            define(:create) { result :one }
-          end
-
-          conf.commands(:tasks) do
-            define(:create) { result :one }
-          end
-        end
-
-        it 'returns a command prepared for the given association' do
-          command = tasks[:create].with_association(:user, key: %i[user_id id])
-
-          expect(command.call(task, user)).
-            to eql(id: 1, title: 'Task one', user_id: user[:id])
-        end
-
-        it 'allows passing a parent explicitly' do
-          command = tasks[:create].with_association(:user, key: %i[user_id id], parent: user)
-
-          expect(command.call(task)).
-            to eql(id: 1, title: 'Task one', user_id: user[:id])
-        end
-
-        it 'allows setting up multiple associations' do
-          command = tasks[:create].
-                      with_association(:user, key: %i[user_id id], parent: user).
-                      with_association(:other, key: %i[other_id id])
-
-          expect(command.configured_associations).to eql(%i[user other])
-        end
-      end
-
-      shared_context 'automatic FK setting' do
-        it 'sets foreign key prior execution for many tuples' do
-          create_user = users[:create].curry(name: 'Jade')
-          create_task = tasks[:create_many].curry([{ title: 'Task one' }, { title: 'Task two' }])
-
-          command = create_user >> create_task
-
-          result = command.call
-
-          expect(result).to match_array([
-            { id: 1, user_id: 1, title: 'Task one' },
-            { id: 2, user_id: 1, title: 'Task two' }
-          ])
-        end
-
-        it 'sets foreign key prior execution for one tuple' do
-          create_user = users[:create].curry(name: 'Jade')
-          create_task = tasks[:create_one].curry(title: 'Task one')
-
-          command = create_user >> create_task
-
-          result = command.call
-
-          expect(result).to match_array(id: 1, user_id: 1, title: 'Task one')
-        end
-      end
-
-      context 'with a schema' do
-        include_context 'automatic FK setting'
-
-        before do
-          conf.relation(:tasks) do
-            schema(infer: true) do
-              associations do
-                many_to_one :users, as: :user
-                one_to_many :task_tags
-                one_to_many :tags, through: :task_tags
-              end
-            end
-          end
-
-          conf.commands(:tasks) do
-            define(:create) do
-              register_as :create_many
-              associates :user
-            end
-
-            define(:create) do
-              register_as :create_one
-              result :one
-              associates :user
-            end
-          end
-        end
-
-        context 'with many-to-many association' do
-          before do
-            conf.relation(:tags) do
-              schema(infer: true) do
-                associations do
-                  one_to_many :task_tags
-                  one_to_many :tasks, through: :task_tags
-                end
-              end
-            end
-
-            conf.relation(:task_tags) do
-              schema do
-                attribute :tag_id, ROM::SQL::Types::ForeignKey(:tags)
-                attribute :task_id, ROM::SQL::Types::ForeignKey(:tasks)
-
-                primary_key :tag_id, :task_id
-
-                associations do
-                  many_to_one :tags
-                  many_to_one :tasks
-                end
-              end
-            end
-
-            conf.commands(:tasks) do
-              define(:create) do
-                result :one
-                associates :user
-              end
-            end
-
-            conf.commands(:tags) do
-              define(:create) do
-                associates :tasks
-              end
-            end
-          end
-
-          it 'sets FKs for the join table' do
-            create_user = users[:create].curry(name: 'Jade')
-            create_task = tasks[:create].curry(title: "Jade's task")
-            create_tags = tags[:create].curry([{ name: 'red' }, { name: 'blue' }])
-
-            command = create_user >> create_task >> create_tags
-
-            result = command.call
-            tags = relations[:tasks].associations[:tags].().to_a
-
-            expect(result).to eql([
-              { id: 1, task_id: 1, name: 'red' }, { id: 2, task_id: 1, name: 'blue' }
-            ])
-
-            expect(tags).to eql(result)
-          end
-        end
-      end
-
-      it 'raises when already defined' do
-        expect {
-          conf.commands(:tasks) do
-            define(:create) do
-              result :one
-              associates :user, key: [:user_id, :id]
-              associates :user, key: [:user_id, :id]
-            end
-          end
-        }.to raise_error(ArgumentError, /user/)
-      end
-    end
-  end
-
-  with_adapters :sqlite do
-    context 'with Update command' do
-      subject(:command) do
-        container.commands[:tasks][:update].with_association(:user).by_pk(jane_task[:id])
-      end
-
-      let(:john) do
-        container.commands[:users][:create].call(name: 'John')
-      end
-
-      let(:jane) do
-        container.commands[:users][:create].call(name: 'Jane')
-      end
-
-      let(:jane_task) do
-        container.commands[:tasks][:create].call(user_id: jane[:id], title: 'Jane Task')
-      end
-
-      let(:john_task) do
-        container.commands[:tasks][:create].call(user_id: john[:id], title: 'John Task')
-      end
-
-      before do
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations do
-              belongs_to :user
-            end
-          end
-        end
-
-        conf.commands(:users) do
-          define(:create) do
-            result :one
-          end
-        end
-
-        conf.commands(:tasks) do
-          define(:create) do
-            result :one
-          end
-
-          define(:update) do
-            result :one
-          end
-        end
-      end
-
-      it 'automatically sets FK prior execution' do
-        expect(command.curry(title: 'Another John task').call(john)).
-          to eql(id: jane_task[:id], user_id: john[:id], title: 'Another John task')
-      end
-    end
-  end
-end