carrierwave_backgrounder 0.4.2 → 1.0.0.beta

data/spec/integrations/process_in_background_spec.rb

@@ -0,0 +1,75 @@
+require 'rails_helper'
+
+RSpec.describe '::process_in_background', clear_images: true do
+  let(:admin) { Admin.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      admin.update(avatar: load_file('test-1.jpg'))
+    end
+
+    it 'stores the original file' do
+      expect(file_count("spec/support/dummy_app/public/uploads/admin/avatar/#{admin.id}")).to eql(1)
+      expect(admin.avatar.file.present?).to be(true)
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(admin.avatar_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      admin.update(avatar: load_file('test-1.jpg'))
+      expect(admin.avatar_processing).to be(true)
+      process_latest_sidekiq_job
+      admin.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = admin.avatar.versions.keys.map { |key| admin.avatar.send(key).current_path }
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(admin.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { admin.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:admin) {
+      Sidekiq::Testing.inline! do
+        Admin.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    it 'removes the attachment' do
+      expect(admin.reload.avatar.file.nil?).to be(false)
+
+      admin.remove_avatar = true
+      admin.save!
+
+      expect(admin.avatar.file.nil?).to be(true)
+    end
+  end
+end

data/spec/integrations/store_in_background_multi_upload_spec.rb

@@ -0,0 +1,87 @@
+require 'rails_helper'
+
+RSpec.describe '::store_in_background multi-upload support', clear_images: true do
+  let(:user) { User.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+      user.update(images: load_files('test-1.jpg', 'test-2.jpg'))
+    end
+
+    it 'creates a temp file and stores the path' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(2)
+      expect(user.images_tmp).to include('test-1.jpg')
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(user.images_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      user.update(images: load_files('test-1.jpg','test-2.jpg'))
+      expect(user.images_processing).to be(true)
+      process_latest_sidekiq_job
+      user.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = AvatarUploader.versions.keys.map { |key| user.images.map { |i| i.send(key).current_path } }.flatten
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'sets the <column>_tmp to nil' do
+      expect(user.avatar_tmp).to be_nil
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(user.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { user.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(images: load_files('test-1.jpg'))
+      end
+    }
+
+    before do
+      expect(user.reload.images.present?).to be(true)
+
+      user.remove_images = true
+      user.save!
+    end
+
+    it 'removes the attachment' do
+      expect(user.images.present?).to be(false)
+    end
+
+    it 'does not enqueue a new job' do
+      expect(Sidekiq::Queues["carrierwave"].size).to be(0)
+    end
+
+  end
+end

data/spec/integrations/store_in_background_spec.rb

@@ -0,0 +1,86 @@
+require 'rails_helper'
+
+RSpec.describe '::store_in_background', clear_images: true do
+  let(:user) { User.new }
+
+  context 'when assigning an asset' do
+    before(:each) do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+      user.update(avatar: load_file('test-1.jpg'))
+    end
+
+    it 'creates a temp file and stores the path' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(1)
+      expect(user.avatar_tmp).to include('test-1.jpg')
+    end
+
+    it 'creates a background job in carrierwave queue' do
+      expect(Sidekiq::Queues["carrierwave"].size).to eql(1)
+    end
+
+    it 'sets the <column>_processing flag to true' do
+      expect(user.avatar_processing).to be(true)
+    end
+  end
+
+  context 'when processing the worker' do
+    before do
+      user.update(avatar: load_file('test-1.jpg'))
+      expect(user.avatar_processing).to be(true)
+      process_latest_sidekiq_job
+      user.reload
+    end
+
+    it 'creates the versions' do
+      version_paths = user.avatar.versions.keys.map { |key| user.avatar.send(key).current_path }
+      version_paths.each { |path| expect(File.exist? path).to be(true) }
+    end
+
+    it 'sets the <column>_tmp to nil' do
+      expect(user.avatar_tmp).to be_nil
+    end
+
+    it 'removes the files tmp directory' do
+      expect(file_count('spec/support/dummy_app/tmp/images')).to eql(0)
+    end
+
+    it 'sets the <column>_processing flag to false' do
+      expect(user.avatar_processing).to be(false)
+    end
+  end
+
+  context 'when saving a record' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    it 'does not enqueue a new job' do
+      expect { user.reload.save }.to_not change(Sidekiq::Queues["carrierwave"], :size)
+    end
+  end
+
+  context 'when setting a column for removal' do
+    let!(:user) {
+      Sidekiq::Testing.inline! do
+        User.create(avatar: load_file('test-1.jpg'))
+      end
+    }
+
+    before do
+      expect(user.reload.avatar.file.nil?).to be(false)
+
+      user.remove_avatar = true
+      user.save!
+    end
+
+    it 'removes the attachment' do
+      expect(user.avatar.file.nil?).to be(true)
+    end
+
+    it 'does not enqueue a new job' do
+      expect(Sidekiq::Queues["carrierwave"].size).to be(0)
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+ENV['RAILS_ENV'] ||= 'test'
+
+require_relative 'support/dummy_app/config/environment'
+require_relative 'support/global_macros'
+require 'sidekiq/testing'
+require 'rspec/rails'
+require 'backgrounder/railtie'
+
+begin
+  ActiveRecord::Migration.maintain_test_schema!
+rescue ActiveRecord::PendingMigrationError => e
+  abort e.to_s.strip
+end
+
+RSpec.configure do |config|
+  config.include GlobalMacros
+
+  config.after(:example, clear_images: true) do
+    Sidekiq::Queues.clear_all
+    FileUtils.rm_rf Dir.glob("spec/support/dummy_app/tmp/images/*")
+    FileUtils.rm_rf Dir.glob("spec/support/dummy_app/public/uploads/*")
+  end
+end
+
+ActiveRecord::Schema.verbose = false
+load 'support/dummy_app/db/schema.rb' # use db agnostic schema by default

data/spec/spec_helper.rb

@@ -2,6 +2,8 @@
 require 'rubygems'
 require 'bundler/setup'
 require 'logger'
+require 'pry'
+require 'rails'
 require 'carrierwave_backgrounder'
 
 module WarningSuppression

data/spec/support/dummy_app/Gemfile

@@ -0,0 +1,49 @@
+source "https://rubygems.org"
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+
+ruby "3.0.0"
+
+# Bundle edge Rails instead: gem "rails", github: "rails/rails", branch: "main"
+gem "rails", "~> 7.0.6"
+
+# Use sqlite3 as the database for Active Record
+gem "sqlite3", "~> 1.4"
+
+# Use the Puma web server [https://github.com/puma/puma]
+# gem "puma", "~> 5.0"
+
+gem 'carrierwave'
+gem 'carrierwave_backgrounder', path: "../../../"
+gem 'sidekiq'
+
+# Build JSON APIs with ease [https://github.com/rails/jbuilder]
+# gem "jbuilder"
+
+# Use Redis adapter to run Action Cable in production
+# gem "redis", "~> 4.0"
+
+# Use Kredis to get higher-level data types in Redis [https://github.com/rails/kredis]
+# gem "kredis"
+
+# Use Active Model has_secure_password [https://guides.rubyonrails.org/active_model_basics.html#securepassword]
+# gem "bcrypt", "~> 3.1.7"
+
+# Windows does not include zoneinfo files, so bundle the tzinfo-data gem
+gem "tzinfo-data", platforms: %i[ mingw mswin x64_mingw jruby ]
+
+# Use Active Storage variants [https://guides.rubyonrails.org/active_storage_overview.html#transforming-images]
+# gem "image_processing", "~> 1.2"
+
+# Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
+# gem "rack-cors"
+
+group :development, :test do
+  # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
+  gem "debug", platforms: %i[ mri mingw x64_mingw ]
+end
+
+group :development do
+  # Speed up commands on slow machines / big apps [https://github.com/rails/spring]
+  # gem "spring"
+end
+

data/spec/support/dummy_app/README.md

@@ -0,0 +1,24 @@
+# README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...

data/spec/support/dummy_app/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require_relative "config/application"
+
+Rails.application.load_tasks

data/spec/support/dummy_app/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::API
+end

data/spec/support/dummy_app/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/spec/support/dummy_app/app/models/admin.rb

@@ -0,0 +1,10 @@
+class Admin < ApplicationRecord
+  # Single attachment support
+  mount_uploader :avatar, AvatarUploader
+  process_in_background :avatar
+
+  # Multi attachment support
+  mount_uploaders :images, AvatarUploader
+  process_in_background :images
+  serialize :images, JSON
+end

data/spec/support/dummy_app/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/spec/support/dummy_app/app/models/user.rb

@@ -0,0 +1,10 @@
+class User < ApplicationRecord
+  # Single attachment support
+  mount_uploader :avatar, AvatarUploader
+  store_in_background :avatar
+
+  # Multi attachment support
+  mount_uploaders :images, AvatarUploader
+  store_in_background :images
+  serialize :images, JSON
+end

data/spec/support/dummy_app/app/uploaders/avatar_uploader.rb

@@ -0,0 +1,67 @@
+require 'carrierwave'
+
+class AvatarUploader < CarrierWave::Uploader::Base
+  # Include RMagick or MiniMagick support:
+  # include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
+  include ::CarrierWave::Backgrounder::Delay
+
+  # Choose what kind of storage to use for this uploader:
+  # storage :aws
+  storage :file
+  # storage :fog
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  def cache_dir
+    "../tmp/images"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url(*args)
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # ActionController::Base.helpers.asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process scale: [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  # Create different versions of your uploaded files:
+  version :thumb do
+    process resize_to_fit: [50, 50]
+  end
+
+  version :large_1920 do
+    process resize_to_limit: [1920, 1920]
+  end
+
+  version :medium_1024 do
+    process resize_to_limit: [1024, 1024]
+  end
+
+  version :small_640 do
+    process resize_to_limit: [640, 640]
+  end
+
+  # Add an allowlist of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_allowlist
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+end

data/spec/support/dummy_app/bin/bundle

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+#
+# This file was generated by Bundler.
+#
+# The application 'bundle' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require "rubygems"
+
+m = Module.new do
+  module_function
+
+  def invoked_as_script?
+    File.expand_path($0) == File.expand_path(__FILE__)
+  end
+
+  def env_var_version
+    ENV["BUNDLER_VERSION"]
+  end
+
+  def cli_arg_version
+    return unless invoked_as_script? # don't want to hijack other binstubs
+    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
+    bundler_version = nil
+    update_index = nil
+    ARGV.each_with_index do |a, i|
+      if update_index && update_index.succ == i && a =~ Gem::Version::ANCHORED_VERSION_PATTERN
+        bundler_version = a
+      end
+      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
+      bundler_version = $1
+      update_index = i
+    end
+    bundler_version
+  end
+
+  def gemfile
+    gemfile = ENV["BUNDLE_GEMFILE"]
+    return gemfile if gemfile && !gemfile.empty?
+
+    File.expand_path("../../Gemfile", __FILE__)
+  end
+
+  def lockfile
+    lockfile =
+      case File.basename(gemfile)
+      when "gems.rb" then gemfile.sub(/\.rb$/, gemfile)
+      else "#{gemfile}.lock"
+      end
+    File.expand_path(lockfile)
+  end
+
+  def lockfile_version
+    return unless File.file?(lockfile)
+    lockfile_contents = File.read(lockfile)
+    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
+    Regexp.last_match(1)
+  end
+
+  def bundler_version
+    @bundler_version ||=
+      env_var_version || cli_arg_version ||
+        lockfile_version
+  end
+
+  def bundler_requirement
+    return "#{Gem::Requirement.default}.a" unless bundler_version
+
+    bundler_gem_version = Gem::Version.new(bundler_version)
+
+    requirement = bundler_gem_version.approximate_recommendation
+
+    return requirement unless Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.7.0")
+
+    requirement += ".a" if bundler_gem_version.prerelease?
+
+    requirement
+  end
+
+  def load_bundler!
+    ENV["BUNDLE_GEMFILE"] ||= gemfile
+
+    activate_bundler
+  end
+
+  def activate_bundler
+    gem_error = activation_error_handling do
+      gem "bundler", bundler_requirement
+    end
+    return if gem_error.nil?
+    require_error = activation_error_handling do
+      require "bundler/version"
+    end
+    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
+    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
+    exit 42
+  end
+
+  def activation_error_handling
+    yield
+    nil
+  rescue StandardError, LoadError => e
+    e
+  end
+end
+
+m.load_bundler!
+
+if m.invoked_as_script?
+  load Gem.bin_path("bundler", "bundle")
+end

data/spec/support/dummy_app/bin/rails

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path("../config/application", __dir__)
+require_relative "../config/boot"
+require "rails/commands"

data/spec/support/dummy_app/bin/rake

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../config/boot"
+require "rake"
+Rake.application.run

data/spec/support/dummy_app/bin/setup

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require "fileutils"
+
+# path to your application root.
+APP_ROOT = File.expand_path("..", __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+FileUtils.chdir APP_ROOT do
+  # This script is a way to set up or update your development environment automatically.
+  # This script is idempotent, so that you can run it at any time and get an expectable outcome.
+  # Add necessary setup steps to this file.
+
+  puts "== Installing dependencies =="
+  system! "gem install bundler --conservative"
+  system("bundle check") || system!("bundle install")
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?("config/database.yml")
+  #   FileUtils.cp "config/database.yml.sample", "config/database.yml"
+  # end
+
+  puts "\n== Preparing database =="
+  system! "bin/rails db:prepare"
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! "bin/rails log:clear tmp:clear"
+
+  puts "\n== Restarting application server =="
+  system! "bin/rails restart"
+end

data/spec/support/dummy_app/config/application.rb

@@ -0,0 +1,39 @@
+require_relative "boot"
+
+require "rails"
+# Pick the frameworks you want:
+require "active_model/railtie"
+require "active_job/railtie"
+require "active_record/railtie"
+# require "active_storage/engine"
+# require "action_controller/railtie"
+# require "action_mailer/railtie"
+# require "action_mailbox/engine"
+# require "action_text/engine"
+# require "action_view/railtie"
+# require "action_cable/engine"
+# require "rails/test_unit/railtie"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+
+module DummyApp
+  class Application < Rails::Application
+    # Initialize configuration defaults for originally generated Rails version.
+    config.load_defaults 7.0
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+
+    # Only loads a smaller set of middleware suitable for API only apps.
+    # Middleware like session, flash, cookies can be added back manually.
+    # Skip views, helpers and assets when generating a new resource.
+    config.api_only = true
+  end
+end

data/spec/support/dummy_app/config/boot.rb

@@ -0,0 +1,3 @@
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+
+require "bundler/setup" # Set up gems listed in the Gemfile.