paperclip 3.5.4 → 6.1.0

data/spec/paperclip/media_type_spoof_detector_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Paperclip::MediaTypeSpoofDetector do
+  it 'rejects a file that is named .html and identifies as PNG' do
+    file = File.open(fixture_file("5k.png"))
+    assert Paperclip::MediaTypeSpoofDetector.using(file, "5k.html", "image/png").spoofed?
+  end
+
+  it 'does not reject a file that is named .jpg and identifies as PNG' do
+    file = File.open(fixture_file("5k.png"))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(file, "5k.jpg", "image/png").spoofed?
+  end
+
+  it 'does not reject a file that is named .html and identifies as HTML' do
+    file = File.open(fixture_file("empty.html"))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "text/html").spoofed?
+  end
+
+  it 'does not reject a file that does not have a name' do
+    file = File.open(fixture_file("empty.html"))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(file, "", "text/html").spoofed?
+  end
+
+  it 'does not reject a file that does have an extension' do
+    file = File.open(fixture_file("empty.html"))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(file, "data", "text/html").spoofed?
+  end
+
+  it 'does not reject when the supplied file is an IOAdapter' do
+    adapter = Paperclip.io_adapters.for(File.new(fixture_file("5k.png")))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(adapter, adapter.original_filename, adapter.content_type).spoofed?
+  end
+
+  it 'does not reject when the extension => content_type is in :content_type_mappings' do
+    begin
+      Paperclip.options[:content_type_mappings] = { pem: "text/plain" }
+      file = Tempfile.open(["test", ".PEM"])
+      file.puts "Certificate!"
+      file.close
+      adapter = Paperclip.io_adapters.for(File.new(file.path));
+      assert ! Paperclip::MediaTypeSpoofDetector.using(adapter, adapter.original_filename, adapter.content_type).spoofed?
+    ensure
+      Paperclip.options[:content_type_mappings] = {}
+    end
+  end
+
+  context "file named .html and is as HTML, but we're told JPG" do
+    let(:file) { File.open(fixture_file("empty.html")) }
+    let(:spoofed?) { Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "image/jpg").spoofed? }
+
+    it "rejects the file" do
+      assert spoofed?
+    end
+
+    it "logs info about the detected spoof" do
+      Paperclip.expects(:log).with('Content Type Spoof: Filename empty.html (image/jpg from Headers, ["text/html"] from Extension), content type discovered from file command: text/html. See documentation to allow this combination.')
+      spoofed?
+    end
+  end
+
+  context "GIF file named without extension, but we're told GIF" do
+    let(:file) { File.open(fixture_file("animated")) }
+    let(:spoofed?) do
+      Paperclip::MediaTypeSpoofDetector.
+        using(file, "animated", "image/gif").
+        spoofed?
+    end
+
+    it "accepts the file" do
+      assert !spoofed?
+    end
+  end
+
+  context "GIF file named without extension, but we're told HTML" do
+    let(:file) { File.open(fixture_file("animated")) }
+    let(:spoofed?) do
+      Paperclip::MediaTypeSpoofDetector.
+        using(file, "animated", "text/html").
+        spoofed?
+    end
+
+    it "rejects the file" do
+      assert spoofed?
+    end
+  end
+
+  it "does not reject if content_type is empty but otherwise checks out" do
+    file = File.open(fixture_file("empty.html"))
+    assert ! Paperclip::MediaTypeSpoofDetector.using(file, "empty.html", "").spoofed?
+  end
+
+  it 'does allow array as :content_type_mappings' do
+    begin
+      Paperclip.options[:content_type_mappings] = {
+        html: ['binary', 'text/html']
+      }
+      file = File.open(fixture_file('empty.html'))
+      spoofed = Paperclip::MediaTypeSpoofDetector
+                .using(file, "empty.html", "text/html").spoofed?
+      assert !spoofed
+    ensure
+      Paperclip.options[:content_type_mappings] = {}
+    end
+  end
+
+  context "#type_from_file_command" do
+    let(:file) { File.new(fixture_file("empty.html")) }
+    let(:detector) { Paperclip::MediaTypeSpoofDetector.new(file, "html", "") }
+
+    it "does work with the output of old versions of file" do
+      Paperclip.stubs(:run).returns("text/html charset=us-ascii")
+      expect(detector.send(:type_from_file_command)).to eq("text/html")
+    end
+
+    it "does work with the output of new versions of file" do
+      Paperclip.stubs(:run).returns("text/html; charset=us-ascii")
+      expect(detector.send(:type_from_file_command)).to eq("text/html")
+    end
+  end
+end

