schema_expectations 0.0.1 → 0.2.0

data/spec/lib/schema_expectations/active_record/column_reflector_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'schema_expectations/active_record/column_reflector'
+
+module SchemaExpectations
+  module ActiveRecord
+    describe ColumnReflector, :active_record do
+      subject(:column_reflector) { ColumnReflector.new(Record) }
+
+      context '#without_present_default' do
+        specify 'filters default values' do
+          create_table :records do |t|
+            t.integer :integer_default, default: 0
+            t.string :string_default, default: 'test'
+            t.string :empty_default, default: ''
+            t.string :null_default, default: nil
+            t.string :no_default
+
+            t.timestamps null: false
+          end
+          stub_const('Record', Class.new(::ActiveRecord::Base))
+
+          expect(column_reflector.column_names).
+            to eq %i(id integer_default string_default empty_default null_default no_default created_at updated_at)
+
+          expect(column_reflector.without_present_default.column_names).
+            to eq %i(empty_default null_default no_default)
+        end
+
+        context 'default functions', :postgresql, active_record_version: '>= 4.0' do
+          specify 'are filtered' do
+            create_table :records do |t|
+              t.uuid :uuid_default, default: 'uuid_generate_v4()'
+              t.string :no_default
+            end
+            execute <<-SQL
+              -- not possible via create_table syntax right now
+              ALTER TABLE records
+                ADD COLUMN function_default float DEFAULT random();
+            SQL
+            stub_const('Record', Class.new(::ActiveRecord::Base))
+
+            expect(Record.columns_hash['function_default'].default).to be_nil
+            expect(Record.columns_hash['uuid_default'].default).to be_nil
+            expect(Record.columns_hash['function_default'].default_function).to_not be_nil
+            expect(Record.columns_hash['uuid_default'].default_function).to_not be_nil
+
+            expect(column_reflector.column_names).
+              to eq %i(id uuid_default no_default function_default)
+
+            expect(column_reflector.without_present_default.column_names).
+              to eq %i(no_default)
+          end
+
+          specify 'logs if it encounters an error trying to run default function' do
+            create_table :records
+            execute <<-SQL
+              CREATE FUNCTION raise_error() RETURNS varchar
+                AS $BODY$
+                  BEGIN
+                    RAISE 'test exception';
+                  END;
+                $BODY$
+                LANGUAGE plpgsql;
+
+              -- not possible via create_table syntax right now
+              ALTER TABLE records
+                ADD COLUMN function_default varchar DEFAULT raise_error();
+            SQL
+            stub_const('Record', Class.new(::ActiveRecord::Base))
+
+            expect(Record.columns_hash['function_default'].default).to be_nil
+            expect(Record.columns_hash['function_default'].default_function).to_not be_nil
+
+            expect(column_reflector.column_names).
+              to eq %i(id function_default)
+
+            expect(SchemaExpectations.error_logger).to receive(:error).once do |message|
+              expect(message).to include 'SchemaExpectations: encountered error running SELECT raise_error()'
+              expect(message).to include 'PG::RaiseException: ERROR:  test exception'
+              expect(message).to include ': SELECT raise_error()'
+            end
+            expect(column_reflector.without_present_default.column_names).
+              to eq %i(function_default)
+          end
+        end
+      end
+
+      specify '#not_null' do
+        create_table :records do |t|
+          t.string :not_null, null: false
+          t.string :nullable
+        end
+        stub_const('Record', Class.new(::ActiveRecord::Base))
+
+        expect(column_reflector.column_names).to eq %i(id not_null nullable)
+        expect(column_reflector.not_null.column_names).to eq %i(id not_null)
+      end
+
+      context '#for_attributes' do
+        before do
+          create_table :records do |t|
+            t.string :record_id
+            t.string :record_type
+            t.string :other
+          end
+
+          stub_const('Record', Class.new(::ActiveRecord::Base))
+        end
+
+        specify 'without associations' do
+          expect(column_reflector.column_names).to eq %i(id record_id record_type other)
+          expect(column_reflector.for_attributes(:missing).column_names).to be_empty
+          expect(column_reflector.for_attributes(:record).column_names).to be_empty
+          expect(column_reflector.for_attributes(:record_id).column_names).to eq %i(record_id)
+          expect(column_reflector.for_attributes(:record_type).column_names).to eq %i(record_type)
+          expect(column_reflector.for_attributes(:other).column_names).to eq %i(other)
+          expect(column_reflector.for_attributes(*%i(record missing other)).column_names).to eq %i(other)
+        end
+
+        specify 'belongs_to polymorphic' do
+          Record.instance_eval do
+            belongs_to :record, polymorphic: true
+          end
+
+          expect(column_reflector.column_names).to eq %i(id record_id record_type other)
+          expect(column_reflector.for_attributes(:missing).column_names).to be_empty
+          expect(column_reflector.for_attributes(:record).column_names).to eq %i(record_id record_type)
+          expect(column_reflector.for_attributes(:record_id).column_names).to eq %i(record_id)
+          expect(column_reflector.for_attributes(:record_type).column_names).to eq %i(record_type)
+          expect(column_reflector.for_attributes(:other).column_names).to eq %i(other)
+          expect(column_reflector.for_attributes(*%i(record missing other)).column_names).to eq %i(record_id record_type other)
+        end
+
+        specify 'belongs_to' do
+          Record.instance_eval do
+            belongs_to :record
+          end
+
+          expect(column_reflector.column_names).to eq %i(id record_id record_type other)
+          expect(column_reflector.for_attributes(:missing).column_names).to be_empty
+          expect(column_reflector.for_attributes(:record).column_names).to eq %i(record_id)
+          expect(column_reflector.for_attributes(:record_id).column_names).to eq %i(record_id)
+          expect(column_reflector.for_attributes(:record_type).column_names).to eq %i(record_type)
+          expect(column_reflector.for_attributes(:other).column_names).to eq %i(other)
+          expect(column_reflector.for_attributes(*%i(record missing other)).column_names).to eq %i(record_id other)
+        end
+      end
+    end
+  end
+end

