dragonfly 0.9.15 → 1.0

data/lib/dragonfly/processing/image_magick_processor.rb

@@ -1,6 +0,0 @@
-module Dragonfly
-  module Processing
-    puts "WARNING: Dragonfly::Processing::ImageMagickProcessor is DEPRECATED and will soon be removed. Please use Dragonfly::ImageMagick::Processor instead."
-    ImageMagickProcessor = ImageMagick::Processor
-  end
-end

data/lib/dragonfly/processor.rb

@@ -1,9 +0,0 @@
-module Dragonfly
-  class Processor < FunctionManager
-
-    def process(temp_object, method, *args)
-      call_last(method, temp_object, *args)
-    end
-
-  end
-end

data/lib/dragonfly/rails/images.rb

@@ -1,32 +0,0 @@
-require 'uri'
-require 'dragonfly'
-begin
-  require 'rack/cache'
-rescue LoadError => e
-  puts "Couldn't find rack-cache - make sure you have it in your Gemfile:"
-  puts "  gem 'rack-cache', :require => 'rack/cache'"
-  puts " or configure dragonfly manually instead of using 'dragonfly/rails/images'"
-  raise e
-end
-
-### The dragonfly app ###
-app = Dragonfly[:images]
-app.configure_with(:rails)
-app.configure_with(:imagemagick)
-
-### Extend active record ###
-if defined?(ActiveRecord::Base)
-  app.define_macro(ActiveRecord::Base, :image_accessor)
-  app.define_macro(ActiveRecord::Base, :file_accessor)
-end
-
-### Insert the middleware ###
-rack_cache_already_inserted = Rails.application.config.action_controller.perform_caching && Rails.application.config.action_dispatch.rack_cache
-
-Rails.application.middleware.insert 0, Rack::Cache, {
-  :verbose     => true,
-  :metastore   => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/meta"), # URI encoded in case of spaces
-  :entitystore => URI.encode("file:#{Rails.root}/tmp/dragonfly/cache/body")
-} unless rack_cache_already_inserted
-
-Rails.application.middleware.insert_after Rack::Cache, Dragonfly::Middleware, :images

data/lib/dragonfly/simple_cache.rb

@@ -1,23 +0,0 @@
-module Dragonfly
-  class SimpleCache < Hash
-    
-    def initialize(max_size)
-      @max_size = max_size
-      @keys = []
-    end
-    
-    attr_reader :max_size
-    
-    def []=(key, value)
-      if !has_key?(key)
-        @keys << key
-        if size == max_size
-          key_to_purge = @keys.shift
-          delete(key_to_purge)
-        end
-      end
-      super
-    end
-    
-  end
-end

data/spec/dragonfly/active_model_extensions/spec_helper.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-require 'active_model'
-
-# --------------------------------------------------------------- #
-# MODELS
-# --------------------------------------------------------------- #
-class MyModel
-  
-  # Callbacks
-  extend ActiveModel::Callbacks
-  define_model_callbacks :save, :destroy
-  
-  include ActiveModel::Validations
-  include ActiveModel::Dirty
-  
-  class << self
-    def create!(attrs={})
-      new(attrs).save!
-    end
-    
-    def find(id)
-      new(instances[id])
-    end
-    
-    def instances
-      @instances ||= {}
-    end
-  end
-
-  def initialize(attrs={})
-    attrs.each do |key, value|
-      send("#{key}=", value)
-    end
-  end
-  
-  attr_accessor :id
-  
-  def to_hash
-    self.class::ATTRIBUTES.inject({}) do |hash, attr|
-      hash[attr] = send(attr)
-      hash
-    end
-  end
-  
-  def save
-    _run_save_callbacks {
-      self.id ||= rand(1000)
-      self.class.instances[id] = self.to_hash
-    }
-  end
-  def save!
-    save
-    self
-  end
-  
-  def destroy
-    _run_destroy_callbacks {}
-  end
-end
-
-class Item < MyModel
-  
-  ATTRIBUTES = [
-    :title,
-    :preview_image_uid,
-    :preview_image_some_analyser_method,
-    :preview_image_size,
-    :preview_image_name,
-    :preview_image_blah_blah,
-    :other_image_uid,
-    :yet_another_image_uid,
-    :otra_imagen_uid,
-    :trailer_video_uid,
-    :created_at,
-    :updated_at
-  ]
-  define_attribute_methods ATTRIBUTES
-  attr_accessor *ATTRIBUTES
-end
-
-class Car < MyModel
-  ATTRIBUTES = [
-    :image_uid,
-    :reliant_image_uid,
-    :type
-  ]
-  define_attribute_methods ATTRIBUTES
-  attr_accessor *ATTRIBUTES
-end
-
-class Photo < MyModel
-  ATTRIBUTES = [:image_uid]
-  define_attribute_methods ATTRIBUTES
-  attr_accessor *ATTRIBUTES
-end

