dragonfly 1.0 → 1.0.1

data/spec/dragonfly/job/generate_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Dragonfly::Job::Generate do
+
+  let (:app) { test_app }
+  let (:job) { Dragonfly::Job.new(app) }
+
+  before :each do
+    app.add_generator(:plasma){}
+  end
+
+  it "adds a step" do
+    job.generate!(:plasma, 20)
+    job.steps.should match_steps([Dragonfly::Job::Generate])
+  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
+
+  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

data/spec/dragonfly/job/process_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Dragonfly::Job::Process do
+
+  let (:app) { test_app }
+  let (:job) { Dragonfly::Job.new(app) }
+
+  before :each do
+    app.add_processor(:resize){}
+  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

data/spec/dragonfly/job_endpoint_spec.rb

@@ -94,6 +94,23 @@ describe Dragonfly::JobEndpoint do
     response.status.should == 500
   end
 
+  describe "default content disposition file name" do
+    before do
+      uid = @app.store("GUNGLE", 'name' => 'güng.txt')
+      @job = @app.fetch(uid)
+    end
+
+    it "doesn't encode utf8 characters" do
+      response = make_request(@job)
+      response['Content-Disposition'].should == 'filename="güng.txt"'
+    end
+
+    it "does encode them if the request is from IE" do
+      response = make_request(@job, 'HTTP_USER_AGENT' => "Mozilla/5.0 (Windows; U; MSIE 7.0; Windows NT 6.0; el-GR)")
+      response['Content-Disposition'].should == 'filename="g%C3%BCng.txt"'
+    end
+  end
+
   describe "logging" do
     it "logs successful requests" do
       Dragonfly.should_receive(:info).with("GET /something?great 200")

data/spec/dragonfly/job_spec.rb

@@ -53,199 +53,12 @@ describe Dragonfly::Job do
     end
   end
 
