From 7968a2f33c53b327bbefe5668b019abfbb34a7be Mon Sep 17 00:00:00 2001 From: Marian13 Date: Sun, 28 Jan 2024 18:21:49 +0200 Subject: [PATCH] refactor(has_negated_j_send_result): move negated_result from service to result --- .../service/configs/standard.rb | 2 +- .../entities/result/plugins.rb | 2 +- .../entities/result/plugins/can_be_negated.rb | 3 - .../result/plugins/can_be_negated/concern.rb | 30 -- .../result/plugins/has_negated_result.rb | 3 + .../plugins/has_negated_result/concern.rb | 58 +++ .../has_negated_j_send_result/concern.rb | 26 +- .../dry/gemfile/dry_service/config_spec.rb | 2 +- .../gemfile/rails_service/config_spec.rb | 2 +- .../service/configs/standard_spec.rb | 2 +- .../plugins/can_be_negated/concern_spec.rb | 65 ---- .../has_negated_result/concern_spec.rb | 337 ++++++++++++++++++ .../has_negated_j_send_result/concern_spec.rb | 269 +------------- 13 files changed, 416 insertions(+), 385 deletions(-) delete mode 100644 lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated.rb delete mode 100644 lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern.rb create mode 100644 lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result.rb create mode 100644 lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern.rb delete mode 100644 spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern_spec.rb create mode 100644 spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern_spec.rb diff --git a/lib/convenient_service/service/configs/standard.rb b/lib/convenient_service/service/configs/standard.rb index 8c56d935bf0..72997da24b5 100644 --- a/lib/convenient_service/service/configs/standard.rb +++ b/lib/convenient_service/service/configs/standard.rb @@ -129,7 +129,7 @@ class self::Result use ConvenientService::Plugins::Common::HasJSendResultDuckShortSyntax::Concern use ConvenientService::Plugins::Result::CanRecalculateResult::Concern - use ConvenientService::Plugins::Result::CanBeNegated::Concern + use ConvenientService::Plugins::Result::HasNegatedResult::Concern use ConvenientService::Plugins::Result::CanBeOwnResult::Concern use ConvenientService::Plugins::Result::CanHaveFallbacks::Concern use ConvenientService::Plugins::Result::CanHaveParentResult::Concern diff --git a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins.rb b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins.rb index e12405125cc..4d5f6dda67c 100644 --- a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins.rb +++ b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins.rb @@ -1,7 +1,7 @@ # frozen_string_literal: true require_relative "plugins/can_recalculate_result" -require_relative "plugins/can_be_negated" +require_relative "plugins/has_negated_result" require_relative "plugins/can_be_own_result" require_relative "plugins/can_be_stubbed_result" require_relative "plugins/can_have_fallbacks" diff --git a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated.rb b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated.rb deleted file mode 100644 index 251362ec87e..00000000000 --- a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated.rb +++ /dev/null @@ -1,3 +0,0 @@ -# frozen_string_literal: true - -require_relative "can_be_negated/concern" diff --git a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern.rb b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern.rb deleted file mode 100644 index fbe627dbbe7..00000000000 --- a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern.rb +++ /dev/null @@ -1,30 +0,0 @@ -# frozen_string_literal: true - -module ConvenientService - module Service - module Plugins - module HasJSendResult - module Entities - class Result - module Plugins - module CanBeNegated - module Concern - include Support::Concern - - instance_methods do - ## - # @return [Boolean] - # - def negated? - Utils.to_bool(extra_kwargs[:negated]) - end - end - end - end - end - end - end - end - end - end -end diff --git a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result.rb b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result.rb new file mode 100644 index 00000000000..53d8bdb84d9 --- /dev/null +++ b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result.rb @@ -0,0 +1,3 @@ +# frozen_string_literal: true + +require_relative "has_negated_result/concern" diff --git a/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern.rb b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern.rb new file mode 100644 index 00000000000..dbf1a091a03 --- /dev/null +++ b/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern.rb @@ -0,0 +1,58 @@ +# frozen_string_literal: true + +module ConvenientService + module Service + module Plugins + module HasJSendResult + module Entities + class Result + module Plugins + module HasNegatedResult + module Concern + include Support::Concern + + instance_methods do + ## + # @return [Boolean] + # + def negated? + Utils.to_bool(extra_kwargs[:negated]) + end + + ## + # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result] + # + # @internal + # NOTE: `original_result = result` is used to cache `result` independently, without relying on `CachesReturnValue` plugin. + # + # TODO: `Utils::String.concat_if`? How? + # - https://stackoverflow.com/a/28648594/12201472 + # + def negated_result + case status.to_sym + when :success + service.failure( + data: unsafe_data, + message: "Original `result` is `success`#{" with `message` - #{unsafe_message}" unless unsafe_message.empty?}", + code: "negated_#{unsafe_code}" + ) + when :failure + service.success( + data: unsafe_data, + message: "Original `result` is `failure`#{" with `message` - #{unsafe_message}" unless unsafe_message.empty?}", + code: "negated_#{unsafe_code}" + ) + when :error + copy + end + end + end + end + end + end + end + end + end + end + end +end diff --git a/lib/convenient_service/service/plugins/has_negated_j_send_result/concern.rb b/lib/convenient_service/service/plugins/has_negated_j_send_result/concern.rb index 266280c7151..723f9a3ab43 100644 --- a/lib/convenient_service/service/plugins/has_negated_j_send_result/concern.rb +++ b/lib/convenient_service/service/plugins/has_negated_j_send_result/concern.rb @@ -10,32 +10,10 @@ module Concern instance_methods do ## # @return [ConvenientService::Service::Plugins::HasJSendResult::Entities::Result] - # - # @internal - # NOTE: `original_result = result` is used to cache `result` independently, without relying on `CachesReturnValue` plugin. - # - # TODO: `Utils::String.concat_if`? How? - # - https://stackoverflow.com/a/28648594/12201472 + # @note Users may override this method to provider custom `negataed_result` behavior. # def negated_result - original_result = result - - case result.status.to_sym - when :success - failure( - data: original_result.unsafe_data, - message: "Original `result` is `success`#{" with `message` - #{original_result.unsafe_message}" unless original_result.unsafe_message.empty?}", - code: "negated_#{original_result.unsafe_code}" - ) - when :failure - success( - data: original_result.unsafe_data, - message: "Original `result` is `failure`#{" with `message` - #{original_result.unsafe_message}" unless original_result.unsafe_message.empty?}", - code: "negated_#{original_result.unsafe_code}" - ) - when :error - original_result.copy - end + result.negated_result end end end diff --git a/spec/lib/convenient_service/examples/dry/gemfile/dry_service/config_spec.rb b/spec/lib/convenient_service/examples/dry/gemfile/dry_service/config_spec.rb index 0e74027aea7..8e056971745 100644 --- a/spec/lib/convenient_service/examples/dry/gemfile/dry_service/config_spec.rb +++ b/spec/lib/convenient_service/examples/dry/gemfile/dry_service/config_spec.rb @@ -253,7 +253,7 @@ ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveStep::Concern, ConvenientService::Common::Plugins::HasJSendResultDuckShortSyntax::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanRecalculateResult::Concern, - ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeNegated::Concern, + ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasNegatedResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeOwnResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveFallbacks::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveParentResult::Concern, diff --git a/spec/lib/convenient_service/examples/rails/gemfile/rails_service/config_spec.rb b/spec/lib/convenient_service/examples/rails/gemfile/rails_service/config_spec.rb index 195aaabdfc2..2cffae45a9b 100644 --- a/spec/lib/convenient_service/examples/rails/gemfile/rails_service/config_spec.rb +++ b/spec/lib/convenient_service/examples/rails/gemfile/rails_service/config_spec.rb @@ -255,7 +255,7 @@ ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveStep::Concern, ConvenientService::Common::Plugins::HasJSendResultDuckShortSyntax::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanRecalculateResult::Concern, - ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeNegated::Concern, + ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasNegatedResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeOwnResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveFallbacks::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveParentResult::Concern, diff --git a/spec/lib/convenient_service/service/configs/standard_spec.rb b/spec/lib/convenient_service/service/configs/standard_spec.rb index c91364e84f8..1853f8c3f0d 100644 --- a/spec/lib/convenient_service/service/configs/standard_spec.rb +++ b/spec/lib/convenient_service/service/configs/standard_spec.rb @@ -248,7 +248,7 @@ ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveStep::Concern, ConvenientService::Common::Plugins::HasJSendResultDuckShortSyntax::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanRecalculateResult::Concern, - ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeNegated::Concern, + ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasNegatedResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeOwnResult::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveFallbacks::Concern, ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanHaveParentResult::Concern, diff --git a/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern_spec.rb b/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern_spec.rb deleted file mode 100644 index c6f8bb85c5d..00000000000 --- a/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/can_be_negated/concern_spec.rb +++ /dev/null @@ -1,65 +0,0 @@ -# frozen_string_literal: true - -require "spec_helper" - -require "convenient_service" - -# rubocop:disable RSpec/NestedGroups, RSpec/MultipleMemoizedHelpers -RSpec.describe ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::CanBeNegated::Concern do - include ConvenientService::RSpec::PrimitiveMatchers::CacheItsValue - - example_group "modules" do - include ConvenientService::RSpec::Matchers::IncludeModule - - subject { described_class } - - it { is_expected.to include_module(ConvenientService::Support::Concern) } - - context "when included" do - subject { result_class } - - let(:result_class) do - Class.new.tap do |klass| - klass.class_exec(described_class) do |mod| - include mod - end - end - end - - it { is_expected.to include_module(described_class::InstanceMethods) } - end - end - - example_group "instance methods" do - describe "#negated?" do - let(:result) { service.result } - - let(:service) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - success - end - end - end - - context "when result is NOT from `negated_result` method" do - let(:result) { service.result } - - it "returns `false`" do - expect(result.negated?).to eq(false) - end - end - - context "when result is from `negated_result` method" do - let(:result) { service.negated_result } - - it "returns `true`" do - expect(result.negated?).to eq(true) - end - end - end - end -end -# rubocop:enable RSpec/NestedGroups, RSpec/MultipleMemoizedHelpers diff --git a/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern_spec.rb b/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern_spec.rb new file mode 100644 index 00000000000..935d80fbdb4 --- /dev/null +++ b/spec/lib/convenient_service/service/plugins/has_j_send_result/entities/result/plugins/has_negated_result/concern_spec.rb @@ -0,0 +1,337 @@ +# frozen_string_literal: true + +require "spec_helper" + +require "convenient_service" + +# rubocop:disable RSpec/NestedGroups, RSpec/MultipleMemoizedHelpers +RSpec.describe ConvenientService::Service::Plugins::HasJSendResult::Entities::Result::Plugins::HasNegatedResult::Concern do + include ConvenientService::RSpec::PrimitiveMatchers::CacheItsValue + + example_group "modules" do + include ConvenientService::RSpec::Matchers::IncludeModule + + subject { described_class } + + it { is_expected.to include_module(ConvenientService::Support::Concern) } + + context "when included" do + subject { result_class } + + let(:result_class) do + Class.new.tap do |klass| + klass.class_exec(described_class) do |mod| + include mod + end + end + end + + it { is_expected.to include_module(described_class::InstanceMethods) } + end + end + + example_group "instance methods" do + include ConvenientService::RSpec::Matchers::DelegateTo + include ConvenientService::RSpec::Matchers::Results + + describe "#negated?" do + let(:result) { service.result } + + let(:service) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + success + end + end + end + + context "when result is NOT from `negated_result` method" do + let(:result) { service.result } + + it "returns `false`" do + expect(result.negated?).to eq(false) + end + end + + context "when result is from `negated_result` method" do + let(:result) { service.negated_result } + + it "returns `true`" do + expect(result.negated?).to eq(true) + end + end + end + + describe "#negated_result" do + let(:service_instance) { service_class.new } + let(:result) { service_instance.result } + + context "when original result is `success`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + success + end + end + end + + it "returns `failure`" do + expect(result.negated_result).to be_failure + end + + it "returns `failure` with additional `message`" do + expect(result.negated_result).to be_failure.with_message("Original `result` is `success`") + end + + it "returns `failure` with negated `code`" do + expect(result.negated_result).to be_failure.with_code("negated_#{ConvenientService::Service::Plugins::HasJSendResult::Constants::DEFAULT_SUCCESS_CODE}") + end + + it "returns `failure` with NOT checked status" do + expect(result.negated_result.has_checked_status?).to eq(false) + end + + context "when that `success` has `data`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + success(data: {foo: :bar}) + end + end + end + + it "returns `failure` with that `success` unmodified `data`" do + expect(result.negated_result).to be_failure.with_data(service_instance.result.unsafe_data) + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_data) + .without_arguments + end + end + + context "when that `success` has NOT empty `message`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + success(message: "foo") + end + end + end + + it "returns `failure` with that `success` modified `message`" do + expect(result.negated_result).to be_failure.with_message("Original `result` is `success` with `message` - #{service_instance.result.unsafe_message}") + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_message) + .without_arguments + end + end + + context "when that `success` has `code`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + success(data: {code: :foo}) + end + end + end + + it "returns `failure` with that `success` negated `code`" do + expect(result.negated_result).to be_failure.with_code("negated_#{service_instance.result.unsafe_code}") + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_code) + .without_arguments + end + end + end + + context "when original result is `failure`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + failure + end + end + end + + it "returns `success`" do + expect(result.negated_result).to be_success + end + + it "returns `success` with additional `message`" do + expect(result.negated_result).to be_success.with_message("Original `result` is `failure`") + end + + it "returns `success` with negated `code`" do + expect(result.negated_result).to be_success.with_code("negated_#{ConvenientService::Service::Plugins::HasJSendResult::Constants::DEFAULT_FAILURE_CODE}") + end + + it "returns `success` with NOT checked status" do + expect(result.negated_result.has_checked_status?).to eq(false) + end + + context "when that `failure` has `data`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + failure(data: {foo: :bar}) + end + end + end + + it "returns `success` with that `failure` unmodified `data`" do + expect(result.negated_result).to be_success.with_data(service_instance.result.unsafe_data) + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_data) + .without_arguments + end + end + + context "when that `failure` has NOT empty `message`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + failure(message: "foo") + end + end + end + + it "returns `success` with that `failure` modified `message`" do + expect(result.negated_result).to be_success.with_message("Original `result` is `failure` with `message` - #{service_instance.result.unsafe_message}") + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_message) + .without_arguments + end + end + + context "when that `failure` has `code`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + failure(code: :foo) + end + end + end + + it "returns `success` with that `failure` negated `code`" do + expect(result.negated_result).to be_success.with_code("negated_#{service_instance.result.unsafe_code}") + end + + specify do + expect { result.negated_result } + .to delegate_to(service_instance.result, :unsafe_code) + .without_arguments + end + end + end + + context "when original result is `error`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + error + end + end + end + + it "returns copy of that original `error`" do + expect(result.negated_result).to eq(service_instance.result.copy(overrides: {kwargs: {negated: true}})) + end + + it "returns copy of that original `error` with original `message`" do + expect(result.negated_result).to be_error.with_message(service_instance.result.unsafe_message) + end + + it "returns copy of that original `error` with original `code`" do + expect(result.negated_result).to be_error.with_code(service_instance.result.unsafe_code) + end + + it "returns copy of that original `error` with NOT checked status" do + expect(result.negated_result.has_checked_status?).to eq(false) + end + + context "when that original `error` has `data`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + error(data: {foo: :bar}) + end + end + end + + it "returns copy of that original `error` with its unmodified `data`" do + expect(result.negated_result).to be_error.with_data(service_instance.result.unsafe_data) + end + end + + context "when that original `error` has NOT empty `message`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + error(message: "foo") + end + end + end + + it "returns copy of that original `error` with its unmodified `message`" do + expect(result.negated_result).to be_error.with_message(service_instance.result.unsafe_message) + end + end + + context "when that original `error` has `code`" do + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard + + def result + error(code: :foo) + end + end + end + + it "returns copy of that original `error` with its unmodified `code`" do + expect(result.negated_result).to be_error.with_code(service_instance.result.unsafe_code) + end + end + end + end + end +end +# rubocop:enable RSpec/NestedGroups, RSpec/MultipleMemoizedHelpers diff --git a/spec/lib/convenient_service/service/plugins/has_negated_j_send_result/concern_spec.rb b/spec/lib/convenient_service/service/plugins/has_negated_j_send_result/concern_spec.rb index 93e7c9d7267..85babf6043a 100644 --- a/spec/lib/convenient_service/service/plugins/has_negated_j_send_result/concern_spec.rb +++ b/spec/lib/convenient_service/service/plugins/has_negated_j_send_result/concern_spec.rb @@ -33,270 +33,23 @@ include ConvenientService::RSpec::Matchers::Results describe "#negated_result" do - let(:service_instance) { service_class.new } - - context "when original result is `success`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - success - end - end - end - - it "returns `failure`" do - expect(service_instance.negated_result).to be_failure - end - - it "returns `failure` with additional `message`" do - expect(service_instance.negated_result).to be_failure.with_message("Original `result` is `success`") - end - - it "returns `failure` with negated `code`" do - expect(service_instance.negated_result).to be_failure.with_code("negated_#{ConvenientService::Service::Plugins::HasJSendResult::Constants::DEFAULT_SUCCESS_CODE}") - end - - it "returns `failure` with NOT checked status" do - expect(service_instance.negated_result.has_checked_status?).to eq(false) - end - - context "when that `success` has `data`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - success(data: {foo: :bar}) - end - end - end - - it "returns `failure` with that `success` unmodified `data`" do - expect(service_instance.negated_result).to be_failure.with_data(service_instance.result.unsafe_data) - end - - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_data) - .without_arguments - end - end - - context "when that `success` has NOT empty `message`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - success(message: "foo") - end - end - end - - it "returns `failure` with that `success` modified `message`" do - expect(service_instance.negated_result).to be_failure.with_message("Original `result` is `success` with `message` - #{service_instance.result.unsafe_message}") - end - - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_message) - .without_arguments - end - end - - context "when that `success` has `code`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - success(data: {code: :foo}) - end - end - end - - it "returns `failure` with that `success` negated `code`" do - expect(service_instance.negated_result).to be_failure.with_code("negated_#{service_instance.result.unsafe_code}") - end - - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_code) - .without_arguments - end - end - end - - context "when original result is `failure`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - failure - end - end - end - - it "returns `success`" do - expect(service_instance.negated_result).to be_success - end - - it "returns `success` with additional `message`" do - expect(service_instance.negated_result).to be_success.with_message("Original `result` is `failure`") - end - - it "returns `success` with negated `code`" do - expect(service_instance.negated_result).to be_success.with_code("negated_#{ConvenientService::Service::Plugins::HasJSendResult::Constants::DEFAULT_FAILURE_CODE}") - end - - it "returns `success` with NOT checked status" do - expect(service_instance.negated_result.has_checked_status?).to eq(false) - end - - context "when that `failure` has `data`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - failure(data: {foo: :bar}) - end - end - end - - it "returns `success` with that `failure` unmodified `data`" do - expect(service_instance.negated_result).to be_success.with_data(service_instance.result.unsafe_data) - end - - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_data) - .without_arguments - end - end - - context "when that `failure` has NOT empty `message`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - failure(message: "foo") - end - end - end - - it "returns `success` with that `failure` modified `message`" do - expect(service_instance.negated_result).to be_success.with_message("Original `result` is `failure` with `message` - #{service_instance.result.unsafe_message}") - end - - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_message) - .without_arguments - end - end - - context "when that `failure` has `code`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - failure(code: :foo) - end - end - end - - it "returns `success` with that `failure` negated `code`" do - expect(service_instance.negated_result).to be_success.with_code("negated_#{service_instance.result.unsafe_code}") - end + let(:service_class) do + Class.new do + include ConvenientService::Service::Configs::Standard - specify do - expect { service_instance.negated_result } - .to delegate_to(service_instance.result, :unsafe_code) - .without_arguments + def result + success end end end - context "when original result is `error`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - error - end - end - end - - it "returns copy of that original `error`" do - expect(service_instance.negated_result).to eq(service_instance.result.copy(overrides: {kwargs: {negated: true}})) - end - - it "returns copy of that original `error` with original `message`" do - expect(service_instance.negated_result).to be_error.with_message(service_instance.result.unsafe_message) - end - - it "returns copy of that original `error` with original `code`" do - expect(service_instance.negated_result).to be_error.with_code(service_instance.result.unsafe_code) - end - - it "returns copy of that original `error` with NOT checked status" do - expect(service_instance.negated_result.has_checked_status?).to eq(false) - end - - context "when that original `error` has `data`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - error(data: {foo: :bar}) - end - end - end - - it "returns copy of that original `error` with its unmodified `data`" do - expect(service_instance.negated_result).to be_error.with_data(service_instance.result.unsafe_data) - end - end - - context "when that original `error` has NOT empty `message`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - error(message: "foo") - end - end - end - - it "returns copy of that original `error` with its unmodified `message`" do - expect(service_instance.negated_result).to be_error.with_message(service_instance.result.unsafe_message) - end - end - - context "when that original `error` has `code`" do - let(:service_class) do - Class.new do - include ConvenientService::Service::Configs::Standard - - def result - error(code: :foo) - end - end - end + let(:service_instance) { service_class.new } - it "returns copy of that original `error` with its unmodified `code`" do - expect(service_instance.negated_result).to be_error.with_code(service_instance.result.unsafe_code) - end - end + specify do + expect { service_instance.negated_result } + .to delegate_to(service_instance.result, :negated_result) + .without_arguments + .and_return_its_value end end end