data/spec/lib/schema_expectations/active_record/validation_reflector_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'schema_expectations/active_record/validation_reflector'
+
+module SchemaExpectations
+  module ActiveRecord
+    describe ValidationReflector, :active_record do
+      before do
+        create_table :records
+
+        stub_const('Record', Class.new(::ActiveRecord::Base))
+      end
+
+      subject(:validation_reflector) { ValidationReflector.new(Record) }
+
+      specify 'allows filtering attributes' do
+        Record.instance_eval do
+          validates :present, presence: true
+          validates :not_present, length: { minimum: 1 }
+          validates :conditional_1, presence: true, on: :create
+          validates :conditional_2, presence: true, if: ->{ false }
+          validates :conditional_3, presence: true, unless: ->{ false }
+          validates :conditional_4, presence: true, allow_nil: true
+          validates :conditional_5, presence: true, allow_blank: true
+        end
+
+        expect(validation_reflector.attributes).to eq %i(
+          present not_present conditional_1 conditional_2
+          conditional_3 conditional_4 conditional_5)
+
+        expect(validation_reflector.unconditional.attributes).to eq %i(present not_present)
+
+        expect(validation_reflector.presence.attributes).to eq %i(
+          present conditional_1 conditional_2
+          conditional_3 conditional_4 conditional_5)
+
+        expect(validation_reflector.unconditional.presence.attributes).to eq %i(present)
+        expect(validation_reflector.presence.unconditional.attributes).to eq %i(present)
+      end
+
+      specify '#conditions_for_attribute' do
+        Record.instance_eval do
+          validates :present, presence: true
+          validates :not_present, length: { minimum: 1 }
+          validates :conditional_1, presence: true, on: :create
+          validates :conditional_2, presence: true, if: ->{ false }
+          validates :conditional_3, presence: true, unless: ->{ false }
+          validates :conditional_4, presence: true, allow_nil: true
+          validates :conditional_5, presence: true, allow_blank: true
+        end
+
+        expect(validation_reflector.conditions_for_attribute(:missing)).to be_nil
+        expect(validation_reflector.conditions_for_attribute(:present)).to be_nil
+        expect(validation_reflector.conditions_for_attribute(:not_present)).to be_nil
+        expect(validation_reflector.conditions_for_attribute(:conditional_1)).to eq(on: :create)
+        expect(validation_reflector.conditions_for_attribute(:conditional_2).keys).to eq [:if]
+        expect(validation_reflector.conditions_for_attribute(:conditional_3).keys).to eq [:unless]
+        expect(validation_reflector.conditions_for_attribute(:conditional_4)).to eq(allow_nil: true)
+        expect(validation_reflector.conditions_for_attribute(:conditional_5)).to eq(allow_blank: true)
+      end
+    end
+  end
+end

