attachs 0.3.5 → 0.4.0

data/test/generator_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+require 'rails/generators'
+require 'generators/attachs/install_generator'
+
+class GeneratorsTest < Rails::Generators::TestCase
+  tests Attachs::InstallGenerator
+  destination File.expand_path('../tmp', File.dirname(__FILE__))
+
+  teardown do
+    FileUtils.rm_rf self.destination_root
+  end
+
+  test 'initializer generator' do
+    run_generator
+    assert_file 'config/initializers/attachs.rb'
+  end
+
+end

data/test/local_storage_test.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class LocalStorageTest < ActiveSupport::TestCase
+
+  test 'file url' do
+    medium = Medium.create(local_attach: file_upload)
+    assert_equal file_url, medium.local_attach.url
+  end
+
+  test 'image url' do
+    medium = Medium.create(local_attach: image_upload)
+    assert_equal image_url, medium.local_attach.url
+    assert_equal image_url(:small), medium.local_attach.url(:small)
+  end
+
+  test 'crud' do
+    medium = Medium.create(local_attach: file_upload)
+    assert File.exist?(file_path)
+    medium.update_attributes! local_attach: image_upload
+    assert !File.exist?(file_path)
+    assert File.exist?(image_path)
+    assert File.exist?(image_path(:small))
+    medium.destroy
+    assert !File.exist?(image_path)
+    assert !File.exist?(image_path(:small))
+  end
+
+  test 'detroy attr' do
+    medium = Medium.create(local_attach: file_upload, destroy_attach: true)
+    assert File.exist?(file_path)
+    medium.update_attributes! destroy_local_attach: true
+    assert !File.exist?(file_path)
+  end
+
+  private
+
+  def month
+    Time.zone.now.month
+  end
+
+  def file_url(style=:original)
+    "/storage/text/11/#{style}/#{month}/file.txt"
+  end
+
+  def image_url(style=:original)
+    "/storage/image/5461/#{style}/#{month}/180x150.gif"
+  end
+
+  def file_path(style=:original)
+    Rails.root.join("public/storage/text/11/#{style}/#{month}/file.txt")
+  end
+
+  def image_path(style=:original)
+    Rails.root.join("public/storage/image/5461/#{style}/#{month}/180x150.gif")
+  end
+
+end

data/test/magick_tool_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class MagickToolTest < ActiveSupport::TestCase
+
+  teardown do
+    Dir[Rails.root.join('tmp', '*')].each do |file|
+      File.delete file
+    end
+  end
+
+  test 'force resize' do
+    Attachs::Tools::Magick.resize(source, :big_force, resized)
+    assert_equal [160,130], Attachs::Tools::Magick.dimensions(resized)
+    Attachs::Tools::Magick.resize(resized, :small_force)
+    assert_equal [140,110], Attachs::Tools::Magick.dimensions(resized)
+  end
+
+  test 'cover resize' do
+    Attachs::Tools::Magick.resize(source, :big_cover, resized)
+    assert_equal [160, 130], Attachs::Tools::Magick.dimensions(resized)
+    Attachs::Tools::Magick.resize(resized, :small_cover)
+    assert_equal [140,110], Attachs::Tools::Magick.dimensions(resized)
+  end
+
+  test 'contain resize' do
+    Attachs::Tools::Magick.resize(source, :big_contain, resized)
+    assert_equal [156, 130], Attachs::Tools::Magick.dimensions(resized)
+    Attachs::Tools::Magick.resize(resized, :small_contain)
+    assert_equal [132,110], Attachs::Tools::Magick.dimensions(resized)
+  end
+
+  private
+
+  def source
+    image_upload.path
+  end
+
+  def resized
+    Rails.root.join('public', 'resized.gif')
+  end
+
+end

