torque-postgresql 1.1.5 → 2.0.3

data/spec/tests/geometric_builder_spec.rb

@@ -0,0 +1,221 @@
+require 'spec_helper'
+
+RSpec.describe 'Geometries' do
+  context 'on build' do
+    let(:klass) do
+      klass = Class.new(Torque::PostgreSQL::GeometryBuilder)
+      klass.define_singleton_method(:name) { 'TestSample' }
+      klass.const_set('PIECES', %i[a b c d].freeze)
+      klass.const_set('FORMATION', '(%s, %s, <%s, {%s}>)'.freeze)
+      klass
+    end
+
+    let(:instance) { klass.new }
+
+    context '#type' do
+      it 'originally does not have the constant defined' do
+        expect(klass.constants).not_to include('TYPE')
+      end
+
+      it 'creates the type constant based on the name' do
+        expect(instance.type).to be_eql(:test_sample)
+        expect(klass.constants).to include(:TYPE)
+        expect(klass::TYPE).to be_eql(:test_sample)
+      end
+
+      it 'returns the constant value' do
+        klass.const_set('TYPE', 'another_type')
+        expect(instance.type).to be_eql('another_type')
+      end
+    end
+
+    context '#pieces' do
+      it 'returns the definition pieces' do
+        expect(instance.pieces).to be_eql([:a, :b, :c, :d])
+      end
+
+      it 'returns whatever is in the constant' do
+        klass.send(:remove_const, 'PIECES')
+        klass.const_set('PIECES', %i[a].freeze)
+        expect(instance.pieces).to be_eql([:a])
+      end
+    end
+
+    context '#formation' do
+      it 'returns the definition set' do
+        expect(instance.formation).to be_eql("(%s, %s, <%s, {%s}>)")
+      end
+
+      it 'returns whatever is in the constant' do
+        klass.send(:remove_const, 'FORMATION')
+        klass.const_set('FORMATION', '(<%s>)'.freeze)
+        expect(instance.formation).to be_eql("(<%s>)")
+      end
+    end
+
+    context '#cast' do
+      let(:config_class) { double }
+
+      before { allow(instance).to receive(:config_class).and_return(config_class) }
+
+      it 'accepts string values' do
+        expect(instance.cast('')).to be_nil
+
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(4)
+        expect(instance.cast('1, 2, 3, 4')).to be_eql(4)
+
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(8)
+        expect(instance.cast('(1, {2}, <3>, 4)')).to be_eql(8)
+
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(7)
+        expect(instance.cast('1, 2, 3, 4, 5, 6')).to be_eql(7)
+
+        expect(config_class).to receive(:new).with(1.0, 2.0, 3.0, 4.0).and_return(1)
+        expect(instance.cast('1.0, 2.0, 3.0, 4.0')).to be_eql(1)
+
+        expect { instance.cast(['6 6 6']) }.to raise_error(RuntimeError, 'Invalid format')
+      end
+
+      it 'accepts hash values' do
+        expect(instance.cast({})).to be_nil
+
+        expect { instance.cast({ 'a' => 1, 'b' => 2 }) }.to raise_error(RuntimeError, 'Invalid format')
+
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(4)
+        expect(instance.cast({ 'a' => 1, 'b' => 2 , 'c' => 3, 'd' => 4})).to be_eql(4)
+
+        expect(config_class).to receive(:new).with(1.0, 2.0, 3.0, 4.0).and_return(5)
+        expect(instance.cast({ 'a' => 1.0, 'b' => 2.0, 'c' => 3.0, 'd' => 4.0})).to be_eql(5)
+
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(2)
+        expect(instance.cast({ a: 1, b: 2 , c: 3, d: 4, e: 5, f: 6})).to be_eql(2)
+      end
+
+      it 'accepts array values' do
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(4)
+        expect(instance.cast([1, 2, 3, 4])).to be_eql(4)
+
+        expect(config_class).to receive(:new).with(1.1, 1.2, 1.3, 1.4).and_return(9)
+        expect(instance.cast(['1.1', '1.2', '1.3', '1.4'])).to be_eql(9)
+
+        expect(config_class).to receive(:new).with(6, 5, 4, 3).and_return(2)
+        expect(instance.cast([6, 5, 4, 3, 2, 1])).to be_eql(2)
+
+        expect(instance.cast([])).to be_nil
+
+        expect { instance.cast([6, 5, 4]) }.to raise_error(RuntimeError, 'Invalid format')
+      end
+    end
+
+    context '#serialize' do
+      before { allow(instance).to receive(:config_class).and_return(OpenStruct) }
+
+      it 'return value nil' do
+        expect(instance.serialize(nil)).to be_nil
+      end
+
+      it 'accepts config class' do
+        expect(instance.serialize(OpenStruct.new)).to be_nil
+        expect(instance.serialize(OpenStruct.new(a: 1, b: 2, c: 3, d: 4))).to be_eql('(1, 2, <3, {4}>)')
+        expect(instance.serialize(OpenStruct.new(a: 1, b: 2, c: 3, d: 4, e: 5))).to be_eql('(1, 2, <3, {4}>)')
+      end
+
+      it 'accepts hash value' do
+        expect { instance.cast({a: 1, b: 2, c: 3}) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(instance.serialize({a: 1, b: 2, c: 3, d: 4})).to be_eql('(1, 2, <3, {4}>)')
+        expect(instance.serialize({a: 1, b: 2, c: 3, d: 4, e: 5, f: 6})).to be_eql('(1, 2, <3, {4}>)')
+      end
+
+      it 'accepts array value' do
+        expect { instance.serialize([6, 5, 4]) }.to raise_error(RuntimeError, 'Invalid format')
+        expect(instance.serialize([1, 2, 3, 4])).to be_eql('(1, 2, <3, {4}>)')
+        expect(instance.serialize([5, 4, 3, 2, 1, 0])).to be_eql('(5, 4, <3, {2}>)')
+      end
+
+    end
+
+    context '#deserialize' do
+      let(:config_class) { double }
+
+      before { allow(instance).to receive(:config_class).and_return(config_class) }
+
+      it 'return value nil' do
+        expect(instance.deserialize(nil)).to be_nil
+      end
+
+      it 'accept correct format' do
+        expect(config_class).to receive(:new).with(1, 2, 3, 4).and_return(6)
+        expect(instance.deserialize('(1, 2, <3, {4}>)')).to be_eql(6)
+      end
+    end
+
+    context '#type_cast_for_schema' do
+      before { allow(instance).to receive(:config_class).and_return(OpenStruct) }
+
+      it 'returns the array for schema' do
+        result = instance.type_cast_for_schema(OpenStruct.new(a: 1, b: 2, c: 3, d: 4))
+        expect(result).to be_eql([1, 2, 3, 4])
+      end
+    end
+  end
+
+  context 'on box' do
+    let(:klass) { Torque::PostgreSQL::Adapter::OID::Box }
+    let(:value_klass) { Torque::PostgreSQL::Box }
+    let(:instance) { klass.new }
+    let(:value_instance) { instance.cast([1, 2, 3, 4]) }
+
+    before { allow(instance).to receive(:config_class).and_return(value_klass) }
+
+    it '#points' do
+      mock_klass = Struct.new(:a, :b)
+      Torque::PostgreSQL.config.geometry.point_class = mock_klass
+
+      result = value_instance.points
+      expect(result).to be_a(Array)
+      expect(result.size).to be_eql(4)
+      expect(result).to all(be_a(mock_klass))
+
+      expect(result[0].a).to be_eql(1.0)
+      expect(result[0].b).to be_eql(2.0)
+      expect(result[1].a).to be_eql(1.0)
+      expect(result[1].b).to be_eql(4.0)
+      expect(result[2].a).to be_eql(3.0)
+      expect(result[2].b).to be_eql(2.0)
+      expect(result[3].a).to be_eql(3.0)
+      expect(result[3].b).to be_eql(4.0)
+    end
+  end
+
+  context 'on circle' do
+    let(:klass) { Torque::PostgreSQL::Adapter::OID::Circle }
+    let(:value_klass) { Torque::PostgreSQL::Circle }
+    let(:instance) { klass.new }
+    let(:value_instance) { instance.cast([1, 2, 3]) }
+
+    before { allow(instance).to receive(:config_class).and_return(value_klass) }
+
+    it '#center' do
+      mock_klass = Struct.new(:a, :b)
+      Torque::PostgreSQL.config.geometry.point_class = mock_klass
+
+      result = value_instance.center
+      expect(result).to be_a(mock_klass)
+      expect(result.a).to be_eql(1.0)
+      expect(result.b).to be_eql(2.0)
+    end
+
+    it '#center=' do
+      mock_klass = Struct.new(:x, :y)
+      Torque::PostgreSQL.config.geometry.point_class = mock_klass
+
+      value_instance.center = [1, 2]
+      expect(value_instance.x).to be_eql(1)
+      expect(value_instance.y).to be_eql(2)
+
+      value_instance.center = mock_klass.new(3, 4)
+      expect(value_instance.x).to be_eql(3)
+      expect(value_instance.y).to be_eql(4)
+    end
+  end
+end

data/spec/tests/has_many_spec.rb

@@ -0,0 +1,400 @@
+require 'spec_helper'
+
+RSpec.describe 'HasMany' do
+  context 'on builder' do
+    let(:builder) { ActiveRecord::Associations::Builder::HasMany }
+
+    it 'adds the array option' do
+      expect(builder.send(:valid_options, [])).to include(:array)
+    end
+  end
+
+  context 'on original' do
+    let(:other) { Text }
+
+    before { User.has_many :texts }
+    subject { User.create(name: 'User 1') }
+    after { User._reflections = {} }
+
+    it 'has the method' do
+      expect(subject).to respond_to(:texts)
+      expect(subject._reflections).to include('texts')
+    end
+
+    it 'has correct foreign key' do
+      item = subject._reflections['texts']
+      expect(item.foreign_key).to be_eql('user_id')
+    end
+
+    it 'loads associated records' do
+      expect(subject.texts.to_sql).to match(Regexp.new(<<-SQL.squish))
+        SELECT "texts"\\.\\* FROM "texts" WHERE \\(?"texts"\\."user_id" = #{subject.id}\\)?
+      SQL
+
+      expect(subject.texts.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.texts.to_a).to be_eql([])
+    end
+
+    it 'can be marked as loaded' do
+      expect(subject.texts.loaded?).to be_eql(false)
+      expect(subject.texts).to respond_to(:load_target)
+      expect(subject.texts.load_target).to be_eql([])
+      expect(subject.texts.loaded?).to be_eql(true)
+    end
+
+    it 'can find specific records' do
+      records = FactoryBot.create_list(:text, 10, user_id: subject.id)
+      ids = records.map(&:id).sample(5)
+
+      expect(subject.texts).to respond_to(:find)
+      records = subject.texts.find(*ids)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can return last n records' do
+      records = FactoryBot.create_list(:text, 10, user_id: subject.id)
+      ids = records.map(&:id).last(5)
+
+      expect(subject.texts).to respond_to(:last)
+      records = subject.texts.last(5)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can return first n records' do
+      records = FactoryBot.create_list(:text, 10, user_id: subject.id)
+      ids = records.map(&:id).first(5)
+
+      expect(subject.texts).to respond_to(:take)
+      records = subject.texts.take(5)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can build an associated record' do
+      record = subject.texts.build(content: 'Test')
+      expect(record).to be_a(other)
+      expect(record).not_to be_persisted
+      expect(record.content).to be_eql('Test')
+      expect(record.user_id).to be_eql(subject.id)
+
+      expect(subject.save).to be_truthy
+      expect(subject.texts.size).to be_eql(1)
+    end
+
+    it 'can create an associated record' do
+      record = subject.texts.create(content: 'Test')
+      expect(subject.texts).to respond_to(:create!)
+
+      expect(record).to be_a(other)
+      expect(record).to be_persisted
+      expect(record.content).to be_eql('Test')
+      expect(record.user_id).to be_eql(subject.id)
+    end
+
+    it 'can concat records' do
+      FactoryBot.create(:text, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(1)
+
+      subject.texts.concat(other.new(content: 'Test'))
+      expect(subject.texts.size).to be_eql(2)
+      expect(subject.texts.last.content).to be_eql('Test')
+    end
+
+    it 'can replace records' do
+      FactoryBot.create(:text, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(1)
+
+      subject.texts.replace([other.new(content: 'Test 1'), other.new(content: 'Test 2')])
+      expect(subject.texts.size).to be_eql(2)
+      expect(subject.texts[0].content).to be_eql('Test 1')
+      expect(subject.texts[1].content).to be_eql('Test 2')
+    end
+
+    it 'can delete all records' do
+      FactoryBot.create_list(:text, 5, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(5)
+
+      subject.texts.delete_all
+      expect(subject.texts.size).to be_eql(0)
+    end
+
+    it 'can destroy all records' do
+      FactoryBot.create_list(:text, 5, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(5)
+
+      subject.texts.destroy_all
+      expect(subject.texts.size).to be_eql(0)
+    end
+
+    it 'can have sum operations' do
+      result = FactoryBot.create_list(:text, 5, user_id: subject.id).map(&:id).reduce(:+)
+      expect(subject.texts).to respond_to(:sum)
+      expect(subject.texts.sum(:id)).to be_eql(result)
+    end
+
+    it 'can have a pluck operation' do
+      result = FactoryBot.create_list(:text, 5, user_id: subject.id).map(&:content).sort
+      expect(subject.texts).to respond_to(:pluck)
+      expect(subject.texts.pluck(:content).sort).to be_eql(result)
+    end
+
+    it 'can be markes as empty' do
+      expect(subject.texts).to respond_to(:empty?)
+      expect(subject.texts.empty?).to be_truthy
+
+      FactoryBot.create(:text, user_id: subject.id)
+      expect(subject.texts.empty?).to be_falsey
+    end
+
+    it 'can check if a record is included on the list' do
+      inside = FactoryBot.create(:text, user_id: subject.id)
+      outside = FactoryBot.create(:text)
+
+      expect(subject.texts).to respond_to(:include?)
+      expect(subject.texts.include?(inside)).to be_truthy
+      expect(subject.texts.include?(outside)).to be_falsey
+    end
+
+    it 'can append records' do
+      FactoryBot.create(:text, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(1)
+
+      subject.texts << other.new(content: 'Test')
+      expect(subject.texts.size).to be_eql(2)
+      expect(subject.texts.last.content).to be_eql('Test')
+    end
+
+    it 'can clear records' do
+      FactoryBot.create(:text, user_id: subject.id)
+      expect(subject.texts.size).to be_eql(1)
+
+      subject.texts.clear
+      expect(subject.texts.size).to be_eql(0)
+    end
+
+    it 'can reload records' do
+      expect(subject.texts.size).to be_eql(0)
+      FactoryBot.create(:text, user_id: subject.id)
+
+      expect(subject.texts.size).to be_eql(0)
+
+      subject.texts.reload
+      expect(subject.texts.size).to be_eql(1)
+    end
+
+    it 'can preload records' do
+      FactoryBot.create_list(:text, 5, user_id: subject.id)
+      entries = User.all.includes(:texts).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.texts).to be_loaded
+      expect(entries.first.texts.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = User.all.joins(:texts)
+      expect(query.to_sql).to match(/INNER JOIN "texts"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
+
+  context 'on array' do
+    let(:other) { Video }
+
+    before { Tag.has_many :videos, array: true }
+    subject { Tag.create(name: 'A') }
+    after { Tag._reflections = {} }
+
+    it 'has the method' do
+      expect(subject).to respond_to(:videos)
+      expect(subject._reflections).to include('videos')
+    end
+
+    it 'has correct foreign key' do
+      item = subject._reflections['videos']
+      expect(item.foreign_key).to be_eql('tag_ids')
+    end
+
+    it 'loads associated records' do
+      expect(subject.videos.to_sql).to match(Regexp.new(<<-SQL.squish))
+        SELECT "videos"\\.\\* FROM "videos"
+        WHERE \\(?"videos"\\."tag_ids" && ARRAY\\[#{subject.id}\\]::bigint\\[\\]\\)?
+      SQL
+
+      expect(subject.videos.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.videos.to_a).to be_eql([])
+    end
+
+    it 'can be marked as loaded' do
+      expect(subject.videos.loaded?).to be_eql(false)
+      expect(subject.videos).to respond_to(:load_target)
+      expect(subject.videos.load_target).to be_eql([])
+      expect(subject.videos.loaded?).to be_eql(true)
+    end
+
+    it 'can find specific records' do
+      records = FactoryBot.create_list(:video, 10, tag_ids: [subject.id])
+      ids = records.map(&:id).sample(5)
+
+      expect(subject.videos).to respond_to(:find)
+      records = subject.videos.find(*ids)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can return last n records' do
+      records = FactoryBot.create_list(:video, 10, tag_ids: [subject.id])
+      ids = records.map(&:id).last(5)
+
+      expect(subject.videos).to respond_to(:last)
+      records = subject.videos.last(5)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can return first n records' do
+      records = FactoryBot.create_list(:video, 10, tag_ids: [subject.id])
+      ids = records.map(&:id).first(5)
+
+      expect(subject.videos).to respond_to(:take)
+      records = subject.videos.take(5)
+
+      expect(records.size).to be_eql(5)
+      expect(records.map(&:id).sort).to be_eql(ids.sort)
+    end
+
+    it 'can build an associated record' do
+      record = subject.videos.build(title: 'Test')
+      expect(record).to be_a(other)
+      expect(record).not_to be_persisted
+      expect(record.title).to be_eql('Test')
+
+      expect(subject.save).to be_truthy
+      expect(record.tag_ids).to be_eql([subject.id])
+      expect(subject.videos.size).to be_eql(1)
+    end
+
+    it 'can create an associated record' do
+      record = subject.videos.create(title: 'Test')
+      expect(subject.videos).to respond_to(:create!)
+
+      expect(record).to be_a(other)
+      expect(record).to be_persisted
+      expect(record.title).to be_eql('Test')
+      expect(record.tag_ids).to be_eql([subject.id])
+    end
+
+    it 'can concat records' do
+      FactoryBot.create(:video, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(1)
+
+      subject.videos.concat(other.new(title: 'Test'))
+      expect(subject.videos.size).to be_eql(2)
+      expect(subject.videos.last.title).to be_eql('Test')
+    end
+
+    it 'can replace records' do
+      FactoryBot.create(:video, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(1)
+
+      subject.videos.replace([other.new(title: 'Test 1'), other.new(title: 'Test 2')])
+      expect(subject.videos.size).to be_eql(2)
+      expect(subject.videos[0].title).to be_eql('Test 1')
+      expect(subject.videos[1].title).to be_eql('Test 2')
+    end
+
+    it 'can delete all records' do
+      FactoryBot.create_list(:video, 5, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(5)
+
+      subject.videos.delete_all
+      expect(subject.videos.size).to be_eql(0)
+    end
+
+    it 'can destroy all records' do
+      FactoryBot.create_list(:video, 5, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(5)
+
+      subject.videos.destroy_all
+      expect(subject.videos.size).to be_eql(0)
+    end
+
+    it 'can have sum operations' do
+      result = FactoryBot.create_list(:video, 5, tag_ids: [subject.id]).map(&:id).reduce(:+)
+      expect(subject.videos).to respond_to(:sum)
+      expect(subject.videos.sum(:id)).to be_eql(result)
+    end
+
+    it 'can have a pluck operation' do
+      result = FactoryBot.create_list(:video, 5, tag_ids: [subject.id]).map(&:title).sort
+      expect(subject.videos).to respond_to(:pluck)
+      expect(subject.videos.pluck(:title).sort).to be_eql(result)
+    end
+
+    it 'can be markes as empty' do
+      expect(subject.videos).to respond_to(:empty?)
+      expect(subject.videos.empty?).to be_truthy
+
+      FactoryBot.create(:video, tag_ids: [subject.id])
+      expect(subject.videos.empty?).to be_falsey
+    end
+
+    it 'can check if a record is included on the list' do
+      inside = FactoryBot.create(:video, tag_ids: [subject.id])
+      outside = FactoryBot.create(:video)
+
+      expect(subject.videos).to respond_to(:include?)
+      expect(subject.videos.include?(inside)).to be_truthy
+      expect(subject.videos.include?(outside)).to be_falsey
+    end
+
+    it 'can append records' do
+      FactoryBot.create(:video, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(1)
+
+      subject.videos << other.new(title: 'Test')
+      expect(subject.videos.size).to be_eql(2)
+      expect(subject.videos.last.title).to be_eql('Test')
+    end
+
+    it 'can clear records' do
+      FactoryBot.create(:video, tag_ids: [subject.id])
+      expect(subject.videos.size).to be_eql(1)
+
+      subject.videos.clear
+      expect(subject.videos.size).to be_eql(0)
+    end
+
+    it 'can reload records' do
+      expect(subject.videos.size).to be_eql(0)
+      FactoryBot.create(:video, tag_ids: [subject.id])
+
+      expect(subject.videos.size).to be_eql(0)
+
+      subject.videos.reload
+      expect(subject.videos.size).to be_eql(1)
+    end
+
+    it 'can preload records' do
+      FactoryBot.create_list(:video, 5, tag_ids: [subject.id])
+      entries = Tag.all.includes(:videos).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.videos).to be_loaded
+      expect(entries.first.videos.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = Tag.all.joins(:videos)
+      expect(query.to_sql).to match(/INNER JOIN "videos"/)
+      expect { query.load }.not_to raise_error
+    end
+  end
+end