delayed_paperclip 2.6.0.0 → 2.6.1

data/spec/delayed_paperclip/url_generator_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::UrlGenerator do
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Resque
+    reset_dummy
+  end
+
+  let(:dummy) { Dummy.create }
+  let(:attachment) { dummy.image }
+
+
+  describe "#most_appropriate_url_with_processed" do
+    context "without delayed_default_url" do
+      subject { Paperclip::UrlGenerator.new(attachment, {url: "/blah/url.jpg"})}
+
+      before :each do
+        subject.stubs(:delayed_default_url?).returns false
+      end
+
+      context "with original file name" do
+        before :each do
+          attachment.stubs(:original_filename).returns "blah"
+        end
+
+        it "returns options url" do
+          subject.most_appropriate_url_with_processed.should == "/blah/url.jpg"
+        end
+      end
+
+      context "without original_filename" do
+        before :each do
+          attachment.stubs(:original_filename).returns nil
+        end
+
+        context "without delayed_options" do
+          before :each do
+            attachment.stubs(:delayed_options).returns nil
+          end
+
+          it "gets default url" do
+            subject.expects(:default_url)
+            subject.most_appropriate_url_with_processed
+          end
+        end
+
+        context "with delayed_options" do
+          before :each do
+            attachment.stubs(:delayed_options).returns "something"
+          end
+
+          context "without processing_image_url" do
+            before :each do
+              attachment.stubs(:processing_image_url).returns nil
+            end
+
+            it "gets default url" do
+              subject.expects(:default_url)
+              subject.most_appropriate_url_with_processed
+            end
+          end
+
+          context "with processing_image_url" do
+            before :each do
+              attachment.stubs(:processing_image_url).returns "/processing/image.jpg"\
+            end
+
+            context "and is processing" do
+              before :each do
+                attachment.stubs(:processing?).returns true
+              end
+
+              it "gets processing url" do
+                subject.most_appropriate_url_with_processed.should == "/processing/image.jpg"
+              end
+            end
+
+            context "and is not processing" do
+              it "gets default url" do
+                subject.expects(:default_url)
+                subject.most_appropriate_url_with_processed
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#timestamp_possible_with_processed?" do
+    subject { Paperclip::UrlGenerator.new(attachment, {})}
+
+    context "with delayed_default_url" do
+      before :each do
+        subject.stubs(:delayed_default_url?).returns true
+      end
+
+      it "is false" do
+        subject.timestamp_possible_with_processed?.should be_false
+      end
+    end
+
+    context "without delayed_default_url" do
+      before :each do
+        subject.stubs(:delayed_default_url?).returns false
+      end
+
+      it "goes up the chain" do
+        subject.expects(:timestamp_possible_without_processed?)
+        subject.timestamp_possible_with_processed?
+      end
+    end
+  end
+
+  describe "#delayed_default_url?" do
+    subject { Paperclip::UrlGenerator.new(attachment, {})}
+
+    before :each do
+      attachment.stubs(:job_is_processing).returns false
+      attachment.stubs(:dirty?).returns false
+      attachment.delayed_options[:url_with_processing] = true
+      attachment.instance.stubs(:respond_to?).with(:image_processing?).returns true
+      attachment.stubs(:processing?).returns true
+    end
+
+    it "has all false, delayed_default_url returns true" do
+      subject.delayed_default_url?.should be_true
+    end
+
+    context "job is processing" do
+      before :each do
+        attachment.stubs(:job_is_processing).returns true
+      end
+
+      it "returns true" do
+        subject.delayed_default_url?.should be_false
+      end
+    end
+
+    context "attachment is dirty" do
+      before :each do
+        attachment.stubs(:dirty?).returns true
+      end
+
+      it "returns true" do
+        subject.delayed_default_url?.should be_false
+      end
+    end
+
+    context "attachment has delayed_options without url_with_processing" do
+      before :each do
+        attachment.delayed_options[:url_with_processing] = false
+      end
+
+      it "returns true" do
+        subject.delayed_default_url?.should be_false
+      end
+    end
+
+    context "attachment does not responds to name_processing and is not processing" do
+      before :each do
+        attachment.instance.stubs(:respond_to?).with(:image_processing?).returns false
+        attachment.stubs(:processing?).returns false
+      end
+
+      it "returns true" do
+        subject.delayed_default_url?.should be_false
+      end
+    end
+  end
+end