data/spec/paperclip/meta_class_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe 'Metaclasses' do
+  context "A meta-class of dummy" do
+    if active_support_version >= "4.1" || ruby_version < "2.1"
+      before do
+        rebuild_model
+        reset_class("Dummy")
+      end
+
+      it "is able to use Paperclip like a normal class" do
+        @dummy = Dummy.new
+
+        assert_nothing_raised do
+          rebuild_meta_class_of(@dummy)
+        end
+      end
+
+      it "works like any other instance" do
+        @dummy = Dummy.new
+        rebuild_meta_class_of(@dummy)
+
+        assert_nothing_raised do
+          @dummy.avatar = File.new(fixture_file("5k.png"), 'rb')
+        end
+        assert @dummy.save
+      end
+    end
+  end
+end

data/spec/paperclip/paperclip_missing_attachment_styles_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe 'Missing Attachment Styles' do
+  before do
+    Paperclip::AttachmentRegistry.clear
+  end
+
+  after do
+    File.unlink(Paperclip.registered_attachments_styles_path) rescue nil
+  end
+
+  it "enables to get and set path to registered styles file" do
+    assert_equal ROOT.join('tmp/public/system/paperclip_attachments.yml').to_s, Paperclip.registered_attachments_styles_path
+    Paperclip.registered_attachments_styles_path = '/tmp/config/paperclip_attachments.yml'
+    assert_equal '/tmp/config/paperclip_attachments.yml', Paperclip.registered_attachments_styles_path
+    Paperclip.registered_attachments_styles_path = nil
+    assert_equal ROOT.join('tmp/public/system/paperclip_attachments.yml').to_s, Paperclip.registered_attachments_styles_path
+  end
+
+  it "is able to get current attachment styles" do
+    assert_equal Hash.new, Paperclip.send(:current_attachments_styles)
+    rebuild_model styles: {croppable: '600x600>', big: '1000x1000>'}
+    expected_hash = { Dummy: {avatar: [:big, :croppable]}}
+    assert_equal expected_hash, Paperclip.send(:current_attachments_styles)
+  end
+
+  it "is able to save current attachment styles for further comparison" do
+    rebuild_model styles: {croppable: '600x600>', big: '1000x1000>'}
+    Paperclip.save_current_attachments_styles!
+    expected_hash = { Dummy: {avatar: [:big, :croppable]}}
+    assert_equal expected_hash, YAML.load_file(Paperclip.registered_attachments_styles_path)
+  end
+
+  it "is able to read registered attachment styles from file" do
+    rebuild_model styles: {croppable: '600x600>', big: '1000x1000>'}
+    Paperclip.save_current_attachments_styles!
+    expected_hash = { Dummy: {avatar: [:big, :croppable]}}
+    assert_equal expected_hash, Paperclip.send(:get_registered_attachments_styles)
+  end
+
+  it "is able to calculate differences between registered styles and current styles" do
+    rebuild_model styles: {croppable: '600x600>', big: '1000x1000>'}
+    Paperclip.save_current_attachments_styles!
+    rebuild_model styles: {thumb: 'x100', export: 'x400>', croppable: '600x600>', big: '1000x1000>'}
+    expected_hash = { Dummy: {avatar: [:export, :thumb]} }
+    assert_equal expected_hash, Paperclip.missing_attachments_styles
+
+    ActiveRecord::Base.connection.create_table :books, force: true
+    class ::Book < ActiveRecord::Base
+      has_attached_file :cover, styles: {small: 'x100', large: '1000x1000>'}
+      has_attached_file :sample, styles: {thumb: 'x100'}
+    end
+
+    expected_hash = {
+      Dummy: {avatar: [:export, :thumb]},
+      Book: {sample: [:thumb], cover: [:large, :small]}
+    }
+    assert_equal expected_hash, Paperclip.missing_attachments_styles
+    Paperclip.save_current_attachments_styles!
+    assert_equal Hash.new, Paperclip.missing_attachments_styles
+  end
+
+  it "is able to calculate differences when a new attachment is added to a model" do
+    rebuild_model styles: {croppable: '600x600>', big: '1000x1000>'}
+    Paperclip.save_current_attachments_styles!
+
+    class ::Dummy
+      has_attached_file :photo, styles: {small: 'x100', large: '1000x1000>'}
+    end
+
+    expected_hash = {
+      Dummy: {photo: [:large, :small]}
+    }
+    assert_equal expected_hash, Paperclip.missing_attachments_styles
+    Paperclip.save_current_attachments_styles!
+    assert_equal Hash.new, Paperclip.missing_attachments_styles
+  end
+
+  # It's impossible to build styles hash without loading from database whole bunch of records
+  it "skips lambda-styles" do
+    rebuild_model styles: lambda{ |attachment| attachment.instance.other == 'a' ? {thumb: "50x50#"} : {large: "400x400"} }
+    assert_equal Hash.new, Paperclip.send(:current_attachments_styles)
+  end
+end