data/test/migration_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+class MigrationTest < ActiveSupport::TestCase
+
+  setup do
+    ActiveRecord::Migration.verbose = false
+  end
+
+  test 'table migration' do
+    table_migration.migrate(:up)
+    assert_includes columns, ['image_filename', :string]
+    assert_includes columns, ['image_size', :integer]
+    assert_includes columns, ['image_content_type', :string]
+    assert_includes columns, ['image_updated_at', :datetime]
+
+    assert_nothing_raised do
+      table_migration.migrate(:down)
+    end
+  end
+
+  test 'column migration' do
+    ActiveRecord::Base.connection.create_table :pictures
+
+    column_migration.migrate(:up)
+    assert_includes columns, ['image_filename', :string]
+    assert_includes columns, ['image_size', :integer]
+    assert_includes columns, ['image_content_type', :string]
+    assert_includes columns, ['image_updated_at', :datetime]
+
+    column_migration.migrate(:down)
+    refute_includes columns, ['image_filename', :string]
+    refute_includes columns, ['image_size', :integer]
+    refute_includes columns, ['image_content_type', :string]
+    refute_includes columns, ['image_updated_at', :datetime]
+  end
+
+  private
+
+  def columns
+    Picture.reset_column_information
+    Picture.columns.map { |column| [column.name, column.type] }
+  end
+
+  def table_migration
+    Class.new(ActiveRecord::Migration) do
+      def change
+        create_table :pictures do |t|
+          t.attachment :image
+        end
+      end
+    end
+  end
+
+  def column_migration
+    Class.new(ActiveRecord::Migration) do
+      def up
+        add_attachment :pictures, :image
+      end
+      def down
+        remove_attachment :pictures, :image
+      end
+    end
+  end
+
+end

data/test/s3_storage_tes.rb

@@ -0,0 +1,56 @@
+require 'test_helper'
+
+class S3StorageTest < ActiveSupport::TestCase
+
+  test 'file url' do
+    medium = Medium.create(s3_attach: file_upload)
+    assert_equal file_url, medium.s3_attach.url
+    assert_equal file_url(ssl: true), medium.s3_attach.url(ssl: true)
+  end
+
+  test 'image url' do
+    medium = Medium.create(s3_attach: image_upload)
+    assert_equal image_url, medium.s3_attach.url
+    assert_equal image_url(ssl: true), medium.s3_attach.url(ssl: true)
+    assert_equal image_url(:small), medium.s3_attach.url(:small)
+    assert_equal image_url(:small, ssl: true), medium.s3_attach.url(:small, ssl: true)
+  end
+
+  test 'storage' do
+    medium = Medium.create(s3_attach: file_upload)
+    assert_url file_url
+    medium.update_attributes! s3_attach: image_upload
+    assert_not_url file_url
+    assert_url image_url
+    assert_url image_url(:small)
+    medium.destroy
+    assert_not_url image_url
+    assert_not_url image_url(:small)
+  end
+
+  test 'detroy attr' do
+    medium = Medium.create(s3_attach: file_upload, destroy_s3_attach: true)
+    assert_url file_url
+    medium.update_attributes! destroy_s3_attach: true
+    assert_not_url file_url
+  end
+
+  private
+
+  def month
+    Time.zone.now.month
+  end
+
+  def file_url(*args)
+    options = args.extract_options!
+    style = (args.first || :original)
+    "http#{'s' if options[:ssl]}://attachs-test.s3.amazonaws.com/storage/text/11/#{style}/#{month}/file.txt"
+  end
+
+  def image_url(*args)
+    options = args.extract_options!
+    style = (args.first || :original)
+    "http#{'s' if options[:ssl]}://attachs-test.s3.amazonaws.com/storage/image/5461/#{style}/#{month}/180x150.gif"
+  end
+
+end

data/test/tasks_test.rb

@@ -0,0 +1,61 @@
+require 'test_helper'
+require 'rake'
+
+class TasksTest < ActiveSupport::TestCase
+
+  setup do
+    Dummy::Application.load_tasks
+  end
+
+  test 'refresh all styles' do
+    Medium.create(attach: image_upload)
+    original_small_time = small_time
+    original_big_time = big_time
+    ENV['CLASS'] = 'medium'
+    ENV['ATTACHMENT'] = 'attach'
+    sleep 1
+    Rake::Task['attachs:refresh:all'].invoke
+    assert File.file?(image_path(:small))
+    assert File.file?(image_path(:big))
+    assert_not_equal original_small_time, small_time
+    assert_not_equal original_big_time, big_time
+  end
+
+  test 'refersh missing styles' do
+    Medium.create(attach: image_upload)
+    original_big_time = big_time
+    original_small_time = small_time
+    File.delete image_path(:small)
+    ENV['CLASS'] = 'medium'
+    ENV['ATTACHMENT'] = 'attach'
+    sleep 1
+    Rake::Task['attachs:refresh:missing'].invoke
+    assert File.file?(image_path(:small))
+    assert File.file?(image_path(:big))
+    assert_not_equal original_small_time, small_time
+    assert_equal original_big_time, big_time
+  end
+
+  private
+
+  def image_path(style=:original)
+    Rails.root.join("public/#{style}/180x150.gif")
+  end
+
+  def small_path
+    image_path(:small)
+  end
+
+  def big_path
+    image_path(:big)
+  end
+
+  def small_time
+    File.mtime(small_path)
+  end
+
+  def big_time
+    File.mtime(big_path)
+  end
+
+end

