added full pending post unit test

app/logical/download.rb

@@ -0,0 +1,87 @@
+class Download
+  class Error < Exception ; end
+  
+  attr_accessor :source, :content_type
+  
+  def initialize(source, file_path)
+    @source = source
+    @file_path = file_path
+  end
+
+  # Downloads to @file_path
+  def download!
+    http_get_streaming(@source) do |response|
+      self.content_type = response["Content-Type"]
+      File.open(@file_path, "wb") do |out|
+        response.read_body(out)
+      end
+    end
+    @source = fix_image_board_sources(@source)
+  end
+
+# private
+  def handle_pixiv(source, headers)
+    if source =~ /pixiv\.net/
+      headers["Referer"] = "http://www.pixiv.net"
+
+      # Don't download the small version
+      if source =~ %r!(/img/.+?/.+?)_m.+$!
+        match = $1
+        source.sub!(match + "_m", match)
+      end
+    end
+  
+    source
+  end
+
+  def http_get_streaming(source, options = {})
+    max_size = options[:max_size] || Danbooru.config.max_file_size
+    max_size = nil if max_size == 0 # unlimited
+    limit = 4
+
+    while true
+      url = URI.parse(source)
+
+      unless url.is_a?(URI::HTTP)
+        raise Error.new("URL must be HTTP")
+      end
+
+      Net::HTTP.start(url.host, url.port) do |http|
+        http.read_timeout = 10
+        headers = {
+          "User-Agent" => "#{Danbooru.config.safe_app_name}/#{Danbooru.config.version}"
+        }
+        source = handle_pixiv(source, headers)
+        http.request_get(url.request_uri, headers) do |res|
+          case res
+          when Net::HTTPSuccess then
+            if max_size
+              len = res["Content-Length"]
+              raise Error.new("File is too large (#{len} bytes)") if len && len.to_i > max_size
+            end
+            yield(res)
+            return
+
+          when Net::HTTPRedirection then
+            if limit == 0 then
+              raise Error.new("Too many redirects")
+            end
+            source = res["location"]
+            limit -= 1
+
+          else
+            raise Error.new("HTTP error code: #{res.code} #{res.message}")
+          end
+        end # http.request_get
+      end # http.start
+    end # while
+  end # def
+
+  def fix_image_board_sources(source)
+    if source =~ /\/src\/\d{12,}|urnc\.yi\.org|yui\.cynthia\.bne\.jp/
+      "Image board"
+    else
+      source
+    end
+  end
+end

app/models/pending_post.rb

@@ -1,2 +1,205 @@
+require "danbooru_image_resizer/danbooru_image_resizer"
+require "tmpdir"
+
 class PendingPost < ActiveRecord::Base
