torque-postgresql 2.0.4 → 2.1.2

data/spec/tests/has_many_spec.rb

@@ -291,6 +291,20 @@ RSpec.describe 'HasMany' do
       expect(record.tag_ids).to be_eql([subject.id])
     end
 
+    it 'can perist after accessed in after_create' do
+      other.belongs_to_many(:tags)
+      other.after_create { self.tags.to_a }
+
+      video = FactoryBot.create(:video)
+      subject.videos << video
+
+      expect(subject.reload.videos.size).to eql(1)
+      expect(video.reload.tags.size).to eql(1)
+
+      other.reset_callbacks(:create)
+      other._reflections = {}
+    end
+
     it 'can concat records' do
       FactoryBot.create(:video, tag_ids: [subject.id])
       expect(subject.videos.size).to be_eql(1)

data/spec/tests/insert_all_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+RSpec.describe 'InsertAll' do
+  context 'on executing' do
+    before do
+      ActiveRecord::InsertAll.send(:public, :to_sql)
+      allow_any_instance_of(ActiveRecord::InsertAll).to receive(:execute, &:to_sql)
+    end
+
+    subject { Tag }
+
+    let(:entries) { [{ name: 'A' }, { name: 'B' }] }
+
+    it 'does not mess with insert_all' do
+      result = subject.insert_all(entries)
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT  DO NOTHING RETURNING "id"
+      SQL
+
+      result = subject.insert_all(entries, returning: %i[name])
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT  DO NOTHING RETURNING "name"
+      SQL
+
+      result = subject.insert_all(entries, returning: %i[id name])
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT  DO NOTHING RETURNING "id","name"
+      SQL
+    end
+
+    it 'does not mess with insert_all!' do
+      result = subject.insert_all!(entries)
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B') RETURNING "id"
+      SQL
+
+      result = subject.insert_all!(entries, returning: %i[name])
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B') RETURNING "name"
+      SQL
+    end
+
+    it 'does not mess with upsert without where' do
+      result = subject.upsert_all(entries)
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT ("id") DO UPDATE SET "name"=excluded."name"
+        RETURNING "id"
+      SQL
+
+      result = subject.upsert_all(entries, returning: %i[name])
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT ("id") DO UPDATE SET "name"=excluded."name"
+        RETURNING "name"
+      SQL
+    end
+
+    it 'does add the where condition without the returning clause' do
+      result = subject.upsert_all(entries, returning: false, where: '1=1')
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT ("id") DO UPDATE SET "name"=excluded."name"
+        WHERE 1=1
+      SQL
+    end
+
+    it 'does add the where condition with the returning clause' do
+      result = subject.upsert_all(entries, where: '1=1')
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT ("id") DO UPDATE SET "name"=excluded."name"
+        WHERE 1=1 RETURNING "id"
+      SQL
+    end
+
+    xit 'dows work with model-based where clause' do
+      result = subject.upsert_all(entries, where: Tag.where(name: 'C'))
+      expect(result.squish).to be_eql(<<~SQL.squish)
+        INSERT INTO "tags" ("name") VALUES ('A'), ('B')
+        ON CONFLICT ("id") DO UPDATE SET "name"=excluded."name"
+        WHERE "tags"."name" = 'C' RETURNING "id"
+      SQL
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 2.1.2
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-13 00:00:00.000000000 Z
+date: 2021-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -215,12 +215,12 @@ files:
 - lib/torque/postgresql/auxiliary_statement.rb
 - lib/torque/postgresql/auxiliary_statement/settings.rb
 - lib/torque/postgresql/base.rb
-- lib/torque/postgresql/coder.rb
 - lib/torque/postgresql/collector.rb
 - lib/torque/postgresql/config.rb
 - lib/torque/postgresql/geometry_builder.rb
 - lib/torque/postgresql/i18n.rb
 - lib/torque/postgresql/inheritance.rb
+- lib/torque/postgresql/insert_all.rb
 - lib/torque/postgresql/migration.rb
 - lib/torque/postgresql/migration/command_recorder.rb
 - lib/torque/postgresql/railtie.rb
@@ -242,6 +242,7 @@ files:
 - spec/en.yml
 - spec/factories/authors.rb
 - spec/factories/comments.rb
+- spec/factories/item.rb
 - spec/factories/posts.rb
 - spec/factories/tags.rb
 - spec/factories/texts.rb
@@ -259,6 +260,7 @@ files:
 - spec/models/course.rb
 - spec/models/geometry.rb
 - spec/models/guest_comment.rb
+- spec/models/item.rb
 - spec/models/post.rb
 - spec/models/tag.rb
 - spec/models/text.rb
@@ -270,13 +272,13 @@ files:
 - spec/tests/arel_spec.rb
 - spec/tests/auxiliary_statement_spec.rb
 - spec/tests/belongs_to_many_spec.rb
-- spec/tests/coder_spec.rb
 - spec/tests/collector_spec.rb
 - spec/tests/distinct_on_spec.rb
 - spec/tests/enum_set_spec.rb
 - spec/tests/enum_spec.rb
 - spec/tests/geometric_builder_spec.rb
 - spec/tests/has_many_spec.rb
