kt-delayed_paperclip 3.1.0

data/spec/delayed_paperclip/class_methods_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::ClassMethods do
+  before :each do
+    reset_dummy(with_processed: false)
+  end
+
+  describe ".process_in_background" do
+    it "is empty to start" do
+      Dummy.paperclip_definitions.should == { :image => {} }
+    end
+
+    it "adds basics to paperclip_definitions" do
+      Dummy.process_in_background(:image)
+      Dummy.paperclip_definitions.should == { :image => {
+        :delayed => {
+          :priority => 0,
+          :only_process => [],
+          :url_with_processing => true,
+          :processing_image_url => nil,
+          :queue => "paperclip"}
+        }
+      }
+    end
+
+    it "allows to set queue name" do
+      Dummy.process_in_background(:image, :queue => "custom")
+      expect(Dummy.paperclip_definitions).to eq({ :image => {
+        :delayed => {
+          :priority => 0,
+          :only_process => [],
+          :url_with_processing => true,
+          :processing_image_url => nil,
+          :queue => "custom"}
+        }
+      })
+    end
+
+    context "with processing_image_url" do
+      before :each do
+        Dummy.process_in_background(:image, processing_image_url: "/processing/url")
+      end
+
+      it "incorporates processing url" do
+        Dummy.paperclip_definitions.should == { :image => {
+          :delayed => {
+            :priority => 0,
+            :only_process => [],
+            :url_with_processing => true,
+            :processing_image_url => "/processing/url",
+            :queue => "paperclip"}
+          }
+        }
+      end
+    end
+
+    context "inherits only_process options" do
+      before :each do
+        reset_class("Dummy", paperclip: { only_process: [:small, :large] } )
+        Dummy.process_in_background(:image)
+      end
+
+      it "incorporates processing url" do
+        Dummy.paperclip_definitions.should == { :image => {
+          :only_process => [:small, :large],
+          :delayed => {
+            :priority => 0,
+            :only_process => [:small, :large],
+            :url_with_processing => true,
+            :processing_image_url => nil,
+            :queue => "paperclip"}
+          }
+        }
+      end
+    end
+
+    context "sets callback" do
+      context "commit" do
+        it "sets after_commit callback" do
+          Dummy.expects(:after_commit).with(:enqueue_delayed_processing)
+          Dummy.process_in_background(:image)
+        end
+      end
+
+      context "save" do
+        it "sets after_save callback" do
+          Dummy.stubs(:respond_to?).with(:attachment_definitions).returns(true)
+          Dummy.stubs(:respond_to?).with(:after_commit).returns(false)
+          Dummy.expects(:after_save).with(:enqueue_delayed_processing)
+          Dummy.process_in_background(:image)
+        end
+      end
+    end
+  end
+end

data/spec/delayed_paperclip/instance_methods_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::InstanceMethods do
+  before :each do
+    reset_dummy
+  end
+
+  let(:dummy) { Dummy.create }
+
+  describe "#enqueue_delayed_processing" do
+    it "marks enqueue_delayed_processing" do
+      dummy.expects(:mark_enqueue_delayed_processing)
+      dummy.enqueue_delayed_processing
+    end
+
+    it "enqueues post processing for all enqueued" do
+      dummy.instance_variable_set(:@_enqued_for_processing, ['image'])
+      dummy.expects(:enqueue_post_processing_for).with('image')
+      dummy.enqueue_delayed_processing
+    end
+
+    it "clears instance variables" do
+      dummy.instance_variable_set(:@_enqued_for_processing, ['foo'])
+      dummy.instance_variable_set(:@_enqued_for_processing_with_processing, ['image'])
+      dummy.expects(:enqueue_post_processing_for).with('foo')
+      dummy.enqueue_delayed_processing
+      dummy.instance_variable_get(:@_enqued_for_processing).should == []
+      dummy.instance_variable_get(:@_enqued_for_processing_with_processing).should == []
+    end
+  end
+
+  describe "#mark_enqueue_delayed_processing" do
+    it "updates columns of _processing" do
+      dummy.image_processing.should be_falsey
+      dummy.instance_variable_set(:@_enqued_for_processing_with_processing, ['image'])
+      dummy.mark_enqueue_delayed_processing
+      dummy.reload.image_processing.should be_truthy
+    end
+
+    it "does nothing if instance variable not set" do
+      dummy.image_processing.should be_falsey
+      dummy.mark_enqueue_delayed_processing
+      dummy.reload.image_processing.should be_falsey
+    end
+  end
+
+  describe "#enqueue_post_processing_for" do
+    it "enqueues the instance and image" do
+      DelayedPaperclip.expects(:enqueue).with("Dummy", dummy.id, :image)
+      dummy.enqueue_post_processing_for("image")
+    end
+  end
+
+  describe "#prepare_enqueueing_for" do
+    it "updates processing column to true" do
+      dummy.image_processing.should be_falsey
+      dummy.prepare_enqueueing_for("image")
+      dummy.image_processing.should be_truthy
+    end
+
+    it "sets instance variables for column updating" do
+      dummy.prepare_enqueueing_for("image")
+      dummy.instance_variable_get(:@_enqued_for_processing_with_processing).should == ["image"]
+    end
+
+    it "sets instance variables for processing" do
+      dummy.prepare_enqueueing_for("image")
+      dummy.instance_variable_get(:@_enqued_for_processing).should == ["image"]
+    end
+  end
+end

