ungulate 0.1.4 → 0.2.0

data/spec/lib/ungulate/curl_http_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'ungulate/curl_http'
+
+module Ungulate
+  describe CurlHttp do
+    subject do
+      CurlHttp.new(:logger => ::Logger.new(nil))
+    end
+
+    it "can return the body of a resource from https" do
+      subject.get_body('https://dmxno528jhfy0.cloudfront.net/superhug-watermark.png').
+        should == fixture('watermark.png')
+    end
+
+    it "can PUT to a HTTP URL" do
+      response = subject.put('https://dmxno528jhfy0.cloudfront.net/superhug-watermark.png')
+      response.code.should == 403
+    end
+  end
+end

data/spec/{ungulate → lib/ungulate}/file_upload_spec.rb

@@ -1,5 +1,6 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'spec_helper'
 require 'ungulate/file_upload'
+require 'active_support/core_ext/numeric/time'
 
 module Ungulate
   describe FileUpload do
@@ -11,14 +12,15 @@ module Ungulate
     let(:queue_name) { 'some-queue-name' }
 
     before do
-      FileUpload.access_key_id = access_key_id
-      FileUpload.secret_access_key = secret_access_key
-      FileUpload.queue_name = queue_name
+      Ungulate.configure do |config|
+        config.access_key_id = access_key_id
+        config.secret_access_key = secret_access_key
+        config.queue_name = 'not-used'
+        config.queue = lambda { q }
+      end
     end
 
     its(:access_key_id) { should == access_key_id }
-    its(:queue_name) { should == queue_name }
-    its(:secret_access_key) { should == secret_access_key }
 
     context "policy set directly" do
       let(:policy) do
@@ -94,12 +96,11 @@ module Ungulate
     end
 
     describe "enqueue" do
-      let(:q) { stub 'queue' }
+      let(:q) { double 'queue' }
       let(:job_hash) { stub('Hash', :to_yaml => :some_yaml) }
-      before { Ungulate::FileUpload.stub(:queue).and_return(q) }
 
       it "queues the yamlised version of the passed job hash" do
-        q.should_receive(:send_message).with(:some_yaml)
+        q.should_receive(:push).with(:some_yaml)
         Ungulate::FileUpload.enqueue(job_hash)
       end
     end
@@ -153,24 +154,6 @@ module Ungulate
       end
     end
 
-    describe "queue" do
-      let(:sqs) do
-        sqs = stub 'SQS'
-        sqs.stub(:queue).with(queue_name).and_return(:queue_instance)
-        sqs
-      end
-
-      subject { Ungulate::FileUpload.queue }
-
-      before do
-        RightAws::SqsGen2.stub(:new).
-          with(access_key_id, secret_access_key).
-          and_return(sqs)
-      end
-
-      it { should == :queue_instance }
-    end
-
     describe "signature" do
       let(:sha1) { stub 'SHA1' }
 

data/spec/lib/ungulate/job_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+require 'ungulate/job'
+
+module Ungulate
+  describe Job do
+    subject do
+      Job.new(:blob_processor => blob_processor, :storage => storage,
+              :http => http, :logger => ::Logger.new(nil))
+    end
+
+    let(:http) { double 'http' }
+    let(:blob_processor) { double 'blob processor' }
+    let(:storage) { double 'storage', :bucket => bucket }
+    let(:bucket) { double 'bucket', :retrieve => nil }
+    let(:versions) do
+      {
+        :large => [ :resize_to_fill, 400, 300 ],
+        :medium => [ :resize_to_fit, 300, 200 ],
+        :thumbnail => [ :resize_to_fit, 40, 20 ]
+      }
+    end
+    let(:job_description) do
+      {
+        :bucket => 'some-bucket',
+        :key => 'original-key.jpg',
+        :versions => versions
+      }
+    end
+    let(:job_encoded) { job_description.to_yaml }
+
+    it "gets an original blob and sends it to be processed" do
+      blob = double 'blob'
+
+      storage.should_receive(:bucket).with('some-bucket', :listener => subject).
+        and_return(bucket)
+      bucket.should_receive(:retrieve).with('original-key.jpg').and_return(blob)
+
+      blob_processor.should_receive(:process).
+        with(:blob => blob, :versions => versions, :bucket => bucket,
+             :original_key => 'original-key.jpg')
+
+      subject.process(job_encoded)
+    end
+
+    context "with no notification URL" do
+      it "accepts storage complete messages, but does nothing" do
+        storage.stub(:get)
+        blob_processor.stub(:process)
+        subject.process(job_encoded)
+        subject.storage_complete(:large)
+        subject.storage_complete(:medium)
+
+        http.should_not_receive(:put)
+        subject.storage_complete(:thumbnail)
+      end
+    end
+
+    context "when notification URL set" do
+      let(:job_description) do
+        {
+          :bucket => 'some-bucket',
+          :key => 'original-key.jpg',
+          :notification_url => 'http://some.url',
+          :versions => versions
+        }
+      end
+
+      before do
+        storage.stub(:get)
+        blob_processor.stub(:process)
+        subject.process(job_encoded)
+      end
+
+      context "with only one version" do
+        let(:versions) { { :large => [ :resize_to_fill, 400, 300 ] } }
+
+        it "PUTs to the notification URL when only version stored" do
+          http.should_receive(:put).with('http://some.url')
+          subject.storage_complete(:large)
+        end
+      end
+
+      context "with three versions" do
+        let(:versions) do
+          {
+            :large => [ :resize_to_fill, 400, 300 ],
+            :medium => [ :resize_to_fit, 300, 200 ],
+            :thumbnail => [ :resize_to_fit, 40, 20 ]
+          }
+        end
+
+        it "PUTs to the notification URL when third version stored" do
+          subject.storage_complete(:large)
+          subject.storage_complete(:medium)
+
+          http.should_receive(:put).with('http://some.url')
+          subject.storage_complete(:thumbnail)
+        end
+      end
+
+      context "with a different URL" do
+        let(:job_description) do
+          {
+            :bucket => 'some-bucket',
+            :key => 'original-key.jpg',
+            :notification_url => 'http://some.other.url',
+            :versions => versions
+          }
+        end
+
+        it "uses the other URL" do
+          subject.storage_complete(:large)
+          subject.storage_complete(:medium)
+          http.should_receive(:put).with('http://some.other.url')
+          subject.storage_complete(:thumbnail)
+        end
+      end
+    end
+  end
+end

