cuprum-collections 0.3.0.rc.0 → 0.4.0.rc.0

data/lib/cuprum/collections/rspec/collection_contract.rb

@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-require 'rspec/sleeping_king_studios/contract'
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of a Collection.
-  module CollectionContract
-    extend RSpec::SleepingKingStudios::Contract
-
-    # @!method apply(example_group)
-    #   Adds the contract to the example group.
-    #
-    #   @param example_group [RSpec::Core::ExampleGroup] The example group to
-    #     which the contract is applied.
-
-    contract do
-      shared_examples 'should define the command' \
-      do |command_name, command_class|
-        tools      = SleepingKingStudios::Tools::Toolbelt.instance
-        class_name = tools.str.camelize(command_name)
-
-        describe "::#{class_name}" do
-          let(:constructor_options) { {} }
-          let(:command) do
-            collection.const_get(class_name).new(**constructor_options)
-          end
-
-          it { expect(collection).to define_constant(class_name) }
-
-          it { expect(collection.const_get(class_name)).to be_a Class }
-
-          it { expect(collection.const_get(class_name)).to be < command_class }
-
-          command_options.each do |option_name|
-            it "should set the ##{option_name}" do
-              expect(command.send(option_name))
-                .to be == collection.send(option_name)
-            end
-          end
-
-          describe 'with options' do
-            let(:constructor_options) do
-              {
-                data:        [],
-                member_name: 'tome'
-              }
-            end
-
-            command_options.each do |option_name|
-              it "should set the ##{option_name}" do
-                expect(command.send(option_name)).to(
-                  be == constructor_options.fetch(option_name) do
-                    collection.send(option_name)
-                  end
-                )
-              end
-            end
-          end
-        end
-
-        describe "##{command_name}" do
-          let(:constructor_options) { {} }
-          let(:command) do
-            collection.send(command_name, **constructor_options)
-          end
-
-          it 'should define the command' do
-            expect(collection)
-              .to respond_to(command_name)
-              .with(0).arguments
-              .and_any_keywords
-          end
-
-          it { expect(command).to be_a collection.const_get(class_name) }
-
-          command_options.each do |option_name|
-            it "should set the ##{option_name}" do
-              expect(command.send(option_name))
-                .to be == collection.send(option_name)
-            end
-          end
-
-          describe 'with options' do
-            let(:constructor_options) do
-              {
-                data:        [],
-                member_name: 'tome'
-              }
-            end
-
-            command_options.each do |option_name|
-              it "should set the ##{option_name}" do
-                expect(command.send(option_name)).to(
-                  be == constructor_options.fetch(option_name) do
-                    collection.send(option_name)
-                  end
-                )
-              end
-            end
-          end
-        end
-      end
-
-      include_examples 'should define the command',
-        :assign_one,
-        commands_namespace::AssignOne
-
-      include_examples 'should define the command',
-        :build_one,
-        commands_namespace::BuildOne
-
-      include_examples 'should define the command',
-        :destroy_one,
-        commands_namespace::DestroyOne
-
-      include_examples 'should define the command',
-        :find_many,
-        commands_namespace::FindMany
-
-      include_examples 'should define the command',
-        :find_matching,
-        commands_namespace::FindMatching
-
-      include_examples 'should define the command',
-        :find_one,
-        commands_namespace::FindOne
-
-      include_examples 'should define the command',
-        :insert_one,
-        commands_namespace::InsertOne
-
-      include_examples 'should define the command',
-        :update_one,
-        commands_namespace::UpdateOne
-
-      include_examples 'should define the command',
-        :validate_one,
-        commands_namespace::ValidateOne
-
-      describe '#collection_name' do
-        include_examples 'should define reader',
-          :collection_name,
-          -> { an_instance_of(String) }
-      end
-
-      describe '#count' do
-        it { expect(collection).to respond_to(:count).with(0).arguments }
-
-        it { expect(collection).to have_aliased_method(:count).as(:size) }
-
-        it { expect(collection.count).to be 0 }
-
-        wrap_context 'when the collection has many items' do
-          it { expect(collection.count).to be items.count }
-        end
-      end
-
-      describe '#qualified_name' do
-        include_examples 'should define reader',
-          :qualified_name,
-          -> { an_instance_of(String) }
-      end
-
-      describe '#query' do
-        let(:default_order) { defined?(super()) ? super() : {} }
-        let(:query)         { collection.query }
-
-        it { expect(collection).to respond_to(:query).with(0).arguments }
-
-        it { expect(collection.query).to be_a query_class }
-
-        it 'should set the query options' do
-          query_options.each do |option, value|
-            expect(collection.query.send option).to be == value
-          end
-        end
-
-        it { expect(query.criteria).to be == [] }
-
-        it { expect(query.limit).to be nil }
-
-        it { expect(query.offset).to be nil }
-
-        it { expect(query.order).to be == default_order }
-      end
-    end
-  end
-end

data/lib/cuprum/collections/rspec/destroy_one_command_contract.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of a FindOne command implementation.
-  DESTROY_ONE_COMMAND_CONTRACT = lambda 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 { |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: 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
-  end
-end

data/lib/cuprum/collections/rspec/find_many_command_contract.rb

@@ -1,407 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of a FindMany command implementation.
-  FIND_MANY_COMMAND_CONTRACT = lambda 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|
-                next nil unless invalid_primary_key_values.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))
-              .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
-  end
-end