data/spec/delayed_paperclip/url_generator_spec.rb

@@ -0,0 +1,273 @@
+require 'spec_helper'
+
+describe DelayedPaperclip::UrlGenerator do
+  before :each do
+    reset_dummy({})
+  end
+
+  def make_attachment(options = {})
+    reset_dummy(options)
+    Dummy.create.image
+  end
+
+  describe "for" do
+    before :each do
+      attachment.stubs(:original_filename).returns "12k.png"
+    end
+
+    context "with split processing" do
+      let(:attachment) do
+        make_attachment(
+          {
+            paperclip: {
+              styles: {
+                online: "400x400x",
+                background: "600x600x"
+              },
+              only_process: [:online]
+            },
+
+            only_process: [:background]
+          }
+        )
+      end
+
+      context "processing" do
+        before :each do
+          attachment.stubs(:processing?).returns true
+        end
+
+        it "returns the default_url when the style is still being processed" do
+          expect(attachment.url(:background)).to eql "/images/background/missing.png"
+        end
+
+        it "returns the attachment url when the style is not set for background processing" do
+          expect(attachment.url(:online)).to eql "/system/dummies/images/000/000/001/online/12k.png"
+        end
+      end
+
+      context "not processing" do
+        before :each do
+          attachment.stubs(:processing?).returns false
+        end
+
+        it "returns the attachment url even when the style is set for background processing" do
+          expect(attachment.url(:background)).to eql "/system/dummies/images/000/000/001/background/12k.png"
+        end
+
+        it "returns the generated url when the style is not set for background processing" do
+          expect(attachment.url(:online)).to eql "/system/dummies/images/000/000/001/online/12k.png"
+        end
+      end
+
+      context "should be able to escape (, ), [, and ]." do
+        def generate(expected, updated_at = nil)
+          attachment = make_attachment(
+            {
+              paperclip: {
+                styles: {
+                  online: "400x400x",
+                  background: "600x600x"
+                },
+                only_process: [:online],
+                interpolator: MockInterpolator.new(result: expected)
+              },
+
+              only_process: [:background]
+            }
+          )
+          url_generator = DelayedPaperclip::UrlGenerator.new(attachment, {})
+          attachment.stubs(:updated_at).returns updated_at
+          url_generator.for(:style_name, {escape: true, timestamp: !!updated_at})
+        end
+
+        it "interpolates correctly without timestamp" do
+          expect(
+            "the%28expected%29result%5B%5D"
+          ).to eq(generate("the(expected)result[]"))
+        end
+
+        it "does not interpolate timestamp" do
+          expected = "the(expected)result[]"
+          updated_at = 1231231234
+
+          expect(
+            "the%28expected%29result%5B%5D?#{updated_at}"
+          ).to eq(generate(expected, updated_at))
+        end
+      end
+    end
+  end
+
+  describe "#most_appropriate_url" do
+    context "without delayed_default_url" do
+      let(:attachment) { make_attachment(paperclip: {url: "/blah/url.jpg"}) }
+
+      subject { DelayedPaperclip::UrlGenerator.new(attachment) }
+
+      before :each do
+        subject.stubs(:delayed_default_url?).returns false
+      end
+
+      context "with original file name" do
+        it "returns options url" do
+          attachment.stubs(:original_filename).returns "blah"
+          subjec = DelayedPaperclip::UrlGenerator.new(attachment)
+          subjec.stubs(:delayed_default_url?).returns false
+          subjec.most_appropriate_url.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
+          end
+        end
+
+        context "with delayed_options" do
+          before :each do
+            attachment.stubs(:delayed_options).returns(some: 'thing')
+          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
+            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.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
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "#timestamp_possible?" do
+    let(:attachment) { make_attachment }
+    subject { DelayedPaperclip::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?.should be_falsey
+      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.class.superclass.any_instance.expects(:timestamp_possible?)
+        subject.timestamp_possible?
+      end
+    end
+  end
+
+  describe "#delayed_default_url?" do
+    let(:attachment) { make_attachment }
+    subject { DelayedPaperclip::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
+      attachment.stubs(:processing_style?).with(anything).returns true
+    end
+
+    it "has all false, delayed_default_url returns true" do
+      subject.delayed_default_url?.should be_truthy
+    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_falsey
+      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_falsey
+      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_falsey
+      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_falsey
+      end
+    end
+
+    context "style is provided and is being processed" do
+      let(:style) { :main }
+      before :each do
+        attachment.stubs(:processing_style?).with(style).returns(true)
+      end
+
+      specify { expect(subject.delayed_default_url?(style)).to be }
+    end
+  end
+end

data/spec/delayed_paperclip_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe DelayedPaperclip do
+  before :each do
+    reset_dummy
+  end
+
+  describe ".options" do
+    it ".options returns basic options" do
+      DelayedPaperclip.options.should == {:background_job_class => DelayedPaperclip::ProcessJob,
+                                          :url_with_processing => true,
+                                          :processing_image_url => nil,
+                                          :queue => "paperclip"}
+    end
+  end
+
+  describe ".processor" do
+    it ".processor returns processor" do
+      DelayedPaperclip.processor.should == DelayedPaperclip::ProcessJob
+    end
+  end
+
+  describe ".enqueue" do
+    it "delegates to processor" do
+      DelayedPaperclip::ProcessJob.expects(:enqueue_delayed_paperclip).with("Dummy", 1, :image)
+      DelayedPaperclip.enqueue("Dummy", 1, :image)
+    end
+  end
+
+  describe ".process_job" do
+    let(:dummy) { Dummy.create! }
+
+    it "returns early on invalid id" do
+      dummy_stub = stub
+      dummy_stub.expects(:where).with(id: dummy.id).returns([])
+      Dummy.expects(:unscoped).returns(dummy_stub)
+      dummy.image.expects(:process_delayed!).never
+      DelayedPaperclip.process_job("Dummy", dummy.id, :image)
+    end
+
+    it "finds dummy and calls #process_delayed!" do
+      dummy_stub = stub
+      dummy_stub.expects(:where).with(id: dummy.id).returns([dummy])
+      Dummy.expects(:unscoped).returns(dummy_stub)
+      dummy.image.expects(:process_delayed!)
+      DelayedPaperclip.process_job("Dummy", dummy.id, :image)
+    end
+  end
+
+  describe "paperclip definitions" do
+    before :each do
+      reset_dummy :paperclip => { styles: { thumbnail: "25x25"} }
+    end
+
+    it "returns paperclip options regardless of version" do
+      expect(Dummy.paperclip_definitions).to eq({:image =>   { :styles => { :thumbnail => "25x25" },
+                                              :delayed => { :priority => 0,
+                                                            :only_process => [],
+                                                            :url_with_processing => true,
+                                                            :processing_image_url => nil,
+                                                            :queue => "paperclip"}
+                                                          }
+                                              })
+    end
+  end
+end