data/test/test_helper.rb

@@ -22,28 +22,28 @@ load(File.expand_path('../dummy/db/schema.rb', __FILE__))
 
 # Addons
 class ActiveSupport::TestCase
-  include ActionDispatch::TestProcess
-
-  def load_s3
-    require 'aws-sdk' unless defined?(AWS)
-    @storage_type = Rails.application.config.attachs.storage
-    Rails.application.config.attachs.storage = :s3
-    Attachs::Storages::S3.config = YAML.load_file(Rails.root.join('config', 's3.yml')) if Attachs::Storages::S3.config.blank?
-    self.class.teardown { Rails.application.config.attachs.storage = @storage_type }
+  include ActionView::Helpers::NumberHelper
+
+  private
+
+  def fixture_file_upload(path, content_type)
+    Rack::Test::UploadedFile.new(Rails.root.join("test/fixtures/#{path}"), content_type)
   end
 
-  def fixture_file_upload_s3(fixture, type, path, default=false)
-    upload = fixture_file_upload(fixture, type)
-    storage = Attachs::Storages::S3.new(default, false)
-    storage.store upload, path
+  def file_upload
+    fixture_file_upload('file.txt', 'text/plain')
   end
 
-  def assert_object_s3(url)
-    assert_equal '200', Net::HTTP.get_response(url).code
+  def image_upload
+    fixture_file_upload('180x150.gif', 'image/gif')
   end
 
-  def assert_not_object_s3(url)
-    assert_equal '403', Net::HTTP.get_response(url).code
+  def assert_url(url)
+    assert_equal '200', Net::HTTP.get_response(URI(url)).code
   end
-end
 
+  def assert_not_url(url)
+    assert_equal '403', Net::HTTP.get_response(URI(url)).code
+  end
+
+end

data/test/validators_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+class ValidatorsTest < ActiveSupport::TestCase
+  include ActionView::Helpers::NumberHelper
+
+  test 'presence validator' do
+    model = build_model
+    model.validates_attachment_presence_of :attach
+    record = model.new
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_presence')
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: image_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  test 'content type regex validator' do
+    model = build_model
+    model.validates_attachment_content_type_of :attach, with: /\Aimage/
+    record = model.new(attach: file_upload)
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_content_type_with')
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: image_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  test 'content type inclusion validator' do
+    model = build_model
+    model.validates_attachment_content_type_of :attach, in: %w(image/gif)
+    record = model.new(attach: file_upload)
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_content_type_in', types: %w(image/gif).to_sentence)
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: image_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  test 'size range validator' do
+    model = build_model
+    model.validates_attachment_size_of :attach, in: 1..20.bytes
+    record = model.new(attach: image_upload)
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_size_in', min: number_to_human_size(1.byte), max: number_to_human_size(20.bytes))
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: file_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  test 'size minimum validator' do
+    model = build_model
+    model.validates_attachment_size_of :attach, less_than: 20.bytes
+    record = model.new(attach: image_upload)
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_size_less_than', count: number_to_human_size(20.bytes))
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: file_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  test 'size maximum validator' do
+    model = build_model
+    model.validates_attachment_size_of :attach, greater_than: 20.bytes
+    record = model.new(attach: file_upload)
+    assert !record.valid?
+    message = I18n.t('errors.messages.attachment_size_greater_than', count: number_to_human_size(20.bytes))
+    assert record.errors[:attach].include?(message)
+
+    record = model.new(attach: image_upload)
+    assert record.valid?
+    assert record.errors[:attach].empty?
+    record.destroy
+  end
+
+  private
+
+  def build_model
+    Class.new(Medium) do
+      def self.name
+        'Medium'
+      end
+    end
+  end
+
+end