cuprum-collections 0.3.0 → 0.4.0

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

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/collections/queries'
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  OPERATORS = Cuprum::Collections::Queries::Operators
-  private_constant :OPERATORS
-
-  # Shared contexts for specs that define querying behavior.
-  QUERYING_CONTEXTS = lambda do
-    let(:filter)    { nil }
-    let(:strategy)  { nil }
-    let(:limit)     { nil }
-    let(:offset)    { nil }
-    let(:order)     { nil }
-
-    shared_context 'when the query has limit: value' do
-      let(:limit)         { 3 }
-      let(:matching_data) { super()[0...limit] }
-    end
-
-    shared_context 'when the query has offset: value' do
-      let(:offset)        { 2 }
-      let(:matching_data) { super()[offset..] || [] }
-    end
-
-    shared_context 'when the query has order: a simple ordering' do
-      let(:order)         { :title }
-      let(:matching_data) { super().sort_by { |item| item['title'] } }
-    end
-
-    shared_context 'when the query has order: a complex ordering' do
-      let(:order) do
-        {
-          author: :asc,
-          title:  :desc
-        }
-      end
-      let(:matching_data) do
-        super().sort do |u, v|
-          cmp = u['author'] <=> v['author']
-
-          cmp.zero? ? (v['title'] <=> u['title']) : cmp
-        end
-      end
-    end
-
-    shared_context 'when the query has where: a simple block filter' do
-      let(:filter) { -> { { author: 'Ursula K. LeGuin' } } }
-      let(:matching_data) do
-        super().select { |item| item['author'] == 'Ursula K. LeGuin' }
-      end
-    end
-
-    shared_context 'when the query has where: a complex block filter' do
-      let(:filter) do
-        lambda do
-          {
-            author: equals('Ursula K. LeGuin'),
-            series: not_equal('Earthsea')
-          }
-        end
-      end
-      let(:matching_data) do
-        super()
-          .select { |item| item['author'] == 'Ursula K. LeGuin' }
-          .reject { |item| item['series'] == 'Earthsea' }
-      end
-    end
-
-    shared_context 'when the query has where: a greater_than filter' do
-      let(:filter) { -> { { published_at: greater_than('1970-12-01') } } }
-      let(:matching_data) do
-        super().select { |item| item['published_at'] > '1970-12-01' }
-      end
-    end
-
-    shared_context 'when the query has where: a greater_than_or_equal_to ' \
-                   'filter' \
-    do
-      let(:filter) do
-        -> { { published_at: greater_than_or_equal_to('1970-12-01') } }
-      end
-      let(:matching_data) do
-        super().select { |item| item['published_at'] >= '1970-12-01' }
-      end
-    end
-
-    shared_context 'when the query has where: a less_than filter' do
-      let(:filter) { -> { { published_at: less_than('1970-12-01') } } }
-      let(:matching_data) do
-        super().select { |item| item['published_at'] < '1970-12-01' }
-      end
-    end
-
-    shared_context 'when the query has where: a less_than_or_equal_to filter' do
-      let(:filter) do
-        -> { { published_at: less_than_or_equal_to('1970-12-01') } }
-      end
-      let(:matching_data) do
-        super().select { |item| item['published_at'] <= '1970-12-01' }
-      end
-    end
-
-    shared_context 'when the query has where: an equal block filter' do
-      let(:filter) { -> { { author: equals('Ursula K. LeGuin') } } }
-      let(:matching_data) do
-        super().select { |item| item['author'] == 'Ursula K. LeGuin' }
-      end
-    end
-
-    shared_context 'when the query has where: a not_equal block filter' do
-      let(:filter) { -> { { author: not_equal('Ursula K. LeGuin') } } }
-      let(:matching_data) do
-        super().reject { |item| item['author'] == 'Ursula K. LeGuin' }
-      end
-    end
-
-    shared_context 'when the query has where: a not_one_of block filter' do
-      let(:filter) do
-        -> { { series: not_one_of(['Earthsea', 'The Lord of the Rings']) } }
-      end
-      let(:matching_data) do
-        super().reject do |item|
-          ['Earthsea', 'The Lord of the Rings'].include?(item['series'])
-        end
-      end
-    end
-
-    shared_context 'when the query has where: a one_of block filter' do
-      let(:filter) do
-        -> { { series: one_of(['Earthsea', 'The Lord of the Rings']) } }
-      end
-      let(:matching_data) do
-        super().select do |item|
-          ['Earthsea', 'The Lord of the Rings'].include?(item['series'])
-        end
-      end
-    end
-
-    shared_context 'when the query has multiple query options' do
-      let(:filter)    { -> { { author: 'Ursula K. LeGuin' } } }
-      let(:strategy)  { nil }
-      let(:order)     { { title: :desc } }
-      let(:limit)     { 2 }
-      let(:offset)    { 1 }
-      let(:matching_data) do
-        super()
-          .select { |item| item['author'] == 'Ursula K. LeGuin' }
-          .sort { |u, v| v['title'] <=> u['title'] }
-          .slice(1, 2) || []
-      end
-    end
-  end
-
-  # Contract validating the behavior objects that perform queries.
-  QUERYING_CONTRACT = lambda do |block:, operators: OPERATORS.values|
-    wrap_context 'when the query has limit: value' do
-      instance_exec(&block)
-    end
-
-    wrap_context 'when the query has offset: value' do
-      instance_exec(&block)
-    end
-
-    wrap_context 'when the query has order: a simple ordering' do
-      instance_exec(&block)
-    end
-
-    wrap_context 'when the query has order: a complex ordering' do
-      instance_exec(&block)
-    end
-
-    context 'when the query has where: a block filter' do
-      context 'with a simple filter' do
-        include_context 'when the query has where: a simple block filter'
-
-        instance_exec(&block)
-      end
-
-      context 'with a complex filter' do
-        include_context 'when the query has where: a complex block filter'
-
-        if operators.include?(OPERATORS::EQUAL) &&
-           operators.include?(OPERATORS::NOT_EQUAL)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with an equals filter' do
-        include_context 'when the query has where: an equal block filter'
-
-        if operators.include?(OPERATORS::EQUAL)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a greater_than filter' do
-        include_context 'when the query has where: a greater_than filter'
-
-        if operators.include?(OPERATORS::GREATER_THAN)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a greater_than_or_equal_to filter' do
-        include_context \
-          'when the query has where: a greater_than_or_equal_to filter'
-
-        if operators.include?(OPERATORS::GREATER_THAN_OR_EQUAL_TO)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a less_than filter' do
-        include_context 'when the query has where: a less_than filter'
-
-        if operators.include?(OPERATORS::LESS_THAN)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a less_than_or_equal_to filter' do
-        include_context \
-          'when the query has where: a less_than_or_equal_to filter'
-
-        if operators.include?(OPERATORS::LESS_THAN_OR_EQUAL_TO)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a not_equal filter' do
-        include_context 'when the query has where: a not_equal block filter'
-
-        if operators.include?(OPERATORS::NOT_EQUAL)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a not_one_of filter' do
-        include_context 'when the query has where: a not_one_of block filter'
-
-        if operators.include?(OPERATORS::NOT_ONE_OF)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-
-      context 'with a one_of filter' do
-        include_context 'when the query has where: a one_of block filter'
-
-        if operators.include?(OPERATORS::ONE_OF)
-          instance_exec(&block)
-        else
-          # :nocov:
-          pending
-          # :nocov:
-        end
-      end
-    end
-
-    wrap_context 'when the query has multiple query options' do
-      instance_exec(&block)
-    end
-  end
-end

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