data/spec/lib/schema_expectations/config_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'schema_expectations/config'
+
+module SchemaExpectations
+  describe Config do
+    after do
+      SchemaExpectations.configure do |config|
+        config.reset!
+      end
+    end
+
+    specify 'error_logger' do
+      expect(SchemaExpectations.error_logger).to be_a Logger
+
+      new_logger = Logger.new(StringIO.new)
+      SchemaExpectations.configure do |config|
+        config.error_logger = new_logger
+      end
+      expect(SchemaExpectations.error_logger).to be new_logger
+    end
+  end
+end

data/spec/lib/schema_expectations/rspec_matchers/validate_schema_nullable_spec.rb

@@ -1,106 +1,289 @@
 require 'spec_helper'
 
-describe :validate_schema_nullable do
-  specify 'works on instances', :active_record do
-    create_table :records do |t|
-      t.string :name, null: false
-      t.string :wrong
+describe SchemaExpectations::RSpecMatchers::ValidateSchemaNullableMatcher, :active_record do
+  shared_examples_for 'Record' do
+    def validates(*args)
+      Record.instance_eval do
+        validates *args
+      end
     end
 
-    stub_const('Record', Class.new(ActiveRecord::Base))
+    let(:not_null_columns) { [:not_null] }
+    let(:nullable_columns) { [:nullable] }
+    let(:columns) { not_null_columns + nullable_columns }
 
-    Record.instance_eval do
-      validates :name, :wrong, presence: true
+    before do
+      create_table :records do |t|
+        not_null_columns.each do |column|
+          t.string column, null: false
+        end
+
+        nullable_columns.each do |column|
+          t.string column
+        end
+      end
+
+      stub_const('Record', Class.new(ActiveRecord::Base))
     end
 
-    expect(Record.new).to validate_schema_nullable.only(:name)
-    expect(Record.new).to_not validate_schema_nullable.only(:wrong)
-  end
+    subject(:record) { Record }
+
+    context 'with no validations' do
+      it { is_expected.to_not validate_schema_nullable }
+
+      specify 'error messages' do
+        expect do
+          is_expected.to validate_schema_nullable
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to eq "#{column} is NOT NULL but has no presence validation"
+          end
+        end
+      end
+
+      specify '#only' do
+        is_expected.to_not validate_schema_nullable.only(*columns)
+        is_expected.to_not validate_schema_nullable.only(*not_null_columns)
+        is_expected.to validate_schema_nullable.only(*nullable_columns)
+      end
 
-  specify 'doesnt raise extraneous exceptions from timestamps', :active_record do
-    create_table :records do |t|
-      t.timestamps
+      specify '#except' do
+        is_expected.to validate_schema_nullable.except(*columns)
+        is_expected.to validate_schema_nullable.except(*not_null_columns)
+        is_expected.to_not validate_schema_nullable.except(*nullable_columns)
+      end
     end
 
-    stub_const('Record', Class.new(ActiveRecord::Base))
+    context 'with not_null present' do
+      before { validates :not_null, presence: true }
 
