auction_fun_core 0.8.9 → 0.8.10

data/spec/auction_fun_core/operations/auction_context/processor/unpause_operation_spec.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::UnpauseOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_paused_standard] }
+
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:attributes) { {auction_id: auction.id} }
+
+        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 eq(auction.id)
+          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[:auction_id]).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 is invalid" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect not change auction status" do
+        expect { operation }.not_to change { auction_repository.by_id(auction.id).status }
+      end
+
+      it "expect return failure with error messages" do
+        expect(operation.failure[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract is valid" do
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect update status auction record on database" do
+        expect { operation }.to change { auction_repository.by_id(auction.id).status }.from("paused").to("running")
+      end
+
+      it "expect publish the auction unpause event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        operation
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/bid_context/create_bid_closed_operation_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::BidContext::CreateBidClosedOperation, type: :operation do
+  let(:bid_repository) { AuctionFunCore::Repos::BidContext::BidRepository.new }
+
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:auction) { Factory[:auction, :default_scheduled_closed] }
+        let(:user) { Factory[:user] }
+        let(:attributes) do
+          Factory.structs[:bid, user: user, auction: auction]
+            .to_h.except(:id, :created_at, :updated_at, :admin, :user)
+            .merge!(value_cents: auction.initial_bid_cents * 2)
+        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::Bid)
+          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[:auction_id]).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 bid on database" do
+        expect(bid_repository.count).to be_zero
+
+        expect { operation }.not_to change(bid_repository, :count)
+      end
+
+      it "expect return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:auction) { Factory[:auction, :default_scheduled_closed] }
+      let(:user) { Factory[:user] }
+      let(:attributes) do
+        Factory.structs[:bid, user: user, auction: auction]
+          .to_h.except(:id, :created_at, :updated_at, :staff, :user)
+          .merge!(value_cents: auction.initial_bid_cents * 2)
+      end
+
+      it "expect return success without error messages" do
+        expect(operation).to be_success
+        expect(operation.failure).to be_blank
+      end
+
+      it "expect persist new bid on database and dispatch event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        expect { operation }.to change(bid_repository, :count).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/bid_context/create_bid_penny_operation_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::BidContext::CreateBidPennyOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:bid_repository) { AuctionFunCore::Repos::BidContext::BidRepository.new }
+
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:auction) { Factory[:auction, :default_scheduled_penny] }
+        let(:user) { Factory[:user] }
+        let(:attributes) do
+          Factory.structs[:bid, user: user, auction: auction]
+            .to_h.except(:id, :created_at, :updated_at, :staff, :user)
+        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::Bid)
+          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[:auction_id]).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 bid on database" do
+        expect(bid_repository.count).to be_zero
+
+        expect { operation }.not_to change(bid_repository, :count)
+      end
+
+      it "expect return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:auction) { Factory[:auction, :default_scheduled_penny] }
+      let(:user) { Factory[:user] }
+      let(:attributes) do
+        Factory.structs[:bid, user: user, auction: auction]
+          .to_h.except(:id, :created_at, :updated_at, :staff, :user)
+      end
+
+      it "expect return success without error messages" do
+        expect(operation).to be_success
+        expect(operation.failure).to be_blank
+      end
+
+      it "expect persist new bid on database" do
+        expect { operation }.to change(bid_repository, :count).from(0).to(1)
+      end
+
+      it "expect dispatch event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        operation
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      context "when an auction has not started" do
+        it "expects not to update the auction's 'finished_at' field" do
+          expect { operation }.not_to change { auction_repository.by_id(auction.id).finished_at }
+        end
+
+        it "expect not reschedule the end of the auction" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .to receive(:perform_at).with(Time, auction.id)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .not_to have_received(:perform_at).with(Time, auction.id)
+        end
+      end
+
+      context "when an auction was started" do
+        let(:auction) { Factory[:auction, :default_running_penny] }
+        let(:user) { Factory[:user, :with_balance] }
+
+        it "expects to update the auction's 'finished_at' field and reschedule the end of the auction" do
+          expect { operation }.to change { auction_repository.by_id(auction.id).finished_at }
+        end
+
+        it "expect reschedule the end of the auction" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .to receive(:perform_at).with(Time, auction.id)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .to have_received(:perform_at).with(Time, auction.id).once
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/bid_context/create_bid_standard_operation_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::BidContext::CreateBidStandardOperation, type: :operation do
+  let(:bid_repository) { AuctionFunCore::Repos::BidContext::BidRepository.new }
+
+  describe ".call(attributes, &block)" do
+    let(:operation) { described_class }
+
+    context "when block is given" do
+      context "when operation happens with success" do
+        let(:auction) { Factory[:auction, :default_scheduled_standard] }
+        let(:user) { Factory[:user] }
+        let(:attributes) do
+          Factory.structs[:bid, user: user, auction: auction]
+            .to_h.except(:id, :created_at, :updated_at, :staff, :user)
+            .merge!(value_cents: auction.initial_bid_cents * 2)
+        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::Bid)
+          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[:auction_id]).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 return failure with error messages" do
+        expect(operation).to be_failure
+        expect(operation.failure[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+
+      it "expect not persist new bid on database" do
+        expect(bid_repository.count).to be_zero
+
+        expect { operation }.not_to change(bid_repository, :count)
+      end
+    end
+
+    context "when contract are valid" do
+      let(:auction) { Factory[:auction, :default_scheduled_standard] }
+      let(:user) { Factory[:user] }
+      let(:attributes) do
+        Factory.structs[:bid, user: user, auction: auction]
+          .to_h.except(:id, :created_at, :updated_at, :staff, :user)
+          .merge!(value_cents: auction.initial_bid_cents * 2)
+      end
+
+      it "expect persist new bid on database" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        expect { operation }.to change(bid_repository, :count).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      it "expect return success without error messages" do
+        expect(operation).to be_success
+        expect(operation.failure).to be_blank
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/staff_context/authentication_operation_spec.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::StaffContext::AuthenticationOperation, 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(:staff) { Factory[:staff] }
+        let(:attributes) { {login: staff.email, password: "password"} }
+
+        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::Staff)
+          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[:login]).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[:login]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:staff) { Factory[:staff] }
+      let(:attributes) { {login: staff.email, password: "password"} }
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+      end
+
+      it "expect return success" do
+        expect(operation).to be_success
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::StaffContext::RegistrationOperation, type: :operation do
+  let(:staff_repository) { AuctionFunCore::Repos::StaffContext::StaffRepository.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[:staff]
+            .to_h
+            .except(:id, :created_at, :updated_at, :password_digest)
+        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::Staff)
+          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 staff on database" do
+        expect(staff_repository.count).to be_zero
+
+        expect { operation }.not_to change(staff_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[:staff]
+          .to_h
+          .except(:id, :created_at, :updated_at, :password_digest)
+      end
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+      end
+
+      it "expect persist new staff on database and dispatch event registration" do
+        expect { operation }.to change(staff_repository, :count).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      it "expect return success without error messages" do
+        expect(operation).to be_success
+        expect(operation.failure).to be_blank
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::UserContext::AuthenticationOperation, 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] }
+        let(:attributes) { {login: user.email, password: "password"} }
+
+        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[:login]).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[:login]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when contract are valid" do
+      let(:user) { Factory[:user] }
+      let(:attributes) { {login: user.email, password: "password"} }
+
+      before do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+      end
+
+      it "expect return success" do
+        expect(operation).to be_success
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+    end
+  end
+end