rom-sql 0.7.0 → 0.8.0

data/spec/integration/association/many_to_one_spec.rb

@@ -0,0 +1,110 @@
+RSpec.describe ROM::SQL::Association::ManyToOne, helpers: true do
+  subject(:assoc) {
+    ROM::SQL::Association::ManyToOne.new(:tasks, :users)
+  }
+
+  include_context 'users and tasks'
+
+  let(:users) { container.relations[:users] }
+  let(:tasks) { container.relations[:tasks] }
+  let(:articles) { container.relations[:articles] }
+
+  with_adapters do
+    before do
+      conf.relation(:tasks) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+          attribute :title, ROM::SQL::Types::String
+        end
+      end
+    end
+
+    describe '#result' do
+      specify { expect(ROM::SQL::Association::ManyToOne.result).to be(:one) }
+    end
+
+    describe '#name' do
+      it 'uses target by default' do
+        expect(assoc.name).to be(:users)
+      end
+    end
+
+    describe '#target' do
+      it 'builds full relation name' do
+        assoc = ROM::SQL::Association::ManyToOne.new(:users, :tasks, relation: :foo)
+
+        expect(assoc.name).to be(:tasks)
+        expect(assoc.target).to eql(ROM::SQL::Association::Name[:foo, :tasks])
+      end
+    end
+
+    describe '#call' do
+      it 'prepares joined relations' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id name task_id])
+
+        expect(relation.where(user_id: 1).one).to eql(id: 1, task_id: 2, name: 'Jane')
+
+        expect(relation.where(user_id: 2).one).to eql(id: 2, task_id: 1, name: 'Joe')
+
+        expect(relation.to_a).to eql([
+          { id: 2, task_id: 1, name: 'Joe' },
+          { id: 1, task_id: 2, name: 'Jane' }
+        ])
+      end
+    end
+
+    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      it 'preloads relation based on association' do
+        relation = users.for_combine(assoc).call(tasks.call)
+
+        expect(relation.to_a).to eql([
+          { id: 2, task_id: 1, name: 'Joe' },
+          { id: 1, task_id: 2, name: 'Jane' }
+        ])
+      end
+    end
+
+    context 'arbitrary name conventions' do
+      let(:articles_name) { ROM::Relation::Name[:articles, :posts] }
+
+      subject(:assoc) do
+        ROM::SQL::Association::ManyToOne.new(articles_name, :users)
+      end
+
+      before do
+        conf.relation(:articles) do
+          schema(:posts) do
+            attribute :post_id, ROM::SQL::Types::Serial
+            attribute :author_id, ROM::SQL::Types::ForeignKey(:users)
+            attribute :title, ROM::SQL::Types::Strict::String
+            attribute :body, ROM::SQL::Types::Strict::String
+          end
+        end
+      end
+
+      describe '#call' do
+        it 'prepares joined relations' do
+          relation = assoc.call(container.relations)
+
+          expect(relation.attributes).to eql(%i[id name post_id])
+
+          expect(relation.order(:id).to_a).to eql([
+            { id: 1, name: 'Jane', post_id: 2 },
+            { id: 2, name: 'Joe', post_id: 1 }
+          ])
+
+          expect(relation.where(author_id: 1).to_a).to eql(
+            [id: 1, name: 'Jane', post_id: 2]
+          )
+
+          expect(relation.where(author_id: 2).to_a).to eql(
+            [id: 2, name: 'Joe', post_id: 1]
+          )
+        end
+      end
+    end
+  end
+end

