hyrax 2.9.5 → 3.0.0.pre.beta1

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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,241 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,294 @@
+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 '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)
+
+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
+
+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
+
+    if example.metadata[:type] == :view
+      # View tests should not hit any services. This ensures the tests are unit
+      # testing only the views and run fast.
+      WebMock.disable_net_connect!(allow_localhost: false)
+    else
+      WebMock.disable_net_connect!(allow_localhost: true)
+    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) { initialize_controller_helpers(view) }
+
+  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