convenient_service 0.20.0 → 0.21.0

data/lib/convenient_service/service/plugins/can_have_rspec_stubbed_results.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+require_relative "can_have_rspec_stubbed_results/concern"

data/lib/convenient_service/service/plugins/can_have_stubbed_results/commands/delete_service_stubbed_result.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveStubbedResults
+        module Commands
+          class DeleteServiceStubbedResult < Support::Command
+            ##
+            # @!attribute [r] service
+            #   @return [ConvenientService::Service]
+            #
+            attr_reader :service
+
+            ##
+            # @!attribute [r] arguments
+            #   @return [ConvenientService::Support::Arguments]
+            #
+            attr_reader :arguments
+
+            ##
+            # @param service [ConvenientService::Service]
+            # @param arguments [ConvenientService::Support::Arguments]
+            # @return [void]
+            #
+            def initialize(service:, arguments:)
+              @service = service
+              @arguments = arguments
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result]
+            #
+            # @internal
+            #   NOTE: `arguments.nil?` means "match any arguments".
+            #
+            def call
+              if arguments.nil?
+                cache.default = nil
+              else
+                cache.delete(cache.keygen(*arguments.args, **arguments.kwargs, &arguments.block))
+              end
+            end
+
+            private
+
+            ##
+            # @return [ConvenientService::Support::Cache]
+            #
+            def cache
+              @cache ||= Commands::FetchServiceStubbedResultsCache.call(service: service)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/commands/fetch_all_services_stubbed_results_cache.rb

@@ -12,20 +12,25 @@ module ConvenientService
         module Commands
           class FetchAllServicesStubbedResultsCache < Support::Command
             ##
-            # @return [ConvenientService::Support::Cache]
+            # @!attribute [r] service
+            #   @return [Class<ConvenientService::Service>]
             #
-            # @internal
-            #   NOTE: `::RSpec.current_example` docs.
-            #   - https://www.rubydoc.info/github/rspec/rspec-core/RSpec.current_example
-            #   - https://github.com/rspec/rspec-core/blob/v3.12.0/lib/rspec/core.rb#L122
-            #   - https://github.com/rspec/rspec-support/blob/v3.12.0/lib/rspec/support.rb#L92
-            #   - https://relishapp.com/rspec/rspec-core/docs/metadata/current-example
+            attr_reader :service
+
+            ##
+            # @param service [Class<ConvenientService::Service>]
+            # @return [void]
             #
-            #   TODO: Abstract RSpec-specific code.
+            def initialize(service:)
+              @service = service
+            end
+
+            ##
+            # @return [ConvenientService::Support::Cache]
             #
             def call
-              if Dependencies.rspec.current_example
-                Utils::Object.memoize_including_falsy_values(Dependencies.rspec.current_example, :@__convenient_service_stubbed_results__) { Support::Cache.backed_by(:thread_safe_hash).new }
+              if service.stubbed_results_store
+                Utils::Object.memoize_including_falsy_values(service.stubbed_results_store, :@__convenient_service_stubbed_results__) { Support::Cache.backed_by(:thread_safe_hash).new }
               else
                 Support::Cache.backed_by(:thread_safe_hash).new
               end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/commands/fetch_service_stubbed_results_cache.rb

@@ -13,12 +13,12 @@ module ConvenientService
           class FetchServiceStubbedResultsCache < Support::Command
             ##
             # @!attribute [r] service
-            #   @return [ConvenientService::Service]
+            #   @return [Class<ConvenientService::Service>]
             #
             attr_reader :service
 
             ##
-            # @param service [ConvenientService::Service]
+            # @param service [Class<ConvenientService::Service>]
             # @return [void]
             #
             def initialize(service:)
@@ -38,7 +38,7 @@ module ConvenientService
             # @return [ConvenientService::Support::Cache]
             #
             def cache
-              @cache ||= Commands::FetchAllServicesStubbedResultsCache.call
+              @cache ||= Commands::FetchAllServicesStubbedResultsCache.call(service: service)
             end
           end
         end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/commands.rb

@@ -7,4 +7,6 @@
 
 require_relative "commands/fetch_all_services_stubbed_results_cache"
 require_relative "commands/fetch_service_stubbed_results_cache"
+
+require_relative "commands/delete_service_stubbed_result"
 require_relative "commands/set_service_stubbed_result"

data/lib/convenient_service/service/plugins/can_have_stubbed_results/concern.rb

