image_vise 0.2.1 → 0.2.2

data/spec/image_vise/fetcher_http_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../spec_helper'
+
+describe ImageVise::FetcherHTTP do
+  it 'is a class (can be inherited from)' do
+    expect(ImageVise::FetcherHTTP).to be_kind_of(Class)
+  end
+
+  it 'is registered as a fetcher for http:// and https://' do
+    expect(ImageVise.fetcher_for('http')).to eq(ImageVise::FetcherHTTP)
+    expect(ImageVise.fetcher_for('https')).to eq(ImageVise::FetcherHTTP)
+  end
+
+  it 'raises an AccessError if the host of the URL is not on the whitelist' do
+    uri = URI('https://wrong-origin.com/image.psd')
+    expect {
+      ImageVise::FetcherHTTP.fetch_uri_to_tempfile(uri)
+    }.to raise_error(ImageVise::FetcherHTTP::AccessError, /is not permitted as source/)
+  end
+
+  it 'raises an UpstreamError if the upstream fetch returns an error-ish status code' do
+    uri = URI('http://localhost:9001/forbidden')
+    ImageVise.add_allowed_host! 'localhost'
+    
+    expect {
+      ImageVise::FetcherHTTP.fetch_uri_to_tempfile(uri)
+    }.to raise_error {|e|
+      expect(e).to be_kind_of(ImageVise::FetcherHTTP::UpstreamError)
+      expect(e.message).to include(uri.to_s)
+      expect(e.message).to include('403')
+      expect(e.http_status).to eq(403)
+    }
+  end
+
+  it 'fetches the image into a Tempfile' do
+    uri = URI(public_url_psd)
+    ImageVise.add_allowed_host! 'localhost'
+
+    result = ImageVise::FetcherHTTP.fetch_uri_to_tempfile(uri)
+
+    expect(result).to be_kind_of(Tempfile)
+    expect(result.size).to be_nonzero
+    expect(result.pos).to be_zero
+  end
+end

data/spec/image_vise/file_response_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../spec_helper'
+
+describe ImageVise::FileResponse do
+  it 'reads the file in binary mode, closes and unlinks the tempfile when close() is called' do
+    random_data = Random.new.bytes(1024 * 2048)
+    f = Tempfile.new("experiment")
+    f.binmode
+    f << random_data
+    
+    response = described_class.new(f)
+    readback = ''.encode(Encoding::BINARY)
+    response.each do | chunk |
+      expect(chunk.encoding).to eq(Encoding::BINARY)
+      readback << chunk
+    end
+    
+    response.close
+    
+    expect(readback).to eq(random_data)
+    expect(f).to be_closed
+    expect(f.path).to be_nil
+  end
+  
+  it 'only asks for the path of the tempfile and uses a separate file descriptor' do
+    f = Tempfile.new("experiment")
+    f.binmode
+    f << Random.new.bytes(2048)
+    f.flush
+    
+    # Use a double so that all the methods except the ones we mock raise an assertion
+    double = double(path: f.path)
+    expect(double).to receive(:flush)
+    
+    read_from_response = ''.encode(Encoding::BINARY)
+    response = described_class.new(double)
+    response.each{|b| read_from_response << b }
+    
+    f.rewind
+    
+    expect(f.read).to eq(read_from_response)
+    
+    f.close
+    f.unlink
+  end
+end

data/spec/image_vise/fit_crop_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe ImageVise::FitCrop do
+  it 'refuses invalid arguments' do
+    expect { described_class.new(width: 0, height: -1, gravity: '') }.to raise_error(ArgumentError)
+  end
+  
+  it 'applies the crop with different gravities' do
+    %w( s sw se n ne nw c).each do |gravity|
+      image = Magick::Image.read(test_image_path)[0]
+      crop = described_class.new(width: 120, height: 220, gravity: gravity)
+
+      crop.apply!(image)
+
+      expect(image.columns).to eq(120)
+      expect(image.rows).to eq(220)
+      examine_image(image, "gravity-%s-" % gravity)
+    end
+  end
+end

