hyrax 2.6.0 → 2.9.0

data/spec/services/hyrax/workflow/workflow_factory_spec.rb

@@ -1,26 +0,0 @@
-require 'rails_helper'
-
-RSpec.describe Hyrax::Workflow::WorkflowFactory do
-  describe '.create' do
-    let(:work) { create(:work, with_admin_set: { with_permission_template: true }) }
-    let(:permission_template) { Hyrax::PermissionTemplate.find_by!(source_id: work.admin_set_id) }
-    let(:workflow) { create(:workflow, active: true, permission_template: permission_template) }
-    let(:attributes) { {} }
-    let(:user) { create(:user) }
-    let(:deposit_action) { Sipity::WorkflowAction.create!(workflow: workflow, name: 'start') }
-
-    subject { described_class.create(work, attributes, user) }
-
-    it 'creates a Sipity::Entity, assign entity specific responsibility (but not to the full workflow) then runs the WorkflowActionService' do
-      expect(Hyrax::Workflow::WorkflowActionService).to receive(:run).with(
-        subject: kind_of(Hyrax::WorkflowActionInfo), action: deposit_action
-      )
-      expect do
-        expect do
-          subject
-        end.to change { Sipity::Entity.count }.by(1)
-                                              .and change { Sipity::EntitySpecificResponsibility.count }.by(1)
-      end.not_to change { Sipity::WorkflowResponsibility.count }
-    end
-  end
-end

data/spec/services/hyrax/workflow/workflow_importer_spec.rb

