oahu-dragonfly 0.8.2

data/spec/dragonfly/simple_cache_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Dragonfly::SimpleCache do
+  
+  before(:each) do
+    @cache = Dragonfly::SimpleCache.new(2)
+  end
+  
+  it "should act as a normal hash" do
+    @cache[:egg] = 'four'
+    @cache[:egg].should == 'four'
+  end
+  
+  it "should allow filling up to the limit" do
+    @cache[:a] = 1
+    @cache[:b] = 2
+    @cache.should == {:a => 1, :b => 2}
+  end
+  
+  it "should get rid of the first added when full" do
+    @cache[:a] = 1
+    @cache[:b] = 2
+    @cache[:c] = 3
+    @cache.should == {:b => 2, :c => 3}
+  end
+  
+end

data/spec/dragonfly/temp_object_spec.rb

@@ -0,0 +1,306 @@
+require 'spec_helper'
+
+describe Dragonfly::TempObject do
+
+  ####### Helper Methods #######
+
+  def sample_path(filename)
+    File.join(SAMPLES_DIR, filename)
+  end
+
+  def new_tempfile(data='HELLO')
+    tempfile = Tempfile.new('test')
+    tempfile.write(data)
+    tempfile.rewind
+    tempfile
+  end
+
+  def new_file(data='HELLO', path="/tmp/test_file")
+    File.open(path, 'w') do |f|
+      f.write(data)
+    end
+    File.new(path)
+  end
+
+  def new_pathname(data='HELLO', path="/tmp/test_file")
+    File.open(path, 'w') do |f|
+      f.write(data)
+    end
+    Pathname.new(path)
+  end
+
+  def new_temp_object(data, klass=Dragonfly::TempObject)
+    klass.new(initialization_object(data))
+  end
+
+  def initialization_object(data)
+    raise NotImplementedError, "This should be implemented in the describe block!"
+  end
+
+  def get_parts(temp_object)
+    parts = []
+    temp_object.each do |bytes|
+      parts << bytes
+    end
+    parts.length.should >= 2 # Sanity check to check that the sample file is adequate for this test
+    parts
+  end
+
+  ###############################
+
+  it "should raise an error if initialized with a non-string/file/tempfile" do
+    lambda{
+      Dragonfly::TempObject.new(3)
+    }.should raise_error(ArgumentError)
+  end
+
+  shared_examples_for "common behaviour" do
+
+    describe "simple initialization" do
+
+      before(:each) do
+        @temp_object = new_temp_object('HELLO')
+      end
+
+      describe "data" do
+        it "should return the data correctly" do
+          @temp_object.data.should == 'HELLO'
+        end
+      end
+
+      describe "file" do
+        it "should return a readable file" do
+          @temp_object.file.should be_a(File)
+        end
+        it "should contain the correct data" do
+          @temp_object.file.read.should == 'HELLO'
+        end
+        it "should yield a file then close it if a block is given" do
+          @temp_object.file do |f|
+            f.read.should == 'HELLO'
+            f.should_receive :close
+          end
+        end
+        it "should return whatever is returned from the block if a block is given" do
+          @temp_object.file do |f|
+            'doogie'
+          end.should == 'doogie'
+        end
+        it "should enable reading the file twice" do
+          @temp_object.file{|f| f.read }.should == "HELLO"
+          @temp_object.file{|f| f.read }.should == "HELLO"
+        end
+      end
+
+      describe "tempfile" do
+        it "should create a closed tempfile" do
+          @temp_object.tempfile.should be_a(Tempfile)
+          @temp_object.tempfile.should be_closed
+        end
+        it "should contain the correct data" do
+          @temp_object.tempfile.open.read.should == 'HELLO'
+        end
+      end
+
+      describe "path" do
+        it "should return an absolute file path" do
+          @temp_object.path.should =~ %r{^/\w+}
+        end
+      end
+
+      describe "size" do
+        it "should return the size in bytes" do
+          @temp_object.size.should == 5
+        end
+      end
+
+      describe "to_file" do
+        before(:each) do
+          @filename = 'eggnog.txt'
+          FileUtils.rm(@filename) if File.exists?(@filename)
+        end
+        after(:each) do
+          FileUtils.rm(@filename) if File.exists?(@filename)
+        end
+        it "should write to a file" do
+          @temp_object.to_file(@filename)
+          File.exists?(@filename).should be_true
+        end
+        it "should write the correct data to the file" do
+          @temp_object.to_file(@filename)
+          File.read(@filename).should == 'HELLO'
+        end
+        it "should return a readable file" do
+          file = @temp_object.to_file(@filename)
+          file.should be_a(File)
+          file.read.should == 'HELLO'
+        end
+      end
+
+    end
+
+    describe "each" do
+      it "should yield 8192 bytes each time" do
+        temp_object = new_temp_object(File.read(sample_path('round.gif')))
+        parts = get_parts(temp_object)
+        parts[0...-1].each do |part|
+          part.bytesize.should == 8192
+        end
+        parts.last.bytesize.should <= 8192
+      end
+      it "should yield the number of bytes specified in the class configuration" do
+        klass = Class.new(Dragonfly::TempObject)
+        temp_object = new_temp_object(File.read(sample_path('round.gif')), klass)
+        klass.block_size = 3001
+        parts = get_parts(temp_object)
+        parts[0...-1].each do |part|
+          part.length.should == 3001
+        end
+        parts.last.length.should <= 3001
+      end
+    end
+
+  end
+
+  describe "initializing from a string" do
+
+    def initialization_object(data)
+      data
+    end
+
+    it_should_behave_like "common behaviour"
+
+    it "should not create a file when calling each" do
+      temp_object = new_temp_object('HELLO')
+      temp_object.should_not_receive(:tempfile)
+      temp_object.each{}
+    end
+  end
+
+  describe "initializing from a tempfile" do
+
+    def initialization_object(data)
+      new_tempfile(data)
+    end
+
+    it_should_behave_like "common behaviour"
+
+    it "should not create a data string when calling each" do
+      temp_object = new_temp_object('HELLO')
+      temp_object.should_not_receive(:data)
+      temp_object.each{}
+    end
+
+    it "should return the tempfile's path" do
+      temp_object = new_temp_object('HELLO')
+      temp_object.path.should == temp_object.tempfile.path
+    end
+  end
+
+  describe "initializing from a file" do
+
+    def initialization_object(data)
+      new_file(data)
+    end
+
+    it_should_behave_like "common behaviour"
+
+    it "should not create a data string when calling each" do
+      temp_object = new_temp_object('HELLO')
+      temp_object.should_not_receive(:data)
+      temp_object.each{}
+    end
+
+    it "should return the file's path" do
+      file = new_file('HELLO')
+      temp_object = Dragonfly::TempObject.new(file)
+      temp_object.path.should == file.path
+    end
+    
+    it "should return an absolute path even if the file wasn't instantiated like that" do
+      file = new_file('HELLO', 'testfile')
+      temp_object = Dragonfly::TempObject.new(file)
+      temp_object.path.should =~ %r{^/\w.*testfile}
+      file.close
+      FileUtils.rm(file.path)
+    end
+  end
+
+  describe "initializing from a pathname" do
+
+    def initialization_object(data)
+      new_pathname(data)
+    end
+
+    it_should_behave_like "common behaviour"
+
+    it "should not create a data string when calling each" do
+      temp_object = new_temp_object('HELLO')
+      temp_object.should_not_receive(:data)
+      temp_object.each{}
+    end
+
+    it "should return the file's path" do
+      pathname = new_pathname('HELLO')
+      temp_object = Dragonfly::TempObject.new(pathname)
+      temp_object.path.should == pathname.to_s
+    end
+    
+    it "should return an absolute path even if the pathname is relative" do
+      pathname = new_pathname('HELLO', 'testfile')
+      temp_object = Dragonfly::TempObject.new(pathname)
+      temp_object.path.should =~ %r{^/\w.*testfile}
+      pathname.delete
+    end
+  end
+
+  describe "initializing from another temp object" do
+    
+    def initialization_object(data)
+      Dragonfly::TempObject.new(data)
+    end
+    
+    before(:each) do
+      @temp_object1 = Dragonfly::TempObject.new(new_tempfile('hello'))
+      @temp_object2 = Dragonfly::TempObject.new(@temp_object1)
+    end
+    
+    it_should_behave_like "common behaviour"
+    
+    it "should not be the same object" do
+      @temp_object1.should_not == @temp_object2
+    end
+    it "should have the same data" do
+      @temp_object1.data.should == @temp_object2.data
+    end
+    it "should have the same file path" do
+      @temp_object1.path.should == @temp_object2.path
+    end
+  end
+
+  describe "original_filename" do
+    before(:each) do
+      @obj = new_tempfile
+    end
+    it "should set the original_filename if the initial object responds to 'original filename'" do
+      def @obj.original_filename
+        'jimmy.page'
+      end
+      Dragonfly::TempObject.new(@obj).original_filename.should == 'jimmy.page'
+    end
+    it "should not set the name if the initial object doesn't respond to 'original filename'" do
+      Dragonfly::TempObject.new(@obj).original_filename.should be_nil
+    end
+    it "should set the name if the initial object is a file object" do
+      file = File.new(SAMPLES_DIR + '/round.gif')
+      temp_object = Dragonfly::TempObject.new(file)
+      temp_object.original_filename.should == 'round.gif'
+    end
+    it "should set the name if the initial object is a pathname" do
+      pathname = Pathname.new(SAMPLES_DIR + '/round.gif')
+      temp_object = Dragonfly::TempObject.new(pathname)
+      temp_object.original_filename.should == 'round.gif'
+    end
+  end
+
+end

