validates_type 0.0.1

data/spec/active_model/types_spec.rb

@@ -0,0 +1,217 @@
+require_relative '../spec_helper'
+
+describe 'ValidatesType' do
+  context 'supported types' do
+    before do
+      subject.attribute = value
+    end
+
+    describe 'String' do
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:string) }
+
+      context 'field value is a String' do
+        let(:value) { 'some string' }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not a String' do
+        let(:value) { -1 }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a String and is not/)
+        end
+      end
+    end
+
+    describe 'Integer' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:integer) }
+
+      context 'field value is an Integer' do
+        let(:value) { 20 }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not an Integer' do
+        let(:value) { {} }
+
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Integer and is not/)
+        end
+      end
+    end
+
+    describe 'Float' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:float) }
+
+      context 'field value is a Float' do
+        let(:value) { 1.2 }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not a Float' do
+        let(:value) { 10 }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Float and is not/)
+        end
+      end
+    end
+
+    describe 'Boolean' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:boolean) }
+
+      context 'field value is a Boolean' do
+        let(:value) { true }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not a Boolean' do
+        let(:value) { 'true' }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Boolean and is not/)
+        end
+      end
+    end
+
+    describe 'Hash' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:hash) }
+
+      context 'field value is a Hash' do
+        let(:value) { {} }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not a Hash' do
+        let(:value) { [] }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Hash and is not/)
+        end
+      end
+    end
+
+    describe 'Array' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:array) }
+
+      context 'field value is an Array' do
+        let(:value) { [] }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not an Array' do
+        let(:value) { true }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Array and is not/)
+        end
+      end
+    end
+
+    describe 'Symbol' do
+
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:symbol) }
+
+      context 'field value is a Symbol' do
+        let(:value) { :foo }
+
+        specify do
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'field value is not a Symbol' do
+        let(:value) { [] }
+        specify do
+          expect(subject).to_not be_valid
+        end
+
+        specify do
+          subject.validate
+          expect(subject.errors).to_not be_empty
+          expect(subject.errors.messages[:attribute][0]).to match(/is expected to be a Symbol and is not/)
+        end
+      end
+    end
+
+    context 'passing in a custom message' do
+      subject { ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:string, message: 'is not a String!') }
+
+      context 'when validation fails' do
+        let(:value) { 1 }
+
+        specify do
+          subject.validate
+          expect(subject.errors.messages[:attribute][0]).to match(/is not a String!/)
+        end
+      end
+    end
+  end
+
+  context 'unsupported types' do
+    describe 'Foo' do
+      specify do
+        expect do
+          subject = ActiveModel::TypeValidationTestClass.set_accessor_and_long_validator(:foo)
+          subject.valid?
+        end.to raise_error(
+          ValidatesType::UnsupportedType,
+          "Unsupported type Foo given for validates_type.")
+      end
+    end
+  end
+end

data/spec/active_model_helper.rb

@@ -0,0 +1,47 @@
+module ActiveModel
+  class TypeValidationTestClass
+    include Validations
+
+    # Creates and returns a new instance of TypeValidationTestClass with
+    # a "long" style validator:
+    #
+    # class TypeValidationTestClass
+    #   attr_accessor :attribute
+    #
+    #   validates_type :attribute, :string
+    # end
+    #
+    # @set_accessor_and_long_validator
+    #   param: type <Symbol> - type which to validate against
+    #   param: options<Hash *Optional*> - extra modifiers/custom messaging
+    #   return: TypeValidationTestClass instance with set validator
+    def self.set_accessor_and_long_validator(type, options = {})
+      self.new.tap do |test_class|
+        test_class._validators = {}
+        test_class.class_eval { attr_accessor :attribute }
+        test_class.class_eval { validates_type :attribute, type.to_sym, options }
+      end
+    end
+
+    # Creates and returns a new instance of TypeValidationTestClass with
+    # a "short" style validator:
+    #
+    # class TypeValidationTestClass
+    #   attr_accessor :attribute
+    #
+    #   validates :attribute, type: { type: :string }
+    # end
+    #
+    # @set_accessor_and_long_validator
+    #   param: type <Symbol> - type which to validate against
+    #   param: options<Hash *Optional*> - extra modifiers/custom messaging
+    #   return: TypeValidationTestClass instance with set validator
+    def self.set_accessor_and_validator(type, options = {})
+      self.new.tap do |test_class|
+        test_class._validators = {}
+        test_class.class_eval { attr_accessor :attribute }
+        test_class.class_eval { validates :attribute, type: { type: type }.merge(options) }
+      end
+    end
+  end
+end

data/spec/active_record_helper.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Base.establish_connection(
+    "adapter"   => "sqlite3",
+    "database"  => ":memory:"
+)
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define do
+  create_table :type_validation_tests do |t|
+    t.string :test_attribute
+  end
+end
+
+def drop_and_create_column_with_type(column_type)
+  ActiveRecord::Schema.define do
+    change_column :type_validation_tests, :test_attribute, column_type.to_sym
+  end
+end
+
+class TypeValidationTest < ActiveRecord::Base
+  def self.set_accessor_and_long_validator(type, options = {})
+    self.new.tap do |test_class|
+      test_class._validators = {}
+      test_class.class_eval { validates_type :test_attribute, type.to_sym, options }
+    end
+  end
+
+  def self.set_accessor_and_validator(type, options = {})
+    self.new.tap do |test_class|
+      test_class._validators = {}
+      test_class.class_eval { validates :test_attribute, type: { type: type }.merge(options) }
+    end
+  end
+end