data/spec/lib/ungulate/rmagick_version_creator_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+require 'ungulate/rmagick_version_creator'
+
+module Ungulate
+  describe RmagickVersionCreator do
+    subject do
+      RmagickVersionCreator.new(:logger => ::Logger.new(nil),
+                                :http => http)
+    end
+
+    let(:http) { double 'http' }
+
+    shared_examples_for "an image converter" do
+      it "creates a matching blob" do
+        new_blob = subject.create(original, instructions)[:blob]
+
+        expected_image = Magick::Image.from_blob(converted).first
+        got_image = Magick::Image.from_blob(new_blob).first
+
+        expected_image.difference(got_image)
+
+        puts "good image:"
+        puts "mean per pixel: #{expected_image.mean_error_per_pixel}"
+        puts "normalized mean: #{expected_image.normalized_mean_error}"
+        puts "normalized max: #{expected_image.normalized_maximum_error}"
+
+        expected_image.mean_error_per_pixel.round.should be_zero
+        expected_image.normalized_maximum_error.round.should be_zero
+
+        expected_image.destroy!
+        got_image.destroy!
+      end
+
+      context "for a png" do
+        it "includes image/png as the content-type in the return hash" do
+          subject.create(original, instructions)[:content_type].
+            should == 'image/png'
+        end
+      end
+
+      context "for a jpeg" do
+        let(:original) { fixture 'chuckle.jpg' }
+
+        it "includes image/jpeg as the content-type in the return hash" do
+          subject.create(original, instructions)[:content_type].
+            should == 'image/jpeg'
+        end
+      end
+    end
+
+    context "resize to fill only" do
+      let(:original) { fixture 'chuckle.png' }
+      let(:converted) { fixture 'chuckle_thumbnail.png' }
+      let(:instructions) { [ :resize_to_fill, 80, 80 ] }
+      it_behaves_like "an image converter"
+    end
+
+    context "resize to fit and then composite" do
+      let(:url) { "https://some/watermark.png" }
+      let(:original) { fixture 'chuckle.png' }
+      let(:converted) { fixture 'chuckle_converted.png' }
+      let(:bad) { fixture 'chuckle_converted_badly.png' }
+
+      let(:instructions) do
+        [
+          [ :resize_to_fit, 628, 464 ],
+          [ :composite, url, :center_gravity, :soft_light_composite_op ]
+        ]
+      end
+
+      before do
+        http.should_receive(:get_body).with(url).and_return fixture('watermark.png')
+      end
+
+      it_behaves_like "an image converter"
+
+      it "doesn't compare well with a broken image" do
+        new_blob = subject.create(original, instructions)[:blob]
+        got_image = Magick::Image.from_blob(new_blob).first
+        bad_image = Magick::Image.from_blob(bad).first
+
+        bad_image.difference(got_image)
+
+        puts "bad image:"
+        puts "mean per pixel: #{bad_image.mean_error_per_pixel}"
+        puts "normalized mean: #{bad_image.normalized_mean_error}"
+        puts "normalized max: #{bad_image.normalized_maximum_error}"
+
+        bad_image.mean_error_per_pixel.round.should > 0
+        bad_image.normalized_maximum_error.round.should > 0
+
+        bad_image.destroy!
+        got_image.destroy!
+      end
+    end
+  end
+end

