torque-postgresql 3.4.1 → 4.0.0

data/spec/tests/belongs_to_many_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 RSpec.describe 'BelongsToMany' do
   context 'on model' do
     let(:model) { Video }
+    let(:key) { :tests }
     let(:builder) { Torque::PostgreSQL::Associations::Builder::BelongsToMany }
     let(:reflection) { Torque::PostgreSQL::Reflection::BelongsToManyReflection }
-    let(:key) { Torque::PostgreSQL::AR720 ? :tests : 'tests' }
 
     after { model._reflections = {} }
 
@@ -34,8 +34,8 @@ RSpec.describe 'BelongsToMany' do
 
   context 'on association' do
     let(:other) { Tag }
+    let(:key) { :tags }
     let(:initial) { FactoryBot.create(:tag) }
-    let(:key) { Torque::PostgreSQL::AR720 ? :tags : 'tags' }
 
     before { Video.belongs_to_many(:tags) }
     subject { Video.create(title: 'A') }
@@ -58,7 +58,7 @@ RSpec.describe 'BelongsToMany' do
     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})
+        SELECT "tags".* FROM "tags" WHERE "tags"."id" = #{initial.id}
       SQL
 
       expect(subject.tags.load).to be_a(ActiveRecord::Associations::CollectionProxy)
@@ -370,6 +370,18 @@ RSpec.describe 'BelongsToMany' do
       expect { query.load }.not_to raise_error
     end
 
+    context 'when handling binds' do
+      let(:tag_ids) { FactoryBot.create_list(:tag, 5).map(&:id) }
+      let!(:record) { Video.new(tag_ids: tag_ids) }
+
+      it 'uses rails default with in and several binds' do
+        sql, binds = get_query_with_binds { record.tags.load }
+
+        expect(sql).to include(' WHERE "tags"."id" IN ($1, $2, $3, $4, $5)')
+        expect(binds.size).to be_eql(5)
+      end
+    end
+
     context 'when the attribute has a default value' do
       subject { FactoryBot.create(:item) }
 
@@ -424,16 +436,28 @@ RSpec.describe 'BelongsToMany' do
 
     subject { game.create }
 
-    it 'loads associated records' do
+    it 'loads one associated records' do
       subject.update(player_ids: [other.id])
       expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
-        SELECT "players".* FROM "players" WHERE "players"."id" IN ('#{other.id}')
+        SELECT "players".* FROM "players" WHERE "players"."id" = '#{other.id}'
       SQL
 
       expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.players.to_a).to be_eql([other])
     end
 
+    it 'loads several associated records' do
+      entries = [other, player.create]
+      subject.update(player_ids: entries.map(&:id))
+      expect(subject.players.to_sql).to be_eql(<<-SQL.squish)
+        SELECT "players".* FROM "players"
+        WHERE "players"."id" IN ('#{entries[0].id}', '#{entries[1].id}')
+      SQL
+
+      expect(subject.players.load).to be_a(ActiveRecord::Associations::CollectionProxy)
+      expect(subject.players.to_a).to be_eql(entries)
+    end
+
     it 'can preload records' do
       records = 5.times.map { player.create }
       subject.players.concat(records)
@@ -452,6 +476,49 @@ RSpec.describe 'BelongsToMany' do
     end
   end
 
+  context 'using callbacks' do
+    let(:tags) { FactoryBot.create_list(:tag, 3) }
+    let(:collectors) { Hash.new { |h, k| h[k] = [] } }
+
+    subject { Video.create(title: 'A') }
+
+    after do
+      Video.reset_callbacks(:save)
+      Video._reflections = {}
+    end
+
+    before do
+      subject.update_attribute(:tag_ids, tags.first(2).pluck(:id))
+      Video.belongs_to_many(:tags,
+        before_add:    ->(_, tag) { collectors[:before_add]    << tag },
+        after_add:     ->(_, tag) { collectors[:after_add]     << tag },
+        before_remove: ->(_, tag) { collectors[:before_remove] << tag },
+        after_remove:  ->(_, tag) { collectors[:after_remove]  << tag },
+      )
+    end
+
+    it 'works with id changes' do
+      subject.tag_ids = tags.drop(1).pluck(:id)
+      subject.save!
+
+      expect(collectors[:before_add]).to be_eql([tags.last])
+      expect(collectors[:after_add]).to be_eql([tags.last])
+
+      expect(collectors[:before_remove]).to be_eql([tags.first])
+      expect(collectors[:after_remove]).to be_eql([tags.first])
+    end
+
+    it 'works with record changes' do
+      subject.tags = tags.drop(1)
+
+      expect(collectors[:before_add]).to be_eql([tags.last])
+      expect(collectors[:after_add]).to be_eql([tags.last])
+
+      expect(collectors[:before_remove]).to be_eql([tags.first])
+      expect(collectors[:after_remove]).to be_eql([tags.first])
+    end
+  end
+
   context 'using custom keys' do
     let(:connection) { ActiveRecord::Base.connection }
     let(:post) { Post }