+- spec/tests/insert_all_spec.rb
 - spec/tests/interval_spec.rb
 - spec/tests/lazy_spec.rb
 - spec/tests/period_spec.rb
@@ -303,7 +305,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.14
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extension to access PostgreSQL advanced resources
@@ -324,6 +326,7 @@ test_files:
 - spec/models/tag.rb
 - spec/models/time_keeper.rb
 - spec/models/video.rb
+- spec/models/item.rb
 - spec/factories/authors.rb
 - spec/factories/comments.rb
 - spec/factories/posts.rb
@@ -331,23 +334,24 @@ test_files:
 - spec/factories/texts.rb
 - spec/factories/users.rb
 - spec/factories/videos.rb
+- spec/factories/item.rb
 - spec/tests/geometric_builder_spec.rb
-- spec/tests/range_spec.rb
-- spec/tests/table_inheritance_spec.rb
+- spec/tests/arel_spec.rb
+- spec/tests/insert_all_spec.rb
 - spec/tests/enum_spec.rb
-- spec/tests/auxiliary_statement_spec.rb
-- spec/tests/enum_set_spec.rb
-- spec/tests/coder_spec.rb
+- spec/tests/period_spec.rb
+- spec/tests/range_spec.rb
 - spec/tests/collector_spec.rb
 - spec/tests/distinct_on_spec.rb
 - spec/tests/interval_spec.rb
 - spec/tests/lazy_spec.rb
 - spec/tests/quoting_spec.rb
 - spec/tests/relation_spec.rb
-- spec/tests/belongs_to_many_spec.rb
-- spec/tests/period_spec.rb
-- spec/tests/arel_spec.rb
+- spec/tests/auxiliary_statement_spec.rb
+- spec/tests/enum_set_spec.rb
 - spec/tests/has_many_spec.rb
+- spec/tests/belongs_to_many_spec.rb
+- spec/tests/table_inheritance_spec.rb
 - spec/mocks/cache_query.rb
 - spec/mocks/create_table.rb
 - spec/en.yml

data/lib/torque/postgresql/coder.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-module Torque
-  module PostgreSQL
-    module Coder
-
-      # This class represents an Record to be encoded, instead of a literal Array
-      Record = Class.new(Array)
-
-      class << self
-
-        NEED_QUOTE_FOR = /[\\"(){}, \t\n\r\v\f]/m
-        DELIMITER = ','
-
-        # This method replace the +read_array+ method from PG gem
-        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_decoder.c#L177
-        # for more information
-        def decode(value)
-          # TODO: Use StringScanner
-          # See http://ruby-doc.org/stdlib-1.9.3/libdoc/strscan/rdoc/StringScanner.html
-          _decode(::StringIO.new(value))
-        end
-
-        # This method replace the ++ method from PG gem
-        # See https://github.com/ged/ruby-pg/blob/master/ext/pg_text_encoder.c#L398
-        # for more information
-        def encode(value)
-          _encode(value)
-        end
-
-        private
-
-          def _decode(stream)
-            quoted = 0
-            escaped = false
-            result = []
-            part = String.new
-
-            # Always start getting the non-collection character, the second char
-            stream.getc if stream.pos == 0
-
-            # Check for an empty list
-            return result if %w[} )].include?(stream.getc)
-
-            # If it's not an empty list, return one position before iterating
-            stream.pos -= 1
-            stream.each_char do |c|
-
-              case
-              when quoted < 1
-                case
-                when c == DELIMITER, c == '}', c == ')'
-
-                  unless escaped
-                    # Non-quoted empty string or NULL as extense
-                    part = nil if quoted == 0 && ( part.length == 0 || part == 'NULL' )
-                    result << part
-                  end
-
-                  return result unless c == DELIMITER
-
-                  escaped = false
-                  quoted = 0
-                  part = String.new
-
-                when c == '"'
-                  quoted = 1
-                when c == '{', c == '('
-                  result << _decode(stream)
-                  escaped = true
-                else
-                  part << c
-                end
-              when escaped
-                escaped = false
-                part << c
-              when c == '\\'
-                escaped = true
-              when c == '"'
-                if stream.getc == '"'
-                  part << c
-                else
-                  stream.pos -= 1
-                  quoted = -1
-                end
-              else
-                if ( c == '"' || c == "'" ) && stream.getc != c
-                  stream.pos -= 1
-                  quoted = -1
-                else
-                  part << c
-                end
-              end
-
-            end
-          end
-
-          def _encode(list)
-            is_record = list.is_a?(Record)
-            list.map! do |part|
-              case part
-              when NilClass
-                is_record ? '' : 'NULL'
-              when Array
-                _encode(part)
-              else
-                _quote(part.to_s)
-              end
-            end
-
-            result = is_record ? '(%s)' : '{%s}'
-            result % list.join(DELIMITER)
-          end
-
-          def _quote(string)
-            len = string.length
-
-            # Fast results
-            return '""' if len == 0
-            return '"NULL"' if len == 4 && string == 'NULL'
-
-            # Check if the string don't need quotes
-            return string unless string =~ NEED_QUOTE_FOR
-
-            # Use the original string escape function
-            PG::Connection.escape_string(string).inspect
-          end
-
-      end
-
-    end
-  end
-end

data/spec/tests/coder_spec.rb

@@ -1,367 +0,0 @@
-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