paperclip 2.4.5 → 2.5.0

data/features/rake_tasks.feature

@@ -0,0 +1,63 @@
+Feature: Rake tasks
+
+  Background:
+    Given I generate a new rails application
+    And I run a rails generator to generate a "User" scaffold with "name:string"
+    And I run a paperclip generator to add a paperclip "attachment" to the "User" model
+    And I run a migration
+    And I add the paperclip rake task to a Rails 2.3 application
+    And I add this snippet to the User model:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename"
+      """
+
+  Scenario: Paperclip refresh thumbnails task
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "200x200#" }
+      """
+    And I upload the fixture "5k.png"
+    Then the attachment "medium/5k.png" should have a dimension of 200x200
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "100x100#" }
+      """
+    When I successfully run `bundle exec rake paperclip:refresh:thumbnails CLASS=User --trace`
+    Then the attachment "original/5k.png" should exist
+    And the attachment "medium/5k.png" should have a dimension of 100x100
+
+  Scenario: Paperclip refresh metadata task
+    When I upload the fixture "5k.png"
+    And I swap the attachment "original/5k.png" with the fixture "12k.png"
+    And I successfully run `bundle exec rake paperclip:refresh:metadata CLASS=User --trace`
+    Then the attachment should have the same content type as the fixture "12k.png"
+    And the attachment should have the same file size as the fixture "12k.png"
+
+  Scenario: Paperclip refresh missing styles task
+    When I upload the fixture "5k.png"
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "medium/5k.png" should not exist
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename",
+                                     :styles => { :medium => "200x200#" }
+      """
+    When I successfully run `bundle exec rake paperclip:refresh:missing_styles --trace`
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "medium/5k.png" should exist
+
+  Scenario: Paperclip clean task
+    When I upload the fixture "5k.png"
+    And I upload the fixture "12k.png"
+    Then the attachment file "original/5k.png" should exist
+    And the attachment file "original/12k.png" should exist
+    When I modify my attachment definition to:
+      """
+      has_attached_file :attachment, :path => ":rails_root/public/system/:attachment/:style/:filename"
+      validates_attachment_size :attachment, :less_than => 10.kilobytes
+      """
+    And I successfully run `bundle exec rake paperclip:clean CLASS=User --trace`
+    Then the attachment file "original/5k.png" should exist
+    But the attachment file "original/12k.png" should not exist

data/features/step_definitions/attachment_steps.rb

@@ -0,0 +1,65 @@
+module AttachmentHelpers
+  def fixture_path(filename)
+    File.expand_path("#{PROJECT_ROOT}/test/fixtures/#{filename}")
+  end
+
+  def attachment_path(filename)
+    File.expand_path("public/system/attachments/#{filename}")
+  end
+end
+World(AttachmentHelpers)
+
+When /^I modify my attachment definition to:$/ do |definition|
+  write_file "app/models/user.rb", <<-FILE
+    class User < ActiveRecord::Base
+      #{definition}
+    end
+  FILE
+  in_current_dir { FileUtils.rm_rf ".rbx" }
+end
+
+When /^I upload the fixture "([^"]*)"$/ do |filename|
+  run_simple %(bundle exec #{runner_command} "User.create!(:attachment => File.open('#{fixture_path(filename)}'))")
+end
+
+Then /^the attachment "([^"]*)" should have a dimension of (\d+x\d+)$/ do |filename, dimension|
+  in_current_dir do
+    geometry = `identify -format "%wx%h" "#{attachment_path(filename)}"`.strip
+    geometry.should == dimension
+  end
+end
+
+Then /^the attachment "([^"]*)" should exist$/ do |filename|
+  in_current_dir do
+    File.exists?(attachment_path(filename)).should be
+  end
+end
+
+When /^I swap the attachment "([^"]*)" with the fixture "([^"]*)"$/ do |attachment_filename, fixture_filename|
+  in_current_dir do
+    require 'fileutils'
+    FileUtils.rm_f attachment_path(attachment_filename)
+    FileUtils.cp fixture_path(fixture_filename), attachment_path(attachment_filename)
+  end
+end
+
+Then /^the attachment should have the same content type as the fixture "([^"]*)"$/ do |filename|
+  in_current_dir do
+    require 'mime/types'
+    attachment_content_type = `bundle exec #{runner_command} "puts User.last.attachment_content_type"`.strip
+    attachment_content_type.should == MIME::Types.type_for(filename).first.content_type
+  end
+end
+
+Then /^the attachment should have the same file size as the fixture "([^"]*)"$/ do |filename|
+  in_current_dir do
+    attachment_file_size = `bundle exec #{runner_command} "puts User.last.attachment_file_size"`.strip
+    attachment_file_size.should == File.size(fixture_path(filename)).to_s
+  end
+end
+
+Then /^the attachment file "([^"]*)" should (not )?exist$/ do |filename, not_exist|
+  in_current_dir do
+    check_file_presence([attachment_path(filename)], !not_exist)
+  end
+end