-  describe "fetch" do
-    before(:each) do
-      job.fetch!('some_uid')
-    end
-
-    it { job.steps.should match_steps([Dragonfly::Job::Fetch]) }
-
-    it "should read from the app's datastore when applied" do
-      app.datastore.should_receive(:read).with('some_uid').and_return ["", {}]
-      job.apply
-    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 "generate" do
-    before :each do
-      app.add_generator(:plasma){}
-    end
-
-    it "adds a step" do
-      job.generate!(:plasma, 20)
-      job.steps.should match_steps([Dragonfly::Job::Generate])
-    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
-
-    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_attributes" do
-      job.url_attributes.name.should == 'egg.png'
-    end
-
-    it "should set the name" do
-      job.name.should == 'egg.png'
-    end
-  end
-
-  describe "fetch_url" do
-    before(:each) do
-      stub_request(:get, %r{http://place\.com/.*}).to_return(:body => 'result!')
-    end
-
-    it "adds a step" do
-      job.fetch_url!('some.url')
-      job.steps.should match_steps([Dragonfly::Job::FetchUrl])
-    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 "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
-
-    [
-      "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 "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
-
-    [
-      "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 "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
-
-    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 "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 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
-
-    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 "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
-
   describe "apply" do
     it "should return itself" do
       job.apply.should == job
     end
   end
 
-  describe "process" do
-    before :each do
-      app.add_processor(:resize){}
-    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") }
 

data/spec/dragonfly/model/model_spec.rb

@@ -946,7 +946,7 @@ describe "models" do
     end
   end
 
-  describe "changed?" do
+  describe "xxx_changed?" do
     before(:each) do
       @item_class = new_model_class('Item', :preview_image_uid) do
         dragonfly_accessor :preview_image
@@ -955,21 +955,36 @@ describe "models" do
     end
 
     it "should be changed when assigned" do
+      expect( @item.preview_image_changed? ).to be_false
       @item.preview_image = 'ggg'
-      @item.preview_image.should be_changed
+      expect( @item.preview_image_changed? ).to be_true
     end
 
-    it "should not be changed when saved" do
-      @item.preview_image = 'ggg'
-      @item.save!
-      @item.preview_image.should_not be_changed
-    end
+    describe "after saving" do
+      before do
+        @item.preview_image = 'ggg'
+        @item.save!
+      end
+
+      it "should not be changed" do
+        expect( @item.preview_image_changed? ).to be_false
+      end
+
+      it "should be changed when set to nil" do
+        @item.preview_image = nil
+        expect( @item.preview_image_changed? ).to be_true
+      end
+
+      it "should be changed when changed" do
+        @item.preview_image = "asdf"
+        expect( @item.preview_image_changed? ).to be_true
+      end
+
+      it "should not be changed when reloaded" do
+        item = @item_class.find(@item.id)
+        expect( @item.preview_image_changed? ).to be_false
+      end
 
-    it "should not be changed when reloaded" do
-      @item.preview_image = 'ggg'
-      @item.save!
-      item = @item_class.find(@item.id)
-      item.preview_image.should_not be_changed
     end
   end
 

data/spec/dragonfly/routed_endpoint_spec.rb

@@ -10,43 +10,84 @@ describe Dragonfly::RoutedEndpoint do
     Rack::MockRequest.env_for(url, opts)
   end
 
-  before(:each) do
-    @app = test_app
-    @endpoint = Dragonfly::RoutedEndpoint.new(@app) {|params, app|
-      app.fetch(params[:uid])
+  let (:app) { test_app }
+
+  describe "endpoint returning a job" do
+    let (:endpoint) {
+      Dragonfly::RoutedEndpoint.new(app) {|params, app|
+        app.fetch(params[:uid])
+      }
     }
-    @uid = @app.store('wassup')
-  end
 
-  it "should raise an error when there are no routing parameters" do
-    lambda{
-      @endpoint.call(env_for('/blah'))
-    }.should raise_error(Dragonfly::RoutedEndpoint::NoRoutingParams)
-  end
+    before(:each) do
+      @uid = app.store('wassup')
+    end
+
+    it "should raise an error when there are no routing parameters" do
+      lambda{
+        endpoint.call(env_for('/blah'))
+      }.should raise_error(Dragonfly::RoutedEndpoint::NoRoutingParams)
+    end
+
+    {
+      'Rails' => 'action_dispatch.request.path_parameters',
+      'HTTP Router' => 'router.params',
+      'Rack-Mount' => 'rack.routing_args',
+      'Dragonfly' => 'dragonfly.params'
+    }.each do |name, key|
 
-  {
-    'Rails' => 'action_dispatch.request.path_parameters',
-    'Usher' => 'usher.params',
-    'HTTP Router' => 'router.params',
-    'Rack-Mount' => 'rack.routing_args',
-    'Dragonfly' => 'dragonfly.params'
-  }.each do |name, key|
+      it "should work with #{name} routing args" do
+        response = response_for endpoint.call(env_for('/blah', key => {:uid => @uid}))
+        response.body.should == 'wassup'
+      end
 
-    it "should work with #{name} routing args" do
-      response = response_for @endpoint.call(env_for('/blah', key => {:uid => @uid}))
+    end
+
+    it "should merge with query parameters" do
+      env = Rack::MockRequest.env_for("/big/buns?uid=#{@uid}", 'dragonfly.params' => {:something => 'else'})
+      response = response_for endpoint.call(env)
       response.body.should == 'wassup'
     end
 
+     it "should have nice inspect output" do
+       endpoint.inspect.should =~ /<Dragonfly::RoutedEndpoint for app :default >/
+     end
   end
 
-  it "should merge with query parameters" do
-    env = Rack::MockRequest.env_for("/big/buns?uid=#{@uid}", 'dragonfly.params' => {:something => 'else'})
-    response = response_for @endpoint.call(env)
-    response.body.should == 'wassup'
-  end
+  describe "endpoint returning other things" do
+    let (:model_class) {
+      Class.new do
+        extend Dragonfly::Model
+        dragonfly_accessor :image
+        attr_accessor :image_uid
+      end
+    }
+    let (:model) {
+      model_class.new
+    }
+    let (:endpoint) {
+      Dragonfly::RoutedEndpoint.new(app) {|params, app|
+        model.image
+      }
+    }
+
+    it "acts like the job one" do
+      model.image = "wassup"
+      response = response_for endpoint.call(env_for('/blah', 'dragonfly.params' => {}))
+      response.body.should == 'wassup'
+    end
+
+    it "returns 404 if nil is returned from the endpoint" do
+      endpoint = Dragonfly::RoutedEndpoint.new(app) { nil }
+      response = response_for endpoint.call(env_for('/blah', 'dragonfly.params' => {}))
+      response.status.should == 404
+    end
 
-   it "should have nice inspect output" do
-     @endpoint.inspect.should =~ /<Dragonfly::RoutedEndpoint for app :default >/
-   end
+    it "returns 500 if something else is returned from the endpoint" do
+      endpoint = Dragonfly::RoutedEndpoint.new(app) { "ASDF" }
+      response = response_for endpoint.call(env_for('/blah', 'dragonfly.params' => {}))
+      response.status.should == 500
+    end
+  end
 
 end