data/spec/delayed_paperclip_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'resque'
+
+describe DelayedPaperclip do
+  before :all do
+    reset_dummy
+  end
+
+  describe ".options" do
+    it ".options returns basic options" do
+      DelayedPaperclip.options.should == {:background_job_class => DelayedPaperclip::Jobs::Resque,
+                                          :url_with_processing => true,
+                                          :processing_image_url => nil}
+    end
+  end
+
+  describe ".processor" do
+    it ".processor returns processor" do
+      DelayedPaperclip.processor.should == DelayedPaperclip::Jobs::Resque
+    end
+  end
+
+  describe ".enqueue" do
+    it "delegates to processor" do
+      DelayedPaperclip::Jobs::Resque.expects(:enqueue_delayed_paperclip).with("Dummy", 1, :image)
+      DelayedPaperclip.enqueue("Dummy", 1, :image)
+    end
+  end
+
+  describe ".process_job" do
+    let(:dummy) { Dummy.create! }
+
+    it "finds dummy and calls #process_delayed!" do
+      Dummy.expects(:find).with(dummy.id).returns(dummy)
+      dummy.image.expects(:process_delayed!)
+      DelayedPaperclip.process_job("Dummy", dummy.id, :image)
+    end
+  end
+
+  describe "paperclip definitions" do
+    before :all do
+      reset_dummy :paperclip => { styles: { thumbnail: "25x25"} }
+    end
+
+    it "returns paperclip options regardless of version" do
+      Dummy.paperclip_definitions.should ==  {:image =>   { :styles => { :thumbnail => "25x25" },
+                                              :delayed => { :priority => 0,
+                                                            :only_process => nil,
+                                                            :url_with_processing => true,
+                                                            :processing_image_url => nil}
+                                                          }
+                                              }
+    end
+
+  end
+end

data/spec/integration/delayed_job_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'delayed_job'
+
+Delayed::Worker.backend = :active_record
+
+describe "Delayed Job" do
+
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::DelayedJob
+    build_delayed_jobs
+  end
+
+  let(:dummy) { Dummy.new(:image => File.open("#{ROOT}/spec/fixtures/12k.png")) }
+
+  describe "integration tests" do
+    include_examples "base usage"
+  end
+
+  describe "perform job" do
+    before :each do
+      DelayedPaperclip.options[:url_with_processing] = true
+      reset_dummy
+    end
+
+    it "performs a job" do
+      dummy.image = File.open("#{ROOT}/spec/fixtures/12k.png")
+      Paperclip::Attachment.any_instance.expects(:reprocess!)
+      dummy.save!
+      Delayed::Job.last.payload_object.perform
+    end
+  end
+
+  def process_jobs
+    Delayed::Worker.new.work_off
+  end
+
+  def jobs_count
+    Delayed::Job.count
+  end
+
+  def build_delayed_jobs
+    ActiveRecord::Base.connection.create_table :delayed_jobs, :force => true do |table|
+      table.integer  :priority, :default => 0      # Allows some jobs to jump to the front of the queue
+      table.integer  :attempts, :default => 0      # Provides for retries, but still fail eventually.
+      table.text     :handler                      # YAML-encoded string of the object that will do work
+      table.string   :last_error                   # reason for last failure (See Note below)
+      table.datetime :run_at                       # When to run. Could be Time.now for immediately, or sometime in the future.
+      table.datetime :locked_at                    # Set when a client is working on this object
+      table.datetime :failed_at                    # Set when all retries have failed (actually, by default, the record is deleted instead)
+      table.string   :locked_by                    # Who is working on this object (if locked)
+      table.string   :queue
+      table.timestamps
+    end
+  end
+end

data/spec/integration/examples/base.rb

