rom-sql 0.7.0 → 0.8.0

data/spec/integration/commands/delete_spec.rb

@@ -1,67 +1,109 @@
-require 'spec_helper'
-
-describe 'Commands / Delete' do
+RSpec.describe 'Commands / Delete' do
   include_context 'users and tasks'
 
   subject(:users) { container.commands.users }
 
-  before do
-    configuration.relation(:users) do
-      def by_name(name)
-        where(name: name)
+  with_adapters do
+    before do
+      conf.relation(:users) do
+        def by_name(name)
+          where(name: name)
+        end
       end
-    end
 
-    configuration.commands(:users) do
-      define(:delete) do
-        result :one
+      conf.commands(:users) do
+        define(:delete) do
+          result :one
+        end
       end
+
+      container.relations.users.insert(id: 3, name: 'Jade')
+      container.relations.users.insert(id: 4, name: 'John')
     end
 
-    container.relations.users.insert(id: 2, name: 'Jane')
-  end
+    describe '#transaction' do
+      it 'deletes in normal way if no error raised' do
+        expect {
+          users.delete.transaction do
+            users.delete.by_name('Jade').call
+          end
+        }.to change { container.relations.users.count }.by(-1)
+      end
 
-  context '#transaction' do
-    it 'delete in normal way if no error raised' do
-      expect {
-        users.delete.transaction do
-          users.delete.by_name('Jane').call
-        end
-      }.to change { container.relations.users.count }.by(-1)
+      it 'deletes nothing if error was raised' do
+        expect {
+          users.delete.transaction do
+            users.delete.by_name('Jade').call
+            raise ROM::SQL::Rollback
+          end
+        }.to_not change { container.relations.users.count }
+      end
     end
 
-    it 'delete nothing if error was raised' do
-      expect {
-        users.delete.transaction do
-          users.delete.by_name('Jane').call
-          raise ROM::SQL::Rollback
-        end
-      }.to_not change { container.relations.users.count }
-    end
-  end
+    describe '#call' do
+      it 'deletes all tuples in a restricted relation' do
+        result = users.try { users.delete.by_name('Jade').call }
+
+        expect(result.value).to eql(id: 3, name: 'Jade')
+      end
 
-  it 'raises error when tuple count does not match expectation' do
-    result = users.try { users.delete.call }
+      it 're-raises database error' do
+        command = users.delete.by_name('Jade')
 
-    expect(result.value).to be(nil)
-    expect(result.error).to be_instance_of(ROM::TupleCountMismatchError)
-  end
+        expect(command.relation).to receive(:delete).and_raise(
+          Sequel::DatabaseError, 'totally wrong'
+        )
 
-  it 'deletes all tuples in a restricted relation' do
-    result = users.try { users.delete.by_name('Jane').call }
+        expect {
+          users.try { command.call }
+        }.to raise_error(ROM::SQL::DatabaseError, /totally wrong/)
+      end
+    end
 
-    expect(result.value).to eql(id: 2, name: 'Jane')
-  end
+    describe '#execute' do
+      context 'with postgres adapter' do
+        context 'with a single record' do
+          it 'materializes the result' do
+            result = container.command(:users).delete.by_name(%w(Jade)).execute
+            expect(result).to eq([
+              { id: 3, name: 'Jade' }
+            ])
+          end
+        end
 
-  it 're-raises database error' do
-    command = users.delete.by_name('Jane')
+        context 'with multiple records' do
+          it 'materializes the results' do
+            result = container.command(:users).delete.by_name(%w(Jade John)).execute
+            expect(result).to eq([
+              { id: 3, name: 'Jade' },
+              { id: 4, name: 'John' }
+            ])
+          end
+        end
+      end
+
+      context 'with other adapter', adapter: :sqlite do
+        let(:uri) { SQLITE_DB_URI }
 
