file_validators 2.1.0 → 3.0.0

data/spec/integration/file_size_validator_integration_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'rack/test/uploaded_file'
 
@@ -44,7 +46,7 @@ describe 'File Size Validator integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_size: { in: lambda { |record| 20.kilobytes..40.kilobytes } }
+          validates :avatar, file_size: { in: ->(_record) { 20.kilobytes..40.kilobytes } }
         end
       end
 
@@ -99,8 +101,8 @@ describe 'File Size Validator integration with ActiveModel' do
       before :all do
         Person.class_eval do
           Person.reset_callbacks(:validate)
-          validates :avatar, file_size: { greater_than: lambda { |record| 20.kilobytes },
-                                          less_than:    lambda { |record| 40.kilobytes } }
+          validates :avatar, file_size: { greater_than: ->(_record) { 20.kilobytes },
+                                          less_than:    ->(_record) { 40.kilobytes } }
         end
       end
 
@@ -218,24 +220,35 @@ describe 'File Size Validator integration with ActiveModel' do
     subject { Person.new }
 
     context 'when file size is less than the specified size' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.GIF\",\"content_type\":\"image/gif\",\"size\":13150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.GIF","content_type":"image/gif","size":13150}'
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'when file size within the specified size' do
-      before { subject.avatar = "{\"filename\":\"img140910_88338.GIF\",\"content_type\":\"image/gif\",\"size\":33150}" }
+      before do
+        subject.avatar = '{"filename":"img140910_88338.GIF","content_type":"image/gif","size":33150}'
+      end
+
       it { is_expected.to be_valid }
     end
 
     context 'empty json string' do
-      before { subject.avatar = "{}" }
+      before { subject.avatar = '{}' }
       it { is_expected.to be_valid }
     end
 
-    context 'empty json string' do
-      before { subject.avatar = "" }
+    context 'empty string' do
+      before { subject.avatar = '' }
       it { is_expected.to be_valid }
     end
+
+    context 'invalid json string' do
+      before { subject.avatar = '{filename":"img140910_88338.GIF","content_type":"image/gif","size":33150}' }
+      it { is_expected.not_to be_valid }
+    end
   end
 
   context 'image data as hash' do
@@ -249,12 +262,26 @@ describe 'File Size Validator integration with ActiveModel' do
     subject { Person.new }
 
     context 'when file size is less than the specified size' do