data/spec/dragonfly/analyser_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe Dragonfly::Analyser do
-  
-  before(:each) do
-    @analyser = Dragonfly::Analyser.new
-    @analyser.log = Logger.new(LOG_FILE)
-  end
-  
-  describe "analysis_methods module" do
-    
-    before(:each) do
-      @analyser.add(:num_letters){|temp_object, letter| temp_object.data.count(letter) }
-      @obj = Object.new
-      @obj.extend @analyser.analysis_methods
-    end
-    
-    it "should return a module" do
-      @analyser.analysis_methods.should be_a(Module)
-    end
-    
-    it "should provide the object with the analyser method" do
-      @obj.analyser.should == @analyser
-    end
-    
-    it "should provide the object with the direct analysis method, provided that analyse method exists" do
-      def @obj.analyse(meth, *args)
-        analyser.analyse Dragonfly::TempObject.new('HELLO'), meth, *args
-      end
-      @obj.num_letters('L').should == 2
-    end
-    
-  end
-  
-  describe "analyse" do
-    it "should return nil if the function isn't defined" do
-      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
-    end
-    it "should return nil if the function can't be handled" do
-      @analyser.add(:width){ throw :unable_to_handle }
-      @analyser.analyse(Dragonfly::TempObject.new("Hello"), :width).should be_nil
-    end
-  end
-  
-  describe "analysis_method_names" do
-    it "should return the analysis methods" do
-      @analyser.add(:width){}
-      @analyser.add(:height){}
-      @analyser.analysis_method_names.should == [:width, :height]
-    end
-  end
-  
-  describe "cache" do
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('HELLO')
-    end
-
-    def it_should_analyse_using(meth, temp_object, *args)
-      result = mock('result')
-      @analyser.should_receive(:call_last).with(meth, temp_object, *args).exactly(:once).and_return result
-      @analyser.analyse(temp_object, meth, *args).should == result
-      result
-    end
-
-    it "should do the analysis the first time" do
-      it_should_analyse_using(:blah, @temp_object, :arg1)
-    end
-
-    describe "when already called" do
-      before(:each) do
-        @result = it_should_analyse_using(:blah, @temp_object, :arg1)
-      end
-
-      it "should not do it subsequent times but still return the result" do
-        @analyser.should_not_receive(:call_last)
-        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
-        @analyser.analyse(@temp_object, :blah, :arg1).should == @result
-      end
-      
-      it "should not use the cache if the temp_object is different" do
-        temp_object = Dragonfly::TempObject.new('aaa')
-        it_should_analyse_using(:blah, temp_object, :arg1)
-      end
-      
-      it "should not use the cache if the method name is different" do
-        it_should_analyse_using(:egghead, @temp_object, :arg1)
-      end
-      
-      it "should not use the cache if the args are different" do
-        it_should_analyse_using(:blah, @temp_object, :arg2)
-      end
-      
-      it "should do it again if the cache has been cleared" do
-        @analyser.clear_cache!
-        it_should_analyse_using(:blah, @temp_object, :arg1)
-      end
-
-      it "should not use the cache if it has been turned off" do
-        @analyser.enable_cache = false
-        it_should_analyse_using(:blah, @temp_object, :arg1)
-      end
-      
-    end
-
-    describe "cache size" do
-      it "should not exceed the cache size" do
-        @analyser.cache_size = 2
-
-        res1 = it_should_analyse_using(:blah, @temp_object, :arg1)
-        res2 = it_should_analyse_using(:blah, @temp_object, :arg2)
-        res3 = it_should_analyse_using(:blah, @temp_object, :arg3) # Should kick out first one
-        
-        it_should_analyse_using(:blah, @temp_object, :arg1)
-
-        # Third analysis should still be cached
-        @analyser.should_not_receive(:call_last)
-        @analyser.analyse(@temp_object, :blah, :arg3).should == res3
-      end
-    end
-
-  end
-  
-end

