file_validators 1.0.0

data/spec/integration/combined_validators_integration_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'rack/test/uploaded_file'
+
+describe 'Combined File Validators integration with ActiveModel' do
+  class Person
+    include ActiveModel::Validations
+    attr_accessor :avatar
+  end
+
+  before :all do
+    @cute_path = File.join(File.dirname(__FILE__), '../fixtures/cute.jpg')
+    @chubby_bubble_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_bubble.jpg')
+    @chubby_cute_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_cute.png')
+    @sample_text_path = File.join(File.dirname(__FILE__), '../fixtures/sample.txt')
+  end
+
+  context 'without helpers' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { less_than: 20.kilobytes },
+                           file_content_type: { allow: 'image/jpeg' }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'with an allowed type' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+      it { is_expected.to be_valid }
+    end
+
+    context 'with a disallowed type' do
+      it 'invalidates jpeg image file having size bigger than the allowed size' do
+        subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path, 'image/jpeg')
+        expect(subject).not_to be_valid
+      end
+
+      it 'invalidates png image file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png')
+        expect(subject).not_to be_valid
+      end
+
+      it 'invalidates text file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
+        expect(subject).not_to be_valid
+      end
+    end
+  end
+
+  context 'with helpers' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates_file_size :avatar, { less_than: 20.kilobytes }
+        validates_file_content_type :avatar, allow: 'image/jpeg'
+      end
+    end
+
+    subject { Person.new }
+
+    context 'with an allowed type' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+      it { is_expected.to be_valid }
+    end
+
+    context 'with a disallowed type' do
+      it 'invalidates jpeg image file having size bigger than the allowed size' do
+        subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path, 'image/jpeg')
+        expect(subject).not_to be_valid
+      end
+
+      it 'invalidates png image file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png')
+        expect(subject).not_to be_valid
+      end
+
+      it 'invalidates text file' do
+        subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
+        expect(subject).not_to be_valid
+      end
+    end
+  end
+end

data/spec/integration/file_content_type_validation_integration_spec.rb

@@ -0,0 +1,195 @@
+require 'spec_helper'
+require 'rack/test/uploaded_file'
+
+describe 'File Content Type integration with ActiveModel' do
+  class Person
+    include ActiveModel::Validations
+    attr_accessor :avatar
+  end
+
+  before :all do
+    @cute_path = File.join(File.dirname(__FILE__), '../fixtures/cute.jpg')
+    @chubby_bubble_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_bubble.jpg')
+    @chubby_cute_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_cute.png')
+    @sample_text_path = File.join(File.dirname(__FILE__), '../fixtures/sample.txt')
+  end
+
+  context ':allow option' do
+    context 'a string' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { allow: 'image/jpeg' }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+        it { is_expected.to be_valid }
+      end
+
+      context 'with a disallowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png') }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context 'as a regex' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { allow: /^image\/.*/ }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed types' do
+        it 'validates jpeg image file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).to be_valid
+        end
+
+        it 'validates png image file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png')
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'with a disallowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain') }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context 'as a list' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { allow: ['image/jpeg', 'text/plain'] }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with allowed types' do
+        it 'validates jpeg' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).to be_valid
+        end
+
+        it 'validates text file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
+          expect(subject).to be_valid
+        end
+      end
+
+      context 'with a disallowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png') }
+        it { is_expected.not_to be_valid }
+      end
+    end
+  end
+
+  context ':exclude option' do
+    context 'a string' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { exclude: 'image/jpeg' }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain') }
+        it { is_expected.to be_valid }
+      end
+
+      context 'with a disallowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+        it { is_expected.not_to be_valid }
+      end
+    end
+
+    context 'as a regex' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { exclude: /^image\/.*/ }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain') }
+        it { is_expected.to be_valid }
+      end
+
+      context 'with a disallowed types' do
+        it 'invalidates jpeg image file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).not_to be_valid
+        end
+
+        it 'invalidates png image file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png')
+          expect(subject).not_to be_valid
+        end
+      end
+    end
+
+    context 'as a list' do
+      before :all do
+        Person.class_eval do
+          Person.reset_callbacks(:validate)
+          validates :avatar, file_content_type: { exclude: ['image/jpeg', 'text/plain'] }
+        end
+      end
+
+      subject { Person.new }
+
+      context 'with an allowed type' do
+        before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png') }
+        it { is_expected.to be_valid }
+      end
+
+      context 'with a disallowed types' do
+        it 'invalidates jpeg' do
+          subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg')
+          expect(subject).not_to be_valid
+        end
+
+        it 'invalidates text file' do
+          subject.avatar = Rack::Test::UploadedFile.new(@sample_text_path, 'text/plain')
+          expect(subject).not_to be_valid
+        end
+      end
+    end
+  end
+
+  context ':allow and :exclude combined' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_content_type: { allow: /^image\/.*/, exclude: 'image/png' }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'with an allowed type' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+      it { is_expected.to be_valid }
+    end
+
+    context 'with a disallowed type' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path, 'image/png') }
+      it { is_expected.not_to be_valid }
+    end
+  end
+end

