rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/integration/combine_with_spec.rb

@@ -1,43 +0,0 @@
-RSpec.describe 'Eager loading' do
-  include_context 'users and tasks'
-
-  with_adapters do
-    before do
-      conf.relation(:users) do
-        auto_map false
-
-        def by_name(name)
-          where(name: name)
-        end
-      end
-
-      conf.relation(:tasks) do
-        auto_map false
-
-        def for_users(users)
-          where(user_id: users.map { |tuple| tuple[:id] })
-        end
-      end
-
-      conf.relation(:tags) do
-        auto_map false
-
-        def for_tasks(tasks)
-          inner_join(:task_tags, task_id: :id)
-            .where(task_id: tasks.map { |tuple| tuple[:id] })
-        end
-      end
-    end
-
-    it 'issues 3 queries for 3.graphd relations' do
-      users = container.relations[:users].by_name('Piotr')
-      tasks = container.relations[:tasks]
-      tags = container.relations[:tags]
-
-      relation = users.combine_with(tasks.for_users.combine_with(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)
-    end
-  end
-end

data/spec/integration/commands/create_spec.rb

@@ -1,304 +0,0 @@
-require 'dry-struct'
-
-RSpec.describe 'Commands / Create', :postgres, seeds: false do
-  include_context 'relations'
-
-  let(:create_user) { user_commands.create }
-  let(:create_users) { user_commands.create_many }
-  let(:create_task) { task_commands.create }
-
-  before do |ex|
-    module Test
-      class Params < Dry::Struct
-        attribute :name, Types::Strict::String.optional
-
-        def self.[](input)
-          new(input)
-        end
-      end
-    end
-
-    conn.add_index :users, :name, unique: true
-
-    if sqlite?(ex)
-      conn.add_index :tasks, :title, unique: true
-    else
-      conn.execute "ALTER TABLE tasks add CONSTRAINT tasks_title_key UNIQUE (title)"
-    end
-
-    conf.commands(:users) do
-      define(:create) do
-        input Test::Params
-
-        result :one
-      end
-
-      define(:create_many, type: :create) do
-        result :many
-      end
-    end
-
-    conf.commands(:tasks) do
-      define(:create)
-    end
-  end
-
-  with_adapters do
-    describe '#transaction' do
-      it 'creates record if nothing was raised' do
-        result = users.transaction {
-          create_user.call(name: 'Jane')
-        }
-
-        expect(result).to eql(id: 1, name: 'Jane')
-      end
-
-      it 'creates multiple records if nothing was raised' do
-        result = users.transaction {
-          create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
-        }
-
-        expect(result).to match_array([
-          { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
-        ])
-      end
-
-      it 'allows for nested transactions' do
-        result = users.transaction {
-          users.transaction {
-            create_user.call(name: 'Jane')
-          }
-        }
-
-        expect(result).to eql(id: 1, name: 'Jane')
-      end
-
-      it 'creates nothing if command error was raised' do
-        expect {
-          begin
-            users.transaction {
-              create_user.call(name: 'Jane')
-              create_user.call(name: nil)
-            }
-          rescue ROM::SQL::Error
-          end
-        }.to_not change { container.relations.users.count }
-      end
-
-      it 'creates nothing if rollback was raised' do
-        expect {
-          result = users.transaction { |t|
-            create_user.call(name: 'Jane')
-            create_user.call(name: 'John')
-            t.rollback!
-          }
-
-          expect(result).to be(nil)
-        }.to_not change { container.relations.users.count }
-      end
-
-      it 'creates nothing if constraint error was raised' do
-        expect {
-          begin
-            passed = false
-
-            users.transaction {
-              create_user.call(name: 'Jane')
-              create_user.call(name: 'Jane')
-              passed = true
-            }
-          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.transaction {
-              create_user.call(name: 'John')
-
-              users.transaction {
-                create_user.call(name: 'Jane')
-                raise Exception
-              }
-            }
-          }.to raise_error(Exception)
-        }.to_not change { container.relations.users.count }
-      end
-    end
-
-    it 'uses relation schema for the default input handler' do
-      conf.relation(:users_with_schema) do
-        schema(:users) do
-          attribute :id, ROM::SQL::Types::Serial
-          attribute :name, ROM::SQL::Types::String
-        end
-      end
-
-      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
-
-    it 'returns a single tuple when result is set to :one' do
-      result = create_user.call(name: 'Jane')
-
-      expect(result).to eql(id: 1, name: 'Jane')
-    end
-
-    it 'returns tuples when result is set to :many' do
-      result = create_users.call([{ name: 'Jane' }, { name: 'Jack' }])
-
-      expect(result.to_a).to match_array([
-        { id: 1, name: 'Jane' }, { id: 2, name: 'Jack' }
-      ])
-    end
-
-    it 're-raises not-null constraint violation error' do
-      expect {
-        create_user.call(name: nil)
-      }.to raise_error(ROM::SQL::NotNullConstraintError)
-    end
-
-    # Because Oracle doesn't have boolean in SQL
-    if !metadata[:oracle]
-      context 'with puppies' do
-        include_context 'puppies'
-
-        before do
-          conf.relation(:puppies) do
-            schema(infer: true)
-          end
-
-
-          conf.commands(:puppies) do
-            define(:create)
-          end
-        end
-
-        it 're-raises not-null constraint violation error with nil boolean' do
-          puppies = commands[:puppies]
-
-          expect { puppies.create.call(name: 'Charlie', cute: nil) }.
-            to raise_error(ROM::SQL::NotNullConstraintError)
-        end
-      end
-    end
-
-    it 'raises uniqueness constraint violation error' do
-      expect {
-        user = create_user.call(name: 'Jane')
-        create_user.call(name: user[:name])
-      }.to raise_error(ROM::SQL::UniqueConstraintError)
-    end
-
-    it 're-raises fk constraint violation error' do |ex|
-      expect { create_task.call(user_id: 918_273_645) }.
-        to raise_error(ROM::SQL::ForeignKeyConstraintError)
-    end
-
-    it 're-raises database errors' do
-      expect {
-        create_user.call(name: nil)
-      }.to raise_error(ROM::SQL::NotNullConstraintError)
-    end
-
-    describe '#execute' do
-      context 'with a single record' do
-        it 'materializes the result' do
-          result = create_user.execute(name: 'Jane')
-
-          expect(result).to eq([{ id: 1, name: 'Jane' }])
-        end
-      end
-
-      context 'with multiple records' do
-        it 'materializes the results' do
-          result = create_user.execute([
-            { name: 'Jane' },
-            { name: 'John' }
-          ])
-
-          expect(result).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'John' }])
-        end
-      end
-
-      context 'with a composite pk' do
-        before do
-          inferrable_relations.concat %i(user_group)
-        end
-
-        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
-
-          conf.relation(:user_group) do
-            schema(infer: true)
-          end
-
-          conf.commands(:user_group) do
-            define(:create) { result :one }
-          end
-        end
-
-        # with a composite pk sequel returns 0 when inserting for MySQL
-        if !metadata[:mysql]
-          it 'materializes the result' do |ex|
-            command = container.commands[:user_group][:create]
-            result = command.call(user_id: 1, group_id: 2)
-
-            pending "if sequel could use Oracle's RETURNING statement, that would be possible" if oracle?(ex)
-            expect(result).to eql(user_id: 1, group_id: 2)
-          end
-        end
-      end
-    end
-  end
-
-  describe '#call' do
-    it 'raises check constraint violation error' do
-      expect { create_user.call(name: 'J') }.
-        to raise_error(ROM::SQL::CheckConstraintError, /name/)
-    end
-
-    it 'raises constraint violation error' do
-      expect { create_task.call(title: '') }.to raise_error(ROM::SQL::ConstraintError, /title/)
-    end
-  end
-
-  describe '#upsert' do
-    let(:task) { { title: 'task 1' } }
-
-    before { create_task.call(task) }
-
-    it 'raises error without upsert marker' do
-      expect {
-        create_task.call(task)
-      }.to raise_error(ROM::SQL::UniqueConstraintError)
-    end
-
-    it 'raises no error for duplicated data' do
-      expect { create_task.upsert(task) }.to_not raise_error
-    end
-
-    it 'returns record data' do
-      expect(create_task.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

data/spec/integration/commands/delete_spec.rb

@@ -1,84 +0,0 @@
-RSpec.describe 'Commands / Delete' do
-  include_context 'users and tasks'
-
-  let(:delete_user) { user_commands.delete }
-
-  with_adapters do
-    before do
-      conf.relation(:users) do
-        def by_name(name)
-          where(name: name)
-        end
-      end
-
-      conf.commands(:users) do
-        define(:delete) do
-          result :one
-        end
-      end
-
-      users.insert(id: 3, name: 'Jade')
-      users.insert(id: 4, name: 'John')
-    end
-
-    describe '#transaction' do
-      it 'deletes in normal way if no error raised' do
-        expect {
-          users.transaction do
-            delete_user.by_name('Jade').call
-          end
-        }.to change { users.count }.by(-1)
-      end
-
-      it 'deletes nothing if error was raised' do
-        expect {
-          users.transaction do |t|
-            delete_user.by_name('Jade').call
-            t.rollback!
-          end
-        }.to_not change { users.count }
-      end
-    end
-
-    describe '#call' do
-      it 'deletes all tuples in a restricted relation' do
-        result = delete_user.by_name('Jade').call
-
-        expect(result).to eql(id: 3, name: 'Jade')
-      end
-
-      it 're-raises database error' do
-        command = delete_user.by_name('Jade')
-
-        expect(command.relation).to receive(:delete).and_raise(
-          Sequel::DatabaseError, 'totally wrong'
-        )
-
-        expect {
-          command.call
-        }.to raise_error(ROM::SQL::DatabaseError, /totally wrong/)
-      end
-    end
-
-    describe '#execute' do
-      context 'with a single record' do
-        it 'materializes the result' do
-          result = container.commands[:users].delete.by_name(%w(Jade)).execute
-          expect(result).to eq([
-            { id: 3, name: 'Jade' }
-          ])
-        end
-      end
-
-      context 'with multiple records' do
-        it 'materializes the results' do
-          result = container.commands[: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

data/spec/integration/commands/update_spec.rb

@@ -1,90 +0,0 @@
-require 'dry-struct'
-
-RSpec.describe 'Commands / Update', seeds: false do
-  include_context 'users'
-
-  let(:update_user) { user_commands[:update] }
-
-  let(:piotr) { users.by_name('Piotr').one }
-  let(:peter) { { name: 'Peter' } }
-
-  with_adapters do
-    before do
-      Test::User = Class.new(Dry::Struct) {
-        attribute :id, Types::Strict::Int
-        attribute :name, Types::Strict::String
-      }
-
-      conf.relation(:users) do
-        schema(infer: true)
-
-        def by_id(id)
-          where(id: id)
-        end
-
-        def by_name(name)
-          where(name: name)
-        end
-      end
-
-      conf.commands(:users) do
-        define(:update)
-      end
-
-      conf.mappers do
-        register :users, entity: -> tuples { tuples.map { |tuple| Test::User.new(tuple) } }
-      end
-
-      users.insert(name: 'Piotr')
-      users.insert(name: 'Jane')
-    end
-
-    context '#transaction' do
-      it 'update record if there was no errors' do
-        result = users.transaction do
-          update_user.by_id(piotr[:id]).call(peter)
-        end
-
-        expect(result).to eq([{ id: 1, name: 'Peter' }])
-      end
-
-      it 'updates nothing if error was raised' do
-        users.transaction do |t|
-          update_user.by_id(piotr[:id]).call(peter)
-          t.rollback!
-        end
-
-        expect(users.first[:name]).to eql('Piotr')
-      end
-    end
-
-    describe '#call' do
-      it 'updates relation tuples' do
-        result = update_user.by_id(piotr[:id]).call(peter)
-
-        expect(result.to_a).to match_array([{ id: 1, name: 'Peter' }])
-      end
-
-      it 're-raises database errors' do |example|
-        expect {
-          update_user.by_id(piotr[:id]).call(name: nil)
-        }.to raise_error(ROM::SQL::NotNullConstraintError, /name/i)
-      end
-
-      it 'materializes single result' do
-        result = update_user.by_name('Piotr').call(name: 'Pete')
-        expect(result).to eq([
-          { id: 1, name: 'Pete' }
-        ])
-      end
-
-      it 'materializes multiple results' do
-        result = update_user.by_name(%w(Piotr Jane)).call(name: 'Josie')
-        expect(result).to eq([
-          { id: 1, name: 'Josie' },
-          { id: 2, name: 'Josie' }
-        ])
-      end
-    end
-  end
-end