jaculabilis/danbooru
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add support for upload preprocessing

Browse Source
This commit is contained in:
Albert Yi
2018-05-16 17:13:36 -07:00
parent b561a6d9ab
commit fdd7582fb0
14 changed files with 1060 additions and 684 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
test/factories/upload.rb
View File

@@ -14,6 +14,14 @@ FactoryBot.define do
source "http://www.google.com/intl/en_ALL/images/logo.gif"
end
factory(:ugoira_upload) do
file do
f = Tempfile.new
IO.copy_stream("#{Rails.root}/test/fixtures/ugoira.zip", f.path)
ActionDispatch::Http::UploadedFile.new(tempfile: f, filename: "ugoira.zip")
end
end
factory(:jpg_upload) do
file do
f = Tempfile.new

BIN
test/files/valid_ugoira.zip Normal file
View File

Binary file not shown.

17
test/functional/uploads_controller_test.rb
View File

@@ -38,6 +38,15 @@ class UploadsControllerTest < ActionDispatch::IntegrationTest
assert_response :success
end
context "with a url" do
should "preprocess" do
assert_difference(-> { Upload.count }) do
get_auth new_upload_path, @user, params: {:url => "http://www.google.com/intl/en_ALL/images/logo.gif"}
assert_response :success
end
end
end
context "for a twitter post" do
should "render" do
skip "Twitter keys are not set" unless Danbooru.config.twitter_api_key
@@ -49,13 +58,15 @@ class UploadsControllerTest < ActionDispatch::IntegrationTest
context "for a post that has already been uploaded" do
setup do
as_user do
@post = create(:post, :source => "aaa")
@post = create(:post, :source => "http://google.com/aaa")
end
end
should "initialize the post" do
get_auth new_upload_path, @user, params: {:url => "http://google.com/aaa"}
assert_response :success
assert_difference(-> { Upload.count }, 0) do
get_auth new_upload_path, @user, params: {:url => "http://google.com/aaa"}
assert_response :success
end
end
end
end

525
test/models/upload_service_test.rb Normal file
View File

