rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/unit/relation/lock_spec.rb

@@ -1,93 +0,0 @@
-require 'concurrent/atomic/count_down_latch'
-
-RSpec.describe ROM::Relation, '#lock' do
-  include_context 'users and tasks'
-
-  subject(:relation) { users }
-
-  def lock_style(relation)
-    relation.dataset.opts.fetch(:lock)
-  end
-
-  context 'with hitting the database' do
-    let(:latch) { Concurrent::CountDownLatch.new }
-
-    let(:timeout) { (defined? JRUBY_VERSION) ? 2 : 0.2 }
-
-    let!(:start) { Time.now }
-
-    def elapsed_time
-      Time.now.to_f - start.to_f
-    end
-
-    with_adapters :postgres, :mysql, :oracle do
-      it 'locks rows for update' do
-        Thread.new do
-          relation.lock do |rel|
-            latch.count_down
-
-            sleep timeout
-          end
-        end
-
-        latch.wait
-
-        expect(elapsed_time).to be < timeout
-
-        relation.lock.to_a
-
-        expect(elapsed_time).to be > timeout
-      end
-    end
-  end
-
-  with_adapters :postgres, :mysql, :oracle do
-    it 'selects rows for update' do
-      expect(lock_style(relation.lock)).to eql('FOR UPDATE')
-    end
-
-    it 'locks without wait' do
-      expect(lock_style(relation.lock(wait: false))).to eql('FOR UPDATE NOWAIT')
-    end
-
-    it 'skips locked rows' do
-      expect(lock_style(relation.lock(skip_locked: true))).to eql('FOR UPDATE SKIP LOCKED')
-    end
-
-    it 'raises an exception on attempt to use NOWAIT/WAIT with SKIP LOCKED' do
-      expect { relation.lock(wait: false, skip_locked: true) }
-        .to raise_error(ArgumentError, /cannot be used/)
-    end
-  end
-
-  with_adapters :postgres do
-    it 'locks with UPDATE OF' do
-      expect(lock_style(relation.lock(of: :users))).to eql('FOR UPDATE OF users')
-      expect(lock_style(relation.lock(of: :users, skip_locked: true))).to eql('FOR UPDATE OF users SKIP LOCKED')
-    end
-
-    it 'locks rows in different modes' do
-      expect(lock_style(relation.lock(mode: :update))).to eql('FOR UPDATE')
-      expect(lock_style(relation.lock(mode: :no_key_update))).to eql('FOR NO KEY UPDATE')
-      expect(lock_style(relation.lock(mode: :share))).to eql('FOR SHARE')
-      expect(lock_style(relation.lock(mode: :key_share))).to eql('FOR KEY SHARE')
-    end
-  end
-
-  with_adapters :mysql do
-    it 'locks rows in the SHARE mode' do
-      expect(lock_style(relation.lock(mode: :share))).to eql('LOCK IN SHARE MODE')
-    end
-  end
-
-  with_adapters :oracle do
-    it 'locks with timeout' do
-      expect(lock_style(relation.lock(wait: 10))).to eql('FOR UPDATE WAIT 10')
-    end
-
-    it 'locks with UPDATE OF' do
-      expect(lock_style(relation.lock(of: :name))).to eql('FOR UPDATE OF name')
-      expect(lock_style(relation.lock(of: %i(id name)))).to eql('FOR UPDATE OF id, name')
-    end
-  end
-end

data/spec/unit/relation/map_spec.rb

@@ -1,16 +0,0 @@
-RSpec.describe ROM::Relation, '#map' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'yields tuples' do
-      result = relation.map { |tuple| tuple[:name] }
-      expect(result).to eql(%w(Jane Joe))
-    end
-
-    it 'plucks value' do
-      expect(relation.map(:name)).to eql(%w(Jane Joe))
-    end
-  end
-end

data/spec/unit/relation/max_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#max' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users'
-
-  with_adapters do
-    it 'delegates to dataset and return value' do
-      expect(relation.max(:id)).to eql(2)
-    end
-  end
-end