data/spec/paperclip/paperclip_spec.rb

@@ -0,0 +1,192 @@
+require 'spec_helper'
+
+describe Paperclip do
+  context ".run" do
+    before do
+      Paperclip.options[:log_command] = false
+      Terrapin::CommandLine.expects(:new).with("convert", "stuff", {}).returns(stub(:run))
+      @original_command_line_path = Terrapin::CommandLine.path
+    end
+
+    after do
+      Paperclip.options[:log_command] = true
+      Terrapin::CommandLine.path = @original_command_line_path
+    end
+
+    it "runs the command with Terrapin" do
+      Paperclip.run("convert", "stuff")
+    end
+
+    it "saves Terrapin::CommandLine.path that set before" do
+      Terrapin::CommandLine.path = "/opt/my_app/bin"
+      Paperclip.run("convert", "stuff")
+      expect(Terrapin::CommandLine.path).to match("/opt/my_app/bin")
+    end
+
+    it "does not duplicate Terrapin::CommandLine.path on multiple runs" do
+      Terrapin::CommandLine.expects(:new).with("convert", "more_stuff", {}).returns(stub(:run))
+      Terrapin::CommandLine.path = nil
+      Paperclip.options[:command_path] = "/opt/my_app/bin"
+      Paperclip.run("convert", "stuff")
+      Paperclip.run("convert", "more_stuff")
+
+      cmd_path = Paperclip.options[:command_path]
+      assert_equal 1, Terrapin::CommandLine.path.scan(cmd_path).count
+    end
+  end
+
+  it 'does not raise errors when doing a lot of running' do
+    Paperclip.options[:command_path] = ["/usr/local/bin"] * 1024
+    Terrapin::CommandLine.path = "/something/else"
+    100.times do |x|
+      Paperclip.run("echo", x.to_s)
+    end
+  end
+
+  context "Calling Paperclip.log without options[:logger] set" do
+    before do
+      Paperclip.logger = nil
+      Paperclip.options[:logger] = nil
+    end
+
+    after do
+      Paperclip.options[:logger] = ActiveRecord::Base.logger
+      Paperclip.logger = ActiveRecord::Base.logger
+    end
+
+    it "does not raise an error when log is called" do
+      silence_stream(STDOUT) do
+        Paperclip.log('something')
+      end
+    end
+  end
+  context "Calling Paperclip.run with a logger" do
+    it "passes the defined logger if :log_command is set" do
+      Paperclip.options[:log_command] = true
+      Terrapin::CommandLine.expects(:new).with("convert", "stuff", logger: Paperclip.logger).returns(stub(:run))
+      Paperclip.run("convert", "stuff")
+    end
+  end
+
+  context "Paperclip.each_instance_with_attachment" do
+    before do
+      @file = File.new(fixture_file("5k.png"), 'rb')
+      d1 = Dummy.create(avatar: @file)
+      d2 = Dummy.create
+      d3 = Dummy.create(avatar: @file)
+      @expected = [d1, d3]
+    end
+
+    after { @file.close }
+
+    it "yields every instance of a model that has an attachment" do
+      actual = []
+      Paperclip.each_instance_with_attachment("Dummy", "avatar") do |instance|
+        actual << instance
+      end
+      expect(actual).to match_array @expected
+    end
+  end
+
+  it "raises when sent #processor and the name of a class that doesn't exist" do
+    assert_raises(LoadError){ Paperclip.processor(:boogey_man) }
+  end
+
+  it "returns a class when sent #processor and the name of a class under Paperclip" do
+    assert_equal ::Paperclip::Thumbnail, Paperclip.processor(:thumbnail)
+  end
+
+  it "gets a class from a namespaced class name" do
+    class ::One; class Two; end; end
+    assert_equal ::One::Two, Paperclip.class_for("One::Two")
+  end
+
+  it "raises when class doesn't exist in specified namespace" do
+    class ::Three; end
+    class ::Four; end
+    assert_raises NameError do
+      Paperclip.class_for("Three::Four")
+    end
+  end
+
+  context "An ActiveRecord model with an 'avatar' attachment" do
+    before do
+      rebuild_model path: "tmp/:class/omg/:style.:extension"
+      @file = File.new(fixture_file("5k.png"), 'rb')
+    end
+
+    after { @file.close }
+
+    it "does not error when trying to also create a 'blah' attachment" do
+      assert_nothing_raised do
+        Dummy.class_eval do
+          has_attached_file :blah
+        end
+      end
+    end
+
+    context "with a subclass" do
+      before do
+        class ::SubDummy < Dummy; end
+      end
+
+      it "is able to use the attachment from the subclass" do
+        assert_nothing_raised do
+          @subdummy = SubDummy.create(avatar: @file)
+        end
+      end
+
+      after do
+        SubDummy.delete_all
+        Object.send(:remove_const, "SubDummy") rescue nil
+      end
+    end
+
+    it "has an avatar getter method" do
+      assert Dummy.new.respond_to?(:avatar)
+    end
+
+    it "has an avatar setter method" do
+      assert Dummy.new.respond_to?(:avatar=)
+    end
+
+    context "that is valid" do
+      before do
+        @dummy = Dummy.new
+        @dummy.avatar = @file
+      end
+
+      it "is valid" do
+        assert @dummy.valid?
+      end
+    end
+
+    it "does not have Attachment in the ActiveRecord::Base namespace" do
+      assert_raises(NameError) do
+        ActiveRecord::Base::Attachment
+      end
+    end
+  end
+
+  context "configuring a custom processor" do
+    before do
+      @freedom_processor = Class.new do
+        def make(file, options = {}, attachment = nil)
+          file
+        end
+      end.new
+
+      Paperclip.configure do |config|
+        config.register_processor(:freedom, @freedom_processor)
+      end
+    end
+
+    it "is able to find the custom processor" do
+      assert_equal @freedom_processor, Paperclip.processor(:freedom)
+    end
+
+    after do
+      Paperclip.clear_processors!
+    end
+  end
+end