@@ -26,6 +26,17 @@ module ConvenientService
           end
 
           class_methods do
+            ##
+            # @return [Thread]
+            #
+            # @internal
+            #   NOTE: Why not `Fiber.current`? Fibers created in one thread are concurrently executed in that one thread.
+            #   NOTE: Why not `Ractor.current`? Each ractor has its own thread.
+            #
+            def stubbed_results_store
+              ::Thread.current
+            end
+
             ##
             # @return [ConvenientService::Support::Cache]
             #
@@ -43,6 +54,20 @@ module ConvenientService
             def stubbed_results
               Commands::FetchServiceStubbedResultsCache.call(service: self)
             end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            def stub_result
+              Entities::ServiceStub.new(service_class: self)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceUnstub]
+            #
+            def unstub_result
+              Entities::ServiceUnstub.new(service_class: self)
+            end
           end
         end
       end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/entities/result_mock.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveStubbedResults
+        module Entities
+          ##
+          # @internal
+          #   IMPORTANT: Do NOT cache `data`, `message`, and `code` since they can be set multiple times by `with_data`, `and_data`, `with_message`, `and_message`, `with_code`, and `and_code`.
+          #
+          class ResultMock
+            ##
+            # @param status [Symbol]
+            # @param service_class [Class<ConvenientService::Service>]
+            # @param arguments [ConvenientService::Support::Arguments]
+            # @param chain [Hash]
+            # @return [void]
+            #
+            def initialize(status:, service_class: nil, arguments: nil, chain: {})
+              @status = status
+              @service_class = service_class
+              @arguments = arguments
+              @chain = chain
+            end
+
+            ##
+            # @param service_class [Class<ConvenientService::Service>]
+            # @param arguments [ConvenientService::Support::Arguments]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def for(service_class, arguments)
+              self.class.new(status: status, service_class: service_class, arguments: arguments, chain: chain)
+            end
+
+            ##
+            # @param data [Hash]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def with_data(data)
+              chain[:data] = data
+
+              self
+            end
+
+            ##
+            # @param message [String]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def with_message(message)
+              chain[:message] = message
+
+              self
+            end
+
+            ##
+            # @param code [String]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def with_code(code)
+              chain[:code] = code
+
+              self
+            end
+
+            ##
+            # @param data [Hash]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def and_data(data)
+              chain[:data] = data
+
+              self
+            end
+
+            ##
+            # @param message [String]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def and_message(message)
+              chain[:message] = message
+
+              self
+            end
+
+            ##
+            # @param code [String]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def and_code(code)
+              chain[:code] = code
+
+              self
+            end
+
+            ##
+            # @param block [Proc, nil]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def register(&block)
+              Commands::SetServiceStubbedResult[service: service_class, arguments: arguments, result: result]
+
+              return self unless block
+
+              begin
+                yield
+              ensure
+                Commands::DeleteServiceStubbedResult[service: service_class, arguments: arguments]
+              end
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            alias_method :apply, :register
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def unregister
+              Commands::DeleteServiceStubbedResult[service: service_class, arguments: arguments]
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            alias_method :revert, :unregister
+
+            ##
+            # @return [ConvenientService::Service]
+            #
+            def result
+              service_class.__send__(status, **kwargs).copy(overrides: {kwargs: {stubbed_result: true}})
+            end
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if status != other.status
+              return false if service_class != other.service_class
+              return false if arguments != other.arguments
+              return false if chain != other.chain
+
+              true
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] status
+            #   @return [Symbol]
+            #
+            attr_reader :status
+
+            ##
+            # @!attribute [r] service_class
+            #   @return [Class<ConvenientService::Service>]
+            #
+            attr_reader :service_class
+
+            ##
+            # @!attribute [r] arguments
+            #   @return [ConvenientService::Support::Arguments]
+            #
+            attr_reader :arguments
+
+            ##
+            # @!attribute [r] chain
+            #   @return [Hash]
+            #
+            attr_reader :chain
+
+            private
+
+            ##
+            # @return [Hash]
+            #
+            def kwargs
+              kwargs = {}
+
+              kwargs[:data] = data if used_data?
+              kwargs[:message] = message if used_message?
+              kwargs[:code] = code if used_code?
+
+              kwargs[:service] = service_instance
+
+              kwargs
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def used_data?
+              chain.key?(:data)
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def used_message?
+              chain.key?(:message)
+            end
+
+            ##
+            # @return [Boolean]
+            #
+            def used_code?
+              chain.key?(:code)
+            end
+
+            ##
+            # @return [Hash]
+            #
+            def data
+              chain[:data] || {}
+            end
+
+            ##
+            # @return [String]
+            #
+            def message
+              chain[:message] || ""
+            end
+
+            ##
+            # @return [String]
+            #
+            def code
+              chain[:code] || ""
+            end
+
+            ##
+            # @return [ConvenientService::Service]
+            #
+            def service_instance
+              service_class.new_without_initialize
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/entities/result_unmock.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveStubbedResults
+        module Entities
+          ##
+          # @internal
+          #   IMPORTANT: Do NOT cache `data`, `message`, and `code` since they can be set multiple times by `with_data`, `and_data`, `with_message`, `and_message`, `with_code`, and `and_code`.
+          #
+          class ResultUnmock
+            ##
+            # @param service_class [Class<ConvenientService::Service>]
+            # @param arguments [ConvenientService::Support::Arguments]
+            # @return [void]
+            #
+            def initialize(service_class: nil, arguments: nil)
+              @service_class = service_class
+              @arguments = arguments
+            end
+
+            ##
+            # @param service_class [Class<ConvenientService::Service>]
+            # @param arguments [ConvenientService::Support::Arguments]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            #
+            def for(service_class, arguments)
+              self.class.new(service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            #
+            def register
+              Commands::DeleteServiceStubbedResult[service: service_class, arguments: arguments]
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultUnmock]
+            #
+            alias_method :apply, :register
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if service_class != other.service_class
+              return false if arguments != other.arguments
+
+              true
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] service_class
+            #   @return [Class<ConvenientService::Service>]
+            #
+            attr_reader :service_class
+
+            ##
+            # @!attribute [r] arguments
+            #   @return [ConvenientService::Support::Arguments]
+            #
+            attr_reader :arguments
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/service/plugins/can_have_stubbed_results/entities/service_stub.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+##
+# @author Marian Kostyk <mariankostyk13895@gmail.com>
+# @license LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>
+##
+
+module ConvenientService
+  module Service
+    module Plugins
+      module CanHaveStubbedResults
+        module Entities
+          class ServiceStub
+            ##
+            # @param service_class [Class<ConvenientService::Service>]
+            # @return [void]
+            #
+            # @internal
+            #   NOTE: `@arguments = nil` means "match any arguments".
+            #
+            def initialize(service_class:)
+              @service_class = service_class
+              @arguments = nil
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            # @internal
+            #   NOTE: `@arguments = nil` means "match any arguments".
+            #
+            def with_any_arguments(...)
+              @arguments = nil
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            def with_arguments(...)
+              @arguments = Support::Arguments.new(...)
+
+              self
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            def without_arguments
+              @arguments = Support::Arguments.null_arguments
+
+              self
+            end
+
+            ##
+            # @param result_mock [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ServiceStub]
+            #
+            def to(result_mock)
+              @result_mock = result_mock.for(service_class, arguments)
+
+              @result_mock.register
+
+              self
+            end
+
+            ##
+            # @param status [Symbol]
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def to_return_result(status)
+              @result_mock = Entities::ResultMock.new(status: status, service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def to_return_success
+              @result_mock = Entities::ResultMock.new(status: :success, service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def to_return_failure
+              @result_mock = Entities::ResultMock.new(status: :failure, service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            def to_return_error
+              @result_mock = Entities::ResultMock.new(status: :error, service_class: service_class, arguments: arguments)
+            end
+
+            ##
+            # @param other [Object] Can be any type.
+            # @return [Boolean, nil]
+            #
+            def ==(other)
+              return unless other.instance_of?(self.class)
+
+              return false if service_class != other.service_class
+              return false if arguments != other.arguments
+              return false if result_mock != other.result_mock
+
+              true
+            end
+
+            protected
+
+            ##
+            # @!attribute [r] service_class
+            #   @return [Class<ConvenientService::Service>]
+            #
+            attr_reader :service_class
+
+            ##
+            # @!attribute [r] arguments
+            #   @return [ConvenientService::Support::Arguments]
+            #
+            attr_reader :arguments
+
+            ##
+            # @!attribute [r] result_mock
+            #   @return [ConvenientService::Service::Plugins::CanHaveStubbedResults::Entities::ResultMock]
+            #
+            attr_reader :result_mock
+          end
+        end
+      end
+    end
+  end
+end