rom-sql 0.9.1 → 1.0.0.beta1

data/spec/integration/association/one_to_many_spec.rb

@@ -27,7 +27,7 @@ RSpec.describe ROM::SQL::Association::OneToMany do
       it 'prepares joined relations' do
         relation = assoc.call(container.relations)
 
-        expect(relation.attributes).to eql(%i[id user_id title])
+        expect(relation.schema.map(&:name)).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" },

data/spec/integration/association/one_to_one_spec.rb

@@ -28,7 +28,7 @@ RSpec.describe ROM::SQL::Association::OneToOne do
       it 'prepares joined relations' do |example|
         relation = assoc.call(container.relations)
 
-        expect(relation.attributes).to eql(%i[id user_id number balance])
+        expect(relation.schema.map(&:name)).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

data/spec/integration/association/one_to_one_through_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe ROM::SQL::Association::OneToOneThrough 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.schema.map(&:name)).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
@@ -74,7 +74,7 @@ RSpec.describe ROM::SQL::Association::OneToOneThrough do
       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.schema.map(&:name)).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

data/spec/integration/commands/create_spec.rb

@@ -27,10 +27,6 @@ RSpec.describe 'Commands / Create', :postgres do
       define(:create) do
         input Test::Params
 
-        validator -> tuple {
-          raise ROM::CommandError, 'name cannot be empty' if tuple[:name] == ''
-        }
-
         result :one
       end
 
@@ -80,18 +76,13 @@ RSpec.describe 'Commands / Create', :postgres do
 
       it 'creates nothing if command error was raised' do
         expect {
-          passed = false
-
-          result = users.create.transaction {
-            users.create.call(name: 'Jane')
-            users.create.call(name: '')
-          } >-> _value {
-            passed = true
-          }
-
-          expect(result.value).to be(nil)
-          expect(result.error.message).to eql('name cannot be empty')
-          expect(passed).to be(false)
+          begin
+            users.create.transaction {
+              users.create.call(name: 'Jane')
+              users.create.call(name: nil)
+            }
+          rescue ROM::SQL::Error
+          end
         }.to_not change { container.relations.users.count }
       end
 
@@ -209,7 +200,8 @@ RSpec.describe 'Commands / Create', :postgres do
       }.to raise_error(ROM::SQL::UniqueConstraintError)
     end
 