data/spec/integration/file_size_validator_integration_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+require 'rack/test/uploaded_file'
+
+describe 'File Size Validator integration with ActiveModel' do
+  class Person
+    include ActiveModel::Validations
+    attr_accessor :avatar
+  end
+
+  before :all do
+    @cute_path = File.join(File.dirname(__FILE__), '../fixtures/cute.jpg')
+    @chubby_bubble_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_bubble.jpg')
+    @chubby_cute_path = File.join(File.dirname(__FILE__), '../fixtures/chubby_cute.png')
+  end
+
+  context ':in option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { in: 20.kilobytes..40.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is out of range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size is out of range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context ':greater_than and :less_than option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { greater_than: 20.kilobytes,
+                                        less_than:    40.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is out of range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size is out of range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within range' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context ':less_than_or_equal_to option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { less_than_or_equal_to: 20.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is greater than the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context ':greater_than_or_equal_to option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { greater_than_or_equal_to: 20.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is less than the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context ':less_than option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { less_than: 20.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is greater than the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context ':greater_than option' do
+    before :all do
+      Person.class_eval do
+        Person.reset_callbacks(:validate)
+        validates :avatar, file_size: { greater_than: 20.kilobytes }
+      end
+    end
+
+    subject { Person.new }
+
+    context 'when file size is less than the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@cute_path) }
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when file size within the specified size' do
+      before { subject.avatar = Rack::Test::UploadedFile.new(@chubby_bubble_path) }
+      it { is_expected.to be_valid }
+    end
+  end
+end

data/spec/lib/file_validators/validators/file_content_type_validator_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+require 'file_validators/validators/file_content_type_validator'
+
+describe ActiveModel::Validations::FileContentTypeValidator do
+  class Dummy
+    include ActiveModel::Validations
+  end
+
+  subject { Dummy }
+
+  def build_validator(options)
+    @validator = ActiveModel::Validations::FileContentTypeValidator.new(options.merge(attributes: :avatar))
+  end
+
+  context 'whitelist format' do
+    context 'with an allowed type' do
+      context 'as a string' do
+        before { build_validator allow: 'image/jpg' }
+        it { is_expected.to allow_file_content_type('image/jpg', @validator) }
+      end
+  
+      context 'as an regexp' do
+        before { build_validator allow: /^image\/.*/ }
+        it { is_expected.to allow_file_content_type('image/png', @validator) }
+      end
+  
+      context 'as a list' do
+        before { build_validator allow: ['image/png', 'image/jpg', 'image/jpeg'] }
+        it { is_expected.to allow_file_content_type('image/png', @validator) }
+      end
+    end
+  
+    context 'with a disallowed type' do
+      context 'as a string' do
+        before { build_validator allow: 'image/png' }
+        it { is_expected.not_to allow_file_content_type('image/jpeg', @validator) }
+      end
+  
+      context 'as a regexp' do
+        before { build_validator allow: /^text\/.*/ }
+        it { is_expected.not_to allow_file_content_type('image/png', @validator) }
+      end
+  
+      context 'with :message option' do
+        context 'without interpolation' do
+          before { build_validator allow: 'image/png', message: 'should be a PNG image' }
+          it { is_expected.not_to allow_file_content_type('image/jpeg', @validator, message: 'Avatar should be a PNG image') }
+        end
+  
+        context 'with interpolation' do
+          before { build_validator allow: 'image/png', message: 'should have content type %{types}' }
+          it { is_expected.not_to allow_file_content_type('image/jpeg', @validator,
+                                                          message: 'Avatar should have content type image/png') }
+          it { is_expected.to allow_file_content_type('image/png', @validator,
+                                                          message: 'Avatar should have content type image/png') }
+        end
+      end
+    end
+  end
+
+  context 'blacklist format' do
+    context 'with an allowed type' do
+      context 'as a string' do
+        before { build_validator exclude: 'image/gif' }
+        it { is_expected.to allow_file_content_type('image/png', @validator) }
+      end
+  
+      context 'as an regexp' do
+        before { build_validator exclude: /^text\/.*/ }
+        it { is_expected.to allow_file_content_type('image/png', @validator) }
+      end
+  
+      context 'as a list' do
+        before { build_validator exclude: ['image/png', 'image/jpg', 'image/jpeg'] }
+        it { is_expected.to allow_file_content_type('image/gif', @validator) }
+      end
+    end
+  
+    context 'with a disallowed type' do
+      context 'as a string' do
+        before { build_validator exclude: 'image/gif' }
+        it { is_expected.not_to allow_file_content_type('image/gif', @validator) }
+      end
+
+      context 'as an regexp' do
+        before { build_validator exclude: /^text\/.*/ }
+        it { is_expected.not_to allow_file_content_type('text/plain', @validator) }
+      end
+  
+      context 'with :message option' do
+        context 'without interpolation' do
+          before { build_validator exclude: 'image/png', message: 'should not be a PNG image' }
+          it { is_expected.not_to allow_file_content_type('image/png', @validator, message: 'Avatar should not be a PNG image') }
+        end
+  
+        context 'with interpolation' do
+          before { build_validator exclude: 'image/png', message: 'should not have content type %{types}' }
+          it { is_expected.not_to allow_file_content_type('image/png', @validator,
+                                                          message: 'Avatar should not have content type image/png') }
+          it { is_expected.to allow_file_content_type('image/jpeg', @validator,
+                                                      message: 'Avatar should not have content type image/jpeg') }
+        end
+      end
+    end
+  end
+
+  context 'using the helper' do
+    before { Dummy.validates_file_content_type :avatar, allow: 'image/jpg' }
+
+    it 'adds the validator to the class' do
+      expect(Dummy.validators_on(:avatar)).to include(ActiveModel::Validations::FileContentTypeValidator)
+    end
+  end
+
+  context 'given options' do
+    it 'raises argument error if no required argument was given' do
+      expect { build_validator message: 'Some message' }.to raise_error(ArgumentError)
+    end
+
+    it 'does not raise argument error if :in was given' do
+      expect { build_validator allow: 'image/jpg' }.not_to raise_error
+    end
+
+    it 'does not raise argument error if :exclude was given' do
+      expect { build_validator exclude: 'image/jpg' }.not_to raise_error
+    end
+  end
+end

data/spec/lib/file_validators/validators/file_size_validator_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'file_validators/validators/file_size_validator'
+
+describe ActiveModel::Validations::FileSizeValidator do
+  class Dummy
+    include ActiveModel::Validations
+  end
+
+  def storage_units
+    if defined?(ActiveSupport::NumberHelper) # Rails 4.0+
+      { 5120 => '5 KB',       10240 => '10 KB' }
+    else
+      { 5120 => '5120 Bytes', 10240 => '10240 Bytes' }
+    end
+  end
+
+  before :all do
+    @storage_units = storage_units
+  end
+
+  subject { Dummy }
+
+  def build_validator(options)
+    @validator = ActiveModel::Validations::FileSizeValidator.new(options.merge(attributes: :avatar))
+  end
+
+  context 'with :in option' do
+    before { build_validator in: (5.kilobytes..10.kilobytes) }
+
+    it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(4.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+  end
+
+  context 'with :greater_than_or_equal_to option' do
+    before { build_validator greater_than_or_equal_to: 10.kilobytes }
+
+    it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+    it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(9.kilobytes, @validator) }
+  end
+
+  context 'with :less_than_or_equal_to option' do
+    before { build_validator less_than_or_equal_to: 10.kilobytes }
+
+    it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+    it { is_expected.to allow_file_size(10.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(11.kilobytes, @validator) }
+  end
+
+  context 'with :greater_than option' do
+    before { build_validator greater_than: 10.kilobytes }
+
+    it { is_expected.to allow_file_size(11.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+  end
+
+  context 'with :less_than option' do
+    before { build_validator less_than: 10.kilobytes }
+
+    it { is_expected.to allow_file_size(9.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+  end
+
+  context 'with :greater_than and :less_than option' do
+    before { build_validator greater_than: 5.kilobytes, less_than: 10.kilobytes }
+
+    it { is_expected.to allow_file_size(7.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(5.kilobytes, @validator) }
+    it { is_expected.not_to allow_file_size(10.kilobytes, @validator) }
+  end
+
+  context 'with :message option' do
+    before { build_validator in: (5.kilobytes..10.kilobytes),
+                             message: 'is invalid. (Between %{min} and %{max} please.)' }
+
+    it { is_expected.not_to allow_file_size(11.kilobytes, @validator,
+                                            message: "Avatar is invalid. (Between #{@storage_units[5120]} and #{@storage_units[10240]} please.)") }
+
+    it { is_expected.to allow_file_size(7.kilobytes, @validator,
+                                        message: "Avatar is invalid. (Between #{@storage_units[5120]} and #{@storage_units[10240]} please.)") }
+  end
+
+
+  context 'using the helper' do
+    before { Dummy.validates_file_size :avatar, in: (5.kilobytes..10.kilobytes) }
+
+    it 'adds the validator to the class' do
+      expect(Dummy.validators_on(:avatar)).to include(ActiveModel::Validations::FileSizeValidator)
+    end
+  end
+
+  context 'given options' do
+    it 'raises argument error if no required argument was given' do
+      expect { build_validator message: 'Some message' }.to raise_error(ArgumentError)
+    end
+
+    (ActiveModel::Validations::FileSizeValidator::AVAILABLE_CHECKS).each do |argument|
+      it "does not raise argument error if #{argument} was given" do
+        expect { build_validator argument => 5.kilobytes }.not_to raise_error
+      end
+    end
+
+    it 'does not raise argument error if :in was given' do
+      expect { build_validator in: (5.kilobytes..10.kilobytes) }.not_to raise_error
+    end
+  end
+end

data/spec/locale/en.yml

@@ -0,0 +1,13 @@
+en:
+  number:
+    human:
+      storage_units:
+        format: "%n %u"
+        units:
+          byte:
+            one:   "Byte"
+            other: "Bytes"
+          kb: "KB"
+          mb: "MB"
+          gb: "GB"
+          tb: "TB"

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'active_support/core_ext'
+require_relative '../lib/file_validators'
+require 'rspec'
+require 'coveralls'
+
+Coveralls.wear!
+
+locale_path = Dir.glob(File.dirname(__FILE__) + '/locale/*.yml')
+I18n.load_path += locale_path unless I18n.load_path.include?(locale_path)
+
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+end