bulldog 0.0.1

data/spec/integration/processing_video_attachments_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe "Processing video attachments" do
+  use_model_class(:Thing,
+                  :video_file_name => :string,
+                  :still_frame_file_name => :string)
+
+  before do
+    spec = self
+    Thing.class_eval do
+      has_attachment :video do
+        style :encoded, :format => 'ogg', :size => '640x360',
+                        :video => 'libtheora 24fps', :audio => 'libvorbis 44100Hz 128kbps',
+                        :pixel_format => 'yuv420p'
+        style :frame,   :format => 'jpg'
+        path "#{spec.temporary_directory}/:id.:style.:extension"
+
+        # TODO: fix problem with :after => save running when the
+        # attachment wasn't changed, and process on after save.
+        process :on => :process, :styles => [:encoded]
+        process :on => :process, :styles => [:frame] do
+          record_frame(:assign_to => :still_frame)
+        end
+      end
+
+      has_attachment :still_frame do
+        style :thumbnail, :format => 'png'
+        path "#{spec.temporary_directory}/:id-still_frame.:style.:extension"
+        process :on => :process
+      end
+    end
+
+    @file = open("#{ROOT}/spec/data/test.mov")
+    @thing = Thing.new(:video => @file)
+  end
+
+  after do
+    @file.close
+  end
+
+  def original_video_path
+    "#{temporary_directory}/#{@thing.id}.original.mov"
+  end
+
+  def encoded_video_path
+    "#{temporary_directory}/#{@thing.id}.encoded.ogg"
+  end
+
+  def original_frame_path
+    "#{temporary_directory}/#{@thing.id}-still_frame.original.jpg"
+  end
+
+  def frame_thumbnail_path
+    "#{temporary_directory}/#{@thing.id}-still_frame.thumbnail.png"
+  end
+
+  it "should not yet have a still frame assigned" do
+    @thing.still_frame.should be_blank
+  end
+
+  describe "when the record is saved" do
+    before do
+      @thing.save
+      @thing.process_attachment(:video, :process)
+      @thing.process_attachment(:still_frame, :process)
+    end
+
+    it "should encode the video" do
+      File.should exist(original_video_path)
+      File.should exist(encoded_video_path)
+    end
+
+    it "should assign to the still frame" do
+      @thing.still_frame.should_not be_blank
+    end
+
+    it "should create the thumbnail" do
+      File.should exist(original_frame_path)
+      File.should exist(frame_thumbnail_path)
+    end
+  end
+end

data/spec/integration/saving_an_attachment_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Saving an attachment" do
+  use_model_class(:Thing, :value => :integer)
+
+  #
+  # The list of files this process has open.
+  #
+  def open_files
+    `lsof -p #{Process.pid} -F n`.split(/\n/).sort
+  end
+
+  it "should not leave any file handles left open" do
+    tmp = temporary_directory
+    Thing.has_attachment :photo do
+      path "#{tmp}/:style.png"
+      style :small, :size => '10x10'
+      process :after => :save do
+        resize
+      end
+    end
+
+    path = create_image("#{temporary_directory}/tmp.jpg")
+    open(path) do |file|
+      @initial_open_files = open_files
+      thing = Thing.new(:photo => file)
+      thing.save.should be_true
+      open_files.should == @initial_open_files
+    end
+  end
+end

data/spec/matchers/file_operations.rb

