cuprum-collections 0.4.0 → 0.5.0

data/lib/cuprum/collections/rspec/contracts/collection_contracts.rb

@@ -5,6 +5,9 @@ require 'cuprum/collections/rspec/contracts/relation_contracts'
 
 module Cuprum::Collections::RSpec::Contracts
   # Contracts for asserting on Collection objects.
+  #
+  # @deprecated 0.5.0 Collection contracts are deprecated. Use
+  #   Deferred::CollectionExamples instead.
   module CollectionContracts
     include Cuprum::Collections::RSpec::Contracts::RelationContracts
 
@@ -25,88 +28,36 @@ module Cuprum::Collections::RSpec::Contracts
       #     for the collection, if any.
 
       contract do |**options|
+        shared_context 'when initialized with a scope' do
+          let(:initial_scope) do
+            Cuprum::Collections::Scope.new({ 'ok' => true })
+          end
+          let(:constructor_options) do
+            super().merge(scope: initial_scope)
+          end
+        end
+
         shared_examples 'should define the command' \
         do |command_name, command_class_name = nil|
           next if options[:abstract]
 
-          tools           = SleepingKingStudios::Tools::Toolbelt.instance
-          class_name      = tools.str.camelize(command_name)
-          command_options = %i[
-            collection_name
-            member_name
-            primary_key_name
-            primary_key_type
-          ] + options.fetch(:command_options, []).map(&:intern)
+          tools      = SleepingKingStudios::Tools::Toolbelt.instance
+          class_name = tools.str.camelize(command_name)
 
-          describe "::#{class_name}" do
+          describe "##{command_name}" do
             let(:constructor_options) { defined?(super()) ? super() : {} }
+            let(:command)             { build_command(collection) }
             let(:command_class) do
-              command_class_name ||
+              (
+                command_class_name ||
                 "#{options[:commands_namespace]}::#{class_name}"
-                  .then { |str| Object.const_get(str) }
-            end
-            let(:command) do
-              collection.const_get(class_name).new(**constructor_options)
-            end
-            let(:expected_options) do
-              Hash
-                .new { |_, key| collection.send(key) }
-                .merge(
-                  collection_name: collection.name,
-                  member_name:     collection.singular_name
-                )
-            end
-
-            it { expect(collection).to define_constant(class_name) }
-
-            it { expect(collection.const_get(class_name)).to be_a Class }
-
-            it 'should be an instance of the command class' do
-              expect(collection.const_get(class_name)).to be < command_class
-            end
-
-            it { expect(command.options).to be >= {} }
-
-            command_options.each do |option_name|
-              it "should set the ##{option_name}" do
-                expect(command.send(option_name))
-                  .to be == expected_options[option_name]
-              end
-            end
-
-            describe 'with options' do
-              let(:constructor_options) do
-                super().merge(
-                  custom_option: 'value',
-                  singular_name: 'tome'
-                )
-              end
-
-              it { expect(command.options).to be >= { custom_option: 'value' } }
-
-              command_options.each do |option_name|
-                it "should set the ##{option_name}" do
-                  expect(command.send(option_name)).to(
-                    be == expected_options[option_name]
-                  )
-                end
-              end
+              )
+                .then { |str| Object.const_get(str) }
             end
-          end
 
-          describe "##{command_name}" do
-            let(:constructor_options) { defined?(super()) ? super() : {} }
-            let(:command) do
+            define_method(:build_command) do |collection|
               collection.send(command_name, **constructor_options)
             end
-            let(:expected_options) do
-              Hash
-                .new { |_, key| collection.send(key) }
-                .merge(
-                  collection_name: collection.name,
-                  member_name:     collection.singular_name
-                )
-            end
 
             it 'should define the command' do
               expect(collection)
@@ -115,33 +66,9 @@ module Cuprum::Collections::RSpec::Contracts
                 .and_any_keywords
             end
 
-            it { expect(command).to be_a collection.const_get(class_name) }
+            it { expect(command).to be_a command_class }
 
