cuprum-collections 0.1.0

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+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
+
+        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 '#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

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

@@ -0,0 +1,106 @@
+# 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(
+            collection_name:    command.collection_name,
+            primary_key_name:   primary_key_name,
+            primary_key_values: primary_key
+          )
+        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(
+              collection_name:    command.collection_name,
+              primary_key_name:   primary_key_name,
+              primary_key_values: primary_key
+            )
+          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

@@ -0,0 +1,327 @@
+# 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::Collections::Errors::NotFound.new(
+            collection_name:    command.collection_name,
+            primary_key_name:   primary_key_name,
+            primary_key_values: primary_keys
+          )
+        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
+            .compact
+        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::Collections::Errors::NotFound.new(
+              collection_name:    command.collection_name,
+              primary_key_name:   primary_key_name,
+              primary_key_values: primary_keys
+            )
+          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::Collections::Errors::NotFound.new(
+              collection_name:    command.collection_name,
+              primary_key_name:   primary_key_name,
+              primary_key_values: invalid_primary_key_values
+            )
+          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::Collections::Errors::NotFound.new(
+                collection_name:    command.collection_name,
+                primary_key_name:   primary_key_name,
+                primary_key_values: primary_keys
+              )
+            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
+
+            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
+
+          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::Collections::Errors::NotFound.new(
+                collection_name:    command.collection_name,
+                primary_key_name:   primary_key_name,
+                primary_key_values: primary_keys
+              )
+            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::Collections::Errors::NotFound.new(
+                  collection_name:    command.collection_name,
+                  primary_key_name:   primary_key_name,
+                  primary_key_values: primary_keys
+                )
+              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().select { |item| item['series'].nil? }
+            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
+                )
+              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 }
+
+                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)
+                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