dragonfly 0.9.15 → 1.0

data/spec/dragonfly/content_spec.rb

@@ -0,0 +1,353 @@
+require 'spec_helper'
+
+describe Dragonfly::Content do
+
+  let(:app) { test_app }
+
+  let(:content) { Dragonfly::Content.new(app) }
+
+  describe "initializing" do
+    it "allows initializing with content and meta" do
+      content = Dragonfly::Content.new(app, "things", 'some' => 'meta')
+      content.data.should == 'things'
+      content.meta.should == {'some' => 'meta'}
+    end
+  end
+
+  describe "temp_object" do
+    it "has one from the beginning" do
+      content.temp_object.should be_a(Dragonfly::TempObject)
+    end
+  end
+
+  describe "meta" do
+    it "defaults to an empty hash" do
+      content.meta.should == {}
+    end
+
+    it "sets meta" do
+      content.meta = {"hello" => 'there'}
+      content.meta.should == {"hello" => 'there'}
+    end
+
+    it "adds meta and returns itself" do
+      content.meta = {'hello' => 'there'}
+      content.add_meta('wassup' => 'guys?').should == content
+      content.meta.should == {'hello' => 'there', 'wassup' => 'guys?'}
+    end
+  end
+
+  describe "name" do
+    it "defaults to nil" do
+      content.name.should be_nil
+    end
+
+    it "gets taken from the meta" do
+      content.meta["name"] = 'some.name'
+      content.name.should == 'some.name'
+    end
+
+    it "has basename/name/ext setters" do
+      content.name = 'hello.there'
+      content.name.should == 'hello.there'
+      content.basename.should == 'hello'
+      content.ext.should == 'there'
+      content.ext = 'schmo'
+      content.name.should == 'hello.schmo'
+    end
+  end
+
+  describe "mime_type" do
+    it "takes it from the extension" do
+      content.name = "thing"
+      content.mime_type.should == "application/octet-stream"
+      content.name = "thing.png"
+      content.mime_type.should == "image/png"
+    end
+  end
+
+  describe "process!" do
+    it "calls the app's processor on itself and returns itself" do
+      app.add_processor(:shizzle){}
+      app.get_processor(:shizzle).should_receive(:call).with(content, 'args')
+      content.process!(:shizzle, 'args').should == content
+    end
+  end
+
+  describe "generate!" do
+    it "calls the app's generator on itself and returns itself" do
+      app.add_generator(:shizzle){}
+      app.get_generator(:shizzle).should_receive(:call).with(content, 'args')
+      content.generate!(:shizzle, 'args').should == content
+    end
+  end
+
+  describe "analyse" do
+    before do
+      app.add_analyser(:len){|content| content.size }
+      content.update("shizzle")
+    end
+
+    it "calls the app's analyser on itself" do
+      app.get_analyser(:len).should_receive(:call).with(content).and_return(7)
+      content.analyse(:len).should == 7
+    end
+
+    it "caches the result" do
+      content.analyse(:len).should == 7
+      app.get_analyser(:len).should_not_receive(:call)
+      content.analyse(:len).should == 7
+    end
+
+    it "caches it in the meta" do
+      content.meta["analyser_cache"].should be_nil
+      content.analyse(:len).should == 7
+      content.meta["analyser_cache"].should == {"len" => 7}
+    end
+
+    it "empties the cache if updated" do
+      content.analyse(:len).should == 7
+      content.meta["analyser_cache"].should == {"len" => 7}
+      content.update("something else")
+      content.meta["analyser_cache"].should be_nil
+      content.analyse(:len).should == 14
+      content.meta["analyser_cache"].should == {"len" => 14}
+    end
+  end
+
+  describe "update" do
+    it "updates the content" do
+      content.update("stuff")
+      content.data.should == 'stuff'
+    end
+
+    it "optionally updates the meta" do
+      content.update("stuff", 'meta' => 'here')
+      content.meta.should == {'meta' => 'here'}
+    end
+
+    it "returns itself" do
+      content.update('abc').should == content
+    end
+
+    it "can be updated with another content" do
+      content2 = Dragonfly::Content.new(app, "a", "b" => "c")
+      content.update(content2)
+      content.data.should == 'a'
+      content.meta['b'].should == 'c'
+    end
+
+    describe "meta name" do
+      let (:object) { "HI EVERYONE" }
+      let (:object_with_original_filename) {
+        obj = "Hi Guys"
+        def obj.original_filename; 'something.original'; end
+        obj
+      }
+
+      it "is nil if there is no original_filename" do
+        content.update(object)
+        content.meta['name'].should be_nil
+      end
+
+      it "sets the name to the original filename" do
+        content.update(object_with_original_filename)
+        content.meta['name'].should == 'something.original'
+      end
+
+      it "overrides original filename with the specified name" do
+        content.update(object_with_original_filename, 'name' => 'summink.else')
+        content.meta['name'].should == 'summink.else'
+      end
+
+      it "doesn't override a name already there" do
+        content.meta['name'] = 'already.here'
+        content.update(object_with_original_filename)
+        content.meta['name'].should == 'already.here'
+      end
+    end
+  end
+
+  describe "delegated methods to temp_object" do
+    it "data" do
+      content.data.should == ""
+      content.update("ASDF")
+      content.data.should == 'ASDF'
+    end
+
+    it "file" do
+      content.file.should be_a(File)
+      content.file.read.should == ""
+      content.update("sdf")
+      content.file.should be_a(File)
+      content.file.read.should == 'sdf'
+      content.file{|f| f.read.should == 'sdf'}
+    end
+
+    it "path" do
+      content.path.should =~ %r{\w+/\w+}
+      content.update(Pathname.new('/usr/eggs'))
+      content.path.should == '/usr/eggs'
+    end
+
+    it "size" do
+      content.size.should == 0
+      content.update("hjk")
+      content.size.should == 3
+    end
+
+    it "each" do
+      str = ""
+      content.each{|chunk| str << chunk }
+      str.should == ""
+      content.update("asdf")
+      content.each{|chunk| str << chunk }
+      str.should == "asdf"
+    end
+
+  end
+
+  describe "shell commands" do
+    let (:content) { Dragonfly::Content.new(app, "big\nstuff", 'name' => 'content.jpg') }
+
+    it "evalutes using the shell" do
+      path = nil
+      content.shell_eval do |p|
+        path = p
+        "cat #{path}"
+      end.should == "big\nstuff"
+      path.should == app.shell.quote(content.path)
+    end
+
+    it "allows evaluating without escaping" do
+      path = nil
+      content.shell_eval(:escape => false) do |p|
+        path = p
+        %{$(echo cat) #{path}}
+      end.should == "big\nstuff"
+      path.should == content.path
+    end
+
+    it "runs the shell command with a new tempfile path, returning self" do
+      original_path = content.path
+      old_path = nil
+      new_path = nil
+      content.shell_update do |o, n|
+        old_path = o
+        new_path = n
+        "cp #{o} #{n}"
+      end.should == content
+      old_path.should == app.shell.quote(original_path)
+      new_path.should == app.shell.quote(content.path)
+      content.data.should == "big\nstuff"
+    end
+
+    it "allows updating without escaping" do
+      original_path = content.path
+      old_path = nil
+      new_path = nil
+      content.shell_update(:escape => false) do |o, n|
+        old_path = o
+        new_path = n
+        "cat #{o} > #{n}"
+      end.should == content
+      old_path.should == original_path
+      new_path.should == content.path
+      content.data.should == "big\nstuff"
+    end
+
+    it "defaults the extension to the same" do
+      content.shell_update do |old_path, new_path|
+        "cp #{old_path} #{new_path}"
+      end
+      content.path.should =~ /\.jpg$/
+    end
+
+    it "allows changing the new_path file extension" do
+      content.shell_update :ext => 'png' do |old_path, new_path|
+        "cp #{old_path} #{new_path}"
+      end
+      content.path.should =~ /\.png$/
+    end
+
+    describe "generating" do
+      let(:content_2) { Dragonfly::Content.new(app) }
+
+      it "allows generating with the shell" do
+        content_2.shell_generate do |path|
+          "cp #{content.path} #{path}"
+        end.should == content_2
+        content_2.data.should == "big\nstuff"
+      end
+
+      it "allows generating without escaping" do
+        content_2.shell_generate(:escape => false) do |path|
+          "echo dogs >> #{path}"
+        end
+        content_2.data.should == "dogs\n"
+      end
+
+      it "allows setting the ext on generate" do
+        content_2.shell_generate(:ext => 'txt') do |path|
+          "cp #{content.path} #{path}"
+        end
+        content_2.path.should =~ /\.txt$/
+      end
+    end
+
+  end
+
+  describe "store" do
+    it "stores itself in the app's datastore" do
+      app.datastore.should_receive(:write).with(content, {})
+      content.store
+    end
+
+    it "allows passing options" do
+      app.datastore.should_receive(:write).with(content, :hello => 'there')
+      content.store(:hello => 'there')
+    end
+  end
+
+  describe "b64_data" do
+    it "returns a b64 data string" do
+      content.update("HELLO", "name" => "hello.txt")
+      content.b64_data.should == "data:text/plain;base64,SEVMTE8=\n"
+    end
+  end
+
+  describe "close" do
+    before(:each) do
+      @app = test_app
+      @app.add_processor(:upcase){|c| c.update("HELLO") }
+      @content = Dragonfly::Content.new(@app, "hello")
+      @temp_object1 = @content.temp_object
+      @content.process!(:upcase)
+      @temp_object2 = @content.temp_object
+      @temp_object1.should_not == @temp_object2 # just checking
+    end
+
+    it "should clean up tempfiles for the last temp_object" do
+      @temp_object2.should_receive(:close)
+      @content.close
+    end
+
+    it "should clean up tempfiles for previous temp_objects" do
+      @temp_object1.should_receive(:close)
+      @content.close
+    end
+  end
+
+  describe "env" do
+    it "returns the app's env" do
+      content.env.should == app.env
+    end
+  end
+
+  describe "inspect" do
+    it "returns a string" do
+      content.inspect.should =~ /Content/
+    end
+  end
+
+end

data/spec/dragonfly/cookie_monster_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'rack'
+require 'dragonfly/cookie_monster'
 
 describe Dragonfly::CookieMonster do
 
@@ -19,7 +20,7 @@ describe Dragonfly::CookieMonster do
   end
 
   it "should delete the set-cookie header from the response if the response comes from dragonfly" do
-    response = Rack::MockRequest.new(app('dragonfly.job' => mock)).get('')
+    response = Rack::MockRequest.new(app('dragonfly.job' => double)).get('')
     response.status.should == 200
     response.body.should == "body here"
     response.headers["Set-Cookie"].should be_nil

data/spec/dragonfly/file_data_store_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+require 'dragonfly/spec/data_store_examples'
+
+describe Dragonfly::FileDataStore do
+
+  def touch_file(filename)
+    FileUtils.mkdir_p(File.dirname(filename))
+    FileUtils.touch(filename)
+  end
+
+  def assert_exists(path)
+    File.exists?(path).should be_true
+  end
+
+  def assert_does_not_exist(path)
+    File.exists?(path).should be_false
+  end
+
+  let (:app) { test_app }
+  let (:content) { Dragonfly::Content.new(app, 'goobydoo') }
+  let (:new_content) { Dragonfly::Content.new(app) }
+
+  describe "with a given root path" do
+
+    before(:each) do
+      @data_store = Dragonfly::FileDataStore.new(:root_path => 'tmp/file_data_store_test')
+    end
+
+    after(:each) do
+      # Clean up created files
+      FileUtils.rm_rf("#{@data_store.root_path}")
+    end
+
+    it_should_behave_like 'data_store'
+
+    describe "write" do
+
+      before(:each) do
+        # Set 'now' to a date in the past
+        Time.stub(:now).and_return Time.mktime(1984,"may",4,14,28,1)
+        @file_pattern_prefix_without_root = '1984/05/04/14_28_01_0_'
+        @file_pattern_prefix = "#{@data_store.root_path}/#{@file_pattern_prefix_without_root}"
+      end
+
+      it "should store the file in a folder based on date, with default filename" do
+        @data_store.write(content)
+        assert_exists "#{@file_pattern_prefix}file"
+      end
+
+      it "should use the content name if it exists" do
+        content.should_receive(:name).at_least(:once).and_return('hello.there')
+        @data_store.write(content)
+        assert_exists "#{@file_pattern_prefix}hello.there"
+      end
+
+      it "should get rid of funny characters in the content name" do
+        content.should_receive(:name).at_least(:once).and_return('A Picture with many spaces in its name (at 20:00 pm).png')
+        @data_store.write(content)
+        assert_exists "#{@file_pattern_prefix}A_Picture_with_many_spaces_in_its_name_at_20_00_pm_.png"
+      end
+
+      it "stores meta as YAML" do
+        content.meta = {'wassup' => 'doc'}
+        @data_store.write(content)
+        File.read("#{@file_pattern_prefix}file.meta.yml").should =~ /---\s+wassup: doc/
+      end
+
+      describe "when the filename already exists" do
+
+        it "should use a different filename" do
+          touch_file("#{@file_pattern_prefix}file")
+          @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}file").and_return("#{@file_pattern_prefix}file_2")
+          @data_store.write(content)
+          assert_exists "#{@file_pattern_prefix}file_2"
+        end
+
+        it "should use a different filename taking into account the name and ext" do
+          content.should_receive(:name).at_least(:once).and_return('hello.png')
+          touch_file("#{@file_pattern_prefix}hello.png")
+          @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}hello.png").and_return("#{@file_pattern_prefix}blah.png")
+          @data_store.write(content)
+        end
+
+        it "should keep trying until it finds a free filename" do
+          touch_file("#{@file_pattern_prefix}file")
+          touch_file("#{@file_pattern_prefix}file_2")
+          @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}file").and_return("#{@file_pattern_prefix}file_2")
+          @data_store.should_receive(:disambiguate).with("#{@file_pattern_prefix}file_2").and_return("#{@file_pattern_prefix}file_3")
+          @data_store.write(content)
+          assert_exists "#{@file_pattern_prefix}file_3"
+        end
+
+        describe "specifying the uid" do
+          it "should allow for specifying the path to use" do
+            @data_store.write(content, :path => 'hello/there/mate.png')
+            assert_exists "#{@data_store.root_path}/hello/there/mate.png"
+          end
+          it "should correctly disambiguate if the file exists" do
+            touch_file("#{@data_store.root_path}/hello/there/mate.png")
+            @data_store.should_receive(:disambiguate).with("#{@data_store.root_path}/hello/there/mate.png").and_return("#{@data_store.root_path}/hello/there/mate_2.png")
+            @data_store.write(content, :path => 'hello/there/mate.png')
+            assert_exists "#{@data_store.root_path}/hello/there/mate_2.png"
+          end
+        end
+
+      end
+
+      describe "return value" do
+
+        it "should return the filepath without the root of the stored file when a file name is not provided" do
+          @data_store.write(content).should == "#{@file_pattern_prefix_without_root}file"
+        end
+
+        it "should return the filepath without the root of the stored file when a file name is provided" do
+          content.should_receive(:name).at_least(:once).and_return('hello.you.png')
+          @data_store.write(content).should == "#{@file_pattern_prefix_without_root}hello.you.png"
+        end
+
+      end
+
+    end
+
+    describe "disambiguate" do
+      it "should add a suffix" do
+        @data_store.disambiguate('/some/file').should =~ %r{^/some/file_\w+$}
+      end
+      it "should add a suffix to the basename" do
+        @data_store.disambiguate('/some/file.png').should =~ %r{^/some/file_\w+\.png$}
+      end
+      it "should be random(-ish)" do
+        @data_store.disambiguate('/some/file').should_not == @data_store.disambiguate('/some/file')
+      end
+    end
+
+    describe "read" do
+      it "should be able to read any file, stored or not (and without meta data)" do
+        FileUtils.mkdir_p("#{@data_store.root_path}/jelly_beans/are")
+        File.open("#{@data_store.root_path}/jelly_beans/are/good", 'w'){|f| f.write('hey dog') }
+        new_content.update(*@data_store.read("jelly_beans/are/good"))
+        new_content.data.should == 'hey dog'
+        new_content.meta.should == {'name' => 'good'}
+      end
+
+      it "should raise if the file path has ../ in it" do
+        expect{
+          @data_store.read('jelly_beans/../are/good')
+        }.to raise_error(Dragonfly::FileDataStore::BadUID)
+      end
+
+      it "should not raise if the file path has .. but not ../ in it" do
+        @data_store.write(content, :path => 'jelly_beans..good')
+        new_content.update(*@data_store.read('jelly_beans..good'))
+        new_content.data.should == 'goobydoo'
+      end
+    end
+
+    describe "destroying" do
+      it "should prune empty directories when destroying" do
+        uid = @data_store.write(content)
+        @data_store.destroy(uid)
+        @data_store.root_path.should be_an_empty_directory
+      end
+
+      it "should not prune root_path directory when destroying file without directory prefix in path" do
+        uid = @data_store.write(content, :path => 'mate.png')
+        @data_store.destroy(uid)
+        @data_store.root_path.should be_an_empty_directory
+      end
+
+      it "should raise if the file path has ../ in it" do
+        expect{
+          @data_store.destroy('jelly_beans/../are/good')
+        }.to raise_error(Dragonfly::FileDataStore::BadUID)
+      end
+    end
+
+    describe "setting the root_path" do
+      it "should allow setting as a pathname" do
+        @data_store.root_path = Pathname.new('/some/thing')
+        @data_store.root_path.should == '/some/thing'
+      end
+    end
+
+    describe "relative paths" do
+      let(:store) { Dragonfly::FileDataStore.new }
+      let(:relative_path) { "2011/02/11/picture.jpg" }
+      let(:absolute_path) { "#{root_path}#{relative_path}" }
+      let(:root_path) { "/path/to/file/" }
+
+      before do
+        store.root_path = root_path
+      end
+
+      subject { store.send :relative, absolute_path }
+
+      it { should == relative_path }
+
+      context "where root path contains spaces" do
+        let(:root_path) { "/path/to/file name/" }
+        it { should == relative_path }
+      end
+      context "where root path contains special chars" do
+        let(:root_path) { "/path/to/file name (Special backup directory)/" }
+        it { should == relative_path }
+      end
+    end
+
+    describe "turning meta off" do
+      before(:each) do
+        @data_store.store_meta = false
+        content.meta = {'bitrate' => '35', 'name' => 'danny.boy'}
+      end
+
+      it "should not write a meta file" do
+        uid = @data_store.write(content)
+        assert_does_not_exist(File.join(@data_store.root_path, "#{uid}.meta"))
+        assert_does_not_exist(File.join(@data_store.root_path, "#{uid}.meta.yml"))
+      end
+
+      it "should return an empty hash on read" do
+        uid = @data_store.write(content)
+        new_content.update(*@data_store.read(uid))
+        new_content.meta['bitrate'].should be_nil
+      end
+
+      it "should still destroy the meta file if it exists" do
+        @data_store.store_meta = true
+        uid = @data_store.write(content)
+        @data_store.store_meta = false
+        @data_store.destroy(uid)
+        @data_store.root_path.should be_an_empty_directory
+      end
+
+      it "should still destroy properly if meta is on but the meta file doesn't exist" do
+        uid = @data_store.write(content)
+        @data_store.store_meta = true
+        @data_store.destroy(uid)
+        @data_store.root_path.should be_an_empty_directory
+      end
+    end
+
+    describe "urls for serving directly" do
+      before(:each) do
+        @uid = 'some/path/to/file.png'
+        @data_store.root_path = '/var/tmp/eggs'
+      end
+
+      it "should raise an error if called without configuring" do
+        expect{
+          @data_store.url_for(@uid)
+        }.to raise_error(Dragonfly::FileDataStore::UnableToFormUrl)
+      end
+
+      it "should work as expected when the the server root is above the root path" do
+        @data_store.server_root = '/var/tmp'
+        @data_store.url_for(@uid).should == '/eggs/some/path/to/file.png'
+      end
+
+      it "should work as expected when the the server root is the root path" do
+        @data_store.server_root = '/var/tmp/eggs'
+        @data_store.url_for(@uid).should == '/some/path/to/file.png'
+      end
+
+      it "should work as expected when the the server root is below the root path" do
+        @data_store.server_root = '/var/tmp/eggs/some/path'
+        @data_store.url_for(@uid).should == '/to/file.png'
+      end
+
+      it "should allow setting the server_root as a pathname" do
+        @data_store.server_root = Pathname.new('/var/tmp/eggs/some/path')
+        @data_store.url_for(@uid).should == '/to/file.png'
+      end
+
+      it "should raise an error when the server root doesn't coincide with the root path" do
+        @data_store.server_root = '/var/blimey/eggs'
+        expect{
+          @data_store.url_for(@uid)
+        }.to raise_error(Dragonfly::FileDataStore::UnableToFormUrl)
+      end
+
+      it "should raise an error when the server root doesn't coincide with the uid" do
+        @data_store.server_root = '/var/tmp/eggs/some/gooney'
+        expect{
+          @data_store.url_for(@uid)
+        }.to raise_error(Dragonfly::FileDataStore::UnableToFormUrl)
+      end
+    end
+
+  end
+
+  describe "deprecated meta" do
+    let(:data_store){ Dragonfly::FileDataStore.new(:root_path => 'spec/fixtures/deprecated_stored_content')}
+
+    it "still works with old-style meta" do
+      new_content.update(*data_store.read('eggs.bonus'))
+      new_content.data.should == "Barnicle"
+      new_content.meta.should == {'name' => 'eggs.bonus', 'some' => 'meta', 'number' => 5}
+    end
+  end
+end
+