@@ -0,0 +1,316 @@
+shared_examples "base usage" do
+  before :each do
+    DelayedPaperclip.options[:url_with_processing] = true
+    reset_dummy
+  end
+
+  describe "normal paperclip" do
+    before :each do
+      DelayedPaperclip.options[:url_with_processing] = false
+      reset_dummy :with_processed => false
+    end
+
+    it "allows normal paperclip functionality" do
+      Paperclip::Attachment.any_instance.expects(:post_process)
+      dummy.image.delay_processing?.should be_false
+      dummy.image.post_processing.should be_true
+      dummy.save.should be_true
+      File.exists?(dummy.image.path).should be_true
+    end
+
+    context "missing url" do
+      it "does not return missing url if false globally" do
+        dummy.save!
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+        process_jobs
+        dummy.reload
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+
+      it "does not return missing url if false on instance" do
+        reset_dummy :with_processed => false, :url_with_processing => false
+        dummy.save!
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+        process_jobs  # There aren't any
+        dummy.reload
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+    end
+
+    # TODO: somewhat duplicate test of the above
+    context "original url without processing column" do
+      it "works normally" do
+        dummy.save!
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+    end
+  end
+
+  describe "set post processing" do
+    before :each do
+      reset_dummy :with_processed => true
+      dummy.image.post_processing = true
+    end
+    it "has delay_processing is false" do
+      dummy.image.delay_processing?.should be_false
+    end
+
+    it "post processing returns true" do
+      dummy.image.post_processing.should be_true
+    end
+
+    it "writes the file" do
+      dummy.save
+      File.exists?(dummy.image.path).should be_true
+    end
+  end
+
+  describe "without processing column" do
+    before :each do
+      build_dummy_table(false)
+      reset_class "Dummy", :with_processed => true
+      Paperclip::Attachment.any_instance.expects(:post_process).never
+    end
+
+    it "delays processing" do
+      dummy.image.delay_processing?.should be_true
+    end
+
+    it "post_processing is false" do
+      dummy.image.post_processing.should be_false
+    end
+
+    it "has file after save" do
+      dummy.save
+      File.exists?(dummy.image.path).should be_true
+    end
+
+  end
+
+  describe "jobs count" do
+    it "increments by 1" do
+      original_job_count = jobs_count
+      dummy.save
+      jobs_count.should == original_job_count + 1
+    end
+  end
+
+  describe "processing column not altered" do
+    it "resets after job finished" do
+      dummy.save!
+      dummy.image_processing?.should be_true
+      process_jobs
+      dummy.reload.image_processing?.should be_false
+    end
+
+    context "with error" do
+      before :each do
+        Paperclip::Attachment.any_instance.stubs(:reprocess!).raises(StandardError.new('oops'))
+      end
+
+      it "stays true even if errored" do
+        dummy.save!
+        dummy.image_processing?.should be_true
+        process_jobs
+        dummy.image_processing?.should be_true
+        dummy.reload.image_processing?.should be_true
+      end
+    end
+  end
+
+  # TODO: test appears redundant
+  describe "processing is true for new record" do
+    it "is true" do
+      dummy.image_processing?.should be_false
+      dummy.new_record?.should be_true
+      dummy.save!
+      dummy.reload.image_processing?.should be_true
+    end
+  end
+
+  describe "urls" do
+    it "returns missing url until job is finished" do
+      dummy.save!
+      dummy.image.url.should start_with("/images/original/missing.png")
+      process_jobs
+      dummy.reload
+      dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+    end
+
+    context "processing url" do
+      before :each do
+        reset_dummy :processing_image_url => "/images/original/processing.png"
+      end
+
+      it "returns processing url while processing" do
+        dummy.save!
+        dummy.image.url.should start_with("/images/original/processing.png")
+        process_jobs
+        dummy.reload
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+
+      context "defaults to missing when no file" do
+        it "fallsback gracefully" do
+          dummy = Dummy.new()
+          dummy.save!
+          dummy.reload.image.url.should start_with("/images/original/missing.png")
+        end
+      end
+    end
+
+    context "same url if same file assigned" do
+      it "falls to missing while processing" do
+        dummy.save!
+        dummy.image = File.open("#{ROOT}/spec/fixtures/12k.png")
+        dummy.save!
+        dummy.image.url.should start_with("/images/original/missing.png")
+        process_jobs
+        dummy.reload.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+    end
+
+  end
+
+  describe "callbacks" do
+    context "paperclip callback" do
+      before :each do
+        Dummy.send(:define_method, :done_processing) { puts 'done' }
+        Dummy.after_image_post_process :done_processing
+        Dummy.any_instance.expects(:done_processing).once
+      end
+
+      it "observes after_image_post_process" do
+        dummy.save!
+        process_jobs
+      end
+    end
+
+    context "after_update callback" do
+      before :each do
+        reset_class "Dummy", :with_processed => true,
+                             :with_after_update_callback => true
+      end
+
+      it "hits after_update" do
+        Dummy.any_instance.expects(:reprocess).once
+        dummy.save!
+        process_jobs
+      end
+    end
+  end
+
+  describe "only_process option" do
+
+    # TODO: This test must be faulty
+    # https://github.com/jrgifford/delayed_paperclip/issues/40
+    context "passed just to delayed_paperclip argument" do
+      before :each do
+        reset_class "Dummy", :with_processed => true, :only_process => [:thumbnail]
+      end
+
+      it "reprocesses just those" do
+        Paperclip::Attachment.any_instance.expects(:reprocess!).with(:thumbnail).once
+        dummy.save!
+        process_jobs
+      end
+    end
+
+    context "inherits from paperclip options" do
+      before :each do
+        reset_class "Dummy", :with_processed => true, :paperclip => { :only_process => [:thumbnail] }
+      end
+
+      it "reprocesses just those" do
+        Paperclip::Attachment.any_instance.expects(:reprocess!).with(:thumbnail).once
+        dummy.save!
+        process_jobs
+      end
+    end
+  end
+
+  describe "converts image formats" do
+    before :each do
+      reset_class "Dummy",  :with_processed => true,
+                            :paperclip => {
+                              :styles => {
+                                :thumbnail => ['12x12', :jpg]
+                              }
+                            }
+    end
+
+    it "observes the option" do
+      dummy.save!
+      process_jobs
+      dummy.reload.image.url(:thumbnail).should start_with("/system/dummies/images/000/000/001/thumbnail/12k.jpg")
+      File.exists?(dummy.image.path).should be_true
+    end
+  end
+
+  describe "reprocess_without_delay" do
+    before :each do
+      DelayedPaperclip.options[:url_with_processing] = true
+      reset_dummy :paperclip => {
+                    :styles => {
+                      :thumbnail => '12x12'
+                    }
+                  }
+    end
+
+    it "does not increase jobs count" do
+      dummy.save!
+      dummy.image_processing?.should be_true
+      process_jobs
+      dummy.reload.image_processing?.should be_false
+
+      Paperclip::Attachment.any_instance.expects(:reprocess!).once
+
+      existing_jobs = jobs_count
+      dummy.image.reprocess_without_delay!(:thumbnail)
+      existing_jobs.should == jobs_count
+
+      dummy.image_processing?.should be_false
+      File.exists?(dummy.image.path).should be_true
+    end
+
+  end
+
+  describe "reprocessing_url" do
+
+    context "interpolation of styles" do
+      before :each do
+        reset_dummy :processing_image_url => "/images/:style/processing.png",
+                    :paperclip => {
+                      :styles => {
+                        :thumbnail => '12x12'
+                      }
+                    }
+      end
+
+      it "interpolates unporcessed image" do
+        dummy.save!
+        dummy.image.url.should start_with("/images/original/processing.png")
+        dummy.image.url(:thumbnail).should start_with("/images/thumbnail/processing.png")
+        process_jobs
+        dummy.reload.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+    end
+
+    context "proc for reprocessing_url" do
+      before :each do
+        reset_dummy :processing_image_url => lambda { |attachment| attachment.instance.reprocessing_url }
+        Dummy.send(:define_method, :reprocessing_url) { 'done' }
+      end
+
+      it "calls it correctly" do
+        dummy.save!
+        dummy.image.url.should start_with("done")
+        process_jobs
+        dummy.reload
+        dummy.image.url.should start_with("/system/dummies/images/000/000/001/original/12k.png")
+      end
+    end
+  end
+
+end
+

