rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/spec/unit/relation/select_append_spec.rb

@@ -1,21 +0,0 @@
-RSpec.describe ROM::Relation, '#select_append' do
-  subject(:relation) { relations[:tasks] }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    it 'appends new columns' do
-      selected = relation.select(:id).select_append(:title)
-
-      expect(selected.schema.map(&:name)).to eql(%i[id title])
-      expect(selected.first).to eql(id: 1, title: "Joe's task")
-    end
-
-    it 'supports blocks' do
-      selected = relation.select(:id).select_append { string::upper(title).as(:title) }
-
-      expect(selected.schema.map(&:name)).to eql(%i[id title])
-      expect(selected.first).to eql(id: 1, title: "JOE'S TASK")
-    end
-  end
-end

data/spec/unit/relation/select_spec.rb

@@ -1,40 +0,0 @@
-RSpec.describe ROM::Relation, '#select' do
-  subject(:relation) { container.relations.tasks }
-
-  include_context 'users and tasks'
-
-  before do
-    conf.relation(:tasks) { schema(infer: true) }
-  end
-
-  with_adapters do
-    it 'projects a relation using a list of symbols' do
-      expect(relation.select(:id, :title).to_a)
-        .to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task"}])
-    end
-
-    it 'projects a relation using a schema' do
-      expect(relation.select(*relation.schema.project(:id, :title)).to_a)
-        .to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task"}])
-    end
-
-    it 'maintains schema' do
-      expect(relation.select(:id, :title).schema.map(&:name)).to eql(%i[id title])
-    end
-
-    it 'supports args and blocks' do
-      expect(relation.select(:id) { [title] }.schema.map(&:name)).to eql(%i[id title])
-    end
-
-    it 'supports blocks' do
-      expect(relation.select { [id, title] }.schema.map(&:name)).to eql(%i[id title])
-    end
-
-    it 'supports selecting literal strings' do
-      new_rel = relation.select { `'event'`.as(:type) }
-
-      expect(new_rel.schema[:type].primitive).to be(String)
-      expect(new_rel.first).to eql(type: 'event')
-    end
-  end
-end

data/spec/unit/relation/sum_spec.rb

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

data/spec/unit/relation/union_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe ROM::Relation, '#union' do
-  subject(:relation) { container.relations.users }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    let(:relation1) { relation.where(id: 1).select(:id, :name) }
-    let(:relation2) { relation.where(id: 2).select(:id, :name) }
-
-    it 'unions two relations and returns a new relation' do
-      result = relation1.union(relation2)
-
-      expect(result.to_a).to match_array([
-        { id: 1, name: 'Jane' },
-        { id: 2, name: 'Joe' }
-      ])
-    end
-  end
-end

data/spec/unit/relation/unique_predicate_spec.rb

@@ -1,18 +0,0 @@
-RSpec.describe ROM::Relation, '#unique?' do
-  subject(:relation) { container.relations.tasks }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    before { relation.delete }
-
-    it 'returns true when there is only one tuple matching criteria' do
-      expect(relation.unique?(title: 'Task One')).to be(true)
-    end
-
-    it 'returns true when there are more than one tuple matching criteria' do
-      relation.insert(title: 'Task One')
-      expect(relation.unique?(title: 'Task One')).to be(false)
-    end
-  end
-end

data/spec/unit/relation/where_spec.rb

@@ -1,133 +0,0 @@
-RSpec.describe ROM::Relation, '#where' do
-  subject(:relation) { relations[:tasks].select(:id, :title) }
-
-  include_context 'users and tasks'
-
-  with_adapters do
-    context 'without :read types' do
-      it 'restricts relation using provided conditions' do
-        expect(relation.where(id: 1).to_a).
-          to eql([{ id: 1, title: "Joe's task" }])
-      end
-
-      it 'restricts relation using provided conditions and block' do
-        expect(relation.where(id: 1) { title.like("%Jane%") }.to_a).to be_empty
-      end
-
-      it 'restricts relation using provided conditions in a block' do
-        expect(relation.where { (id > 2) & title.like("%Jane%") }.to_a).to be_empty
-      end
-
-      it 'restricts relation using canonical attributes' do
-        expect(relation.rename(id: :user_id).where { id > 3 }.to_a).to be_empty
-      end
-
-      it 'restricts with or condition' do
-        expect(relation.where { id.is(1) | id.is(2) }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-      end
-
-      it 'restricts with a range condition' do
-        expect(relation.where { id.in(-1...2) }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }])
-
-        expect(relation.where { id.in(0...3) }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-      end
-
-      it 'restricts with an inclusive range' do
-        expect(relation.where { id.in(0..2) }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }, { id: 2, title: "Jane's task" }])
-      end
-
-      it 'restricts with an ordinary enum' do
-        expect(relation.where { id.in(2, 3) }.to_a).
-          to eql([{ id: 2, title: "Jane's task" }])
-      end
-
-      it 'restricts with enum using self syntax' do
-        expect(relation.where(relation[:id].in(2, 3)).to_a).
-          to eql([{ id: 2, title: "Jane's task" }])
-      end
-
-      context 'using underscored symbols for qualifying' do
-        before { Sequel.split_symbols = true }
-        after { Sequel.split_symbols = false }
-
-        it 'queries with a qualified name' do
-          expect(relation.where(tasks__id: 1).to_a).
-            to eql([{ id: 1, title: "Joe's task" }])
-        end
-      end
-
-      it 'restricts with a function' do
-        expect(relation.where { string::lower(title).is("joe's task") }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }])
-      end
-
-      it 'restricts with a function using LIKE' do
-        expect(relation.where { string::lower(title).like("joe%") }.to_a).
-          to eql([{ id: 1, title: "Joe's task" }])
-      end
-    end
-
-    context 'with :read types' do
-      before do
-        conf.relation(:tasks) do
-          schema(infer: true) do
-            attribute :id, ROM::SQL::Types::Serial.constructor(&:to_i)
-            attribute :title, ROM::SQL::Types::Coercible::String
-          end
-        end
-
-        module Test
-          Id = Struct.new(:v) do
-            def to_i
-              v.to_i
-            end
-          end
-
-          Title = Struct.new(:v) do
-            def to_s
-              v.to_s
-            end
-          end
-        end
-      end
-
-      it 'applies write_schema to hash conditions' do
-        rel = tasks.where(id: Test::Id.new('2'), title: Test::Title.new(:"Jane's task"))
-
-        expect(rel.first).
-          to eql(id: 2, user_id: 1, title: "Jane's task")
-      end
-
-      it 'applies write_schema to hash conditions where value is an array' do
-        ids = %w(1 2).map(&Test::Id.method(:new))
-        rel = tasks.where(id: ids)
-
-        expect(rel.to_a).
-          to eql([
-                   { id: 1, user_id: 2, title: "Joe's task" },
-                   { id: 2, user_id: 1, title: "Jane's task" }
-                 ])
-      end
-
-      it 'applies write_schema to conditions with operators other than equality' do
-        rel = tasks.where { id >= Test::Id.new('2') }
-
-        expect(rel.first).
-          to eql(id: 2, user_id: 1, title: "Jane's task")
-      end
-
-      it 'applies write_schema to conditions in a block' do
-        rel = tasks.where {
-          id.is(Test::Id.new('2')) & title.is(Test::Title.new(:"Jane's task"))
-        }
-
-        expect(rel.first).
-          to eql(id: 2, user_id: 1, title: "Jane's task")
-      end
-    end
-  end
-end

