cuprum-collections 0.2.0 → 0.3.0

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

@@ -1,153 +1,190 @@
 # 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.
-  COLLECTION_CONTRACT = lambda 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
+  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).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_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
+          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 == constructor_options.fetch(option_name) do
-                  collection.send(option_name)
-                end
-              )
+              expect(command.send(option_name))
+                .to be == collection.send(option_name)
             end
           end
-        end
-      end
 
-      describe "##{command_name}" do
-        let(:constructor_options) { {} }
-        let(:command) do
-          collection.send(command_name, **constructor_options)
-        end
+          describe 'with options' do
+            let(:constructor_options) do
+              {
+                data:        [],
+                member_name: 'tome'
+              }
+            end
 
-        it 'should define the command' do
-          expect(collection)
-            .to respond_to(command_name)
-            .with(0).arguments
-            .and_any_keywords
+            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
 
-        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)
+        describe "##{command_name}" do
+          let(:constructor_options) { {} }
+          let(:command) do
+            collection.send(command_name, **constructor_options)
           end
-        end
 
-        describe 'with options' do
-          let(:constructor_options) do
-            {
-              data:        [],
-              member_name: 'tome'
-            }
+          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 == constructor_options.fetch(option_name) do
-                  collection.send(option_name)
-                end
-              )
+              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
-    end
 
-    include_examples 'should define the command',
-      :assign_one,
-      commands_namespace::AssignOne
+      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',
-      :build_one,
-      commands_namespace::BuildOne
+      include_examples 'should define the command',
+        :destroy_one,
+        commands_namespace::DestroyOne
 
-    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_many,
-      commands_namespace::FindMany
+      include_examples 'should define the command',
+        :find_matching,
+        commands_namespace::FindMatching
 
-    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',
-      :find_one,
-      commands_namespace::FindOne
+      include_examples 'should define the command',
+        :insert_one,
+        commands_namespace::InsertOne
 
-    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',
-      :update_one,
-      commands_namespace::UpdateOne
+      include_examples 'should define the command',
+        :validate_one,
+        commands_namespace::ValidateOne
 
-    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 '#query' do
-      let(:default_order) { defined?(super()) ? super() : {} }
-      let(:query)         { collection.query }
+      describe '#count' do
+        it { expect(collection).to respond_to(:count).with(0).arguments }
 
-      it { expect(collection).to respond_to(:query).with(0).arguments }
+        it { expect(collection).to have_aliased_method(:count).as(:size) }
 
-      it { expect(collection.query).to be_a query_class }
+        it { expect(collection.count).to be 0 }
 
-      it 'should set the query options' do
-        query_options.each do |option, value|
-          expect(collection.query.send option).to be == value
+        wrap_context 'when the collection has many items' do
+          it { expect(collection.count).to be items.count }
         end
       end
 
-      it { expect(query.criteria).to be == [] }
+      describe '#qualified_name' do
+        include_examples 'should define reader',
+          :qualified_name,
+          -> { an_instance_of(String) }
+      end
 
-      it { expect(query.limit).to be nil }
+      describe '#query' do
+        let(:default_order) { defined?(super()) ? super() : {} }
+        let(:query)         { collection.query }
 
-      it { expect(query.offset).to be nil }
+        it { expect(collection).to respond_to(:query).with(0).arguments }
 
-      it { expect(query.order).to be == default_order }
+        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

@@ -28,9 +28,10 @@ module Cuprum::Collections::RSpec
         let(:primary_key) { invalid_primary_key_value }
         let(:expected_error) do
           Cuprum::Collections::Errors::NotFound.new(
-            collection_name:    command.collection_name,
-            primary_key_name:   primary_key_name,
-            primary_key_values: primary_key
+            attribute_name:  primary_key_name,
+            attribute_value: primary_key,
+            collection_name: collection_name,
+            primary_key:     true
           )
         end
 
@@ -59,9 +60,10 @@ module Cuprum::Collections::RSpec
           let(:primary_key) { invalid_primary_key_value }
           let(:expected_error) do
             Cuprum::Collections::Errors::NotFound.new(
-              collection_name:    command.collection_name,
-              primary_key_name:   primary_key_name,
-              primary_key_values: primary_key
+              attribute_name:  primary_key_name,
+              attribute_value: primary_key,
+              collection_name: collection_name,
+              primary_key:     true
             )
           end
 

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

@@ -58,10 +58,15 @@ module Cuprum::Collections::RSpec
       describe 'with an array of invalid primary keys' do
         let(:primary_keys) { invalid_primary_key_values }
         let(:expected_error) do