-    expect(Record.new).to validate_schema_nullable
-  end
+      it { is_expected.to validate_schema_nullable }
+
+      specify '#only' do
+        is_expected.to validate_schema_nullable.only(*columns)
+        is_expected.to validate_schema_nullable.only(*not_null_columns)
+        is_expected.to validate_schema_nullable.only(*nullable_columns)
+      end
+
+      specify '#except' do
+        is_expected.to validate_schema_nullable.except(*columns)
+        is_expected.to validate_schema_nullable.except(*not_null_columns)
+        is_expected.to validate_schema_nullable.except(*nullable_columns)
+      end
+    end
+
+    context 'with nullable present' do
+      before { validates :nullable, presence: true }
+
+      it { is_expected.to_not validate_schema_nullable }
+
+      specify 'error messages' do
+        expect do
+          is_expected.to validate_schema_nullable
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          errors = error.message.split(', ')
+
+          nullable_columns.sort.zip(errors.take(nullable_columns.size)) do |column, message|
+            expect(message).to eq "#{column} has unconditional presence validation but is missing NOT NULL"
+          end
+
+          not_null_columns.sort.zip(errors.drop(nullable_columns.size)) do |column, message|
+            expect(message).to eq "#{column} is NOT NULL but has no presence validation"
+          end
+        end
+      end
+
+      specify '#only' do
+        is_expected.to_not validate_schema_nullable.only(*columns)
+        is_expected.to_not validate_schema_nullable.only(*not_null_columns)
+        is_expected.to_not validate_schema_nullable.only(*nullable_columns)
+      end
+
+      specify '#except' do
+        is_expected.to validate_schema_nullable.except(*columns)
+        is_expected.to_not validate_schema_nullable.except(*not_null_columns)
+        is_expected.to_not validate_schema_nullable.except(*nullable_columns)
+      end
+    end
+
+    context 'with nullable and not_null present' do
+      before do
+        validates :not_null, presence: true
+        validates :nullable, presence: true
+      end
+
+      it { is_expected.to_not validate_schema_nullable }
+
+      specify 'error messages' do
+        expect do
+          is_expected.to validate_schema_nullable
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          nullable_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to eq "#{column} has unconditional presence validation but is missing NOT NULL"
+          end
+        end
+      end
+
+      specify '#only' do
+        is_expected.to_not validate_schema_nullable.only(*columns)
+        is_expected.to validate_schema_nullable.only(*not_null_columns)
+        is_expected.to_not validate_schema_nullable.only(*nullable_columns)
+      end
+
+      specify '#except' do
+        is_expected.to validate_schema_nullable.except(*columns)
+        is_expected.to_not validate_schema_nullable.except(*not_null_columns)
+        is_expected.to validate_schema_nullable.except(*nullable_columns)
+      end
+    end
+
+    specify '#failure_message_when_negated' do
+      validates :not_null, presence: true
+
+      expect do
+        is_expected.to_not validate_schema_nullable
+      end.to raise_error 'should not match NOT NULL with its presence validation but does'
+    end
+
+    specify 'when primary_key is not id' do
+      create_table :records, force: true, id: false do |t|
+        t.integer :pk
+      end
+      Record.reset_column_information
+      Record.instance_eval do
+        self.primary_key = 'pk'
 
-  specify 'asserts that presence validations match NOT NULL', :active_record do
-    create_table :records do |t|
-      t.string :not_null, null: false
-      t.string :not_null_present, null: false
+        validates :pk, presence: true
+      end
 
-      t.string :nullable
-      t.string :nullable_present
+      is_expected.to validate_schema_nullable
     end
 
-    stub_const('Record', Class.new(ActiveRecord::Base))
+    specify 'doesnt raise extraneous exceptions from timestamps' do
+      create_table :records, force: true do |t|
+        t.timestamps null: false
+      end
+      Record.reset_column_information
 
-    Record.instance_eval do
-      validates :not_null_present, presence: true
-      validates :nullable_present, presence: true
+      is_expected.to validate_schema_nullable
     end
 
-    expect(Record).to validate_schema_nullable.only(:not_null_present, :nullable)
-    expect(Record).to validate_schema_nullable.except(:not_null, :nullable_present)
+    context 'ignores validators with' do
+      specify 'on: create' do
+        validates :not_null, presence: true, on: :create
+
+        expect do
+          is_expected.to validate_schema_nullable.only(*not_null_columns)
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to eq "#{column} is NOT NULL but its presence validator was conditional: {:on=>:create}"
+          end
+        end
+      end
 