-    expect(command.relation).to receive(:delete).and_raise(
-      Sequel::DatabaseError, 'totally wrong'
-    )
+        context 'with a single record' do
+          it 'materializes the result' do
+            result = container.command(:users).delete.by_name(%w(Jade)).execute
+            expect(result).to eq([
+              { id: 3, name: 'Jade' }
+            ])
+          end
+        end
 
-    expect {
-      users.try { command.call }
-    }.to raise_error(ROM::SQL::DatabaseError, /totally wrong/)
+        context 'with multiple records' do
+          it 'materializes the results' do
+            result = container.command(:users).delete.by_name(%w(Jade John)).execute
+            expect(result).to eq([
+              { id: 3, name: 'Jade' },
+              { id: 4, name: 'John' }
+            ])
+          end
+        end
+      end
+    end
   end
 end

data/spec/integration/commands/update_spec.rb

@@ -1,91 +1,172 @@
-require 'spec_helper'
 require 'anima'
 
-describe 'Commands / Update' do
+RSpec.describe 'Commands / Update' do
   include_context 'database setup'
 
   subject(:users) { container.command(:users) }
 
+  let(:update) { container.commands[:users][:update] }
+
   let(:relation) { container.relations.users }
   let(:piotr) { relation.by_name('Piotr').one }
   let(:peter) { { name: 'Peter' } }
 
-  before do
-    configuration.relation(:users) do
-      def by_id(id)
-        where(id: id).limit(1)
+  with_adapters do
+    context 'with a schema' do
+      before do
+        conf.relation(:users) do
+          schema do
+            attribute :id, ROM::SQL::Types::Serial
+            attribute :name, ROM::SQL::Types::String
+          end
+        end
       end
 
-      def by_name(name)
-        where(name: name)
+      it 'uses relation schema for the default input handler' do
+        conf.commands(:users) do
+          define(:update) do
+            result :one
+          end
+        end
+
+        expect(update.input[foo: 'bar', id: 1, name: 'Jane']).to eql(
+          id: 1, name: 'Jane'
+        )
       end
     end
 
-    configuration.commands(:users) do
-      define(:update)
-    end
+    context 'without a schema' do
+      before do
+        conf.relation(:users) do
+          def by_id(id)
+            where(id: id).limit(1)
+          end
 
-    User = Class.new { include Anima.new(:id, :name) }
+          def by_name(name)
+            where(name: name)
+          end
+        end
 
-    configuration.mappers do
-      register :users, entity: -> tuples { tuples.map { |tuple| User.new(tuple) } }
-    end
+        conf.commands(:users) do
+          define(:update)
+        end
 
-    relation.insert(name: 'Piotr')
-  end
+        Test::User = Class.new { include Anima.new(:id, :name) }
 
-  after { Object.send(:remove_const, :User) }
+        conf.mappers do
+          register :users, entity: -> tuples { tuples.map { |tuple| Test::User.new(tuple) } }
+        end
 
-  context '#transaction' do
-    it 'update record if there was no errors' do
-      result = users.update.transaction do
-        users.update.by_id(piotr[:id]).call(peter)
+        relation.insert(name: 'Piotr')
+        relation.insert(name: 'Jane')
       end
 
-      expect(result.value).to eq([{ id: 1, name: 'Peter' }])
-    end
-
-    it 'updates nothing if error was raised' do
-      users.update.transaction do
-        users.update.by_id(piotr[:id]).call(peter)
-        raise ROM::SQL::Rollback
+      it 'respects configured input handler' do
+        expect(update.input[foo: 'bar', id: 1, name: 'Jane']).to eql(
+          foo: 'bar', id: 1, name: 'Jane'
+        )
       end
 
-      expect(relation.one[:name]).to eql('Piotr')
-    end
-  end
+      context '#transaction' do
+        it 'update record if there was no errors' do
+          result = users.update.transaction do
+            users.update.by_id(piotr[:id]).call(peter)
+          end
 
-  it 'updates everything when there is no original tuple' do
-    result = users.try do
-      users.update.by_id(piotr[:id]).call(peter)
-    end
+          expect(result.value).to eq([{ id: 1, name: 'Peter' }])
+        end
 