data/spec/dragonfly/url_mapper_spec.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Dragonfly::UrlMapper do
+
+  describe "validating the url format" do
+    it "should be ok with a valid one" do
+      Dragonfly::UrlMapper.new('/media/:job/:name')
+    end
+    it "should throw an error if params aren't separated" do
+      lambda{
+        Dragonfly::UrlMapper.new('/media/:job:name')
+      }.should raise_error(Dragonfly::UrlMapper::BadUrlFormat)
+    end
+  end
+
+  describe "params_in_url" do
+    it "should return everything specified in the url" do
+      url_mapper = Dragonfly::UrlMapper.new('/media/:job/:basename.:ext')
+      url_mapper.params_in_url.should == ['job', 'basename', 'ext']
+    end
+  end
+  
+  describe "url_regexp" do
+    it "should return a regexp with non-greedy optional groups that include the preceding slash/dot/dash" do
+      url_mapper = Dragonfly::UrlMapper.new('/media/:job/:basename-:size.:format')
+      url_mapper.url_regexp.should == %r{^/media(/[^\/\-\.]+?)?(/[^\/\-\.]+?)?(\-[^\/\-\.]+?)?(\.[^\/\-\.]+?)?$}
+    end
+    
+    it "should allow setting custom patterns in the url" do
+      url_mapper = Dragonfly::UrlMapper.new('/media/:job-:size.:format',
+        :job => '\w',
+        :size => '\d',
+        :format => '[^\.]'
+      )
+      url_mapper.url_regexp.should == %r{^/media(/\w+?)?(\-\d+?)?(\.[^\.]+?)?$}
+    end
+    
+    it "should make optional match patterns (ending in ?) apply to the whole group including the preceding seperator" do
+      url_mapper = Dragonfly::UrlMapper.new('/media/:job', :job => '\w')
+      url_mapper.url_regexp.should == %r{^/media(/\w+?)?$}
+    end
+  end
+
+  describe "url_for" do
+    before(:each) do
+      @url_mapper = Dragonfly::UrlMapper.new('/media/:job-:size',
+        :job => '\w',
+        :size => '\w'
+      )
+    end
+    
+    it "should map correctly" do
+      @url_mapper.url_for('job' => 'asdf', 'size' => '30x30').should == '/media/asdf-30x30'
+    end
+    
+    it "should add extra params as query parameters" do
+      @url_mapper.url_for('job' => 'asdf', 'size' => '30x30', 'when' => 'now').should == '/media/asdf-30x30?when=now'
+    end
+    
+    it "should not worry if params aren't given" do
+      @url_mapper.url_for('job' => 'asdf', 'when' => 'now', 'then' => 'soon').should == '/media/asdf?when=now&then=soon'
+    end
+  end
+
+  describe "params_for" do
+    before(:each) do
+      @url_mapper = Dragonfly::UrlMapper.new('/media/:job')
+    end
+    
+    it "should map correctly" do
+      @url_mapper.params_for('/media/asdf').should == {'job' => 'asdf'}
+    end
+    
+    it "should include query parameters" do
+      @url_mapper.params_for('/media/asdf', 'when=now').should == {'job' => 'asdf', 'when' => 'now'}
+    end
+    
+    it "should generally be ok with wierd characters" do
+      @url_mapper = Dragonfly::UrlMapper.new('/media/:doobie')
+      @url_mapper.params_for('/media/sd sdf jl£@$ sdf:_', 'job=goodun').should == {'job' => 'goodun', 'doobie' => 'sd sdf jl£@$ sdf:_'}
+    end
+  end
+
+  describe "matching urls with standard format /media/:job/:basename.:format" do
+    before(:each) do
+      @url_mapper = Dragonfly::UrlMapper.new('/media/:job/:basename.:format',
+        :job => '\w',
+        :basename => '[^\/]',
+        :format => '[^\.]'
+      )
+    end
+
+    {
+      '' => nil,
+      '/' => nil,
+      '/media' => {'job' => nil, 'basename' => nil, 'format' => nil},
+      '/media/' => nil,
+      '/moodia/asdf' => nil,
+      '/media/asdf/' => nil,
+      '/mount/media/asdf' => nil,
+      '/media/asdf/stuff.egg' => {'job' => 'asdf', 'basename' => 'stuff', 'format' => 'egg'},
+      '/media/asdf' =>           {'job' => 'asdf', 'basename' => nil,     'format' => nil},
+      '/media/asdf/stuff' =>     {'job' => 'asdf', 'basename' => 'stuff', 'format' => nil},
+      '/media/asdf.egg' =>       {'job' => 'asdf', 'basename' => nil,     'format' => 'egg'},
+      '/media/asdf/stuff/egg' => nil,
+      '/media/asdf/stuff.dog.egg' => {'job' => 'asdf', 'basename' => 'stuff.dog', 'format' => 'egg'},
+      '/media/asdf/s=2 -.d.e' => {'job' => 'asdf', 'basename' => 's=2 -.d', 'format' => 'e'},
+      '/media/asdf-40x40/stuff.egg' => nil
+    }.each do |path, params|
+      
+      it "should turn the url #{path} into params #{params.inspect}" do
+        @url_mapper.params_for(path).should == params
+      end    
+      
+      if params
+        it "should turn the params #{params.inspect} into url #{path}" do
+          @url_mapper.url_for(params).should == path
+        end
+      end
+      
+    end
+
+  end
+  
+end