data/spec/dragonfly/analysis/file_command_analyser_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-png_path = File.dirname(__FILE__) + '/../../../samples/egg.png'
-
-describe Dragonfly::Analysis::FileCommandAnalyser do
-  
-  before(:each) do
-    pending "not applicable to windows" if Dragonfly.running_on_windows?
-    @analyser = Dragonfly::Analysis::FileCommandAnalyser.new
-  end
-  
-  describe "mime_type" do
-    
-    describe "when using the filesystem" do
-      before(:each) do
-        @analyser.use_filesystem = true
-        @temp_object = Dragonfly::TempObject.new(File.new(png_path))
-      end
-      it "should give the mime-type" do
-        @analyser.mime_type(@temp_object).should == 'image/png'
-      end
-      it "should not have initialized the data string" do
-        @analyser.mime_type(@temp_object)
-        @temp_object.instance_eval{@data}.should be_nil
-      end
-    end
-    
-    describe "when not using the filesystem" do
-      before(:each) do
-        @analyser.use_filesystem = false
-        @temp_object = Dragonfly::TempObject.new(File.read(png_path))
-      end
-      it "should give the mime-type" do
-        @analyser.mime_type(@temp_object).should == 'image/png'
-      end
-      it "should not have initialized the file" do
-        @analyser.mime_type(@temp_object)
-        @temp_object.instance_eval{@tempfile}.should be_nil
-      end
-      it "should work properly (without a broken pipe error) for big files of format jpg" do
-        data = Dragonfly::ImageMagick::Generator.new.plasma(1000, 1000, :jpg).first
-        temp_object = Dragonfly::TempObject.new(data)
-        @analyser.mime_type(temp_object).should == "image/jpeg"
-      end
-    end
-  
-  end
-  
-end

data/spec/dragonfly/data_storage/couch_data_store_spec.rb

