dragonfly 0.9.15 → 1.0

data/spec/dragonfly/job_endpoint_spec.rb

@@ -6,7 +6,7 @@ require 'spec_helper'
 describe "Dragonfly::JobEndpoint Rack::Lint tests" do
   before(:each) do
     @app = test_app
-    @app.generator.add(:test_data){ "Test Data" }
+    @app.add_generator(:test_data){|content| content.update("Test Data") }
     @job = @app.generate(:test_data)
     @endpoint = Rack::Lint.new(Dragonfly::JobEndpoint.new(@job))
   end
@@ -37,13 +37,14 @@ describe Dragonfly::JobEndpoint do
   def make_request(job, opts={})
     endpoint = Dragonfly::JobEndpoint.new(job)
     method = (opts.delete(:method) || :get).to_s.upcase
-    Rack::MockRequest.new(endpoint).request(method, '', opts)
+    uri = opts[:path] || ""
+    Rack::MockRequest.new(endpoint).request(method, uri, opts)
   end
 
   before(:each) do
     @app = test_app
-    @app.datastore.stub!(:retrieve).with('egg').and_return(["GUNGLE", {:name => 'gung.txt'}])
-    @job = @app.new_job.fetch('egg')
+    uid = @app.store("GUNGLE", 'name' => 'gung.txt')
+    @job = @app.fetch(uid)
   end
 
   it "should return a correct response to a successful GET request" do
@@ -75,21 +76,29 @@ describe Dragonfly::JobEndpoint do
       response.status.should == 405
       response['Allow'].should == "GET, HEAD"
       response['Content-Type'].should == 'text/plain'
-      response.body.should == "#{method} method not allowed"
+      response.body.should == "method not allowed"
     end
 
   end
 
-  it "should return 404 if the datastore raises data not found" do
-    @job.should_receive(:apply).and_raise(Dragonfly::DataStorage::DataNotFound)
+  it "should return 404 if the datastore raises NotFound" do
+    @job.should_receive(:apply).and_raise(Dragonfly::Job::Fetch::NotFound)
     response = make_request(@job)
     response.status.should == 404
   end
 
-  it "should return a 404 if the datastore raises bad uid" do
-    @job.should_receive(:apply).and_raise(Dragonfly::DataStorage::BadUID)
+  it "returns a 500 for any runtime error" do
+    @job.should_receive(:apply).and_raise(RuntimeError, "oh dear")
+    Dragonfly.should_receive(:warn).with(/oh dear/)
     response = make_request(@job)
-    response.status.should == 404
+    response.status.should == 500
+  end
+
+  describe "logging" do
+    it "logs successful requests" do
+      Dragonfly.should_receive(:info).with("GET /something?great 200")
+      make_request(@job, :path => '/something?great')
+    end
   end
 
   describe "ETag" do
@@ -105,7 +114,7 @@ describe Dragonfly::JobEndpoint do
       '*'
     ].each do |header|
       it "should return a 304 if the correct ETag is specified in HTTP_IF_NONE_MATCH header e.g. #{header}" do
-        @job.should_receive(:unique_signature).at_least(:once).and_return('dingle')
+        @job.should_receive(:signature).at_least(:once).and_return('dingle')
         response = make_request(@job, 'HTTP_IF_NONE_MATCH' => header)
         response.status.should == 304
         response['ETag'].should == '"dingle"'
@@ -115,70 +124,14 @@ describe Dragonfly::JobEndpoint do
     end
 
     it "should not have applied any steps if the correct ETag is specified in HTTP_IF_NONE_MATCH header" do
-      response = make_request(@job, 'HTTP_IF_NONE_MATCH' => @job.unique_signature)
+      response = make_request(@job, 'HTTP_IF_NONE_MATCH' => @job.signature)
       @job.applied_steps.should be_empty
     end
   end
 
-  describe "Content Disposition" do
-    before(:each) do
-      @app.encoder.add{|temp_object, format| temp_object }
-    end
-
-    describe "filename" do
-      it "should return the original name" do
-        response = make_request(@job)
-        response['Content-Disposition'].should == 'filename="gung.txt"'
-      end
-      it "should return a filename with a different extension if it's been encoded" do
-        response = make_request(@job.encode(:doogs))
-        response['Content-Disposition'].should == 'filename="gung.doogs"'
-      end
-      it "should not have the filename if name doesn't exist" do
-        response = make_request(@app.new_job("ADFSDF"))
-        response['Content-Disposition'].should be_nil
-      end
-      it "should cope with filenames with no ext" do
-        response = make_request(@app.new_job("ASDF", :name => 'asdf'))
-        response['Content-Disposition'].should == 'filename="asdf"'
-      end
-      it "should uri encode funny characters" do
-        response = make_request(@app.new_job("ASDF", :name => '£@$£ `'))
-        response['Content-Disposition'].should == 'filename="%C2%A3@$%C2%A3%20%60"'
-      end
-      it "should allow for setting the filename using a block" do
-        @app.content_filename = proc{|job, request|
-          job.basename.reverse.upcase + request['a']
-        }
-        response = make_request(@job, 'QUERY_STRING' => 'a=egg')
-        response['Content-Disposition'].should == 'filename="GNUGegg"'
-      end
-      it "should not include the filename if configured to be nil" do
-        @app.content_filename = nil
-        response = make_request(@job)
-        response['Content-Disposition'].should be_nil
-      end
-    end
-
-    describe "content disposition" do
-      it "should use the app's configured content-disposition" do
-        @app.content_disposition = :attachment
-        response = make_request(@job)
-        response['Content-Disposition'].should == 'attachment; filename="gung.txt"'
-      end
-      it "should allow using a block to set the content disposition" do
-        @app.content_disposition = proc{|job, request|
-          job.basename + request['blah']
-        }
-        response = make_request(@job, 'QUERY_STRING' => 'blah=yo')
-        response['Content-Disposition'].should == 'gungyo; filename="gung.txt"'
-      end
-    end
-  end
-
   describe "custom headers" do
     before(:each) do
-      @app.configure{|c| c.response_headers['This-is'] = 'brill' }
+      @app.configure{ response_header 'This-is', 'brill' }
     end
     it "should allow specifying custom headers" do
       make_request(@job).headers['This-is'].should == 'brill'
@@ -191,17 +144,21 @@ describe Dragonfly::JobEndpoint do
       make_request(@job).headers['Cache-Control'].should == 'try me'
     end
     it "should allow giving a proc" do
