fogged 0.0.4 → 0.0.5

data/test/dummy/test/controllers/resources_controller/index_test.rb

@@ -10,13 +10,13 @@ class ResourcesControllerIndexTest < ActionController::TestCase
   end
 
   test "should index all resources for movies" do
-    get :index, :type => "movie", :use_route => :fogged
+    get :index, :type => "movie"
 
     assert_json_resources(Movie.all.map(&:resources).flatten)
   end
 
   test "should index resources for a movie" do
-    get :index, :type => "movie", :type_id => @movie.id, :use_route => :fogged
+    get :index, :type => "movie", :type_id => @movie.id
 
     assert_json_resources(@movie.resources.to_a)
   end
@@ -25,8 +25,7 @@ class ResourcesControllerIndexTest < ActionController::TestCase
     resources = movies(:movie_one, :movie_two).map(&:resources).flatten
     get :index,
         :type => "movie",
-        :type_ids => movies(:movie_one, :movie_two).map(&:id),
-        :use_route => :fogged
+        :type_ids => movies(:movie_one, :movie_two).map(&:id)
 
     assert_json_resources(resources)
   end
@@ -42,14 +41,13 @@ class ResourcesControllerIndexTest < ActionController::TestCase
     get :index,
         :type => "movie",
         :type_id => @movie.id,
-        :query => "test",
-        :use_route => :fogged
+        :query => "test"
 
     assert_json_resources([res])
   end
 
   test "should index resources with invalid movie id" do
-    get :index, :type => "movie", :type_id => 1234567890, :use_route => :fogged
+    get :index, :type => "movie", :type_id => 1234567890
 
     assert_json_resources([])
   end

data/test/dummy/test/models/image_test.rb

@@ -21,4 +21,15 @@ class ImageTest < ActiveSupport::TestCase
 
     refute @image.update(:resource => resource)
   end
+
+  test "image url changing the storage name" do
+    d = "foobar"
+    @image.update!(:resource => fogged_resources(:resource_png_1))
+    Fogged.storage.directories.create(:key => d)
+
+    url = Fogged.with_directory(d) { @image.resource.url }
+
+    assert url.include?(d)
+    refute @image.resource.url.include?(d)
+  end
 end

data/test/fixtures/fogged/resources.yml

@@ -7,19 +7,23 @@ resource_text_<%= n %>:
   token: qwertzuiop<%= n %>
 <% end %>
 
-resource_mov:
+<% 5.times do |n| %>
+resource_mov_<%= n %>:
   extension: mov
   uploading: false
   content_type: video/quicktime
-  name: resource mov 1
-  token: 1234567890mov
+  name: resource mov <%= n %>
+  token: mov<%= n %>
+<% end %>
 
-resource_png:
+<% 5.times do |n| %>
+resource_png_<%= n %>:
   extension: png
   uploading: false
   content_type: image/png
-  name: resource png 1
-  token: 1234567890png
+  name: resource png <%= n %>
+  token: png<%= n %>
+<% end %>
 
 encoding_resource:
   extension: mov
@@ -29,3 +33,11 @@ encoding_resource:
   token: 1234567890mov
   encoding_job_id: 1234567890
   encoding_progress: 10
+
+resource_thumbnail:
+  extension: png
+  uploading: false
+  content_type: image/png
+  name: resource png thumbnail
+  token: pngthumbnail
+  encoding_progress: 0

data/test/fogged_test.rb

@@ -4,4 +4,24 @@ class FoggedTest < ActiveSupport::TestCase
   test "truth" do
     assert_kind_of Module, Fogged
   end
+
+  test "should return directory public url" do
+    assert_equal "https://test.s3.amazonaws.com/", Fogged.directory_public_url("test")
+  end
+
+  test "should return resources public url" do
+    assert_equal "https://test.s3.amazonaws.com/", Fogged.resources_public_url
+  end
+
+  test "should check if file exists" do
+    refute Fogged.file_exists?("foobar")
+
+    Fogged.resources.files.create(
+      :key => "foobar",
+      :body => "foo",
+      :public => true
+    )
+
+    assert Fogged.file_exists?("foobar")
+  end
 end