-end
+  class Error < Exception ; end
+  
+  attr_accessor :file, :image_width, :image_height, :file_ext, :md5, :file_size
+  belongs_to :uploader, :class_name => "User"
+  
+  def process!
+    update_attribute(:status, "processing")    
+    download_from_source(temp_file_path) if is_downloadable?
+    calculate_hash(file_path)
+    calculate_file_size(file_path)
+    calculate_dimensions(file_path) if has_dimensions?
+    generate_resizes(file_path)
+    move_file
+    post = convert_to_post
+    if post.save
+      update_attributes(:status => "finished", :post_id => post.id)
+    else
+      update_attribute(:status, "error: " + post.errors.full_messages.join(", "))
+    end
+  end
+  
+  # private
+  module ResizerMethods
+    def generate_resizes(source_path)
+      generate_resize_for(Danbooru.config.small_image_width, source_path)
+      generate_resize_for(Danbooru.config.medium_image_width, source_path)
+      generate_resize_for(Danbooru.config.large_image_width, source_path)
+    end
+
+    def generate_resize_for(width, source_path)
+      return if width.nil?
+      return unless image_width > width
+
+      unless File.exists?(source_path)
+        raise Error.new("file not found")
+      end
+
+      size = Danbooru.reduce_to({:width => image_width, :height => image_height}, {:width => width})
+
+      # If we're not reducing the resolution, only reencode if the source image larger than
+      # 200 kilobytes.
+      if size[:width] == image_width && size[:height] == image_height && File.size?(source_path) < 200.kilobytes
+        return
+      end
+
+      Danbooru.resize(file_ext, source_path, resized_file_path_for(width), size, 90)
+    end
+  end
+
+  module DimensionMethods
+    # Figures out the dimensions of the image.
+    def calculate_dimensions(file_path)
+      image_size = ImageSize.new(File.open(file_path, "rb"))
+      self.image_width = image_size.get_width
+      self.image_height = image_size.get_height
+    end
+
+    # Does this file have image dimensions?
+    def has_dimensions?
+      %w(jpg gif png swf).include?(file_ext)
+    end
+  end
+  
+  module ContentTypeMethods
+    def content_type_to_file_ext(content_type)
+      case content_type
+      when "image/jpeg"
+        "jpg"
+        
+      when "image/gif"
+        "gif"
+        
+      when "image/png"
+        "png"
+        
+      when "application/x-shockwave-flash"
+        "swf"
+        
+      else
+        "bin"
+      end
+    end
+    
+    # Converts a content type string to a file extension
+    def file_ext_to_content_type(file_ext)
+      case file_ext
+      when /\.jpeg$|\.jpg$/
+        "image/jpeg"
+
+      when /\.gif$/
+        "image/gif"
+
+      when /\.png$/
+        "image/png"
+
+      when /\.swf$/
+        "application/x-shockwave-flash"
+
+      else
+        "application/octet-stream"
+      end
+    end
+  end
+
+  module FilePathMethods
+    def md5_file_path
+      prefix = Rails.env == "test" ? "test." : ""
+      "#{Rails.root}/public/data/original/#{prefix}#{md5}.#{file_ext}"
+    end
+    
+    def resized_file_path_for(width)
+      prefix = Rails.env == "test" ? "test." : ""
+
+      case width
+      when Danbooru.config.small_image_width
+        "#{Rails.root}/public/data/thumb/#{prefix}#{md5}.jpg"
+
+      when Danbooru.config.medium_image_width
+        "#{Rails.root}/public/data/medium/#{prefix}#{md5}.jpg"
+
+      when Danbooru.config.large_image_width
+        "#{Rails.root}/public/data/large/#{prefix}#{md5}.jpg"
+      end
+    end
+    
+    def temp_file_path
+      File.join(Dir::tmpdir, "#{Time.now.to_f}.#{$PROCESS_ID}")
+    end
+  end
+  
+  module DownloaderMethods
+    # Determines whether the source is downloadable
+    def is_downloadable?
+      source =~ /^http:\/\// && file_path.blank?
+    end
+
+    # Downloads the file to destination_path
+    def download_from_source(destination_path)
+      download = Download.new(source, destination_path)
+      download.download!
+      self.file_path = destination_path
+      self.content_type = download.content_type || file_ext_to_content_type(source)
+      self.file_ext = content_type_to_file_ext(content_type)
+      self.source = download.source
+    end
+  end
+
+  module CgiFileMethods
+    # Moves the cgi file to file_path
+    def convert_cgi_file(destination_path)
+      return if file.blank? || file.size == 0
+
+      if file.local_path
+        FileUtils.mv(file.local_path, destination_path)
+      else
+        File.open(destination_path, 'wb') do |out| 
+          out.write(file.read)
+        end
+      end
+      self.file_path = destination_path
+      self.content_type = file.content_type || file_ext_to_content_type(file.original_filename)
+      self.file_ext = content_type_to_file_ext(content_type)
+    end
+  end
+  
+  include ResizerMethods
+  include DimensionMethods
+  include ContentTypeMethods
+  include DownloaderMethods
+  include FilePathMethods
+  include CgiFileMethods
+
+# private
+  def convert_to_post
+    returning Post.new do |p|
+      p.tag_string = tag_string
+      p.md5 = md5
+      p.file_ext = file_ext
+      p.image_width = image_width
+      p.image_height = image_height
+      p.uploader_id = uploader_id
+      p.uploader_ip_addr = uploader_ip_addr
+      p.rating = rating
+      p.source = source
+      p.file_size = file_size
+    end
+  end
+  
+  def move_file
+    FileUtils.mv(file_path, md5_file_path)
+  end
+  
+  def calculate_file_size(source_path)
+    self.file_size = File.size(source_path)
+  end
+  
+  # Calculates the MD5 based on whatever is in temp_file_path
+  def calculate_hash(source_path)
+    self.md5 = Digest::MD5.file(source_path).hexdigest
+  end
+end

