airbrush 0.0.2

data/spec/airbrush/client_spec.rb

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'starling'
+
+describe Airbrush::Client, 'job management' do
+
+  before do
+    @id = :id
+    @command = :command
+    @args = {}
+    @results = { :results => 'results' }
+    @queue = 'incoming'
+    @response_timeout = 5.minutes
+    @queue_validity = 15.minutes
+
+    @server = mock(Starling)
+    @server.stub!(:set).and_return
+    @server.stub!(:get).and_return(@results)
+    Starling.stub!(:new).and_return(@server)
+
+    @host = 'host'
+    @client = Airbrush::Client.new(@host, @queue, @response_timeout, @queue_validity)
+  end
+
+  describe 'when created' do
+
+    it 'should support a configurable target memcache host' do
+      @client.host.should == @host
+    end
+
+    it 'should support a configurable inbound queue name' do
+      @client.incoming_queue.should == @queue
+    end
+
+    it 'should support a configurable target memcache host' do
+      @client.response_timeout.should == @response_timeout
+    end
+
+    it 'should support a configurable queue validity' do
+      @client.queue_validity.should == @queue_validity
+    end
+
+  end
+
+  describe 'job management' do
+
+    it 'should allow a job to be posted' do
+      @client.should respond_to(:process)
+    end
+
+    it 'should allow access to the results returned by a job' do
+      @client.process(@id, @command, @args).should == @results
+    end
+
+  end
+
+  describe 'a posted job' do
+
+    it 'should raise an error if the id is not valid' do
+      lambda { @client.process(nil, @command, @args) }.should raise_error
+    end
+
+    it 'should raise an error if the command is not valid' do
+      lambda { @client.process(@id, nil, @args) }.should raise_error
+    end
+
+    it 'should raise an error if the args are not valid' do
+      lambda { @client.process(@id, @command, nil) }.should raise_error
+    end
+
+    it 'should support optional arguments' do
+      lambda { @client.process(@id, @command) }.should_not raise_error
+    end
+
+    it 'should time out after 2 minutes seconds of inactivity' do
+      Airbrush::Client::DEFAULT_RESPONSE_TIMEOUT.should == 2.minutes
+      Timeout.should_receive(:timeout).and_return
+      @client.process(@id, @command)
+    end
+
+    it 'should add the job into the incoming process queue' do
+      @server.should_receive(:set).with(@queue, { :id => @id, :command => @command, :args => @args }, @queue_validity, false)
+      @client.process(@id, @command, @args)
+    end
+
+  end
+
+end

data/spec/airbrush/handler_spec.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe Airbrush::Handler, 'during creation' do
+  
+  it 'should raise an error if given a nil processor' do
+    lambda { Airbrush::Handler.new(nil, Airbrush::Publishers::Publisher.new) }.should raise_error
+  end
+  
+  it 'should raise an error if given a nil publisher' do
+    lambda { Airbrush::Handler.new(Airbrush::Processors::Processor.new, nil) }.should raise_error
+  end
+  
+end
+
+describe Airbrush::Handler, 'when processing a request' do
+  
+  before do
+    @processor = mock(Airbrush::Processors::Processor)
+    @processor.stub!(:dispatch).and_return(true)
+    
+    @publisher = mock(Airbrush::Publishers::Publisher)
+    @publisher.stub!(:publish).and_return
+    
+    @handler = Airbrush::Handler.new(@processor, @publisher)
+    
+    @id = 'id'
+    @command = :command
+    @args = {}    
+  end
+  
+  it 'should pass the request to the processor' do
+    @processor.should_receive(:dispatch).with(@command, @args).and_return(true)
+    @handler.process @id, @command, @args
+  end
+  
+  it 'should publish the processors result' do
+    @publisher.should_receive(:publish).with(@id, true).and_return
+    @handler.process @id, @command, @args
+  end
+  
+  it 'should handle errors raised from the processor gracefully'
+  it 'should handle errors raised from the publisher gracefully'
+  
+end