-    expect(Record).to_not validate_schema_nullable
-    expect(Record).to_not validate_schema_nullable.only(:not_null)
-    expect(Record).to_not validate_schema_nullable.only(:nullable_present)
+      specify 'if: proc' do
+        validates :not_null, presence: true, if: ->{ false }
 
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null)
-    end.to raise_error 'not_null is NOT NULL but has no presence validation'
+        expect do
+          is_expected.to validate_schema_nullable.only(*not_null_columns)
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to match /\A#{column} is NOT NULL but its presence validator was conditional: {:if=>\#<Proc:.*>}\z/
+          end
+        end
+      end
 
-    expect do
-      expect(Record).to validate_schema_nullable.only(:nullable_present)
-    end.to raise_error 'nullable_present has unconditional presence validation but is missing NOT NULL'
+      specify 'unless: proc' do
+        validates :not_null, presence: true, unless: ->{ true }
 
-    Record.instance_eval do
-      clear_validators!
-      validates :not_null_present, presence: true, on: :create
+        expect do
+          is_expected.to validate_schema_nullable.only(*not_null_columns)
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to match /\A#{column} is NOT NULL but its presence validator was conditional: {:unless=>\#<Proc:.*>}\z/
+          end
+        end
+      end
+
+      specify 'allow_nil: true' do
+        validates :not_null, presence: true, allow_nil: true
+
+        expect do
+          is_expected.to validate_schema_nullable.only(*not_null_columns)
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to eq "#{column} is NOT NULL but its presence validator was conditional: {:allow_nil=>true}"
+          end
+        end
+      end
+
+      specify 'allow_blank: true' do
+        validates :not_null, presence: true, allow_blank: true
+
+        expect do
+          is_expected.to validate_schema_nullable.only(*not_null_columns)
+        end.to raise_error do |error|
+          expect(error).to be_a RSpec::Expectations::ExpectationNotMetError
+          not_null_columns.sort.zip(error.message.split(', ')) do |column, message|
+            expect(message).to eq "#{column} is NOT NULL but its presence validator was conditional: {:allow_blank=>true}"
+          end
+        end
+      end
     end
-    expect(Record).to_not validate_schema_nullable.only(:not_null_present)
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null_present)
-    end.to raise_error 'not_null_present is NOT NULL but its presence validator was conditional: {:on=>:create}'
-
-    Record.instance_eval do
-      clear_validators!
-      validates :not_null_present, presence: true, if: ->{ false }
+  end
+
+  context 'called on class' do
+    include_examples 'Record' do
+      subject(:record) { Record }
     end
-    expect(Record).to_not validate_schema_nullable.only(:not_null_present)
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null_present)
-    end.to raise_error /\Anot_null_present is NOT NULL but its presence validator was conditional: {:if=>\#<Proc:.*>}\z/
-
-    Record.instance_eval do
-      clear_validators!
-      validates :not_null_present, presence: true, unless: ->{ true }
+  end
+
+  context 'called on instance' do
+    include_examples 'Record' do
+      subject(:record) { Record.new }
     end
-    expect(Record).to_not validate_schema_nullable.only(:not_null_present)
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null_present)
-    end.to raise_error /\Anot_null_present is NOT NULL but its presence validator was conditional: {:unless=>\#<Proc:.*>}\z/
-
-    Record.instance_eval do
-      clear_validators!
-      validates :not_null_present, presence: true, allow_nil: true
+  end
+
+  specify 'called on unrecognized object' do
+    expect { expect(double('object')).to validate_schema_nullable }.
+      to raise_error /#<RSpec::Mocks::Double:0x\h* @name="object"> does not inherit from ActiveRecord::Base/
+  end
+
+  context 'with belongs_to associations' do
+    include_examples 'Record' do
+      let(:not_null_columns) { [:not_null_id] }
+      let(:nullable_columns) { [:nullable_id] }
+
+      before do
+        create_table :other_records
+        stub_const('OtherRecord', Class.new(ActiveRecord::Base))
+
+        Record.instance_eval do
+          belongs_to :not_null, class_name: 'OtherRecord', foreign_key: :not_null_id
+          belongs_to :nullable, class_name: 'OtherRecord', foreign_key: :nullable_id
+        end
+      end
     end
-    expect(Record).to_not validate_schema_nullable.only(:not_null_present)
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null_present)
-    end.to raise_error 'not_null_present is NOT NULL but its presence validator was conditional: {:allow_nil=>true}'
-
-    Record.instance_eval do
-      clear_validators!
-      validates :not_null_present, presence: true, allow_blank: true
+  end
+
+  context 'with polymorphic belongs_to associations' do
+    include_examples 'Record' do
+      let(:not_null_columns) { [:not_null_id, :not_null_type] }
+      let(:nullable_columns) { [:nullable_id, :nullable_type] }
+
+      before do
+        Record.instance_eval do
+          belongs_to :not_null, polymorphic: true, foreign_key: :not_null_id, foreign_type: :not_null_type
+          belongs_to :nullable, polymorphic: true, foreign_key: :nullable_id, foreign_type: :nullable_type
+        end
+      end
     end