@@ -1,241 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Hyrax::Workflow::WorkflowImporter do
-  let(:permission_template) { create(:permission_template) }
-  let(:data) do
-    {
-      workflows: [
-        {
-          name: "ulra_submission",
-          label: "This is the label",
-          description: "This description could get really long",
-          allows_access_grant: true,
-          actions: [{
-            name: "approve",
-            transition_to: "reviewed",
-            from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
-          }]
-        }
-      ]
-    }
-  end
-  let(:validator) { double(call: true) }
-  let(:importer) { described_class.new(data: {}, permission_template: permission_template, validator: validator) }
-
-  subject { importer }
-
-  before { described_class.clear_load_errors! }
-
-  describe '#default_validator' do
-    subject { importer.send(:default_validator) }
-
-    it { is_expected.to respond_to(:call) }
-  end
-
-  describe '#default_schema' do
-    subject { importer.send(:default_schema) }
-
-    it { is_expected.to respond_to(:call) }
-  end
-
-  it 'validates the data against the schema' do
-    subject
-    expect(validator).to have_received(:call).with(data: subject.send(:data), schema: subject.send(:schema), logger: subject.send(:logger))
-  end
-
-  describe '.load_workflow_for' do
-    it 'will assocate the workflows' do
-      expect do
-        described_class.load_workflow_for(permission_template: permission_template)
-      end.to change { Sipity::Workflow.count }
-    end
-  end
-
-  describe '.generate_from_hash' do
-    it 'creates the requisite data from the configuration' do
-      number_of_workflows_created = 1
-      expect(Hyrax::Workflow::WorkflowPermissionsGenerator).to receive(:call).and_call_original
-      expect(Hyrax::Workflow::SipityActionsGenerator).to receive(:call).and_call_original
-      result = nil
-      expect do
-        result = described_class.generate_from_hash(data: data, permission_template: permission_template)
-      end.to change { Sipity::Workflow.count }.by(number_of_workflows_created).and(change { permission_template.available_workflows.count }.by(number_of_workflows_created))
-      expect(result).to match_array(kind_of(Sipity::Workflow))
-      expect(described_class.load_errors).to be_empty
-      first_workflow = result.first
-      expect(first_workflow.label).to eq "This is the label"
-      expect(first_workflow.description).to eq "This description could get really long"
-      expect(first_workflow.allows_access_grant?).to be true
-    end
-  end
-
-  describe 'data generation' do
-    let(:logger) { Logger.new(STDOUT) }
-    let(:data) { { workflows: [{ name: '', actions: [] }] } }
-    let(:importer) { described_class.new(data: data, permission_template: permission_template, logger: logger) }
-
-    describe 'with invalid data' do
-      it 'logs the output' do
-        expect(logger).to receive(:error).with(kind_of(String))
-        expect { importer }.to raise_error(RuntimeError)
-      end
-    end
-
-    describe 'with very invalid schema' do
-      let(:data) { { workflows: [{ name: '' }] } }
-
-      it 'logs the output' do
-        expect(logger).to receive(:error).with(kind_of(String))
-        expect { importer }.to raise_error(RuntimeError)
-      end
-    end
-  end
-
-  context "when I load JSON twice" do
-    let!(:workflow1) { described_class.generate_from_hash(data: data, permission_template: permission_template).first }
-    let(:workflow2) { described_class.generate_from_hash(data: data, permission_template: permission_template).first }
-    let(:workflow2_errors) { described_class.load_errors }
-
-    context 'with the same data' do
-      it "workflow and workflow states do not change" do
-        workflow1
-        # If the Sipity::WorkflowState IDs or Sipity::Workflow IDs change, we are going to have a serious problem upstream
-        expect do
-          expect do
-            workflow2
-          end.not_to change { Sipity::WorkflowState.all.pluck(:id).sort }
-        end.not_to change { Sipity::Workflow.all.pluck(:id).sort }
-        expect(workflow2).to eq(workflow1)
-        expect(workflow2_errors).to be_empty
-      end
-    end
-
-    context 'with different data' do
-      let(:action_name)  { "awesome action" }
-      let(:state_name)   { "awesome state" }
-      let(:workflow2) { described_class.generate_from_hash(data: updated_data, permission_template: permission_template).first }
-      let(:updated_data) do
-        {
-          workflows: [
-            {
-              name: workflow_name,
-              label: "This is the label for the second json",
-              description: "This description could get really long",
-              actions: [{
-                name: action_name,
-                transition_to: state_name,
-                from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
-              }]
-            }
-          ]
-        }
-      end
-
-      context 'that includes a workflow_name changes' do
-        let(:workflow_name) { "awsome workflow" }
-
-        it "creates a new workflow (preserving the old)" do
-          expect(workflow2).not_to eq(workflow1)
-          expect(Sipity::Workflow.count).to eq(2)
-          expect(Sipity::WorkflowState.count).to eq(4)
-          expect(workflow2_errors).to be_empty
-        end
-      end
-
-      context "that keeps the same workflow_name name" do
-        let(:workflow_name) { "ulra_submission" }
-
-        it "preserves state names identified in actions > transition_to and actions> from_states > names hash key" do
-          expect(workflow2.label).not_to eq(workflow1.label)
-          expect(workflow2).to eq(workflow1)
-          expect(Sipity::Workflow.count).to eq(1)
-          expect(workflow2_errors).to be_empty
-          expect(Sipity::WorkflowAction.count).to eq(1)
-          expect(Sipity::WorkflowState.count).to eq(2)
-        end
-
-        context "when entities are in a state that is no longer included" do
-          let(:data) do
-            {
-              workflows: [
-                {
-                  name: "ulra_submission",
-                  label: "This is the label",
-                  description: "This description could get really long",
-                  allows_access_grant: true,
-                  actions: [{
-                    name: "approve",
-                    transition_to: "reviewed",
-                    from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }]
-                  }, {
-                    name: "decline",
-                    transition_to: "declined",
-                    from_states: [{ names: ['under_review'], roles: ['ulra_reviewing'] }]
-                  }]
-                }
-              ]
-            }
-          end
-          let(:workflow_state) { workflow1.reload.workflow_states.find_by(name: 'declined') }
-          let!(:entity) { Sipity::Entity.create(workflow_state: workflow_state, proxy_for_global_id: "abc123", workflow_id: workflow1.id) }
-
-          it "reports an error and does not update the WorkflowStates" do
-            expect do
-              expect do
-                expect do
-                  workflow2
-                end.not_to change { Sipity::Workflow.count }
-              end.not_to change { Sipity::WorkflowState.count }
-            end.not_to change { Sipity::WorkflowAction.count }
-            expect(workflow2_errors).to eq(["The workflow: ulra_submission has not been updated.  " \
-                                            "You are removing a state: #{workflow_state.name} with " \
-                                            "1 entity/ies.  A state may not be removed while it has " \
-                                            "active entities!"])
-          end
-        end
-      end
-    end
-  end
-
-  context 'data generation' do
-    let(:invalid_data) do
-      {
-        workflows: [
-          {
-            name: "ulra_submission",
-            label: "",
-            description: "",
-            actions: [{ name: "approve", transition_to: "reviewed", from_states: [{ names: ["under_review"], roles: ["ulra_reviewing"] }] }]
-          }
-        ]
-      }
-    end
-
-    context 'with incomplete data' do
-      it 'will not load any of the data' do
-        expect do
-          expect do
-            expect do
-              expect do
-                described_class.generate_from_hash(data: invalid_data, permission_template: permission_template)
-              end.to raise_error(RuntimeError)
-            end.not_to change { Sipity::Workflow.count }
-          end.not_to change { Sipity::WorkflowAction.count }
-        end.not_to change { Sipity::WorkflowState.count }
-      end
-
-      it 'will not amend when new data is invalid' do
-        described_class.generate_from_hash(data: data, permission_template: permission_template)
-        expect do
-          expect do
-            expect do
-              expect do
-                described_class.generate_from_hash(data: invalid_data, permission_template: permission_template)
-              end.to raise_error(RuntimeError)
-            end.not_to change { Sipity::Workflow.count }
-          end.not_to change { Sipity::WorkflowAction.count }
-        end.not_to change { Sipity::WorkflowState.count }
-      end
-    end
-  end
-end

