bulldog 0.0.1

data/spec/helpers/temporary_values.rb

@@ -0,0 +1,102 @@
+module TemporaryValues
+  def self.included(mod)
+    mod.extend ClassMethods
+  end
+
+  #
+  # Use +value+ for the value of the constant +mod::name+ for the
+  # duration of the block.
+  #
+  def with_temporary_constant_value(mod, name, value)
+    save_and_set_constant(mod, name, value)
+    yield
+  ensure
+    restore_constant(mod, name)
+  end
+
+  #
+  # Use +value+ for the value of the +name+ attribute of the given
+  # +object+ for the duration of the block.
+  #
+  def with_temporary_attribute_value(object, name, value)
+    save_and_set_attribute(object, name, value)
+    yield
+  ensure
+    restore_attribute(object, name)
+  end
+
+  module ClassMethods
+    #
+    # Use +value+ for the value of the constant +mod::name+ for the
+    # duration of each example in this example group.
+    #
+    # If the value should be recalculated for each example, pass a
+    # block instead of a value argument.
+    #
+    def use_temporary_constant_value(mod, name, value=nil, &block)
+      before do
+        value = block ? instance_eval(&block) : value
+        save_and_set_constant(mod, name, value)
+      end
+      after do
+        restore_constant(mod, name)
+      end
+    end
+
+    #
+    # Use +value+ for the value of the +name+ attribute of the given
+    # +object+ for the duration of each example in this example group.
+    #
+    # If the value should be recalculated for each example, pass a
+    # block instead of a value argument.
+    #
+    def use_temporary_attribute_value(object, name, value=nil, &block)
+      before do
+        value = block ? instance_eval(&block) : value
+        save_and_set_attribute(object, name, value)
+      end
+      after do
+        restore_attribute(object, name)
+      end
+    end
+  end
+
+  private  # ---------------------------------------------------------
+
+  UNDEFINED = Object.new
+
+  def original_attribute_values
+    @original_attribute_values ||= Hash.new{|h,k| h[k] = Hash.new{|h2,k2| h2[k2] = {}}}
+  end
+
+  def save_and_set_attribute(object, name, value)
+    original_attribute_values[object.__id__][name] = object.send(name)
+    object.send("#{name}=", value)
+  end
+
+  def restore_attribute(object, name)
+    value = original_attribute_values[object.__id__].delete(name)
+    object.send("#{name}=", value)
+  end
+
+  def original_constant_values
+    @original_constant_values ||= Hash.new{|h,k| h[k] = Hash.new{|h2,k2| h2[k2] = {}}}
+  end
+
+  def save_and_set_constant(mod, name, value)
+    if mod.const_defined?(name)
+      original_constant_values[mod.name][name] = mod.send(:remove_const, name)
+    else
+      original_constant_values[mod.name][name] = UNDEFINED
+    end
+    mod.const_set(name, value)
+  end
+
+  def restore_constant(mod, name)
+    mod.send(:remove_const, name)
+    original_value = original_constant_values[mod.name].delete(name)
+    unless original_value.equal?(UNDEFINED)
+      mod.const_set(name, original_value)
+    end
+  end
+end

data/spec/helpers/test_upload_files.rb