data/spec/tests/enum_set_spec.rb

@@ -43,13 +43,7 @@ RSpec.describe 'Enum' do
   end
 
   context 'on schema' do
-    let(:source) do
-      if Torque::PostgreSQL::AR720
-        ActiveRecord::Base.connection_pool
-      else
-        ActiveRecord::Base.connection
-      end
-    end
+    let(:source) { ActiveRecord::Base.connection_pool }
 
     let(:dump_result) do
       ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
@@ -275,10 +269,11 @@ RSpec.describe 'Enum' do
   end
 
   context 'on model' do
+    let(:instance) { Course.new }
+
     before(:each) { decorate(Course, :types) }
 
     subject { Course }
-    let(:instance) { Course.new }
 
     it 'has all enum set methods' do
       expect(subject).to  respond_to(:types)
@@ -301,17 +296,23 @@ RSpec.describe 'Enum' do
 
     it 'scope the model correctly' do
       query = subject.a.to_sql
-      expect(query).to match(/"courses"."types" @> ARRAY\['A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" @> '{A}'::types[]})
     end
 
     it 'has a match all scope' do
       query = subject.has_types('B', 'A').to_sql
-      expect(query).to match(/"courses"."types" @> ARRAY\['B', 'A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" @> '{B,A}'::types[]})
     end
 
     it 'has a match any scope' do
       query = subject.has_any_types('B', 'A').to_sql
-      expect(query).to match(/"courses"."types" && ARRAY\['B', 'A'\]::types\[\]/)
+      expect(query).to include(%{WHERE "courses"."types" && '{B,A}'::types[]})
+    end
+
+    it 'uses bind param instead of raw value' do
+      sql, binds = get_query_with_binds { subject.has_any_types('B', 'A').load }
+      expect(sql).to include('WHERE "courses"."types" && $1::types[]')
+      expect(binds.first.value).to eq(%w[B A])
     end
   end
 end

data/spec/tests/enum_spec.rb

@@ -70,7 +70,6 @@ RSpec.describe 'Enum' do
   end
 
   context 'on value' do
-    subject { Enum::ContentStatus }
     let(:values) { %w(created draft published archived) }
     let(:error) { Torque::PostgreSQL::Attributes::Enum::EnumError }
     let(:mock_enum) do
@@ -79,6 +78,8 @@ RSpec.describe 'Enum' do
       klass
     end
 
+    subject { Enum::ContentStatus }
+
     it 'class exists' do
       namespace = Torque::PostgreSQL.config.enum.namespace
       expect(namespace.const_defined?('ContentStatus')).to be_truthy
@@ -341,10 +342,11 @@ RSpec.describe 'Enum' do
   end
 
   context 'on model' do
+    let(:instance) { FactoryBot.build(:user) }
+
     before(:each) { decorate(User, :role) }
 
     subject { User }
-    let(:instance) { FactoryBot.build(:user) }
 
     it 'has all enum methods' do
       expect(subject).to  respond_to(:roles)

data/spec/tests/full_text_seach_test.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+RSpec.describe 'FullTextSearch' do
+  context 'on builder' do
+    let(:builder) { Torque::PostgreSQL::Attributes::Builder }
+
+    describe '.to_search_weights' do
+      it 'works with a single column' do
+        expect(builder.to_search_weights('title')).to eq({ 'title' => 'A' })
+        expect(builder.to_search_weights(:title)).to eq({ 'title' => 'A' })
+      end
+
+      it 'works with an array of columns' do
+        value = { 'title' => 'A', 'content' => 'B' }
+        expect(builder.to_search_weights(%w[title content])).to eq(value)
+        expect(builder.to_search_weights(%i[title content])).to eq(value)
+      end
+
+      it 'works with a hash of columns and weights' do
+        value = { 'title' => 'A', 'content' => 'B', 'summary' => 'C' }
+        expect(builder.to_search_weights(value.transform_keys(&:to_sym))).to eq(value)
+      end
+
+      it 'works with a hash of columns and invalid weights' do
+        value = { 'title' => 'X', 'content' => 'Y', 'summary' => 'Z' }
+        expect(builder.to_search_weights(value.transform_keys(&:to_sym))).to eq(value)
+      end
+    end
+
+    describe '.to_search_vector_operation' do
+      it 'builds a simple one' do
+        result = builder.to_search_vector_operation('english', { 'title' => 'A' })
+        expect(result.to_sql).to eq("TO_TSVECTOR('english', COALESCE(title, ''))")
+      end
+
+      it 'builds with 2 columns' do
+        columns = { 'title' => 'A', 'content' => 'B' }
+        result = builder.to_search_vector_operation('english', columns)
+        expect(result.to_sql).to eq(<<~SQL.squish)
+          SETWEIGHT(TO_TSVECTOR('english', COALESCE(title, '')), 'A') ||
+          SETWEIGHT(TO_TSVECTOR('english', COALESCE(content, '')), 'B')
+        SQL
+      end
+
+      it 'builds with a dynamic language' do
+        columns = { 'title' => 'A', 'content' => 'B' }
+        result = builder.to_search_vector_operation(:lang, columns)
+        expect(result.to_sql).to eq(<<~SQL.squish)
+          SETWEIGHT(TO_TSVECTOR(lang, COALESCE(title, '')), 'A') ||
+          SETWEIGHT(TO_TSVECTOR(lang, COALESCE(content, '')), 'B')
+        SQL
+      end
+    end
+
+    describe '.search_vector_options' do
+      it 'correctly translates the settings' do
+        options = builder.search_vector_options(columns: 'title')
+        expect(options).to eq(
+          type: :tsvector,
+          as: "TO_TSVECTOR('english', COALESCE(title, ''))",
+          stored: true,
+        )
+      end
+
+      it 'properly adds the index type' do
+        options = builder.search_vector_options(columns: 'title', index: true)
+        expect(options).to eq(
+          type: :tsvector,
+          as: "TO_TSVECTOR('english', COALESCE(title, ''))",
+          stored: true,
+          index: { using: :gin },
+        )
+      end
+    end
+  end
+
+  context 'on schema dumper' do
+    let(:connection) { ActiveRecord::Base.connection }
+    let(:source) { ActiveRecord::Base.connection_pool }
+    let(:dump_result) do
+      ActiveRecord::SchemaDumper.dump(source, (dump_result = StringIO.new))
+      dump_result.string
+    end
+
+    it 'properly supports search language' do
+      parts = %{t.search_language "lang", default: "english", null: false}
+      expect(dump_result).to include(parts)
+    end
+
+    it 'properly translates a simple single search vector with embedded language' do
+      parts = 't.search_vector "search_vector", stored: true'
+      parts << ', language: :lang, columns: :title'
+      expect(dump_result).to include(parts)
+    end
+
+    it 'properly translates a simple multiple column search vector with language' do
+      parts = 't.search_vector "search_vector", stored: true'
+      parts << ', language: "english", columns: [:title, :content]'
+      expect(dump_result).to include(parts)
+    end
+
+    it 'supports a custom definition of weights' do
+      connection.create_table :custom_search do |t|
+        t.string :title
+        t.string :content
+        t.string :subtitle
+        t.search_vector :sample_a, columns: {
+          title: 'A',
+          subtitle: 'A',
+          content: 'B',
+        }
+        t.search_vector :sample_b, columns: {
+          title: 'A',
+          subtitle: 'C',
+          content: 'D',
+        }
+        t.search_vector :sample_c, columns: {
+          title: 'C',
+          subtitle: 'B',
+          content: 'A',
+        }
+      end
+
+      parts = 't.search_vector "sample_a", stored: true'
+      parts << ', language: "english", columns: { title: "A", subtitle: "A", content: "B" }'
+      expect(dump_result).to include(parts)
+
+      parts = 't.search_vector "sample_b", stored: true'
+      parts << ', language: "english", columns: { title: "A", subtitle: "C", content: "D" }'
+      expect(dump_result).to include(parts)
+
+      parts = 't.search_vector "sample_c", stored: true'
+      parts << ', language: "english", columns: [:content, :subtitle, :title]'
+      expect(dump_result).to include(parts)
+    end
+  end
+
+  context 'on config' do
+    let(:base) { Course }
+    let(:scope) { 'full_text_search' }
+
+    let(:mod) { base.singleton_class.included_modules.first }
+
+    after { mod.send(:undef_method, scope) if scope.present? }
+
+    it 'has the initialization method' do
+      scope.replace('')
+      expect(base).to respond_to(:torque_search_for)
+    end
+
+    it 'properly generates the search scope' do
+      base.torque_search_for(:search_vector)
+      expect(base.all).to respond_to(:full_text_search)
+    end
+
+    it 'works with prefix and suffix' do
+      scope.replace('custom_full_text_search_scope')
+      base.torque_search_for(:search_vector, prefix: 'custom', suffix: 'scope')
+      expect(base.all).to respond_to(:custom_full_text_search_scope)
+    end
+  end
+
+  context 'on relation' do
+    let(:base) { Course }
+    let(:scope) { 'full_text_search' }
+
+    let(:mod) { base.singleton_class.included_modules.first }
+
+    before { Course.torque_search_for(:search_vector) }
+    after { mod.send(:undef_method, :full_text_search) }
+
+    it 'performs a simple query' do
+      result = Course.full_text_search('test')
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the order' do
+      result = Course.full_text_search('test', order: true)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      parts << ' ORDER BY TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) ASC"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the order descending' do
+      result = Course.full_text_search('test', order: :desc)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      parts << ' ORDER BY TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) DESC"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the rank' do
+      result = Course.full_text_search('test', rank: true)
+      parts = 'SELECT "courses".*, TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) AS rank"
+      parts << ' FROM "courses" WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can include the rank named differently' do
+      result = Course.full_text_search('test', rank: :custom_rank)
+      parts = 'SELECT "courses".*, TS_RANK("courses"."search_vector",'
+      parts << " PHRASETO_TSQUERY('english', 'test')) AS custom_rank"
+      parts << ' FROM "courses" WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use default query mode' do
+      result = Course.full_text_search('test', mode: :default)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " TO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use plain query mode' do
+      result = Course.full_text_search('test', mode: :plain)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PLAINTO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use web query mode' do
+      result = Course.full_text_search('test', mode: :web)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " WEBSEARCH_TO_TSQUERY('english', 'test')"
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can use a attribute as the language' do
+      result = Course.full_text_search('test', language: :lang)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << %{ PHRASETO_TSQUERY("courses"."lang", 'test')}
+      expect(result.to_sql).to eql(parts)
+    end
+
+    it 'can call a method to pull the language' do
+      Course.define_singleton_method(:search_language) { 'portuguese' }
+      result = Course.full_text_search('test', language: :search_language)
+      parts = 'SELECT "courses".* FROM "courses"'
+      parts << ' WHERE "courses"."search_vector" @@'
+      parts << " PHRASETO_TSQUERY('portuguese', 'test')"
+      expect(result.to_sql).to eql(parts)
+      Course.singleton_class.undef_method(:search_language)
+    end
+
+    it 'properly binds all provided values' do
+      query = Course.full_text_search('test')
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include("PHRASETO_TSQUERY($1, $2)")
+      expect(binds.first.value).to eq('english')
+      expect(binds.second.value).to eq('test')
+    end
+
+    it 'raises an error when the language is not found' do
+      expect do
+        Course.full_text_search('test', language: '')
+      end.to raise_error(ArgumentError, /Unable to determine language/)
+    end
+
+    it 'raises an error when the mode is invalid' do
+      expect do
+        Course.full_text_search('test', mode: :invalid)
+      end.to raise_error(ArgumentError, /Invalid mode :invalid for full text search/)
+    end
+  end
+end

data/spec/tests/function_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe 'Function' do
+  let(:helper) { Torque::PostgreSQL::FN }
+  let(:conn) { ActiveRecord::Base.connection }
+  let(:visitor) { ::Arel::Visitors::PostgreSQL.new(conn) }
+  let(:collector) { ::Arel::Collectors::SQLString }
+
+  context 'on helper' do
+    it 'helps creating a bind' do
+      type = ::ActiveRecord::Type::String.new
+      expect(helper.bind(:foo, 'test', type)).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps creating a bind for a model attribute' do
+      expect(helper.bind_for(Video, :title, 'test')).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps creating a bind for an arel attribute' do
+      attr = Video.arel_table['title']
+      expect(helper.bind_with(attr, 'test')).to be_a(::Arel::Nodes::BindParam)
+    end
+
+    it 'helps concatenating arguments' do
+      values = %w[a b c].map(&::Arel.method(:sql))
+
+      # Unable to just call .sql with a simple thing
+      visited = visitor.accept(helper.concat(values[0]), collector.new)
+      expect(visited.value).to eq("a")
+
+      # 2+ we can call .sql directly
+      expect(helper.concat(values[0], values[1]).to_sql).to eq("a || b")
+      expect(helper.concat(values[0], values[1], values[2]).to_sql).to eq("a || b || c")
+    end
+
+    it 'helps building any other function' do
+      values = %w[a b c].map(&::Arel.method(:sql))
+      expect(helper).to respond_to(:coalesce)
+      expect(helper.coalesce(values[0], values[1]).to_sql).to eq("COALESCE(a, b)")
+    end
+  end
+end

data/spec/tests/has_many_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe 'HasMany' do
 
   context 'on original' do
     let(:other) { Text }
-    let(:key) { Torque::PostgreSQL::AR720 ? :texts : 'texts' }
+    let(:key) { :texts }
 
     before { User.has_many :texts }
     subject { User.create(name: 'User 1') }
@@ -247,7 +247,7 @@ RSpec.describe 'HasMany' do
 
   context 'on array' do
     let(:other) { Video }
-    let(:key) { Torque::PostgreSQL::AR720 ? :videos : 'videos' }
+    let(:key) { :videos }
 
     before { Tag.has_many :videos, array: true }
     subject { Tag.create(name: 'A') }
@@ -264,15 +264,21 @@ RSpec.describe 'HasMany' do
     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\\[\\]\\)?
+      expect(subject.videos.to_sql).to eq(<<~SQL.squish)
+        SELECT "videos".* FROM "videos" WHERE #{subject.id} = ANY("videos"."tag_ids")
       SQL
 
       expect(subject.videos.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.videos.to_a).to be_eql([])
     end
 
+    it 'uses binds instead of the literal value' do
+      query = subject.videos
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include('WHERE $1 = ANY("videos"."tag_ids")')
+      expect(binds.first.value).to eq(subject.id)
+    end
+
     it 'can be marked as loaded' do
       expect(subject.videos.loaded?).to be_eql(false)
       expect(subject.videos).to respond_to(:load_target)
@@ -474,15 +480,22 @@ RSpec.describe 'HasMany' do
     subject { player.create }
 
     it 'loads associated records' do
-      expect(subject.games.to_sql).to match(Regexp.new(<<-SQL.squish))
-        SELECT "games"\\.\\* FROM "games"
-        WHERE \\(?"games"\\."player_ids" && ARRAY\\['#{subject.id}'\\]::uuid\\[\\]\\)?
+      expect(subject.games.to_sql).to eq(<<~SQL.squish)
+        SELECT "games".* FROM "games"
+        WHERE '#{subject.id}' = ANY("games"."player_ids")
       SQL
 
       expect(subject.games.load).to be_a(ActiveRecord::Associations::CollectionProxy)
       expect(subject.games.to_a).to be_eql([])
     end
 
+    it 'uses binds instead of the literal value' do
+      query = subject.games
+      sql, binds = get_query_with_binds { query.load }
+      expect(sql).to include('WHERE $1 = ANY("games"."player_ids")')
+      expect(binds.first.value).to eq(subject.id)
+    end
+
     it 'can preload records' do
       5.times { game.create(player_ids: [subject.id]) }
       entries = player.all.includes(:games).load

data/spec/tests/interval_spec.rb

@@ -3,13 +3,7 @@ require 'spec_helper'
 RSpec.describe 'Interval' do
   let(:table_definition) { ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition }
   let(:connection) { ActiveRecord::Base.connection }
-  let(:source) do
-    if Torque::PostgreSQL::AR720
-      ActiveRecord::Base.connection_pool
-    else
-      ActiveRecord::Base.connection
-    end
-  end
+  let(:source) { ActiveRecord::Base.connection_pool }
 
   context 'on settings' do
     it 'must be set to ISO 8601' do