rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/unit/relation/distinct_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe ROM::Relation, '#distinct' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  before do
-    relation.insert id: 3, name: 'Jane'
-  end
-
-  with_adapters :postgres do
-    it 'delegates to dataset and returns a new relation' do
-      expect(relation.distinct(:name).order(:name).group(:name, :id).to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe' }])
-    end
-  end
-end

data/spec/unit/relation/exclude_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#exclude' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'delegates to dataset and returns a new relation' do
-      expect(relation.exclude(name: 'Jane').to_a).to eql([{ id: 2, name: 'Joe' }])
-    end
-  end
-end

data/spec/unit/relation/exist_predicate_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe ROM::Relation, '#exist?' do
-  include_context 'users and tasks'
-
-  subject(:relation) { users }
-
-  with_adapters do
-    it 'returns true if relation has at least one tuple' do
-      expect(relation.exist?).to be(true)
-    end
-
-    it 'returns false if relation is empty' do
-      expect(relation.where(name: 'Klaus').exist?).to be(false)
-    end
-
-    it 'accepts a condition' do
-      expect(relation.exist?(name: 'Jane')).to be(true)
-      expect(relation.exist?(name: 'Klaus')).to be(false)
-    end
-
-    it 'accepts a block' do
-      expect(relation.exist? { name.is('Jane') }).to be true
-      expect(relation.exist? { name.is('Klaus') }).to be false
-    end
-  end
-end

data/spec/unit/relation/exists_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe ROM::Relation, '#exists' do
-  include_context 'users and tasks'
-
-  let(:tasks) { container.relations.tasks }
-  let(:users) { container.relations.users }
-
-  with_adapters do
-    it 'returns true if subquery has at least one tuple' do
-      subquery = tasks.where(tasks[:user_id].qualified => users[:id].qualified)
-      expect(users.where { exists(subquery) }.count).to eql(2)
-    end
-
-    it 'returns false if subquery is empty' do
-      subquery = tasks.where(false)
-      expect(users.where { exists(subquery) }.count).to eql(0)
-    end
-  end
-end

data/spec/unit/relation/fetch_spec.rb

@@ -1,21 +0,0 @@
-RSpec.describe ROM::Relation, '#fetch' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    describe '#fetch' do
-      it 'returns a single tuple identified by the pk' do
-        expect(relation.fetch(1)).to eql(id: 1, name: 'Jane')
-      end
-
-      it 'raises when tuple was not found' do
-        expect { relation.fetch(535315412) }.to raise_error(ROM::TupleCountMismatchError)
-      end
-
-      it 'raises when more tuples were returned' do
-        expect { relation.fetch([1, 2]) }.to raise_error(ROM::TupleCountMismatchError)
-      end
-    end
-  end
-end

data/spec/unit/relation/group_spec.rb

@@ -1,61 +0,0 @@
-RSpec.describe ROM::Relation, '#group' do
-  subject(:relation) { relations[:users] }
-
-  let(:notes) { relations[:notes] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'groups by provided attribute name' do |example|
-      # Oracle doesn't support concise GROUP BY
-      group_by = oracle?(example) ? %i(id name) : %i(id)
-      grouped = relation.
-                  qualified.
-                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
-                  group(*group_by)
-
-      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
-    end
-
-    it 'groups by provided attribute name in a block' do
-      grouped = relation.
-                  qualified.
-                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
-                  group { [id.qualified, name.qualified] }
-
-      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
-    end
-
-    it 'groups by aliased attributes' do
-      grouped = relation.
-                  select { id.as(:user_id) }.
-                  group(:id)
-
-      expect(grouped.to_a).to eql([{ user_id: 1 }, { user_id: 2 }])
-    end
-  end
-
-  with_adapters :postgres do
-    include_context 'notes'
-
-    it 'groups by provided attribute name in and attributes from a block' do
-      grouped = relation.
-                  qualified.
-                  left_join(:tasks, tasks[:user_id].qualified => relation[:id].qualified).
-                  group(tasks[:title]) { id.qualified }
-
-      expect(grouped.to_a).to eql([{ id: 1, name: 'Jane' }, { id: 2, name: 'Joe'}])
-    end
-
-    it 'groups by a function' do
-      notes.insert user_id: 1, text: 'Foo', created_at: Time.now, updated_at: Time.now
-
-      grouped = notes
-                  .select { [int::count(id), time::date_trunc('day', created_at).as(:date)] }
-                  .group { date_trunc('day', created_at) }
-                  .order(nil)
-
-      expect(grouped.to_a).to eql([ count: 1, date: Date.today.to_time ])
-    end
-  end
-end

data/spec/unit/relation/having_spec.rb

@@ -1,22 +0,0 @@
-RSpec.describe ROM::Relation, '#having' do
-  subject(:relation) do
-    relations[:users]
-      .inner_join(:tasks, user_id: :id)
-      .qualified
-      .select_group(:id, :name)
-      .select_append { int::count(:tasks).as(:task_count) }
-  end
-
-  include_context 'users and tasks'
-
-  with_adapters :postgres do
-    before do
-      conn[:tasks].insert(id: 3, user_id: 2, title: "Joe's another task")
-    end
-
-    it 'restricts a relation using HAVING clause' do
-      expect(relation.having { count(id.qualified) >= 2 }.to_a).
-        to eq([{ id: 2, name: 'Joe', task_count: 2 }])
-    end
-  end
-end

data/spec/unit/relation/inner_join_spec.rb

@@ -1,158 +0,0 @@
-RSpec.describe ROM::Relation, '#inner_join' do
-  subject(:relation) { relations[:users] }
-
-  let(:puzzles) { relations[:puzzles] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'joins relations using inner join' do
-      relation.insert id: 3, name: 'Jade'
-
-      result = relation.
-                 inner_join(:tasks, user_id: :id).
-                 select(:name, tasks[:title])
-
-      expect(result.schema.map(&:name)).to eql(%i[name title])
-
-      expect(result.to_a).to eql([
-        { name: 'Jane', title: "Jane's task" },
-        { name: 'Joe', title: "Joe's task" }
-      ])
-    end
-
-    it 'allows specifying table_aliases' do
-      relation.insert id: 3, name: 'Jade'
-
-      result = relation.
-                 inner_join(:tasks, {user_id: :id}, table_alias: :t1).
-                 select(:name, tasks[:title])
-
-      expect(result.schema.map(&:name)).to eql(%i[name title])
-
-      expect(result.to_a).to eql([
-        { name: 'Jane', title: "Jane's task" },
-        { name: 'Joe', title: "Joe's task" }
-      ])
-    end
-
-    context 'with associations' do
-      before do
-        inferrable_relations.concat %i(puzzles)
-      end
-
-      before do
-        conn.create_table(:puzzles) do
-          primary_key :id
-          foreign_key :author_id, :users, null: false
-          column :text, String, null: false
-        end
-
-        conf.relation(:users) do
-          schema(infer: true) do
-            associations do
-              has_many :tasks
-              has_many :tasks, as: :todos, relation: :tasks
-            end
-          end
-        end
-
-        conf.relation(:task_tags) do
-          schema(infer: true) do
-            associations do
-              belongs_to :tasks
-              belongs_to :tags
-            end
-          end
-        end
-
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            associations do
-              belongs_to :user
-              has_many :task_tags
-              has_many :tags, through: :task_tags
-            end
-          end
-        end
-
-        conf.relation(:puzzles) do
-          schema(infer: true) do
-            associations do
-              belongs_to :users, as: :author
-            end
-          end
-        end
-
-        relation.insert id: 3, name: 'Jade'
-        puzzles.insert id: 1, author_id: 1, text: 'solved by Jane'
-      end
-
-      it 'joins relation with join keys inferred' do
-        result = relation.
-                   inner_join(tasks).
-                   select(:name, tasks[:title])
-
-        expect(result.schema.map(&:name)).to eql(%i[name title])
-
-        expect(result.to_a).to eql([
-                                     { name: 'Jane', title: "Jane's task" },
-                                     { name: 'Joe', title: "Joe's task" }
-                                   ])
-      end
-
-      let(:task_relation_proxy) { Class.new{ def name; ROM::Relation::Name.new(:tasks); end }.new }
-
-      it 'joins relation with relation proxy objects' do
-        result = relation.
-                   inner_join(task_relation_proxy).
-                   select(:name, tasks[:title])
-
-        expect(result.schema.map(&:name)).to eql(%i[name title])
-
-        expect(result.to_a).to eql([
-                                     { name: 'Jane', title: "Jane's task" },
-                                     { name: 'Joe', title: "Joe's task" }
-                                   ])
-      end
-
-      it 'joins relation with join keys inferred for m:m-through' do
-        result = tasks.inner_join(tags)
-
-        expect(result.to_a).to eql([{ id: 1, user_id: 2, title: "Joe's task" }])
-      end
-
-      it 'joins by association name if no condition provided' do
-        result = relation.
-                   inner_join(:tasks).
-                   select(:name, tasks[:title])
-
-        expect(result.schema.map(&:name)).to eql(%i[name title])
-
-        expect(result.to_a).to eql([
-                                     { name: 'Jane', title: "Jane's task" },
-                                     { name: 'Joe', title: "Joe's task" }
-                                   ])
-      end
-
-      it 'joins if association name differs from relation name' do
-        result = relation.
-                   inner_join(:todos).
-                   select(:name, tasks[:title])
-
-        expect(result.schema.map(&:name)).to eql(%i[name title])
-
-        expect(result.to_a).to eql([
-                                     { name: 'Jane', title: "Jane's task" },
-                                     { name: 'Joe', title: "Joe's task" }
-                                   ])
-      end
-
-      it 'joins by relation if association name differs from relation name' do
-        result = puzzles.inner_join(users).select(users[:name], puzzles[:text])
-
-        expect(result.to_a).to eql([ name: 'Jane', text: "solved by Jane" ])
-      end
-    end
-  end
-end

data/spec/unit/relation/inspect_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#inspect' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'includes dataset' do
-      expect(relation.inspect).to include('dataset')
-    end
-  end
-end

data/spec/unit/relation/instrument_spec.rb

@@ -1,45 +0,0 @@
-RSpec.describe ROM::SQL::Relation, '#instrument', :sqlite do
-  include_context 'users and tasks'
-
-  subject(:relation) do
-    relations[:users]
-  end
-
-  let(:notifications) do
-    spy(:notifications)
-  end
-
-  before do
-    conf.plugin(:sql, relations: :instrumentation) do |p|
-      p.notifications = notifications
-    end
-  end
-
-  it 'instruments relation materialization' do
-    users.to_a
-
-    expect(notifications).
-      to have_received(:instrument).with(:sql, name: :users, query: users.dataset.sql)
-  end
-
-  it 'instruments methods that return a single tuple' do
-    users.first
-
-    expect(notifications).
-      to have_received(:instrument).with(:sql, name: :users, query: users.limit(1).dataset.sql)
-
-    users.last
-
-    expect(notifications).
-      to have_received(:instrument).with(:sql, name: :users, query: users.reverse.limit(1).dataset.sql)
-  end
-
-  it 'instruments aggregation methods' do
-    pending "no idea how to make this work with sequel"
-
-    users.count
-
-    expect(notifications).
-      to have_received(:instrument).with(:sql, name: :users, query: 'SELECT COUNT(*) FROM users')
-  end
-end

data/spec/unit/relation/invert_spec.rb

@@ -1,11 +0,0 @@
-RSpec.describe ROM::Relation, '#invert' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'delegates to dataset and returns a new relation' do
-      expect(relation.where(name: 'Jane').invert.to_a).to eql([{ id: 2, name: 'Joe' }])
-    end
-  end
-end

data/spec/unit/relation/left_join_spec.rb

@@ -1,55 +0,0 @@
-RSpec.describe ROM::Relation, '#left_join' do
-  subject(:relation) { relations[:users] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'joins relations using left outer join' do
-      relation.insert id: 3, name: 'Jade'
-
-      result = relation.
-                 left_join(:tasks, user_id: :id).
-                 select(:name, tasks[:title])
-
-      expect(result.schema.map(&:name)).to eql(%i[name title])
-
-      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
-
-        relation.insert id: 3, name: 'Jade'
-      end
-
-      it 'joins relation with join keys inferred' do
-        result = relation.
-                   left_join(tasks).
-                   select(:name, tasks[:title])
-
-        expect(result.schema.map(&:name)).to eql(%i[name title])
-
-        expect(result.to_a).to eql([
-                                     { name: 'Jane', title: "Jane's task" },
-                                     { name: 'Joe', title: "Joe's task" },
-                                     { name: 'Jade', title: nil }
-                                   ])
-      end
-    end
-  end
-end