@@ -0,0 +1,108 @@
+module TestUploadFiles
+  def self.included(mod)
+    mod.before{init_test_upload_files}
+    mod.after{close_test_upload_files}
+  end
+
+  def autoclose(file)
+    @files_to_close << file
+    file
+  end
+
+  def small_uploaded_file(path=unused_temp_path, test_file='test.jpg')
+    content = content_for_uploaded_file(test_file)
+    io = ActionController::UploadedStringIO.new(content)
+    io.original_path = path
+    io.content_type = Rack::Mime::MIME_TYPES[File.extname(path)]
+    io
+  end
+
+  def large_uploaded_file(path=unused_temp_path, test_file='test.jpg')
+    content = content_for_uploaded_file(test_file)
+    file = ActionController::UploadedTempfile.new(path)
+    file.write(content)
+    file.rewind
+    file.original_path = path
+    file.content_type = Rack::Mime::MIME_TYPES[File.extname(path)]
+    autoclose(file)
+  end
+
+  def uploaded_file_with_content(basename, content)
+    io = ActionController::UploadedStringIO.new(content)
+    io.original_path = basename
+    io.content_type = Rack::Mime::MIME_TYPES[File.extname(basename)]
+    io
+  end
+
+  def test_file(basename)
+    path = test_path(basename)
+    file = open(path)
+    autoclose(file)
+  end
+
+  def test_path(basename)
+    "#{ROOT}/spec/data/#{basename}"
+  end
+
+  # For when it doesn't matter if it's small or large.
+  alias uploaded_file small_uploaded_file
+
+  def test_image_file(basename='test.jpg')
+    path = test_image_path(basename)
+    file = open(path)
+    autoclose(file)
+  end
+
+  def test_image_path(basename='test.jpg')
+    test_path(basename)
+  end
+
+  def test_video_file(basename='test.mov')
+    path = test_video_path(basename)
+    file = open(path)
+    autoclose(file)
+  end
+
+  def test_video_path(basename='test.mov')
+    test_path(basename)
+  end
+
+  def test_pdf_file(basename='test.pdf')
+    path = test_pdf_path(basename)
+    file = open(path)
+    autoclose(file)
+  end
+
+  def test_pdf_path(basename='test.pdf')
+    test_path(basename)
+  end
+
+  def test_empty_file
+    file = open(test_path('empty.txt'))
+    autoclose(file)
+  end
+
+  private  # ---------------------------------------------------------
+
+  def init_test_upload_files
+    @files_to_close = []
+  end
+
+  def close_test_upload_files
+    @files_to_close.each(&:close)
+  end
+
+  def content_for_uploaded_file(test_file)
+    path = test_path("test#{File.extname(test_file)}")
+    File.read(path)
+  end
+
+  def unused_temp_path
+    i = 0
+    path = nil
+    begin
+      path = File.join(temporary_directory, "test-#{i}.jpg")
+    end while File.exist?(path)
+    path
+  end
+end

data/spec/helpers/time_travel.rb

@@ -0,0 +1,20 @@
+module TimeTravel
+  def self.included(mod)
+    mod.before{stop_time}
+  end
+
+  def stop_time
+    warp_to Time.now
+  end
+
+  def warp_to(time)
+    time = Time.parse(time) if time.is_a?(String)
+    Time.stubs(:now).returns(time)
+  end
+
+  def warp_ahead(duration)
+    new_now = Time.now + duration
+    Time.stubs(:now).returns(new_now)
+    new_now
+  end
+end