data/spec/unit/relation/min_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#min' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'returns a min' do
-      expect(relation.min(:id)).to eql(1)
-    end
-  end
-end

data/spec/unit/relation/order_spec.rb

@@ -1,51 +0,0 @@
-RSpec.describe ROM::Relation, '#order' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  before do
-    relation.insert(id: 3, name: 'Jade')
-  end
-
-  with_adapters do
-    it 'orders by provided attribute names' do
-      ordered = relation.order(:name, :id)
-
-      expect(ordered.to_a).
-        to eql([{ id: 3, name: 'Jade' }, { id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
-    end
-
-    it 'orders by provided attribute using a block' do
-      ordered = relation.
-                  qualified.
-                  select(:id, :name).
-                  left_join(:tasks, user_id: :id).
-                  order { name.qualified.desc }
-
-      expect(ordered.to_a).
-        to eql([{ id: 2, name: 'Joe' }, { id: 1, name: 'Jane' }, { id: 3, name: 'Jade' }])
-    end
-
-    it 'orders by provided attributes using a block' do
-      ordered = relation.
-                  qualified.
-                  select(:id, :name).
-                  left_join(:tasks, user_id: :id).
-                  order { [name.qualified.desc, id.qualified.desc] }
-
-      expect(ordered.to_a).
-        to eql([{ id: 2, name: 'Joe' }, { id: 1, name: 'Jane' }, { id: 3, name: 'Jade' }])
-    end
-  end
-
-  with_adapters :postgres, :mysql do
-    it 'orders by virtual attributes' do
-      ordered = relation.
-                  select { string::concat(id, '-', name).as(:uid) }.
-                  order(:uid)
-
-      expect(ordered.to_a).
-        to eql([{ uid: '1-Jane' }, { uid: '2-Joe' }, { uid: '3-Jade' }])
-    end
-  end
-end

data/spec/unit/relation/pluck_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#pluck' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'returns a list of values from a specific column' do
-      expect(relation.pluck(:id)).to eql([1, 2])
-    end
-  end
-end

data/spec/unit/relation/prefix_spec.rb

@@ -1,29 +0,0 @@
-RSpec.describe ROM::Relation, '#prefix' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:users) do
-      schema(infer: true)
-
-      def sorted
-        order(:id)
-      end
-    end
-  end
-
-  with_adapters do
-    it 'projects the dataset using new column names' do
-      prefixed = relation.sorted.prefix(:user)
-
-      expect(prefixed.first).to eql(user_id: 1, user_name: 'Jane')
-    end
-
-    it 'uses singularized table name as the default prefix' do
-      prefixed = relation.sorted.prefix
-
-      expect(prefixed.first).to eql(user_id: 1, user_name: 'Jane')
-    end
-  end
-end

data/spec/unit/relation/primary_key_spec.rb

@@ -1,27 +0,0 @@
-RSpec.describe ROM::Relation, '#primary_key' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    context 'with schema' do
-      it 'returns configured primary key from the schema' do
-        conf.relation(:users) do
-          schema do
-            attribute :name, ROM::SQL::Types::String.meta(primary_key: true)
-          end
-        end
-
-        expect(relation.primary_key).to be(:name)
-      end
-    end
-
-    context 'without schema' do
-      it 'returns :id by default' do
-        conf.relation(:users) { schema(infer: true) }
-
-        expect(relation.primary_key).to be(:id)
-      end
-    end
-  end
-end

data/spec/unit/relation/project_spec.rb

@@ -1,24 +0,0 @@
-RSpec.describe ROM::Relation, '#project' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:users) do
-      schema(infer: true)
-
-      def sorted
-        order(:id)
-      end
-    end
-  end
-
-  with_adapters do
-    it 'projects the dataset using new column names' do
-      projected = relation.sorted.project(:name)
-
-      expect(projected.schema.map(&:to_sql_name)).to match_array(Sequel[:name])
-      expect(projected.first).to eql(name: 'Jane')
-    end
-  end
-end

data/spec/unit/relation/qualified_columns_spec.rb

@@ -1,30 +0,0 @@
-RSpec.describe ROM::Relation, '#qualified_columns' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:users) do
-      schema(infer: true)
-
-      def sorted
-        order(:id)
-      end
-    end
-  end
-
-  with_adapters do
-    it 'returns qualified column names' do
-      columns = relation.sorted.prefix(:user).qualified_columns
-
-      expect(columns).to eql([Sequel.qualify(:users, :id).as(:user_id),
-                              Sequel.qualify(:users, :name).as(:user_name)])
-    end
-
-    it 'returns projected qualified column names' do
-      columns = relation.sorted.project(:id).prefix(:user).qualified_columns
-
-      expect(columns).to eql([Sequel.qualify(:users, :id).as(:user_id)])
-    end
-  end
-end