data/spec/airbrush/listeners/listener_spec.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe Airbrush::Listeners::Listener, 'when created' do
+  
+  before do
+    @listener = Airbrush::Listeners::Listener.new
+  end
+  
+  it 'should provide access to the handler instance' do
+    @listener.handler = Airbrush::Handler.new(mock(Airbrush::Processors::Processor), mock(Airbrush::Publishers::Publisher))
+    @listener.handler.should_not be_nil
+  end
+  
+  it 'should raise an error if start is attempted (since its an abstract class)' do
+    lambda { @listener.start }.should raise_error
+  end
+  
+end

data/spec/airbrush/listeners/memcache_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'starling'
+
+describe Airbrush::Listeners::Memcache, 'initialization' do
+  
+  before do
+    @host = 'host'
+    @frequency = 5
+  end
+  
+  describe Airbrush::Listeners::Memcache, 'when created' do
+  
+    before do
+      @memcache = Airbrush::Listeners::Memcache.new(@host, @frequency)
+    end
+  
+    it 'should configure access to the remote memcache server host' do
+      @memcache.host.should == @host
+    end
+  
+    it 'should configure the poll frequency time' do
+      @memcache.poll_frequency.should == @frequency
+    end
+  
+    # future
+    it 'should accept a configurable incoming job queue name'
+  
+  end
+  
+  describe Airbrush::Listeners::Memcache, 'signal handling' do
+    
+    before do
+      Signal.stub!(:trap).and_return
+    end
+    
+    it 'should catch sigint and disconnect from the memcache server' do
+      Signal.should_receive(:trap).with('INT').and_return
+      Airbrush::Listeners::Memcache.new(@host, @frequency)
+    end
+  
+  end
+  
+  describe Airbrush::Listeners::Memcache, 'when started' do
+  
+    before do
+      @op = { :command => :command, :args => {}, :id => 'id' }
+      @server = mock(MemCache)
+      @server.stub!(:get).and_return(@op)
+      MemCache.stub!(:new).and_return(@server)
+    
+      @handler = mock(Airbrush::Handler)
+      @handler.stub!(:process).and_return
+
+      @memcache = Airbrush::Listeners::Memcache.new(@host)
+      @memcache.handler = @handler
+    end
+  
+    it 'should connect to the remote memcache server' # REVISIT: can't call start since it loops forever
+  
+    it 'should poll the remote memcache server for jobs' # REVISIT: can't call start since it loops forever
+  
+    it 'should sleep 2 seconds inbetween memcache server polls' # REVISIT: can't call start since it loops forever
+  
+    it 'should ensure remote jobs are contained inside a hash' do
+      @server.stub!(:get).and_return("bad format")
+      @handler.should_not_receive(:process)
+      @memcache.send :process, @server
+    end
+    
+    it 'should ensure remote jobs include a :id key' do
+      @server.stub!(:get).and_return(@op.except(:id))
+      @handler.should_not_receive(:process)
+      @memcache.send :process, @server
+    end
+  
+    it 'should ensure remote jobs include a :command key' do
+      @server.stub!(:get).and_return(@op.except(:command))
+      @handler.should_not_receive(:process)
+      @memcache.send :process, @server
+    end
+
+    it 'should ensure remote jobs include an :args key' do
+      @server.stub!(:get).and_return(@op.except(:args))
+      @handler.should_not_receive(:process)
+      @memcache.send :process, @server
+    end
+  
+    it 'should log invalid jobs' do
+      @server.stub!(:get).and_return('invalid job')
+      @server.stub!(:valid?).and_return(false)
+      @server.log.should_receive(:error).and_return
+      @handler.should_not_receive(:process)
+      @memcache.send :process, @server
+    end
+  
+    it 'should ignore invalid jobs (ie. invalid jobs should not halt processing)' do
+      @server.stub!(:get).and_return(nil)
+      @handler.should_not_receive(:process)
+    
+      lambda { @memcache.send :process, @server }.should_not raise_error
+    end
+  
+    it 'should pass valid jobs to the handler' do
+      @handler.should_receive(:process).with(@op[:id], @op[:command], @op[:args]).and_return
+      @memcache.send :process, @op
+    end
+  
+    it 'should log errors return from the handler' do
+      @server.stub!(:get).and_return(@op)
+      @server.log.should_receive(:error).twice.and_return
+      @handler.should_receive(:process).with(@op[:id], @op[:command], @op[:args]).and_raise('Error')
+      @memcache.send :process, @op
+    end
+    
+    it 'should ignore errors returned from the handler (ie. errors raised from the handler should not halt processing)' do
+      @server.stub!(:get).and_return(@op)
+      @handler.stub!(:process).and_raise("Test Error")
+    
+      lambda { @memcache.send :process, @server }.should_not raise_error
+    end
+  
+    it 'should accept a configurable poll time frequency' do
+      @memcache = Airbrush::Listeners::Memcache.new(@host, 10)
+      @memcache.poll_frequency.should == 10
+    end
+
+    # future
+    it 'should automatically discover the target memcache host address via dnssd'
+  end
+  
+end