-    expect(Record).to_not validate_schema_nullable.only(:not_null_present)
-    expect do
-      expect(Record).to validate_schema_nullable.only(:not_null_present)
-    end.to raise_error 'not_null_present is NOT NULL but its presence validator was conditional: {:allow_blank=>true}'
   end
 end

data/spec/lib/schema_expectations/util_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'schema_expectations/util'
+
+module SchemaExpectations
+  describe SchemaExpectations::Util do
+    specify '.slice_hash' do
+      expect(Util.slice_hash({}, :key)).to eq({})
+      expect(Util.slice_hash({ key: :value }, :key)).to eq(key: :value)
+      expect(Util.slice_hash({ other: :value }, :key)).to eq({})
+      expect(Util.slice_hash({
+        key_1: :value_1,
+        key_2: :value_2,
+        other: :value_3 }, :key_1, :key_2)).to eq(key_1: :value_1, key_2: :value_2)
+    end
+  end
+end

data/spec/meta_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe SchemaExpectations do
+  specify 'Appraisals and .travis.yml are synced' do
+    env_bundle_gemfile = ENV['BUNDLE_GEMFILE']
+    ENV.delete 'BUNDLE_GEMFILE'
+
+    require 'appraisal'
+    require 'yaml'
+
+    travis_file = File.expand_path('../../.travis.yml', __FILE__)
+    travis_config = YAML.load(File.read(travis_file))
+
+    Appraisal::File.each do |appraisal|
+      error_message = "Appraisal #{appraisal.name} is out of sync. Run `rake refresh`"
+      expect(File.file?(appraisal.gemfile_path)).to be_truthy, error_message
+      expect(File.read(appraisal.gemfile_path)).to include(appraisal.gemfile.to_s), error_message
+      expect(travis_config['gemfile']).to be_a(Array), error_message
+      expect(travis_config['gemfile']).to include("gemfiles/#{File.basename(appraisal.gemfile_path)}"), error_message
+    end
+
+    ENV['BUNDLE_GEMFILE'] = env_bundle_gemfile
+  end
+
+  specify 'binding.pry is not committed' do
+    bindings = `git grep binding.pry`.split("\n")
+    bindings.reject! do |binding|
+      binding.start_with? 'spec/meta_spec.rb:'
+    end
+    expect(bindings).to be_empty
+  end
+
+  specify 'tests connect to postgresql', :active_record, :postgresql do
+    expect(ActiveRecord::Base.connection_config[:adapter]).to eq 'postgresql'
+  end
+
+  specify 'tests connect to sqlite3', :active_record, :sqlite3 do
+    expect(ActiveRecord::Base.connection_config[:adapter]).to eq 'sqlite3'
+  end
+
+  specify 'tests connect to mysql2', :active_record, :mysql2 do
+    expect(ActiveRecord::Base.connection_config[:adapter]).to eq 'mysql2'
+  end
+end