data/spec/paperclip/plural_cache_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe 'Plural cache' do
+  it 'caches pluralizations' do
+    cache = Paperclip::Interpolations::PluralCache.new
+    symbol = :box
+
+    first = cache.pluralize_symbol(symbol)
+    second = cache.pluralize_symbol(symbol)
+    expect(first).to equal(second)
+  end
+
+  it 'caches pluralizations and underscores' do
+    class BigBox ; end
+    cache = Paperclip::Interpolations::PluralCache.new
+    klass = BigBox
+
+    first = cache.underscore_and_pluralize_class(klass)
+    second = cache.underscore_and_pluralize_class(klass)
+    expect(first).to equal(second)
+  end
+
+  it 'pluralizes words' do
+    cache = Paperclip::Interpolations::PluralCache.new
+    symbol = :box
+
+    expect(cache.pluralize_symbol(symbol)).to eq("boxes")
+  end
+
+  it 'pluralizes and underscore class names' do
+    class BigBox ; end
+    cache = Paperclip::Interpolations::PluralCache.new
+    klass = BigBox
+
+    expect(cache.underscore_and_pluralize_class(klass)).to eq("big_boxes")
+  end
+end

data/spec/paperclip/processor_helpers_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Paperclip::ProcessorHelpers do
+  describe '.load_processor' do
+    context 'when the file exists in lib/paperclip' do
+      it 'loads it correctly' do
+        pathname = Pathname.new('my_app')
+        main_path = 'main_path'
+        alternate_path = 'alternate_path'
+
+        Rails.stubs(:root).returns(pathname)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.expects(:exist?).with(main_path).returns(true)
+        File.expects(:exist?).with(alternate_path).returns(false)
+
+        Paperclip.expects(:require).with(main_path)
+
+        Paperclip.load_processor(:custom)
+      end
+    end
+
+    context 'when the file exists in lib/paperclip_processors' do
+      it 'loads it correctly' do
+        pathname = Pathname.new('my_app')
+        main_path = 'main_path'
+        alternate_path = 'alternate_path'
+
+        Rails.stubs(:root).returns(pathname)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.expects(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.expects(:exist?).with(main_path).returns(false)
+        File.expects(:exist?).with(alternate_path).returns(true)
+
+        Paperclip.expects(:require).with(alternate_path)
+
+        Paperclip.load_processor(:custom)
+      end
+    end
+
+    context 'when the file does not exist in lib/paperclip_processors' do
+      it 'raises an error' do
+        pathname = Pathname.new('my_app')
+        main_path = 'main_path'
+        alternate_path = 'alternate_path'
+
+        Rails.stubs(:root).returns(pathname)
+        File.stubs(:expand_path).with(pathname.join('lib/paperclip', 'custom.rb')).returns(main_path)
+        File.stubs(:expand_path).with(pathname.join('lib/paperclip_processors', 'custom.rb')).returns(alternate_path)
+        File.stubs(:exist?).with(main_path).returns(false)
+        File.stubs(:exist?).with(alternate_path).returns(false)
+
+        assert_raises(LoadError) { Paperclip.processor(:custom) }
+      end
+    end
+  end
+end

data/{test/processor_test.rb → spec/paperclip/processor_spec.rb}

@@ -1,7 +1,7 @@
-require './test/helper'
+require 'spec_helper'
 
-class ProcessorTest < Test::Unit::TestCase
-  should "instantiate and call #make when sent #make to the class" do
+describe Paperclip::Processor do
+  it "instantiates and call #make when sent #make to the class" do
     processor = mock
     processor.expects(:make).with()
     Paperclip::Processor.expects(:new).with(:one, :two, :three).returns(processor)
@@ -9,17 +9,17 @@ class ProcessorTest < Test::Unit::TestCase
   end
 
   context "Calling #convert" do
-    should "run the convert command with Cocaine" do
+    it "runs the convert command with Terrapin" do
       Paperclip.options[:log_command] = false
-      Cocaine::CommandLine.expects(:new).with("convert", "stuff", {}).returns(stub(:run))
+      Terrapin::CommandLine.expects(:new).with("convert", "stuff", {}).returns(stub(:run))
       Paperclip::Processor.new('filename').convert("stuff")
     end
   end
 
   context "Calling #identify" do
-    should "run the identify command with Cocaine" do
+    it "runs the identify command with Terrapin" do
       Paperclip.options[:log_command] = false
-      Cocaine::CommandLine.expects(:new).with("identify", "stuff", {}).returns(stub(:run))
+      Terrapin::CommandLine.expects(:new).with("identify", "stuff", {}).returns(stub(:run))
       Paperclip::Processor.new('filename').identify("stuff")
     end
   end

data/spec/paperclip/rails_environment_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Paperclip::RailsEnvironment do
+
+  it "returns nil when Rails isn't defined" do
+    resetting_rails_to(nil) do
+      expect(Paperclip::RailsEnvironment.get).to be_nil
+    end
+  end
+
+  it "returns nil when Rails.env isn't defined" do
+    resetting_rails_to({}) do
+      expect(Paperclip::RailsEnvironment.get).to be_nil
+    end
+  end
+
+  it "returns the value of Rails.env if it is set" do
+    resetting_rails_to(OpenStruct.new(env: "foo")) do
+      expect(Paperclip::RailsEnvironment.get).to eq "foo"
+    end
+  end
+
+  def resetting_rails_to(new_value)
+    begin
+      previous_rails = Object.send(:remove_const, "Rails")
+      Object.const_set("Rails", new_value) unless new_value.nil?
+      yield
+    ensure
+      Object.send(:remove_const, "Rails") if Object.const_defined?("Rails")
+      Object.const_set("Rails", previous_rails)
+    end
+  end
+end