cuprum-collections 0.4.0 → 0.5.0

data/lib/cuprum/collections/rspec/contracts/command_contracts.rb

@@ -1,10 +1,19 @@
 # frozen_string_literal: true
 
+require 'cuprum/rspec/deferred/parameter_validation_examples'
+
 require 'cuprum/collections/rspec/contracts'
 
 module Cuprum::Collections::RSpec::Contracts
   # Contracts for asserting on Command objects.
+  #
+  # @deprecated 0.5.0 Command contracts are deprecated. Use Deferred::Commands
+  #   examples instead.
   module CommandContracts
+    include Cuprum::RSpec::Deferred::ParameterValidationExamples
+
+    # :nocov:
+
     # Contract validating the behavior of an AssignOne command implementation.
     module ShouldBeAnAssignOneCommandContract
       extend RSpec::SleepingKingStudios::Contract
@@ -16,166 +25,10 @@ module Cuprum::Collections::RSpec::Contracts
       #     which the contract is applied.
       #   @param allow_extra_attributes [Boolean] if false, the command should
       #     fail if given attributes not defined for the entity.
-      contract do |allow_extra_attributes:|
-        describe '#call' do
-          shared_examples 'should assign the attributes' do
-            it { expect(result).to be_a_passing_result }
-
-            it { expect(result.value).to be_a entity.class }
-
-            it { expect(result.value).to be == expected_value }
-          end
-
-          let(:attributes) { {} }
-          let(:result) do
-            command.call(attributes: attributes, entity: entity)
-          end
-          let(:expected_attributes) do
-            initial_attributes.merge(attributes)
-          end
-          let(:expected_value) do
-            defined?(super()) ? super() : expected_attributes
-          end
-
-          it 'should validate the :attributes keyword' do
-            expect(command)
-              .to validate_parameter(:call, :attributes)
-              .using_constraint(
-                Stannum::Constraints::Types::HashWithIndifferentKeys.new
-              )
-          end
-
-          it 'should validate the :entity keyword' do
-            expect(command)
-              .to validate_parameter(:call, :entity)
-              .using_constraint(entity_type)
-              .with_parameters(attributes: {}, entity: nil)
-          end
-
-          describe 'with an empty attributes hash' do
-            let(:attributes) { {} }
-
-            include_examples 'should assign the attributes'
-          end
-
-          describe 'with an attributes hash with partial attributes' do
-            let(:attributes) { { title: 'Gideon the Ninth' } }
-
-            include_examples 'should assign the attributes'
-          end
-
-          describe 'with an attributes hash with full attributes' do
-            let(:attributes) do
-              {
-                title:    'Gideon the Ninth',
-                author:   'Tamsyn Muir',
-                series:   'The Locked Tomb',
-                category: 'Horror'
-              }
-            end
-
-            include_examples 'should assign the attributes'
-          end
-
-          describe 'with an attributes hash with extra attributes' do
-            let(:attributes) do
-              {
-                title:     'The Book of Lost Tales',
-                audiobook: true
-              }
-            end
-
-            if allow_extra_attributes
-              include_examples 'should assign the attributes'
-            else
-              # :nocov:
-              let(:valid_attributes) do
-                defined?(super()) ? super() : expected_attributes.keys
-              end
-              let(:expected_error) do
-                Cuprum::Collections::Errors::ExtraAttributes.new(
-                  entity_class:     entity.class,
-                  extra_attributes: %w[audiobook],
-                  valid_attributes: valid_attributes
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(result).to be_a_failing_result.with_error(expected_error)
-              end
-              # :nocov:
-            end
-          end
-
-          context 'when the entity has existing attributes' do
-            let(:initial_attributes) do
-              # :nocov:
-              if defined?(super())
-                super().merge(fixtures_data.first)
-              else
-                fixtures_data.first
-              end
-              # :nocov:
-            end
-
-            describe 'with an empty attributes hash' do
-              let(:attributes) { {} }
-
-              include_examples 'should assign the attributes'
-            end
-
-            describe 'with an attributes hash with partial attributes' do
-              let(:attributes) { { title: 'Gideon the Ninth' } }
-
-              include_examples 'should assign the attributes'
-            end
-
-            describe 'with an attributes hash with full attributes' do
-              let(:attributes) do
-                {
-                  title:    'Gideon the Ninth',
-                  author:   'Tamsyn Muir',
-                  series:   'The Locked Tomb',
-                  category: 'Horror'
-                }
-              end
-
-              include_examples 'should assign the attributes'
-            end
-
-            describe 'with an attributes hash with extra attributes' do
-              let(:attributes) do
-                {
-                  title:     'The Book of Lost Tales',
-                  audiobook: true
-                }
-              end
-
-              if allow_extra_attributes
-                include_examples 'should assign the attributes'
-              else
-                # :nocov:
-                let(:valid_attributes) do
-                  defined?(super()) ? super() : expected_attributes.keys
-                end
-                let(:expected_error) do
-                  Cuprum::Collections::Errors::ExtraAttributes.new(
-                    entity_class:     entity.class,
-                    extra_attributes: %w[audiobook],
-                    valid_attributes: valid_attributes
-                  )
-                end
-
-                it 'should return a failing result' do
-                  expect(result)
-                    .to be_a_failing_result
-                    .with_error(expected_error)
-                end
-                # :nocov:
-              end
-            end
-          end
-        end
+      contract do |**|
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the AssignOne command"` instead.'
       end
     end
 
@@ -190,92 +43,14 @@ module Cuprum::Collections::RSpec::Contracts
       #     which the contract is applied.
       #   @param allow_extra_attributes [Boolean] if false, the command should
       #     fail if given attributes not defined for the entity.
-      contract do |allow_extra_attributes:|
-        include Stannum::RSpec::Matchers
-
-        describe '#call' do
-          shared_examples 'should build the entity' do
-            it { expect(result).to be_a_passing_result }
-
-            it { expect(result.value).to be == expected_value }
-          end
-
-          let(:attributes) { {} }
-          let(:result)     { command.call(attributes: attributes) }
-          let(:expected_attributes) do
-            attributes
-          end
-          let(:expected_value) do
-            defined?(super()) ? super() : attributes
-          end
-
-          it 'should validate the :attributes keyword' do
-            expect(command)
-              .to validate_parameter(:call, :attributes)
-              .using_constraint(
-                Stannum::Constraints::Types::HashWithIndifferentKeys.new
-              )
-          end
-
-          describe 'with an empty attributes hash' do
-            let(:attributes) { {} }
-
-            include_examples 'should build the entity'
-          end
-
-          describe 'with an attributes hash with partial attributes' do
-            let(:attributes) { { title: 'Gideon the Ninth' } }
-
-            include_examples 'should build the entity'
-          end
-
-          describe 'with an attributes hash with full attributes' do
-            let(:attributes) do
-              {
-                title:    'Gideon the Ninth',
-                author:   'Tamsyn Muir',
-                series:   'The Locked Tomb',
-                category: 'Horror'
-              }
-            end
-
-            include_examples 'should build the entity'
-          end
-
-          describe 'with an attributes hash with extra attributes' do
-            let(:attributes) do
-              {
-                title:     'The Book of Lost Tales',
-                audiobook: true
-              }
-            end
-
-            if allow_extra_attributes
-              include_examples 'should build the entity'
-            else
-              # :nocov:
-              let(:valid_attributes) do
-                defined?(super()) ? super() : expected_attributes.keys
-              end
-              let(:expected_error) do
-                Cuprum::Collections::Errors::ExtraAttributes.new(
-                  entity_class:     entity_type,
-                  extra_attributes: %w[audiobook],
-                  valid_attributes: valid_attributes
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(result).to be_a_failing_result.with_error(expected_error)
-              end
-              # :nocov:
-            end
-          end
-        end
+      contract do |**|
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the BuildOne command"` instead.'
       end
     end
 
-    # Contract validating the behavior of a FindOne command implementation.
+    # Contract validating the behavior of a DestroyOne command implementation.
     module ShouldBeADestroyOneCommandContract
       extend RSpec::SleepingKingStudios::Contract
 
@@ -285,107 +60,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        describe '#call' do
-          let(:mapped_data) do
-            defined?(super()) ? super() : data
-          end
-          let(:primary_key_name) { defined?(super()) ? super() : 'id' }
-          let(:primary_key_type) { defined?(super()) ? super() : Integer }
-          let(:invalid_primary_key_value) do
-            defined?(super()) ? super() : 100
-          end
-          let(:valid_primary_key_value) do
-            defined?(super()) ? super() : 0
-          end
-
-          it 'should validate the :primary_key keyword' do
-            expect(command)
-              .to validate_parameter(:call, :primary_key)
-              .using_constraint(primary_key_type)
-          end
-
-          describe 'with an invalid primary key' do
-            let(:primary_key) { invalid_primary_key_value }
-            let(:expected_error) do
-              Cuprum::Collections::Errors::NotFound.new(
-                attribute_name:  primary_key_name,
-                attribute_value: primary_key,
-                collection_name: collection_name,
-                primary_key:     true
-              )
-            end
-
-            it 'should return a failing result' do
-              expect(command.call(primary_key: primary_key))
-                .to be_a_failing_result
-                .with_error(expected_error)
-            end
-
-            it 'should not remove an entity from the collection' do
-              expect { command.call(primary_key: primary_key) }
-                .not_to(change { query.reset.count })
-            end
-          end
-
-          context 'when the collection has many items' do
-            let(:data) { fixtures_data }
-            let(:matching_data) do
-              mapped_data.find do |item|
-                item[primary_key_name.to_s] == primary_key
-              end
-            end
-            let!(:expected_data) do
-              defined?(super()) ? super() : matching_data
-            end
-
-            describe 'with an invalid primary key' do
-              let(:primary_key) { invalid_primary_key_value }
-              let(:expected_error) do
-                Cuprum::Collections::Errors::NotFound.new(
-                  attribute_name:  primary_key_name,
-                  attribute_value: primary_key,
-                  collection_name: collection_name,
-                  primary_key:     true
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(primary_key: primary_key))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-
-              it 'should not remove an entity from the collection' do
-                expect { command.call(primary_key: primary_key) }
-                  .not_to(change { query.reset.count })
-              end
-            end
-
-            describe 'with a valid primary key' do
-              let(:primary_key) { valid_primary_key_value }
-
-              it 'should return a passing result' do
-                expect(command.call(primary_key: primary_key))
-                  .to be_a_passing_result
-                  .with_value(expected_data)
-              end
-
-              it 'should remove an entity from the collection' do
-                expect { command.call(primary_key: primary_key) }
-                  .to(
-                    change { query.reset.count }.by(-1)
-                  )
-              end
-
-              it 'should remove the entity from the collection' do
-                command.call(primary_key: primary_key)
-
-                expect(query.map { |item| item[primary_key_name.to_s] })
-                  .not_to include primary_key
-              end
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the DestroyOne command"` instead.'
       end
     end
 
@@ -399,424 +76,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        describe '#call' do
-          let(:mapped_data) do
-            defined?(super()) ? super() : data
-          end
-          let(:primary_key_name) { defined?(super()) ? super() : 'id' }
-          let(:primary_key_type) { defined?(super()) ? super() : Integer }
-          let(:primary_keys_contract) do
-            Stannum::Constraints::Types::ArrayType
-              .new(item_type: primary_key_type)
-          end
-          let(:invalid_primary_key_values) do
-            defined?(super()) ? super() : [100, 101, 102]
-          end
-          let(:valid_primary_key_values) do
-            defined?(super()) ? super() : [0, 1, 2]
-          end
-
-          it 'should validate the :allow_partial keyword' do
-            expect(command)
-              .to validate_parameter(:call, :allow_partial)
-              .using_constraint(Stannum::Constraints::Boolean.new)
-          end
-
-          it 'should validate the :envelope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :envelope)
-              .using_constraint(Stannum::Constraints::Boolean.new)
-          end
-
-          it 'should validate the :primary_keys keyword' do
-            expect(command)
-              .to validate_parameter(:call, :primary_keys)
-              .using_constraint(Array)
-          end
-
-          it 'should validate the :primary_keys keyword items' do
-            expect(command)
-              .to validate_parameter(:call, :primary_keys)
-              .with_value([nil])
-              .using_constraint(primary_keys_contract)
-          end
-
-          it 'should validate the :scope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :scope)
-              .using_constraint(
-                Stannum::Constraints::Type.new(query.class, optional: true)
-              )
-              .with_value(Object.new.freeze)
-          end
-
-          describe 'with an array of invalid primary keys' do
-            let(:primary_keys) { invalid_primary_key_values }
-            let(:expected_error) do
-              Cuprum::Errors::MultipleErrors.new(
-                errors: primary_keys.map do |primary_key|
-                  Cuprum::Collections::Errors::NotFound.new(
-                    attribute_name:  primary_key_name,
-                    attribute_value: primary_key,
-                    collection_name: command.collection_name,
-                    primary_key:     true
-                  )
-                end
-              )
-            end
-
-            it 'should return a failing result' do
-              expect(command.call(primary_keys: primary_keys))
-                .to be_a_failing_result
-                .with_error(expected_error)
-            end
-          end
-
-          context 'when the collection has many items' do
-            let(:data) { fixtures_data }
-            let(:matching_data) do
-              primary_keys
-                .map do |key|
-                  mapped_data.find { |item| item[primary_key_name.to_s] == key }
-                end
-            end
-            let(:expected_data) do
-              defined?(super()) ? super() : matching_data
-            end
-
-            describe 'with an array of invalid primary keys' do
-              let(:primary_keys) { invalid_primary_key_values }
-              let(:expected_error) do
-                Cuprum::Errors::MultipleErrors.new(
-                  errors: primary_keys.map do |primary_key|
-                    Cuprum::Collections::Errors::NotFound.new(
-                      attribute_name:  primary_key_name,
-                      attribute_value: primary_key,
-                      collection_name: command.collection_name,
-                      primary_key:     true
-                    )
-                  end
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(primary_keys: primary_keys))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-            end
-
-            describe 'with a partially valid array of primary keys' do
-              let(:primary_keys) do
-                invalid_primary_key_values + valid_primary_key_values
-              end
-              let(:expected_error) do
-                Cuprum::Errors::MultipleErrors.new(
-                  errors: primary_keys.map do |primary_key|
-                    unless invalid_primary_key_values.include?(primary_key)
-                      next nil
-                    end
-
-                    Cuprum::Collections::Errors::NotFound.new(
-                      attribute_name:  primary_key_name,
-                      attribute_value: primary_key,
-                      collection_name: command.collection_name,
-                      primary_key:     true
-                    )
-                  end
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(primary_keys: primary_keys))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-            end
-
-            describe 'with a valid array of primary keys' do
-              let(:primary_keys) { valid_primary_key_values }
-
-              it 'should return a passing result' do
-                expect(command.call(primary_keys: primary_keys))
-                  .to be_a_passing_result
-                  .with_value(expected_data)
-              end
-
-              describe 'with an ordered array of primary keys' do
-                let(:primary_keys) { valid_primary_key_values.reverse }
-
-                it 'should return a passing result' do
-                  expect(command.call(primary_keys: primary_keys))
-                    .to be_a_passing_result
-                    .with_value(expected_data)
-                end
-              end
-            end
-
-            describe 'with allow_partial: true' do
-              describe 'with an array of invalid primary keys' do
-                let(:primary_keys) { invalid_primary_key_values }
-                let(:expected_error) do
-                  Cuprum::Errors::MultipleErrors.new(
-                    errors: invalid_primary_key_values.map do |primary_key|
-                      Cuprum::Collections::Errors::NotFound.new(
-                        attribute_name:  primary_key_name,
-                        attribute_value: primary_key,
-                        collection_name: command.collection_name,
-                        primary_key:     true
-                      )
-                    end
-                  )
-                end
-
-                it 'should return a failing result' do
-                  expect(command.call(primary_keys: primary_keys))
-                    .to be_a_failing_result
-                    .with_error(expected_error)
-                end
-              end
-
-              describe 'with a partially valid array of primary keys' do
-                let(:primary_keys) do
-                  invalid_primary_key_values + valid_primary_key_values
-                end
-                let(:expected_error) do
-                  Cuprum::Errors::MultipleErrors.new(
-                    errors: primary_keys.map do |primary_key|
-                      unless invalid_primary_key_values.include?(primary_key)
-                        next nil
-                      end
-
-                      Cuprum::Collections::Errors::NotFound.new(
-                        attribute_name:  primary_key_name,
-                        attribute_value: primary_key,
-                        collection_name: command.collection_name,
-                        primary_key:     true
-                      )
-                    end
-                  )
-                end
-
-                it 'should return a passing result' do
-                  expect(
-                    command.call(
-                      primary_keys:  primary_keys,
-                      allow_partial: true
-                    )
-                  )
-                    .to be_a_passing_result
-                    .with_value(expected_data)
-                    .and_error(expected_error)
-                end
-              end
-
-              describe 'with a valid array of primary keys' do
-                let(:primary_keys) { valid_primary_key_values }
-
-                it 'should return a passing result' do
-                  expect(
-                    command.call(
-                      primary_keys:  primary_keys,
-                      allow_partial: true
-                    )
-                  )
-                    .to be_a_passing_result
-                    .with_value(expected_data)
-                end
-
-                describe 'with an ordered array of primary keys' do
-                  let(:primary_keys) { valid_primary_key_values.reverse }
-
-                  it 'should return a passing result' do
-                    expect(
-                      command.call(
-                        primary_keys:  primary_keys,
-                        allow_partial: true
-                      )
-                    )
-                      .to be_a_passing_result
-                      .with_value(expected_data)
-                  end
-                end
-              end
-            end
-
-            describe 'with envelope: true' do
-              describe 'with a valid array of primary keys' do
-                let(:primary_keys) { valid_primary_key_values }
-
-                it 'should return a passing result' do
-                  expect(
-                    command.call(primary_keys: primary_keys, envelope: true)
-                  )
-                    .to be_a_passing_result
-                    .with_value({ collection_name => expected_data })
-                end
-
-                describe 'with an ordered array of primary keys' do
-                  let(:primary_keys) { valid_primary_key_values.reverse }
-
-                  it 'should return a passing result' do
-                    expect(
-                      command.call(primary_keys: primary_keys, envelope: true)
-                    )
-                      .to be_a_passing_result
-                      .with_value({ collection_name => expected_data })
-                  end
-                end
-              end
-            end
-
-            describe 'with scope: query' do
-              let(:scope_filter) { -> { {} } }
-
-              describe 'with an array of invalid primary keys' do
-                let(:primary_keys) { invalid_primary_key_values }
-                let(:expected_error) do
-                  Cuprum::Errors::MultipleErrors.new(
-                    errors: primary_keys.map do |primary_key|
-                      Cuprum::Collections::Errors::NotFound.new(
-                        attribute_name:  primary_key_name,
-                        attribute_value: primary_key,
-                        collection_name: command.collection_name,
-                        primary_key:     true
-                      )
-                    end
-                  )
-                end
-
-                it 'should return a failing result' do
-                  expect(command.call(primary_keys: primary_keys, scope: scope))
-                    .to be_a_failing_result
-                    .with_error(expected_error)
-                end
-              end
-
-              describe 'with a scope that does not match any keys' do
-                let(:scope_filter) { -> { { author: 'Ursula K. LeGuin' } } }
-
-                describe 'with a valid array of primary keys' do
-                  let(:primary_keys) { valid_primary_key_values }
-                  let(:expected_error) do
-                    Cuprum::Errors::MultipleErrors.new(
-                      errors: primary_keys.map do |primary_key|
-                        Cuprum::Collections::Errors::NotFound.new(
-                          attribute_name:  primary_key_name,
-                          attribute_value: primary_key,
-                          collection_name: command.collection_name,
-                          primary_key:     true
-                        )
-                      end
-                    )
-                  end
-
-                  it 'should return a failing result' do
-                    expect(
-                      command.call(primary_keys: primary_keys, scope: scope)
-                    )
-                      .to be_a_failing_result
-                      .with_error(expected_error)
-                  end
-                end
-              end
-
-              describe 'with a scope that matches some keys' do
-                let(:scope_filter) { -> { { series: nil } } }
-                let(:matching_data) do
-                  super().map do |item|
-                    next nil unless item['series'].nil?
-
-                    item
-                  end
-                end
-
-                describe 'with a valid array of primary keys' do
-                  let(:primary_keys) { valid_primary_key_values }
-                  let(:expected_error) do
-                    found_keys =
-                      matching_data
-                        .compact
-                        .map { |item| item[primary_key_name.to_s] }
-
-                    Cuprum::Errors::MultipleErrors.new(
-                      errors: primary_keys.map do |primary_key|
-                        next if found_keys.include?(primary_key)
-
-                        Cuprum::Collections::Errors::NotFound.new(
-                          attribute_name:  primary_key_name,
-                          attribute_value: primary_key,
-                          collection_name: command.collection_name,
-                          primary_key:     true
-                        )
-                      end
-                    )
-                  end
-
-                  it 'should return a failing result' do
-                    expect(
-                      command.call(primary_keys: primary_keys, scope: scope)
-                    )
-                      .to be_a_failing_result
-                      .with_error(expected_error)
-                  end
-                end
-
-                describe 'with allow_partial: true' do
-                  describe 'with a valid array of primary keys' do
-                    let(:primary_keys) { valid_primary_key_values }
-                    let(:expected_error) do
-                      found_keys =
-                        matching_data
-                          .compact
-                          .map { |item| item[primary_key_name.to_s] }
-
-                      Cuprum::Errors::MultipleErrors.new(
-                        errors: primary_keys.map do |primary_key|
-                          next if found_keys.include?(primary_key)
-
-                          Cuprum::Collections::Errors::NotFound.new(
-                            attribute_name:  primary_key_name,
-                            attribute_value: primary_key,
-                            collection_name: command.collection_name,
-                            primary_key:     true
-                          )
-                        end
-                      )
-                    end
-
-                    it 'should return a passing result' do
-                      expect(
-                        command.call(
-                          allow_partial: true,
-                          primary_keys:  primary_keys,
-                          scope:         scope
-                        )
-                      )
-                        .to be_a_passing_result
-                        .with_value(expected_data)
-                        .and_error(expected_error)
-                    end
-                  end
-                end
-              end
-
-              describe 'with a scope that matches all keys' do
-                let(:scope_filter) { -> { { author: 'J.R.R. Tolkien' } } }
-
-                describe 'with a valid array of primary keys' do
-                  let(:primary_keys) { valid_primary_key_values }
-
-                  it 'should return a passing result' do
-                    expect(command.call(primary_keys: primary_keys))
-                      .to be_a_passing_result
-                      .with_value(expected_data)
-                  end
-                end
-              end
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the FindMany command"` instead.'
       end
     end
 
@@ -830,190 +92,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        include Stannum::RSpec::Matchers
-        include Cuprum::Collections::RSpec::Contracts::QueryContracts
-
-        describe '#call' do
-          include_contract 'with query contexts'
-
-          shared_examples 'should return the matching items' do
-            it { expect(result).to be_a_passing_result }
-
-            it { expect(result.value).to be_a Enumerator }
-
-            it { expect(result.value.to_a).to be == expected_data }
-          end
-
-          shared_examples 'should return the wrapped items' do
-            it { expect(result).to be_a_passing_result }
-
-            it { expect(result.value).to be_a Hash }
-
-            it { expect(result.value.keys).to be == [collection_name] }
-
-            it { expect(result.value[collection_name]).to be == expected_data }
-          end
-
-          let(:options) do
-            opts = {}
-
-            opts[:limit]  = limit  if limit
-            opts[:offset] = offset if offset
-            opts[:order]  = order  if order
-            opts[:where]  = filter unless filter.nil? || filter.is_a?(Proc)
-
-            opts
-          end
-          let(:block)         { filter.is_a?(Proc) ? filter : nil }
-          let(:result)        { command.call(**options, &block) }
-          let(:data)          { [] }
-          let(:matching_data) { data }
-          let(:expected_data) do
-            defined?(super()) ? super() : matching_data
-          end
-
-          it 'should validate the :envelope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :envelope)
-              .using_constraint(Stannum::Constraints::Boolean.new)
-          end
-
-          it 'should validate the :limit keyword' do
-            expect(command)
-              .to validate_parameter(:call, :limit)
-              .with_value(Object.new)
-              .using_constraint(Integer, required: false)
-          end
-
-          it 'should validate the :offset keyword' do
-            expect(command)
-              .to validate_parameter(:call, :offset)
-              .with_value(Object.new)
-              .using_constraint(Integer, required: false)
-          end
-
-          it 'should validate the :order keyword' do
-            constraint = Cuprum::Collections::Constraints::Ordering.new
-
-            expect(command)
-              .to validate_parameter(:call, :order)
-              .with_value(Object.new)
-              .using_constraint(constraint, required: false)
-          end
-
-          it 'should validate the :scope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :scope)
-              .using_constraint(
-                Stannum::Constraints::Type.new(query.class, optional: true)
-              )
-              .with_value(Object.new.freeze)
-          end
-
-          it 'should validate the :where keyword' do
-            expect(command).to validate_parameter(:call, :where)
-          end
-
-          include_examples 'should return the matching items'
-
-          include_contract 'should perform queries',
-            block: lambda {
-              include_examples 'should return the matching items'
-            }
-
-          describe 'with an invalid filter block' do
-            let(:block) { -> {} }
-            let(:expected_error) do
-              an_instance_of(Cuprum::Collections::Errors::InvalidQuery)
-            end
-
-            it 'should return a failing result' do
-              expect(result).to be_a_failing_result.with_error(expected_error)
-            end
-          end
-
-          describe 'with envelope: true' do
-            let(:options) { super().merge(envelope: true) }
-
-            include_examples 'should return the wrapped items'
-
-            include_contract 'should perform queries',
-              block: lambda {
-                include_examples 'should return the wrapped items'
-              }
-          end
-
-          context 'when the collection has many items' do
-            let(:data) { fixtures_data }
-
-            include_examples 'should return the matching items'
-
-            include_contract 'should perform queries',
-              block: lambda {
-                include_examples 'should return the matching items'
-              }
-
-            describe 'with envelope: true' do
-              let(:options) { super().merge(envelope: true) }
-
-              include_examples 'should return the wrapped items'
-
-              include_contract 'should perform queries',
-                block: lambda {
-                  include_examples 'should return the wrapped items'
-                }
-            end
-
-            describe 'with scope: query' do
-              let(:scope_filter) { -> { {} } }
-              let(:options)      { super().merge(scope: scope) }
-
-              describe 'with a scope that does not match any values' do
-                let(:scope_filter)  { -> { { series: 'Mistborn' } } }
-                let(:matching_data) { [] }
-
-                include_examples 'should return the matching items'
-              end
-
-              describe 'with a scope that matches some values' do
-                let(:scope_filter) { -> { { series: nil } } }
-                let(:matching_data) do
-                  super().select { |item| item['series'].nil? }
-                end
-
-                include_examples 'should return the matching items'
-
-                describe 'with a where filter' do
-                  let(:filter)  { -> { { author: 'Ursula K. LeGuin' } } }
-                  let(:options) { super().merge(where: filter) }
-                  let(:matching_data) do
-                    super()
-                      .select { |item| item['author'] == 'Ursula K. LeGuin' }
-                  end
-
-                  include_examples 'should return the matching items'
-                end
-              end
-
-              describe 'with a scope that matches all values' do
-                let(:scope_filter) { -> { { id: not_equal(nil) } } }
-
-                include_examples 'should return the matching items'
-
-                describe 'with a where filter' do
-                  let(:filter)  { -> { { author: 'Ursula K. LeGuin' } } }
-                  let(:options) { super().merge(where: filter) }
-                  let(:matching_data) do
-                    super()
-                      .select { |item| item['author'] == 'Ursula K. LeGuin' }
-                  end
-
-                  include_examples 'should return the matching items'
-                end
-              end
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the FindMatching command"` instead.'
       end
     end
 
@@ -1027,155 +108,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        describe '#call' do
-          let(:mapped_data) do
-            defined?(super()) ? super() : data
-          end
-          let(:primary_key_name) { defined?(super()) ? super() : 'id' }
-          let(:primary_key_type) { defined?(super()) ? super() : Integer }
-          let(:invalid_primary_key_value) do
-            defined?(super()) ? super() : 100
-          end
-          let(:valid_primary_key_value) do
-            defined?(super()) ? super() : 0
-          end
-
-          def tools
-            SleepingKingStudios::Tools::Toolbelt.instance
-          end
-
-          it 'should validate the :envelope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :envelope)
-              .using_constraint(Stannum::Constraints::Boolean.new)
-          end
-
-          it 'should validate the :primary_key keyword' do
-            expect(command)
-              .to validate_parameter(:call, :primary_key)
-              .using_constraint(primary_key_type)
-          end
-
-          it 'should validate the :scope keyword' do
-            expect(command)
-              .to validate_parameter(:call, :scope)
-              .using_constraint(
-                Stannum::Constraints::Type.new(query.class, optional: true)
-              )
-              .with_value(Object.new.freeze)
-          end
-
-          describe 'with an invalid primary key' do
-            let(:primary_key) { invalid_primary_key_value }
-            let(:expected_error) do
-              Cuprum::Collections::Errors::NotFound.new(
-                attribute_name:  primary_key_name,
-                attribute_value: primary_key,
-                collection_name: command.collection_name,
-                primary_key:     true
-              )
-            end
-
-            it 'should return a failing result' do
-              expect(command.call(primary_key: primary_key))
-                .to be_a_failing_result
-                .with_error(expected_error)
-            end
-          end
-
-          context 'when the collection has many items' do
-            let(:data) { fixtures_data }
-            let(:matching_data) do
-              mapped_data
-                .find { |item| item[primary_key_name.to_s] == primary_key }
-            end
-            let(:expected_data) do
-              defined?(super()) ? super() : matching_data
-            end
-
-            describe 'with an invalid primary key' do
-              let(:primary_key) { invalid_primary_key_value }
-              let(:expected_error) do
-                Cuprum::Collections::Errors::NotFound.new(
-                  attribute_name:  primary_key_name,
-                  attribute_value: primary_key,
-                  collection_name: command.collection_name,
-                  primary_key:     true
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(primary_key: primary_key))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-            end
-
-            describe 'with a valid primary key' do
-              let(:primary_key) { valid_primary_key_value }
-
-              it 'should return a passing result' do
-                expect(command.call(primary_key: primary_key))
-                  .to be_a_passing_result
-                  .with_value(expected_data)
-              end
-            end
-
-            describe 'with envelope: true' do
-              let(:member_name) { tools.str.singularize(collection_name) }
-
-              describe 'with a valid primary key' do
-                let(:primary_key) { valid_primary_key_value }
-
-                it 'should return a passing result' do
-                  expect(command.call(primary_key: primary_key, envelope: true))
-                    .to be_a_passing_result
-                    .with_value({ member_name => expected_data })
-                end
-              end
-            end
-
-            describe 'with scope: query' do
-              let(:scope_filter) { -> { {} } }
-
-              describe 'with a scope that does not match the key' do
-                let(:scope_filter) { -> { { author: 'Ursula K. LeGuin' } } }
-
-                describe 'with an valid primary key' do
-                  let(:primary_key) { valid_primary_key_value }
-                  let(:expected_error) do
-                    Cuprum::Collections::Errors::NotFound.new(
-                      attribute_name:  primary_key_name,
-                      attribute_value: primary_key,
-                      collection_name: command.collection_name,
-                      primary_key:     true
-                    )
-                  end
-
-                  it 'should return a failing result' do
-                    expect(command.call(primary_key: primary_key, scope: scope))
-                      .to be_a_failing_result
-                      .with_error(expected_error)
-                  end
-                end
-              end
-
-              describe 'with a scope that matches the key' do
-                let(:scope_filter) { -> { { author: 'J.R.R. Tolkien' } } }
-
-                describe 'with a valid primary key' do
-                  let(:primary_key) { valid_primary_key_value }
-
-                  it 'should return a passing result' do
-                    expect(command.call(primary_key: primary_key))
-                      .to be_a_passing_result
-                      .with_value(expected_data)
-                  end
-                end
-              end
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the FindOne command"` instead.'
       end
     end
 
@@ -1189,84 +124,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        describe '#call' do
-          let(:matching_data) { attributes }
-          let(:expected_data) do
-            defined?(super()) ? super() : matching_data
-          end
-          let(:primary_key_name) do
-            defined?(super()) ? super() : 'id'
-          end
-          let(:primary_key_type) do
-            defined?(super()) ? super() : Integer
-          end
-          let(:scoped) do
-            key    = primary_key_name
-            value  = entity[primary_key_name.to_s]
-
-            query.where { { key => value } }
-          end
-
-          it 'should validate the :entity keyword' do
-            expect(command)
-              .to validate_parameter(:call, :entity)
-              .using_constraint(entity_type)
-          end
-
-          context 'when the item does not exist in the collection' do
-            it 'should return a passing result' do
-              expect(command.call(entity: entity))
-                .to be_a_passing_result
-                .with_value(be == expected_data)
-            end
-
-            it 'should append an item to the collection' do
-              expect { command.call(entity: entity) }
-                .to(
-                  change { query.reset.count }
-                  .by(1)
-                )
-            end
-
-            it 'should add the entity to the collection' do
-              expect { command.call(entity: entity) }
-                .to change(scoped, :exists?)
-                .to be true
-            end
-
-            it 'should set the attributes' do
-              command.call(entity: entity)
-
-              expect(scoped.to_a.first).to be == expected_data
-            end
-          end
-
-          context 'when the item exists in the collection' do
-            let(:data) { fixtures_data }
-            let(:expected_error) do
-              Cuprum::Collections::Errors::AlreadyExists.new(
-                attribute_name:  primary_key_name,
-                attribute_value: attributes.fetch(
-                  primary_key_name.to_s,
-                  attributes[primary_key_name.intern]
-                ),
-                collection_name: collection_name,
-                primary_key:     true
-              )
-            end
-
-            it 'should return a failing result' do
-              expect(command.call(entity: entity))
-                .to be_a_failing_result
-                .with_error(expected_error)
-            end
-
-            it 'should not append an item to the collection' do
-              expect { command.call(entity: entity) }
-                .not_to(change { query.reset.count })
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the InsertOne command"` instead.'
       end
     end
 
@@ -1280,80 +140,9 @@ module Cuprum::Collections::RSpec::Contracts
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
       contract do
-        describe '#call' do
-          let(:mapped_data) do
-            defined?(super()) ? super() : data
-          end
-          let(:matching_data) { attributes }
-          let(:expected_data) do
-            defined?(super()) ? super() : matching_data
-          end
-          let(:primary_key_name) do
-            defined?(super()) ? super() : 'id'
-          end
-          let(:scoped) do
-            key    = primary_key_name
-            value  = entity[primary_key_name.to_s]
-
-            query.where { { key => value } }
-          end
-
-          it 'should validate the :entity keyword' do
-            expect(command)
-              .to validate_parameter(:call, :entity)
-              .using_constraint(entity_type)
-          end
-
-          context 'when the item does not exist in the collection' do
-            let(:expected_error) do
-              Cuprum::Collections::Errors::NotFound.new(
-                attribute_name:  primary_key_name,
-                attribute_value: attributes.fetch(
-                  primary_key_name.to_s,
-                  attributes[primary_key_name.intern]
-                ),
-                collection_name: collection_name,
-                primary_key:     true
-              )
-            end
-            let(:matching_data) { mapped_data.first }
-
-            it 'should return a failing result' do
-              expect(command.call(entity: entity))
-                .to be_a_failing_result
-                .with_error(expected_error)
-            end
-
-            it 'should not append an item to the collection' do
-              expect { command.call(entity: entity) }
-                .not_to(change { query.reset.count })
-            end
-          end
-
-          context 'when the item exists in the collection' do
-            let(:data) { fixtures_data }
-            let(:matching_data) do
-              mapped_data.first.merge(super())
-            end
-
-            it 'should return a passing result' do
-              expect(command.call(entity: entity))
-                .to be_a_passing_result
-                .with_value(be == expected_data)
-            end
-
-            it 'should not append an item to the collection' do
-              expect { command.call(entity: entity) }
-                .not_to(change { query.reset.count })
-            end
-
-            it 'should set the attributes' do
-              command.call(entity: entity)
-
-              expect(scoped.to_a.first).to be == expected_data
-            end
-          end
-        end
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the UpdateOne command"` instead.'
       end
     end
 
@@ -1368,95 +157,13 @@ module Cuprum::Collections::RSpec::Contracts
       #     default contract.
       #   @param example_group [RSpec::Core::ExampleGroup] the example group to
       #     which the contract is applied.
-      contract do |default_contract:|
-        describe '#call' do
-          it 'should validate the :contract keyword' do
-            expect(command)
-              .to validate_parameter(:call, :contract)
-              .with_value(Object.new.freeze)
-              .using_constraint(Stannum::Constraints::Base, optional: true)
-          end
-
-          it 'should validate the :entity keyword' do
-            expect(command)
-              .to validate_parameter(:call, :entity)
-              .with_value(Object.new.freeze)
-              .using_constraint(entity_type)
-          end
-
-          describe 'with contract: nil' do
-            if default_contract
-              context 'when the entity does not match the default contract' do
-                let(:attributes) { invalid_default_attributes }
-                let(:expected_error) do
-                  Cuprum::Collections::Errors::FailedValidation.new(
-                    entity_class: entity.class,
-                    errors:       expected_errors
-                  )
-                end
-
-                it 'should return a failing result' do
-                  expect(command.call(entity: entity))
-                    .to be_a_failing_result
-                    .with_error(expected_error)
-                end
-              end
-
-              context 'when the entity matches the default contract' do
-                let(:attributes) { valid_default_attributes }
-
-                it 'should return a passing result' do
-                  expect(command.call(entity: entity))
-                    .to be_a_passing_result
-                    .with_value(entity)
-                end
-              end
-            else
-              let(:attributes) { valid_attributes }
-              let(:expected_error) do
-                Cuprum::Collections::Errors::MissingDefaultContract.new(
-                  entity_class: entity.class
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(entity: entity))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-            end
-          end
-
-          describe 'with contract: value' do
-            context 'when the entity does not match the contract' do
-              let(:attributes) { invalid_attributes }
-              let(:errors)     { contract.errors_for(entity) }
-              let(:expected_error) do
-                Cuprum::Collections::Errors::FailedValidation.new(
-                  entity_class: entity.class,
-                  errors:       errors
-                )
-              end
-
-              it 'should return a failing result' do
-                expect(command.call(contract: contract, entity: entity))
-                  .to be_a_failing_result
-                  .with_error(expected_error)
-              end
-            end
-
-            context 'when the entity matches the contract' do
-              let(:attributes) { valid_attributes }
-
-              it 'should return a passing result' do
-                expect(command.call(contract: contract, entity: entity))
-                  .to be_a_passing_result
-                  .with_value(entity)
-              end
-            end
-          end
-        end
+      contract do |**|
+        pending \
+          'Command contracts are deprecated. Use `include_deferred "should ' \
+          'implement the ValidateOne command"` instead.'
       end
     end
+
+    # :nocov:
   end
 end