data/spec/integration/association/one_to_many_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe ROM::SQL::Association::OneToMany do
+  subject(:assoc) {
+    ROM::SQL::Association::OneToMany.new(:users, :tasks)
+  }
+
+  include_context 'users and tasks'
+
+  let(:users) { container.relations[:users] }
+  let(:tasks) { container.relations[:tasks] }
+
+  with_adapters do
+    before do
+      conf.relation(:tasks) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+          attribute :title, ROM::SQL::Types::String
+        end
+      end
+    end
+
+    describe '#result' do
+      specify { expect(ROM::SQL::Association::OneToMany.result).to be(:many) }
+    end
+
+    describe '#call' do
+      it 'prepares joined relations' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id user_id title])
+
+        expect(relation.order(:tasks__id).to_a).to eql([
+          { id: 1, user_id: 2, title: "Joe's task" },
+          { id: 2, user_id: 1, title: "Jane's task" }
+        ])
+
+        expect(relation.where(user_id: 1).to_a).to eql([
+          { id: 2, user_id: 1, title: "Jane's task" }
+        ])
+
+        expect(relation.where(user_id: 2).to_a).to eql([
+          { id: 1, user_id: 2, title: "Joe's task" }
+        ])
+      end
+    end
+
+    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      it 'preloads relation based on association' do
+        relation = tasks.for_combine(assoc).call(users.call)
+
+        expect(relation.to_a).to eql([
+          { id: 1, user_id: 2, title: "Joe's task" },
+          { id: 2, user_id: 1, title: "Jane's task" }
+        ])
+      end
+    end
+  end
+end

data/spec/integration/association/one_to_one_spec.rb

@@ -0,0 +1,57 @@
+RSpec.describe ROM::SQL::Association::OneToOne do
+  subject(:assoc) {
+    ROM::SQL::Association::OneToOne.new(:users, :accounts)
+  }
+
+  include_context 'users and accounts'
+
+  let(:users) { container.relations[:users] }
+  let(:accounts) { container.relations[:accounts] }
+
+  with_adapters do
+    before do
+      conf.relation(:accounts) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+          attribute :number, ROM::SQL::Types::String
+          attribute :balance, ROM::SQL::Types::Decimal
+        end
+      end
+    end
+
+    describe '#result' do
+      specify { expect(ROM::SQL::Association::OneToOne.result).to be(:one) }
+    end
+
+    describe '#call' do
+      it 'prepares joined relations' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id user_id number balance])
+
+        # TODO: this if caluse should be removed when (and if) https://github.com/xerial/sqlite-jdbc/issues/112
+        # will be resolved. See https://github.com/rom-rb/rom-sql/issues/49 for details
+        if defined? JRUBY_VERSION && SQLITE_DB_URI == db_uri
+          expect(relation.to_a).to eql([id: 1, user_id: 1, number: '42', balance: 10_000])
+        else
+          expect(relation.to_a).to eql([id: 1, user_id: 1, number: '42', balance: 10_000.to_d])
+        end
+      end
+    end
+
+    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      it 'preloads relation based on association' do
+        relation = accounts.for_combine(assoc).call(users.call)
+
+        # TODO: this if caluse should be removed when (and if) https://github.com/xerial/sqlite-jdbc/issues/112
+        # will be resolved. See https://github.com/rom-rb/rom-sql/issues/49 for details
+        if defined? JRUBY_VERSION && SQLITE_DB_URI == db_uri
+          expect(relation.to_a).to eql([id: 1, user_id: 1, number: '42', balance: 10_000])
+        else
+          expect(relation.to_a).to eql([id: 1, user_id: 1, number: '42', balance: 10_000.to_d])
+        end
+      end
+    end
+  end
+end

data/spec/integration/association/one_to_one_through_spec.rb

