auction_fun_core 0.8.9 → 0.8.10

data/spec/auction_fun_core/operations/auction_context/pre_auction/auction_start_reminder_operation_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::PreAuction::AuctionStartReminderOperation, 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(:auction) { Factory[:auction, :default_scheduled_standard, started_at: 3.hours.from_now] }
+        let(:participant) { Factory[:user] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        before do
+          Factory[:bid, user_id: participant.id, auction_id: auction.id, value_cents: auction.minimal_bid_cents]
+        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 include([participant.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 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(:auction) { Factory[:auction, :default_scheduled_standard, started_at: 3.hours.from_now] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      context "when the auction has no participants" do
+        it "expect not to schedule a reminder email to the participant" do
+          allow(AuctionFunCore::Workers::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailerJob)
+            .to receive(:perform_async)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailerJob)
+            .not_to have_received(:perform_async)
+        end
+      end
+
+      context "when the auction has participants" do
+        let(:participant) { Factory[:user] }
+
+        before do
+          Factory[:bid, user_id: participant.id, auction_id: auction.id, value_cents: auction.minimal_bid_cents]
+        end
+
+        it "expects to schedule a reminder email to the participant" do
+          allow(AuctionFunCore::Workers::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailerJob)
+            .to receive(:perform_async).with(auction.id, participant.id)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailerJob)
+            .to have_received(:perform_async).with(auction.id, participant.id).once
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/auction_context/processor/finish/closed_operation_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::Finish::ClosedOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_running_closed, finished_at: Time.current] }
+
+  describe ".call(auction_id, &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.id).to eq(auction.id)
+          expect(matched_success.status).to eq("finished")
+          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 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("running")
+          .to("finished")
+      end
+
+      it "expect publish the auction finish event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        operation
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      context "when the auction has a winning bid with other participations" do
+        let(:participant) { Factory[:user] }
+        let(:winner) { Factory[:user] }
+
+        before do
+          Factory[:bid, auction: auction, user: winner, value_cents: (auction.minimal_bid_cents * 2)]
+          Factory[:bid, auction: auction, user: participant, value_cents: auction.minimal_bid_cents]
+        end
+
+        it "expect call winner operation and participant operation jobs" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to receive(:perform_async).with(auction.id, winner.id)
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to receive(:perform_async).with(auction.id, participant.id)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to have_received(:perform_async).with(auction.id, winner.id).once
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to have_received(:perform_async).with(auction.id, participant.id).once
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/auction_context/processor/finish/penny_operation_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::Finish::PennyOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_running_penny, finished_at: Time.current] }
+
+  describe ".call(auction_id, &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.id).to eq(auction.id)
+          expect(matched_success.status).to eq("finished")
+          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 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("running")
+          .to("finished")
+      end
+
+      it "expect publish the auction finish event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        operation
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      context "when the auction has a winning bid with other participations" do
+        let(:participant) { Factory[:user] }
+        let(:winner) { Factory[:user] }
+
+        before do
+          Factory[:bid, auction: auction, user: participant, value_cents: auction.minimal_bid_cents]
+          Factory[:bid, auction: auction, user: winner, value_cents: auction.minimal_bid_cents]
+        end
+
+        it "expect call winner operation and participant operation jobs" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to receive(:perform_async).with(auction.id, winner.id)
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to receive(:perform_async).with(auction.id, participant.id)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to have_received(:perform_async).with(auction.id, winner.id).once
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to have_received(:perform_async).with(auction.id, participant.id).once
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/operations/auction_context/processor/finish/standard_operation_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::Finish::StandardOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_running_standard, finished_at: Time.current] }
+
+  describe ".call(auction_id, &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.id).to eq(auction.id)
+          expect(matched_success.status).to eq("finished")
+          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 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("running")
+          .to("finished")
+      end
+
+      it "expect publish the auction finish event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        operation
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      context "when the auction has a winning bid with other participations" do
+        let(:winner) { Factory[:user] }
+
+        before do
+          Factory[:bid, auction: auction, value_cents: auction.minimal_bid_cents]
+          Factory[:bid, auction: auction, user: winner, value_cents: (auction.minimal_bid_cents * 2)]
+        end
+
+        it "expect call winner operation and participant operation jobs" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to receive(:perform_async)
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to receive(:perform_async)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::WinnerOperationJob)
+            .to have_received(:perform_async).once
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::PostAuction::ParticipantOperationJob)
+            .to have_received(:perform_async).once
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::PauseOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_running_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("running")
+          .to("paused")
+      end
+
+      it "expect publish the auction pause 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/auction_context/processor/start_operation_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Operations::AuctionContext::Processor::StartOperation, type: :operation do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_scheduled_standard, started_at: Time.current] }
+  let(:auction_id) { auction.id }
+  let(:kind) { auction.kind }
+  let(:stopwatch) { 0 }
+
+  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
+          {
+            auction_id: auction.id,
+            kind: auction.kind,
+            stopwatch: auction.stopwatch
+          }
+        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.id).to eq(auction.id)
+          expect(matched_success.status).to eq("running")
+          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 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
+    end
+
+    context "when contract is valid" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          kind: auction.kind,
+          stopwatch: auction.stopwatch
+        }
+      end
+
+      it "expect update status auction record on database and publish the auction start event" do
+        allow(AuctionFunCore::Application[:event]).to receive(:publish)
+
+        expect { operation }.to change { auction_repository.by_id(auction.id).status }.from("scheduled").to("running")
+
+        expect(AuctionFunCore::Application[:event]).to have_received(:publish).once
+      end
+
+      context "when auction kind is equal to 'standard'" do
+        it "expect create a new job to finish the standard auction" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::StandardOperationJob).to receive(:perform_at)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::StandardOperationJob)
+            .to have_received(:perform_at)
+            .once
+        end
+      end
+
+      context "when auction kind is equal to 'closed'" do
+        let(:auction) { Factory[:auction, :default_scheduled_closed, started_at: Time.current] }
+
+        it "expect create a new job to finish the closed auction" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::ClosedOperationJob).to receive(:perform_at)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::ClosedOperationJob)
+            .to have_received(:perform_at)
+            .once
+        end
+      end
+
+      context "when auction kind is equal to 'penny'" do
+        let(:auction) { Factory[:auction, :default_scheduled_closed, started_at: Time.current] }
+        let(:stopwatch) { 45 }
+        let(:old_finished_at) { auction.finished_at.strftime("%Y-%m-%d %H:%M:%S") }
+        let(:new_finished_at) { stopwatch.seconds.from_now.strftime("%Y-%m-%d %H:%M:%S") }
+        let(:attributes) do
+          {
+            auction_id: auction.id,
+            kind: "penny",
+            stopwatch: stopwatch
+          }
+        end
+
+        before { auction_repository.update(auction.id, kind: "penny") }
+
+        it "expect update finished_at to stopwatch seconds from now" do
+          expect { operation }
+            .to change { auction_repository.by_id(auction.id).finished_at.strftime("%Y-%m-%d %H:%M:%S") }
+            .from(old_finished_at)
+            .to(new_finished_at)
+        end
+
+        it "expect call the finish penny auction job" do
+          allow(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .to receive(:perform_at)
+
+          operation
+
+          expect(AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::PennyOperationJob)
+            .to have_received(:perform_at)
+        end
+      end
+    end
+  end
+end