@@ -1,235 +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 Repository.
-  module RepositoryContract
-    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
-      describe '#[]' do
-        let(:error_class) do
-          described_class::UndefinedCollectionError
-        end
-        let(:error_message) do
-          "repository does not define collection #{collection_name.inspect}"
-        end
-
-        it { expect(repository).to respond_to(:[]).with(1).argument }
-
-        describe 'with nil' do
-          let(:collection_name) { nil }
-
-          it 'should raise an exception' do
-            expect { repository[collection_name] }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        describe 'with an object' do
-          let(:collection_name) { Object.new.freeze }
-
-          it 'should raise an exception' do
-            expect { repository[collection_name] }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        describe 'with an invalid string' do
-          let(:collection_name) { 'invalid_name' }
-
-          it 'should raise an exception' do
-            expect { repository[collection_name] }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        describe 'with an invalid symbol' do
-          let(:collection_name) { :invalid_name }
-
-          it 'should raise an exception' do
-            expect { repository[collection_name] }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        wrap_context 'when the repository has many collections' do
-          describe 'with an invalid string' do
-            let(:collection_name) { 'invalid_name' }
-
-            it 'should raise an exception' do
-              expect { repository[collection_name] }
-                .to raise_error(error_class, error_message)
-            end
-          end
-
-          describe 'with an invalid symbol' do
-            let(:collection_name) { :invalid_name }
-
-            it 'should raise an exception' do
-              expect { repository[collection_name] }
-                .to raise_error(error_class, error_message)
-            end
-          end
-
-          describe 'with a valid string' do
-            let(:collection)      { collections.values.first }
-            let(:collection_name) { collections.keys.first }
-
-            it { expect(repository[collection_name]).to be collection }
-          end
-
-          describe 'with a valid symbol' do
-            let(:collection)      { collections.values.first }
-            let(:collection_name) { collections.keys.first.intern }
-
-            it { expect(repository[collection_name]).to be collection }
-          end
-        end
-      end
-
-      describe '#add' do
-        let(:error_class) do
-          described_class::InvalidCollectionError
-        end
-        let(:error_message) do
-          "#{collection.inspect} is not a valid collection"
-        end
-
-        it 'should define the method' do
-          expect(repository)
-            .to respond_to(:add)
-            .with(1).argument
-            .and_keywords(:force)
-        end
-
-        it 'should alias #add as #<<' do
-          expect(repository.method(:<<)).to be == repository.method(:add)
-        end
-
-        describe 'with nil' do
-          let(:collection) { nil }
-
-          it 'should raise an exception' do
-            expect { repository.add(collection) }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        describe 'with an object' do
-          let(:collection) { Object.new.freeze }
-
-          it 'should raise an exception' do
-            expect { repository.add(collection) }
-              .to raise_error(error_class, error_message)
-          end
-        end
-
-        describe 'with a collection' do
-          it { expect(repository.add(example_collection)).to be repository }
-
-          it 'should add the collection to the repository' do
-            repository.add(example_collection)
-
-            expect(repository[example_collection.qualified_name])
-              .to be example_collection
-          end
-
-          describe 'with force: true' do
-            it 'should add the collection to the repository' do
-              repository.add(example_collection, force: true)
-
-              expect(repository[example_collection.qualified_name])
-                .to be example_collection
-            end
-          end
-
-          context 'when the collection already exists' do
-            let(:error_message) do
-              "collection #{example_collection.qualified_name} already exists"
-            end
-
-            before(:example) do
-              allow(repository)
-                .to receive(:key?)
-                .with(example_collection.qualified_name)
-                .and_return(true)
-            end
-
-            it 'should raise an exception' do
-              expect { repository.add(example_collection) }
-                .to raise_error(
-                  described_class::DuplicateCollectionError,
-                  error_message
-                )
-            end
-
-            it 'should not update the repository' do
-              begin
-                repository.add(example_collection)
-              rescue described_class::DuplicateCollectionError
-                # Do nothing.
-              end
-
-              expect { repository[example_collection.qualified_name] }
-                .to raise_error(
-                  described_class::UndefinedCollectionError,
-                  'repository does not define collection ' \
-                  "#{example_collection.qualified_name.inspect}"
-                )
-            end
-
-            describe 'with force: true' do
-              it 'should add the collection to the repository' do
-                repository.add(example_collection, force: true)
-
-                expect(repository[example_collection.qualified_name])
-                  .to be example_collection
-              end
-            end
-          end
-        end
-      end
-
-      describe '#key?' do
-        it { expect(repository).to respond_to(:key?).with(1).argument }
-
-        it { expect(repository.key? nil).to be false }
-
-        it { expect(repository.key? Object.new.freeze).to be false }
-
-        it { expect(repository.key? 'invalid_name').to be false }
-
-        it { expect(repository.key? :invalid_name).to be false }
-
-        wrap_context 'when the repository has many collections' do
-          it { expect(repository.key? 'invalid_name').to be false }
-
-          it { expect(repository.key? :invalid_name).to be false }
-
-          it { expect(repository.key? collections.keys.first).to be true }
-
-          it 'should include the key' do
-            expect(repository.key? collections.keys.first.intern).to be true
-          end
-        end
-      end
-
-      describe '#keys' do
-        include_examples 'should define reader', :keys, []
-
-        wrap_context 'when the repository has many collections' do
-          it { expect(repository.keys).to be == collections.keys }
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'cuprum/collections/rspec'
-
-module Cuprum::Collections::RSpec
-  # Contract validating the behavior of an UpdateOne command implementation.
-  UPDATE_ONE_COMMAND_CONTRACT = lambda 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[primary_key_name],
-            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
-  end
-end

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

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