data/test/jobs/fogged/resources/aws_thumbnail_job_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+
+module Fogged
+  module Resources
+    class AWSThumbnailJobTest < ActiveSupport::TestCase
+      def setup
+        super
+        @resource = fogged_resources(:resource_thumbnail)
+        Fogged.thumbnail_sizes = %w(50x50 100x100)
+      end
+
+      test "should thumbnail the image" do
+        in_a_fork do
+          require "mini_magick"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
+
+          Resource.any_instance.expects(:url).twice.returns("http://lorempixel.com/800/600/cats")
+
+          AWSThumbnailJob.perform_now(@resource)
+
+          Fogged.thumbnail_sizes.each_with_index do |size, index|
+            key = @resource.send(:fogged_name_for, :thumbnails, index)
+            f = Fogged.resources.files.get(key)
+            Tempfile.open(["thumbnail", ".png"]) do |t|
+              t.write(f.body)
+              t.flush
+              output_size = FastImage.size(t.path)
+              assert_equal size, "#{output_size.first}x#{output_size.second}"
+            end
+          end
+          refute @resource.encoding?
+          assert_equal 100, @resource.reload.encoding_progress
+        end
+      end
+
+      test "should not thumbnail with unknown image" do
+        in_a_fork do
+          require "mini_magick"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
+
+          Resource.any_instance.expects(:url).returns("http://localhost:7777/image")
+
+          assert_raise(MiniMagick::Error) do
+            AWSThumbnailJob.perform_now(@resource)
+          end
+        end
+      end
+    end
+  end
+end

data/test/jobs/fogged/resources/zencoder_poll_job_test.rb

@@ -6,13 +6,14 @@ module Fogged
       def setup
         super
         @resource = fogged_resources(:encoding_resource)
-        @job = ZencoderPollJob.new(@resource.id)
       end
 
       test "should poll job with status success" do
         in_a_fork do
           require "zencoder"
           require "delayed_job_active_record"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
 
           Zencoder::Job.expects(:progress).with("1234567890").returns(
             OpenStruct.new(:body => progress_output("finished"))
@@ -22,7 +23,7 @@ module Fogged
           )
 
           assert_no_difference("Delayed::Job.count") do
-            @job.perform
+            ZencoderPollJob.perform_now(@resource)
           end
           refute @resource.reload.encoding?
           assert_equal 800, @resource.width
@@ -36,13 +37,15 @@ module Fogged
           in_a_fork do
             require "zencoder"
             require "delayed_job_active_record"
+            Rails.application.config.active_job.queue_adapter = :delayed_job
+            Fogged.configure
 
             Zencoder::Job.expects(:progress).with("1234567890").returns(
               OpenStruct.new(:body => progress_output(status))
             )
 
             assert_difference("Delayed::Job.count") do
-              @job.perform
+              ZencoderPollJob.perform_now(@resource)
             end
             assert @resource.reload.encoding?
             assert_equal 55, @resource.encoding_progress
@@ -54,6 +57,7 @@ module Fogged
         in_a_fork do
           require "zencoder"
           require "delayed_job_active_record"
