plumbum 0.1.0

data/lib/plumbum/rspec/deferred/consumer_examples.rb

@@ -0,0 +1,2122 @@
+# frozen_string_literal: true
+
+require 'rspec/sleeping_king_studios/deferred/provider'
+
+require 'plumbum/rspec/deferred'
+
+module Plumbum::RSpec::Deferred
+  # Deferred examples for validating Plumbum::Consumer implementations.
+  module ConsumerExamples
+    include RSpec::SleepingKingStudios::Deferred::Provider
+
+    define_method :tools do
+      SleepingKingStudios::Tools::Toolbelt.instance
+    end
+
+    deferred_context 'with example providers' do
+      example_class 'Spec::MutableProvider', Module do |klass|
+        klass.include Plumbum::Providers::Singular
+
+        klass.define_method :initialize do |key:, value:|
+          @key   = key.to_s
+          @value = value
+        end
+
+        klass.attr_writer :value
+      end
+    end
+
+    deferred_context 'when an included module defines dependencies' do
+      let(:included_dependencies) { %w[context] }
+
+      before(:example) do
+        included_module.plumbum_dependency('context')
+      end
+    end
+
+    deferred_context 'when an included module defines providers' do
+      let(:context_provider) do
+        Plumbum::OneProvider.new(:context, value: Object.new.freeze)
+      end
+      let(:expected_providers) do
+        super() << context_provider
+      end
+
+      before(:example) do
+        included_module.plumbum_provider context_provider
+      end
+    end
+
+    deferred_context 'when the class defines dependencies' do
+      let(:class_dependencies) { %w[env tools] }
+
+      before(:example) do
+        described_class.plumbum_dependency('env')
+        described_class.plumbum_dependency('tools')
+      end
+    end
+
+    deferred_context 'when the class defines providers' do
+      let(:config_provider) do
+        Plumbum::ManyProvider.new(
+          values: { env: 'test', repository: { books: [] }, tools: {} }
+        )
+      end
+      let(:tools_provider) do
+        Plumbum::OneProvider.new(:tools, value: { string_tools: {} })
+      end
+      let(:expected_providers) do
+        super() << tools_provider << config_provider
+      end
+
+      before(:example) do
+        described_class.plumbum_provider config_provider
+        described_class.plumbum_provider tools_provider
+      end
+    end
+
+    deferred_context 'when the parent class defines dependencies' do
+      let(:parent_dependencies) { %w[repository tools] }
+
+      before(:example) do
+        parent_class.plumbum_dependency('repository')
+        parent_class.plumbum_dependency('tools')
+      end
+    end
+
+    deferred_context 'when the parent class defines providers' do
+      let(:options_provider) do
+        Plumbum::OneProvider.new(:options, value: { key: 'value' })
+      end
+      let(:expected_providers) do
+        super() << options_provider
+      end
+
+      before(:example) do
+        parent_class.plumbum_provider options_provider
+      end
+    end
+
+    deferred_examples 'should implement the Consumer class methods' do
+      describe '.plumbum_dependency' do
+        deferred_examples 'should define the delegated method' \
+        do |scoped: false, visibility: :public|
+          if scoped
+            it 'should not define the unscoped delegated method' do
+              expect(subject).not_to respond_to(delegated_name)
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(delegated_name)
+            end
+          end
+
+          if visibility == :private
+            it 'should define the private delegated method',
+              :aggregate_failures \
+            do
+              expect(subject).not_to respond_to(method_name)
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(method_name)
+              expect(subject)
+                .to respond_to(method_name, true)
+                .with_unlimited_arguments
+                .and_any_keywords
+                .and_a_block
+            end
+          else
+            it 'should define the delegated method', :aggregate_failures do
+              expect(subject).not_to respond_to(method_name)
+
+              define_dependencies
+
+              expect(subject)
+                .to respond_to(method_name)
+                .with_unlimited_arguments
+                .and_any_keywords
+                .and_a_block
+            end
+          end
+        end
+
+        deferred_examples 'should define the predicate method' \
+        do |scoped: false, visibility: :public|
+          if scoped
+            it 'should not define the unscoped predicate method' do
+              expect(subject).not_to respond_to(predicate_name)
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(predicate_name)
+            end
+          end
+
+          if visibility == :private
+            it 'should define the private predicate method',
+              :aggregate_failures \
+            do
+              expect(subject).not_to respond_to(:"#{method_name}?")
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(:"#{method_name}?")
+              expect(subject)
+                .to respond_to(:"#{method_name}?", true)
+                .with(0).arguments
+            end
+          else
+            it 'should define the predicate method', :aggregate_failures do
+              expect(subject).not_to respond_to(:"#{method_name}?")
+
+              define_dependencies
+
+              expect(subject)
+                .to respond_to(:"#{method_name}?")
+                .with(0).arguments
+            end
+          end
+        end
+
+        deferred_examples 'should define the reader method' \
+        do |scoped: false, visibility: :public|
+          if scoped
+            it 'should not define the unscoped reader method' do
+              expect(subject).not_to respond_to(reader_name)
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(reader_name)
+            end
+          end
+
+          if visibility == :private
+            it 'should define the private reader method', :aggregate_failures do
+              expect(subject).not_to respond_to(method_name)
+
+              define_dependencies
+
+              expect(subject).not_to respond_to(method_name)
+              expect(subject).to respond_to(method_name, true).with(0).arguments
+            end
+          else
+            it 'should define the reader method', :aggregate_failures do
+              expect(subject).not_to respond_to(method_name)
+
+              define_dependencies
+
+              expect(subject).to respond_to(method_name).with(0).arguments
+            end
+          end
+        end
+
+        deferred_examples 'should define dependency' \
+        do |dependency_name, allow_as: true, to: nil, visibility: :public|
+          let(:expected_key) { (to || dependency_name).to_s.split('.').first }
+          let(:reader_name)  { dependency_name.to_sym }
+          let(:method_name)  { reader_name }
+
+          it 'should add the key to the dependency keys' do
+            expect { define_dependencies }.to(
+              change { dependency_keys }.to(include(expected_key))
+            )
+          end
+
+          include_deferred 'should define the reader method',
+            visibility: visibility
+
+          if allow_as
+            describe 'with as: nil' do
+              let(:options) { super().merge(as: nil) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }.to(
+                  change { dependency_keys }.to(include(expected_key))
+                )
+              end
+
+              include_deferred 'should define the reader method',
+                visibility: visibility
+            end
+
+            describe 'with as: an Object' do
+              let(:options) { super().merge(as: Object.new.freeze) }
+              let(:error_message) do
+                tools
+                  .assertions
+                  .error_message_for(
+                    'sleeping_king_studios.tools.assertions.name',
+                    as: :as
+                  )
+              end
+
+              it 'should raise an exception' do
+                expect { define_dependencies }
+                  .to raise_error ArgumentError, error_message
+              end
+            end
+
+            describe 'with as: an empty String' do
+              let(:options) { super().merge(as: '') }
+              let(:error_message) do
+                tools
+                  .assertions
+                  .error_message_for(
+                    'sleeping_king_studios.tools.assertions.presence',
+                    as: :as
+                  )
+              end
+
+              it 'should raise an exception' do
+                expect { define_dependencies }
+                  .to raise_error ArgumentError, error_message
+              end
+            end
+
+            describe 'with as: an empty Symbol' do
+              let(:options) { super().merge(as: :'') }
+              let(:error_message) do
+                tools
+                  .assertions
+                  .error_message_for(
+                    'sleeping_king_studios.tools.assertions.presence',
+                    as: :as
+                  )
+              end
+
+              it 'should raise an exception' do
+                expect { define_dependencies }
+                  .to raise_error ArgumentError, error_message
+              end
+            end
+
+            describe 'with as: a String' do
+              let(:scoped_name) { :"scoped_#{reader_name}" }
+              let(:method_name) { scoped_name.to_s }
+              let(:options)     { super().merge(as: method_name) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }
+                  .to(change { dependency_keys }.to(include(expected_key)))
+              end
+
+              include_deferred 'should define the reader method',
+                scoped:     true,
+                visibility: visibility
+            end
+
+            describe 'with as: a Symbol' do
+              let(:scoped_name) { :"scoped_#{reader_name}" }
+              let(:method_name) { scoped_name }
+              let(:options)     { super().merge(as: method_name) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }
+                  .to change { dependency_keys }.to(include(expected_key))
+              end
+
+              include_deferred 'should define the reader method',
+                scoped:     true,
+                visibility: visibility
+            end
+          end
+
+          describe 'with predicate: true' do
+            let(:predicate_name) { :"#{reader_name}?" }
+            let(:options)        { super().merge(predicate: true) }
+
+            it 'should add the key to the dependency keys' do
+              expect { define_dependencies }
+                .to change { dependency_keys }.to(include(expected_key))
+            end
+
+            include_deferred 'should define the predicate method',
+              visibility: visibility
+
+            include_deferred 'should define the reader method',
+              visibility: visibility
+
+            if allow_as
+              describe 'with as: value' do
+                let(:scoped_name) { :"scoped_#{reader_name}" }
+                let(:method_name) { scoped_name.to_s }
+                let(:options)     { super().merge(as: method_name) }
+
+                include_deferred 'should define the predicate method',
+                  scoped:     true,
+                  visibility: visibility
+
+                include_deferred 'should define the reader method',
+                  scoped:     true,
+                  visibility: visibility
+              end
+            end
+          end
+        end
+
+        deferred_examples 'should define method dependency' \
+        do |dependency_name, allow_as: true, to: nil, visibility: :public|
+          let(:expected_key)   { (to || dependency_name).to_s.split('.').first }
+          let(:delegated_name) { dependency_name.to_sym }
+          let(:method_name)    { delegated_name }
+
+          it 'should add the key to the dependency keys' do
+            expect { define_dependencies }.to(
+              change { dependency_keys }.to(include(expected_key))
+            )
+          end
+
+          include_deferred 'should define the delegated method',
+            visibility: visibility
+
+          if allow_as
+            describe 'with as: nil' do
+              let(:options) { super().merge(as: nil) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }.to(
+                  change { dependency_keys }.to(include(expected_key))
+                )
+              end
+
+              include_deferred 'should define the delegated method',
+                visibility: visibility
+            end
+
+            describe 'with as: a String' do
+              let(:scoped_name) { :"scoped_#{delegated_name}" }
+              let(:method_name) { scoped_name.to_s }
+              let(:options)     { super().merge(as: method_name) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }
+                  .to(change { dependency_keys }.to(include(expected_key)))
+              end
+
+              include_deferred 'should define the delegated method',
+                scoped:     true,
+                visibility: visibility
+            end
+
+            describe 'with as: a Symbol' do
+              let(:scoped_name) { :"scoped_#{delegated_name}" }
+              let(:method_name) { scoped_name.to_sym }
+              let(:options)     { super().merge(as: method_name) }
+
+              it 'should add the key to the dependency keys' do
+                expect { define_dependencies }
+                  .to(change { dependency_keys }.to(include(expected_key)))
+              end
+
+              include_deferred 'should define the delegated method',
+                scoped:     true,
+                visibility: visibility
+            end
+          end
+        end
+
+        let(:keys)    { [key] }
+        let(:options) { {} }
+        let(:expected_keywords) do
+          %i[
+            as
+            default
+            memoize
+            optional
+            predicate
+            private
+            scope
+          ]
+        end
+
+        define_method :define_dependencies do
+          described_class.plumbum_dependency(*keys, **options)
+        end
+
+        define_method :dependency_keys do
+          described_class.plumbum_dependency_keys(cache: false)
+        end
+
+        define_method :tools do
+          SleepingKingStudios::Tools::Toolbelt.instance
+        end
+
+        it 'should define the class method' do
+          expect(described_class)
+            .to respond_to(:plumbum_dependency)
+            .with(1).argument
+            .and_unlimited_arguments
+            .and_keywords(*expected_keywords)
+        end
+
+        describe 'with nil' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency(nil) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an Object' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.name',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency(Object.new.freeze) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty String' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency('') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty Symbol' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency(:'') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with a valid String' do
+          let(:key) { 'valid' }
+
+          include_deferred 'should define dependency', 'valid'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key)).to be :valid
+          end
+
+          describe 'with as: value' do
+            let(:scoped_name) { :scoped_valid }
+            let(:method_name) { scoped_name.to_s }
+            let(:options)     { super().merge(as: method_name) }
+
+            it 'should return the reader name' do
+              expect(described_class.plumbum_dependency(key, as: method_name))
+                .to be :scoped_valid
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define dependency',
+              'valid',
+              visibility: :private
+          end
+
+          describe 'with scope: value' do
+            let(:options) { super().merge(scope: 'application.data') }
+
+            include_deferred 'should define dependency',
+              'valid',
+              to: 'application.data'
+          end
+        end
+
+        describe 'with a valid Symbol' do
+          let(:key) { :valid }
+
+          include_deferred 'should define dependency', 'valid'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key))
+              .to be :valid
+          end
+
+          describe 'with as: value' do
+            let(:scoped_name) { :scoped_valid }
+            let(:method_name) { scoped_name.to_s }
+            let(:options)     { super().merge(as: method_name) }
+
+            it 'should return the reader name' do
+              expect(described_class.plumbum_dependency(key, as: method_name))
+                .to be :scoped_valid
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define dependency',
+              'valid',
+              visibility: :private
+          end
+
+          describe 'with scope: value' do
+            let(:options) { super().merge(scope: 'application.data') }
+
+            include_deferred 'should define dependency',
+              'valid',
+              to: 'application.data'
+          end
+        end
+
+        describe 'with a dot-separated String' do
+          let(:key) { 'application.tools.object_tools' }
+
+          include_deferred 'should define dependency',
+            :object_tools,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key))
+              .to be :object_tools
+          end
+
+          describe 'with as: value' do
+            let(:scoped_name) { :scoped_object_tools }
+            let(:method_name) { scoped_name.to_s }
+            let(:options)     { super().merge(as: method_name) }
+
+            it 'should return the reader name' do
+              expect(described_class.plumbum_dependency(key, as: method_name))
+                .to be :scoped_object_tools
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define dependency',
+              :object_tools,
+              to:         'application.tools',
+              visibility: :private
+          end
+
+          describe 'with scope: value' do
+            let(:options) { super().merge(scope: 'config') }
+
+            include_deferred 'should define dependency',
+              'object_tools',
+              to: 'config.application.tools'
+          end
+        end
+
+        describe 'with a dot-separated Symbol' do
+          let(:key) { :'application.tools.object_tools' }
+
+          include_deferred 'should define dependency',
+            :object_tools,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key))
+              .to be :object_tools
+          end
+
+          describe 'with as: value' do
+            let(:scoped_name) { :scoped_object_tools }
+            let(:method_name) { scoped_name.to_s }
+            let(:options)     { super().merge(as: method_name) }
+
+            it 'should return the reader name' do
+              expect(described_class.plumbum_dependency(key, as: method_name))
+                .to be :scoped_object_tools
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define dependency',
+              :object_tools,
+              to:         'application.tools',
+              visibility: :private
+          end
+
+          describe 'with scope: value' do
+            let(:options) { super().merge(scope: 'config') }
+
+            include_deferred 'should define dependency',
+              'object_tools',
+              to: 'config.application.tools'
+          end
+        end
+
+        describe 'with multiple invalid keys' do
+          let(:keys) do
+            [
+              'valid',
+              nil,
+              'application.tools.object_tools'
+            ]
+          end
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency(*keys) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with multiple valid keys' do
+          let(:keys) do
+            [
+              'valid',
+              'application.tools.object_tools'
+            ]
+          end
+
+          include_deferred 'should define dependency',
+            'valid',
+            allow_as: false
+
+          include_deferred 'should define dependency',
+            :object_tools,
+            to:       'application.tools',
+            allow_as: false
+
+          describe 'with as: value' do
+            let(:method_name) { 'scoped_valid' }
+            let(:error_message) do
+              'invalid option :as when providing multiple keys'
+            end
+
+            it 'should raise an exception' do
+              expect do
+                described_class.plumbum_dependency(*keys, as: method_name)
+              end
+                .to raise_error ArgumentError, error_message
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define dependency',
+              'valid',
+              allow_as:   false,
+              visibility: :private
+
+            include_deferred 'should define dependency',
+              :object_tools,
+              to:         'application.tools',
+              allow_as:   false,
+              visibility: :private
+          end
+
+          describe 'with scope: value' do
+            let(:options) { super().merge(scope: 'config') }
+
+            include_deferred 'should define dependency',
+              'valid',
+              to:       'config',
+              allow_as: false
+
+            include_deferred 'should define dependency',
+              :object_tools,
+              to:       'config.application.tools',
+              allow_as: false
+          end
+        end
+
+        describe 'with a bare method name' do
+          let(:error_message) do
+            'delegated methods must have a scope - use a scoped key or pass ' \
+              'the :scope option to #dependency'
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_dependency('#launch') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with a method name String with scope: value' do
+          let(:options) { super().merge(scope: 'application.tools') }
+          let(:key)     { '#fetch' }
+
+          include_deferred 'should define method dependency',
+            :fetch,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key, **options))
+              .to be :fetch
+          end
+
+          describe 'with memoize: value' do
+            let(:options) { super().merge(memoize: false) }
+            let(:error_message) do
+              'invalid option :memoize for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define method dependency',
+              :fetch,
+              to:         'application.tools',
+              visibility: :private
+          end
+
+          describe 'with predicate: value' do
+            let(:options) { super().merge(predicate: true) }
+            let(:error_message) do
+              'invalid option :predicate for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+        end
+
+        describe 'with a method name Symbol with scope: value' do
+          let(:options) { super().merge(scope: 'application.tools') }
+          let(:key)     { :'#fetch' }
+
+          include_deferred 'should define method dependency',
+            :fetch,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key, **options))
+              .to be :fetch
+          end
+
+          describe 'with memoize: value' do
+            let(:options) { super().merge(memoize: false) }
+            let(:error_message) do
+              'invalid option :memoize for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+
+          describe 'with private: value' do
+            let(:options) { super().merge(private: true) }
+
+            include_deferred 'should define method dependency',
+              :fetch,
+              to:         'application.tools',
+              visibility: :private
+          end
+
+          describe 'with predicate: value' do
+            let(:options) { super().merge(predicate: true) }
+            let(:error_message) do
+              'invalid option :predicate for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+        end
+
+        describe 'with a dot-separated method name String' do
+          let(:key) { 'application.tools.#fetch' }
+
+          include_deferred 'should define method dependency',
+            :fetch,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key))
+              .to be :fetch
+          end
+
+          describe 'with memoize: value' do
+            let(:options) { super().merge(memoize: false) }
+            let(:error_message) do
+              'invalid option :memoize for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+
+          describe 'with predicate: value' do
+            let(:options) { super().merge(predicate: true) }
+            let(:error_message) do
+              'invalid option :predicate for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+        end
+
+        describe 'with a dot-separated method name Symbol' do
+          let(:key) { :'application.tools.#fetch' }
+
+          include_deferred 'should define method dependency',
+            :fetch,
+            to: 'application.tools'
+
+          it 'should return the reader name' do
+            expect(described_class.plumbum_dependency(key))
+              .to be :fetch
+          end
+
+          describe 'with memoize: value' do
+            let(:options) { super().merge(memoize: false) }
+            let(:error_message) do
+              'invalid option :memoize for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+
+          describe 'with predicate: value' do
+            let(:options) { super().merge(predicate: true) }
+            let(:error_message) do
+              'invalid option :predicate for method dependency'
+            end
+
+            it 'should raise an exception' do
+              expect { define_dependencies }
+                .to raise_error ArgumentError, error_message
+            end
+          end
+        end
+      end
+
+      describe '.plumbum_dependency_keys' do
+        it 'should define the method' do
+          expect(described_class)
+            .to respond_to(:plumbum_dependency_keys)
+            .with(0).arguments
+            .and_keywords(:cache)
+        end
+
+        it { expect(described_class.plumbum_dependency_keys).to be == Set.new }
+
+        wrap_deferred 'when an included module defines dependencies' do
+          let(:expected_dependencies) { included_dependencies }
+
+          it 'should return the class dependencies' do
+            expect(described_class.plumbum_dependency_keys)
+              .to be_a(Set)
+              .and match_array(expected_dependencies)
+          end
+        end
+
+        wrap_deferred 'when the parent class defines dependencies' do
+          let(:expected_dependencies) { parent_dependencies }
+
+          it 'should return the class dependencies' do
+            expect(described_class.plumbum_dependency_keys)
+              .to be_a(Set)
+              .and match_array(expected_dependencies)
+          end
+        end
+
+        wrap_deferred 'when the class defines dependencies' do
+          let(:expected_dependencies) { class_dependencies }
+
+          it 'should return the class dependencies' do
+            expect(described_class.plumbum_dependency_keys)
+              .to be_a(Set)
+              .and match_array(expected_dependencies)
+          end
+        end
+
+        context 'when the class and ancestors define dependencies' do
+          let(:expected_dependencies) do
+            [
+              *parent_dependencies,
+              *class_dependencies,
+              *included_dependencies
+            ].uniq
+          end
+
+          include_deferred 'when the parent class defines dependencies'
+          include_deferred 'when an included module defines dependencies'
+          include_deferred 'when the class defines dependencies'
+
+          it 'should return the parent class and class dependencies' do
+            expect(described_class.plumbum_dependency_keys)
+              .to be_a(Set)
+              .and match_array(expected_dependencies)
+          end
+        end
+
+        context 'when the dependency keys change' do
+          before(:example) do
+            # Memoize value.
+            described_class.plumbum_dependency_keys
+
+            described_class.plumbum_dependency 'added_dependency'
+          end
+
+          it 'should not update the dependency keys' do
+            expect(described_class.plumbum_dependency_keys).to be == Set.new
+          end
+
+          describe 'with cache: false' do
+            it 'should update the dependency keys' do
+              expect(described_class.plumbum_dependency_keys(cache: false))
+                .to be == Set.new(%w[added_dependency])
+            end
+          end
+
+          describe 'with cache: true' do
+            it 'should not update the dependency keys' do
+              expect(described_class.plumbum_dependency_keys(cache: true))
+                .to be == Set.new
+            end
+          end
+        end
+      end
+
+      describe '.plumbum_provider' do
+        it 'should define the method' do
+          expect(described_class)
+            .to respond_to(:plumbum_provider)
+            .with(1).argument
+        end
+
+        describe 'with nil' do
+          let(:error_message) { 'provider does not respond to #get' }
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_provider(nil) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an Object' do
+          let(:error_message) { 'provider does not respond to #get' }
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_provider(Object.new.freeze) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with a Provider' do
+          let(:provider) { Plumbum::ManyProvider.new }
+
+          define_method :defined_providers do
+            described_class.plumbum_providers(cache: false)
+          end
+
+          it { expect(described_class.plumbum_provider(provider)).to be nil }
+
+          it 'should add the provider to #plumbum_providers',
+            :aggregate_failures \
+          do
+            expect { described_class.plumbum_provider(provider) }.to(
+              change { defined_providers.count }.by(1)
+            )
+
+            expect(defined_providers.first).to be provider
+          end
+
+          wrap_deferred 'when the class defines providers' do
+            it 'should add the provider to #plumbum_providers',
+              :aggregate_failures \
+            do
+              expect { described_class.plumbum_provider(provider) }.to(
+                change { defined_providers.count }.by(1)
+              )
+
+              expect(defined_providers.first).to be provider
+            end
+          end
+        end
+
+        describe 'with an object implementing the Provider interface' do
+          let(:provider) do
+            Spec::CustomProvider.new(hostname: 'localhost', port: '3000')
+          end
+
+          example_constant 'Spec::CustomProvider' do
+            Data.define(:hostname, :port) do
+              def get(key) = has?(key) ? send(key) : nil
+
+              def has?(key) = members.include?(key.to_sym)
+            end
+          end
+
+          define_method :defined_providers do
+            described_class.plumbum_providers(cache: false)
+          end
+
+          it { expect(described_class.plumbum_provider(provider)).to be nil }
+
+          it 'should add the provider to #plumbum_providers',
+            :aggregate_failures \
+          do
+            expect { described_class.plumbum_provider(provider) }.to(
+              change { defined_providers.count }.by(1)
+            )
+
+            expect(defined_providers.first).to be provider
+          end
+
+          wrap_deferred 'when the class defines providers' do
+            it 'should add the provider to #plumbum_providers',
+              :aggregate_failures \
+            do
+              expect { described_class.plumbum_provider(provider) }.to(
+                change { defined_providers.count }.by(1)
+              )
+
+              expect(defined_providers.first).to be provider
+            end
+          end
+        end
+
+        describe 'with an object that partially implements the interface' do
+          let(:provider) do
+            Spec::PartialProvider.new(hostname: 'localhost', port: '3000')
+          end
+          let(:error_message) { 'provider does not respond to #has?' }
+
+          example_constant 'Spec::PartialProvider' do
+            Data.define(:hostname, :port) do
+              def get(key) = send(key)
+            end
+          end
+
+          it 'should raise an exception' do
+            expect { described_class.plumbum_provider(provider) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+      end
+
+      describe '.plumbum_providers' do
+        let(:expected_providers) { [] }
+
+        it 'should define the method' do
+          expect(described_class)
+            .to respond_to(:plumbum_providers)
+            .with(0).arguments
+            .and_keywords(:cache)
+        end
+
+        it { expect(described_class.plumbum_providers).to be == [] }
+
+        wrap_deferred 'when the parent class defines providers' do
+          it 'should return the expected providers' do
+            expect(described_class.plumbum_providers).to eq(expected_providers)
+          end
+        end
+
+        wrap_deferred 'when the class defines providers' do
+          it 'should return the expected providers' do
+            expect(described_class.plumbum_providers).to eq(expected_providers)
+          end
+        end
+
+        wrap_deferred 'when an included module defines dependencies' do
+          it 'should return the expected providers' do
+            expect(described_class.plumbum_providers).to eq(expected_providers)
+          end
+        end
+
+        context 'when the class and ancestors define providers' do
+          include_deferred 'when the parent class defines providers'
+          include_deferred 'when an included module defines providers'
+          include_deferred 'when the class defines providers'
+
+          it 'should return the expected providers' do
+            expect(described_class.plumbum_providers).to eq(expected_providers)
+          end
+        end
+
+        context 'when the providers change' do
+          let(:generic_provider) { Plumbum::ManyProvider.new }
+
+          before(:example) do
+            # Memoize value.
+            described_class.plumbum_providers
+
+            described_class.plumbum_provider generic_provider
+          end
+
+          it 'should not update the dependency keys' do
+            expect(described_class.plumbum_providers).to be == []
+          end
+
+          describe 'with cache: false' do
+            it 'should update the dependency keys' do
+              expect(described_class.plumbum_providers(cache: false))
+                .to be == [generic_provider]
+            end
+          end
+
+          describe 'with cache: true' do
+            it 'should not update the dependency keys' do
+              expect(described_class.plumbum_providers(cache: true))
+                .to be == []
+            end
+          end
+        end
+      end
+    end
+
+    deferred_examples 'should implement the Consumer instance methods' do
+      describe '#get_plumbum_dependency' do
+        it 'should define the method' do
+          expect(subject)
+            .to respond_to(:get_plumbum_dependency)
+            .with(1).argument
+            .and_keywords(:optional)
+        end
+
+        describe 'with nil' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency(nil) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an Object' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.name',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency(Object.new.freeze) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty String' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency('') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty Symbol' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency(:'') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with a non-matching String' do
+          let(:error_message) do
+            'dependency not found with key "invalid"'
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency('invalid') }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+        end
+
+        describe 'with a non-matching Symbol' do
+          let(:error_message) do
+            'dependency not found with key :invalid'
+          end
+
+          it 'should raise an exception' do
+            expect { subject.get_plumbum_dependency(:invalid) }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+        end
+
+        wrap_deferred 'when the class defines providers' do
+          describe 'with a non-matching String' do
+            let(:error_message) do
+              'dependency not found with key "invalid"'
+            end
+
+            it 'should raise an exception' do
+              expect { subject.get_plumbum_dependency('invalid') }
+                .to raise_error(
+                  Plumbum::Errors::MissingDependencyError,
+                  error_message
+                )
+            end
+          end
+
+          describe 'with a non-matching Symbol' do
+            let(:error_message) do
+              'dependency not found with key :invalid'
+            end
+
+            it 'should raise an exception' do
+              expect { subject.get_plumbum_dependency(:invalid) }
+                .to raise_error(
+                  Plumbum::Errors::MissingDependencyError,
+                  error_message
+                )
+            end
+          end
+
+          describe 'with a matching String' do
+            it 'should return the dependency value' do
+              expect(subject.get_plumbum_dependency('env'))
+                .to eq(config_provider.values['env'])
+            end
+
+            context 'with a String matching multiple providers' do
+              it 'should return the value from the last provider' do
+                expect(subject.get_plumbum_dependency('tools'))
+                  .to eq(tools_provider.value)
+              end
+            end
+          end
+
+          describe 'with a matching Symbol' do
+            it 'should return the dependency value' do
+              expect(subject.get_plumbum_dependency(:env))
+                .to eq(config_provider.values['env'])
+            end
+
+            context 'with a Symbol matching multiple providers' do
+              it 'should return the value from the last provider' do
+                expect(subject.get_plumbum_dependency(:tools))
+                  .to eq(tools_provider.value)
+              end
+            end
+          end
+        end
+      end
+
+      describe '#has_plumbum_dependency?' do
+        it 'should define the method' do
+          expect(subject)
+            .to respond_to(:has_plumbum_dependency?)
+            .with(1).argument
+        end
+
+        describe 'with nil' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.has_plumbum_dependency?(nil) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an Object' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.name',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.has_plumbum_dependency?(Object.new.freeze) }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty String' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.has_plumbum_dependency?('') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with an empty Symbol' do
+          let(:error_message) do
+            tools
+              .assertions
+              .error_message_for(
+                'sleeping_king_studios.tools.assertions.presence',
+                as: :key
+              )
+          end
+
+          it 'should raise an exception' do
+            expect { subject.has_plumbum_dependency?(:'') }
+              .to raise_error ArgumentError, error_message
+          end
+        end
+
+        describe 'with a non-matching String' do
+          it { expect(subject.has_plumbum_dependency?('invalid')).to be false }
+        end
+
+        describe 'with a non-matching Symbol' do
+          it { expect(subject.has_plumbum_dependency?(:invalid)).to be false }
+        end
+
+        wrap_deferred 'when the class defines providers' do
+          describe 'with a non-matching String' do
+            let(:value) { 'invalid' }
+
+            it { expect(subject.has_plumbum_dependency?(value)).to be false }
+          end
+
+          describe 'with a non-matching Symbol' do
+            it { expect(subject.has_plumbum_dependency?(:invalid)).to be false }
+          end
+
+          describe 'with a matching String' do
+            it { expect(subject.has_plumbum_dependency?('tools')).to be true }
+          end
+
+          describe 'with a matching Symbol' do
+            it { expect(subject.has_plumbum_dependency?(:tools)).to be true }
+          end
+        end
+      end
+    end
+
+    deferred_examples 'should generate the dependency methods' do
+      describe '#:dependency' do
+        it { expect(consumer).not_to respond_to(:tools) }
+
+        wrap_deferred 'when the class defines dependencies' do
+          let(:error_message) do
+            'dependency not found with key "tools"'
+          end
+
+          it { expect(consumer).to respond_to(:tools).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.tools }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          wrap_deferred 'when the class defines providers' do
+            it { expect(consumer.tools).to be tools_provider.value }
+
+            context 'when the class overwrites the method' do
+              before(:example) do
+                described_class.define_method(:tools) do
+                  { tools: super() }
+                end
+              end
+
+              it 'should use the class definition' do
+                expect(consumer.tools)
+                  .to eq({ tools: tools_provider.value })
+              end
+            end
+          end
+        end
+
+        context 'when the class defines a dependency with as: value' do
+          let(:error_message) do
+            'dependency not found with key "railtie"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('railtie', as: 'integration')
+          end
+
+          it { expect(consumer).to respond_to(:integration).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.integration }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:railtie_provider) do
+              Plumbum::OneProvider.new(:railtie, value: Object.new.freeze)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider railtie_provider
+            end
+
+            it 'should return the dependency value' do
+              expect(consumer.integration).to be railtie_provider.value
+            end
+          end
+        end
+
+        context 'when the class defines a dependency with default: a Proc' do
+          let(:default) { -> { { id: SecureRandom.uuid } } }
+
+          before(:example) do
+            described_class.plumbum_dependency('tools', default:)
+          end
+
+          it { expect(consumer).to respond_to(:tools).with(0).arguments }
+
+          it { expect(consumer.tools).to match({ id: an_instance_of(String) }) }
+
+          context 'when the class includes a provider for the dependency' do
+            include_deferred 'when the class defines providers'
+
+            it { expect(consumer.tools).to be tools_provider.value }
+          end
+        end
+
+        context 'when the class defines a dependency with default: value' do
+          let(:default) { {} }
+
+          before(:example) do
+            described_class.plumbum_dependency('tools', default:)
+          end
+
+          it { expect(consumer).to respond_to(:tools).with(0).arguments }
+
+          it { expect(consumer.tools).to be == default }
+
+          context 'when the class includes a provider for the dependency' do
+            include_deferred 'when the class defines providers'
+
+            it { expect(consumer.tools).to be tools_provider.value }
+          end
+        end
+
+        context 'when the class defines a dependency with memoize: false' do
+          let(:error_message) do
+            'dependency not found with key "request"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('request', memoize: false)
+          end
+
+          it { expect(consumer).to respond_to(:request).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.request }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:original_value) { { http_method: :get } }
+
+            example_constant 'Spec::RequestProvider' do
+              Spec::MutableProvider.new(key: :request, value: original_value)
+            end
+
+            before(:example) do
+              described_class.plumbum_dependency('request', memoize: false)
+
+              described_class.plumbum_provider Spec::RequestProvider
+            end
+
+            it { expect(consumer.request).to be Spec::RequestProvider.value }
+
+            context 'when the provider value changes' do
+              let(:changed_value) { { http_method: :post } }
+
+              before(:example) do
+                consumer.request # Cache the dependency.
+
+                Spec::RequestProvider.value = changed_value
+              end
+
+              it { expect(consumer.request).to be Spec::RequestProvider.value }
+            end
+          end
+        end
+
+        context 'when the class defines a dependency with memoize: true' do
+          let(:error_message) do
+            'dependency not found with key "request"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('request', memoize: true)
+          end
+
+          it { expect(consumer).to respond_to(:request).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.request }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:original_value) { { http_method: :get } }
+
+            example_constant 'Spec::RequestProvider' do
+              Spec::MutableProvider.new(key: :request, value: original_value)
+            end
+
+            before(:example) do
+              described_class.plumbum_dependency('request', memoize: true)
+
+              described_class.plumbum_provider Spec::RequestProvider
+            end
+
+            it { expect(consumer.request).to be Spec::RequestProvider.value }
+
+            context 'when the provider value changes' do
+              let(:changed_value) { { http_method: :post } }
+
+              before(:example) do
+                consumer.request # Cache the dependency.
+
+                Spec::RequestProvider.value = changed_value
+              end
+
+              it { expect(consumer.request).to be original_value }
+            end
+          end
+        end
+
+        context 'when the class defines a dependency with optional: false' do
+          let(:error_message) do
+            'dependency not found with key "railtie"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('railtie', optional: false)
+          end
+
+          it { expect(consumer).to respond_to(:railtie).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.railtie }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:railtie_provider) do
+              Plumbum::OneProvider.new(:railtie, value: Object.new.freeze)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider railtie_provider
+            end
+
+            it { expect(consumer.railtie).to be railtie_provider.value }
+          end
+        end
+
+        context 'when the class defines a dependency with optional: true' do
+          before(:example) do
+            described_class.plumbum_dependency('railtie', optional: true)
+          end
+
+          it { expect(consumer).to respond_to(:railtie).with(0).arguments }
+
+          it { expect(consumer.railtie).to be nil }
+
+          context 'when the class includes a provider for the dependency' do
+            let(:railtie_provider) do
+              Plumbum::OneProvider.new(:railtie, value: Object.new.freeze)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider railtie_provider
+            end
+
+            it { expect(consumer.railtie).to be railtie_provider.value }
+          end
+        end
+
+        context 'when the class defines a dependency with scope: value' do
+          let(:error_message) do
+            'dependency not found with key "application"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency(
+              'object_tools',
+              scope: 'application.tools'
+            )
+          end
+
+          it { expect(consumer).to respond_to(:object_tools).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.object_tools }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:object_tools) { Object.new.freeze }
+            let(:tools)        { Struct.new(:object_tools).new(object_tools) }
+            let(:application)  { Struct.new(:tools).new(tools) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it { expect(consumer.object_tools).to be object_tools }
+          end
+        end
+
+        context 'when the class defines a scoped dependency' do
+          let(:error_message) do
+            'dependency not found with key "application"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('application.tools.object_tools')
+          end
+
+          it { expect(consumer).to respond_to(:object_tools).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.object_tools }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:object_tools) { Object.new.freeze }
+            let(:tools)        { Struct.new(:object_tools).new(object_tools) }
+            let(:application)  { Struct.new(:tools).new(tools) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it { expect(consumer.object_tools).to be object_tools }
+          end
+        end
+
+        context 'when the class defines a scoped dependency with as: value' do
+          let(:error_message) do
+            'dependency not found with key "application"'
+          end
+
+          before(:example) do
+            described_class
+              .plumbum_dependency('application.tools.object_tools', as: :obj)
+          end
+
+          it { expect(consumer).to respond_to(:obj).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.obj }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:object_tools) { Object.new.freeze }
+            let(:tools)        { Struct.new(:object_tools).new(object_tools) }
+            let(:application)  { Struct.new(:tools).new(tools) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it { expect(consumer.obj).to be object_tools }
+          end
+        end
+
+        context 'when the class defines a scoped dependency with invalid path' \
+        do
+          let(:error_message) do
+            'dependency not found with key "application"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('application.tools.basic_tools')
+          end
+
+          it { expect(consumer).to respond_to(:basic_tools).with(0).arguments }
+
+          it 'should raise an exception' do
+            expect { consumer.basic_tools }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:object_tools) { Object.new.freeze }
+            let(:tools)        { Struct.new(:object_tools).new(object_tools) }
+            let(:application)  { Struct.new(:tools).new(tools) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+            let(:error_message) { 'undefined method "basic_tools"' }
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it 'should raise an exception' do
+              expect { consumer.basic_tools }
+                .to raise_error(
+                  Plumbum::Errors::MissingDependencyError,
+                  error_message
+                )
+            end
+          end
+        end
+
+        context 'when the class defines an optional scoped dependency' do
+          before(:example) do
+            described_class.plumbum_dependency(
+              'application.tools.object_tools',
+              optional: true
+            )
+          end
+
+          it { expect(consumer).to respond_to(:object_tools).with(0).arguments }
+
+          it { expect(consumer.object_tools).to be nil }
+
+          context 'when the class includes a provider for the dependency' do
+            let(:object_tools) { Object.new.freeze }
+            let(:tools)        { Struct.new(:object_tools).new(object_tools) }
+            let(:application)  { Struct.new(:tools).new(tools) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it { expect(consumer.object_tools).to be object_tools }
+          end
+        end
+
+        context 'when the class defines a method dependency' do
+          let(:error_message) do
+            'dependency not found with key "application"'
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency(
+              '#restart',
+              scope: 'application.manager'
+            )
+          end
+
+          it 'should define the delegator method' do
+            expect(consumer)
+              .to respond_to(:restart)
+              .with_unlimited_arguments
+              .and_any_keywords
+              .and_a_block
+          end
+
+          it 'should raise an exception' do
+            expect { consumer.restart }.to raise_error(
+              Plumbum::Errors::MissingDependencyError,
+              error_message
+            )
+          end
+
+          context 'when the class includes a provider for the dependency' do
+            let(:manager)      { double('application_manager', restart: nil) }
+            let(:application)  { Struct.new(:manager).new(manager) }
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: application)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it 'should delegate to the dependency' do
+              consumer.restart
+
+              expect(manager).to have_received(:restart).with(no_args)
+            end
+
+            describe 'with parameters' do
+              let(:arguments) { ['all-applications'] }
+              let(:keywords)  { { force: true } }
+
+              it 'should delegate to the dependency', :aggregate_failures do
+                restarted = false
+
+                allow(manager).to receive(:restart) { restarted = true }
+
+                consumer.restart(*arguments, **keywords)
+                expect(manager)
+                  .to have_received(:restart)
+                  .with(*arguments, **keywords)
+
+                expect(restarted).to be true
+              end
+            end
+          end
+        end
+
+        context 'when the class includes a mutable provider' do
+          let(:original_value) { { http_method: :get } }
+
+          example_constant 'Spec::RequestProvider' do
+            Spec::MutableProvider.new(key: :request, value: original_value)
+          end
+
+          before(:example) do
+            described_class.plumbum_dependency('request')
+
+            described_class.plumbum_provider Spec::RequestProvider
+          end
+
+          it { expect(consumer.request).to be Spec::RequestProvider.value }
+
+          context 'when the provider value changes' do
+            let(:changed_value) { { http_method: :post } }
+
+            before(:example) do
+              consumer.request # Cache the dependency.
+
+              Spec::RequestProvider.value = changed_value
+            end
+
+            it { expect(consumer.request).to be original_value }
+          end
+        end
+      end
+
+      describe '#:dependency?' do
+        wrap_deferred 'when the class defines dependencies' do
+          it { expect(consumer).not_to respond_to(:tools?) }
+        end
+
+        context 'when the class defines a dependency with predicate: false' do
+          before(:example) do
+            described_class.plumbum_dependency('flag_enabled', predicate: false)
+          end
+
+          it { expect(consumer).not_to respond_to(:flag_enabled?) }
+        end
+
+        context 'when the class defines a dependency with predicate: true' do
+          before(:example) do
+            described_class.plumbum_dependency('flag_enabled', predicate: true)
+          end
+
+          it 'should define the predicate' do
+            expect(consumer).to respond_to(:flag_enabled?).with(0).arguments
+          end
+
+          it { expect(consumer.flag_enabled?).to be false }
+
+          context 'with as: value' do
+            before(:example) do
+              described_class
+                .plumbum_dependency('flag_enabled', as: 'flag', predicate: true)
+            end
+
+            it { expect(consumer).to respond_to(:flag?).with(0).arguments }
+
+            it { expect(consumer.flag?).to be false }
+
+            context 'when the class defines providers' do
+              let(:flag_provider) do
+                Plumbum::OneProvider.new(:flag_enabled, value: false)
+              end
+
+              before(:example) do
+                described_class.plumbum_provider flag_provider
+              end
+
+              it { expect(consumer.flag?).to be true }
+
+              context 'when the class overwrites the method' do
+                before(:example) do
+                  described_class.define_method(:flag?) do
+                    super().to_s
+                  end
+                end
+
+                it 'should use the class definition' do
+                  expect(consumer.flag?).to eq 'true'
+                end
+              end
+            end
+          end
+
+          context 'when the class overwrites the method' do
+            before(:example) do
+              described_class.define_method(:flag_enabled?) do
+                super().to_s
+              end
+            end
+
+            it 'should use the class definition' do
+              expect(consumer.flag_enabled?).to eq 'false'
+            end
+          end
+
+          context 'when the class defines providers' do
+            let(:flag_provider) do
+              Plumbum::OneProvider.new(:flag_enabled, value: false)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider flag_provider
+            end
+
+            it { expect(consumer.flag_enabled?).to be true }
+
+            context 'when the class overwrites the method' do
+              before(:example) do
+                described_class.define_method(:flag_enabled?) do
+                  super().to_s
+                end
+              end
+
+              it 'should use the class definition' do
+                expect(consumer.flag_enabled?).to eq 'true'
+              end
+            end
+          end
+        end
+
+        context 'when the class defines a drilled dependency with a predicate' \
+        do
+          before(:example) do
+            described_class.plumbum_dependency(
+              'application.tools.object_tools',
+              predicate: true
+            )
+          end
+
+          it 'should define the predicate' do
+            expect(consumer).to respond_to(:object_tools?).with(0).arguments
+          end
+
+          it { expect(consumer.object_tools?).to be false }
+
+          context 'when the class includes a provider for the dependency' do
+            let(:application_provider) do
+              Plumbum::OneProvider.new(:application, value: Object.new.freeze)
+            end
+
+            before(:example) do
+              described_class.plumbum_provider application_provider
+            end
+
+            it { expect(consumer.object_tools?).to be true }
+          end
+        end
+      end
+    end
+  end
+end