data/spec/airbrush/processors/image/image_processor_spec.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/../../../spec_helper.rb'
+
+class MyImageProcessor < Airbrush::Processors::Image::ImageProcessor
+  before_filter :before
+  after_filter :after
+  
+  def command
+    'no op'
+  end
+end
+
+class MyExtraImageProcessor < Airbrush::Processors::Image::ImageProcessor
+  before_filter :before_extra
+  after_filter :after_extra
+  
+  def command
+    'no op'
+  end
+end
+
+describe Airbrush::Processors::Image::ImageProcessor, 'filter definitions' do
+  
+  before do
+    @processor1 = MyImageProcessor.new
+    @processor2 = MyExtraImageProcessor.new
+  end
+  
+  it 'should not override filters from other processors' do
+    @processor1.before_filters.should == [ :before ]
+    @processor2.before_filters.should == [ :before_extra ]
+    
+    @processor1.after_filters.should == [ :after ]
+    @processor2.after_filters.should == [ :after_extra ]
+  end
+  
+end
+
+describe Airbrush::Processors::Image::ImageProcessor, 'when dispatching' do
+  
+  before do
+    @args = {}
+    @processor = MyImageProcessor.new
+    @processor.stub!(:filter_dispatch).and_return
+  end
+  
+  it 'should invoke before filters before sending operation' do
+    @processor.should_receive(:filter_dispatch).with(:before, @args).and_return
+    @processor.dispatch :command, @args
+  end
+  
+  it 'should invoke after filters after sending operation' do
+    @processor.should_receive(:filter_dispatch).with(:after, @args).and_return
+    @processor.dispatch :command, @args
+  end
+  
+end

data/spec/airbrush/processors/image/rmagick_spec.rb