@@ -0,0 +1,159 @@
+module Matchers
+  #
+  # Matches if the Proc object creates the file at the given path.
+  # The file also must not exist to begin with.
+  #
+  def create_file(path)
+    CreateFile.new(path)
+  end
+
+  #
+  # Matches if the Proc deletes the file at the given path.  The file
+  # also must exist at the start.
+  #
+  def delete_file(path)
+    DeleteFile.new(path)
+  end
+
+  #
+  # Matches if the Proc modifies the file at the given path.  Checks
+  # by examining the mtime of the file.
+  #
+  # In order to avoid false-positives, the mtime of the file is set to
+  # a temporary value during the block.
+  #
+  def modify_file(path)
+    ModifyFile.new(path)
+  end
+
+  class FileOperation
+    def initialize(path)
+      @path = path
+    end
+
+    attr_reader :path
+  end
+
+  class CreateFile < FileOperation
+    def matches?(proc)
+      @file_already_exists = File.exist?(path) and
+        return false
+      proc.call
+      File.exist?(path)
+    end
+
+    def does_not_match?(proc)
+      @file_already_exists = File.exist?(path) and
+        return false
+      proc.call
+      !File.exist?(path)
+    end
+
+    def failure_message_for_should
+      if @file_already_exists
+        "`#{path}' already exists"
+      else
+        "expected block to create `#{path}'"
+      end
+    end
+
+    def failure_message_for_should_not
+      if @file_already_exists
+        "`#{path}' already exists"
+      else
+        "expected block to not create `#{path}'"
+      end
+    end
+  end
+
+  class DeleteFile < FileOperation
+    def matches?(proc)
+      @file_did_not_exist = !File.exist?(path) and
+        return false
+      proc.call
+      !File.exist?(path)
+    end
+
+    def does_not_match?(proc)
+      @file_did_not_exist = !File.exist?(path) and
+        return false
+      proc.call
+      File.exist?(path)
+    end
+
+    def failure_message_for_should
+      if @file_did_not_exist
+        "`#{path}' does not exist"
+      else
+        "expected block to delete `#{path}'"
+      end
+    end
+
+    def failure_message_for_should_not
+      if @file_did_not_exist
+        "`#{path}' does not exist"
+      else
+        "expected block to not delete `#{path}'"
+      end
+    end
+  end
+
+  class ModifyFile < FileOperation
+    def matches?(proc)
+      @file_did_not_exist = !File.exist?(path) and
+        return false
+      modified?(proc)
+    end
+
+    def does_not_match?(proc)
+      @file_did_not_exist = !File.exist?(path) and
+        return false
+      !modified?(proc)
+    end
+
+    def failure_message_for_should
+      if @file_did_not_exist
+        "`#{path}' does not exist"
+      else
+        "expected block to modify `#{path}'"
+      end
+    end
+
+    def failure_message_for_should_not
+      if @file_did_not_exist
+        "`#{path}' does not exist"
+      else
+        "expected block to not modify `#{path}'"
+      end
+    end
+
+    private  # -------------------------------------------------------
+
+    def modified?(proc)
+      temporarily_setting_mtime_to(1.minute.ago) do
+        start_mtime = mtime
+        proc.call
+        end_mtime = mtime
+        start_mtime.to_i != end_mtime.to_i
+      end
+    end
+
+    def temporarily_setting_mtime_to(time)
+      original_time = mtime
+      set_mtime_to(time)
+      yield
+    ensure
+      set_mtime_to(original_time)
+    end
+
+    def mtime
+      File.mtime(path)
+    end
+
+    def set_mtime_to(time)
+      atime = File.atime(path)
+      File.utime(atime, time, path)
+      time
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'ostruct'
+
+require 'spec'
+require 'rspec_outlines'
+require 'mocha'
+require 'tempfile'
+require 'active_record'
+require 'action_controller'
+
+require 'bulldog'
+include Bulldog
+
+ROOT = File.dirname( File.dirname(__FILE__) )
+
+require 'helpers/time_travel'
+require 'helpers/temporary_models'
+require 'helpers/temporary_values'
+require 'helpers/temporary_directory'
+require 'helpers/test_upload_files'
+require 'helpers/image_creation'
+require 'matchers/file_operations'
+
+class Time
+  #
+  # Return a new Time object with subsecond components dropped.
+  #
+  # This is useful for testing Time values that have been roundtripped
+  # through the database, as not all databases store subsecond
+  # precision.
+  #
+  def drop_subseconds
+    self.class.mktime(year, month, day, hour, min, sec)
+  end
+end
+
+module SpecHelper
+  def self.included(mod)
+    mod.use_temporary_attribute_value Bulldog, :default_url_template do
+      ":class/:id.:style"
+    end
+    mod.use_temporary_attribute_value Bulldog, :default_path_template do
+      "#{temporary_directory}/attachments/:class/:id.:style"
+    end
+
+    mod.use_temporary_attribute_value Bulldog, :logger do
+      buffer = StringIO.new
+      logger = Logger.new(buffer)
+      (class << logger; self; end).send(:define_method, :content) do
+        buffer.string
+      end
+      logger
+    end
+  end
+
+  #
+  # Stub out all system calls.  Pretend they were successful.
+  #
+  def stub_system_calls
+    Kernel.stubs(:system).returns(true)
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+  config.include TimeTravel
+  config.include TemporaryModels
+  config.include TemporaryValues
+  config.include TemporaryDirectory
+  config.include TestUploadFiles
+  config.include ImageCreation
+  config.include Matchers
+  config.include SpecHelper
+end
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")