data/spec/services/hyrax/workflow/workflow_permissions_generator_spec.rb

@@ -1,39 +0,0 @@
-require "spec_helper"
-
-module Hyrax
-  module Workflow
-    RSpec.describe WorkflowPermissionsGenerator do
-      let(:workflow) { Sipity::Workflow.new(name: 'Hello') }
-      let(:workflow_permissions_configuration) do
-        [
-          { role: "work_submitting" },
-          { role: "etd_reviewing" }
-        ]
-      end
-
-      before do
-        workflow_permissions_configuration.each do |config|
-          Sipity::Role.find_or_create_by!(name: config.fetch(:role))
-        end
-      end
-
-      it 'exposes .call as a convenience method' do
-        expect_any_instance_of(described_class).to receive(:call)
-        described_class.call(workflow: workflow, workflow_permissions_configuration: workflow_permissions_configuration)
-      end
-
-      subject { described_class.new(workflow: workflow, workflow_permissions_configuration: workflow_permissions_configuration) }
-
-      it 'will create groups and assign permissions accordingly' do
-        allow_any_instance_of(PermissionGenerator).to receive(:call)
-        subject.call
-
-        # And it won't keep creating things
-        [:update_attribute, :update_attributes, :update_attributes!, :save, :save!, :update, :update!].each do |method_names|
-          expect_any_instance_of(ActiveRecord::Base).not_to receive(method_names)
-        end
-        subject.call
-      end
-    end
-  end
-end

data/spec/services/hyrax/workflow/workflow_schema_spec.rb