@@ -0,0 +1,179 @@
+require File.dirname(__FILE__) + '/../../../spec_helper.rb'
+require 'RMagick'
+
+describe Airbrush::Processors::Image::Rmagick do
+
+  before do
+    @image = 'image'
+    @columns = 1500; @rows = 1000
+    @blob = 'blob'
+
+    @rm_image = mock(Object)
+    @rm_image.stub!(:change_geometry).and_return
+    @rm_image.stub!(:crop!).and_return
+    @rm_image.stub!(:crop_resized!).and_return
+    @rm_image.stub!(:ensure_rgb!).and_return
+    @rm_image.stub!(:to_blob).and_return(@blob)
+    @rm_image.stub!(:format=).and_return('JPEG')
+    @rm_image.stub!(:columns).and_return(@columns)
+    @rm_image.stub!(:rows).and_return(@rows)
+    Magick::Image.stub!(:from_blob).and_return([@rm_image])
+
+    @processor = Airbrush::Processors::Image::Rmagick.new
+  end
+
+  describe 'when resizing' do
+
+    it 'should auto calculate width/height when passed a single value' do
+      Magick::Image.should_receive(:from_blob).and_return([@rm_image])
+      @processor.should_receive(:calculate_dimensions).with(@image, 300).and_return([300,200])
+
+      @processor.resize @image, 300
+    end
+
+    it 'should preprocess images before resizing' do
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:change_geometry).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.resize(@image, 300, 200).should == { :image => "blob", :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when cropping' do
+
+    it 'should preprocess images before cropping' do
+      @processor.crop @image, 10, 10, 100, 100
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop!).and_return
+      @processor.crop @image, 10, 10, 100, 100
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.crop(@image, 10, 10, 100, 100).should == { :image => "blob", :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when performing a resized crop' do
+
+    it 'should preprocess images before resizing/cropping' do
+      @processor.crop_resize @image, 75, 75
+    end
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop_resized!).and_return
+      @processor.crop_resize @image, 75, 75
+    end
+
+    it 'should convert images to rgb if required' do
+      @rm_image.should_receive(:ensure_rgb!).and_return
+      @processor.resize @image, 300, 200
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).and_return('blob')
+      @processor.crop_resize(@image, 75, 75).should == { :image => "blob", :height => 1000, :width => 1500 }
+    end
+
+  end
+
+  describe 'when generating previews' do
+
+    it 'should change the geometry of the image' do
+      @rm_image.should_receive(:crop_resized!).twice.and_return
+      @processor.previews @image, { :small => [200,100], :large => [500,250] }
+    end
+
+    it 'should return the raw image data back to the caller' do
+      @rm_image.should_receive(:to_blob).twice.and_return('blob')
+      @processor.previews(@image, { :small => [200,100], :large => [500,250] }).should == { :small=> { :image => "blob", :height => 1000, :width => 1500 }, :large=> { :image => "blob", :height => 1000, :width => 1500 }, :original => [1500, 1000] }
+    end
+
+  end
+
+  describe 'dimension calculation' do
+
+    it 'should automatically recognize images in portrait mode' do
+      @processor.send(:calculate_dimensions, @rm_image, 300).should == [300,200]
+    end
+
+    it 'should automatically recognize images in landscape mode' do
+      @rm_image.stub!(:columns).and_return(1000)
+      @rm_image.stub!(:rows).and_return(1500)
+      @processor.send(:calculate_dimensions, @rm_image, 300).should == [200,300]
+    end
+
+    it 'should automatically clip resizes if they are larger than the original' do
+      @processor.send(:calculate_dimensions, @rm_image, 2000).should == [1500,1000]
+    end
+
+  end
+
+end
+
+describe Magick::Image, 'when created' do
+
+  before do
+    @image = Magick::Image.new(200, 100)
+  end
+
+  it 'should be able to convert the profile to srgb when requested' do
+    @image.should respond_to(:ensure_rgb!)
+  end
+
+end
+
+describe Magick::Image, 'when converting images to sRGB' do
+
+  before do
+    @image = Magick::Image.new(200, 100)
+    @image.stub!(:add_profile).and_return
+  end
+
+  it 'should return if the image is already in sRGB colour space' do
+    @image.colorspace = Magick::RGBColorspace
+    @image.should_not_receive(:add_profile)
+    @image.ensure_rgb!
+  end
+
+  it 'should log a warning if a non CMYK/RGB image is encountered' do
+    @image.colorspace = Magick::Rec709LumaColorspace
+    @image.should_not_receive(:add_profile)
+    @image.log.should_receive(:warn).and_return
+    @image.ensure_rgb!
+  end
+
+  it 'should add a CMYK profile if the image does not have a profile and is in CMYK colour space' do
+    @image.colorspace = Magick::CMYKColorspace
+    @image.should_receive(:add_profile).twice.and_return
+    @image.ensure_rgb!
+  end
+
+  it 'should add a sRGB profile if the image is in CMYK colour space' do
+    @image.colorspace = Magick::CMYKColorspace
+    @image.should_receive(:add_profile).with(Magick::Image::SCT_SRGB_ICC).and_return
+    @image.ensure_rgb!
+  end
+
+end