app/models/post.rb

@@ -3,267 +3,4 @@ class Post < ActiveRecord::Base
     set_table_name "deleted_posts"
   end
   
-  class Pending < ActiveRecord::Base
-    class Error < Exception ; end
-    
-    class Download
-      class Error < Exception ; end
-      
-      attr_accessible :source, :content_type
-      
-      def initialize(source, file_path)
-        @source = source
-        @file_path = file_path
-      end
-
-      # Downloads to @file_path
-      def download!
-        http_get_streaming(@source) do |response|
-          self.content_type = response["Content-Type"]
-          File.open(@file_path, "wb") do |out|
-            response.read_body(out)
-          end
-        end
-        @source = fix_image_board_sources(@source)
-      end
-  
-    private
-      def handle_pixiv(source, headers)
-        if source =~ /pixiv\.net/
-          headers["Referer"] = "http://www.pixiv.net"
-
-          # Don't download the small version
-          if source =~ %r!(/img/.+?/.+?)_m.+$!
-            match = $1
-            source.sub!(match + "_m", match)
-          end
-        end
-      
-        source
-      end
-    
-      def http_get_streaming(source, options = {})
-        max_size = options[:max_size] || Danbooru.config.max_file_size
-        max_size = nil if max_size == 0 # unlimited
-        limit = 4
-
-        while true
-          url = URI.parse(source)
-
-          unless url.is_a?(URI::HTTP)
-            raise Error.new("URL must be HTTP")
-          end
-
-          Net::HTTP.start(url.host, url.port) do |http|
-            http.read_timeout = 10
-            headers = {
-              "User-Agent" => "#{Danbooru.config.safe_app_name}/#{Danbooru.config.version}"
-            }
-            source = handle_pixiv(source, headers)
-            http.request_get(url.request_uri, headers) do |res|
-              case res
-              when Net::HTTPSuccess then
-                if max_size
-                  len = res["Content-Length"]
-                  raise Error.new("File is too large (#{len} bytes)") if len && len.to_i > max_size
-                end
-                yield(res)
-                return
-
-              when Net::HTTPRedirection then
-                if limit == 0 then
-                  raise Error.new("Too many redirects")
-                end
-                source = res["location"]
-                limit -= 1
-
-              else
-                raise Error.new("HTTP error code: #{res.code} #{res.message}")
-              end
-            end # http.request_get
-          end # http.start
-        end # while
-      end # def
-    
-      def fix_image_board_sources(source)
-        if source =~ /\/src\/\d{12,}|urnc\.yi\.org|yui\.cynthia\.bne\.jp/
-          "Image board"
-        else
-          source
-        end
-      end
-    end # download
-    
-    set_table_name "pending_posts"
-    belongs_to :post
-    attr_accessible :file, :image_width, :image_height
-    
-    def process!
-      update_attribute(:status, "processing")
-      
-      if file
-        convert_cgi_file(temp_file_path)
-      elsif is_downloadable?
-        download_from_source(temp_file_path)
-      end
-      
-      calculate_hash(temp_file_path)
-      move_file
-      calculate_dimensions
-      generate_resizes
-      convert_to_post
-      update_attribute(:status, "finished")
-    end
-    
-  private
-    def generate_resizes
-      generate_resize_for(Danbooru.config.small_image_width)
-      generate_resize_for(Danbooru.config.medium_image_width)
-      generate_resize_for(Danbooru.config.large_image_width)
-    end
-  
-    def create_resize_for(width)
-      return if width.nil?
-      return unless image_width > width
-
-      unless File.exists?(final_file_path)
-        raise Error.new("file not found")
-      end
-
-      size = Danbooru.reduce_to({:width => image_width, :height => image_height}, {:width => width})
-
-      # If we're not reducing the resolution, only reencode if the source image larger than
-      # 200 kilobytes.
-      if size[:width] == width && size[:height] == height && File.size?(path) > 200.kilobytes
-        return true
-      end
-
-      begin
-        Danbooru.resize(file_ext, final_file_path, resize_file_path_for(width), size, 90)
-      rescue Exception => x
-        errors.add "sample", "couldn't be created: #{x}"
-        return false
-      end
-
-      self.sample_width = size[:width]
-      self.sample_height = size[:height]
-      return true
-    end
-    
-    def resize_file_path_for(width)
-      case width
-      when Danbooru.config.small_image_width
-        "#{Rails.root}/public/data/preview"
-        
-      when Danbooru.config.medium_image_width
-        "#{Rails.root}/public/data/medium"        
-        
-      when Danbooru.config.large_image_width
-        "#{Rails.root}/public/data/large"
-      end
-    end
-    
-    def convert_to_post
-      returning Post.new do |p|
-        p.tag_string = tag_string
-        p.md5 = md5
-        p.file_ext = file_ext
-        p.image_width = image_width
-        p.image_height = image_height
-        p.uploader_id = uploader_id
-        p.uploader_ip_addr = uploader_ip_addr
-        p.rating = rating
-        p.source = source
-      end
-    end
-
-    def calculate_dimensions(post)
-      if has_dimensions?
-        image_size = ImageSize.new(File.open(final_file_path, "rb"))
-        self.image_width = image_size.get_width
-        self.image_hegiht = image_hegiht.get_height
-      end
-    end
-    
-    def has_dimensions?
-      %w(jpg gif png swf).include?(file_ext)
-    end
-    
-    def move_file
-      FileUtils.mv(temp_file_path, final_file_path)
-    end
-  
-    def final_file_path
-      "#{Rails.root}/public/data/original/#{md5}.#{file_ext}"
-    end
-  
-    # Calculates the MD5 based on whatever is in temp_file_path
-    def calculate_hash(file_path)
-      self.md5 = Digest::MD5.file(file_path).hexdigest
-    end
-  
-    # Moves the cgi file to file_path
-    def convert_cgi_file(file_path)
-      return if file.blank? || file.size == 0
-
-      if file.local_path
-        FileUtils.mv(file.local_path, file_path)
-      else
-        File.open(file_path, 'wb') do |out| 
-          out.write(file.read)
-        end
-      end
-      self.file_ext = content_type_to_file_ext(file.content_type) || find_ext(file.original_filename)
-    end
-
-    # Determines whether the source is downloadable
-    def is_downloadable?
-      source =~ /^http:\/\// && file.blank?
-    end
-
-    # Downloads the file to file_path
-    def download_from_source(file_path)
-      download = Download.new(source, file_path)
-      download.download!
-      self.file_ext = content_type_to_file_ext(download.content_type) || find_ext(source)
-    end
-    
-    # Converts a content type string to a file extension
-    def content_type_to_file_ext(content_type)
-      case content_type
-      when /jpeg/
-        return "jpg"
-
-      when /gif/
-        return "gif"
-
-      when /png/
-        return "png"
-
-      when /x-shockwave-flash/
-        return "swf"
-
-      else
-        nil
-      end
-    end
-
-    # Determines the file extention based on a path, normalizing if necessary
-    def find_ext(file_path)
-      ext = File.extname(file_path)
-      if ext.blank?
-        return "txt"
-      else
-        ext = ext[1..-1].downcase
-        ext = "jpg" if ext == "jpeg"
-        return ext
-      end
-    end
-    
-    # Path to a temporary file
-    def temp_file_path
-      @temp_file ||= Tempfile.new("danbooru-upload-#{$PROCESS_ID}")
-      @temp_file.path
-    end
-  end
 end