-          Cuprum::Collections::Errors::NotFound.new(
-            collection_name:    command.collection_name,
-            primary_key_name:   primary_key_name,
-            primary_key_values: primary_keys
+          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
 
@@ -79,7 +84,6 @@ module Cuprum::Collections::RSpec
             .map do |key|
               mapped_data.find { |item| item[primary_key_name.to_s] == key }
             end
-            .compact
         end
         let(:expected_data) do
           defined?(super()) ? super() : matching_data
@@ -88,10 +92,15 @@ module Cuprum::Collections::RSpec
         describe 'with an array of invalid primary keys' do
           let(:primary_keys) { invalid_primary_key_values }
           let(:expected_error) do
-            Cuprum::Collections::Errors::NotFound.new(
-              collection_name:    command.collection_name,
-              primary_key_name:   primary_key_name,
-              primary_key_values: primary_keys
+            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
 
@@ -107,10 +116,17 @@ module Cuprum::Collections::RSpec
             invalid_primary_key_values + valid_primary_key_values
           end
           let(:expected_error) do
-            Cuprum::Collections::Errors::NotFound.new(
-              collection_name:    command.collection_name,
-              primary_key_name:   primary_key_name,
-              primary_key_values: invalid_primary_key_values
+            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
 
@@ -145,10 +161,15 @@ module Cuprum::Collections::RSpec
           describe 'with an array of invalid primary keys' do
             let(:primary_keys) { invalid_primary_key_values }
             let(:expected_error) do
-              Cuprum::Collections::Errors::NotFound.new(
-                collection_name:    command.collection_name,
-                primary_key_name:   primary_key_name,
-                primary_key_values: primary_keys
+              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
 
@@ -163,6 +184,22 @@ module Cuprum::Collections::RSpec
             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(
@@ -170,6 +207,7 @@ module Cuprum::Collections::RSpec
               )
                 .to be_a_passing_result
                 .with_value(expected_data)
+                .and_error(expected_error)
             end
           end
 
@@ -226,10 +264,15 @@ module Cuprum::Collections::RSpec
           describe 'with an array of invalid primary keys' do
             let(:primary_keys) { invalid_primary_key_values }
             let(:expected_error) do
-              Cuprum::Collections::Errors::NotFound.new(
-                collection_name:    command.collection_name,
-                primary_key_name:   primary_key_name,
-                primary_key_values: primary_keys
+              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
 
@@ -246,10 +289,15 @@ module Cuprum::Collections::RSpec
             describe 'with a valid array of primary keys' do
               let(:primary_keys) { valid_primary_key_values }
               let(:expected_error) do
-                Cuprum::Collections::Errors::NotFound.new(
-                  collection_name:    command.collection_name,
-                  primary_key_name:   primary_key_name,
-                  primary_key_values: primary_keys
+                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
 
@@ -264,20 +312,32 @@ module Cuprum::Collections::RSpec
           describe 'with a scope that matches some keys' do
             let(:scope_filter) { -> { { series: nil } } }
             let(:matching_data) do
-              super().select { |item| item['series'].nil? }
+              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.map { |item| item[primary_key_name.to_s] }
-                missing_keys = primary_keys - found_keys
-
-                Cuprum::Collections::Errors::NotFound.new(
-                  collection_name:    command.collection_name,
-                  primary_key_name:   primary_key_name,
-                  primary_key_values: missing_keys
+                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
 
@@ -291,6 +351,25 @@ module Cuprum::Collections::RSpec
             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(
@@ -302,6 +381,7 @@ module Cuprum::Collections::RSpec
                   )
                     .to be_a_passing_result
                     .with_value(expected_data)
+                    .and_error(expected_error)
                 end
               end
             end

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

@@ -47,9 +47,10 @@ module Cuprum::Collections::RSpec
         let(:primary_key) { invalid_primary_key_value }
         let(:expected_error) do
           Cuprum::Collections::Errors::NotFound.new(
-            collection_name:    command.collection_name,
-            primary_key_name:   primary_key_name,
-            primary_key_values: primary_key
+            attribute_name:  primary_key_name,
+            attribute_value: primary_key,
+            collection_name: command.collection_name,
+            primary_key:     true
           )
         end
 
@@ -73,9 +74,10 @@ module Cuprum::Collections::RSpec
           let(:primary_key) { invalid_primary_key_value }
           let(:expected_error) do
             Cuprum::Collections::Errors::NotFound.new(
-              collection_name:    command.collection_name,
-              primary_key_name:   primary_key_name,
-              primary_key_values: primary_key
+              attribute_name:  primary_key_name,
+              attribute_value: primary_key,
+              collection_name: command.collection_name,
+              primary_key:     true
             )
           end
 
@@ -120,9 +122,10 @@ module Cuprum::Collections::RSpec
               let(:primary_key) { valid_primary_key_value }
               let(:expected_error) do
                 Cuprum::Collections::Errors::NotFound.new(
-                  collection_name:    command.collection_name,
-                  primary_key_name:   primary_key_name,
-                  primary_key_values: primary_key
+                  attribute_name:  primary_key_name,
+                  attribute_value: primary_key,
+                  collection_name: command.collection_name,
+                  primary_key:     true
                 )
               end
 

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

@@ -61,9 +61,10 @@ module Cuprum::Collections::RSpec
         let(:data) { fixtures_data }
         let(:expected_error) do
           Cuprum::Collections::Errors::AlreadyExists.new(
-            collection_name:    collection_name,
-            primary_key_name:   primary_key_name,
-            primary_key_values: attributes[primary_key_name]
+            attribute_name:  primary_key_name,
+            attribute_value: attributes[primary_key_name],
+            collection_name: collection_name,
+            primary_key:     true
           )
         end
 

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

@@ -386,8 +386,8 @@ module Cuprum::Collections::RSpec # rubocop:disable Style/Documentation
     describe '#order' do
       let(:default_order) { defined?(super()) ? super() : {} }
       let(:error_message) do
-        'order must be a list of attribute names and/or a hash of attribute' \
-          ' names with values :asc or :desc'
+        'order must be a list of attribute names and/or a hash of attribute ' \
+          'names with values :asc or :desc'
       end
 
       it 'should define the method' do
@@ -397,7 +397,7 @@ module Cuprum::Collections::RSpec # rubocop:disable Style/Documentation
           .and_unlimited_arguments
       end
 
-      it { expect(query).to alias_method(:order).as(:order_by) }
+      it { expect(query).to have_aliased_method(:order).as(:order_by) }
 
       describe 'with no arguments' do
         it { expect(query.order).to be == default_order }

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

@@ -76,8 +76,8 @@ module Cuprum::Collections::RSpec
       end
     end
 
-    shared_context 'when the query has where: a greater_than_or_equal_to' \
-                   ' filter' \
+    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') } }