data/spec/unit/attachment/base_spec.rb

@@ -0,0 +1,311 @@
+require 'spec_helper'
+
+describe Attachment::Base do
+  def self.configure_attachment(&block)
+    before do
+      spec = self
+      Thing.has_attachment :photo do
+        instance_exec(spec, &block)
+      end
+      @thing = Thing.new
+    end
+  end
+
+  describe "#path" do
+    use_model_class(:Thing, :photo_file_name => :string)
+
+    configure_attachment do |spec|
+      path "#{spec.temporary_directory}/:style.jpg"
+      style :small, {}
+      style :png, :format => :png
+    end
+
+    def original_path
+      "#{temporary_directory}/original.jpg"
+    end
+
+    def small_path
+      "#{temporary_directory}/small.jpg"
+    end
+
+    def png_path
+      "#{temporary_directory}/png.png"
+    end
+
+    it "should return the path of the given style, interpolated from the path template" do
+      @thing.photo = test_image_file
+      @thing.stubs(:id).returns(5)
+      @thing.photo.path(:original).should == original_path
+      @thing.photo.path(:small).should == small_path
+    end
+
+    describe "when the :extension interpolation key is used" do
+      before do
+        spec = self
+        Thing.attachment_reflections[:photo].configure do
+          path "#{spec.temporary_directory}/:style.:extension"
+        end
+        @thing.photo = test_image_file
+      end
+
+      it "should use the extension of the original file for the original style" do
+        @thing.photo.path(:original).should == "#{temporary_directory}/original.jpg"
+      end
+      it "should use the format of the output file for other styles" do
+        @thing.photo.path(:png).should == "#{temporary_directory}/png.png"
+      end
+    end
+
+    describe "when the :extension interpolation key is not used" do
+      before do
+        spec = self
+        Thing.attachment_reflections[:photo].configure do
+          path "#{spec.temporary_directory}/:style.xyz"
+        end
+        @thing.photo = test_image_file
+      end
+
+      it "should use the extension of the path template for the original style" do
+        @thing.photo.path(:original).should == "#{temporary_directory}/original.xyz"
+      end
+
+      it "should use the extension of the path template for other styles" do
+        @thing.photo.path(:png).should == "#{temporary_directory}/png.xyz"
+      end
+    end
+
+    describe "when no style is given" do
+      configure_attachment do
+        path "/tmp/:style.jpg"
+        style :small, {}
+        default_style :small
+      end
+
+      it "should default to the attachment's default style" do
+        @thing.photo = test_image_file
+        @thing.photo.path.should == "/tmp/small.jpg"
+      end
+    end
+  end
+
+  describe "#url" do
+    use_model_class(:Thing, :photo_file_name => :string)
+
+    configure_attachment do
+      path "/tmp/:style.jpg"
+      url "/assets/:style.jpg"
+      style :small
+      style :png, :format => :png
+    end
+
+    it "should return the url of the given style, interpolated from the url template" do
+      @thing.photo = test_image_file
+      @thing.photo.url(:original).should == "/assets/original.jpg"
+      @thing.photo.url(:small).should == "/assets/small.jpg"
+    end
+
+    describe "when the :extension interpolation key is used" do
+      before do
+        spec = self
+        Thing.attachment_reflections[:photo].configure do
+          path "/tmp/:style.:extension"
+          url "/assets/:style.:extension"
+        end
+        @thing.photo = test_image_file
+      end
+
+      it "should use the extension of the original file for the original style" do
+        @thing.photo.url(:original).should == "/assets/original.jpg"
+      end
+
+      it "should use the format of the output file for the other styles" do
+        @thing.photo.url(:png).should == "/assets/png.png"
+      end
+    end
+
+    describe "when the :extension interpolation key is not used" do
+      before do
+        spec = self
+        Thing.attachment_reflections[:photo].configure do
+          path "/tmp/:style.xyz"
+          url "/assets/:style.xyz"
+        end
+        @thing.photo = test_image_file
+      end
+
+      it "should use the extension of the url template for the original style" do
+        @thing.photo.url(:original).should == "/assets/original.xyz"
+      end
+
+      it "should use the extension of the url template for the other styles" do
+        @thing.photo.url(:png).should == "/assets/png.xyz"
+      end
+    end
+
+    describe "when no style is given" do
+      configure_attachment do
+        url "/assets/:style.jpg"
+        style :small, {}
+        default_style :small
+      end
+
+      it "should default to the attachment's default style" do
+        @thing.photo = test_image_file
+        @thing.photo.url.should == "/assets/small.jpg"
+      end
+    end
+  end
+
+  describe "#file_size" do
+    use_model_class(:Thing)
+
+    configure_attachment do |spec|
+      path "#{spec.temporary_directory}/:id.:style.jpg"
+      style :small, {}
+    end
+
+    def original_path
+      "#{temporary_directory}/#{@thing.id}.original.jpg"
+    end
+
+    def with_temporary_file(path, content)
+      FileUtils.mkdir_p File.dirname(path)
+      open(path, 'w'){|f| f.print '...'}
+      begin
+        yield path
+      ensure
+        File.delete(path)
+      end
+    end
+
+    before do
+      @thing = Thing.new(:photo => test_image_file)
+    end
+
+    it "should return the size of the file" do
+      @thing.photo.file_size.should == File.size(test_image_path)
+    end
+  end
+
+  describe "#file_name" do
+    use_model_class(:Thing, :photo_file_name => :string)
+
+    configure_attachment do |spec|
+      path "#{spec.temporary_directory}/:id.:style.jpg"
+      style :small, {}
+      store_attributes :file_name
+    end
+
+    def original_path
+      "#{temporary_directory}/#{@thing.id}.original.jpg"
+    end
+
+    def with_temporary_file(path, content)
+      FileUtils.mkdir_p File.dirname(path)
+      open(path, 'w'){|f| f.print '...'}
+      begin
+        yield path
+      ensure
+        File.delete(path)
+      end
+    end
+
+    before do
+      @thing = Thing.new(:photo => test_image_file)
+    end
+
+    it "should return the original base name of the file" do
+      @thing.photo.file_name.should == File.basename(test_image_path)
+    end
+  end
+
+  describe "#process" do
+    use_model_class(:Thing)
+
+    use_temporary_constant_value Processor, :Test do
+      Class.new(Processor::Base)
+    end
+
+    it "should use the default processor if no processor was specified" do
+      context = nil
+      Thing.has_attachment :photo do
+        style :normal
+        process :on => :test_event do
+          context = self
+        end
+      end
+      thing = Thing.new(:photo => test_image_file)
+      thing.photo.stubs(:default_processor_type).returns(:test)
+      thing.photo.process(:test_event)
+      context.should be_a(Processor::Test)
+    end
+
+    it "should use the configured processor if one was specified" do
+      context = nil
+      Thing.has_attachment :photo do
+        style :normal
+        process :on => :test_event, :with => :test do
+          context = self
+        end
+      end
+      thing = Thing.new(:photo => test_image_file)
+      thing.photo.process(:test_event)
+      context.should be_a(Processor::Test)
+    end
+
+    it "should not run any processors if no attachment is set" do
+      run = false
+      Thing.has_attachment :photo do
+        style :normal
+        process :on => :test_event, :with => :test do
+          run = true
+        end
+      end
+      thing = Thing.new(:photo => nil)
+      thing.photo.process(:test_event)
+      run.should be_false
+    end
+
+    it "should run the processors only for the specified styles" do
+      styles = nil
+      Thing.has_attachment :photo do
+        style :small, :size => '10x10'
+        style :large, :size => '1000x1000'
+        process :on => :test_event, :styles => [:small], :with => :test do
+          styles = self.styles
+        end
+      end
+      thing = Thing.new(:photo => test_image_file)
+      thing.photo.process(:test_event)
+      styles.should be_a(StyleSet)
+      styles.map(&:name).should == [:small]
+    end
+  end
+
+  describe "storable attributes" do
+    use_model_class(:Thing,
+                    :photo_file_name => :string,
+                    :photo_file_size => :integer,
+                    :photo_content_type => :string)
+
+    before do
+      Thing.has_attachment :photo
+      @thing = Thing.new(:photo => uploaded_file_with_content('test.jpg', "\xff\xd8"))
+    end
+
+    it "should set the stored attributes on assignment" do
+      @thing.photo_file_name.should == 'test.jpg'
+      @thing.photo_file_size.should == 2
+      @thing.photo_content_type.should =~ /image\/jpeg/
+    end
+
+    it "should successfully roundtrip the stored attributes" do
+      warp_ahead 1.minute
+      @thing.save
+      @thing = Thing.find(@thing.id)
+      @thing.photo_file_name.should == 'test.jpg'
+      @thing.photo_file_size.should == 2
+      @thing.photo_content_type.should =~ /image\/jpeg/
+    end
+  end
+end