+          Fogged.configure
 
           Zencoder::Job.expects(:progress).with("1234567890").returns(
             OpenStruct.new(:body => progress_output("unknown"))
@@ -61,7 +65,7 @@ module Fogged
 
           assert_raise(ArgumentError) do
             assert_no_difference("Delayed::Job.count") do
-              @job.perform
+              ZencoderPollJob.perform_now(@resource)
             end
           end
         end

data/test/models/fogged/resource_test.rb

@@ -48,7 +48,7 @@ module Fogged
     end
 
     test "should process resource image" do
-      @resource = fogged_resources(:resource_png)
+      @resource = fogged_resources(:resource_png_1)
 
       @resource.process!
       assert_equal 800, @resource.width
@@ -57,7 +57,7 @@ module Fogged
     end
 
     test "should process resource video" do
-      @resource = fogged_resources(:resource_mov)
+      @resource = fogged_resources(:resource_mov_1)
 
       @resource.process!
 
@@ -69,10 +69,10 @@ module Fogged
       in_a_fork do
         require "zencoder"
         require "delayed_job_active_record"
+        Rails.application.config.active_job.queue_adapter = :delayed_job
+        Fogged.configure
 
-        Fogged.zencoder_enabled = true
-
-        @resource = fogged_resources(:resource_mov)
+        @resource = fogged_resources(:resource_mov_1)
         Zencoder::Job.expects(:create).returns(
           OpenStruct.new(:body => create_output)
         )

data/test/models/fogged/resources/aws_encoder_test.rb

@@ -3,42 +3,137 @@ require "test_helper"
 module Fogged
   module Resources
     class AWSEncoderTest < ActiveSupport::TestCase
-      def setup
-        super
-        @resource = fogged_resources(:resource_mov)
-        @encoder = AWSEncoder.new(@resource)
+      test "should not encode video file without delayed job" do
+        resource = fogged_resources(:resource_mov_1)
+        encoder = AWSEncoder.new(resource)
+
+        in_a_fork do
+          encoder.encode!
+
+          refute resource.encoding?
+          refute resource.encoding_job_id
+        end
+      end
+
+      test "should not encode video file without zencoder" do
+        resource = fogged_resources(:resource_mov_2)
+        encoder = AWSEncoder.new(resource)
+
+        in_a_fork do
+          require "delayed_job_active_record"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
+
+          assert_no_difference("Delayed::Job.count") do
+            encoder.encode!
+          end
+
+          refute resource.encoding?
+          refute resource.encoding_job_id
+        end
       end
 
       test "should encode video file" do
+        resource = fogged_resources(:resource_mov_3)
+        encoder = AWSEncoder.new(resource)
+
         in_a_fork do
           require "zencoder"
           require "delayed_job_active_record"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
 
           Zencoder::Job.expects(:create).returns(
             OpenStruct.new(:body => create_output)
           )
           assert_difference("Delayed::Job.count") do
-            @encoder.encode!
+            encoder.encode!
           end
 
-          assert @resource.encoding?
-          assert_equal 0, @resource.encoding_progress
-          assert_equal "1234567890", @resource.encoding_job_id
+          assert resource.encoding?
+          assert_equal 0, resource.encoding_progress
+          assert_equal "1234567890", resource.encoding_job_id
         end
       end
 
-      test "should not encode image file" do
+      test "should not encode image file without delayed job" do
+        resource = fogged_resources(:resource_png_1)
+        encoder = AWSEncoder.new(resource)
+
         in_a_fork do
-          require "delayed_job_active_record"
+          encoder.encode!
 
-          @resource = fogged_resources(:resource_png)
-          @encoder = AWSEncoder.new(@resource)
+          refute resource.encoding?
+          refute resource.encoding_job_id
+        end
+      end
+
+      test "should not encode image file without minimagick" do
+        resource = fogged_resources(:resource_png_2)
+        encoder = AWSEncoder.new(resource)
+
+        in_a_fork do
+          require "delayed_job_active_record"
+          Fogged.configure
 
           assert_no_difference("Delayed::Job.count") do
-            @encoder.encode!
+            encoder.encode!
           end
-          refute @resource.encoding?
-          refute @resource.encoding_job_id
+          refute resource.encoding?
+          refute resource.encoding_job_id
+        end
+      end
+
+      test "should encode image file" do
+        resource = fogged_resources(:resource_png_3)
+        encoder = AWSEncoder.new(resource)
+
+        in_a_fork do
+          require "mini_magick"
+          require "delayed_job_active_record"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure
+          Fogged.thumbnail_sizes = %w(50x50 60x60)
+
+          assert_difference("Delayed::Job.count") do
+            encoder.encode!
+          end
+          assert resource.encoding?
+          assert_equal 0, resource.encoding_progress
+        end
+      end
+
+      test "should encode video with additional outputs" do
+        resource = fogged_resources(:resource_mov_3)
+        encoder = AWSEncoder.new(resource)
+
+        in_a_fork do
+          require "zencoder"
+          require "delayed_job_active_record"
+          Rails.application.config.active_job.queue_adapter = :delayed_job
+          Fogged.configure do |config|
+            config.zencoder_additional_outputs do |bucket, res|
+              [
+                {
+                  :url => "s3://#{bucket}/#{res.token}-custom1.mp4",
+                  :video_codec => "mpeg4",
+                  :quality => 1,
+                  :public => 1
+                }
+              ]
+            end
+          end
+
+          Zencoder::Job.expects(:create).with { |options| assert_equal 4, options[:output].size }.returns(
+            OpenStruct.new(:body => create_output)
+          )
+          assert_difference("Delayed::Job.count") do
+            encoder.encode!
+          end
+
+          assert resource.encoding?
+          assert_equal 0, resource.encoding_progress
+          assert_equal "1234567890", resource.encoding_job_id
         end
       end
 

data/test/models/fogged/resources/encoder_test.rb

@@ -5,7 +5,7 @@ module Fogged
     class EncoderTest < ActiveSupport::TestCase
       def setup
         super
-        @resource = fogged_resources(:resource_mov)
+        @resource = fogged_resources(:resource_mov_1)
       end
 
       test "should aws encoder" do

data/test/test_helper.rb

@@ -7,20 +7,23 @@ SimpleCov.start "rails"
 require "minitest/reporters"
 Minitest::Reporters.use!(Minitest::Reporters::DefaultReporter.new)
 
-require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require File.expand_path("../../test/dummy/config/environment.rb",  __FILE__)
+ActiveRecord::Migrator.migrations_paths = [File.expand_path("../../test/dummy/db/migrate", __FILE__)]
+ActiveRecord::Migrator.migrations_paths << File.expand_path('../../db/migrate', __FILE__)
+
 require "rails/test_help"
 require "mocha/mini_test"
 
-Rails.backtrace_cleaner.remove_silencers!
-
-# Run any available migration from dummy app
-ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
 
 # Load fixtures from the engine
-ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+if ActiveSupport::TestCase.respond_to?(:fixture_path=)
+  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
+  ActiveSupport::TestCase.fixtures :all
+end
 Fogged.test_mode!
 
 class ActiveSupport::TestCase