@@ -0,0 +1,525 @@
require 'test_helper'
class UploadServiceTest < ActiveSupport::TestCase
UGOIRA_CONTEXT = {
"ugoira" => {
"frame_data" => [
{"file" => "000000.jpg", "delay" => 200},
{"file" => "000001.jpg", "delay" => 200},
{"file" => "000002.jpg", "delay" => 200},
{"file" => "000003.jpg", "delay" => 200},
{"file" => "000004.jpg", "delay" => 250}
],
"content_type" => "image/jpeg"
}
}.freeze
context "::Utils" do
subject { UploadService::Utils }
context ".calculate_ugoira_dimensions" do
context "for a valid ugoira file" do
setup do
@path = "test/files/valid_ugoira.zip"
end
should "extract the dimensions" do
w, h = subject.calculate_ugoira_dimensions(@path)
assert_operator(w, :>, 0)
assert_operator(h, :>, 0)
end
end
context "for an invalid ugoira file" do
setup do
@path = "test/files/invalid_ugoira.zip"
end
should "raise an error" do
assert_raises(ImageSpec::Error) do
subject.calculate_ugoira_dimensions(@path)
end
end
end
end
context ".calculate_dimensions" do
context "for an ugoira" do
setup do
@file = File.open("test/files/valid_ugoira.zip", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(false)
@upload.stubs(:is_ugoira?).returns(true)
end
teardown do
@file.close
end
should "return the dimensions" do
subject.expects(:calculate_ugoira_dimensions).once.returns([60, 60])
subject.calculate_dimensions(@upload, @file) do |w, h|
assert_operator(w, :>, 0)
assert_operator(h, :>, 0)
end
end
end
context "for a video" do
setup do
@file = File.open("test/files/test-300x300.mp4", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(true)
end
teardown do
@file.close
end
should "return the dimensions" do
subject.calculate_dimensions(@upload, @file) do |w, h|
assert_operator(w, :>, 0)
assert_operator(h, :>, 0)
end
end
end
context "for an image" do
setup do
@file = File.open("test/files/test.jpg", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(false)
@upload.stubs(:is_ugoira?).returns(false)
end
teardown do
@file.close
end
should "find the dimensions" do
subject.calculate_dimensions(@upload, @file) do |w, h|
assert_operator(w, :>, 0)
assert_operator(h, :>, 0)
end
end
end
end
context ".process_file" do
setup do
@upload = FactoryBot.build(:jpg_upload)
@file = @upload.file
end
should "run" do
subject.expects(:distribute_files).twice
subject.process_file(@upload, @file)
assert_equal("jpg", @upload.file_ext)
assert_equal(28086, @upload.file_size)
assert_equal("ecef68c44edb8a0d6a3070b5f8e8ee76", @upload.md5)
assert_equal(335, @upload.image_height)
assert_equal(500, @upload.image_width)
end
end
context ".generate_resizes" do
context "for an ugoira" do
setup do
context = UGOIRA_CONTEXT
@file = File.open("test/fixtures/ugoira.zip", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(false)
@upload.stubs(:is_ugoira?).returns(true)
@upload.stubs(:context).returns(context)
end
should "generate a preview and a video" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
assert_operator(File.size(sample.path), :>, 0)
preview.close
preview.unlink
sample.close
sample.unlink
end
end
context "for a video" do
teardown do
@file.close
end
context "for an mp4" do
setup do
@file = File.open("test/files/test-300x300.mp4", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(true)
@upload.stubs(:is_ugoira?).returns(false)
end
should "generate a video" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
preview.close
preview.unlink
end
end
context "for a webm" do
setup do
@file = File.open("test/files/test-512x512.webm", "rb")
@upload = mock()
@upload.stubs(:is_video?).returns(true)
@upload.stubs(:is_ugoira?).returns(false)
end
should "generate a video" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
preview.close
preview.unlink
end
end
end
context "for an image" do
teardown do
@file.close
end
setup do
@upload = mock()
@upload.stubs(:is_video?).returns(false)
@upload.stubs(:is_ugoira?).returns(false)
@upload.stubs(:is_image?).returns(true)
@upload.stubs(:image_width).returns(1200)
@upload.stubs(:image_height).returns(200)
end
context "for a jpeg" do
setup do
@file = File.open("test/files/test.jpg", "rb")
end
should "generate a preview" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
assert_operator(File.size(sample.path), :>, 0)
preview.close
preview.unlink
sample.close
sample.unlink
end
end
context "for a png" do
setup do
@file = File.open("test/files/test.png", "rb")
end
should "generate a preview" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
assert_operator(File.size(sample.path), :>, 0)
preview.close
preview.unlink
sample.close
sample.unlink
end
end
context "for a gif" do
setup do
@file = File.open("test/files/test.png", "rb")
end
should "generate a preview" do
preview, sample = subject.generate_resizes(@file, @upload)
assert_operator(File.size(preview.path), :>, 0)
assert_operator(File.size(sample.path), :>, 0)
preview.close
preview.unlink
sample.close
sample.unlink
end
end
end
end
context ".generate_video_preview_for" do
context "for an mp4" do
setup do
@path = "test/files/test-300x300.mp4"
@video = FFMPEG::Movie.new(@path)
end
should "generate a video" do
sample = subject.generate_video_preview_for(@video, 100, 100)
assert_operator(File.size(sample.path), :>, 0)
sample.close
sample.unlink
end
end
context "for a webm" do
setup do
@path = "test/files/test-512x512.webm"
@video = FFMPEG::Movie.new(@path)
end
should "generate a video" do
sample = subject.generate_video_preview_for(@video, 100, 100)
assert_operator(File.size(sample.path), :>, 0)
sample.close
sample.unlink
end
end
end
end
context "::Preprocessor" do
subject { UploadService::Preprocessor }
context "#download_from_source" do
setup do
@jpeg = "https://upload.wikimedia.org/wikipedia/commons/c/c5/Moraine_Lake_17092005.jpg"
@ugoira = "https://i.pximg.net/img-zip-ugoira/img/2017/04/04/08/57/38/62247364_ugoira1920x1080.zip"
end
should "work on a jpeg" do
file = subject.new({}).download_from_source(@jpeg) do |context|
assert_not_nil(context[:downloaded_source])
assert_not_nil(context[:source])
end
assert_operator(File.size(file.path), :>, 0)
file.close
end
should "work on an ugoira url" do
file = subject.new({}).download_from_source(@ugoira, referer_url: "https://www.pixiv.net") do |context|
assert_not_nil(context[:downloaded_source])
assert_not_nil(context[:source])
assert_not_nil(context[:ugoira])
end
assert_operator(File.size(file.path), :>, 0)
file.close
end
end
context "#start!" do
setup do
CurrentUser.user = travel_to(1.month.ago) do
FactoryBot.create(:user)
end
CurrentUser.ip_addr = "127.0.0.1"
@jpeg = "https://upload.wikimedia.org/wikipedia/commons/c/c5/Moraine_Lake_17092005.jpg"
@ugoira = "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=62247364"
@video = "https://www.sample-videos.com/video/mp4/720/big_buck_bunny_720p_1mb.mp4"
end
teardown do
CurrentUser.user = nil
CurrentUser.ip_addr = nil
end
should "work for a jpeg" do
@service = subject.new(source: @jpeg)
@upload = @service.start!
assert_equal("preprocessed", @upload.status)
assert_not_nil(@upload.md5)
assert_equal("jpg", @upload.file_ext)
assert_operator(@upload.file_size, :>, 0)
assert_not_nil(@upload.source)
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "jpg", :original)))
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "jpg", :large)))
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "jpg", :preview)))
end
should "work for an ugoira" do
@service = subject.new(source: @ugoira)
@upload = @service.start!
assert_equal("preprocessed", @upload.status)
assert_not_nil(@upload.md5)
assert_equal("zip", @upload.file_ext)
assert_operator(@upload.file_size, :>, 0)
assert_not_nil(@upload.source)
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "zip", :original)))
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "zip", :large)))
end
should "work for a video" do
@service = subject.new(source: @video)
@upload = @service.start!
assert_equal("preprocessed", @upload.status)
assert_not_nil(@upload.md5)
assert_equal("mp4", @upload.file_ext)
assert_operator(@upload.file_size, :>, 0)
assert_not_nil(@upload.source)
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "mp4", :original)))
assert(File.exists?(Danbooru.config.storage_manager.file_path(@upload.md5, "mp4", :preview)))
end
context "on timeout errors" do
setup do
HTTParty.stubs(:get).raises(Net::ReadTimeout)
end
should "leave the upload in an error state" do
@service = subject.new(source: @video)
@upload = @service.start!
assert_match(/error:/, @upload.status)
end
end
end
end
context "#start!" do
subject { UploadService }
setup do
@source = "https://upload.wikimedia.org/wikipedia/commons/c/c5/Moraine_Lake_17092005.jpg"
CurrentUser.user = travel_to(1.month.ago) do
FactoryBot.create(:user)
end
CurrentUser.ip_addr = "127.0.0.1"
end
teardown do
CurrentUser.user = nil
CurrentUser.ip_addr = nil
end
context "automatic tagging" do
setup do
@build_service = ->(file) { subject.new(file: file)}
end
should "tag animated png files" do
service = @build_service.call(upload_file("test/files/apng/normal_apng.png"))
upload = service.start!
assert_match(/animated_png/, upload.tag_string)
end
should "tag animated gif files" do
service = @build_service.call(upload_file("test/files/test-animated-86x52.gif"))
upload = service.start!
assert_match(/animated_gif/, upload.tag_string)
end
should "not tag static gif files" do
service = @build_service.call(upload_file("test/files/test-static-32x32.gif"))
upload = service.start!
assert_no_match(/animated_gif/, upload.tag_string)
end
end
context "that is too large" do
setup do
Danbooru.config.stubs(:max_image_resolution).returns(31*31)
end
should "should fail validation" do
service = subject.new(file: upload_file("test/files/test-static-32x32.gif"))
upload = service.start!
assert_match(/image resolution is too large/, upload.status)
end
end
context "with a preprocessing predecessor" do
setup do
@predecessor = FactoryBot.create(:source_upload, status: "preprocessing", source: @source, image_height: 0, image_width: 0, file_ext: "jpg")
Delayed::Worker.delay_jobs = true
end
teardown do
Delayed::Worker.delay_jobs = false
end
should "schedule a job later" do
service = subject.new(source: @source)
assert_difference(-> { Delayed::Job.count }) do
predecessor = service.start!
assert_equal(@predecessor, predecessor)
end
end
end
context "with a preprocessed predecessor" do
setup do
@predecessor = FactoryBot.create(:source_upload, status: "preprocessed", source: @source, image_height: 0, image_width: 0, file_ext: "jpg")
@tags = 'hello world'
end
should "update the predecessor" do
service = subject.new(source: @source, tag_string: @tags)
predecessor = service.start!
assert_equal(@predecessor, predecessor)
assert_equal(@tags, predecessor.tag_string.strip)
end
end
context "with no predecessor" do
should "create an upload" do
service = subject.new(source: @source)
assert_difference(-> { Upload.count }) do
service.start!
end
end
end
end
context "#create_post_from_upload" do
subject { UploadService }
setup do
CurrentUser.user = travel_to(1.month.ago) do
FactoryBot.create(:user)
end
CurrentUser.ip_addr = "127.0.0.1"
end
teardown do
CurrentUser.user = nil
CurrentUser.ip_addr = nil
end
context "for an ugoira" do
setup do
@upload = FactoryBot.create(:ugoira_upload, file_size: 1000, md5: "12345", file_ext: "jpg", image_width: 100, image_height: 100, context: UGOIRA_CONTEXT)
end
should "create a post" do
assert_difference(-> { PixivUgoiraFrameData.count }) do
post = subject.new({}).create_post_from_upload(@upload)
assert_equal([], post.errors.full_messages)
assert_not_nil(post.id)
end
end
end
context "for an image" do
setup do
@upload = FactoryBot.create(:source_upload, file_size: 1000, md5: "12345", file_ext: "jpg", image_width: 100, image_height: 100)
end
should "create a commentary record" do
assert_difference(-> { ArtistCommentary.count }) do
subject.new({include_artist_commentary: true, artist_commentary_title: "blah", artist_commentary_desc: "blah"}).create_post_from_upload(@upload)
end
end
should "create a post" do
post = subject.new({}).create_post_from_upload(@upload)
assert_equal([], post.errors.full_messages)
assert_not_nil(post.id)
end
end
end
end

