cuprum-collections 0.4.0 → 0.5.0

data/lib/cuprum/collections/rspec/deferred/commands/find_one_examples.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/deferred/command_examples'
+require 'cuprum/collections/rspec/deferred/commands'
+
+module Cuprum::Collections::RSpec::Deferred::Commands
+  # Namespace for deferred example groups for validating FindOne commands.
+  module FindOneExamples
+    include RSpec::SleepingKingStudios::Deferred::Provider
+
+    deferred_examples 'should implement the FindOne command' do
+      describe '#call' do
+        include Cuprum::Collections::RSpec::Deferred::CommandExamples
+
+        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
+        let(:primary_key) { valid_primary_key_value }
+        let(:options)     { {} }
+
+        def call_command
+          command.call(primary_key:, **options)
+        end
+
+        include_deferred 'should validate the primary key parameter'
+
+        describe 'with an invalid envelope value' do
+          let(:options) { super().merge(envelope: Object.new.freeze) }
+
+          include_deferred 'should validate the parameter',
+            :envelope,
+            'sleeping_king_studios.tools.assertions.boolean'
+        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:  collection.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:))
+              .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:  collection.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:))
+                .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:))
+                .to be_a_passing_result
+                .with_value(expected_data)
+            end
+          end
+
+          describe 'with envelope: true' do
+            let(:member_name) { collection.singular_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:, envelope: true))
+                  .to be_a_passing_result
+                  .with_value(match({ member_name => expected_data }))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cuprum/collections/rspec/deferred/commands/insert_one_examples.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/deferred/command_examples'
+require 'cuprum/collections/rspec/deferred/commands'
+
+module Cuprum::Collections::RSpec::Deferred::Commands
+  # Namespace for deferred example groups for validating InsertOne commands.
+  module InsertOneExamples
+    include RSpec::SleepingKingStudios::Deferred::Provider
+
+    deferred_examples 'should implement the InsertOne command' do
+      describe '#call' do
+        include Cuprum::Collections::RSpec::Deferred::CommandExamples
+
+        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]
+
+          collection.query.where { { key => value } }
+        end
+
+        def call_command
+          command.call(entity:)
+        end
+
+        if defined_deferred_examples? 'should validate the entity'
+          include_deferred 'should validate the entity'
+        else
+          # :nocov:
+          pending \
+            'the command should validate the entity parameter, but entity ' \
+            'validation is not defined - implement a "should validate the ' \
+            'entity" deferred example group to resolve this warning'
+          # :nocov:
+        end
+
+        context 'when the item does not exist in the collection' do
+          it 'should return a passing result' do
+            expect(command.call(entity:))
+              .to be_a_passing_result
+              .with_value(match(expected_data))
+          end
+
+          it 'should append an item to the collection' do
+            expect { command.call(entity:) }
+              .to(
+                change { collection.query.count }
+                .by(1)
+              )
+          end
+
+          it 'should add the entity to the collection' do
+            expect { command.call(entity:) }
+              .to change(scoped, :exists?)
+              .to be true
+          end
+
+          it 'should set the attributes' do
+            command.call(entity:)
+
+            expect(scoped.to_a.first).to match(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:  collection.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:))
+              .to be_a_failing_result
+              .with_error(expected_error)
+          end
+
+          it 'should not append an item to the collection' do
+            expect { command.call(entity:) }
+              .not_to(change { collection.query.count })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cuprum/collections/rspec/deferred/commands/update_one_examples.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/deferred/command_examples'
+require 'cuprum/collections/rspec/deferred/commands'
+
+module Cuprum::Collections::RSpec::Deferred::Commands
+  # Namespace for deferred example groups for validating UpdateOne commands.
+  module UpdateOneExamples
+    include RSpec::SleepingKingStudios::Deferred::Provider
+
+    deferred_examples 'should implement the UpdateOne command' do
+      describe '#call' do
+        include Cuprum::Collections::RSpec::Deferred::CommandExamples
+
+        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]
+
+          collection.query.where { { key => value } }
+        end
+
+        def call_command
+          command.call(entity:)
+        end
+
+        if defined_deferred_examples? 'should validate the entity'
+          include_deferred 'should validate the entity'
+        else
+          # :nocov:
+          pending \
+            'the command should validate the entity parameter, but entity ' \
+            'validation is not defined - implement a "should validate the ' \
+            'entity" deferred example group to resolve this warning'
+          # :nocov:
+        end
+
+        context 'when the item does not exist in the collection' do
+          let(:expected_error) do
+            Cuprum::Collections::Errors::NotFound.new(
+              attribute_name:  collection.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:))
+              .to be_a_failing_result
+              .with_error(expected_error)
+          end
+
+          it 'should not append an item to the collection' do
+            expect { command.call(entity:) }
+              .not_to(change { collection.query.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:))
+              .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:) }
+              .not_to(change { collection.query.count })
+          end
+
+          it 'should set the attributes' do
+            command.call(entity:)
+
+            expect(scoped.to_a.first).to be == expected_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cuprum/collections/rspec/deferred/commands/validate_one_examples.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/deferred/command_examples'
+require 'cuprum/collections/rspec/deferred/commands'
+
+module Cuprum::Collections::RSpec::Deferred::Commands
+  # Namespace for deferred example groups for validating ValidateOne commands.
+  module ValidateOneExamples
+    include RSpec::SleepingKingStudios::Deferred::Provider
+
+    deferred_examples 'should implement the ValidateOne command' \
+    do |default_contract: false|
+      describe '#call' do
+        include Cuprum::Collections::RSpec::Deferred::CommandExamples
+
+        let(:attributes) { defined?(super()) ? super() : {} }
+        let(:contract)   { defined?(super()) ? super() : nil }
+
+        def call_command
+          command.call(contract:, entity:)
+        end
+
+        if defined_deferred_examples? 'should validate the entity'
+          include_deferred 'should validate the entity'
+        else
+          # :nocov:
+          pending \
+            'the command should validate the entity parameter, but entity ' \
+            'validation is not defined - implement a "should validate the ' \
+            'entity" deferred example group to resolve this warning'
+          # :nocov:
+        end
+
+        describe 'with an invalid contract value' do
+          let(:contract) { Object.new.freeze }
+
+          include_deferred 'should validate the parameter',
+            :contract,
+            'sleeping_king_studios.tools.assertions.instance_of',
+            expected: Stannum::Constraints::Base
+        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:))
+                  .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:))
+                  .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:))
+                .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:
+              )
+            end
+
+            it 'should return a failing result' do
+              expect(command.call(contract:, 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:, entity:))
+                .to be_a_passing_result
+                .with_value(entity)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cuprum/collections/rspec/deferred/commands.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/rspec/deferred'
+
+module Cuprum::Collections::RSpec::Deferred
+  # Namespace for deferred example groups for validating collection commands.
+  module Commands; end
+end