data/features/step_definitions/html_steps.rb

@@ -0,0 +1,15 @@
+Then %r{I should see an image with a path of "([^"]*)"} do |path|
+  page.should have_css("img[src^='#{path}']")
+end
+
+Then %r{^the file at "([^"]*)" is the same as "([^"]*)"$} do |web_file, path|
+  expected = IO.read(path)
+  actual = if web_file.match %r{^https?://}
+    Net::HTTP.get(URI.parse(web_file))
+  else
+    visit(web_file)
+    page.body
+  end
+  actual.force_encoding("UTF-8") if actual.respond_to?(:force_encoding)
+  actual.should == expected
+end

data/features/step_definitions/rails_steps.rb

@@ -0,0 +1,182 @@
+Given /^I generate a new rails application$/ do
+  steps %{
+    When I run `bundle exec #{new_application_command} #{APP_NAME}`
+    And I cd to "#{APP_NAME}"
+    And I turn off class caching
+    And I write to "Gemfile" with:
+      """
+      source "http://rubygems.org"
+      gem "rails", "#{framework_version}"
+      gem "sqlite3"
+      gem "capybara"
+      gem "gherkin"
+      gem "aws-sdk"
+      """
+    And I configure the application to use "paperclip" from this project
+    And I reset Bundler environment variable
+    And I successfully run `bundle install --local`
+  }
+end
+
+Given /^I run a rails generator to generate a "([^"]*)" scaffold with "([^"]*)"$/ do |model_name, attributes|
+  step %[I successfully run `bundle exec #{generator_command} scaffold #{model_name} #{attributes}`]
+end
+
+Given /^I run a paperclip generator to add a paperclip "([^"]*)" to the "([^"]*)" model$/ do |attachment_name, model_name|
+  step %[I successfully run `bundle exec #{generator_command} paperclip #{model_name} #{attachment_name}`]
+end
+
+Given /^I run a migration$/ do
+  step %[I successfully run `bundle exec rake db:migrate`]
+end
+
+Given /^I update my new user view to include the file upload field$/ do
+  if framework_version?("3")
+    steps %{
+      Given I overwrite "app/views/users/new.html.erb" with:
+        """
+        <%= form_for @user, :html => { :multipart => true } do |f| %>
+          <%= f.label :name %>
+          <%= f.text_field :name %>
+          <%= f.label :attachment %>
+          <%= f.file_field :attachment %>
+          <%= submit_tag "Submit" %>
+        <% end %>
+        """
+    }
+  else
+    steps %{
+      Given I overwrite "app/views/users/new.html.erb" with:
+        """
+        <% form_for @user, :html => { :multipart => true } do |f| %>
+          <%= f.label :name %>
+          <%= f.text_field :name %>
+          <%= f.label :attachment %>
+          <%= f.file_field :attachment %>
+          <%= submit_tag "Submit" %>
+        <% end %>
+        """
+    }
+  end
+end
+
+Given /^I update my user view to include the attachment$/ do
+  steps %{
+    Given I overwrite "app/views/users/show.html.erb" with:
+      """
+      <p>Name: <%= @user.name %></p>
+      <p>Attachment: <%= image_tag @user.attachment.url %></p>
+      """
+  }
+end
+
+Given /^I add this snippet to the User model:$/ do |snippet|
+  file_name = "app/models/user.rb"
+  in_current_dir do
+    content = File.read(file_name)
+    File.open(file_name, 'w') { |f| f << content.sub(/end\Z/, "#{snippet}\nend") }
+  end
+end
+
+Given /^I start the rails application$/ do
+  in_current_dir do
+    require "./config/environment"
+    require "capybara/rails"
+  end
+end
+
+Given /^I reload my application$/ do
+  Rails::Application.reload!
+end
+
+When %r{I turn off class caching} do
+  in_current_dir do
+    file = "config/environments/test.rb"
+    config = IO.read(file)
+    config.gsub!(%r{^\s*config.cache_classes.*$},
+                 "config.cache_classes = false")
+    File.open(file, "w"){|f| f.write(config) }
+  end
+end
+
+Given /^I update my application to use Bundler$/ do
+  if framework_version?("2")
+    boot_config_template = File.read('features/support/fixtures/boot_config.txt')
+    preinitializer_template = File.read('features/support/fixtures/preinitializer.txt')
+    gemfile_template = File.read('features/support/fixtures/gemfile.txt')
+    in_current_dir do
+      content = File.read("config/boot.rb").sub(/Rails\.boot!/, boot_config_template)
+      File.open("config/boot.rb", "w") { |file| file.write(content) }
+      File.open("config/preinitializer.rb", "w") { |file| file.write(preinitializer_template) }
+      File.open("Gemfile", "w") { |file| file.write(gemfile_template.sub(/RAILS_VERSION/, framework_version)) }
+    end
+  end
+end
+
+Given /^I add the paperclip rake task to a Rails 2.3 application$/ do
+  if framework_version?("2.3")
+    require 'fileutils'
+    source = File.expand_path('lib/tasks/paperclip.rake')
+    destination = in_current_dir { File.expand_path("lib/tasks") }
+    FileUtils.cp source, destination
+    append_to "Rakefile", "require 'paperclip'"
+  end
+end
+
+Then /^the file at "([^"]*)" should be the same as "([^"]*)"$/ do |web_file, path|
+  expected = IO.read(path)
+  actual = if web_file.match %r{^https?://}
+    Net::HTTP.get(URI.parse(web_file))
+  else
+    visit(web_file)
+    page.source
+  end
+  actual.force_encoding("UTF-8") if actual.respond_to?(:force_encoding)
+  actual.should == expected
+end
+
+When /^I configure the application to use "([^\"]+)" from this project$/ do |name|
+  append_to_gemfile "gem '#{name}', :path => '#{PROJECT_ROOT}'"
+  steps %{And I run `bundle install --local`}
+end
+
+When /^I configure the application to use "([^\"]+)"$/ do |gem_name|
+  append_to_gemfile "gem '#{gem_name}'"
+end
+
+When /^I append gems from Appraisal Gemfile$/ do
+  File.read(ENV['BUNDLE_GEMFILE']).split(/\n/).each do |line|
+    if line =~ /^gem "(?!rails|appraisal)/
+      append_to_gemfile line.strip
+    end
+  end
+end
+
+When /^I comment out the gem "([^"]*)" from the Gemfile$/ do |gemname|
+  comment_out_gem_in_gemfile gemname
+end
+
+module FileHelpers
+  def append_to(path, contents)
+    in_current_dir do
+      File.open(path, "a") do |file|
+        file.puts
+        file.puts contents
+      end
+    end
+  end
+
+  def append_to_gemfile(contents)
+    append_to('Gemfile', contents)
+  end
+
+  def comment_out_gem_in_gemfile(gemname)
+    in_current_dir do
+      gemfile = File.read("Gemfile")
+      gemfile.sub!(/^(\s*)(gem\s*['"]#{gemname})/, "\\1# \\2")
+      File.open("Gemfile", 'w'){ |file| file.write(gemfile) }
+    end
+  end
+end
+
+World(FileHelpers)

data/features/step_definitions/s3_steps.rb

@@ -0,0 +1,14 @@
+When /^I attach the file "([^"]*)" to "([^"]*)" on S3$/ do |file_path, field|
+  definition = User.attachment_definitions[field.downcase.to_sym]
+  path = "https://paperclip.s3.amazonaws.com#{definition[:path]}"
+  path.gsub!(':filename', File.basename(file_path))
+  path.gsub!(/:([^\/\.]+)/) do |match|
+    "([^\/\.]+)"
+  end
+  FakeWeb.register_uri(:put, Regexp.new(path), :body => "OK")
+  step "I attach the file \"#{file_path}\" to \"#{field}\""
+end
+
+Then /^the file at "([^"]*)" should be uploaded to S3$/ do |url|
+  FakeWeb.registered_uri?(:put, url)
+end

data/features/step_definitions/web_steps.rb

@@ -0,0 +1,209 @@
+# TL;DR: YOU SHOULD DELETE THIS FILE
+#
+# This file was generated by Cucumber-Rails and is only here to get you a head start
+# These step definitions are thin wrappers around the Capybara/Webrat API that lets you
+# visit pages, interact with widgets and make assertions about page content.
+#
+# If you use these step definitions as basis for your features you will quickly end up
+# with features that are:
+#
+# * Hard to maintain
+# * Verbose to read
+#
+# A much better approach is to write your own higher level step definitions, following
+# the advice in the following blog posts:
+#
+# * http://benmabey.com/2008/05/19/imperative-vs-declarative-scenarios-in-user-stories.html
+# * http://dannorth.net/2011/01/31/whose-domain-is-it-anyway/
+# * http://elabs.se/blog/15-you-re-cuking-it-wrong
+#
+
+
+require 'uri'
+require 'cgi'
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "paths"))
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "support", "selectors"))
+
+module WithinHelpers
+  def with_scope(locator)
+    locator ? within(*selector_for(locator)) { yield } : yield
+  end
+end
+World(WithinHelpers)
+
+# Single-line step scoper
+When /^(.*) within (.*[^:])$/ do |step, parent|
+  with_scope(parent) { When step }
+end
+
+# Multi-line step scoper
+When /^(.*) within (.*[^:]):$/ do |step, parent, table_or_string|
+  with_scope(parent) { When "#{step}:", table_or_string }
+end
+
+Given /^(?:|I )am on (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )go to (.+)$/ do |page_name|
+  visit path_to(page_name)
+end
+
+When /^(?:|I )press "([^"]*)"$/ do |button|
+  click_button(button)
+end
+
+When /^(?:|I )follow "([^"]*)"$/ do |link|
+  click_link(link)
+end
+
+When /^(?:|I )fill in "([^"]*)" with "([^"]*)"$/ do |field, value|
+  fill_in(field, :with => value)
+end
+
+When /^(?:|I )fill in "([^"]*)" for "([^"]*)"$/ do |value, field|
+  fill_in(field, :with => value)
+end
+
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^(?:|I )fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
+When /^(?:|I )select "([^"]*)" from "([^"]*)"$/ do |value, field|
+  select(value, :from => field)
+end
+
+When /^(?:|I )check "([^"]*)"$/ do |field|
+  check(field)
+end
+
+When /^(?:|I )uncheck "([^"]*)"$/ do |field|
+  uncheck(field)
+end
+
+When /^(?:|I )choose "([^"]*)"$/ do |field|
+  choose(field)
+end
+
+When /^(?:|I )attach the file "([^"]*)" to "([^"]*)"$/ do |path, field|
+  attach_file(field, File.expand_path(path))
+end
+
+Then /^(?:|I )should see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_content(text)
+  else
+    assert page.has_content?(text)
+  end
+end
+
+Then /^(?:|I )should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_xpath('//*', :text => regexp)
+  else
+    assert page.has_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^(?:|I )should not see "([^"]*)"$/ do |text|
+  if page.respond_to? :should
+    page.should have_no_content(text)
+  else
+    assert page.has_no_content?(text)
+  end
+end
+
+Then /^(?:|I )should not see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+
+  if page.respond_to? :should
+    page.should have_no_xpath('//*', :text => regexp)
+  else
+    assert page.has_no_xpath?('//*', :text => regexp)
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    if field.value.respond_to? :should
+      field.value.should =~ /#{value}/
+    else
+      assert_match(/#{value}/, field.value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" field(?: within (.*))? should not contain "([^"]*)"$/ do |field, parent, value|
+  with_scope(parent) do
+    field = find_field(field)
+    if field.value.respond_to? :should_not
+      field.value.should_not =~ /#{value}/
+    else
+      assert_no_match(/#{value}/, field.value)
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_true
+    else
+      assert field_checked
+    end
+  end
+end
+
+Then /^the "([^"]*)" checkbox(?: within (.*))? should not be checked$/ do |label, parent|
+  with_scope(parent) do
+    field_checked = find_field(label)['checked']
+    if field_checked.respond_to? :should
+      field_checked.should be_false
+    else
+      assert !field_checked
+    end
+  end
+end
+ 
+Then /^(?:|I )should be on (.+)$/ do |page_name|
+  current_path = URI.parse(current_url).path
+  if current_path.respond_to? :should
+    current_path.should == path_to(page_name)
+  else
+    assert_equal path_to(page_name), current_path
+  end
+end
+
+Then /^(?:|I )should have the following query string:$/ do |expected_pairs|
+  query = URI.parse(current_url).query
+  actual_params = query ? CGI.parse(query) : {}
+  expected_params = {}
+  expected_pairs.rows_hash.each_pair{|k,v| expected_params[k] = v.split(',')} 
+  
+  if actual_params.respond_to? :should
+    actual_params.should == expected_params
+  else
+    assert_equal expected_params, actual_params
+  end
+end
+
+Then /^show me the page$/ do
+  save_and_open_page
+end