data/spec/unit/relation/qualified_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe ROM::Relation, '#qualified' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'qualifies all attributes' do
-      qualified = relation.qualified
-
-      expect(qualified.schema.all?(&:qualified)).to be(true)
-    end
-
-    it 'qualifies virtual attributes' do
-      qualified = relation.
-                    left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
-                    select(:id, tasks[:id].func { int::count(id).as(:count) }).
-                    qualified.
-                    group(:id)
-
-      expect(qualified.schema.all?(&:qualified)).to be(true)
-
-      expect(qualified.to_a).to eql([{ id: 1, count: 1 }, { id: 2, count: 1 }])
-    end
-  end
-end

data/spec/unit/relation/read_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe ROM::Relation, '#read' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    let(:users) do
-      relation.read('SELECT name FROM users')
-    end
-
-    it 'returns results from raw SQL' do
-      expect(users).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
-    end
-
-    it 'returns a new SQL relation' do
-      materialized = users.()
-      expect(materialized).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
-      expect(materialized.source).to be(users)
-    end
-
-    it 'has empty schema' do
-      expect(users.schema).to be_empty
-    end
-  end
-end

data/spec/unit/relation/rename_spec.rb

@@ -1,23 +0,0 @@
-RSpec.describe ROM::Relation, '#rename' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:users) do
-      schema(infer: true)
-
-      def sorted
-        order(:id)
-      end
-    end
-  end
-
-  with_adapters do
-    it 'projects the dataset using new column names' do
-      renamed = relation.sorted.rename(id: :user_id, name: :user_name)
-
-      expect(renamed.first).to eql(user_id: 1, user_name: 'Jane')
-    end
-  end
-end

data/spec/unit/relation/right_join_spec.rb

@@ -1,57 +0,0 @@
-RSpec.describe ROM::Relation, '#right_join' do
-  subject(:relation) { relations[:tasks] }
-
-  include_context 'users and tasks'
-
-  with_adapters :postgres, :mysql do
-    it 'joins relations using left outer join' do
-      users.insert id: 3, name: 'Jade'
-      relation.insert id: 3, title: 'Unassigned'
-
-      result = relation.
-                 right_join(:users, id: :user_id).
-                 select(:title, users[:name])
-
-      expect(result.schema.map(&:name)).to eql(%i[title name])
-
-      expect(result.to_a).to match_array([
-        { name: 'Joe', title: "Joe's task" },
-        { name: 'Jane', title: "Jane's task" },
-        { name: 'Jade', title: nil }
-      ])
-    end
-
-    context 'with associations' do
-      before do
-        conf.relation(:users) do
-          schema(infer: true) do
-            associations { has_many :tasks }
-          end
-        end
-
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations { belongs_to :user }
-          end
-        end
-      end
-
-      it 'joins relation with join keys inferred' do
-        users.insert id: 3, name: 'Jade'
-        relation.insert id: 3, title: 'Unassigned'
-
-        result = relation.
-                   right_join(users).
-                   select(:title, users[:name])
-
-        expect(result.schema.map(&:name)).to eql(%i[title name])
-
-        expect(result.to_a).to match_array([
-                                             { name: 'Joe', title: "Joe's task" },
-                                             { name: 'Jane', title: "Jane's task" },
-                                             { name: 'Jade', title: nil }
-                                           ])
-      end
-    end
-  end
-end