@@ -1,86 +0,0 @@
-module Hyrax
-  module Workflow
-    RSpec.describe 'WorkflowSchema' do
-      let(:valid_data) do
-        {
-          workflows: [
-            {
-              name: "valid",
-              allows_access_grant: true,
-              actions: [
-                {
-                  name: "finalize_digitization",
-                  from_states: [{ names: ["pending"], roles: ['finalizing_digitation_review'] }],
-                  transition_to: "metadata_review"
-                }, {
-                  name: "finalize_metadata",
-                  from_states: [{ names: ["metadata_review"], roles: ['finalizing_metadata_review'] }],
-                  transition_to: "final_review",
-                  notifications: [
-                    {
-                      name: notification_name, notification_type: Sipity::Notification::NOTIFICATION_TYPE_EMAIL, to: ['finalizing_metadata_review']
-                    }
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      end
-
-      let(:notification_name) { 'DoTheThing' }
-
-      let(:invalid_data) do
-        {
-          workflows: [
-            {
-              actions: [
-                { name: "finalize_digitization", from_states: [{ names: ["pending"], roles: [] }], transition_to: "metadata_review" }
-              ]
-            }
-          ]
-        }
-      end
-
-      before do
-        class ::DoTheThing
-        end
-      end
-
-      after do
-        Object.send(:remove_const, :DoTheThing)
-      end
-
-      it 'validates valid data by returning an empty message' do
-        expect(WorkflowSchema.call(valid_data).messages).to be_empty
-      end
-
-      it 'reports invalid data via the returned messages' do
-        expect(WorkflowSchema.call(invalid_data).messages).not_to be_empty
-      end
-
-      describe 'notification names' do
-        context 'with an uninitialized constant' do
-          let(:notification_name) { 'FooBar' }
-
-          it 'is invalid' do
-            expect(WorkflowSchema.call(valid_data).messages).not_to be_empty
-          end
-        end
-
-        context 'within a namespace' do
-          before do
-            class DoTheThing
-            end
-          end
-          after { Hyrax::Workflow.send(:remove_const, :DoTheThing) }
-          let(:notification_name) { 'Hyrax::Workflow::DoTheThing' }
-
-          it 'returns an empty message because valid' do
-            expect(WorkflowSchema.call(valid_data).messages).to be_empty
-          end
-        end
-      end
-    end
-  end
-end

data/spec/services/hyrax/working_directory_spec.rb

@@ -1,12 +0,0 @@
-RSpec.describe Hyrax::WorkingDirectory do
-  let(:path1) { described_class.send(:full_filename, 'abcdefghijklmnop1', 'foo.tif') }
-  let(:path2) { described_class.send(:full_filename, 'abcdefghijklmnop2', 'foo.tif') }
-
-  describe "#full_filename" do
-    it "generates unique filenames for different files" do
-      expect(path1).not_to eq(path2)
-      expect(path1).to match(/\/tmp\/uploads\/ab\/cd\/ef\/gh\/abcdefghijklmnop1\/foo.tif$/)
-      expect(path2).to match(/\/tmp\/uploads\/ab\/cd\/ef\/gh\/abcdefghijklmnop2\/foo.tif$/)
-    end
-  end
-end

data/spec/services/hyrax/works/managed_works_service_spec.rb

@@ -1,17 +0,0 @@
-RSpec.describe Hyrax::Works::ManagedWorksService, clean_repo: true do
-  let(:blacklight_config) { CatalogController.blacklight_config }
-  let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
-
-  let(:current_ability) { instance_double(Ability, admin?: true) }
-  let(:scope) { double('Scope', can?: true, current_ability: current_ability, repository: repository, blacklight_config: blacklight_config) }
-
-  describe '.managed_works_count' do
-    subject { described_class.managed_works_count(scope: scope) }
-
-    let!(:work) { create(:public_work) }
-
-    it 'returns number of works that can be managed' do
-      expect(subject).to eq(1)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,300 +0,0 @@
-ENV["RAILS_ENV"] ||= 'test'
-require "bundler/setup"
-
-def coverage_needed?
-  ENV['COVERAGE'] || ENV['TRAVIS']
-end
-
-def ci_build?
-  ENV['TRAVIS'] || ENV['CIRCLE']
-end
-
-if coverage_needed?
-  require 'simplecov'
-  require 'coveralls'
-  SimpleCov.root(File.expand_path('../..', __FILE__))
-  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  SimpleCov.start('rails') do
-    add_filter '/.internal_test_app'
-    add_filter '/lib/generators'
-    add_filter '/spec'
-    add_filter '/tasks'
-    add_filter '/lib/hyrax/version.rb'
-    add_filter '/lib/hyrax/engine.rb'
-  end
-  SimpleCov.command_name 'spec'
-end
-
-require 'factory_bot'
-require 'engine_cart'
-EngineCart.load_application!
-
-require 'devise'
-require 'devise/version'
-require 'mida'
-require 'rails-controller-testing'
-require 'rspec/rails'
-require 'rspec/its'
-require 'rspec/matchers'
-require 'rspec/active_model/mocks'
-require 'capybara/rspec'
-require 'capybara/rails'
-require 'selenium-webdriver'
-require 'webdrivers'
-require 'equivalent-xml'
-require 'equivalent-xml/rspec_matchers'
-require 'database_cleaner'
-
-unless ENV['SKIP_MALEFICENT']
-  # See https://github.com/jeremyf/capybara-maleficent
-  # Wrap Capybara matchers with sleep intervals to reduce fragility of specs.
-  require 'capybara/maleficent/spindle'
-
-  Capybara::Maleficent.configure do |c|
-    # Quieting down maleficent's logging
-    logger = Logger.new(STDOUT)
-    logger.level = Logger::INFO
-    c.logger = logger
-  end
-end
-
-# Require supporting ruby files from spec/support/ and subdirectories.  Note: engine, not Rails.root context.
-Dir[File.join(File.dirname(__FILE__), "support/**/*.rb")].each { |f| require f }
-
-require 'webmock/rspec'
-WebMock.disable_net_connect!(allow_localhost: true, allow: 'chromedriver.storage.googleapis.com')
-
-require 'i18n/debug' if ENV['I18N_DEBUG']
-require 'byebug' unless ci_build?
-
-# @note In January 2018, TravisCI disabled Chrome sandboxing in its Linux
-#       container build environments to mitigate Meltdown/Spectre
-#       vulnerabilities, at which point Hyrax could no longer use the
-#       Capybara-provided :selenium_chrome_headless driver (which does not
-#       include the `--no-sandbox` argument).
-Capybara.register_driver :selenium_chrome_headless_sandboxless do |app|
-  browser_options = ::Selenium::WebDriver::Chrome::Options.new
-  browser_options.args << '--headless'
-  browser_options.args << '--disable-gpu'
-  browser_options.args << '--no-sandbox'
-  Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options)
-end
-
-Capybara.default_driver = :rack_test # This is a faster driver
-Capybara.javascript_driver = :selenium_chrome_headless_sandboxless # This is slower
-
-# FIXME: Pin to older version of chromedriver to avoid issue with clicking
-# non-visible elements
-Webdrivers::Chromedriver.version = '72.0.3626.69'
-
-ActiveJob::Base.queue_adapter = :test
-
-# require 'http_logger'
-# HttpLogger.logger = Logger.new(STDOUT)
-# HttpLogger.ignore = [/localhost:8983\/solr/]
-# HttpLogger.colorize = false
-
-if defined?(ClamAV)
-  ClamAV.instance.loaddb
-else
-  class ClamAV
-    include Singleton
-    def scanfile(_f)
-      0
-    end
-
-    def loaddb
-      nil
-    end
-  end
-end
-
-class JsonStrategy
-  def initialize
-    @strategy = FactoryBot.strategy_by_name(:create).new
-  end
-
-  delegate :association, to: :@strategy
-
-  def result(evaluation)
-    @strategy.result(evaluation).to_json
-  end
-end
-
-FactoryBot.register_strategy(:json, JsonStrategy)
-FactoryBot.definition_file_paths = [File.expand_path("../factories", __FILE__)]
-FactoryBot.find_definitions
-
-module EngineRoutes
-  def self.included(base)
-    base.routes { Hyrax::Engine.routes }
-  end
-
-  def main_app
-    Rails.application.class.routes.url_helpers
-  end
-end
-
-require 'shoulda/matchers'
-require 'shoulda/callback/matchers'
-Shoulda::Matchers.configure do |config|
-  config.integrate do |with|
-    with.test_framework :rspec
-    with.library :rails
-  end
-end
-
-require 'active_fedora/cleaner'
-RSpec.configure do |config|
-  config.disable_monkey_patching!
-  config.include Shoulda::Matchers::ActiveRecord, type: :model
-  config.include Shoulda::Matchers::ActiveModel, type: :form
-  config.include Shoulda::Callback::Matchers::ActiveModel
-  config.full_backtrace = true if ci_build?
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-
-  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = File.expand_path("../fixtures", __FILE__)
-
-  config.use_transactional_fixtures = false
-
-  config.before :suite do
-    DatabaseCleaner.clean_with(:truncation)
-    # Noid minting causes extra LDP requests which slow the test suite.
-    Hyrax.config.enable_noids = false
-  end
-
-  config.before do |example|
-    if example.metadata[:type] == :feature && Capybara.current_driver != :rack_test
-      DatabaseCleaner.strategy = :truncation
-    else
-      DatabaseCleaner.strategy = :transaction
-      DatabaseCleaner.start
-    end
-
-    # using :workflow is preferable to :clean_repo, use the former if possible
-    # It's important that this comes after DatabaseCleaner.start
-    ensure_deposit_available_for(user) if example.metadata[:workflow]
-    if example.metadata[:clean_repo]
-      ActiveFedora::Cleaner.clean!
-      # The JS is executed in a different thread, so that other thread
-      # may think the root path has already been created:
-      ActiveFedora.fedora.connection.send(:init_base_path) if example.metadata[:js]
-    end
-    Hyrax.config.nested_relationship_reindexer = if example.metadata[:with_nested_reindexing]
-                                                   # Use the default relationship reindexer (and the cascading reindexing of child documents)
-                                                   Hyrax.config.default_nested_relationship_reindexer
-                                                 else
-                                                   # Don't use the nested relationship reindexer. This slows everything down quite a bit.
-                                                   ->(id:, extent:) {}
-                                                 end
-  end
-
-  config.include(ControllerLevelHelpers, type: :view)
-
-  config.before(:each, type: :view) do
-    initialize_controller_helpers(view)
-    WebMock.disable_net_connect!(allow_localhost: false, allow: 'chromedriver.storage.googleapis.com')
-  end
-
-  config.after(:each, type: :view) do
-    WebMock.disable_net_connect!(allow_localhost: true, allow: 'chromedriver.storage.googleapis.com')
-  end
-
-  config.before(:all, type: :feature) do
-    # Assets take a long time to compile. This causes two problems:
-    # 1) the profile will show the first feature test taking much longer than it
-    #    normally would.
-    # 2) The first feature test will trigger rack-timeout
-    #
-    # Precompile the assets to prevent these issues.
-    visit "/assets/application.css"
-    visit "/assets/application.js"
-  end
-
-  config.after do
-    DatabaseCleaner.clean
-  end
-
-  # If true, the base class of anonymous controllers will be inferred
-  # automatically. This will be the default behavior in future versions of
-  # rspec-rails.
-  config.infer_base_class_for_anonymous_controllers = false
-
-  config.include Shoulda::Matchers::Independent
-
-  if Devise::VERSION >= '4.2'
-    config.include Devise::Test::ControllerHelpers, type: :controller
-  else
-    config.include Devise::TestHelpers, type: :controller
-  end
-
-  config.include EngineRoutes, type: :controller
-  config.include Warden::Test::Helpers, type: :request
-  config.include Warden::Test::Helpers, type: :feature
-  config.after(:each, type: :feature) do
-    Warden.test_reset!
-    Capybara.reset_sessions!
-    page.driver.reset!
-  end
-
-  config.include Capybara::RSpecMatchers, type: :input
-  config.include InputSupport, type: :input
-  config.include FactoryBot::Syntax::Methods
-  config.include OptionalExample
-
-  config.infer_spec_type_from_file_location!
-
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.formatter = 'LoggingFormatter'
-  config.default_formatter = 'doc' if config.files_to_run.one?
-
-  config.order = :random
-  Kernel.srand config.seed
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  config.filter_run_when_matching :focus
-
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-
-  config.profile_examples = 10
-
-  # Use this example metadata when you want to perform jobs inline during testing.
-  #
-  #   describe '#my_method`, :perform_enqueued do
-  #     ...
-  #   end
-  #
-  # If you pass an `Array` of job classes, they will be treated as the filter list.
-  #
-  #   describe '#my_method`, perform_enqueued: [MyJobClass] do
-  #     ...
-  #   end
-  #
-  # Limit to specific job classes with:
-  #
-  #   ActiveJob::Base.queue_adapter.filter = [JobClass]
-  #
-  config.before(:example, :perform_enqueued) do |example|
-    ActiveJob::Base.queue_adapter.filter =
-      example.metadata[:perform_enqueued].try(:to_a)
-
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs    = true
-    ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = true
-  end
-
-  config.after(:example, :perform_enqueued) do
-    ActiveJob::Base.queue_adapter.filter         = nil
-    ActiveJob::Base.queue_adapter.enqueued_jobs  = []
-    ActiveJob::Base.queue_adapter.performed_jobs = []
-
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs    = false
-    ActiveJob::Base.queue_adapter.perform_enqueued_at_jobs = false
-  end
-end