@@ -1,84 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require File.dirname(__FILE__) + '/shared_data_store_examples'
-require 'net/http'
-require 'uri'
-
-describe Dragonfly::DataStorage::CouchDataStore do
-
-  before(:each) do
-    WebMock.allow_net_connect!
-    @data_store = Dragonfly::DataStorage::CouchDataStore.new(
-      :database => "dragonfly_test"
-    )
-    begin
-      @data_store.db.get('ping')
-    rescue Errno::ECONNREFUSED => e
-      pending "You need to start CouchDB on localhost:5984 to test the CouchDataStore"
-    rescue RestClient::ResourceNotFound
-    end
-    
-  end
-  
-  it_should_behave_like 'data_store'
-  
-  describe "destroy" do
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('gollum')
-    end
-    
-    it "should raise an error if the data doesn't exist on destroy" do
-      uid = @data_store.store(@temp_object)
-      @data_store.destroy(uid)
-      lambda{
-        @data_store.destroy(uid)
-      }.should raise_error(Dragonfly::DataStorage::DataNotFound)
-    end
-  end
-  
-  describe "url_for" do
-    it "should give the correct url" do
-      @data_store.url_for('asd7fas9df/thing.txt').should == 'http://localhost:5984/dragonfly_test/asd7fas9df/thing.txt'
-    end
-    
-    it "should assume the attachment is called 'file' if not given" do
-      @data_store.url_for('asd7fas9df').should == 'http://localhost:5984/dragonfly_test/asd7fas9df/file'
-    end
-  end
-  
-  describe "serving from couchdb" do
-
-    def get_content(url)
-      uri = URI.parse(url)
-      Net::HTTP.start(uri.host, uri.port) {|http|
-        http.get(uri.path)
-      }
-    end
-
-    before(:each) do
-      @temp_object = Dragonfly::TempObject.new('testingyo')
-    end
-    
-    it "should use the fallback by default" do
-      uid = @data_store.store(@temp_object)
-      response = get_content(@data_store.url_for(uid))
-      response.body.should == 'testingyo'
-      response['Content-Type'].should == 'application/octet-stream'
-    end
-    
-    it "should allow setting on store with 'content_type'" do
-      uid = @data_store.store(@temp_object, :content_type => 'text/plain')
-      response = get_content(@data_store.url_for(uid))
-      response.body.should == 'testingyo'
-      response['Content-Type'].should == 'text/plain'
-    end
-    
-    it "should allow setting on store with 'mime_type'" do
-      uid = @data_store.store(@temp_object, :mime_type => 'text/plain-yo')
-      response = get_content(@data_store.url_for(uid))
-      response.body.should == 'testingyo'
-      response['Content-Type'].should == 'text/plain-yo'
-    end
-  end
-  
-end

data/spec/dragonfly/data_storage/file_data_store_spec.rb