data/spec/integration/lifecycle_hooks_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+
+describe "Lifecycle hooks" do
+  use_model_class(:Thing,
+                  :attachment_file_name => :string,
+                  :value => :integer)
+
+  before do
+    @file = open("#{ROOT}/spec/integration/data/test.jpg")
+    Bulldog.default_url_template = "/attachments/:class/:id.:style.:extension"
+  end
+
+  after do
+    @file.close
+  end
+
+  it "should run before-validation hooks before validating the record" do
+    checks = []
+    Thing.validates_presence_of :value
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :validation do
+        checks << record.errors.empty?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.valid?.should be_false
+    checks.should == [true]
+  end
+
+  it "should run after-validation hooks after validating the record" do
+    checks = []
+    Thing.validates_presence_of :value
+    Thing.has_attachment :attachment do
+      style :normal
+      process :after => :validation do
+        checks << record.errors.empty?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.valid?.should be_false
+    checks.should == [false]
+  end
+
+  it "should run before-save hooks before saving the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :save do
+        checks << record.new_record?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.save.should be_true
+    checks.should == [true]
+  end
+
+  it "should run after-save hooks after saving the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :after => :save do
+        checks << record.new_record?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.save.should be_true
+    checks.should == [false]
+  end
+
+  it "should run before-create hooks before creating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :create do
+        checks << record.new_record?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.save.should be_true
+    checks.should == [true]
+  end
+
+  it "should run after-create hooks after creating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :after => :create do
+        checks << record.new_record?
+      end
+    end
+    thing = Thing.new(:attachment => @file)
+    checks.should == []
+    thing.save.should be_true
+    checks.should == [false]
+  end
+
+  it "should run before-update hooks before updating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :update do
+        checks << Thing.count(:conditions => {:value => 2})
+      end
+    end
+    Thing.create(:attachment => @file, :value => 1)
+    thing = Thing.first
+    checks.should == []
+    thing.update_attributes(:value => 2).should be_true
+    checks.should == [0]
+  end
+
+  it "should run after-update hooks after updating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :after => :update do
+        checks << Thing.count(:conditions => {:value => 2})
+      end
+    end
+    Thing.create(:attachment => @file, :value => 1)
+    thing = Thing.first
+    checks.should == []
+    thing.update_attributes(:value => 2).should be_true
+    checks.should == [1]
+  end
+
+  it "should not run create hooks when updating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :update do
+        checks << [:fail]
+      end
+
+      process :after => :update do |thing|
+        checks << [:fail]
+      end
+    end
+    Thing.create(:attachment => @file)
+    checks.should == []
+  end
+
+  it "should not run update hooks when creating the record" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process :before => :create do
+        checks << [:fail]
+      end
+
+      process :after => :create do
+        checks << [:fail]
+      end
+    end
+    thing = Thing.create(:attachment => @file, :value => 1)
+    checks = []
+    thing.update_attributes(:value => 2)
+    checks.should == []
+  end
+
+  it "should run callbacks for the given attachment types if given" do
+    runs = 0
+    Thing.has_attachment :attachment do
+      style :normal
+      process(:types => :image, :on => :test_event){runs += 1}
+    end
+    thing = Thing.new(:attachment => @file)
+    thing.process_attachment(:attachment, :test_event)
+    runs.should == 1
+  end
+
+  it "should not run callbacks if the attachment is of the wrong type" do
+    runs = 0
+    Thing.has_attachment :attachment do
+      style :normal
+      process(:types => :video, :on => :test_event){runs += 1}
+    end
+    thing = Thing.new(:attachment => @file)
+    thing.process_attachment(:attachment, :test_event)
+    runs.should == 0
+  end
+
+  it "should allow specifying more than one type" do
+    runs = 0
+    Thing.has_attachment :attachment do
+      style :normal
+      process(:types => [:image, :video], :on => :test_event){runs += 1}
+    end
+    thing = Thing.new(:attachment => @file)
+    thing.process_attachment(:attachment, :test_event)
+    thing.attachment = uploaded_file_with_content('test.avi', "RIFF    AVI ")
+    thing.process_attachment(:attachment, :test_event)
+    runs.should == 2
+  end
+
+  it "should run multiple callbacks if given" do
+    checks = []
+    Thing.has_attachment :attachment do
+      style :normal
+      process(:on => :test_event){checks << 1}
+      process(:on => :test_event){checks << 2}
+    end
+    thing = Thing.new(:attachment => @file)
+    thing.process_attachment(:attachment, :test_event)
+    checks.should == [1, 2]
+  end
+end

data/spec/integration/processing_image_attachments.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "Processing image attachments" do
+  use_model_class(:Thing,
+                  :width => :integer,
+                  :height => :integer)
+
+  def identify
+    Bulldog::Processor::ImageMagick.identify_command
+  end
+
+  before do
+    tmp = temporary_directory
+    Thing.has_attachment :photo do
+      path "#{tmp}/:id.:style.png"
+      style :small, {:size => '10x10!'}
+      style :large, {:size => '1000x1000!'}
+
+      process :before => :save do
+        width, height = dimensions
+        record.width = width
+        record.height = height
+      end
+
+      process :on => :resize do
+        resize
+      end
+    end
+    @thing = Thing.new
+    @thing.stubs(:id).returns(5)
+    @file = small_uploaded_file(:size => "40x30")
+  end
+
+  def small_uploaded_file(options={})
+    tmp_path = "#{temporary_directory}/small_uploaded_file.tmp.png"
+    create_image(tmp_path, options)
+    content = File.read(tmp_path)
+    File.unlink(tmp_path)
+
+    io = ActionController::UploadedStringIO.new(content)
+    io.original_path = "tmp.png"
+    io.content_type = 'image/png'
+    io
+  end
+
+  after do
+    @file.close
+  end
+
+  def path(style)
+    "#{temporary_directory}/5.#{style}.png"
+  end
+
+  it "should run the after_save process after saving" do
+    @thing.update_attributes(:photo => @file)
+    @thing.width.should == 40
+    @thing.height.should == 30
+  end
+
+  it "should process the attachment when the processor is run" do
+    File.exist?(path(:original)).should be_false
+    File.exist?(path(:small)).should be_false
+    File.exist?(path(:large)).should be_false
+
+    @thing.update_attributes(:photo => @file).should be_true
+    @thing.process_attachment(:photo, :resize)
+
+    `"#{identify}" -format "%w %h" "#{path(:original)}"`.chomp.should == '40 30'
+    `"#{identify}" -format "%w %h" "#{path(:small)}"`.chomp.should == '10 10'
+    `"#{identify}" -format "%w %h" "#{path(:large)}"`.chomp.should == '1000 1000'
+  end
+end