-      before { subject.avatar = { "filename" => "img140910_88338.GIF", "content_type" => "image/gif", "size" => 13150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.GIF',
+          'content_type' => 'image/gif',
+          'size' => 13_150
+        }
+      end
+
       it { is_expected.not_to be_valid }
     end
 
     context 'when file size within the specified size' do
-      before { subject.avatar = { "filename" => "img140910_88338.GIF", "content_type" => "image/gif", "size" => 33150 } }
+      before do
+        subject.avatar = {
+          'filename' => 'img140910_88338.GIF',
+          'content_type' => 'image/gif',
+          'size' => 33_150
+        }
+      end
+
       it { is_expected.to be_valid }
     end
 
@@ -263,4 +290,67 @@ describe 'File Size Validator integration with ActiveModel' do
       it { is_expected.to be_valid }
     end
   end
+
+  context 'image data as array' 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 size of one file is less than the specified size' do
+      before do
+        subject.avatar = [
+          Rack::Test::UploadedFile.new(@cute_path),
+          Rack::Test::UploadedFile.new(@chubby_bubble_path)
+        ]
+      end
+      it { is_expected.not_to be_valid }
+    end
+
+    context 'when size of all files is within the specified size' do
+      before do
+        subject.avatar = [
+          Rack::Test::UploadedFile.new(@cute_path),
+          Rack::Test::UploadedFile.new(@cute_path)
+        ]
+      end
+
+      it 'is invalid and adds just one error' do
+        expect(subject).not_to be_valid
+        expect(subject.errors.count).to eq 1
+      end
+    end
+
+    context 'when size of all files is less than the specified size' do
+      before do
+        subject.avatar = [
+          Rack::Test::UploadedFile.new(@chubby_bubble_path),
+          Rack::Test::UploadedFile.new(@chubby_bubble_path)
+        ]
+      end
+
+      it { is_expected.to be_valid }
+    end
+
+    context 'one file' do
+      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 within range' do
+        before { subject.avatar = [Rack::Test::UploadedFile.new(@chubby_bubble_path)] }
+        it { is_expected.to be_valid }
+      end
+    end
+
+    context 'empty array' do
+      before { subject.avatar = [] }
+      it { is_expected.to be_valid }
+    end
+  end
 end

data/spec/lib/file_validators/mime_type_analyzer_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rack/test/uploaded_file'
+
+describe FileValidators::MimeTypeAnalyzer do
+  it 'rises error when tool is invalid' do
+    expect { described_class.new(:invalid) }.to raise_error(FileValidators::Error)
+  end
+
+  before :all do
+    @cute_path = File.join(File.dirname(__FILE__), '../../fixtures/cute.jpg')
+    @spoofed_file_path = File.join(File.dirname(__FILE__), '../../fixtures/spoofed.jpg')
+  end
+
+  let(:cute_image) { Rack::Test::UploadedFile.new(@cute_path, 'image/jpeg') }
+  let(:spoofed_file) { Rack::Test::UploadedFile.new(@spoofed_file_path, 'image/jpeg') }
+
+  describe ':file analyzer' do
+    let(:analyzer) { described_class.new(:file) }
+
+    it 'determines MIME type from file contents' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns text/plain for unidentified MIME types' do
+      expect(analyzer.call(fakeio('a' * 5 * 1024 * 1024))).to eq('text/plain')
+    end
+
+    it 'is able to determine MIME type for spoofed files' do
+      expect(analyzer.call(spoofed_file)).to eq('text/plain')
+    end
+
+    it 'is able to determine MIME type for non-files' do
+      expect(analyzer.call(fakeio(cute_image.read))).to eq('image/jpeg')
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq(nil)
+    end
+
+    it 'raises error if file command is not found' do
+      allow(Open3).to receive(:popen3).and_raise(Errno::ENOENT)
+      expect { analyzer.call(fakeio) }.to raise_error(FileValidators::Error, 'file command-line tool is not installed')
+    end
+  end
+
+  describe ':fastimage analyzer' do
+    let(:analyzer) { described_class.new(:fastimage) }
+
+    it 'extracts MIME type of any IO' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns nil for unidentified MIME types' do
+      expect(analyzer.call(fakeio('😃'))).to eq nil
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq nil
+    end
+  end
+
+  describe ':mimemagic analyzer' do
+    let(:analyzer) { described_class.new(:mimemagic) }
+
+    it 'extracts MIME type of any IO' do
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'returns nil for unidentified MIME types' do
+      expect(analyzer.call(fakeio('😃'))).to eq nil
+    end
+
+    it 'returns nil for empty IOs' do
+      expect(analyzer.call(fakeio(''))).to eq nil
+    end
+  end
+
+  if RUBY_VERSION >= '2.2.0'
+    describe ':marcel analyzer' do
+      let(:analyzer) { described_class.new(:marcel) }
+
+      it 'extracts MIME type of any IO' do
+        expect(analyzer.call(cute_image)).to eq('image/jpeg')
+      end
+
+      it 'returns application/octet-stream for unidentified MIME types' do
+        expect(analyzer.call(fakeio('😃'))).to eq 'application/octet-stream'
+      end
+
+      it 'returns nil for empty IOs' do
+        expect(analyzer.call(fakeio(''))).to eq nil
+      end
+    end
+  end
+
+  describe ':mime_types analyzer' do
+    let(:analyzer) { described_class.new(:mime_types) }
+
+    it 'extract MIME type from the file extension' do
+      expect(analyzer.call(fakeio(filename: 'image.png'))).to eq('image/png')
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'extracts MIME type from file extension when IO is empty' do
+      expect(analyzer.call(fakeio('', filename: 'image.png'))).to eq('image/png')
+    end
+
+    it 'returns nil on unknown extension' do
+      expect(analyzer.call(fakeio(filename: 'file.foo'))).to eq(nil)
+    end
+
+    it 'returns nil when input is not a file' do
+      expect(analyzer.call(fakeio)).to eq(nil)
+    end
+  end
+
+  describe ':mini_mime analyzer' do
+    let(:analyzer) { described_class.new(:mini_mime) }
+
+    it 'extract MIME type from the file extension' do
+      expect(analyzer.call(fakeio(filename: 'image.png'))).to eq('image/png')
+      expect(analyzer.call(cute_image)).to eq('image/jpeg')
+    end
+
+    it 'extracts MIME type from file extension when IO is empty' do
+      expect(analyzer.call(fakeio('', filename: 'image.png'))).to eq('image/png')
+    end
+
+    it 'returns nil on unkown extension' do
+      expect(analyzer.call(fakeio(filename: 'file.foo'))).to eq(nil)
+    end
+
+    it 'returns nil when input is not a file' do
+      expect(analyzer.call(fakeio)).to eq(nil)
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ActiveModel::Validations::FileContentTypeValidator do
@@ -17,57 +19,85 @@ describe ActiveModel::Validations::FileContentTypeValidator 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
 
       context 'as a proc' do
-        before { build_validator allow: lambda { |record| ['image/png', 'image/jpg', 'image/jpeg'] } }
+        before { build_validator allow: ->(_record) { ['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 'as a proc' do
-        before { build_validator allow: lambda { |record| /^text\/.*/ } }
+        before { build_validator allow: ->(_record) { /^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') }
+          before do
+            build_validator allow: 'image/png',
+                            message: 'should be a PNG image'
+          end
+
+          it do
+            is_expected.not_to allow_file_content_type(
+              'image/jpeg', @validator,
+              message: 'Avatar should be a PNG image'
+            )
+          end
         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') }
+          before do
+            build_validator allow: 'image/png',
+                            message: 'should have content type %{types}'
+          end
+
+          it do
+            is_expected.not_to allow_file_content_type(
+              'image/jpeg', @validator,
+              message: 'Avatar should have content type image/png'
+            )
+          end
+
+          it do
+            is_expected.to allow_file_content_type(
+              'image/png', @validator,
+              message: 'Avatar should have content type image/png'
+            )
+          end
         end
       end
 
       context 'default message' do
         before { build_validator allow: 'image/png' }
-        it { is_expected.not_to allow_file_content_type('image/jpeg', @validator, message: 'Avatar file should be one of image/png') }
+
+        it do
+          is_expected.not_to allow_file_content_type(
+            'image/jpeg', @validator,
+            message: 'Avatar file should be one of image/png'
+          )
+        end
       end
     end
   end
@@ -78,23 +108,23 @@ describe ActiveModel::Validations::FileContentTypeValidator 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
 
       context 'as a proc' do
-        before { build_validator exclude: lambda { |record| ['image/png', 'image/jpg', 'image/jpeg'] } }
+        before { build_validator exclude: ->(_record) { ['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' }
@@ -107,28 +137,56 @@ describe ActiveModel::Validations::FileContentTypeValidator do
       end
 
       context 'as an proc' do
-        before { build_validator exclude: lambda { |record| /^text\/.*/ } }
+        before { build_validator exclude: ->(_record) { /^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') }
+          before do
+            build_validator exclude: 'image/png',
+                            message: 'should not be a PNG image'
+          end
+
+          it do
+            is_expected.not_to allow_file_content_type(
+              'image/png', @validator,
+              message: 'Avatar should not be a PNG image'
+            )
+          end
         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') }
+          before do
+            build_validator exclude: 'image/png',
+                            message: 'should not have content type %{types}'
+          end
+
+          it do
+            is_expected.not_to allow_file_content_type(
+              'image/png', @validator,
+              message: 'Avatar should not have content type image/png'
+            )
+          end
+
+          it do
+            is_expected.to allow_file_content_type(
+              'image/jpeg', @validator,
+              message: 'Avatar should not have content type image/jpeg'
+            )
+          end
         end
       end
 
       context 'default message' do
         before { build_validator exclude: 'image/png' }
-        it { is_expected.not_to allow_file_content_type('image/png', @validator, message: 'Avatar file cannot be image/png') }
+
+        it do
+          is_expected.not_to allow_file_content_type(
+            'image/png', @validator,
+            message: 'Avatar file cannot be image/png'
+          )
+        end
       end
     end
   end
@@ -151,7 +209,7 @@ describe ActiveModel::Validations::FileContentTypeValidator do
         expect { build_validator argument => 'image/jpg' }.not_to raise_error
         expect { build_validator argument => ['image/jpg'] }.not_to raise_error
         expect { build_validator argument => /^image\/.*/ }.not_to raise_error
-        expect { build_validator argument => lambda { |record| 'image/jpg' } }.not_to raise_error
+        expect { build_validator argument => ->(_record) { 'image/jpg' } }.not_to raise_error
       end
 
       it "raises argument error if :#{argument} is neither a string, array, regexp nor proc" do