data/spec/image_vise/force_jpg_out_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+
+describe ImageVise::ForceJPGOut do
+  it "raises on invalid arguments" do
+    expect {
+      described_class.new({})
+    }.to raise_error(ArgumentError)
+
+    expect {
+      described_class.new(quality: '1')
+    }.to raise_error(ArgumentError)
+
+    expect {
+      described_class.new(quality: -1)
+    }.to raise_error(ArgumentError)
+
+    expect {
+      described_class.new(quality: 'very very low')
+    }.to raise_error(ArgumentError)
+
+    described_class.new(quality: 25)
+  end
+
+  it "sets the :writer metadata key to a JPGWriter" do
+    subject = described_class.new(quality: 25)
+    
+    fake_magick_image = double('Magick::Image')
+    metadata = {}
+
+    subject.apply!(fake_magick_image, metadata)
+
+    w = metadata.fetch(:writer)
+    expect(w).to be_kind_of(ImageVise::JPGWriter)
+    expect(w.quality).to eq(25)
+  end
+end

data/spec/image_vise/geom_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe ImageVise::Geom do
+  it 'refuses invalid parameters' do
+    expect { described_class.new(geometry_string: nil) }.to raise_error(ArgumentError)
+  end
+
+  it 'fits to height' do
+    image = Magick::Image.read(test_image_path)[0]
+    crop = described_class.new(geometry_string: 'x200')
+    crop.apply!(image)
+    expect(image.rows).to eq(200)
+    examine_image(image, 'fit-height-200')
+  end
+
+  it 'fits to width' do
+    image = Magick::Image.read(test_image_path)[0]
+    crop = described_class.new(geometry_string: '100x')
+    crop.apply!(image)
+    expect(image.columns).to eq(100)
+    examine_image(image, 'fit-width-100')
+  end
+
+  it 'applies various geometry strings' do
+    %w( ^220x110 !20x20 !10x100 ).each do |geom_string|
+      image = Magick::Image.read(test_image_path)[0]
+      crop = described_class.new(geometry_string: geom_string)
+
+      crop.apply!(image)
+      examine_image(image, 'geom-%s' % geom_string)
+    end
+  end
+end

data/spec/image_vise/image_request_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe ImageVise::ImageRequest do
+  it 'accepts a set of params and secrets, and returns a Pipeline' do
+    img_params = {src_url: 'http://bucket.s3.aws.com/image.jpg', pipeline: [[:crop, {width: 10, height: 10, gravity: 's'}]]}
+    img_params_json = JSON.dump(img_params)
+    
+    q = Base64.encode64(img_params_json)
+    signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, 'this is a secret', q)
+    params = {q: q, sig: signature}
+
+    image_request = described_class.from_params(qs_params: params, secrets: ['this is a secret'])
+    request_qs_params = image_request.to_query_string_params('this is a secret')
+    expect(request_qs_params).to be_kind_of(Hash)
+
+    image_request_roundtrip = described_class.from_params(qs_params: request_qs_params, secrets: ['this is a secret'])
+  end
+
+  it 'converts a file:// URL into a URI objectlist' do
+    img_params = {src_url: 'file:///etc/passwd', pipeline: [[:auto_orient, {}]]}
+    img_params_json = JSON.dump(img_params)
+    q = Base64.encode64(img_params_json)
+    signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, 'this is a secret', q)
+    params = {q: q, sig: signature}
+    image_request = described_class.from_params(qs_params: params, secrets: ['this is a secret'])
+    expect(image_request.src_url).to be_kind_of(URI)
+  end
+
+  it 'composes path parameters' do
+    parametrized = double(to_params: {foo: 'bar'})
+    uri = URI('http://example.com/image.psd')
+    image_request = described_class.new(src_url: uri, pipeline: parametrized)
+    path = image_request.to_path_params('password')
+    expect(path).to start_with('/eyJwaXB')
+    expect(path).to end_with('f207b')
+  end
+
+  it 'never apppends "="-padding to the Base64-encoded "q"' do
+    parametrized = double(to_params: {foo: 'bar'})
+    (1..12).each do |num_chars_in_url|
+      uri = URI('http://ex.com/%s'  % ('i' * num_chars_in_url))
+      image_request = described_class.new(src_url: uri, pipeline: parametrized)
+      q = image_request.to_query_string_params('password').fetch(:q)
+      expect(q).not_to include('=')
+    end
+  end
+
+  describe 'fails with an invalid signature' do
+    it 'when the sig is invalid' do
+      img_params = {src_url: 'http://bucket.s3.aws.com/image.jpg',
+          pipeline: [[:crop, {width: 10, height: 10, gravity: 's'}]]}
+      img_params_json = JSON.dump(img_params)
+      enc = Base64.encode64(img_params_json)
+      signature = OpenSSL::HMAC.hexdigest(OpenSSL::Digest::SHA256.new, 'a', enc)
+      params = {q: enc, sig: signature}
+      
+      expect {
+        described_class.from_params(qs_params: params, secrets: ['b'])
+      }.to raise_error(/Invalid or missing signature/)
+    end
+  end
+end