data/spec/unit/restriction_dsl_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe ROM::SQL::RestrictionDSL, :sqlite, helpers: true do
-  include_context 'database setup'
-
-  subject(:dsl) do
-    ROM::SQL::RestrictionDSL.new(schema)
-  end
-
-  let(:schema) do
-    define_schema(:users, id: ROM::SQL::Types::Serial, name: ROM::SQL::Types::String)
-  end
-
-  let(:ds) do
-    conn[:users]
-  end
-
-  describe '#call' do
-    it 'evaluates the block and returns an SQL expression' do
-      expect(conn[:users].literal(dsl.call { count(id) >= 3 })).to eql('(count(`id`) >= 3)')
-    end
-  end
-
-  describe '#method_missing' do
-    it 'responds to methods matching attribute names' do
-      expect(dsl.id.name).to be(:id)
-      expect(dsl.name.name).to be(:name)
-    end
-
-    it 'delegates to sequel virtual row' do
-      expect(conn[:users].literal(dsl.count(dsl.id))).to eql('count(`id`)')
-    end
-  end
-end

data/spec/unit/schema_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe ROM::SQL::Schema, :postgres do
-  describe '#primary_key' do
-    it 'returns primary key attributes' do
-      schema_proc = Class.new(ROM::Relation[:sql]).schema do
-        attribute :id, ROM::SQL::Types::Serial
-      end
-
-      schema = schema_proc.call
-      schema.finalize_attributes!.finalize!
-
-      expect(schema.primary_key).to eql([schema[:id]])
-    end
-
-    it 'returns empty array when there is no PK defined' do
-      schema_proc = Class.new(ROM::Relation[:sql]).schema do
-        attribute :id, ROM::SQL::Types::Int
-      end
-
-      schema = schema_proc.call
-      schema.finalize_attributes!.finalize!
-
-      expect(schema.primary_key).to eql([])
-    end
-  end
-end

data/spec/unit/types_spec.rb

@@ -1,65 +0,0 @@
-require 'rom/sql/types'
-
-RSpec.describe ROM::SQL::Types, :postgres do
-  describe ROM::SQL::Types::Blob do
-    it 'coerces strings to Sequel::SQL::Blob' do
-      input = 'sutin'
-      output = described_class[input]
-
-      expect(output).to be_instance_of(Sequel::SQL::Blob)
-      expect(output).to eql('sutin')
-    end
-  end
-
-  describe '#sql_literal', helpers: true do
-    subject(:base) { define_attribute(:age, :Int, source: ROM::Relation::Name.new(:users)) }
-
-    include_context 'database setup'
-
-    let(:ds) { container.gateways[:default][:users] }
-    let(:sql_literal) { type.sql_literal(ds) }
-
-    context 'when qualified' do
-      subject(:type) { base.qualified }
-
-      specify do
-        expect(sql_literal).to eql(%("users"."age"))
-      end
-    end
-
-    context 'when aliased' do
-      subject(:type) { base.as(:user_age) }
-
-      specify do
-        expect(sql_literal).to eql(%("age" AS "user_age"))
-      end
-    end
-
-    context 'when qualified and aliased' do
-      subject(:type) { base.qualified.as(:user_age) }
-
-      specify do
-        expect(sql_literal).to eql(%("users"."age" AS "user_age"))
-      end
-    end
-
-    context 'when aliased and qualified' do
-      subject(:type) { base.as(:user_age).qualified }
-
-      specify do
-        expect(sql_literal).to eql(%("users"."age" AS "user_age"))
-      end
-    end
-
-    context 'when qualified with a function expr' do
-      subject(:type) { base.meta(sql_expr: func).qualified }
-
-      let(:func) { Sequel::SQL::Function.new(:count, :age) }
-
-      specify do
-        expect { sql_literal }.
-          to raise_error(ROM::SQL::Attribute::QualifyError, "can't qualify :age (#{func.inspect})")
-      end
-    end
-  end
-end