@@ -0,0 +1,90 @@
+RSpec.describe ROM::SQL::Association::OneToOneThrough do
+  subject(:assoc) {
+    ROM::SQL::Association::OneToOneThrough.new(:users, :cards, through: :accounts)
+  }
+
+  include_context 'users and accounts'
+
+  let(:users) { container.relations[:users] }
+  let(:cards) { container.relations[:cards] }
+
+  with_adapters do
+    before do
+      conf.relation(:accounts) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :user_id, ROM::SQL::Types::ForeignKey(:users)
+          attribute :number, ROM::SQL::Types::String
+          attribute :balance, ROM::SQL::Types::Decimal
+
+          associations do
+            one_to_many :cards
+            one_to_many :subscriptions, through: :cards
+          end
+        end
+      end
+
+      conf.relation(:cards) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :account_id, ROM::SQL::Types::ForeignKey(:accounts)
+          attribute :pan, ROM::SQL::Types::String
+
+          associations do
+            one_to_many :subscriptions
+          end
+        end
+      end
+
+      conf.relation(:subscriptions) do
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :card_id, ROM::SQL::Types::ForeignKey(:cards)
+          attribute :service, ROM::SQL::Types::String
+
+          associations do
+            many_to_one :cards
+          end
+        end
+      end
+    end
+
+    describe '#result' do
+      specify { expect(ROM::SQL::Association::OneToOneThrough.result).to be(:one) }
+    end
+
+    describe '#call' do
+      it 'prepares joined relations' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id account_id pan user_id])
+        expect(relation.to_a).to eql([id: 1, account_id: 1, pan: '*6789', user_id: 1])
+      end
+    end
+
+    describe ':through another assoc' do
+      subject(:assoc) do
+        ROM::SQL::Association::OneToOneThrough.new(:users, :subscriptions, through: :accounts)
+      end
+
+      let(:account_assoc) do
+        ROM::SQL::Association::OneToOneThrough.new(:accounts, :subscriptions, through: :cards)
+      end
+
+      it 'prepares joined relations through other association' do
+        relation = assoc.call(container.relations)
+
+        expect(relation.attributes).to eql(%i[id card_id service user_id])
+        expect(relation.to_a).to eql([id: 1, card_id: 1, service: 'aws', user_id: 1])
+      end
+    end
+
+    describe ROM::Plugins::Relation::SQL::AutoCombine, '#for_combine' do
+      it 'preloads relation based on association' do
+        relation = cards.for_combine(assoc).call(users.call)
+
+        expect(relation.to_a).to eql([id: 1, account_id: 1, pan: '*6789', user_id: 1])
+      end
+    end
+  end
+end

data/spec/integration/combine_spec.rb

@@ -1,37 +1,37 @@
-require 'spec_helper'
-
-describe 'Eager loading' do
+describe 'Eager loading', adapters: :all do
   include_context 'users and tasks'
 
-  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.relation(:tasks) do
-      def for_users(users)
-        where(user_id: users.map { |tuple| tuple[:id] })
+      conf.relation(:tasks) do
+        def for_users(users)
+          where(user_id: users.map { |tuple| tuple[:id] })
+        end
       end
-    end
 
-    configuration.relation(:tags) do
-      def for_tasks(tasks)
-        inner_join(:task_tags, task_id: :id)
-          .where(task_id: tasks.map { |tuple| tuple[:id] })
+      conf.relation(:tags) do
+        def for_tasks(tasks)
+          inner_join(:task_tags, task_id: :id)
+            .where(task_id: tasks.map { |tuple| tuple[:id] })
+        end
       end
     end
-  end
 
-  it 'issues 3 queries for 3 combined relations' do
-    users = container.relation(:users).by_name('Piotr')
-    tasks = container.relation(:tasks)
-    tags = container.relation(:tags)
+    it 'issues 3 queries for 3 combined relations' do
+      users = container.relation(:users).by_name('Piotr')
+      tasks = container.relation(:tasks)
+      tags = container.relation(:tags)
 
-    relation = users.combine(tasks.for_users.combine(tags.for_tasks))
+      relation = users.combine(tasks.for_users.combine(tags.for_tasks))
 
-    # TODO: figure out a way to assert correct number of issued queries
-    expect(relation.call).to be_instance_of(ROM::Relation::Loaded)
+      # TODO: figure out a way to assert correct number of issued queries
+      expect(relation.call).to be_instance_of(ROM::Relation::Loaded)
+    end
   end
 end

data/spec/integration/commands/create_spec.rb

@@ -1,11 +1,10 @@
-require 'spec_helper'
 require 'virtus'
 
-describe 'Commands / Create' do
-  include_context 'database setup'
+RSpec.describe 'Commands / Create' do
+  include_context 'relations'
 
-  subject(:users) { container.commands.users }
-  subject(:tasks) { container.commands.tasks }
+  let(:users) { commands[:users] }
+  let(:tasks) { commands[:tasks] }
 
   before do
     class Params
@@ -18,7 +17,9 @@ describe 'Commands / Create' do
       end
     end
 
-    configuration.commands(:users) do
+    conn.add_index :users, :name, unique: true
+
+    conf.commands(:users) do
       define(:create) do
         input Params
 
