auction_fun_core 0.8.9 → 0.8.10

data/spec/auction_fun_core/operations/user_context/email_confirmation_operation_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::UserContext::EmailConfirmationOperation, type: :operation do
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:user) { Factory[:user, :unconfirmed, :with_email_confirmation_token] }
+        let(:attributes) { {email_confirmation_token: user.email_confirmation_token} }
+
+        it "expect result success matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_a(AuctionFunCore::Entities::User)
+          expect(matched_failure).to be_nil
+        end
+      end
+
+      context "when operation happens with failure" do
+        let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+        it "expect result matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_nil
+          expect(matched_failure[:email_confirmation_token]).to include(I18n.t("contracts.errors.key?"))
+        end
+      end
+    end
+  end
+
+  describe "#call(attributes)" do
+    subject(:operation) { described_class.new.call(attributes) }
+
+    context "when contract are invalid" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:email_confirmation_token]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:user) { Factory[:user, :unconfirmed, :with_email_confirmation_token] }
+      let(:attributes) { {email_confirmation_token: user.email_confirmation_token} }
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+      end
+
+      it "expect return success" do
+        expect(operation).to be_success
+        expect(operation.success).to be_email_confirmed
+        expect(operation.success).to be_confirmed
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/user_context/phone_confirmation_operation_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::UserContext::PhoneConfirmationOperation, type: :operation do
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:user) { Factory[:user, :unconfirmed, :with_phone_confirmation_token] }
+        let(:attributes) { {phone_confirmation_token: user.phone_confirmation_token} }
+
+        it "expect result success matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_a(AuctionFunCore::Entities::User)
+          expect(matched_failure).to be_nil
+        end
+      end
+
+      context "when operation happens with failure" do
+        let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+        it "expect result matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_nil
+          expect(matched_failure[:phone_confirmation_token]).to include(I18n.t("contracts.errors.key?"))
+        end
+      end
+    end
+  end
+
+  describe "#call(attributes)" do
+    subject(:operation) { described_class.new.call(attributes) }
+
+    context "when contract are invalid" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:phone_confirmation_token]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:user) { Factory[:user, :unconfirmed, :with_phone_confirmation_token] }
+      let(:attributes) { {phone_confirmation_token: user.phone_confirmation_token} }
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+      end
+
+      it "expect return success" do
+        expect(operation).to be_success
+        expect(operation.success).to be_phone_confirmed
+        expect(operation.success).to be_confirmed
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/user_context/registration_operation_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::UserContext::RegistrationOperation, type: :operation do
+  let(:user_repository) { AuctionFunCore::Repos::UserContext::UserRepository.new }
+
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:attributes) do
+          Factory.structs[:user]
+            .to_h
+            .except(:id, :created_at, :updated_at, :password_digest)
+            .merge!(password: "password", password_confirmation: "password")
+        end
+
+        it "expect result success matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_a(AuctionFunCore::Entities::User)
+          expect(matched_failure).to be_nil
+        end
+      end
+
+      context "when operation happens with failure" do
+        let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+        it "expect result matching block" do
+          matched_success = nil
+          matched_failure = nil
+
+          operation.call(attributes) do |o|
+            o.success { |v| matched_success = v }
+            o.failure { |f| matched_failure = f }
+          end
+
+          expect(matched_success).to be_nil
+          expect(matched_failure[:name]).to include(I18n.t("contracts.errors.key?"))
+        end
+      end
+    end
+  end
+
+  describe "#call" do
+    subject(:operation) { described_class.new.call(attributes) }
+
+    context "when contract are not valid" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect not persist new user on database" do
+        expect(user_repository.count).to be_zero
+
+        expect { operation }.not_to change(user_repository, :count)
+      end
+
+      it "expect return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:name]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:attributes) do
+        Factory.structs[:user]
+          .to_h
+          .except(:id, :created_at, :updated_at, :password_digest)
+          .merge!(password: "password", password_confirmation: "password")
+      end
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+        allow(AuctionFunCore::Workers::Services::Mail::UserContext::RegistrationMailerJob)
+          .to receive(:perform_async)
+      end
+
+      it "expect return success without error messages" do
+        expect(operation).to be_success
+        expect(operation.failure).to be_blank
+      end
+
+      it "expect create user with email confirmation token on database and dispatch event registration" do
+        expect { operation }.to change(user_repository, :count).from(0).to(1)
+
+        expect(operation.success.email_confirmation_token).to be_present
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+        expect(AuctionFunCore::Workers::Services::Mail::UserContext::RegistrationMailerJob)
+          .to have_received(:perform_async).once
+      end
+    end
+  end
+end