activerecord_mysql_strict 0.2 → 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7d2ab7d2a8b48a070e7ba2bf8f3301754325e69b
+  data.tar.gz: 05c68f36aa4d65ebea6323752cc8e8c98b525247
+SHA512:
+  metadata.gz: b3a1af02f69c83b3e0a6e171360b7d425306cb908b0d9c4ee585a2823c9fc58cf81d16287253d87e4f8c7d1c023a70b85aa56c6757845c77f5698d4e392fa005
+  data.tar.gz: c2165ac3947567b7c9bb6e679b3b17fed31a312bd18a0cf3e196f02b67e96bd097b84475700fb1aacad570f76f57a395f3d92280a8c65a721b0a6d26340e6b42

data/README.md

@@ -1,6 +1,7 @@
 # ActiveRecord::MySQL::Strict
 
 [![Gem Version](https://badge.fury.io/rb/activerecord_mysql_strict.png)](https://rubygems.org/gems/activerecord_mysql_strict)
+[![Code Climate](https://codeclimate.com/github/mirego/activerecord_mysql_strict.png)](https://codeclimate.com/github/mirego/activerecord_mysql_strict)
 [![Build Status](https://travis-ci.org/mirego/activerecord_mysql_strict.png?branch=master)](https://travis-ci.org/mirego/activerecord_mysql_strict)
 
 `ActiveRecord::MySQL::Strict` adds validations to ActiveRecord models to make sure they do not trigger errors in MySQL strict mode.

data/lib/active_record/mysql/strict/validation.rb

@@ -0,0 +1,25 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      class Validation < Struct.new(:model, :field)
+        # Inject validations into an ActiveRecord model
+        def self.inject_validations(model, options = {})
+          except = options[:except] || []
+          model_columns = model.columns.dup.reject { |c| except.include?(c.name.to_sym) }
+
+          if only = options[:only]
+            model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
+          end
+
+          model_columns.each do |field|
+            validation = "#{field.type.to_s.camelize}Validation"
+
+            if ActiveRecord::MySQL::Strict::Validation.const_defined?(validation)
+              "ActiveRecord::MySQL::Strict::Validation::#{validation}".constantize.new(model, field).apply
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/validation/integer_validation.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      class Validation
+        class IntegerValidation < Validation
+          UPPER_LIMIT = 2147483647
+          LOWER_LIMIT = -2147483647
+
+          def apply
+            model.validates field.name, numericality: { greather_than_or_equal_to: LOWER_LIMIT, less_than_or_equal_to: UPPER_LIMIT }, allow_blank: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/validation/string_validation.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      class Validation
+        class StringValidation < Validation
+          LIMIT = 255
+
+          def apply
+            model.validates field.name, 'ActiveRecord::MySQL::Strict::Validator::StrictLength' => { in: 0..(field.limit || LIMIT) }, allow_blank: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/validation/text_validation.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      class Validation
+        class TextValidation < Validation
+          LIMIT = 65535
+
+          def apply
+            model.validates field.name, 'ActiveRecord::MySQL::Strict::Validator::StrictLength' => { in: 0..(field.limit || LIMIT) }, allow_blank: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/validator/strict_length_validator.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module MySQL
+    module Strict
+      module Validator
+        class StrictLengthValidator < ActiveModel::Validations::LengthValidator
+          def validate_each(record, attribute, value)
+            value = record.send(:read_attribute, attribute)
+            value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+            errors_options = options.except(*RESERVED_OPTIONS)
+
+            CHECKS.each do |key, validity_check|
+              next unless check_value = options[key]
+
+              if !value.nil? || skip_nil_check?(key)
+                next if value_length.send(validity_check, check_value)
+              end
+
+              errors_options[:count] = check_value
+
+              default_message = options[MESSAGES[key]]
+              errors_options[:message] ||= default_message if default_message
+
+              record.errors.add(attribute, MESSAGES[key], errors_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/mysql/strict/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module MySQL
     module Strict
-      VERSION = '0.2'
+      VERSION = '0.2.1'
     end
   end
 end

data/lib/activerecord_mysql_strict.rb

@@ -4,11 +4,19 @@ require 'active_record'
 require 'active_model'
 require 'active_support'
 
-require 'active_record/mysql/strict/strict_length_validator'
-require 'active_record/mysql/strict/validations'
+# Validators
+require 'active_record/mysql/strict/validator/strict_length_validator'
+
+# Validations
+require 'active_record/mysql/strict/validation'
+require 'active_record/mysql/strict/validation/string_validation'
+require 'active_record/mysql/strict/validation/text_validation'
+require 'active_record/mysql/strict/validation/integer_validation'
 
 class ActiveRecord::Base
   def self.validates_strict_columns(options = {})
-    ActiveRecord::MySQL::Strict::Validations.define_mysql_strict_validations(self, options)
+    if table_exists?
+      ActiveRecord::MySQL::Strict::Validation.inject_validations(self, options)
+    end
   end
 end

data/spec/activerecord_mysql_strict/validation/integer_validation_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ActiveRecord::MySQL::Strict::Validation::IntegerValidation do
+  describe :apply do
+    context 'for model without other validations' do
+      let(:model) { strict_model 'User' }
+
+      context 'with field with default limit' do
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.integer :number }
+          end
+        end
+
+        context 'with field value exceeding limit' do
+          subject { model.new(number: 9999999999) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value not exceeding limit' do
+          subject { model.new(number: 2147483647) }
+          it { should be_valid }
+        end
+      end
+    end
+  end
+end

data/spec/activerecord_mysql_strict/validation/string_validation_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe ActiveRecord::MySQL::Strict::Validation::StringValidation do
+  describe :apply do
+    context 'for model without other validations' do
+      let(:model) { strict_model 'User' }
+
+      context 'with field with default limit' do
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.string :name }
+          end
+        end
+
+        context 'with field value exceeding limit' do
+          subject { model.new(name: '*' * 400) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value not exceeding limit' do
+          subject { model.new(name: '*' * 100) }
+          it { should be_valid }
+        end
+      end
+
+      context 'with field with custom limit' do
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.string :name, limit: 128 }
+          end
+        end
+
+        context 'with field value exceeding default limit' do
+          subject { model.new(name: '*' * 400) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value exceeding custom limit' do
+          subject { model.new(name: '*' * 140) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value not exceeding custom limit' do
+          subject { model.new(name: '*' * 120) }
+          it { should be_valid }
+        end
+      end
+    end
+
+    context 'for model with related validations' do
+      context 'for presence validation' do
+        let(:model) do
+          strict_model('User') { validates :name, presence: true }
+        end
+
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.string :name }
+          end
+        end
+
+        subject { model.new.tap(&:valid?) }
+        it { expect(subject.errors.full_messages).to eql ["Name can't be blank"] }
+      end
+    end
+
+    context 'for valid model with accessor that returns an invalid string' do
+      let(:model) do
+        strict_model 'User' do
+          attr_reader :long_name
+
+          # When we call `#long_name` it will return an invalid string but
+          # we want the attribute to store the real, valid value because we
+          # want to actually make sure that the real attribute value does
+          # not exceed the limit, not what the accessor returns.
+          define_method :long_name= do |value|
+            @long_name = '*' * 400
+            write_attribute(:long_name, value)
+          end
+        end
+      end
+
+      before do
+        run_migration do
+          create_table(:users, force: true) { |t| t.string :long_name }
+        end
+      end
+
+      subject { model.new(long_name: '*' * 10) }
+      its(:long_name) { should eql '*' * 400 }
+      it { should be_valid }
+    end
+
+    context 'for invalid model with accessor that returns a valid string' do
+      let(:model) do
+        strict_model 'User' do
+          attr_reader :short_name
+
+          # When we call `#short_name` it will return a valid string but
+          # we want the attribute to store the real, valid value because we
+          # want to actually make sure that the real attribute value does
+          # exceed the limit, not what the accessor returns.
+          define_method :short_name= do |value|
+            @short_name = '*' * 100
+            write_attribute(:short_name, value)
+          end
+        end
+      end
+
+      before do
+        run_migration do
+          create_table(:users, force: true) { |t| t.string :short_name }
+        end
+      end
+
+      subject { model.new(short_name: '*' * 400) }
+      its(:short_name) { should eql '*' * 100 }
+      it { should_not be_valid }
+    end
+  end
+end

data/spec/activerecord_mysql_strict/validation/text_validation_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe ActiveRecord::MySQL::Strict::Validation::TextValidation do
+  describe :apply do
+    context 'for model without other validations' do
+      let(:model) { strict_model 'User' }
+
+      context 'with field with default limit' do
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.text :bio }
+          end
+        end
+
+        context 'with field value exceeding limit' do
+          subject { model.new(bio: '*' * 70000) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value not exceeding limit' do
+          subject { model.new(bio: '*' * 4000) }
+          it { should be_valid }
+        end
+      end
+
+      context 'with field with custom limit' do
+        before do
+          run_migration do
+            create_table(:users, force: true) { |t| t.text :bio, limit: 10000 }
+          end
+        end
+
+        context 'with field value exceeding default limit' do
+          subject { model.new(bio: '*' * 70000) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value exceeding custom limit' do
+          subject { model.new(bio: '*' * 12000) }
+          it { should_not be_valid }
+        end
+
+        context 'with field value not exceeding custom limit' do
+          subject { model.new(bio: '*' * 4000) }
+          it { should be_valid }
+        end
+      end
+    end
+  end
+end

data/spec/activerecord_mysql_strict/validation_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ActiveRecord::MySQL::Strict::Validation do
+  describe :inject_validations do
+    pending 'Test for :except and :only options'
+  end
+end

data/spec/activerecord_mysql_strict_spec.rb

@@ -11,7 +11,7 @@ describe ActiveRecord::MySQL::Strict do
 
     context 'without options' do
       before do
-        expect(ActiveRecord::MySQL::Strict::Validations).to receive(:define_mysql_strict_validations).with(User, {})
+        expect(ActiveRecord::MySQL::Strict::Validation).to receive(:inject_validations).with(User, {})
       end
 
       it { User.validates_strict_columns }
@@ -19,7 +19,7 @@ describe ActiveRecord::MySQL::Strict do
 
     context 'with options' do
       before do
-        expect(ActiveRecord::MySQL::Strict::Validations).to receive(:define_mysql_strict_validations).with(User, { except: [:bar], only: [:foo] })
+        expect(ActiveRecord::MySQL::Strict::Validation).to receive(:inject_validations).with(User, { except: [:bar], only: [:foo] })
       end
 
       it { User.validates_strict_columns except: [:bar], only: [:foo] }

metadata

@@ -1,68 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: activerecord_mysql_strict
 version: !ruby/object:Gem::Version
-  version: '0.2'
-  prerelease: 
+  version: 0.2.1
 platform: ruby
 authors:
 - Rémi Prévost
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-06 00:00:00.000000000 Z
+date: 2013-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -70,7 +62,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -78,7 +69,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -86,7 +76,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -94,33 +83,29 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: ActiveRecord::MySQL::Strict adds validations to ActiveRecord models to
@@ -140,11 +125,17 @@ files:
 - activerecord_mysql_strict.gemspec
 - gemfiles/Gemfile.activerecord-3.2.x
 - gemfiles/Gemfile.activerecord-4.0
-- lib/active_record/mysql/strict/strict_length_validator.rb
-- lib/active_record/mysql/strict/validations.rb
+- lib/active_record/mysql/strict/validation.rb
+- lib/active_record/mysql/strict/validation/integer_validation.rb
+- lib/active_record/mysql/strict/validation/string_validation.rb
+- lib/active_record/mysql/strict/validation/text_validation.rb
+- lib/active_record/mysql/strict/validator/strict_length_validator.rb
 - lib/active_record/mysql/strict/version.rb
 - lib/activerecord_mysql_strict.rb
-- spec/activerecord_mysql_strict/validations_spec.rb
+- spec/activerecord_mysql_strict/validation/integer_validation_spec.rb
+- spec/activerecord_mysql_strict/validation/string_validation_spec.rb
+- spec/activerecord_mysql_strict/validation/text_validation_spec.rb
+- spec/activerecord_mysql_strict/validation_spec.rb
 - spec/activerecord_mysql_strict_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb
@@ -152,37 +143,33 @@ files:
 homepage: https://github.com/mirego/activerecord_mysql_strict
 licenses:
 - BSD 3-Clause
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2194545616864898002
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2194545616864898002
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: ActiveRecord::MySQL::Strict adds validations to ActiveRecord models to make
   sure they do not trigger errors in MySQL strict mode.
 test_files:
-- spec/activerecord_mysql_strict/validations_spec.rb
+- spec/activerecord_mysql_strict/validation/integer_validation_spec.rb
+- spec/activerecord_mysql_strict/validation/string_validation_spec.rb
+- spec/activerecord_mysql_strict/validation/text_validation_spec.rb
+- spec/activerecord_mysql_strict/validation_spec.rb
 - spec/activerecord_mysql_strict_spec.rb
 - spec/spec_helper.rb
 - spec/support/macros/database_macros.rb

data/lib/active_record/mysql/strict/strict_length_validator.rb

@@ -1,28 +0,0 @@
-module ActiveRecord
-  module MySQL
-    module Strict
-      class StrictLengthValidator < ActiveModel::Validations::LengthValidator
-        def validate_each(record, attribute, value)
-          value = record.send(:read_attribute, attribute)
-          value_length = value.respond_to?(:length) ? value.length : value.to_s.length
-          errors_options = options.except(*RESERVED_OPTIONS)
-
-          CHECKS.each do |key, validity_check|
-            next unless check_value = options[key]
-
-            if !value.nil? || skip_nil_check?(key)
-              next if value_length.send(validity_check, check_value)
-            end
-
-            errors_options[:count] = check_value
-
-            default_message = options[MESSAGES[key]]
-            errors_options[:message] ||= default_message if default_message
-
-            record.errors.add(attribute, MESSAGES[key], errors_options)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_record/mysql/strict/validations.rb

@@ -1,40 +0,0 @@
-module ActiveRecord
-  module MySQL
-    module Strict
-      module Validations
-        # Constants
-        MYSQL_STRICT_STRING_LIMIT = 255
-        MYSQL_STRICT_TEXT_LIMIT = 65535
-        MYSQL_STRICT_INTEGER_LIMIT = 2147483647
-
-        def self.define_mysql_strict_validations(klass, options = {})
-          except = options[:except] || []
-          model_columns = klass.columns.dup.reject { |c| except.include?(c.name.to_sym) }
-
-          if only = options[:only]
-            model_columns = model_columns.select { |c| only.include?(c.name.to_sym) }
-          end
-
-          model_columns.each do |field|
-            method = :"define_mysql_strict_#{field.type}_validation"
-            Validations.send(method, klass, field) if Validations.respond_to?(method)
-          end
-        end
-
-      protected
-
-        def self.define_mysql_strict_string_validation(klass, field)
-          klass.validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_STRING_LIMIT) }, allow_blank: true
-        end
-
-        def self.define_mysql_strict_text_validation(klass, field)
-          klass.validates field.name, 'ActiveRecord::MySQL::Strict::StrictLength' => { in: 0..(field.limit || MYSQL_STRICT_TEXT_LIMIT) }, allow_blank: true
-        end
-
-        def self.define_mysql_strict_integer_validation(klass, field)
-          klass.validates field.name, numericality: { greather_than_or_equal_to: -MYSQL_STRICT_INTEGER_LIMIT, less_than_or_equal_to: MYSQL_STRICT_INTEGER_LIMIT }, allow_blank: true
-        end
-      end
-    end
-  end
-end

data/spec/activerecord_mysql_strict/validations_spec.rb

@@ -1,186 +0,0 @@
-require 'spec_helper'
-
-describe ActiveRecord::MySQL::Strict::Validations do
-  describe :define_mysql_strict_validations do
-    context 'for model without other validations' do
-      let(:model) { strict_model 'User' }
-
-      context 'for `string` columns' do
-        context 'with field with default limit' do
-          before do
-            run_migration do
-              create_table(:users, force: true) { |t| t.string :name }
-            end
-          end
-
-          context 'with field value exceeding limit' do
-            subject { model.new(name: '*' * 400) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value not exceeding limit' do
-            subject { model.new(name: '*' * 100) }
-            it { should be_valid }
-          end
-        end
-
-        context 'with field with custom limit' do
-          before do
-            run_migration do
-              create_table(:users, force: true) { |t| t.string :name, limit: 128 }
-            end
-          end
-
-          context 'with field value exceeding default limit' do
-            subject { model.new(name: '*' * 400) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value exceeding custom limit' do
-            subject { model.new(name: '*' * 140) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value not exceeding custom limit' do
-            subject { model.new(name: '*' * 120) }
-            it { should be_valid }
-          end
-        end
-      end
-
-      context 'for `text` columns' do
-        context 'with field with default limit' do
-          before do
-            run_migration do
-              create_table(:users, force: true) { |t| t.text :bio }
-            end
-          end
-
-          context 'with field value exceeding limit' do
-            subject { model.new(bio: '*' * 70000) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value not exceeding limit' do
-            subject { model.new(bio: '*' * 4000) }
-            it { should be_valid }
-          end
-        end
-
-        context 'with field with custom limit' do
-          before do
-            run_migration do
-              create_table(:users, force: true) { |t| t.text :bio, limit: 10000 }
-            end
-          end
-
-          context 'with field value exceeding default limit' do
-            subject { model.new(bio: '*' * 70000) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value exceeding custom limit' do
-            subject { model.new(bio: '*' * 12000) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value not exceeding custom limit' do
-            subject { model.new(bio: '*' * 4000) }
-            it { should be_valid }
-          end
-        end
-      end
-
-      context 'for `integer` columns' do
-        context 'with field with default limit' do
-          before do
-            run_migration do
-              create_table(:users, force: true) { |t| t.integer :number }
-            end
-          end
-
-          context 'with field value exceeding limit' do
-            subject { model.new(number: 9999999999) }
-            it { should_not be_valid }
-          end
-
-          context 'with field value not exceeding limit' do
-            subject { model.new(number: 2147483647) }
-            it { should be_valid }
-          end
-        end
-      end
-    end
-
-    context 'for model with related validations' do
-      context 'for presence validation' do
-        let(:model) do
-          strict_model('User') { validates :name, presence: true }
-        end
-
-        before do
-          run_migration do
-            create_table(:users, force: true) { |t| t.string :name }
-          end
-        end
-
-        subject { model.new.tap(&:valid?) }
-        it { expect(subject.errors.full_messages).to eql ["Name can't be blank"] }
-      end
-    end
-
-    context 'for valid model with accessor that returns an invalid string' do
-      let(:model) do
-        strict_model 'User' do
-          attr_reader :long_name
-
-          # When we call `#long_name` it will return an invalid string but
-          # we want the attribute to store the real, valid value because we
-          # want to actually make sure that the real attribute value does
-          # not exceed the limit, not what the accessor returns.
-          define_method :long_name= do |value|
-            @long_name = '*' * 400
-            write_attribute(:long_name, value)
-          end
-        end
-      end
-
-      before do
-        run_migration do
-          create_table(:users, force: true) { |t| t.string :long_name }
-        end
-      end
-
-      subject { model.new(long_name: '*' * 10) }
-      its(:long_name) { should eql '*' * 400 }
-      it { should be_valid }
-    end
-
-    context 'for invalid model with accessor that returns a valid string' do
-      let(:model) do
-        strict_model 'User' do
-          attr_reader :short_name
-
-          # When we call `#short_name` it will return a valid string but
-          # we want the attribute to store the real, valid value because we
-          # want to actually make sure that the real attribute value does
-          # exceed the limit, not what the accessor returns.
-          define_method :short_name= do |value|
-            @short_name = '*' * 100
-            write_attribute(:short_name, value)
-          end
-        end
-      end
-
-      before do
-        run_migration do
-          create_table(:users, force: true) { |t| t.string :short_name }
-        end
-      end
-
-      subject { model.new(short_name: '*' * 400) }
-      its(:short_name) { should eql '*' * 100 }
-      it { should_not be_valid }
-    end
-  end
-end