data/spec/image_vise/pipeline_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe ImageVise::Pipeline do
+  it 'is empty by default' do
+    expect(subject).to be_empty
+  end
+
+  it 'reinstates the pipeline from the operator list parameters' do
+    params = [
+      ["geom", {:geometry_string=>"10x10"}],
+      ["crop", {:width=>5, :height=>5, :gravity=>"se"}],
+      ["auto_orient", {}],
+      ["fit_crop", {:width=>10, :height=>32, :gravity=>"c"}]
+    ]
+    pipeline = described_class.from_param(params)
+    expect(pipeline).not_to be_empty
+  end
+
+  it 'produces a usable operator parameter list that can be roundtripped' do
+    operator_list = subject.geom(geometry_string: '10x10').
+      crop(width: 5, height: 5, gravity: 'se').
+      auto_orient.
+      fit_crop(width: 10, height: 32, gravity: 'c').to_params
+
+    expect(operator_list).to eq([
+      ["geom", {:geometry_string=>"10x10"}],
+      ["crop", {:width=>5, :height=>5, :gravity=>"se"}],
+      ["auto_orient", {}],
+      ["fit_crop", {:width=>10, :height=>32, :gravity=>"c"}]
+    ])
+
+    pipeline = described_class.from_param(operator_list)
+    expect(pipeline).not_to be_empty
+  end
+
+  it 'applies itself to the image' do
+    pipeline = subject.
+      auto_orient.
+      fit_crop(width: 48, height: 48, gravity: 'c').
+      srgb.
+      sharpen(radius: 2, sigma: 0.5).
+      ellipse_stencil.
+      strip_metadata
+
+    image = Magick::Image.read(test_image_path)[0]
+    pipeline.apply! image, {}
+    examine_image(image, "stenciled")
+  end
+
+  it 'raises an exception when an attempt is made to serialize an unknown operator' do
+    unknown_op_class = Class.new
+    subject << unknown_op_class.new
+    expect {
+      subject.to_params
+    }.to raise_error(/not registered/)
+  end
+
+  it 'composes parameters even if one of the operators does not support to_h' do
+    class AnonOp
+    end
+    class ParametricOp
+      def to_h; {a: 133}; end
+    end
+
+    ImageVise.add_operator('t_anon', AnonOp)
+    ImageVise.add_operator('t_parametric', ParametricOp)
+
+    subject << AnonOp.new
+    subject << ParametricOp.new
+    expect(subject.to_params).to eq([["t_anon", {}], ["t_parametric", {:a=>133}]])
+  end
+end

data/spec/image_vise/render_engine_spec.rb