data/spec/integration/resque_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'resque'
+
+describe "Resque" do
+
+  before :all do
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Resque
+    Resque.remove_queue(:paperclip)
+  end
+
+  let(:dummy) { Dummy.new(:image => File.open("#{ROOT}/spec/fixtures/12k.png")) }
+
+  describe "integration tests" do
+    include_examples "base usage"
+  end
+
+  describe "perform job" do
+    before :each do
+      DelayedPaperclip.options[:url_with_processing] = true
+      reset_dummy
+    end
+
+    it "performs a job" do
+      dummy.image = File.open("#{ROOT}/spec/fixtures/12k.png")
+      Paperclip::Attachment.any_instance.expects(:reprocess!)
+      dummy.save!
+      DelayedPaperclip::Jobs::Resque.perform(dummy.class.name, dummy.id, :image)
+    end
+  end
+
+  def process_jobs
+    worker = Resque::Worker.new(:paperclip)
+    worker.process
+  end
+
+  def jobs_count
+    Resque.size(:paperclip)
+  end
+
+end

data/spec/integration/sidekiq_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'sidekiq'
+
+describe "Sidekiq" do
+
+  before :all do
+    Sidekiq.logger.level = Logger::ERROR
+    DelayedPaperclip.options[:background_job_class] = DelayedPaperclip::Jobs::Sidekiq
+    Sidekiq::Queue.new(:paperclip).clear
+  end
+
+  let(:dummy) { Dummy.new(:image => File.open("#{ROOT}/spec/fixtures/12k.png")) }
+
+  describe "integration tests" do
+    include_examples "base usage"
+  end
+
+  describe "perform job" do
+    before :each do
+      DelayedPaperclip.options[:url_with_processing] = true
+      reset_dummy
+    end
+
+    it "performs a job" do
+      dummy.image = File.open("#{ROOT}/spec/fixtures/12k.png")
+      Paperclip::Attachment.any_instance.expects(:reprocess!)
+      dummy.save!
+      DelayedPaperclip::Jobs::Sidekiq.new.perform(dummy.class.name, dummy.id, :image)
+    end
+  end
+
+  def process_jobs
+    Sidekiq::Queue.new(:paperclip).each do |job|
+      worker = job.klass.constantize.new
+      args   = job.args
+      begin
+        worker.perform(*args)
+      rescue # Assume sidekiq handle exception properly
+      end
+      job.delete
+    end
+  end
+
+  def jobs_count
+    Sidekiq::Queue.new(:paperclip).size
+  end
+
+end