cuprum-collections 0.3.0 → 0.4.0.rc.0

data/lib/cuprum/collections/basic/rspec/command_contract.rb

@@ -1,392 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/collections/basic/rspec'
-
-module Cuprum::Collections::Basic::RSpec
-  # Contract validating the behavior of a basic command implementation.
-  COMMAND_CONTRACT = lambda do
-    describe '.subclass' do
-      let(:subclass) { described_class.subclass }
-      let(:constructor_options) do
-        {
-          collection_name: 'books',
-          data:            data,
-          optional_key:    'optional value'
-        }
-      end
-
-      it 'should define the class method' do
-        expect(described_class)
-          .to respond_to(:subclass)
-          .with(0).arguments
-          .and_any_keywords
-      end
-
-      it { expect(subclass).to be_a Class }
-
-      it { expect(subclass).to be < described_class }
-
-      it 'should define the constructor' do
-        expect(subclass)
-          .to respond_to(:new)
-          .with(0).arguments
-          .and_any_keywords
-      end
-
-      it 'should return the collection name' do
-        expect(subclass.new(**constructor_options).collection_name)
-          .to be collection_name
-      end
-
-      it 'should return the data' do
-        expect(subclass.new(**constructor_options).data)
-          .to be data
-      end
-
-      it 'should return the options' do
-        expect(subclass.new(**constructor_options).options)
-          .to be == { optional_key: 'optional value' }
-      end
-
-      describe 'with options' do
-        let(:default_options) do
-          {
-            collection_name: 'books',
-            custom_key:      'custom value'
-          }
-        end
-        let(:constructor_options) do
-          {
-            data:         data,
-            optional_key: 'optional value'
-          }
-        end
-        let(:subclass) { described_class.subclass(**default_options) }
-
-        it { expect(subclass).to be_a Class }
-
-        it { expect(subclass).to be < described_class }
-
-        it 'should define the constructor' do
-          expect(subclass)
-            .to respond_to(:new)
-            .with(0).arguments
-            .and_any_keywords
-        end
-
-        it 'should return the collection name' do
-          expect(subclass.new(**constructor_options).collection_name)
-            .to be collection_name
-        end
-
-        it 'should return the data' do
-          expect(subclass.new(**constructor_options).data)
-            .to be data
-        end
-
-        it 'should return the options' do
-          expect(subclass.new(**constructor_options).options)
-            .to be == {
-              custom_key:   'custom value',
-              optional_key: 'optional value'
-            }
-        end
-      end
-    end
-
-    describe '#collection_name' do
-      include_examples 'should have reader',
-        :collection_name,
-        -> { collection_name }
-
-      context 'when initialized with collection_name: symbol' do
-        let(:collection_name) { :books }
-
-        it { expect(command.collection_name).to be == collection_name.to_s }
-      end
-    end
-
-    describe '#data' do
-      include_examples 'should define reader', :data, -> { data }
-    end
-
-    describe '#default_contract' do
-      include_examples 'should define reader', :default_contract, nil
-
-      context 'when initialized with a default contract' do
-        let(:default_contract) { Stannum::Contract.new }
-        let(:constructor_options) do
-          super().merge(default_contract: default_contract)
-        end
-
-        it { expect(command.default_contract).to be default_contract }
-      end
-    end
-
-    describe '#member_name' do
-      def tools
-        SleepingKingStudios::Tools::Toolbelt.instance
-      end
-
-      include_examples 'should have reader',
-        :member_name,
-        -> { tools.str.singularize(collection_name) }
-
-      context 'when initialized with collection_name: value' do
-        let(:collection_name) { :books }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name)
-            .to be == tools.str.singularize(collection_name.to_s)
-        end
-      end
-
-      context 'when initialized with member_name: string' do
-        let(:member_name)         { 'tome' }
-        let(:constructor_options) { super().merge(member_name: member_name) }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name).to be member_name
-        end
-      end
-
-      context 'when initialized with member_name: symbol' do
-        let(:member_name)         { :tome }
-        let(:constructor_options) { super().merge(member_name: member_name) }
-
-        it 'should return the singular collection name' do
-          expect(command.member_name).to be == member_name.to_s
-        end
-      end
-    end
-
-    describe '#options' do
-      let(:expected_options) do
-        defined?(super()) ? super() : constructor_options
-      end
-
-      include_examples 'should define reader',
-        :options,
-        -> { be == expected_options }
-
-      context 'when initialized with options' do
-        let(:constructor_options) { super().merge({ key: 'value' }) }
-        let(:expected_options)    { super().merge({ key: 'value' }) }
-
-        it { expect(command.options).to be == expected_options }
-      end
-    end
-
-    describe '#primary_key_name' do
-      include_examples 'should define reader', :primary_key_name, :id
-
-      context 'when initialized with a primary key name' do
-        let(:primary_key_name) { :uuid }
-        let(:constructor_options) do
-          super().merge({ primary_key_name: primary_key_name })
-        end
-
-        it { expect(command.primary_key_name).to be == primary_key_name }
-      end
-    end
-
-    describe '#primary_key_type' do
-      include_examples 'should define reader', :primary_key_type, Integer
-
-      context 'when initialized with a primary key type' do
-        let(:primary_key_type) { String }
-        let(:constructor_options) do
-          super().merge({ primary_key_type: primary_key_type })
-        end
-
-        it { expect(command.primary_key_type).to be == primary_key_type }
-      end
-    end
-
-    describe '#validate_primary_key' do
-      let(:primary_key_type) { Integer }
-      let(:expected_error) do
-        type     = primary_key_type
-        contract = Stannum::Contracts::ParametersContract.new do
-          keyword :primary_key, type
-        end
-        errors = contract.errors_for(
-          {
-            arguments: [],
-            block:     nil,
-            keywords:  { primary_key: nil }
-          }
-        )
-
-        Cuprum::Collections::Errors::InvalidParameters.new(
-          command: command,
-          errors:  errors
-        )
-      end
-
-      it 'should define the private method' do
-        expect(command)
-          .to respond_to(:validate_primary_key, true)
-          .with(1).argument
-      end
-
-      describe 'with nil' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, nil))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Object' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, Object.new.freeze))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with a String' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_key, '12345'))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Integer' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_key, 12_345)).not_to be_a_result
-        end
-      end
-
-      context 'when initialized with a primary key type' do
-        let(:primary_key_type) { String }
-        let(:constructor_options) do
-          super().merge({ primary_key_type: primary_key_type })
-        end
-
-        describe 'with an Integer' do
-          it 'should return a failing result' do
-            expect(command.send(:validate_primary_key, 12_345))
-              .to be_a_failing_result
-              .with_error(expected_error)
-          end
-        end
-
-        describe 'with a String' do
-          it 'should not return a result' do
-            expect(command.send(:validate_primary_key, '12345'))
-              .not_to be_a_result
-          end
-        end
-      end
-    end
-
-    describe '#validate_primary_keys' do
-      let(:primary_keys)     { nil }
-      let(:primary_key_type) { Integer }
-      let(:expected_error) do
-        type     = primary_key_type
-        contract = Stannum::Contracts::ParametersContract.new do
-          keyword :primary_keys,
-            Stannum::Constraints::Types::ArrayType.new(item_type: type)
-        end
-        errors = contract.errors_for(
-          {
-            arguments: [],
-            block:     nil,
-            keywords:  { primary_keys: primary_keys }
-          }
-        )
-
-        Cuprum::Collections::Errors::InvalidParameters.new(
-          command: command,
-          errors:  errors
-        )
-      end
-
-      it 'should define the private method' do
-        expect(command)
-          .to respond_to(:validate_primary_keys, true)
-          .with(1).argument
-      end
-
-      describe 'with nil' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, nil))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Object' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, Object.new.freeze))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with a String' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, '12345'))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Integer' do
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, 12_345))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an empty Array' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_keys, []))
-            .not_to be_a_result
-        end
-      end
-
-      describe 'with an Array with nil values' do
-        let(:primary_keys) { Array.new(3, nil) }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with Object values' do
-        let(:primary_keys) { Array.new(3) { Object.new.freeze } }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with String values' do
-        let(:primary_keys) { %w[ichi ni san] }
-
-        it 'should return a failing result' do
-          expect(command.send(:validate_primary_keys, primary_keys))
-            .to be_a_failing_result
-            .with_error(expected_error)
-        end
-      end
-
-      describe 'with an Array with Integer values' do
-        it 'should not return a result' do
-          expect(command.send(:validate_primary_keys, [0, 1, 2]))
-            .not_to be_a_result
-        end
-      end
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-# frozen_string_literal: true
-
-require 'stannum/constraints/presence'
-require 'stannum/constraints/types/hash_with_indifferent_keys'
-require 'stannum/rspec/validate_parameter'
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of an Assign command implementation.
-  ASSIGN_ONE_COMMAND_CONTRACT = lambda 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)     { command.call(attributes: attributes, entity: entity) }
-      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
-  end
-end

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'stannum/constraints/types/hash_with_indifferent_keys'
-require 'stannum/rspec/validate_parameter'
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of a Build command implementation.
-  BUILD_ONE_COMMAND_CONTRACT = lambda 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
-  end
-end