-            command_options.each do |option_name|
-              it "should set the ##{option_name}" do
-                expect(command.send(option_name))
-                  .to be == expected_options[option_name]
-              end
-            end
-
-            describe 'with options' do
-              let(:constructor_options) do
-                super().merge(
-                  custom_option: 'value',
-                  singular_name: 'tome'
-                )
-              end
-
-              it { expect(command.options).to be >= { custom_option: 'value' } }
-
-              command_options.each do |option_name|
-                it "should set the ##{option_name}" do
-                  expect(command.send(option_name)).to(
-                    be == expected_options[option_name]
-                  )
-                end
-              end
-            end
+            it { expect(command.collection).to be subject }
           end
         end
 
@@ -149,14 +76,6 @@ module Cuprum::Collections::RSpec::Contracts
           constructor:          false,
           default_entity_class: options[:default_entity_class]
 
-        include_contract 'should disambiguate parameter',
-          :name,
-          as: :collection_name
-
-        include_contract 'should disambiguate parameter',
-          :singular_name,
-          as: :member_name
-
         include_contract 'should define primary keys'
 
         include_examples 'should define the command', :assign_one
@@ -178,7 +97,7 @@ module Cuprum::Collections::RSpec::Contracts
         include_examples 'should define the command', :validate_one
 
         describe '#==' do
-          let(:other_options)    { { name: name } }
+          let(:other_options)    { { name: } }
           let(:other_collection) { described_class.new(**other_options) }
 
           describe 'with nil' do
@@ -314,7 +233,7 @@ module Cuprum::Collections::RSpec::Contracts
           describe 'with partially-matching options' do
             let(:other_options) do
               {
-                name:          name,
+                name:,
                 singular_name: 'grimoire'
               }
             end
@@ -343,7 +262,7 @@ module Cuprum::Collections::RSpec::Contracts
           end
 
           describe 'with matching name' do
-            let(:other_options) { { collection_name: name } }
+            let(:other_options) { { name: } }
 
             it { expect(collection.matches?(**other_options)).to be true }
           end
@@ -377,7 +296,7 @@ module Cuprum::Collections::RSpec::Contracts
           describe 'with multiple matching options' do
             let(:other_options) do
               {
-                collection_name:  name,
+                name:,
                 primary_key_name: 'id',
                 qualified_name:   name
               }
@@ -390,7 +309,7 @@ module Cuprum::Collections::RSpec::Contracts
         describe '#query' do
           let(:error_message) do
             "#{described_class.name} is an abstract class. Define a " \
-              'repository subclass and implement the #query method.'
+              'collection subclass and implement the #query method.'
           end
           let(:default_order) { defined?(super()) ? super() : {} }
           let(:query)         { collection.query }
@@ -414,13 +333,52 @@ module Cuprum::Collections::RSpec::Contracts
               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 }
+
+            it { expect(query.scope).to be == subject.scope }
+
+            wrap_context 'when initialized with a scope' do
+              it { expect(query.scope).to be == subject.scope }
+            end
+          end
+        end
+
+        describe '#scope' do
+          let(:expected) do
+            Cuprum::Collections::Scopes::AllScope.new
+          end
+
+          include_examples 'should define reader', :scope, -> { be == expected }
+
+          wrap_context 'when initialized with a scope' do
+            it { expect(subject.scope).to be == initial_scope }
+          end
+        end
+
+        describe '#with_scope' do
+          let(:other_scope) do
+            Cuprum::Collections::Scope.new({ 'secret' => '12345' })
+          end
+          let(:copy) { subject.with_scope(other_scope) }
+
+          it { expect(subject).to respond_to(:with_scope).with(1).argument }
+
+          it { expect(copy).to be_a described_class }
+
+          it { expect(copy).not_to be subject }
+
+          it { expect(copy.scope).to be == other_scope }
+
+          wrap_context 'when initialized with a scope' do
+            let(:expected) do
+              initial_scope.and(other_scope)
+            end
+
+            it { expect(copy.scope).to be == expected }
           end
         end
       end