-      @app.response_headers['Cache-Control'] = proc{|job, request|
-        job.basename.reverse.upcase + request['a']
+      @app.response_headers['Cache-Control'] = proc{|job, request, headers|
+        [job.basename.reverse.upcase, request['a'], headers['Cache-Control'].chars.first].join(',')
       }
       response = make_request(@job, 'QUERY_STRING' => 'a=egg')
-      response['Cache-Control'].should == 'GNUGegg'
+      response['Cache-Control'].should == 'GNUG,egg,p'
+    end
+    it "should allow removing by setting to nil" do
+      @app.response_headers['Cache-Control'] = nil
+      make_request(@job).headers.should_not have_key('Cache-Control')
     end
   end
 
   describe "setting the job in the env for communicating with other rack middlewares" do
     before(:each) do
-      @app.generator.add(:test_data){ "TEST DATA" }
+      @app.add_generator(:test_data){ "TEST DATA" }
       @job = @app.generate(:test_data)
       @endpoint = Dragonfly::JobEndpoint.new(@job)
       @middleware = Class.new do

data/spec/dragonfly/job_spec.rb

@@ -1,12 +1,6 @@
+# encoding: UTF-8
 require 'spec_helper'
 
-# Matchers
-RSpec::Matchers.define :match_steps do |steps|
-  match do |given|
-    given.map{|step| step.class } == steps
-  end
-end
-
 describe Dragonfly::Job do
 
   describe "Step types" do
@@ -14,7 +8,6 @@ describe Dragonfly::Job do
     {
       Dragonfly::Job::Fetch => :fetch,
       Dragonfly::Job::Process => :process,
-      Dragonfly::Job::Encode => :encode,
       Dragonfly::Job::Generate => :generate,
       Dragonfly::Job::FetchFile => :fetch_file,
       Dragonfly::Job::FetchUrl => :fetch_url
@@ -27,7 +20,6 @@ describe Dragonfly::Job do
     {
       Dragonfly::Job::Fetch => 'f',
       Dragonfly::Job::Process => 'p',
-      Dragonfly::Job::Encode => 'e',
       Dragonfly::Job::Generate => 'g',
       Dragonfly::Job::FetchFile => 'ff',
       Dragonfly::Job::FetchUrl => 'fu'
@@ -39,294 +31,245 @@ describe Dragonfly::Job do
 
     describe "step_names" do
       it "should return the available step names" do
-        Dragonfly::Job.step_names.should == [:fetch, :process, :encode, :generate, :fetch_file, :fetch_url]
+        Dragonfly::Job.step_names.should == [:fetch, :process, :generate, :fetch_file, :fetch_url]
       end
     end
 
   end
 
-  it "should allow initializing with content" do
-    job = Dragonfly::Job.new(@app, 'eggheads')
+  let (:app) { test_app }
+  let (:job) { Dragonfly::Job.new(app) }
+
+  it "allows initializing with content" do
+    job = Dragonfly::Job.new(app, 'eggheads')
     job.data.should == 'eggheads'
   end
 
-  describe "without content" do
+  describe "content" do
+    it "starts with an empty content" do
+      job.content.should be_a(Dragonfly::Content)
+      job.content.data.should == ""
+      job.content.meta.should == {}
+    end
+  end
 
+  describe "fetch" do
     before(:each) do
-      @app = test_app
-      @job = Dragonfly::Job.new(@app)
+      job.fetch!('some_uid')
     end
 
-    describe "fetch" do
-      before(:each) do
-        @job.fetch!('some_uid')
-      end
-
-      it { @job.steps.should match_steps([Dragonfly::Job::Fetch]) }
-
-      it "should retrieve from the app's datastore when applied" do
-        @app.datastore.should_receive(:retrieve).with('some_uid').and_return('HELLO')
-        @job.data.should == 'HELLO'
-      end
-
-      it "should set extra data if returned from the datastore" do
-        @app.datastore.should_receive(:retrieve).with('some_uid').and_return(['HELLO', {:name => 'test.txt'}])
-        @job.data.should == 'HELLO'
-        @job.meta.should == {:name => 'test.txt'}
-      end
+    it { job.steps.should match_steps([Dragonfly::Job::Fetch]) }
 
-      it "shouldn't set any url_attrs" do
-        @job.url_attrs.should == {}
-      end
+    it "should read from the app's datastore when applied" do
+      app.datastore.should_receive(:read).with('some_uid').and_return ["", {}]
+      job.apply
     end
 
-    describe "process" do
-      it "should raise an error when applying" do
-        @job.process!(:resize, '20x30')
-        lambda{
-          @job.apply
-        }.should raise_error(Dragonfly::Job::NothingToProcess)
-      end
+    it "raises NotFound if the datastore returns nil" do
+      app.datastore.should_receive(:read).and_return(nil)
+      expect {
+        job.apply
+      }.to raise_error(Dragonfly::Job::Fetch::NotFound)
     end
+  end
 
-    describe "encode" do
-      it "should raise an error when applying" do
-        @job.encode!(:gif)
-        lambda{
-          @job.apply
-        }.should raise_error(Dragonfly::Job::NothingToEncode)
-      end
+  describe "generate" do
+    before :each do
+      app.add_generator(:plasma){}
     end
 
-    describe "analyse" do
-      it "should raise a NoContent error" do
-        job = @app.new_job # This will define #analyser on it
-        lambda{
-          job.analyse(:width)
-        }.should raise_error(Dragonfly::Job::NoContent)
-      end
+    it "adds a step" do
+      job.generate!(:plasma, 20)
+      job.steps.should match_steps([Dragonfly::Job::Generate])
     end
 
-    describe "data" do
-      it "should raise a NoContent error" do
-        lambda{
-          @job.data
-        }.should raise_error(Dragonfly::Job::NoContent)
-      end
+    it "uses the generator when applied" do
+      job.generate!(:plasma, 20)
+      app.get_generator(:plasma).should_receive(:call).with(job.content, 20)
+      job.apply
     end
 
-    describe "generate" do
-      before(:each) do
-        @job.generate!(:plasma, 20, 30)
-      end
-
-      it { @job.steps.should match_steps([Dragonfly::Job::Generate]) }
-
-      it "should use the generator when applied" do
-        @app.generator.should_receive(:generate).with(:plasma, 20, 30).and_return('hi')
-        @job.data.should == 'hi'
-      end
-
-      it "should save extra data if the generator returns it" do
-        @app.generator.should_receive(:generate).with(:plasma, 20, 30).and_return(['hi', {:name => 'plasma.png'}])
-        @job.data.should == 'hi'
-        @job.meta.should == {:name => 'plasma.png'}
-      end
-
-      it "shouldn't set any url_attrs" do
-        @job.url_attrs.should == {}
-      end
+    it "updates the url if method exists" do
+      app.get_generator(:plasma).should_receive(:update_url).with(job.url_attributes, 20)
+      job.generate!(:plasma, 20)
     end
+  end
 
-    describe "fetch_file" do
-      before(:each) do
-        @job.fetch_file!(File.dirname(__FILE__) + '/../../samples/egg.png')
-      end
-
-      it { @job.steps.should match_steps([Dragonfly::Job::FetchFile]) }
-
-      it "should fetch the specified file when applied" do
-        @job.size.should == 62664
-      end
-
-      it "should set the url_attrs" do
-        @job.url_attrs.should == {:name => 'egg.png'}
-      end
-
-      it "should set the name" do
-        @job.meta[:name].should == 'egg.png'
-      end
+  describe "fetch_file" do
+    before(:each) do
+      job.fetch_file!(File.dirname(__FILE__) + '/../../samples/egg.png')
     end
 
-    describe "fetch_url" do
-      before(:each) do
-        stub_request(:get, %r{http://some\.place\.com/.*}).to_return(:body => 'result!')
-        stub_request(:get, 'https://some.place.com').to_return(:body => 'secure result!')
-      end
-
-      it {
-        @job.fetch_url!('some.url')
-        @job.steps.should match_steps([Dragonfly::Job::FetchUrl])
-      }
-
-      it "should fetch the specified url when applied" do
-        @job.fetch_url!('http://some.place.com')
-        @job.data.should == "result!"
-      end
+    it { job.steps.should match_steps([Dragonfly::Job::FetchFile]) }
 
-      it "should default to http" do
-        @job.fetch_url!('some.place.com')
-        @job.data.should == "result!"
-      end
-
-      it "should also work with https" do
-        @job.fetch_url!('https://some.place.com')
-        @job.data.should == "secure result!"
-      end
-
-      it "should set the name if there is one" do
-        @job.fetch_url!('some.place.com/dung.beetle')
-        @job.meta[:name].should == 'dung.beetle'
-      end
-
-      it "should set the name url_attr if there is one" do
-        @job.fetch_url!('some.place.com/dung.beetle')
-        @job.url_attrs.should == {:name =>'dung.beetle'}
-      end
-
-      ["some.place.com", "some.place.com/", "some.place.com/eggs/"].each do |url|
-        it "should not set the name if there isn't one, e.g. #{url}" do
-          @job.fetch_url!(url)
-          @job.meta[:name].should be_nil
-        end
+    it "should fetch the specified file when applied" do
+      job.size.should == 62664
+    end
 
-        it "should not set the name url_attr if there isn't one, e.g. #{url}" do
-          @job.fetch_url!(url)
-          @job.url_attrs[:name].should be_nil
-        end
-      end
+    it "should set the url_attributes" do
+      job.url_attributes.name.should == 'egg.png'
     end
 
+    it "should set the name" do
+      job.name.should == 'egg.png'
+    end
   end
 
-  describe "with content already there" do
-
+  describe "fetch_url" do
     before(:each) do
-      @app = mock_app
-      @job = Dragonfly::Job.new(@app, 'HELLO', :name => 'hello.txt', :a => :b)
-      @temp_object = @job.temp_object
+      stub_request(:get, %r{http://place\.com/.*}).to_return(:body => 'result!')
     end
 
-    describe "apply" do
-      it "should return itself" do
-        @job.apply.should == @job
-      end
+    it "adds a step" do
+      job.fetch_url!('some.url')
+      job.steps.should match_steps([Dragonfly::Job::FetchUrl])
     end
 
-    describe "process" do
-      before(:each) do
-        @job.url_attrs = {:some => 'thing'}
-        @job.process!(:resize, '20x30')
-      end
+    it "should fetch the specified url when applied" do
+      job.fetch_url!('http://place.com')
+      job.data.should == "result!"
+    end
+
+    it "should default to http" do
+      job.fetch_url!('place.com')
+      job.data.should == "result!"
+    end
 
-      it { @job.steps.should match_steps([Dragonfly::Job::Process]) }
+    it "should also work with https" do
+      stub_request(:get, 'https://place.com').to_return(:body => 'secure result!')
+      job.fetch_url!('https://place.com')
+      job.data.should == "secure result!"
+    end
 
-      it "should use the processor when applied" do
-        @app.processor.should_receive(:process).with(@temp_object, :resize, '20x30').and_return('hi')
-        @job.data.should == 'hi'
+    [
+      "place.com",
+      "http://place.com",
+      "place.com/",
+      "place.com/stuff/",
+      "place.com/?things"
+    ].each do |url|
+      it "doesn't set the name if there isn't one, e.g. for #{url}" do
+        job.fetch_url!(url)
+        job.name.should be_nil
       end
 
-      it "should maintain the meta attributes" do
-        @app.processor.should_receive(:process).with(@temp_object, :resize, '20x30').and_return('hi')
-        @job.meta.should == {:name => 'hello.txt', :a => :b}
+      it "doesn't set the name url_attr if there isn't one, e.g. for #{url}" do
+        job.fetch_url!(url)
+        job.url_attributes.name.should be_nil
       end
+    end
 
-      it "should maintain the url_attrs" do
-        @job.url_attrs.should == {:some => 'thing'}
+    [
+      "place.com/dung.beetle",
+      "http://place.com/dung.beetle",
+      "place.com/stuff/dung.beetle",
+      "place.com/dung.beetle?morethings"
+    ].each do |url|
+      it "sets the name if there is one, e.g. for #{url}" do
+        job.fetch_url!(url)
+        job.name.should == 'dung.beetle'
       end
 
-      it "should allow returning an array with extra attributes from the processor" do
-        @app.processor.should_receive(:process).with(@temp_object, :resize, '20x30').and_return(['hi', {:name => 'hello_20x30.txt', :eggs => 'asdf'}])
-        @job.data.should == 'hi'
-        @job.meta.should == {:name => 'hello_20x30.txt', :a => :b, :eggs => 'asdf'}
+      it "sets the name url_attr if there is one, e.g. for #{url}" do
+        job.fetch_url!(url)
+        job.url_attributes.name.should == 'dung.beetle'
       end
     end
 
-    describe "encode" do
-      before(:each) do
-        @job.url_attrs = {:name => 'boid'}
-        @job.encode!(:gif, 'bitrate' => 'mumma')
-      end
+    it "should raise an error if not found" do
+      stub_request(:get, "notfound.com").to_return(:status => 404, :body => "BLAH")
+      expect{
+        job.fetch_url!('notfound.com').apply
+      }.to raise_error(Dragonfly::Job::FetchUrl::ErrorResponse){|error|
+        error.status.should == 404
+        error.body.should == "BLAH"
+      }
+    end
 
-      it { @job.steps.should match_steps([Dragonfly::Job::Encode]) }
+    it "should raise an error if server error" do
+      stub_request(:get, "error.com").to_return(:status => 500, :body => "BLAH")
+      expect{
+        job.fetch_url!('error.com').apply
+      }.to raise_error(Dragonfly::Job::FetchUrl::ErrorResponse){|error|
+        error.status.should == 500
+        error.body.should == "BLAH"
+      }
+    end
 
-      it "should use the encoder when applied" do
-        @app.encoder.should_receive(:encode).with(@temp_object, :gif, 'bitrate' => 'mumma').and_return('alo')
-        @job.data.should == 'alo'
-      end
+    it "should follow redirects" do
+      stub_request(:get, "redirectme.com").to_return(:status => 302, :headers => {'Location' => 'http://ok.com'})
+      stub_request(:get, "ok.com").to_return(:body => "OK!")
+      job.fetch_url('redirectme.com').data.should == 'OK!'
+    end
 
-      it "should maintain the meta and update the format" do
-        @app.encoder.should_receive(:encode).with(@temp_object, :gif, 'bitrate' => 'mumma').and_return('alo')
-        @job.meta.should == {:name => 'hello.txt', :a => :b, :format => :gif}
+    describe "data uris" do
+      it "accepts standard base64 encoded data uris" do
+        job.fetch_url!("data:text/plain;base64,aGVsbG8=\n")
+        job.data.should == 'hello'
+        job.mime_type.should == 'text/plain'
+        job.ext.should == 'txt'
       end
 
-      it "should update the format on the url_attrs" do
-        @app.encoder.should_not_receive(:encode)
-        @job.url_attrs[:format].should == :gif
+      it "doesn't accept other data uris" do
+        expect {
+          job.fetch_url!("data:text/html;charset=utf-8,<stuff />").apply
+        }.to raise_error(Dragonfly::Job::FetchUrl::CannotHandle)
       end
+    end
+  end
 
-      it "should allow returning an array with extra attributes form the encoder" do
-        @app.encoder.should_receive(:encode).with(@temp_object, :gif, 'bitrate' => 'mumma').and_return(['alo', {:name => 'doobie', :eggs => 'fish'}])
-        @job.data.should == 'alo'
-        @job.meta.should == {:name => 'doobie', :a => :b, :eggs => 'fish', :format => :gif}
-      end
+  describe "apply" do
+    it "should return itself" do
+      job.apply.should == job
+    end
+  end
 
-      it "not allow overriding the format" do
-        @app.encoder.should_receive(:encode).with(@temp_object, :gif, 'bitrate' => 'mumma').and_return(['alo', {:format => :png}])
-        @job.apply.meta[:format].should == :gif
-      end
+  describe "process" do
+    before :each do
+      app.add_processor(:resize){}
+    end
 
-      it "should maintain the url_attrs" do
-        @job.url_attrs[:name].should == 'boid'
-      end
+    it "adds a step" do
+      job.process!(:resize, '20x30')
+      job.steps.should match_steps([Dragonfly::Job::Process])
+    end
+
+    it "should use the processor when applied" do
+      job.process!(:resize, '20x30')
+      app.get_processor(:resize).should_receive(:call).with(job.content, '20x30')
+      job.apply
+    end
 
+    it "should call update_url immediately with the url_attributes" do
+      app.get_processor(:resize).should_receive(:update_url).with(job.url_attributes, '20x30')
+      job.process!(:resize, '20x30')
     end
   end
 
   describe "analysis" do
+    let (:job) { Dragonfly::Job.new(app, "HELLO") }
+
     before(:each) do
-      @app = test_app
-      @job = @app.new_job('HELLO')
-      @app.analyser.add(:num_letters){|temp_object, letter| temp_object.data.count(letter) }
+      app.add_analyser(:num_ls){|content| content.data.count('L') }
     end
     it "should return correctly when calling analyse" do
-      @job.analyse(:num_letters, 'L').should == 2
-    end
-    it "should have mixed in the analyser method" do
-      @job.num_letters('L').should == 2
-    end
-    it "should return nil from analyse if calling any old method" do
-      @job.analyse(:robin_van_persie).should be_nil
-    end
-    it "should not allow calling any old method" do
-      lambda{
-        @job.robin_van_persie
-      }.should raise_error(NoMethodError)
+      job.analyse(:num_ls).should == 2
     end
     it "should work correctly with chained jobs, applying before analysing" do
-      @app.processor.add(:double){|temp_object| temp_object.data * 2 }
-      @job.process(:double).num_letters('L').should == 4
+      app.add_processor(:double){|content| content.update(content.data * 2) }
+      job.process(:double).analyse(:num_ls).should == 4
     end
   end
 
   describe "defining extra steps after applying" do
     before(:each) do
-      @app = mock_app
+      @app = test_app
+      @app.add_processor(:resize){}
+      @app.add_processor(:encode){}
       @job = Dragonfly::Job.new(@app)
-      @job.temp_object = Dragonfly::TempObject.new("hello")
       @job.process! :resize
       @job.apply
-      @job.encode! :micky
+      @job.process! :encode
     end
     it "should not call apply on already applied steps" do
       @job.steps[0].should_not_receive(:apply)
@@ -337,20 +280,13 @@ describe Dragonfly::Job do
       @job.apply
     end
     it "should return all steps" do
-      @job.steps.should match_steps([
-        Dragonfly::Job::Process,
-        Dragonfly::Job::Encode
-      ])
+      @job.steps.map{|step| step.name }.should == [:resize, :encode]
     end
     it "should return applied steps" do
-      @job.applied_steps.should match_steps([
-        Dragonfly::Job::Process
-      ])
+      @job.applied_steps.map{|step| step.name }.should == [:resize]
     end
     it "should return the pending steps" do
-      @job.pending_steps.should match_steps([
-        Dragonfly::Job::Encode
-      ])
+      @job.pending_steps.map{|step| step.name }.should == [:encode]
     end
     it "should not call apply on any steps when already applied" do
       @job.apply
@@ -363,8 +299,10 @@ describe Dragonfly::Job do
   describe "chaining" do
 
     before(:each) do
-      @app = mock_app
+      @app = test_app
       @job = Dragonfly::Job.new(@app)
+      @app.add_processor(:resize){|content, length| content.update(content.data[0...length]) }
+      @app.store("SOME_DATA", {}, :uid => 'some_uid')
     end
 
     it "should return itself if bang is used" do
@@ -378,7 +316,7 @@ describe Dragonfly::Job do
     describe "when a chained job is defined" do
       before(:each) do
         @job.fetch!('some_uid')
-        @job2 = @job.process(:resize, '30x30')
+        @job2 = @job.process(:resize, 4)
       end
 
       it "should return the correct steps for the original job" do
@@ -403,61 +341,42 @@ describe Dragonfly::Job do
       end
 
       it "should return the correct data for the new job" do
-        @job2.data.should == 'SOME_PROCESSED_DATA'
-      end
-
-      it "should not affect the other one when one is applied" do
-        @job.apply
-        @job.applied_steps.should match_steps([
-          Dragonfly::Job::Fetch
-        ])
-        @job.pending_steps.should match_steps([
-        ])
-        @job.temp_object.data.should == 'SOME_DATA'
-        @job2.applied_steps.should match_steps([
-        ])
-        @job2.pending_steps.should match_steps([
-          Dragonfly::Job::Fetch,
-          Dragonfly::Job::Process
-        ])
-        @job2.temp_object.should be_nil
+        @job2.data.should == 'SOME'
       end
     end
 
   end
 
   describe "applied?" do
-    before(:each) do
-      @app = test_app
-    end
     it "should return true when empty" do
-      @app.new_job.should be_applied
+      app.new_job.should be_applied
     end
     it "should return false when not applied" do
-      @app.fetch('eggs').should_not be_applied
+      app.fetch('eggs').should_not be_applied
     end
     it "should return true when applied" do
-      @app.datastore.should_receive(:retrieve).with('eggs').and_return("cracked")
-      job = @app.fetch('eggs').apply
+      job = app.fetch('eggs')
+      app.datastore.should_receive(:read).with('eggs').and_return ["", {}]
+      job.apply
       job.should be_applied
     end
   end
 
   describe "to_a" do
     before(:each) do
-      @app = mock_app
+      @app = test_app
+      @app.add_generator(:plasma){}
+      @app.add_processor(:resize){}
     end
     it "should represent all the steps in array form" do
       job = Dragonfly::Job.new(@app)
       job.fetch! 'some_uid'
       job.generate! :plasma # you wouldn't really call this after fetch but still works
       job.process! :resize, '30x40'
-      job.encode! :gif, 'bitrate' => 20
       job.to_a.should == [
         ['f', 'some_uid'],
         ['g', :plasma],
-        ['p', :resize, '30x40'],
-        ['e', :gif, {'bitrate' => 20}]
+        ['p', :resize, '30x40']
       ]
     end
   end
@@ -466,6 +385,8 @@ describe Dragonfly::Job do
 
     before(:each) do
       @app = test_app
+      @app.add_generator(:plasma){}
+      @app.add_processor(:resize){}
     end
 
     describe "a well-defined array" do
@@ -473,8 +394,7 @@ describe Dragonfly::Job do
         @job = Dragonfly::Job.from_a([
           ['f', 'some_uid'],
           ['g', 'plasma'],
-          ['p', 'resize', '30x40'],
-          ['e', 'gif', {'bitrate' => 20}]
+          ['p', 'resize', '30x40']
         ], @app)
       end
       it "should have the correct step types" do
@@ -482,14 +402,12 @@ describe Dragonfly::Job do
           Dragonfly::Job::Fetch,
           Dragonfly::Job::Generate,
           Dragonfly::Job::Process,
-          Dragonfly::Job::Encode
         ])
       end
       it "should have the correct args" do
         @job.steps[0].args.should == ['some_uid']
         @job.steps[1].args.should == ['plasma']
         @job.steps[2].args.should == ['resize', '30x40']
-        @job.steps[3].args.should == ['gif', {'bitrate' => 20}]
       end
       it "should have no applied steps" do
         @job.applied_steps.should be_empty
@@ -526,6 +444,7 @@ describe Dragonfly::Job do
   describe "serialization" do
     before(:each) do
       @app = test_app
+      @app.add_processor(:resize_and_crop){}
       @job = Dragonfly::Job.new(@app).fetch('uid').process(:resize_and_crop, 'width' => 270, 'height' => 92, 'gravity' => 'n')
     end
     it "should serialize itself" do
@@ -550,25 +469,28 @@ describe Dragonfly::Job do
     end
 
     context 'legacy urls are enabled' do
+      before do
+        @app.allow_legacy_urls = true
+      end
+
       it "works with marshal encoded strings (deprecated)" do
         job = Dragonfly::Job.deserialize("BAhbBlsHSSIGZgY6BkVUSSINc29tZV91aWQGOwBU", @app)
         job.fetch_step.uid.should == 'some_uid'
       end
 
       it "checks for potentially malicious strings" do
-        string = Dragonfly::Serializer.marshal_encode(Dragonfly::TempObject.new('a'))
+        string = Dragonfly::Serializer.marshal_b64_encode(Dragonfly::TempObject.new('a'))
         expect{
           Dragonfly::Job.deserialize(string, @app)
         }.to raise_error(Dragonfly::Serializer::MaliciousString)
       end
     end
 
-    context 'legacy urls are disabled' do
+    context 'legacy urls are disabled (default)' do
       it "rejects marshal encoded strings " do
-        @app.allow_legacy_urls = false
         expect {Dragonfly::Job.deserialize("BAhbBlsHSSIGZgY6BkVUSSINc29tZV91aWQGOwBU", @app)}.to raise_error(Dragonfly::Serializer::BadString)
       end
-    end    
+    end
   end
 
   describe "to_app" do
@@ -583,122 +505,82 @@ describe Dragonfly::Job do
     end
   end
 
-  describe "url" do
+  describe "update_url_attributes" do
     before(:each) do
       @app = test_app
-      @job = Dragonfly::Job.new(@app)
+      @job = Dragonfly::Job.new(:app)
+      @job.url_attributes.hello = 'goose'
     end
-
-    it "should return nil if there are no steps" do
-      @job.url.should be_nil
+    it "updates the url_attributes" do
+      @job.update_url_attributes(:jimmy => 'cricket')
+      @job.url_attributes.hello.should == 'goose'
+      @job.url_attributes.jimmy.should == 'cricket'
     end
+    it "overrides keys" do
+      @job.update_url_attributes(:hello => 'cricket')
+      @job.url_attributes.hello.should == 'cricket'
+    end
+  end
 
-    describe "using url_attrs in the url" do
-      before(:each) do
-        @app.server.url_format = '/media/:job/:zoo'
-        @job.generate!(:fish)
-      end
-      it "should act as per usual if no params given" do
-        @job.url.should == "/media/#{@job.serialize}"
-      end
-      it "should add given params" do
-        @job.url(:zoo => 'jokes', :on => 'me').should == "/media/#{@job.serialize}/jokes?on=me"
-      end
-      it "should use the url_attr if it exists" do
-        @job.url_attrs[:zoo] = 'hair'
-        @job.url.should == "/media/#{@job.serialize}/hair"
-      end
-      it "should not add any url_attrs that aren't needed" do
-        @job.url_attrs[:gump] = 'flub'
-        @job.url.should == "/media/#{@job.serialize}"
-      end
-      it "should override if a param is passed in" do
-        @job.url_attrs[:zoo] = 'hair'
-        @job.url(:zoo => 'dare').should == "/media/#{@job.serialize}/dare"
-      end
+  describe "url_attributes" do
+    it "doesn't interfere with other jobs' attributes" do
+      job.url_attributes.zoo = 'hair'
+      job2 = job.dup
+      job2.url_attributes.zoo = 'dare'
 
-      describe "basename" do
-        before(:each) do
-          @app.server.url_format = '/:job/:basename'
-        end
-        it "should use the name" do
-          @job.url_attrs = {:name => 'hello.egg'}
-          @job.url.should == "/#{@job.serialize}/hello"
-        end
-        it "should not set if neither exist" do
-          @job.url_attrs = {}
-          @job.url.should == "/#{@job.serialize}"
-        end
-      end
+      job.url_attributes.zoo.should == 'hair'
+      job2.url_attributes.zoo.should == 'dare'
+    end
+  end
 
-      describe "ext" do
-        before(:each) do
-          @app.server.url_format = '/:job.:ext'
-          @job.url_attrs = {:name => 'hello.egg', :ext => 'hi'}
-        end
-        it "should use the name" do
-          @job.url_attrs = {:name => 'hello.egg'}
-          @job.url.should == "/#{@job.serialize}.egg"
-        end
-        it "should not set if neither exist" do
-          @job.url_attrs = {}
-          @job.url.should == "/#{@job.serialize}"
-        end
-      end
+  describe "url" do
+    let (:app) { test_app }
+    let (:job) { Dragonfly::Job.new(app) }
 
-      describe "format" do
-        before(:each) do
-          @app.server.url_format = '/:job.:format'
-        end
-        it "should use the url_attr if it exists" do
-          @job.url_attrs = {:ext => 'hi', :format => :txt}
-          @job.url.should == "/#{@job.serialize}.txt"
-        end
-        it "should use the ext if format url_attr doesn't exist" do
-          @job.url_attrs = {:name => 'hup.hi'}
-          @job.url.should == "/#{@job.serialize}.hi"
-        end
-        it "should not use the ext if format meta doesn't exist and trust_file_extensions is switched off" do
-          @job.url_attrs = {:name => 'hup.hi'}
-          @app.trust_file_extensions = false
-          @job.url.should == "/#{@job.serialize}"
-        end
-        it "should not set if neither exist" do
-          @job.url_attrs = {}
-          @job.url.should == "/#{@job.serialize}"
-        end
-      end
+    it "returns nil if there are no steps" do
+      job.url.should be_nil
+    end
+
+    it "uses the server url otherwise" do
+      job.fetch!("some_stuff")
+      opts = {:some => "opts"}
+      app.server.should_receive(:url_for).with(job, opts).and_return("some.url")
+      job.url(opts).should == "some.url"
     end
   end
 
   describe "to_fetched_job" do
-    before(:each) do
-      @app = test_app
-      @job = @app.create("HELLO")
+    let (:fetched_job) { job.to_fetched_job('some_uid') }
+
+    before :each do
+      job.content.update "bugs", "bug" => "bear"
+      job.update_url_attributes "boog" => "bar"
     end
-    it "should maintain the same temp_object and be already applied" do
-      new_job = @job.to_fetched_job('some_uid')
-      new_job.data.should == 'HELLO'
-      new_job.to_a.should == [
+
+    it "updates the steps" do
+      fetched_job.to_a.should == [
         ['f', 'some_uid']
       ]
-      new_job.pending_steps.should be_empty
+      fetched_job.should be_applied
     end
-    it "should maintain the meta" do
-      @job.meta = {:right => 'said fred'}
-      new_job = @job.to_fetched_job('some_uid')
-      new_job.meta.should == {:right => 'said fred'}
+    it "maintains the same content (but different object)" do
+      fetched_job.data.should == "bugs"
+      fetched_job.meta.should == {"bug" => "bear"}
+      job.content.update("dogs")
+      fetched_job.data.should == "bugs" # still
     end
-    it "should maintain the url_attrs" do
-      @job.url_attrs = {:dang => 'that dawg'}
-      new_job = @job.to_fetched_job('some_uid')
-      new_job.url_attrs.should == {:dang => 'that dawg'}
+    it "maintains the url_attributes (but different object)" do
+      fetched_job.url_attributes.boog.should == "bar"
+      job.update_url_attributes "boog" => "dogs"
+      fetched_job.url_attributes.boog.should == "bar" # still
     end
   end
 
   describe "to_unique_s" do
     it "should use the arrays of args to create the string" do
-      job = test_app.fetch('uid').process(:gug, 4, 'some' => 'arg', 'and' => 'more')
+      app = test_app
+      app.add_processor(:gug){}
+      job = app.fetch('uid').process(:gug, 4, 'some' => 'arg', 'and' => 'more')
       job.to_unique_s.should == 'fuidpgug4andmoresomearg'
     end
   end
@@ -742,45 +624,18 @@ describe Dragonfly::Job do
     end
   end
 
-  describe "setting the name" do
-    before(:each) do
-      @app = test_app
-      @job = @app.new_job("HELLO", :name => 'not.me')
-    end
-    it "should allow setting the name" do
-      @job.name = 'wassup.doc'
-      @job.name.should == 'wassup.doc'
-    end
-  end
-
-  describe "setting the meta" do
-    before(:each) do
-      @app = test_app
-      @job = @app.new_job("HiThere", :five => 'beans')
-    end
-    it "should allow setting the meta" do
-      @job.meta = {:doogie => 'ladders'}
-      @job.meta.should == {:doogie => 'ladders'}
-    end
-    it "should allow updating the meta" do
-      @job.meta[:doogie] = 'ladders'
-      @job.meta.should == {:five => 'beans', :doogie => 'ladders'}
-    end
-  end
-
   describe "b64_data" do
-    before(:each) do
-      @app = test_app
-    end
-    it "should return a string using the data:URI schema" do
-      job = @app.new_job("HELLO", :name => 'text.txt')
-      job.b64_data.should == "data:text/plain;base64,SEVMTE8=\n"
+    it "takes it from the result" do
+      job.should_receive(:apply)
+      job.b64_data.should =~ /^data:/
     end
   end
 
   describe "querying stuff without applying steps" do
     before(:each) do
       @app = test_app
+      @app.add_generator(:ponies){}
+      @app.add_processor(:jam){}
     end
 
     describe "fetch_step" do
@@ -788,7 +643,7 @@ describe Dragonfly::Job do
         @app.generate(:ponies).process(:jam).fetch_step.should be_nil
       end
       it "should return the fetch step otherwise" do
-        step = @app.fetch('hello').process(:cheese).fetch_step
+        step = @app.fetch('hello').process(:jam).fetch_step
         step.should be_a(Dragonfly::Job::Fetch)
         step.uid.should == 'hello'
       end
@@ -817,7 +672,7 @@ describe Dragonfly::Job do
         @app.generate(:ponies).process(:jam).fetch_file_step.should be_nil
       end
       it "should return the fetch_file step otherwise" do
-        step = @app.fetch_file('/my/file.png').process(:cheese).fetch_file_step
+        step = @app.fetch_file('/my/file.png').process(:jam).fetch_file_step
         step.should be_a(Dragonfly::Job::FetchFile)
         if Dragonfly.running_on_windows?
           step.path.should =~ %r(:/my/file\.png$)
@@ -825,6 +680,10 @@ describe Dragonfly::Job do
           step.path.should == '/my/file.png'
         end
       end
+      it "converts pathname to a string in to_a" do
+        job = @app.fetch_file(Pathname.new('some/where'))
+        job.to_a.should == [['ff', 'some/where']]
+      end
     end
 
     describe "fetch_url_step" do
@@ -832,7 +691,7 @@ describe Dragonfly::Job do
         @app.generate(:ponies).fetch_url_step.should be_nil
       end
       it "should return the fetch_url step otherwise" do
-        step = @app.fetch_url('egg.heads').process(:cheese).fetch_url_step
+        step = @app.fetch_url('egg.heads').process(:jam).fetch_url_step
         step.should be_a(Dragonfly::Job::FetchUrl)
         step.url.should == 'http://egg.heads'
       end
@@ -843,7 +702,7 @@ describe Dragonfly::Job do
         @app.fetch('many/ponies').process(:jam).generate_step.should be_nil
       end
       it "should return the generate step otherwise" do
-        step = @app.generate(:ponies).process(:cheese).generate_step
+        step = @app.generate(:ponies).process(:jam).generate_step
         step.should be_a(Dragonfly::Job::Generate)
         step.name.should == :ponies
       end
@@ -851,7 +710,8 @@ describe Dragonfly::Job do
 
     describe "process_steps" do
       it "should return the processing steps" do
-        job = @app.fetch('many/ponies').process(:jam).process(:eggs).encode(:gif)
+        @app.add_processor(:eggs){}
+        job = @app.fetch('many/ponies').process(:jam).process(:eggs)
         job.process_steps.should match_steps([
           Dragonfly::Job::Process,
           Dragonfly::Job::Process
@@ -859,232 +719,44 @@ describe Dragonfly::Job do
       end
     end
 
-    describe "encode_step" do
-      it "should return nil if it doesn't exist" do
-        @app.generate(:ponies).encode_step.should be_nil
-      end
-      it "should return the last encode step otherwise" do
-        step = @app.fetch('hello').encode(:smells).encode(:cheese).encode_step
-        step.should be_a(Dragonfly::Job::Encode)
-        step.format.should == :cheese
-      end
-    end
-
     describe "step_types" do
       it "should return the step types" do
-        job = @app.fetch('eggs').process(:beat, 'strongly').encode(:meringue)
-        job.step_types.should == [:fetch, :process, :encode]
+        job = @app.fetch('eggs').process(:jam)
+        job.step_types.should == [:fetch, :process]
       end
     end
   end
 
   describe "meta" do
-    before(:each) do
-      @app = test_app
-      @app.generator.add(:gollum){|t| "OK"}
-      @job = @app.new_job("Goo")
-    end
-    it "should default meta to an empty hash" do
-      @job.meta.should == {}
-    end
-    it "should allow setting" do
-      @job.meta = {:a => :b}
-      @job.meta.should == {:a => :b}
-    end
-    it "should apply the job" do
-      @job.should_receive :apply
-      @job.meta
-    end
-    it "should apply the job before setting (for consistency)" do
-      @job.should_receive :apply
-      @job.meta = {}
-    end
-    it "should allow setting on initialize" do
-      job = @app.new_job('asdf', :b => :c)
-      job.meta.should == {:b => :c}
-    end
-    it "should keep them when chained" do
-      @job.meta[:darn] = 'it'
-      @job.generate(:gollum).meta.should == {:darn => 'it'}
+    it "delegates to the result" do
+      job.should_receive(:apply)
+      job.meta = {'a' => 'b'}
+      job.should_receive(:apply)
+      job.meta.should == {'a' => 'b'}
     end
   end
 
-  describe "sanity check for name, basename, ext" do
-    before(:each) do
-      @app = test_app
-      @job = @app.new_job('asdf')
-    end
-
+  describe "sanity check for name, basename, ext, mime_type" do
     it "should default to nil" do
-      @job.name.should be_nil
+      job.name.should be_nil
     end
 
     it "reflect the meta" do
-      @job.meta[:name] = 'monkey.egg'
-      @job.name.should == 'monkey.egg'
-      @job.basename.should == 'monkey'
-      @job.ext.should == 'egg'
-    end
-  end
-
-  describe "format" do
-    before(:each) do
-      @app = test_app
-    end
-    it "should default to nil" do
-      job = @app.new_job("HELLO")
-      job.format.should be_nil
-    end
-    it "should use the meta format if it exists" do
-      job = @app.new_job("HELLO")
-      job.meta[:format] = :txt
-      job.format.should == :txt
-    end
-    it "should use the analyser format if it exists" do
-      @app.analyser.add :format do |temp_object|
-        :egg
-      end
-      job = @app.new_job("HELLO")
-      job.format.should == :egg
-    end
-    it "should use the file extension if it has no format" do
-      job = @app.new_job("HIMATE", :name => 'test.pdf')
-      job.format.should == :pdf
-    end
-    it "should not use the file extension if it's been switched off" do
-      @app.trust_file_extensions = false
-      job = @app.new_job("HIMATE", :name => 'test.pdf')
-      job.format.should be_nil
-    end
-    it "should prefer the set format over the file extension" do
-      job = @app.new_job("HELLO", :name => 'test.pdf', :format => :txt)
-      job.format.should == :txt
-    end
-    it "should prefer the file extension over the analysed format" do
-      @app.analyser.add :format do |temp_object|
-        :egg
-      end
-      job = @app.new_job("HELLO", :name => 'test.pdf')
-      job.format.should == :pdf
-    end
-    it "should apply the job" do
-      @app.generator.add(:test){ ["skid marks", {:name => 'terry.burton'}] }
-      job = @app.generate(:test)
-      job.format.should == :burton
-      job.should be_applied
-    end
-  end
-
-  describe "mime_type" do
-    before(:each) do
-      @app = test_app
-    end
-    it "should return the correct mime_type if the format is given" do
-      @job = @app.new_job("HIMATE")
-      @job.should_receive(:format).and_return(:tiff)
-      @job.mime_type.should == 'image/tiff'
-    end
-    it "should fall back to the mime_type analyser if the format is nil" do
-      @app.analyser.add :mime_type do |temp_object|
-        'image/jpeg'
-      end
-      @job = @app.new_job("HIMATE")
-      @job.mime_type.should == 'image/jpeg'
-    end
-    it "should fall back to the fallback mime_type if neither format or analyser exist" do
-      @app.new_job("HIMATE").mime_type.should == 'application/octet-stream'
+      job.meta['name'] = 'monkey.png'
+      job.name.should == 'monkey.png'
+      job.basename.should == 'monkey'
+      job.ext.should == 'png'
+      job.mime_type.should == 'image/png'
     end
   end
 
   describe "store" do
-    before(:each) do
-      @app = test_app
-      @app.generator.add(:test){ ["Toes", {:name => 'doogie.txt'}] }
-      @job = @app.generate(:test)
-    end
-    it "should store its data along with the meta and mime_type" do
-      @job.meta[:eggs] = 'doolally'
-      @app.datastore.should_receive(:store).with do |temp_object, opts|
-        temp_object.data.should == "Toes"
-        temp_object.name.should == 'doogie.txt'
-        temp_object.meta[:eggs].should == 'doolally'
-        opts[:mime_type].should == 'text/plain'
-      end
-      @job.store
-    end
-    it "should add extra opts" do
-      @app.datastore.should_receive(:store).with(anything, hash_including(:path => 'blah', :mime_type => 'text/plain'))
-      @job.store(:path => 'blah')
-    end
-    it "should pass in its meta, for deprecated datastores" do
-      @job.meta[:beans] = 5
-      @app.datastore.should_receive(:store).with do |temp_object, opts|
-        opts[:meta].should == {:beans => 5, :name => 'doogie.txt'}
-      end
-      @job.store
-    end
-  end
-
-  describe "dealing with original_filename" do
-    before(:each) do
-      @string = "terry"
-      @string.stub!(:original_filename).and_return("gum.tree")
-      @app = test_app
-      @app.generator.add(:test){ @string }
-    end
-    it "should set it as the name" do
-      @app.create(@string).name.should == 'gum.tree'
-    end
-    it "should prefer the initialized name over the original_filename" do
-      @app.create(@string, :name => 'doo.berry').name.should == 'doo.berry'
-    end
-    it "should work with e.g. generators" do
-      @app.generate(:test).apply.name.should == 'gum.tree'
-    end
-    it "should favour an e.g. generator returned name" do
-      @app.generator.add(:test2){ [@string, {:name => 'gen.ome'}] }
-      @app.generate(:test2).apply.name.should == 'gen.ome'
-    end
-    it "should not overwrite a set name" do
-      job = @app.generate(:test)
-      job.name = 'egg.mumma'
-      job.apply.name.should == 'egg.mumma'
-    end
-  end
-
-  describe "deprecated meta format" do
-    before(:each) do
-      @app = test_app
-    end
-    it "should still work if the datastore/whatever returns meta nested in :meta key" do
-      @app.datastore.should_receive(:retrieve).with('some_uid').and_return(['HELLO', {:name => 'test.txt', :meta => {:some => 'meta'}}])
-      job = @app.fetch('some_uid').apply
-      job.meta.should == {:name => 'test.txt', :some => 'meta'}
-    end
-  end
-
-  describe "close" do
-    before(:each) do
-      @app = test_app
-      @app.generator.add(:toast){ "toast" }
-      @app.processor.add(:upcase){|t| t.data.upcase }
-      @job = @app.generate(:toast)
-      @path1 = @job.tempfile.path
-      @job.process!(:upcase)
-      @path2 = @job.tempfile.path
-    end
-
-    it "should clean up tempfiles for the last temp_object" do
-      File.exist?(@path2).should be_true
-      @job.close
-      File.exist?(@path2).should be_false
-    end
-
-    it "should clean up tempfiles for previous temp_objects" do
-      File.exist?(@path1).should be_true
-      @job.close
-      File.exist?(@path1).should be_false
+    it "calls store on the applied content" do
+      job.should_receive(:apply)
+      app.datastore.should_receive(:write).with(job.content, {})
+      job.store
     end
   end
 
 end
+