data/spec/lib/ungulate/s3_storage_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'ungulate/s3_storage'
+
+# integration test
+module Ungulate
+  describe S3Storage do
+    def new_storage
+      S3Storage.new(
+        :access_key_id => ENV['AMAZON_ACCESS_KEY_ID'],
+        :secret_access_key => ENV['AMAZON_SECRET_ACCESS_KEY']
+      )
+    end
+
+    subject { new_storage }
+
+    it "can store and retrieve blobs with keys" do
+      bucket = subject.bucket('ungulate-test')
+      bucket.clear
+      bucket.store('somekey', 'somedata')
+      bucket.retrieve('somekey').should == 'somedata'
+
+      bucket.store('someotherkey', 'someotherdata')
+      bucket.retrieve('someotherkey').should == 'someotherdata'
+    end
+
+    it "persists data across instances" do
+      bucket = subject.bucket('ungulate-test')
+      bucket.clear
+      bucket.store('somekey', 'somedata')
+
+      new_storage.bucket('ungulate-test').
+        retrieve('somekey').should == 'somedata'
+    end
+
+    it "stores publicly accessible items with a long cache expiry" do
+      key = 'somekey'
+      bucket = subject.bucket('ungulate-test')
+      bucket.clear
+      bucket.store(key, 'somedata')
+
+      response = Curl::Easy.http_get("ungulate-test.s3.amazonaws.com/#{key}")
+      response.header_str.should include('Cache-Control: max-age=2629743')
+    end
+
+    it "sets the correct content-type" do
+      key = 'somekey.png'
+      bucket = subject.bucket('ungulate-test')
+      bucket.clear
+      bucket.store(key, 'somedata', :content_type => 'image/png')
+      response = Curl::Easy.http_get("ungulate-test.s3.amazonaws.com/#{key}")
+      response.content_type.should == 'image/png'
+    end
+
+    context "when listener set" do
+      it "notifies the listener when it's done" do
+        listener = double 'listener'
+        bucket = subject.bucket('ungulate-test', :listener => listener)
+
+        listener.should_receive(:storage_complete).with(:large)
+        bucket.store('large', 'largedata', :version => :large)
+      end
+
+      context "but no version passed" do
+        it "does not notify the listener" do
+          listener = double 'listener'
+          bucket = subject.bucket('ungulate-test', :listener => listener)
+
+          listener.should_not_receive(:storage_complete)
+          bucket.store('large', 'largedata')
+        end
+      end
+    end
+  end
+end

data/spec/lib/ungulate/server_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'ungulate/server'
+
+module Ungulate
+  describe Server do
+    subject do
+      Server.new(:job_processor => processor, :queue => queue,
+                 :logger => ::Logger.new(nil))
+    end
+
+    let(:processor) { double 'job processor' }
+    let(:queue_name) { 'queuename' }
+    let(:queue) { double 'queue', :name => 'Some Queue' }
+    let(:message) { double 'message', :to_s => '' }
+
+    it "receives a message from the provided queue and processes it with the processor" do
+      queue.should_receive(:receive).ordered.and_return(message)
+      message.should_receive(:to_s).and_return('job description')
+      processor.should_receive(:process).with('job description').ordered
+      message.should_receive(:delete).ordered
+
+      subject.run
+    end
+
+    it "returns truthy from run if it processed something" do
+      queue.stub(:receive).and_return(message)
+      message.stub(:delete)
+      processor.stub(:process).and_return(true)
+      subject.run.should be_true
+    end
+
+    it "returns whatever the processor returns" do
+      queue.stub(:receive).and_return(message)
+      message.stub(:delete)
+      processor.stub(:process).and_return('some message')
+      subject.run.should == 'some message'
+    end
+
+    it "returns falsey from run if it did not process anything" do
+      queue.stub(:receive).and_return(nil)
+      subject.run.should be_false
+    end
+  end
+end

data/spec/lib/ungulate/sqs_message_queue_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'ungulate/sqs_message_queue'
+
+# integration test - talks to real queue
+#
+# to spec a new message queue, copy this spec and change the require and
+# describe lines, and change new_queue to instantiate your queue class
+# message queues are always passed the options below, from the environment
+#
+# note that you'll probably need to wrap the messages returned from your queue
+# to behave like messages from SQS, i.e. they need to implement 'to_s' to convert
+# them to a string, and 'delete' to delete them from the queue
+module Ungulate
+  describe SqsMessageQueue do
+    def new_queue
+      SqsMessageQueue.new('some_test_queue',
+                          :access_key_id => ENV['AMAZON_ACCESS_KEY_ID'],
+                          :secret_access_key => ENV['AMAZON_SECRET_ACCESS_KEY'],
+                          :server => ENV['QUEUE_SERVER'])
+    end
+
+    it_behaves_like "a message queue"
+
+    it "raises an exception if queue name not set" do
+      expect { SqsMessageQueue.new('', {}) }.to raise_error(MissingConfiguration)
+    end
+  end
+end