@@ -1,308 +0,0 @@
-require 'spec_helper'
-require File.dirname(__FILE__) + '/shared_data_store_examples'
-
-describe Dragonfly::DataStorage::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
-  
-  before(:each) do
-    @data_store = Dragonfly::DataStorage::FileDataStore.new
-    @data_store.root_path = 'tmp/file_data_store_test'
-    @temp_object = Dragonfly::TempObject.new('goobydoo')
-  end
-  
-  after(:each) do
-    # Clean up created files
-    FileUtils.rm_rf("#{@data_store.root_path}")
-  end
-  
-  it_should_behave_like 'data_store'
-  
-  describe "store" 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.store(@temp_object)
-      assert_exists "#{@file_pattern_prefix}file"
-    end
-
-    it "should use the temp_object name if it exists" do
-      @temp_object.should_receive(:name).at_least(:once).and_return('hello.there')
-      @data_store.store(@temp_object)
-      assert_exists "#{@file_pattern_prefix}hello.there"
-    end
-
-    it "should get rid of funny characters in the temp_object name" do
-      @temp_object.should_receive(:name).at_least(:once).and_return('A Picture with many spaces in its name (at 20:00 pm).png')
-      @data_store.store(@temp_object)
-      assert_exists "#{@file_pattern_prefix}A_Picture_with_many_spaces_in_its_name_at_20_00_pm_.png"
-    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.store(@temp_object)
-        assert_exists "#{@file_pattern_prefix}file_2"
-      end
-    
-      it "should use a different filename taking into account the name and ext" do
-        @temp_object.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.store(@temp_object)
-      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.store(@temp_object)
-        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.store(@temp_object, :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.store(@temp_object, :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.store(@temp_object).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
-        @temp_object.should_receive(:name).at_least(:once).and_return('hello.you.png')
-        @data_store.store(@temp_object).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 "errors" do
-
-    it "should raise an error if it can't create a directory" do
-      FileUtils.should_receive(:mkdir_p).and_raise(Errno::EACCES)
-      lambda{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::DataStorage::UnableToStore)
-    end
-  
-    it "should raise an error if it can't create a file" do
-      @temp_object.should_receive(:to_file).and_raise(Errno::EACCES)
-      lambda{ @data_store.store(@temp_object) }.should raise_error(Dragonfly::DataStorage::UnableToStore)
-    end
-
-  end
-  
-  describe "retrieve" do
-    it "should return a pathname" do
-      uid = @data_store.store(@temp_object)
-      pathname, meta = @data_store.retrieve(uid)
-      pathname.should be_a(Pathname)
-    end
-    
-    it "should be able to retrieve 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') }
-      pathname, meta = @data_store.retrieve("jelly_beans/are/good")
-      pathname.read.should == 'hey dog'
-      meta.should == {}
-    end
-    
-    it "should work even if meta is stored in old .extra file" do
-      @temp_object.meta = {:dog => 'foog'}
-      uid = @data_store.store(@temp_object)
-      FileUtils.mv("#{@data_store.root_path}/#{uid}.meta", "#{@data_store.root_path}/#{uid}.extra")
-      pathname, meta = @data_store.retrieve(uid)
-      meta.should == {:dog => 'foog'}
-    end
-    
-    it "should raise a BadUID error if the file path has ../ in it" do
-      expect{
-        @data_store.retrieve('jelly_beans/../are/good')
-      }.to raise_error(Dragonfly::DataStorage::BadUID)
-    end
-
-    it "should not raise a BadUID error if the file path has .. but not ../ in it" do
-      expect{
-        @data_store.retrieve('jelly_beans..good')
-      }.to raise_error(Dragonfly::DataStorage::DataNotFound)
-    end
-  end
-  
-  describe "destroying" do
-    it "should prune empty directories when destroying" do
-      uid = @data_store.store(@temp_object)
-      @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.store(@temp_object, :path => 'mate.png')
-      @data_store.destroy(uid)
-      @data_store.root_path.should be_an_empty_directory
-    end
-
-    it "should raise an error if the data doesn't exist on destroy" do
-      uid = @data_store.store(@temp_object)
-      @data_store.destroy(uid)
-      lambda{
-        @data_store.destroy(uid)
-      }.should raise_error(Dragonfly::DataStorage::DataNotFound)
-    end
-
-    it "should also destroy old .extra files" do
-      uid = @data_store.store(@temp_object)
-      FileUtils.cp("#{@data_store.root_path}/#{uid}.meta", "#{@data_store.root_path}/#{uid}.extra")
-      @data_store.destroy(uid)
-      File.exist?("#{@data_store.root_path}/#{uid}").should be_false
-      File.exist?("#{@data_store.root_path}/#{uid}.meta").should be_false
-      File.exist?("#{@data_store.root_path}/#{uid}.extra").should be_false
-    end
-
-    it "should raise an error if the file path has ../ in it" do
-      expect{
-        @data_store.destroy('jelly_beans/../are/good')
-      }.to raise_error(Dragonfly::DataStorage::BadUID)
-    end
-  end
-
-  describe "relative paths" do
-    let(:store) { Dragonfly::DataStorage::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
-      @temp_object.meta = {:bitrate => '35', :name => 'danny.boy'}
-    end
-
-    it "should not write a meta file" do
-      uid = @data_store.store(@temp_object)
-      path = File.join(@data_store.root_path, uid) + '.meta'
-      File.exist?(path).should be_false
-    end
-
-    it "should return an empty hash on retrieve" do
-      uid = @data_store.store(@temp_object)
-      obj, meta = @data_store.retrieve(uid)
-      meta.should == {}
-    end
-    
-    it "should still destroy the meta file if it exists" do
-      @data_store.store_meta = true
-      uid = @data_store.store(@temp_object)
-      @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.store(@temp_object)
-      @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::Configurable::NotConfigured)
-    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 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::DataStorage::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::DataStorage::FileDataStore::UnableToFormUrl)
-    end
-  end
-
-end