data/spec/airbrush/processors/processor_spec.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+class MyProcessor < Airbrush::Processors::Processor
+
+  def my_action(one, two, three = '3')
+    [ one, two, three ]
+  end
+
+end
+
+describe Airbrush::Processors::Processor, 'abstract class' do
+
+  before do
+    @processor = Airbrush::Processors::Processor.new
+  end
+
+  it 'should return an error from dispatch if the requested command is not implemented by the processor' do
+    @processor.dispatch(:blah, {}).should == { :exception => "ERROR: Received error during processor dispatch for command 'blah' ()", :message => 'Unknown processor operation blah ()' }
+  end
+
+end
+
+describe Airbrush::Processors::Processor, 'argument handling' do
+
+  before do
+    @processor = MyProcessor.new
+  end
+
+  it 'should inspect the target action for its parameters and assign them via the argument hash' do
+    params = @processor.send :assign, :my_action, { :one => 'a', :two => 'b', :three => 'c' }
+    params.should == %w( a b c )
+  end
+
+  it 'should respect default values when present in action signatures, but not in the argument hash' do
+    params = @processor.send :assign, :my_action, { :one => 'a', :two => 'b' }
+    params.should == %w( a b 3 )
+  end
+
+  it 'should raise an error if an action signature value is missing from the argument hash and does not have a default value' do
+    lambda { @processor.send(:assign, :my_action, { :one => 'a' }) }.should raise_error
+  end
+
+end
+
+describe Airbrush::Processors::Processor, 'when processing' do
+
+  before do
+    @processor = MyProcessor.new
+  end
+
+  it 'should invoke the requested target action' do
+    @processor.dispatch(:my_action, { :one => 'a', :two => 'b' }).should == %w( a b 3 )
+  end
+end
+
+describe Airbrush::Processors::Processor, 'error handling' do
+
+  before do
+    @error = 'an error string'
+    @processor = MyProcessor.new
+    @processor.stub!(:my_action).and_raise(@error)
+  end
+
+  it 'should return an error from dispatch if the requested command raises an exception during processing' do
+    @processor.should_receive(:my_action).and_raise(@error)
+    @options = { :one => 'a', :two => 'b', :three => 'c' }
+    @processor.dispatch(:my_action, @options).should == { :exception => "ERROR: Received error during processor dispatch for command 'my_action' (#{@options.inspect})", :message => @error }
+  end
+
+end
+
+class FilteredProcessor < Airbrush::Processors::Processor
+  filter_params :password
+
+  def command(username, password); 'no op'; end
+end
+
+class ExtraFilteredProcessor < Airbrush::Processors::Processor
+  filter_params :username
+
+  def command(username, password); 'no_op'; end
+end
+
+describe Airbrush::Processors::Processor, 'filter definitions' do
+
+  before do
+    @processor1 = FilteredProcessor.new
+    @processor2 = ExtraFilteredProcessor.new
+  end
+
+  it 'should not override filters from other processors' do
+    @processor1.filtered_params.should == [ :password ]
+    @processor2.filtered_params.should == [ :username ]
+  end
+
+  describe 'filtering' do
+
+    before do
+      @params = { :username => 'username', :password => 'password' }
+    end
+
+    it 'should replace market parameter keys with a new value' do
+      { @processor1 => :password, @processor2 => :username }.each do |processor, filtered|
+        processor.send(:filter, @params).should == @params.update(filtered => '[FILTERED]')
+      end
+    end
+
+  end
+
+end

data/spec/airbrush/publishers/memcache_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+require 'starling'
+
+describe Airbrush::Publishers::Memcache, 'when created' do
+  
+  before do
+    @host = 'host'
+    @memcache = Airbrush::Publishers::Memcache.new(@host)
+  end
+
+  it 'should configure access to the remote memcache server host' do
+    @memcache.host.should == @host
+  end  
+  
+end
+
+describe Airbrush::Publishers::Memcache, 'when publishing' do
+  
+  before do
+    @host = 'host'
+    @server = mock(MemCache)
+    @server.stub!(:set).and_return
+    MemCache.stub!(:new).and_return(@server)
+    @results = "results"
+    @id = 'id'
+    
+    @memcache = Airbrush::Publishers::Memcache.new(@host)
+    @memcache.stub!(:unique_name).and_return('unique')
+  end
+
+  it 'should connect to the remote memcache server' do
+    MemCache.should_receive(:new).and_return(@server)
+    @memcache.publish(@id, @results)
+  end
+  
+  it 'should calculate a unique memcache queue name for publishing results' do
+    @memcache.should_receive(:unique_name).with(@id).and_return('unique')
+    @memcache.publish(@id, @results)
+  end
+  
+  it 'should publish the given results to the remote memcache server' do
+    @server.should_receive(:set).with('unique', @results).and_return
+    @memcache.publish(@id, @results)
+  end
+  
+end

data/spec/airbrush/publishers/publisher_spec.rb

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+describe Airbrush::Publishers::Publisher, 'when created' do
+  
+  before do
+    @publisher = Airbrush::Publishers::Publisher.new
+  end
+  
+  it 'should be able to create a unique name given an id' do
+    @publisher.send(:unique_name, 'id').should == 'id'
+  end
+  
+  it 'should accept a symbol as an id to make unique' do
+    @publisher.send(:unique_name, :id).should == 'id'
+  end
+  
+end