RSpec.configure do |config|
  config.around(:each, mock_auth: lambda { |v| !!v }) do |example|
    options                   = example.metadata[:mock_auth]

    klass                     = case options
                                when TrueClass
                                  User
                                when Hash
                                  options[:class] || User
                                else
                                  options
                                end

    underscored_class_name    = klass.
                                   name[/.*::(\w+)\z/, 1].
                                   gsub(/([a-z])([A-Z])/, '\1_\2').
                                   downcase

    current_class_method      = if options.is_a?(Hash) && options[:method]
                                  options[:method]
                                else
                                  :"current_#{underscored_class_name}"
                                end

    instance                  = if options.is_a?(Hash) && options[:strategy] == :instance
                                  klass.new
                                else
                                  FactoryGirl.create(underscored_class_name.to_sym)
                                end

    inferred_auth_method      = if options.is_a?(Hash) && options[:authentication_method]
                                  options[:authentication_method]
                                else
                                  :"authenticate_#{underscored_class_name}!"
                                end

    described_class_instance  = described_class.new

    authentication_method     = if described_class_instance.respond_to?(inferred_auth_method, true)
                                  inferred_auth_method
                                elsif described_class_instance.respond_to?(:authenticate, true)
                                  :authenticate
                                end

    if options[:status] == :unauthorized
      described_class.send(:define_method, authentication_method) { false }
    else
      described_class.send(:define_method, authentication_method) { true }
    end

    example.example_group_instance.class.let(current_class_method) do
      if options[:status] == :unauthorized
        nil
      else
        instance
      end
    end

    described_class.send(:define_method, current_class_method) do
      if options[:status] == :unauthorized
        nil
      else
        instance
      end
    end

    example.run

    described_class.send(:remove_method, current_class_method)
    described_class.send(:remove_method, authentication_method)

    unless options.is_a?(Hash) && options[:strategy] == :instance
      instance.delete
    end
  end
end