@@ -0,0 +1,336 @@
+require_relative '../spec_helper'
+require 'rack/test'
+
+describe ImageVise::RenderEngine do
+  include Rack::Test::Methods
+
+  let(:app) { ImageVise::RenderEngine.new }
+
+  context 'when the subclass is configured to raise exceptions' do
+    after :each do
+      ImageVise.reset_allowed_hosts!
+      ImageVise.reset_secret_keys!
+    end
+
+    it 'raises an exception instead of returning an error response' do
+      class << app
+        def raise_exceptions?
+          true
+        end
+      end
+
+      p = ImageVise::Pipeline.new.crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: 'http://unknown.com/image.jpg', pipeline: p)
+      expect(app).to receive(:handle_generic_error).and_call_original
+      expect {
+        get image_request.to_path_params('l33tness')
+      }.to raise_error(/No keys set/)
+    end
+  end
+
+  context 'when requesting an image' do
+    before :each do
+      parsed_url = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(parsed_url.host)
+    end
+
+    after :each do
+      ImageVise.reset_allowed_hosts!
+      ImageVise.reset_secret_keys!
+    end
+
+    it 'halts with 400 when the requested image cannot be opened by ImageMagick' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+      uri.path = '/___nonexistent_image.jpg'
+
+      p = ImageVise::Pipeline.new.crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      expect_any_instance_of(Patron::Session).to receive(:get_file) {|_self, url, path|
+        File.open(path, 'wb') {|f| f << 'totally not an image' }
+        double(status: 200)
+      }
+      expect(app).to receive(:handle_request_error).and_call_original
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(400)
+      expect(last_response['Cache-Control']).to match(/public/)
+      expect(last_response.body).to include('Unsupported/unknown')
+    end
+
+    it 'halts with 400 when a file:// URL is given and filesystem access is not enabled' do
+      uri = 'file://' + test_image_path
+      ImageVise.deny_filesystem_sources!
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(403)
+      expect(last_response.body).to include('filesystem access is disabled')
+    end
+
+    it 'responds with 403 when upstream returns it, and includes the URL in the error message' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+      uri.path = '/forbidden'
+
+      p = ImageVise::Pipeline.new.crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(403)
+      expect(last_response.headers['Content-Type']).to eq('application/json')
+      parsed = JSON.load(last_response.body)
+      expect(parsed['errors'].to_s).to include("Unfortunate upstream response")
+      expect(parsed['errors'].to_s).to include(uri.to_s)
+    end
+
+    it 'replays upstream error response codes that are selected to be replayed to the requester' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      [404, 403, 503, 504, 500].each do | error_code |
+        allow_any_instance_of(Patron::Session).to receive(:get_file).and_return(double(status: error_code))
+
+        p = ImageVise::Pipeline.new.crop(width: 10, height: 10, gravity: 'c')
+        image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+        get image_request.to_path_params('l33tness')
+
+        expect(last_response.status).to eq(error_code)
+        expect(last_response.headers).to have_key('Cache-Control')
+        expect(last_response.headers['Cache-Control']).to match(/public/)
+
+        expect(last_response.headers['Content-Type']).to eq('application/json')
+        parsed = JSON.load(last_response.body)
+        expect(parsed['errors'].to_s).to include("Unfortunate upstream response")
+      end
+    end
+
+    it 'sets very far caching headers and an ETag, and returns a 304 if any ETag is set' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.fit_crop(width: 10, height: 35, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      req_path = image_request.to_path_params('l33tness')
+
+      get req_path, {}
+      expect(last_response).to be_ok
+      expect(last_response['ETag']).not_to be_nil
+      expect(last_response['Cache-Control']).to match(/public/)
+
+      get req_path, {}, {'HTTP_IF_NONE_MATCH' => last_response['ETag']}
+      expect(last_response.status).to eq(304)
+
+      # Should consider _any_ ETag a request to rerender something
+      # that already exists in an upstream cache
+      get req_path, {}, {'HTTP_IF_NONE_MATCH' => SecureRandom.hex(4)}
+      expect(last_response.status).to eq(304)
+    end
+
+    it 'responds with an image that passes through all the processing steps' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '512x335').fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+      expect(last_response.headers).to have_key('Content-Length')
+      parsed_image = Magick::Image.from_blob(last_response.body)[0]
+      expect(parsed_image.columns).to eq(10)
+    end
+
+    it 'properly decodes the image request if its Base64 representation contains masked slashes and plus characters' do
+      ImageVise.add_secret_key!("this is fab")
+      sig = '64759d9ea610d75d9138bfa3ea01595d343ca8994261ae06fca8e6490222f140'
+      q = 'eyJwaXBlbGluZSI6W1sic2hhcnBlbiIseyJyYWRpdXMiO' +
+       'jAuNSwic2lnbWEiOjAuNX1dXSwic3JjX3VybCI6InNoYWRl' +
+       'cmljb246L0NQR1BfRmlyZWJhbGw-Yz1kOWM4ZTMzO'+
+       'TZmNjMwYzM1MjM0MTYwMmM2YzJhYmQyZjAzNTcxMTF'+
+       'jIn0'
+      params = {q: q, sig: sig}
+      req = ImageVise::ImageRequest.from_params(qs_params: params, secrets: ['this is fab'])
+
+      # We do a check based on the raised exception - the request will fail
+      # at the fetcher lookup stage. That stage however takes place _after_ the
+      # signature has been validated, which means that the slash within the
+      # Base64 payload has been taken into account
+      expect(app).to receive(:raise_exceptions?).and_return(true)
+      expect {
+        get req.to_path_params('this is fab')
+      }.to raise_error(/No fetcher registered for shadericon/)
+    end
+
+    it 'calls all of the internal methods during execution' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '512x335').fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+      params = image_request.to_query_string_params('l33tness')
+
+      expect(app).to receive(:parse_env_into_request).and_call_original
+      expect(app).to receive(:process_image_request).and_call_original
+      expect(app).to receive(:extract_params_from_request).and_call_original
+      expect(app).to receive(:image_rack_response).and_call_original
+      expect(app).to receive(:source_file_type_permitted?).and_call_original
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'picks the image from the filesystem if that is permitted' do
+      uri = 'file://' + test_image_path
+      ImageVise.allow_filesystem_source!(File.dirname(test_image_path) + '/*.*')
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+    end
+
+    it 'URI-decodes the path in a file:// URL for a file with a Unicode path' do
+      utf8_file_path = File.dirname(test_image_path) + '/картинка.jpg'
+      FileUtils.cp_r(test_image_path, utf8_file_path)
+      uri = 'file://' + URI.encode(utf8_file_path)
+
+      ImageVise.allow_filesystem_source!(File.dirname(test_image_path) + '/*.*')
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      File.unlink(utf8_file_path)
+      expect(last_response.status).to eq(200)
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+    end
+
+    it 'forbids a request with an extra GET param' do
+      uri = 'file://' + URI.encode(test_image_path)
+
+      p = ImageVise::Pipeline.new.fit_crop(width: 10, height: 10, gravity: 'c')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness'), {'extra' => '123'}
+
+      expect(last_response.status).to eq(400)
+    end
+
+    it 'returns the processed JPEG image as a PNG if it had to get an alpha channel during processing' do
+      uri = Addressable::URI.parse(public_url)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '220x220').ellipse_stencil
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+
+      expect(last_response.headers['Content-Type']).to eq('image/png')
+      expect(last_response.headers).to have_key('Content-Length')
+
+      examine_image_from_string(last_response.body)
+    end
+
+    it 'permits a PSD file by default' do
+      uri = Addressable::URI.parse(public_url_psd)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '220x220').ellipse_stencil
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'destroys all the loaded PSD layers' do
+      uri = Addressable::URI.parse(public_url_psd_multilayer)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '220x220')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      class << app
+        def raise_exceptions?; true; end
+      end
+
+      # For each layer loaded into the ImageList
+      expect(ImageVise).to receive(:destroy).and_call_original.exactly(5).times
+
+      get image_request.to_path_params('l33tness')
+
+      expect(last_response.status).to eq(200)
+    end
+
+    it 'outputs a converted TIFF file as a PNG' do
+      uri = Addressable::URI.parse(public_url_tif)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('l33tness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: '220x220')
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      class << app
+        def source_file_type_permitted?(type); true; end
+      end
+
+      get image_request.to_path_params('l33tness')
+      expect(last_response.status).to eq(200)
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+    end
+
+    it 'processes a 1.5mb PSD with a forced conversion to JPEG' do
+      uri = Addressable::URI.parse(public_url_psd)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('1337ness')
+
+      p = ImageVise::Pipeline.new.geom(geometry_string: 'x220').force_jpg_out(quality: 85)
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('1337ness')
+
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+      expect(last_response.status).to eq(200)
+
+      examine_image_from_string(last_response.body)
+    end
+
+    it 'converts a PNG into a JPG applying a background fill' do
+      uri = Addressable::URI.parse(public_url_png_transparency)
+      ImageVise.add_allowed_host!(uri.host)
+      ImageVise.add_secret_key!('h00ray')
+
+      p = ImageVise::Pipeline.new.background_fill(color: 'white').geom(geometry_string: 'x220').force_jpg_out(quality: 5)
+      image_request = ImageVise::ImageRequest.new(src_url: uri.to_s, pipeline: p)
+
+      get image_request.to_path_params('h00ray')
+
+      expect(last_response.status).to eq(200)
+      expect(last_response.headers['Content-Type']).to eq('image/jpeg')
+
+      examine_image_from_string(last_response.body)
+    end
+  end
+end

data/spec/image_vise/sharpen_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe ImageVise::Sharpen do
+  it 'refuses invalid parameters' do
+    expect { described_class.new(sigma: 0, radius: -1) }.to raise_error(ArgumentError)
+  end
+  
+  it 'applies the crop with different gravities' do
+    [[1, 1], [4, 2], [0.75, 0.5]].each do |(r, s)|
+      image = Magick::Image.read(test_image_path)[0]
+      expect(ImageVise).to receive(:destroy).with(instance_of(Magick::Image)).and_call_original
+      sharpen = described_class.new(radius: r, sigma: s)
+      sharpen.apply!(image)
+      examine_image(image, "sharpen-rad_%02f-sigma_%02f" % [r, s])
+    end
+  end
+end