@@ -34,225 +35,271 @@ describe 'Commands / Create' do
       end
     end
 
-    configuration.commands(:tasks) do
+    conf.commands(:tasks) do
       define(:create)
     end
-
-    configuration.relation(:users)
-    configuration.relation(:tasks)
   end
 
-  context '#transaction' do
-    it 'creates record if nothing was raised' do
-      result = users.create.transaction {
-        users.create.call(name: 'Jane')
-      }
-
-      expect(result.value).to eq(id: 1, name: 'Jane')
-    end
-
-    it 'creates multiple records if nothing was raised' do
-      result = users.create.transaction {
-        users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
-      }
-
-      expect(result.value).to match_array([
-        { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
-      ])
-    end
-
-    it 'allows for nested transactions' do
-      result = users.create.transaction {
-        users.create.transaction {
+  with_adapters do
+    describe '#transaction' do
+      it 'creates record if nothing was raised' do
+        result = users.create.transaction {
           users.create.call(name: 'Jane')
         }
-      }
 
-      expect(result.value).to eq(id: 1, name: 'Jane')
-    end
-
-    it 'creates nothing if command error was raised' do
-      expect {
-        passed = false
+        expect(result.value).to eq(id: 1, name: 'Jane')
+      end
 
+      it 'creates multiple records if nothing was raised' do
         result = users.create.transaction {
-          users.create.call(name: 'Jane')
-          users.create.call(name: '')
-        } >-> _value {
-          passed = true
+          users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
         }
 
-        expect(result.value).to be(nil)
-        expect(result.error.message).to eql('name cannot be empty')
-        expect(passed).to be(false)
-      }.to_not change { container.relations.users.count }
-    end
-
-    it 'creates nothing if rollback was raised' do
-      expect {
-        passed = false
+        expect(result.value).to match_array([
+          { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
+        ])
+      end
 
+      it 'allows for nested transactions' do
         result = users.create.transaction {
-          users.create.call(name: 'Jane')
-          users.create.call(name: 'John')
-          raise ROM::SQL::Rollback
-        } >-> _value {
-          passed = true
+          users.create.transaction {
+            users.create.call(name: 'Jane')
+          }
         }
 
-        expect(result.value).to be(nil)
-        expect(result.error).to be(nil)
-        expect(passed).to be(false)
-      }.to_not change { container.relations.users.count }
-    end
+        expect(result.value).to eq(id: 1, name: 'Jane')
+      end
 
-    it 'creates nothing if constraint error was raised' do
-      expect {
-        begin
+      it 'creates nothing if command error was raised' do
+        expect {
           passed = false
 
-          users.create.transaction {
-            users.create.call(name: 'Jane')
+          result = users.create.transaction {
             users.create.call(name: 'Jane')
+            users.create.call(name: '')
           } >-> _value {
             passed = true
           }
-        rescue => error
-          expect(error).to be_instance_of(ROM::SQL::UniqueConstraintError)
+
+          expect(result.value).to be(nil)
+          expect(result.error.message).to eql('name cannot be empty')
           expect(passed).to be(false)
-        end
-      }.to_not change { container.relations.users.count }
-    end
+        }.to_not change { container.relations.users.count }
+      end
 
-    it 'creates nothing if anything was raised in any nested transaction' do
-      expect {
+      it 'creates nothing if rollback was raised' do
         expect {
-          users.create.transaction {
+          passed = false
+
+          result = users.create.transaction {
+            users.create.call(name: 'Jane')
             users.create.call(name: 'John')
+            raise ROM::SQL::Rollback
+          } >-> _value {
+            passed = true
+          }
+
+          expect(result.value).to be(nil)
+          expect(result.error).to be(nil)
+          expect(passed).to be(false)
+        }.to_not change { container.relations.users.count }
+      end
+
+      it 'creates nothing if constraint error was raised' do
+        expect {
+          begin
+            passed = false
+
             users.create.transaction {
               users.create.call(name: 'Jane')
-              raise Exception
+              users.create.call(name: 'Jane')
+            } >-> _value {
+              passed = true
             }
-          }
-        }.to raise_error(Exception)
-      }.to_not change { container.relations.users.count }
+          rescue => error
+            expect(error).to be_instance_of(ROM::SQL::UniqueConstraintError)
+            expect(passed).to be(false)
+          end
+        }.to_not change { container.relations.users.count }
+      end
+
+      it 'creates nothing if anything was raised in any nested transaction' do
+        expect {
+          expect {
+            users.create.transaction {
+              users.create.call(name: 'John')
+              users.create.transaction {
+                users.create.call(name: 'Jane')
+                raise Exception
+              }
+            }
+          }.to raise_error(Exception)
+        }.to_not change { container.relations.users.count }
+      end
     end
-  end
 
-  it 'returns a single tuple when result is set to :one' do
-    result = users.try { users.create.call(name: 'Jane') }
+    it 'uses relation schema for the default input handler' do
+      conf.relation(:users) do
+        register_as :users_with_schema
 
-    expect(result.value).to eql(id: 1, name: 'Jane')
-  end
+        schema do
+          attribute :id, ROM::SQL::Types::Serial
+          attribute :name, ROM::SQL::Types::String
+        end
+      end
 
-  it 'returns tuples when result is set to :many' do
-    result = users.try do
-      users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
+      conf.commands(:users_with_schema) do
+        define(:create) do
+          result :one
+        end
+      end
+
+      create = container.commands[:users_with_schema][:create]
+
+      expect(create.input[foo: 'bar', id: 1, name: 'Jane']).to eql(
+        id: 1, name: 'Jane'
+      )
     end
 
-    expect(result.value.to_a).to match_array([
-      { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
-    ])
-  end
+    it 'returns a single tuple when result is set to :one' do
+      result = users.try { users.create.call(name: 'Jane') }
 
-  it 're-raises not-null constraint violation error' do
-    expect {
-      users.try { users.create.call(name: nil) }
-    }.to raise_error(ROM::SQL::NotNullConstraintError)
-  end
+      expect(result.value).to eql(id: 1, name: 'Jane')
+    end
 
-  it 're-raises uniqueness constraint violation error' do
-    expect {
-      users.try {
-        users.create.call(name: 'Jane')
-      } >-> user {
-        users.try { users.create.call(name: user[:name]) }
-      }
-    }.to raise_error(ROM::SQL::UniqueConstraintError)
-  end
+    it 'returns tuples when result is set to :many' do
+      result = users.try do
+        users.create_many.call([{ name: 'Jane' }, { name: 'Jack' }])
+      end
 
-  it 're-raises check constraint violation error' do
-    expect {
-      users.try {
-        users.create.call(name: 'J')
-      }
-    }.to raise_error(ROM::SQL::CheckConstraintError, /name/)
-  end
+      expect(result.value.to_a).to match_array([
+        { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
+      ])
+    end
 
-  it 're-raises fk constraint violation error' do
-    expect {
-      tasks.try {
-        tasks.create.call(user_id: 918_273_645)
-      }
-    }.to raise_error(ROM::SQL::ForeignKeyConstraintError, /user_id/)
-  end
+    it 're-raises not-null constraint violation error' do
+      expect {
+        users.try { users.create.call(name: nil) }
+      }.to raise_error(ROM::SQL::NotNullConstraintError)
+    end
 
-  it 're-raises database errors' do
-    expect {
-      Params.attribute :bogus_field
-      users.try { users.create.call(name: 'some name', bogus_field: 23) }
-    }.to raise_error(ROM::SQL::DatabaseError)
-  end
+    it 're-raises uniqueness constraint violation error' do
+      expect {
+        users.try {
+          users.create.call(name: 'Jane')
+        } >-> user {
+          users.try { users.create.call(name: user[:name]) }
+        }
+      }.to raise_error(ROM::SQL::UniqueConstraintError)
+    end
 
-  it 'supports [] syntax instead of call' do
-    expect {
-      Params.attribute :bogus_field
-      users.try { users.create[name: 'some name', bogus_field: 23] }
-    }.to raise_error(ROM::SQL::DatabaseError)
-  end
+    it 're-raises fk constraint violation error' do
+      expect {
+        tasks.try {
+          tasks.create.call(user_id: 918_273_645)
+        }
+      }.to raise_error(ROM::SQL::ForeignKeyConstraintError, /user_id/)
+    end
 
-  describe '.associates' do
-    it 'sets foreign key prior execution for many tuples' do
-      configuration.commands(:tasks) do
-        define(:create) do
-          associates :user, key: [:user_id, :id]
+    it 're-raises database errors' do
+      expect {
+        Params.attribute :bogus_field
+        users.try { users.create.call(name: 'some name', bogus_field: 23) }
+      }.to raise_error(ROM::SQL::DatabaseError)
+    end
+
+    it 'supports [] syntax instead of call' do
+      expect {
+        Params.attribute :bogus_field
+        users.try { users.create[name: 'some name', bogus_field: 23] }
+      }.to raise_error(ROM::SQL::DatabaseError)
+    end
+
+    describe '#execute' do
+      context 'with a single record' do
+        it 'materializes the result' do
+          result = container.command(:users).create.execute(name: 'Jane')
+          expect(result).to eq([
+            { id: 1, name: 'Jane' }
+          ])
+        end
+      end
+
+      context 'with multiple records' do
+        it 'materializes the results' do
+          result = container.command(:users).create.execute([
+            { name: 'Jane' },
+            { name: 'John' }
+          ])
+          expect(result).to eq([
+            { id: 1, name: 'Jane' },
+            { id: 2, name: 'John' }
+          ])
         end
       end
 
-      create_user = container.command(:users).create.with(name: 'Jade')
+      context 'with a composite pk' do
+        before do
+          conn.create_table?(:user_group) do
+            primary_key [:user_id, :group_id]
+            column :user_id, Integer, null: false
+            column :group_id, Integer, null: false
+          end
 
-      create_task = container.command(:tasks).create.with([
-        { title: 'Task one' }, { title: 'Task two' }
-      ])
+          conf.relation(:user_group) do
+            schema(infer: true)
+          end
 
-      command = create_user >> create_task
+          conf.commands(:user_group) do
+            define(:create) { result :one }
+          end
+        end
 
-      result = command.call
+        after do
+          conn.drop_table(:user_group)
+        end
 
-      expect(result).to match_array([
-        { id: 1, user_id: 1, title: 'Task one' },
-        { id: 2, user_id: 1, title: 'Task two' }
-      ])
-    end
+        it 'materializes the result' do
+          pending 'TODO: with a composite pk sequel returns 0 when inserting' if mysql?
 
-    it 'sets foreign key prior execution for one tuple' do
-      configuration.commands(:tasks) do
-        define(:create) do
-          result :one
-          associates :user, key: [:user_id, :id]
+          command = container.commands[:user_group][:create]
+          result = command.call(user_id: 1, group_id: 2)
+
+          expect(result).to eql(user_id: 1, group_id: 2)
         end
       end
+    end
+  end
 
-      create_user = container.command(:users).create.with(name: 'Jade')
-      create_task = container.command(:tasks).create.with(title: 'Task one')
+  describe '#call', adapter: :postgres do
+    it 're-raises check constraint violation error', adapter: :postgres do
+      expect {
+        users.try {
+          users.create.call(name: 'J')
+        }
+      }.to raise_error(ROM::SQL::CheckConstraintError, /name/)
+    end
+  end
 
-      command = create_user >> create_task
+  describe '#upsert', adapter: :postgres do
+    let(:task) { { title: 'task 1' } }
 
-      result = command.call
+    before { tasks.create.call(task) }
 
-      expect(result).to match_array(id: 1, user_id: 1, title: 'Task one')
+    it 'raises error without upsert marker' do
+      expect {
+        tasks.create.call(task)
+      }.to raise_error(ROM::SQL::UniqueConstraintError)
     end
 
-    it 'raises when already defined' do
-      expect {
-        configuration.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/)
+    it 'raises no error for duplicated data' do
+      expect { tasks.create.upsert(task) }.to_not raise_error
     end
-  end
+
+    it 'returns record data' do
+      expect(tasks.create.upsert(task, constraint: :tasks_title_key, update: { user_id: nil })).to eql([
+        id: 1, user_id: nil, title: 'task 1'
+      ])
+    end
+  end if PG_LTE_95
 end