data/spec/activerecord/base_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../spec_helper'
+
+describe 'ValidatesType' do
+  context 'validates_type :attribute' do
+    subject { TypeValidationTest.set_accessor_and_long_validator(:string) }
+
+    it 'adds a validator to the subject' do
+      klass = subject.class
+      expect(klass.validators).to_not be_empty
+      expect(klass.validators).to include(ActiveModel::Validations::TypeValidator)
+    end
+
+    it 'adds the correct validator to the subject' do
+      validator = subject.class.validators.find { |v| v.is_a?(ActiveModel::Validations::TypeValidator) }
+      expect(validator.options[:type]).to eq(:string)
+    end
+  end
+
+  context 'validates :attribute, type: { type: type }.merge(other_options)' do
+    subject { TypeValidationTest.set_accessor_and_validator(:string) }
+
+    it 'adds a validator to the subject' do
+      klass = subject.class
+      expect(klass.validators).to_not be_empty
+      expect(klass.validators).to include(ActiveModel::Validations::TypeValidator)
+    end
+
+    it 'adds the correct validator to the subject' do
+      validator = subject.class.validators.find { |v| v.is_a?(ActiveModel::Validations::TypeValidator) }
+      expect(validator.options[:type]).to eq(:string)
+    end
+  end
+end

data/spec/activerecord/modifiers_spec.rb

@@ -0,0 +1,319 @@
+require_relative '../spec_helper'
+
+describe 'ValidatesType' do
+  %i[set_accessor_and_long_validator
+     set_accessor_and_validator].each do |validate_version|
+    context "#{ validate_version }" do
+      context 'custom modifiers' do
+        before do
+          subject.test_attribute = value
+        end
+
+        describe 'message' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, message: 'is not a String!')
+          end
+
+          context 'when validation fails' do
+            let(:value) { 1 }
+
+            specify do
+              subject.validate
+              expect(subject.errors.messages[:test_attribute][0]).to match(/is not a String!/)
+            end
+          end
+        end
+
+        describe 'allow_nil' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, allow_nil: true)
+          end
+
+          context 'field value is nil' do
+            let(:value) { nil }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is not nil' do
+            context 'field value is the specified type' do
+              let(:value) { 'I am a string'}
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not specified type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'allow_blank' do
+           subject do
+            TypeValidationTest.send(validate_version,
+              :integer, allow_blank: true)
+            end
+
+          context 'field value is nil' do
+            let(:value) { nil }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is an empty string' do
+            let(:value) { '' }
+
+            specify do
+              expect(subject).to be_valid
+            end
+          end
+
+          context 'field value is not nil' do
+            context 'field value is the specified type' do
+              let(:value) { 1 }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not specified type' do
+              let(:value) { { foo: :bar } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'strict' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, strict: true)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            specify do
+              expect do
+                subject.valid?
+              end.to_not raise_error
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            specify do
+              expect do
+                subject.valid?
+              end.to raise_error(ActiveModel::StrictValidationFailed)
+            end
+
+            context 'with a custom error class' do
+              class UhOhSpaghettios < StandardError; end
+              subject do
+                TypeValidationTest.send(validate_version,
+                  :string, strict: UhOhSpaghettios)
+              end
+
+              specify do
+                expect do
+                  subject.valid?
+                end.to raise_error(UhOhSpaghettios)
+              end
+            end
+          end
+        end
+
+        describe 'if' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, if: condition)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+        end
+
+        describe 'unless' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, unless: condition)
+          end
+
+          context 'field value is expected type' do
+            let(:value) { 'I am a string' }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+
+          context 'field value is not expected type' do
+            let(:value) { -1 }
+
+            context 'condition is true' do
+              let(:condition) { ->{ true } }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'condition is false' do
+              let(:condition) { ->{ false } }
+
+              specify do
+                expect(subject).to_not be_valid
+              end
+            end
+          end
+        end
+
+        describe 'on' do
+          let(:value) { nil }
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, on: :some_test_method)
+          end
+
+          before do
+            allow(subject).to receive(:some_test_method) { subject.validate }
+          end
+
+          context 'on: criteria is met' do
+            specify do
+              expect(subject).to receive(:validate)
+              subject.some_test_method
+            end
+          end
+
+          context 'on: criteria is not met' do
+            specify do
+              expect(subject).to_not receive(:validate)
+              subject.valid?
+            end
+          end
+        end
+      end
+
+      context 'multiple custom modifiers' do
+        before do
+          subject.test_attribute = value
+        end
+
+        describe 'message: with if:' do
+          subject do
+            TypeValidationTest.send(validate_version,
+              :string, message: 'This is bad!', if: condition)
+          end
+
+          context 'condition is true' do
+            let(:condition) { -> { true } }
+
+            context 'field value is the expected type' do
+              let(:value) { 'I am a string' }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not the expected type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to_not be_valid
+                expect(subject.errors.messages[:test_attribute][0]).to match(/This is bad!/)
+              end
+            end
+          end
+
+          context 'condition is false' do
+            let(:condition) { -> { false } }
+
+            context 'field value is the expected type' do
+              let(:value) { 'I am a string' }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+
+            context 'field value is not the expected type' do
+              let(:value) { -1 }
+
+              specify do
+                expect(subject).to be_valid
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end