292
test/unit/upload_test.rb
View File

@@ -1,6 +1,8 @@
require 'test_helper'
class UploadTest < ActiveSupport::TestCase
SOURCE_URL = "https://upload.wikimedia.org/wikipedia/commons/thumb/6/66/NAMA_Machine_d%27Anticyth%C3%A8re_1.jpg/538px-NAMA_Machine_d%27Anticyth%C3%A8re_1.jpg?download"
context "In all cases" do
setup do
mock_iqdb_service!
@@ -28,298 +30,12 @@ class UploadTest < ActiveSupport::TestCase
end
end
context "image size calculator" do
should "discover the dimensions for a compressed SWF" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/compressed.swf"))
assert_equal([607, 756], @upload.calculate_dimensions)
end
should "discover the dimensions for a JPG with JFIF data" do
@upload = FactoryBot.create(:jpg_upload)
assert_equal([500, 335], @upload.calculate_dimensions)
end
should "discover the dimensions for a JPG with EXIF data" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test-exif-small.jpg"))
assert_equal([529, 600], @upload.calculate_dimensions)
end
should "discover the dimensions for a JPG with no header data" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test-blank.jpg"))
assert_equal([668, 996], @upload.calculate_dimensions)
end
should "discover the dimensions for a PNG" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test.png"))
assert_equal([768, 1024], @upload.calculate_dimensions)
end
should "discover the dimensions for a GIF" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test.gif"))
assert_equal([400, 400], @upload.calculate_dimensions)
end
end
context "content type calculator" do
should "know how to parse jpeg, png, gif, and swf file headers" do
@upload = FactoryBot.create(:jpg_upload)
assert_equal("jpg", @upload.file_header_to_file_ext(File.open("#{Rails.root}/test/files/test.jpg")))
assert_equal("gif", @upload.file_header_to_file_ext(File.open("#{Rails.root}/test/files/test.gif")))
assert_equal("png", @upload.file_header_to_file_ext(File.open("#{Rails.root}/test/files/test.png")))
assert_equal("swf", @upload.file_header_to_file_ext(File.open("#{Rails.root}/test/files/compressed.swf")))
assert_equal("bin", @upload.file_header_to_file_ext(File.open("#{Rails.root}/README.md")))
end
end
context "downloader" do
context "for a zip that is not an ugoira" do
should "not validate" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/invalid_ugoira.zip"))
@upload.process!
assert_equal("error: RuntimeError - missing frame data for ugoira", @upload.status)
end
end
context "that is a pixiv ugoira" do
setup do
@url = "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=46378654"
@upload = FactoryBot.create(:source_upload, :source => @url, :tag_string => "ugoira")
end
should "process successfully" do
begin
_, _, output_file = @upload.download_from_source(@url, "")
assert_operator(output_file.size, :>, 1_000)
assert_equal("zip", @upload.file_header_to_file_ext(output_file))
rescue Net::OpenTimeout
skip "Remote connection to #{@url} failed"
end
end
end
end
context "determining if a file is downloadable" do
should "classify HTTP sources as downloadable" do
@upload = FactoryBot.create(:source_upload, :source => "http://www.google.com/1.jpg")
assert_not_nil(@upload.is_downloadable?)
end
should "classify HTTPS sources as downloadable" do
@upload = FactoryBot.create(:source_upload, :source => "https://www.google.com/1.jpg")
assert_not_nil(@upload.is_downloadable?)
end
should "classify non-HTTP/HTTPS sources as not downloadable" do
@upload = FactoryBot.create(:source_upload, :source => "ftp://www.google.com/1.jpg")
assert_nil(@upload.is_downloadable?)
end
end
context "file processor" do
should "parse and process a cgi file representation" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test.jpg"))
assert_nothing_raised {@upload.process_upload}
assert_equal(28086, @upload.file_size)
end
should "process a transparent png" do
@upload = FactoryBot.create(:upload, file: upload_file("test/files/alpha.png"))
assert_nothing_raised {@upload.process_upload}
assert_equal(1136, @upload.file_size)
end
end
context "hash calculator" do
should "caculate the hash" do
@upload = FactoryBot.create(:jpg_upload)
@upload.process_upload
assert_equal("ecef68c44edb8a0d6a3070b5f8e8ee76", @upload.md5)
end
end
context "resizer" do
should "generate several resized versions of the image" do
@upload = FactoryBot.create(:upload, file_ext: "jpg", image_width: 1356, image_height: 911, file: upload_file("test/files/test-large.jpg"))
preview_file, sample_file = @upload.generate_resizes
assert_operator(preview_file.size, :>, 1_000)
assert_operator(sample_file.size, :>, 1_000)
end
end
should "increment the uploaders post_upload_count" do
@upload = FactoryBot.create(:source_upload)
assert_difference("CurrentUser.user.post_upload_count", 1) do
@upload.process!
assert_difference(-> { CurrentUser.user.post_upload_count }) do
FactoryBot.create(:source_upload)
CurrentUser.user.reload
end
end
context "with an artist commentary" do
setup do
@upload = FactoryBot.create(:source_upload,
include_artist_commentary: "1",
artist_commentary_title: "",
artist_commentary_desc: "blah",
)
end
should "create an artist commentary when processed" do
assert_difference("ArtistCommentary.count") do
@upload.process!
end
end
end
should "process completely for a downloaded image" do
@upload = FactoryBot.create(:source_upload,
:rating => "s",
:uploader_ip_addr => "127.0.0.1",
:tag_string => "hoge foo"
)
assert_difference("Post.count") do
assert_nothing_raised {@upload.process!}
end
post = Post.last
assert_equal("http://www.google.com/intl/en_ALL/images/logo.gif", post.source)
assert_equal("foo hoge lowres", post.tag_string)
assert_equal("s", post.rating)
assert_equal(@upload.uploader_id, post.uploader_id)
assert_equal("127.0.0.1", post.uploader_ip_addr.to_s)
assert_equal(@upload.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, @upload.post_id)
assert_equal("completed", @upload.status)
end
context "automatic tagging" do
should "tag animated png files" do
@upload = FactoryBot.build(:upload, file_ext: "png", file: upload_file("test/files/apng/normal_apng.png"))
assert_equal("animated_png", @upload.automatic_tags)
end
should "tag animated gif files" do
@upload = FactoryBot.build(:upload, file_ext: "gif", file: upload_file("test/files/test-animated-86x52.gif"))
assert_equal("animated_gif", @upload.automatic_tags)
end
should "not tag static gif files" do
@upload = FactoryBot.build(:upload, file_ext: "gif", file: upload_file("test/files/test-static-32x32.gif"))
assert_equal("", @upload.automatic_tags)
end
end
context "that is too large" do
should "should fail validation" do
Danbooru.config.stubs(:max_image_resolution).returns(31*31)
@upload = FactoryBot.create(:upload, file: upload_file("test/files/test-static-32x32.gif"))
@upload.process!
assert_match(/image resolution is too large/, @upload.status)
end
end
end
should "process completely for a pixiv ugoira" do
skip "ffmpeg is not installed" unless check_ffmpeg
@upload = FactoryBot.create(:source_upload, source: "http://www.pixiv.net/member_illust.php?mode=medium&illust_id=46378654")
assert_difference(["PixivUgoiraFrameData.count", "Post.count"]) do
@upload.process!
assert_equal([], @upload.errors.full_messages)
end
post = Post.last
assert_not_nil(post.pixiv_ugoira_frame_data)
assert_equal("0d94800c4b520bf3d8adda08f95d31e2", post.md5)
assert_equal(60, post.image_width)
assert_equal(60, post.image_height)
assert_equal("https://i.pximg.net/img-zip-ugoira/img/2014/10/05/23/42/23/46378654_ugoira1920x1080.zip", post.source)
assert_nothing_raised { post.file(:original) }
assert_nothing_raised { post.file(:preview) }
end
should "process completely for an uploaded image" do
@upload = FactoryBot.create(:jpg_upload,
:rating => "s",
:uploader_ip_addr => "127.0.0.1",
:tag_string => "hoge foo",
:file => upload_file("test/files/test.jpg"),
)
assert_difference("Post.count") do
assert_nothing_raised {@upload.process!}
end
post = Post.last
assert_equal("foo hoge lowres", post.tag_string)
assert_equal("s", post.rating)
assert_equal(@upload.uploader_id, post.uploader_id)
assert_equal("127.0.0.1", post.uploader_ip_addr.to_s)
assert_equal(@upload.md5, post.md5)
assert_equal("jpg", post.file_ext)
assert_nothing_raised { post.file(:original) }
assert_equal(28086, post.file(:original).size)
assert_equal(post.id, @upload.post_id)
assert_equal("completed", @upload.status)
end
should "process completely for a .webm" do
upload = FactoryBot.create(:upload, rating: "s", file: upload_file("test/files/test-512x512.webm"))
assert_difference("Post.count") do
upload.process!
assert_equal("completed", upload.status)
end
post = Post.last
assert_includes(post.tag_array, "webm")
assert_equal("webm", upload.file_ext)
assert_equal(12345, upload.file_size)
assert_equal(512, upload.image_width)
assert_equal(512, upload.image_height)
assert_equal("34dd2489f7aaa9e57eda1b996ff26ff7", upload.md5)
assert_nothing_raised { post.file(:preview) }
assert_nothing_raised { post.file(:original) }
end
should "process completely for a .mp4" do
upload = FactoryBot.create(:upload, rating: "s", file: upload_file("test/files/test-300x300.mp4"))
assert_difference("Post.count") do
upload.process!
assert_equal("completed", upload.status)
end
post = Post.last
assert_includes(post.tag_array, "mp4")
assert_equal("mp4", upload.file_ext)
assert_equal(18677, upload.file_size)
assert_equal(300, upload.image_width)
assert_equal(300, upload.image_height)
assert_equal("865c93102cad3e8a893d6aac6b51b0d2", upload.md5)
assert_nothing_raised { post.file(:preview) }
assert_nothing_raised { post.file(:original) }
end
should "process completely for a null source" do
@upload = FactoryBot.create(:jpg_upload, :source => nil)
assert_difference("Post.count") do
assert_nothing_raised {@upload.process!}
end
end
context "on timeout errors" do
should "leave the upload in an error state" do
HTTParty.stubs(:get).raises(Net::ReadTimeout)
@upload = FactoryBot.create(:source_upload)
@upload.process!
assert_match(/\Aerror/, @upload.status)
end
end
end
end