-    it 're-raises fk constraint violation error' do
+    it 're-raises fk constraint violation error' do |ex|
+      pending 'Waits for https://github.com/jeremyevans/sequel/pull/1283' if jruby? && sqlite?(ex)
       expect {
         tasks.try {
           tasks.create.call(user_id: 918_273_645)
@@ -219,16 +211,8 @@ RSpec.describe 'Commands / Create', :postgres do
 
     it 're-raises database errors' do
       expect {
-        Test::Params.attribute :bogus_field, Types::Int
-        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 {
-        Test::Params.attribute :bogus_field, Types::Int
-        users.try { users.create[name: 'some name', bogus_field: 23] }
-      }.to raise_error(ROM::SQL::DatabaseError)
+        users.try { users.create.call(name: nil) }
+      }.to raise_error(ROM::SQL::NotNullConstraintError)
     end
 
     describe '#execute' do

data/spec/integration/commands/update_spec.rb

@@ -12,138 +12,83 @@ RSpec.describe 'Commands / Update' do
   let(:peter) { { name: 'Peter' } }
 
   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
+    before do
+      Test::User = Class.new(Dry::Struct) {
+        attribute :id, Types::Strict::Int
+        attribute :name, Types::Strict::String
+      }
+
+      conf.relation(:users) do
+        def by_id(id)
+          where(id: id).limit(1)
         end
-      end
 
-      it 'uses relation schema for the default input handler' do
-        conf.commands(:users) do
-          define(:update) do
-            result :one
-          end
+        def by_name(name)
+          where(name: name)
         end
-
-        expect(update.input[foo: 'bar', id: 1, name: 'Jane']).to eql(
-          id: 1, name: 'Jane'
-        )
       end
-    end
 
-    context 'without a schema' do
-      before do
-        Test::User = Class.new(Dry::Struct) {
-          attribute :id, Types::Strict::Int
-          attribute :name, Types::Strict::String
-        }
-
-        conf.relation(:users) do
-          def by_id(id)
-            where(id: id).limit(1)
-          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
-
-        relation.insert(name: 'Piotr')
-        relation.insert(name: 'Jane')
+      conf.commands(:users) do
+        define(:update)
       end
 
-      it 'respects configured input handler' do
-        expect(update.input[foo: 'bar', id: 1, name: 'Jane']).to eql(
-          foo: 'bar', id: 1, name: 'Jane'
-        )
+      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)
-          end
+      relation.insert(name: 'Piotr')
+      relation.insert(name: 'Jane')
+    end
 
-          expect(result.value).to eq([{ id: 1, name: 'Peter' }])
+    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 nothing if error was raised' do
-          users.update.transaction do
-            users.update.by_id(piotr[:id]).call(peter)
-            raise ROM::SQL::Rollback
-          end
-
-          expect(relation.first[:name]).to eql('Piotr')
-        end
+        expect(result.value).to eq([{ id: 1, name: 'Peter' }])
       end
 
-      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' }])
+      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(Test::User.new(piotr)).call(peter)
-          end
+        expect(relation.first[:name]).to eql('Piotr')
+      end
+    end
 
-          expect(result.value.to_a).to match_array([Test::User.new(id: 1, name: 'Peter')])
+    describe '#call' do
+      it 'updates relation tuples' do
+        result = users.try do
+          users.update.by_id(piotr[:id]).call(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(result.value.to_a).to match_array([{ id: 1, name: 'Peter' }])
+      end
 
-            command.call(name: piotr[:name])
-          end
+      it 're-raises database errors' do |example|
+        pending 'why is it failing on travis?' if ENV['TRAVIS'] && mysql?(example) && !jruby?
 
-          expect(result.value.to_a).to be_empty
-        end
+        expect {
+          users.update.by_id(piotr[:id]).call(name: nil)
+        }.to raise_error(ROM::SQL::NotNullConstraintError, /name/)
+      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
+      it 'materializes single result' do
+        result = users.update.by_name('Piotr').call(name: 'Pete')
+        expect(result).to eq([
+          { id: 1, name: 'Pete' }
+        ])
+      end
 
-        describe '#execute' 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
+      it 'materializes multiple results' do
+        result = users.update.by_name(%w(Piotr Jane)).call(name: 'Josie')
+        expect(result).to eq([
+          { id: 1, name: 'Josie' },
+          { id: 2, name: 'Josie' }
+        ])
       end
     end
   end

data/spec/integration/gateway_spec.rb

@@ -62,28 +62,42 @@ RSpec.describe ROM::SQL::Gateway, :postgres, skip_tables: true do
     end
   end
 
-  context 'setting up' do
-    it 'skips settings up associations when tables are missing' do
-      conf = ROM::Configuration.new(:sql, uri) do |config|
-        config.relation(:foos) do
-          use :assoc_macros
-          one_to_many :bars, key: :foo_id
-        end
+  describe 'transactions' do
+    before do
+      conn.drop_table?(:names)
+
+      conn.create_table(:names) do
+        String :name
       end
-      expect { ROM.container(conf) }.not_to raise_error
     end
 
-    it 'skips finalization a relation when table is missing' do
-      conf = ROM::Configuration.new(:sql, uri) do |config|
-        class Foos < ROM::Relation[:sql]
-          dataset :foos
-          use :assoc_macros
-          one_to_many :bars, key: :foo_id
-        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 { ROM.container(conf) }.not_to raise_error
-      expect { Foos.model.dataset }.to raise_error(Sequel::Error, /no dataset/i)
+      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/plugins/associates_spec.rb

@@ -13,6 +13,33 @@ RSpec.describe 'Plugins / :associates' do
         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
+      end
+
       shared_context 'automatic FK setting' do
         it 'sets foreign key prior execution for many tuples' do
           create_user = users[:create].with(name: 'Jade')

data/spec/integration/plugins/auto_wrap_spec.rb

@@ -17,26 +17,26 @@ RSpec.describe 'Plugins / :auto_wrap' do
       end
 
       context 'when parent relation is registered under dataset name' do
-        subject(:tasks) { container.relations[:tasks] }
+        subject(:tasks) { relations[:tasks] }
 
-        let(:users) { container.relations[:users] }
+        let(:users) { relations[:users] }
 
         before do
-          conf.relation(:tasks)
-          conf.relation(:users)
+          conf.relation(:tasks) { schema(infer: true) }
+          conf.relation(:users) { schema(infer: true) }
         end
 
         include_context 'joined tuple'
       end
 
       context 'when parent relation is registered under a custom name' do
-        subject(:tasks) { container.relations[:tasks] }
+        subject(:tasks) { relations[:tasks] }
 
-        let(:users) { container.relations[:authors] }
+        let(:users) { relations[:authors] }
 
         before do
-          conf.relation(:tasks)
-          conf.relation(:authors) { dataset :users }
+          conf.relation(:tasks) { schema(infer: true) }
+          conf.relation(:authors) { schema(:users, infer: true) }
         end
 
         include_context 'joined tuple'

data/spec/integration/schema/call_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+RSpec.describe ROM::SQL::Schema, '#call' do
+  include_context 'database setup'
+
+  with_adapters :postgres do
+    before do
+      conf.relation(:users) do
+        schema(infer: true)
+      end
+    end
+
+    let(:schema) { relations[:users].schema }
+
+    it 'auto-projects a relation' do
+      expect(schema.(relations[:users]).dataset.sql).to eql('SELECT "id", "name" FROM "users" ORDER BY "users"."id"')
+    end
+
+    it 'maintains schema' do
+      projected = relations[:users].schema.project(:name)
+      expect(projected.(relations[:users]).schema).to be(projected)
+    end
+  end
+end