-    expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
-  end
+        it 'updates nothing if error was raised' do
+          users.update.transaction do
+            users.update.by_id(piotr[:id]).call(peter)
+            raise ROM::SQL::Rollback
+          end
 
-  it 'updates when attributes changed' do
-    result = users.try do
-      users.as(:entity).update.by_id(piotr[:id]).change(User.new(piotr)).call(peter)
-    end
-
-    expect(result.value.to_a).to match_array([User.new(id: 1, name: 'Peter')])
-  end
-
-  it 'does not update when attributes did not change' do
-    result = users.try do
-      command = users.update.by_id(piotr[:id]).change(piotr)
-
-      expect(command.relation).not_to receive(:update)
+          expect(relation.first[:name]).to eql('Piotr')
+        end
+      end
 
-      command.call(name: piotr[:name])
+      describe '#call' do
+        it 'updates everything when there is no original tuple' do
+          result = users.try do
+            users.update.by_id(piotr[:id]).call(peter)
+          end
+
+          expect(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
+        end
+
+        it 'updates when attributes changed' do
+          result = users.try do
+            users.as(:entity).update.by_id(piotr[:id]).change(Test::User.new(piotr)).call(peter)
+          end
+
+          expect(result.value.to_a).to match_array([Test::User.new(id: 1, name: 'Peter')])
+        end
+
+        it 'does not update when attributes did not change' do
+          result = users.try do
+            command = users.update.by_id(piotr[:id]).change(piotr)
+
+            expect(command.relation).not_to receive(:update)
+
+            command.call(name: piotr[:name])
+          end
+
+          expect(result.value.to_a).to be_empty
+        end
+
+        it 're-reaises database errors' do
+          expect {
+            users.try { users.update.by_id(piotr[:id]).call(bogus_field: '#trollface') }
+          }.to raise_error(ROM::SQL::DatabaseError, /bogus_field/)
+        end
+
+        describe '#execute' do
+          context 'with postgres adapter' do
+            context 'with a single record' do
+              it 'materializes the result' do
+                result = users.update.by_name('Piotr').execute(name: 'Pete')
+                expect(result).to eq([
+                  { id: 1, name: 'Pete' }
+                ])
+              end
+            end
+
+            context 'with multiple records' do
+              it 'materializes the results' do
+                result = users.update.by_name(%w(Piotr Jane)).execute(name: 'Josie')
+                expect(result).to eq([
+                  { id: 1, name: 'Josie' },
+                  { id: 2, name: 'Josie' }
+                ])
+              end
+            end
+          end
+
+          context 'with other adapter', adapter: :sqlite do
+            let(:uri) { SQLITE_DB_URI }
+
+            context 'with a single record' do
+              it 'materializes the result' do
+                result = users.update.by_name('Piotr').execute(name: 'Pete')
+                expect(result).to eq([
+                  { id: 1, name: 'Pete' }
+                ])
+              end
+            end
+
+            context 'with multiple records' do
+              it 'materializes the results' do
+                result = users.update.by_name(%w(Piotr Jane)).execute(name: 'Josie')
+                expect(result).to eq([
+                  { id: 1, name: 'Josie' },
+                  { id: 2, name: 'Josie' }
+                ])
+              end
+            end
+          end
+        end
+      end
     end
-
-    expect(result.value.to_a).to be_empty
-  end
-
-  it 're-reaises database errors' do
-    expect {
-      users.try { users.update.by_id(piotr[:id]).call(bogus_field: '#trollface') }
-    }.to raise_error(ROM::SQL::DatabaseError, /bogus_field/)
   end
 end

data/spec/integration/commands/upsert_spec.rb

@@ -0,0 +1,83 @@
+RSpec.describe 'Commands / Postgres / Upsert', adapter: :postgres do
+  subject(:command) { commands[:tasks][:create_or_update] }
+
+  include_context 'relations'
+
+  let(:tasks) { commands[:tasks] }
+
+  before do
+    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: :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 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