config/initializers/create_empty_directories.rb

@@ -1,6 +1,6 @@
 require 'fileutils'
 
-FileUtils.mkdir_p("#{Rails.root}/public/data/size_thumbnail")
+FileUtils.mkdir_p("#{Rails.root}/public/data/thumb")
-FileUtils.mkdir_p("#{Rails.root}/public/data/size_medium")
+FileUtils.mkdir_p("#{Rails.root}/public/data/medium")
-FileUtils.mkdir_p("#{Rails.root}/public/data/size_large")
+FileUtils.mkdir_p("#{Rails.root}/public/data/large")
-FileUtils.mkdir_p("#{Rails.root}/public/data/size_original")
+FileUtils.mkdir_p("#{Rails.root}/public/data/original")

db/development_structure.sql

@@ -83,6 +83,8 @@ CREATE TABLE pending_posts (
     created_at timestamp without time zone,
     updated_at timestamp without time zone,
     source character varying(255),
+    file_path character varying(255),
+    content_type character varying(255),
     rating character(1) NOT NULL,
     uploader_id integer NOT NULL,
     uploader_ip_addr inet NOT NULL,
@@ -452,8 +454,8 @@ CREATE TRIGGER trigger_posts_on_tag_index_update
 
 INSERT INTO schema_migrations (version) VALUES ('20100204211522');
 
-INSERT INTO schema_migrations (version) VALUES ('20100205162521');
-
 INSERT INTO schema_migrations (version) VALUES ('20100204214746');
 
+INSERT INTO schema_migrations (version) VALUES ('20100205162521');
+
 INSERT INTO schema_migrations (version) VALUES ('20100205224030');

db/migrate/20100205224030_create_pending_posts.rb

@@ -3,6 +3,9 @@ class CreatePendingPosts < ActiveRecord::Migration
     create_table :pending_posts do |t|
       t.timestamps
       t.column :source, :string
+      t.column :file_path, :string
+      t.column :content_type, :string
+      
       t.column :rating, :character, :null => false
       t.column :uploader_id, :integer, :null => false
       t.column :uploader_ip_addr, "inet", :null => false

test/factories/pending_post.rb

@@ -0,0 +1,43 @@
+require 'fileutils'
+
+Factory.define(:pending_post) do |f|
+  f.rating "s"
+  f.uploader {|x| x.association(:user)}
+  f.uploader_ip_addr "127.0.0.1"
+  f.tag_string "special"
+  f.status "pending"
+end
+
+Factory.define(:downloadable_pending_post, :parent => :pending_post) do |f|
+  f.source "http://www.google.com/intl/en_ALL/images/logo.gif"
+end
+
+Factory.define(:uploaded_jpg_pending_post, :parent => :pending_post) do |f|
+  f.file_path do
+    FileUtils.cp("#{Rails.root}/test/files/test.jpg", "#{Rails.root}/tmp")
+    "#{Rails.root}/tmp/test.jpg"
+  end
+end
+
+Factory.define(:uploaded_large_jpg_pending_post, :parent => :pending_post) do |f|
+  f.file_ext "jpg"
+  f.content_type "image/jpeg"
+  f.file_path do
+    FileUtils.cp("#{Rails.root}/test/files/test-large.jpg", "#{Rails.root}/tmp")
+    "#{Rails.root}/tmp/test-large.jpg"
+  end
+end
+
+Factory.define(:uploaded_png_pending_post, :parent => :pending_post) do |f|
+  f.file_path do
+    FileUtils.cp("#{Rails.root}/test/files/test.png", "#{Rails.root}/tmp")
+    "#{Rails.root}/tmp/test.png"
+  end
+end
+
+Factory.define(:uploaded_gif_pending_post, :parent => :pending_post) do |f|
+  f.file_path do
+    FileUtils.cp("#{Rails.root}/test/files/test.gif", "#{Rails.root}/tmp")
+    "#{Rails.root}/tmp/test.gif"
+  end
+end

test/unit/download_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class DownloadTest < ActiveSupport::TestCase
+  context "A post download" do
+    setup do
+      @source = "http://www.google.com/intl/en_ALL/images/logo.gif"
+      @tempfile = Tempfile.new("danbooru-test")
+      @download = Download.new(@source, @tempfile.path)
+    end
+    
+    teardown do
+      @tempfile.close
+    end
+    
+    should "stream a file from an HTTP source" do
+      @download.http_get_streaming(@download.source) do |resp|
+        assert_equal("200", resp.code)
+        assert(resp["Content-Length"].to_i > 0, "File should be larger than 0 bytes")
+      end
+    end
+    
+    should "throw an exception when the file is larger than the maximum" do
+      assert_raise(Download::Error) do
+        @download.http_get_streaming(@download.source, :max_size => 1) do |resp|
+        end
+      end
+    end
+    
+    should "store the file in the tempfile path" do
+      @download.download!
+      assert_equal(@source, @download.source)
+      assert(File.exists?(@tempfile.path), "temp file should exist")
+      assert(File.size(@tempfile.path) > 0, "should have data")
+    end
+    
+    should "initialize the content type" do
+      @download.download!
+      assert_match(/image\/gif/, @download.content_type)
+    end
+  end
+end

test/unit/pending_post_test.rb

@@ -1,8 +1,132 @@
-require 'test_helper'
+require File.dirname(__FILE__) + '/../test_helper'
 
 class PendingPostTest < ActiveSupport::TestCase
-  # Replace this with your real tests.
+  context "A pending post" do    
-  test "the truth" do
+    teardown do
-    assert true
+      FileUtils.rm_f(Dir.glob("#{Rails.root}/tmp/test.*"))
+    end
+
+    context "image size calculator" do
+      should "discover the dimensions for a JPG" do
+        @pending_post = Factory.create(:uploaded_jpg_pending_post)
+        assert_nothing_raised {@pending_post.calculate_dimensions(@pending_post.file_path)}
+        assert_equal(500, @pending_post.image_width)
+        assert_equal(335, @pending_post.image_height)
+      end
+
+      should "discover the dimensions for a PNG" do
+        @pending_post = Factory.create(:uploaded_png_pending_post)
+        assert_nothing_raised {@pending_post.calculate_dimensions(@pending_post.file_path)}
+        assert_equal(768, @pending_post.image_width)
+        assert_equal(1024, @pending_post.image_height)
+      end
+
+      should "discover the dimensions for a GIF" do
+        @pending_post = Factory.create(:uploaded_gif_pending_post)
+        assert_nothing_raised {@pending_post.calculate_dimensions(@pending_post.file_path)}
+        assert_equal(400, @pending_post.image_width)
+        assert_equal(400, @pending_post.image_height)
+      end
+    end
+    
+    context "content type calculator" do
+      should "know how to parse jpeg, png, gif, and swf file extensions" do
+        @pending_post = Factory.create(:uploaded_jpg_pending_post)
+        assert_equal("image/jpeg", @pending_post.file_ext_to_content_type("test.jpeg"))
+        assert_equal("image/gif", @pending_post.file_ext_to_content_type("test.gif"))
+        assert_equal("image/png", @pending_post.file_ext_to_content_type("test.png"))
+        assert_equal("application/x-shockwave-flash", @pending_post.file_ext_to_content_type("test.swf"))
+        assert_equal("application/octet-stream", @pending_post.file_ext_to_content_type(""))
+      end
+
+      should "know how to parse jpeg, png, gif, and swf content types" do
+        @pending_post = Factory.create(:uploaded_jpg_pending_post)
+        assert_equal("jpg", @pending_post.content_type_to_file_ext("image/jpeg"))
+        assert_equal("gif", @pending_post.content_type_to_file_ext("image/gif"))
+        assert_equal("png", @pending_post.content_type_to_file_ext("image/png"))
+        assert_equal("swf", @pending_post.content_type_to_file_ext("application/x-shockwave-flash"))
+        assert_equal("bin", @pending_post.content_type_to_file_ext(""))
+      end
+    end
+    
+    context "downloader" do
+      should "initialize the final path and content type after downloading a file" do
+        @pending_post = Factory.create(:downloadable_pending_post)
+        path = "#{Rails.root}/tmp/test.download.jpg"
+        assert_nothing_raised {@pending_post.download_from_source(path)}
+        assert(File.exists?(path))
+        assert_equal(8558, File.size(path))
+        assert_equal("image/gif", @pending_post.content_type)
+        assert_equal(path, @pending_post.file_path)
+        assert_equal("gif", @pending_post.file_ext)
+      end
+    end
+    
+    context "file processor" do
+      should "parse and process a cgi file representation" do
+        FileUtils.cp("#{Rails.root}/test/files/test.jpg", "#{Rails.root}/tmp")
+        @pending_post = PendingPost.new(:file => upload_jpeg("#{Rails.root}/tmp/test.jpg"))
+        assert_nothing_raised {@pending_post.convert_cgi_file("#{Rails.root}/tmp/test.converted.jpg")}
+        assert_equal("image/jpeg", @pending_post.content_type)
+        assert_equal("#{Rails.root}/tmp/test.converted.jpg", @pending_post.file_path)
+        assert(File.exists?("#{Rails.root}/tmp/test.converted.jpg"))
+        assert_equal(28086, File.size("#{Rails.root}/tmp/test.converted.jpg"))
+        assert_equal("jpg", @pending_post.file_ext)
+      end
+    end
+
+    context "hash calculator" do
+      should "caculate the hash" do
+        @pending_post = Factory.create(:uploaded_jpg_pending_post)
+        @pending_post.calculate_hash(@pending_post.file_path)
+        assert_equal("ecef68c44edb8a0d6a3070b5f8e8ee76", @pending_post.md5)
+      end
+    end
+    
+    context "resizer" do
+      teardown do
+        FileUtils.rm_f(Dir.glob("#{Rails.root}/public/data/thumb/test.*.jpg"))
+        FileUtils.rm_f(Dir.glob("#{Rails.root}/public/data/medium/test.*.jpg"))
+        FileUtils.rm_f(Dir.glob("#{Rails.root}/public/data/large/test.*.jpg"))
+        FileUtils.rm_f(Dir.glob("#{Rails.root}/public/data/original/test.*.jpg"))
+      end
+      
+      should "generate several resized versions of the image" do
+        @pending_post = Factory.create(:uploaded_large_jpg_pending_post)
+        @pending_post.calculate_hash(@pending_post.file_path)
+        @pending_post.calculate_dimensions(@pending_post.file_path)
+        assert_nothing_raised {@pending_post.generate_resizes(@pending_post.file_path)}
+        assert(File.exists?(@pending_post.resized_file_path_for(Danbooru.config.small_image_width)))
+        assert_equal(6556, File.size(@pending_post.resized_file_path_for(Danbooru.config.small_image_width)))
+        assert(File.exists?(@pending_post.resized_file_path_for(Danbooru.config.medium_image_width)))
+        assert_equal(39411, File.size(@pending_post.resized_file_path_for(Danbooru.config.medium_image_width)))
+        assert(File.exists?(@pending_post.resized_file_path_for(Danbooru.config.large_image_width)))
+        assert_equal(179324, File.size(@pending_post.resized_file_path_for(Danbooru.config.large_image_width)))
+      end
+    end
+    
+    should "process completely for a downloaded image" do
+      @pending_post = Factory.create(:downloadable_pending_post,
+        :rating => "s",
+        :uploader_ip_addr => "127.0.0.1",
+        :tag_string => "hoge foo"
+      )
+      assert_difference("Post.count") do
+        assert_nothing_raised {@pending_post.process!}
+      end
+      
+      post = Post.last
+      assert_equal("hoge foo", post.tag_string)
+      assert_equal("s", post.rating)
+      assert_equal(@pending_post.uploader_id, post.uploader_id)
+      assert_equal("127.0.0.1", post.uploader_ip_addr)
+      assert_equal(@pending_post.md5, post.md5)
+      assert_equal("gif", post.file_ext)
+      assert_equal(276, post.image_width)
+      assert_equal(110, post.image_height)
+      assert_equal(8558, post.file_size)
+      assert_equal(post.id, @pending_post.post_id)
+      assert_equal("finished", @pending_post.status)
+    end
   end
 end

test/unit/post_test.rb

@@ -1,41 +1,5 @@
 require File.dirname(__FILE__) + '/../test_helper'
 
 class PostTest < ActiveSupport::TestCase
-  context "A post download" do
+
-    setup do
-      @source = "http://www.google.com/intl/en_ALL/images/logo.gif"
-      @tempfile = Tempfile.new("danbooru-test")
-      @download = ::Post::Pending::Download.new(@source, @tempfile.path)
-    end
-    
-    teardown do
-      @tempfile.close
-    end
-    
-    should "stream a file from an HTTP source" do
-      @download.http_get_streaming(@download.source) do |resp|
-        assert_equal("200", resp.code)
-        assert(resp["Content-Length"].to_i > 0, "File should be larger than 0 bytes")
-      end
-    end
-    
-    should "throw an exception when the file is larger than the maximum" do
-      assert_raise(Post::Pending::Download::Error) do
-        @download.http_get_streaming(@download.source, :max_size => 1) do |resp|
-        end
-      end
-    end
-    
-    should "store the file in the tempfile path" do
-      @download.download!
-      assert_equal(@source, @download.source)
-      assert(File.exists?(@tempfile.path), "temp file should exist")
-      assert(File.size(@tempfile.path) > 0, "should have data")
-    end
-    
-    should "initialize the content type" do
-      @download.download!
-      assert_match(/text\/html/, @download.content_type)
-    end
-  end
 end