torque-postgresql 1.1.1 → 2.0.1

data/spec/tests/belongs_to_many_spec.rb

@@ -0,0 +1,240 @@
+require 'spec_helper'
+
+RSpec.describe 'BelongsToMany' do
+  context 'on model' do
+    let(:model) { Video }
+    let(:builder) { Torque::PostgreSQL::Associations::Builder::BelongsToMany }
+    let(:reflection) { Torque::PostgreSQL::Reflection::BelongsToManyReflection }
+    after { model._reflections = {} }
+
+    it 'has the builder method' do
+      expect(model).to respond_to(:belongs_to_many)
+    end
+
+    it 'triggers the correct builder and relation' do
+      expect(builder).to receive(:build).with(anything, :tests, nil, {}) do |_, name, _, _|
+        ActiveRecord::Reflection.create(:belongs_to_many, name, nil, {}, model)
+      end
+
+      expect(reflection).to receive(:new).with(:tests, nil, {}, model)
+
+      model.belongs_to_many(:tests)
+    end
+  end
+
+  context 'on association' do
+    let(:other) { Tag }
+    let(:initial) { FactoryBot.create(:tag) }
+
+    before { Video.belongs_to_many :tags }
+    subject { Video.create(title: 'A') }
+    after { Video._reflections = {} }
+
+    it 'has the method' do
+      expect(subject).to respond_to(:tags)
+      expect(subject._reflections).to include('tags')
+    end
+
+    it 'loads associated records' do
+      subject.update(tag_ids: [initial.id])
+      expect(subject.tags.to_sql).to be_eql(<<-SQL.squish)
+        SELECT "tags".* FROM "tags" WHERE "tags"."id" IN (#{initial.id})
+      SQL
+
+      expect(subject.tags.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.tags.to_a).to be_eql([initial])
+    end
+
+    it 'can be marked as loaded' do
+      expect(subject.tags.loaded?).to be_eql(false)
+      expect(subject.tags).to respond_to(:load_target)
+      expect(subject.tags.load_target).to be_eql([])
+      expect(subject.tags.loaded?).to be_eql(true)
+    end
+
+    it 'can find specific records' do
+      records = FactoryBot.create_list(:tag, 10)
+      subject.update(tag_ids: records.map(&:id))
+      ids = records.map(&:id).sample(5)
+
+      expect(subject.tags).to respond_to(:find)
+      records = subject.tags.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(:tag, 10)
+      subject.update(tag_ids: records.map(&:id))
+      ids = records.map(&:id).last(5)
+
+      expect(subject.tags).to respond_to(:last)
+      records = subject.tags.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(:tag, 10)
+      subject.update(tag_ids: records.map(&:id))
+      ids = records.map(&:id).first(5)
+
+      expect(subject.tags).to respond_to(:take)
+      records = subject.tags.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.tags.build(name: 'Test')
+      expect(record).to be_a(other)
+      expect(record).not_to be_persisted
+      expect(record.name).to be_eql('Test')
+
+      expect(subject.save).to be_truthy
+      expect(subject.tag_ids).to be_eql([record.id])
+      expect(subject.tags.size).to be_eql(1)
+    end
+
+    it 'can create an associated record' do
+      record = subject.tags.create(name: 'Test')
+      expect(subject.tags).to respond_to(:create!)
+
+      expect(record).to be_a(other)
+      expect(record).to be_persisted
+      expect(record.name).to be_eql('Test')
+      expect(subject.tag_ids).to be_eql([record.id])
+    end
+
+    it 'can concat records' do
+      record = FactoryBot.create(:tag)
+      subject.update(tag_ids: [record.id])
+      expect(subject.tags.size).to be_eql(1)
+
+      subject.tags.concat(other.new(name: 'Test'))
+      subject.tags.reload
+      expect(subject.tags.size).to be_eql(2)
+      expect(subject.tag_ids.size).to be_eql(2)
+      expect(subject.tags.last.name).to be_eql('Test')
+    end
+
+    it 'can replace records' do
+      subject.tags << FactoryBot.create(:tag)
+      expect(subject.tags.size).to be_eql(1)
+
+      subject.tags.replace([other.new(name: 'Test 1'), other.new(name: 'Test 2')])
+      expect(subject.tags.size).to be_eql(2)
+      expect(subject.tags[0].name).to be_eql('Test 1')
+      expect(subject.tags[1].name).to be_eql('Test 2')
+    end
+
+    it 'can delete all records' do
+      subject.tags.concat(FactoryBot.create_list(:tag, 5))
+      expect(subject.tags.size).to be_eql(5)
+
+      subject.tags.delete_all
+      expect(subject.tags.size).to be_eql(0)
+    end
+
+    it 'can destroy all records' do
+      subject.tags.concat(FactoryBot.create_list(:tag, 5))
+      expect(subject.tags.size).to be_eql(5)
+
+      subject.tags.destroy_all
+      expect(subject.tags.size).to be_eql(0)
+    end
+
+    it 'can have sum operations' do
+      records = FactoryBot.create_list(:tag, 5)
+      subject.tags.concat(records)
+
+      result = records.map(&:id).reduce(:+)
+      expect(subject.tags).to respond_to(:sum)
+      expect(subject.tags.sum(:id)).to be_eql(result)
+    end
+
+    it 'can have a pluck operation' do
+      records = FactoryBot.create_list(:tag, 5)
+      subject.tags.concat(records)
+
+      result = records.map(&:name).sort
+      expect(subject.tags).to respond_to(:pluck)
+      expect(subject.tags.pluck(:name).sort).to be_eql(result)
+    end
+
+    it 'can be markes as empty' do
+      expect(subject.tags).to respond_to(:empty?)
+      expect(subject.tags.empty?).to be_truthy
+
+      subject.tags << FactoryBot.create(:tag)
+      expect(subject.tags.empty?).to be_falsey
+    end
+
+    it 'can check if a record is included on the list' do
+      outside = FactoryBot.create(:tag)
+      inside = FactoryBot.create(:tag)
+      subject.tags << inside
+
+      expect(subject.tags).to respond_to(:include?)
+      expect(subject.tags.include?(inside)).to be_truthy
+      expect(subject.tags.include?(outside)).to be_falsey
+    end
+
+    it 'can append records' do
+      subject.tags << other.new(name: 'Test 1')
+      expect(subject.tags.size).to be_eql(1)
+
+      subject.tags << other.new(name: 'Test 2')
+      expect(subject.tags.size).to be_eql(2)
+      expect(subject.tags.last.name).to be_eql('Test 2')
+    end
+
+    it 'can clear records' do
+      subject.tags << FactoryBot.create(:tag)
+      expect(subject.tags.size).to be_eql(1)
+
+      subject.tags.clear
+      expect(subject.tags.size).to be_eql(0)
+    end
+
+    it 'can reload records' do
+      expect(subject.tags.size).to be_eql(0)
+      subject.tags << FactoryBot.create(:tag)
+
+      subject.tags.reload
+      expect(subject.tags.size).to be_eql(1)
+    end
+
+    it 'can preload records' do
+      records = FactoryBot.create_list(:tag, 5)
+      subject.tags.concat(records)
+
+      entries = Video.all.includes(:tags).load
+
+      expect(entries.size).to be_eql(1)
+      expect(entries.first.tags).to be_loaded
+      expect(entries.first.tags.size).to be_eql(5)
+    end
+
+    it 'can joins records' do
+      query = Video.all.joins(:tags)
+      expect(query.to_sql).to match(/INNER JOIN "tags"/)
+      expect { query.load }.not_to raise_error
+    end
+
+    context "When record is not persisted" do
+      let(:initial) { FactoryBot.create(:tag) }
+      before { Video.belongs_to_many :tags }
+      subject { Video.new(title: 'A', tags: [initial]) }
+      after { Video._reflections = {} }
+
+      it 'loads associated records' do
+        expect(subject.tags.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+        expect(subject.tags.to_a).to be_eql([initial])
+      end
+    end
+  end
+end

data/spec/tests/coder_spec.rb

@@ -0,0 +1,367 @@
+require 'spec_helper'
+
+RSpec.describe 'Complex coder', type: :helper do
+  let(:coder) { Torque::PostgreSQL::Coder }
+
+  context 'on decode' do
+
+    context 'one dimensional arrays' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[{}])).to eql []
+      end
+
+      it 'returns an array of strings' do
+        expect(coder.decode(%[{1,2,3}])).to eql ['1','2','3']
+      end
+
+      it 'returns an array of strings, with nils replacing NULL characters' do
+        expect(coder.decode(%[{1,,NULL}])).to eql ['1',nil,nil]
+      end
+
+      it 'returns an array with the word NULL' do
+        expect(coder.decode(%[{1,"NULL",3}])).to eql ['1','NULL','3']
+      end
+
+      it 'returns an array of strings when containing commas in a quoted string' do
+        expect(coder.decode(%[{1,"2,3",4}])).to eql ['1','2,3','4']
+      end
+
+      it 'returns an array of strings when containing an escaped quote' do
+        expect(coder.decode(%[{1,"2\\",3",4}])).to eql ['1','2",3','4']
+      end
+
+      it 'returns an array of strings when containing an escaped backslash' do
+        expect(coder.decode(%[{1,"2\\\\",3,4}])).to eql ['1','2\\','3','4']
+        expect(coder.decode(%[{1,"2\\\\\\",3",4}])).to eql ['1','2\\",3','4']
+      end
+
+      it 'returns an array containing empty strings' do
+        expect(coder.decode(%[{1,"",3,""}])).to eql ['1', '', '3', '']
+      end
+
+      it 'returns an array containing unicode strings' do
+        expect(coder.decode(%[{"Paragraph 399(b)(i) – “valid leave” – meaning"}])).to eq(['Paragraph 399(b)(i) – “valid leave” – meaning'])
+      end
+    end
+
+    context 'two dimensional arrays' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[{{}}])).to eql [[]]
+        expect(coder.decode(%[{{},{}}])).to eql [[],[]]
+      end
+
+      it 'returns an array of strings with a sub array' do
+        expect(coder.decode(%[{1,{2,3},4}])).to eql ['1',['2','3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array' do
+        expect(coder.decode(%[{1,{"2,3"},4}])).to eql ['1',['2,3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted }' do
+        expect(coder.decode(%[{1,{"2,}3",,NULL},4}])).to eql ['1',['2,}3',nil,nil],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted {' do
+        expect(coder.decode(%[{1,{"2,{3"},4}])).to eql ['1',['2,{3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted { and escaped quote' do
+        expect(coder.decode(%[{1,{"2\\",{3"},4}])).to eql ['1',['2",{3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array with empty strings' do
+        expect(coder.decode(%[{1,{""},4,{""}}])).to eql ['1',[''],'4',['']]
+      end
+    end
+
+    context 'three dimensional arrays' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[{{{}}}])).to eql [[[]]]
+        expect(coder.decode(%[{{{},{}},{{},{}}}])).to eql [[[],[]],[[],[]]]
+      end
+
+      it 'returns an array of strings with sub arrays' do
+        expect(coder.decode(%[{1,{2,{3,4}},{NULL,,6},7}])).to eql ['1',['2',['3','4']],[nil,nil,'6'],'7']
+      end
+    end
+
+    context 'record syntax' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[()])).to eql []
+      end
+
+      it 'returns an array of strings' do
+        expect(coder.decode(%[(1,2,3)])).to eql ['1','2','3']
+      end
+
+      it 'returns an array of strings, with nils replacing NULL characters' do
+        expect(coder.decode(%[(1,,NULL)])).to eql ['1',nil,nil]
+      end
+
+      it 'returns an array with the word NULL' do
+        expect(coder.decode(%[(1,"NULL",3)])).to eql ['1','NULL','3']
+      end
+
+      it 'returns an array of strings when containing commas in a quoted string' do
+        expect(coder.decode(%[(1,"2,3",4)])).to eql ['1','2,3','4']
+      end
+
+      it 'returns an array of strings when containing an escaped quote' do
+        expect(coder.decode(%[(1,"2\\",3",4)])).to eql ['1','2",3','4']
+      end
+
+      it 'returns an array of strings when containing an escaped backslash' do
+        expect(coder.decode(%[(1,"2\\\\",3,4)])).to eql ['1','2\\','3','4']
+        expect(coder.decode(%[(1,"2\\\\\\",3",4)])).to eql ['1','2\\",3','4']
+      end
+
+      it 'returns an array containing empty strings' do
+        expect(coder.decode(%[(1,"",3,"")])).to eql ['1', '', '3', '']
+      end
+
+      it 'returns an array containing unicode strings' do
+        expect(coder.decode(%[("Paragraph 399(b)(i) – “valid leave” – meaning")])).to eq(['Paragraph 399(b)(i) – “valid leave” – meaning'])
+      end
+    end
+
+    context 'array of records' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[{()}])).to eql [[]]
+        expect(coder.decode(%[{(),()}])).to eql [[],[]]
+      end
+
+      it 'returns an array of strings with a sub array' do
+        expect(coder.decode(%[{1,(2,3),4}])).to eql ['1',['2','3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array' do
+        expect(coder.decode(%[{1,("2,3"),4}])).to eql ['1',['2,3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted }' do
+        expect(coder.decode(%[{1,("2,}3",,NULL),4}])).to eql ['1',['2,}3',nil,nil],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted {' do
+        expect(coder.decode(%[{1,("2,{3"),4}])).to eql ['1',['2,{3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array and a quoted { and escaped quote' do
+        expect(coder.decode(%[{1,("2\\",{3"),4}])).to eql ['1',['2",{3'],'4']
+      end
+
+      it 'returns an array of strings with a sub array with empty strings' do
+        expect(coder.decode(%[{1,(""),4,("")}])).to eql ['1',[''],'4',['']]
+      end
+    end
+
+    context 'mix of record and array' do
+      it 'returns an empty array' do
+        expect(coder.decode(%[({()})])).to eql [[[]]]
+        expect(coder.decode(%[{({},{}),{(),{}}}])).to eql [[[],[]],[[],[]]]
+      end
+
+      it 'returns an array of strings with sub arrays' do
+        expect(coder.decode(%[{1,(2,{3,4}),(NULL,,6),7}])).to eql ['1',['2',['3','4']],[nil,nil,'6'],'7']
+      end
+    end
+
+    context 'record complex sample' do
+      it 'may have double double quotes translate to single double quotes' do
+        expect(coder.decode(%[("Test with double "" quoutes")])).to eql ['Test with double " quoutes']
+      end
+
+      it 'double double quotes may occur any number of times' do
+        expect(coder.decode(%[("Only one ""","Now "" two "".",""",""{""}","""""")])).to eql ['Only one "', 'Now " two ".', '","{"}', '""']
+      end
+
+      it 'may have any kind of value' do
+        expect(coder.decode(%[(String,123456,false,true,"2016-01-01 12:00:00",{1,2,3})])).to eql ['String', '123456', 'false', 'true', '2016-01-01 12:00:00', ['1', '2', '3']]
+      end
+    end
+
+  end
+
+  context 'on encode' do
+    let(:record) { Torque::PostgreSQL::Coder::Record }
+
+    context 'one dimensional arrays' do
+      it 'receives an empty array' do
+        expect(coder.encode([])).to eql %[{}]
+      end
+
+      it 'receives an array of strings' do
+        expect(coder.encode(['1','2','3'])).to eql %[{1,2,3}]
+      end
+
+      it 'receives an array of strings, with nils replacing NULL characters' do
+        expect(coder.encode(['1',nil,nil])).to eql %[{1,NULL,NULL}]
+      end
+
+      it 'receives an array with the word NULL' do
+        expect(coder.encode(['1','NULL','3'])).to eql %[{1,"NULL",3}]
+      end
+
+      it 'receives an array of strings when containing commas in a quoted string' do
+        expect(coder.encode(['1','2,3','4'])).to eql %[{1,"2,3",4}]
+      end
+
+      it 'receives an array of strings when containing an escaped quote' do
+        expect(coder.encode(['1','2",3','4'])).to eql %[{1,"2\\",3",4}]
+      end
+
+      it 'receives an array of strings when containing an escaped backslash' do
+        expect(coder.encode(['1','2\\','3','4'])).to eql %[{1,"2\\\\",3,4}]
+        expect(coder.encode(['1','2\\",3','4'])).to eql %[{1,"2\\\\\\",3",4}]
+      end
+
+      it 'receives an array containing empty strings' do
+        expect(coder.encode(['1', '', '3', ''])).to eql %[{1,"",3,""}]
+      end
+
+      it 'receives an array containing unicode strings' do
+        expect(coder.encode(['Paragraph 399(b)(i) – “valid leave” – meaning'])).to eql %[{"Paragraph 399(b)(i) – “valid leave” – meaning"}]
+      end
+    end
+
+    context 'two dimensional arrays' do
+      it 'receives an empty array' do
+        expect(coder.encode([[]])).to eql %[{{}}]
+        expect(coder.encode([[],[]])).to eql %[{{},{}}]
+      end
+
+      it 'receives an array of strings with a sub array' do
+        expect(coder.encode(['1',['2','3'],'4'])).to eql %[{1,{2,3},4}]
+      end
+
+      it 'receives an array of strings with a sub array' do
+        expect(coder.encode(['1',['2,3'],'4'])).to eql %[{1,{"2,3"},4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted }' do
+        expect(coder.encode(['1',['2,}3',nil,nil],'4'])).to eql %[{1,{"2,}3",NULL,NULL},4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted {' do
+        expect(coder.encode(['1',['2,{3'],'4'])).to eql %[{1,{"2,{3"},4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted { and escaped quote' do
+        expect(coder.encode(['1',['2",{3'],'4'])).to eql %[{1,{"2\\",{3"},4}]
+      end
+
+      it 'receives an array of strings with a sub array with empty strings' do
+        expect(coder.encode(['1',[''],'4',['']])).to eql %[{1,{""},4,{""}}]
+      end
+    end
+
+    context 'three dimensional arrays' do
+      it 'receives an empty array' do
+        expect(coder.encode([[[]]])).to eql %[{{{}}}]
+        expect(coder.encode([[[],[]],[[],[]]])).to eql %[{{{},{}},{{},{}}}]
+      end
+
+      it 'receives an array of strings with sub arrays' do
+        expect(coder.encode(['1',['2',['3','4']],[nil,nil,'6'],'7'])).to eql %[{1,{2,{3,4}},{NULL,NULL,6},7}]
+      end
+    end
+
+    context 'record syntax' do
+      it 'receives an empty array' do
+        expect(coder.encode( record.new )).to eql %[()]
+      end
+
+      it 'receives an array of strings' do
+        expect(coder.encode( record.new(['1','2','3']) )).to eql %[(1,2,3)]
+      end
+
+      it 'receives an array of strings, with nils replacing NULL characters' do
+        expect(coder.encode( record.new(['1',nil,nil]) )).to eql %[(1,,)]
+      end
+
+      it 'receives an array with the word NULL' do
+        expect(coder.encode( record.new(['1','NULL','3']) )).to eql %[(1,"NULL",3)]
+      end
+
+      it 'receives an array of strings when containing commas in a quoted string' do
+        expect(coder.encode( record.new(['1','2,3','4']) )).to eql %[(1,"2,3",4)]
+      end
+
+      it 'receives an array of strings when containing an escaped quote' do
+        expect(coder.encode( record.new(['1','2",3','4']) )).to eql %[(1,"2\\",3",4)]
+      end
+
+      it 'receives an array of strings when containing an escaped backslash' do
+        expect(coder.encode( record.new(['1','2\\','3','4']) )).to eql %[(1,"2\\\\",3,4)]
+        expect(coder.encode( record.new(['1','2\\",3','4']) )).to eql %[(1,"2\\\\\\",3",4)]
+      end
+
+      it 'receives an array containing empty strings' do
+        expect(coder.encode( record.new(['1', '', '3', '']) )).to eql %[(1,"",3,"")]
+      end
+
+      it 'receives an array containing unicode strings' do
+        expect(coder.encode( record.new(['Paragraph 399(b)(i) – “valid leave” – meaning']) )).to eql %[("Paragraph 399(b)(i) – “valid leave” – meaning")]
+      end
+    end
+
+    context 'array of records' do
+      it 'receives an empty array' do
+        expect(coder.encode([record.new])).to eql %[{()}]
+        expect(coder.encode([record.new,record.new])).to eql %[{(),()}]
+      end
+
+      it 'receives an array of strings with a sub array' do
+        expect(coder.encode(['1',record.new(['2','3']),'4'])).to eql %[{1,(2,3),4}]
+      end
+
+      it 'receives an array of strings with a sub array' do
+        expect(coder.encode(['1',record.new(['2,3']),'4'])).to eql %[{1,("2,3"),4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted }' do
+        expect(coder.encode(['1',record.new(['2,}3',nil,nil]),'4'])).to eql %[{1,("2,}3",,),4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted {' do
+        expect(coder.encode(['1',record.new(['2,{3']),'4'])).to eql %[{1,("2,{3"),4}]
+      end
+
+      it 'receives an array of strings with a sub array and a quoted { and escaped quote' do
+        expect(coder.encode(['1',record.new(['2",{3']),'4'])).to eql %[{1,("2\\",{3"),4}]
+      end
+
+      it 'receives an array of strings with a sub array with empty strings' do
+        expect(coder.encode(['1',record.new(['']),'4',record.new([''])])).to eql %[{1,(""),4,("")}]
+      end
+    end
+
+    context 'mix of record and array' do
+      it 'receives an empty array' do
+        expect(coder.encode( record.new([[record.new,nil]]) )).to eql %[({(),NULL})]
+        expect(coder.encode( [record.new([[], []]),[record.new,[]]] )).to eql %[{({},{}),{(),{}}}]
+      end
+
+      it 'receives an array of strings with sub arrays' do
+        expect(coder.encode(['1',record.new(['2',['3','4']]),record.new([nil,nil,'6']),'7'])).to eql %[{1,(2,{3,4}),(,,6),7}]
+      end
+    end
+
+    context 'record complex sample' do
+      it 'may have double double quotes translate to single double quotes' do
+        expect(coder.encode( record.new(['Test with double " quoutes']) )).to eql %[("Test with double \\" quoutes")]
+      end
+
+      it 'double double quotes may occur any number of times' do
+        expect(coder.encode( record.new(['Only one "', 'Now " two ".', '","{"}', '""']) )).to eql %[("Only one \\"","Now \\" two \\".","\\",\\"{\\"}","\\"\\"")]
+      end
+
+      it 'may have any kind of value' do
+        expect(coder.encode( record.new(['String', '123456', 'false', 'true', '2016-01-01 12:00:00', ['1', '2', '3']]) )).to eql %[(String,123456,false,true,"2016-01-01 12:00:00",{1,2,3})]
+      end
+    end
+
+  end
+
+end