auction_fun_core 0.8.9 → 0.8.10

data/spec/auction_fun_core/contracts/auction_context/processor/unpause_contract_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::UnpauseContract, type: :contract do
+  let(:auction) { Factory[:auction, :default_scheduled_standard] }
+
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when attributes are invalid" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when auction status is different to 'paused'" do
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:auction_id]).to include(
+          I18n.t("contracts.errors.custom.bids.invalid_status")
+        )
+      end
+    end
+
+    context "when auction status is equal to 'paused'" do
+      let(:auction) { Factory[:auction, :default_paused_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect return success" do
+        expect(contract).to be_success
+        expect(contract.context[:auction]).to be_a(AuctionFunCore::Entities::Auction)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/bid_context/create_bid_closed_contract_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::BidContext::CreateBidClosedContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "with foreign key user_id param" do
+      context "when is a invalid type" do
+        let(:attributes) { {user_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {user_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+
+      context "when user has already placed a bid on the auction" do
+        let(:user) { Factory[:user] }
+        let(:auction) { Factory[:auction, :default_running_closed] }
+        let(:bid) { Factory[:bid, user: user, auction: auction, value_cents: auction.initial_bid_cents] }
+        let(:attributes) { {auction_id: auction.id, user_id: user.id, value_cents: (bid.value_cents * 2)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.custom.bids.already_bidded"))
+        end
+      end
+    end
+
+    context "with foreign key auction_id param" do
+      context "when a invalid type" do
+        let(:attributes) { {auction_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {auction_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+
+      context 'when auction kind is different of "closed"' do
+        let(:auction) { Factory[:auction, :default_scheduled_penny] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "closed")
+          )
+        end
+      end
+
+      context 'when auction status is not "scheduled" or "running"' do
+        let(:auction) { Factory[:auction, :default_finished_standard] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_status", status: auction.status)
+          )
+        end
+      end
+    end
+
+    context "with value_cents param" do
+      let(:user) { Factory[:user] }
+      let(:auction) { Factory[:auction, :default_running_closed] }
+
+      context "when value_cents is less than to auction initial bid" do
+        let(:value) { Money.new(auction.initial_bid_cents - 1) }
+        let(:attributes) { {auction_id: auction.id, user_id: user.id, value_cents: value.cents} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:value_cents]).to include(
+            I18n.t("contracts.errors.gteq?", num: Money.new(auction.initial_bid_cents).to_f)
+          )
+        end
+      end
+
+      context "when value_cents is greater than or equal to auction initial bid" do
+        let(:value) { Money.new(auction.initial_bid_cents) }
+        let(:attributes) { {auction_id: auction.id, user_id: user.id, value_cents: value.cents} }
+
+        it "expect return success without error messages" do
+          expect(contract).to be_success
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/bid_context/create_bid_penny_contract_spec.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::BidContext::CreateBidPennyContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "with foreign key user_id param" do
+      context "when is a invalid type" do
+        let(:attributes) { {user_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {user_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+    end
+
+    context "with foreign key auction_id param" do
+      context "when a invalid type" do
+        let(:attributes) { {auction_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {auction_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+
+      context 'when auction kind is different of "penny"' do
+        let(:auction) { Factory[:auction, :default_scheduled_standard] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "penny")
+          )
+        end
+      end
+
+      context 'when auction status is not "scheduled" or "running"' do
+        let(:auction) { Factory[:auction, :default_finished_standard] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_status", status: auction.status)
+          )
+        end
+      end
+    end
+
+    context "with user balance" do
+      let(:bid_cents) { 10_000 }
+      let(:user) { Factory[:user] }
+      let(:auction) { Factory[:auction, :default_running_penny, initial_bid_cents: bid_cents] }
+      let(:attributes) { {auction_id: auction.id, user_id: user.id} }
+
+      context "when does not have enough balance to bid" do
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:user_id]).to include(
+            I18n.t("contracts.errors.custom.bids.insufficient_balance")
+          )
+        end
+      end
+
+      context "when has enough balance to bid" do
+        before do
+          AuctionFunCore::Repos::UserContext::UserRepository.new.update(
+            user.id, balance_cents: (bid_cents * 10)
+          )
+        end
+
+        it "expect return success" do
+          expect(contract).to be_success
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/bid_context/create_bid_standard_contract_spec.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::BidContext::CreateBidStandardContract, type: :contract do
+  let(:auction_repo) { described_class.new.auction_repo }
+
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:value_cents]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "with foreign key user_id param" do
+      context "when is a invalid type" do
+        let(:attributes) { {user_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {user_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:user_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+    end
+
+    context "with foreign key auction_id param" do
+      context "when a invalid type" do
+        let(:attributes) { {auction_id: "wrongvalue"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.int?"))
+        end
+      end
+
+      context "when is not found on database" do
+        let(:attributes) { {auction_id: rand(10_000..1_000_000)} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+
+      context 'when auction kind is different of "standard"' do
+        let(:auction) { Factory[:auction, :default_scheduled_penny] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_kind", kind: "standard")
+          )
+        end
+      end
+
+      context 'when auction status is not "scheduled" or "running"' do
+        let(:auction) { Factory[:auction, :default_finished_standard] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+
+          expect(contract.errors[:auction_id]).to include(
+            I18n.t("contracts.errors.custom.bids.invalid_status", status: auction.status)
+          )
+        end
+      end
+    end
+
+    context "with value_cents param" do
+      let(:user) { Factory[:user] }
+      let(:auction) { Factory[:auction, :default_running_standard] }
+
+      context "when auction has no bids" do
+        context "when value_cents is less than to auction minimal initial bid" do
+          let(:value) { Money.new(auction.initial_bid_cents - 1) }
+          let(:attributes) { {auction_id: auction.id, value_cents: value.cents} }
+
+          it "expect failure with error messages" do
+            expect(contract).to be_failure
+
+            expect(contract.errors[:value_cents]).to include(
+              I18n.t("contracts.errors.gteq?", num: Money.new(auction.initial_bid_cents).to_f)
+            )
+          end
+        end
+
+        context "when value_cents is greather than or equal to to minimal bid" do
+          let(:value) { Money.new(auction.initial_bid_cents) }
+          let(:attributes) { {auction_id: auction.id, user_id: user.id, value_cents: value.cents} }
+
+          it "expect return success" do
+            expect(contract).to be_success
+          end
+        end
+      end
+
+      context "when auction has bids" do
+        let(:last_bid) { Money.new(auction.minimal_bid_cents) }
+        let!(:bid) { Factory[:bid, auction: auction, value_cents: last_bid.cents] }
+        let(:required_minimal_bid) { (last_bid.cents + (last_bid.cents * 0.1)) }
+
+        before do
+          auction_repo.update(auction.id, {minimal_bid_cents: required_minimal_bid.to_i})
+        end
+
+        context "when value_cents is less than to auction minimal bid value" do
+          let(:value_cents) { last_bid.cents - 1 }
+          let(:attributes) { {auction_id: auction.id, value_cents: value_cents} }
+          let(:required_minimal_bid) { (last_bid.cents + (last_bid.cents * 0.1)) }
+
+          it "expect failure with error messages" do
+            expect(contract).to be_failure
+            expect(contract.errors[:value_cents]).to include(
+              I18n.t("contracts.errors.gteq?", num: Money.new(required_minimal_bid).to_f)
+            )
+          end
+        end
+
+        context "when value_cents is greather than or equal to ten percent of auction minimal bid value" do
+          let(:value_cents) { 1_100 }
+          let(:attributes) { {auction_id: auction.id, user_id: user.id, value_cents: value_cents} }
+
+          it "expect return success" do
+            expect(contract).to be_success
+          end
+        end
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/staff_context/authentication_contract_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::StaffContext::AuthenticationContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:login]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:password]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when login params are invalid" do
+      context "when email is invalid" do
+        let(:attributes) { {login: "invalid_email"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:login]).to include(
+            I18n.t("contracts.errors.custom.macro.login_format")
+          )
+        end
+      end
+
+      context "when phone is invalid" do
+        let(:attributes) { {login: "12345"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:login]).to include(
+            I18n.t("contracts.errors.custom.macro.login_format")
+          )
+        end
+      end
+    end
+
+    context "with database" do
+      context "when login is not found on database" do
+        let(:attributes) { {login: "notfound@staff.com", password: "example"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.login_not_found")
+          )
+        end
+      end
+
+      context "when password doesn't match with storage password on database" do
+        let(:staff) { Factory[:staff] }
+        let(:attributes) { {login: staff.email, password: "invalid"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.login_not_found")
+          )
+        end
+      end
+
+      context "when credentials are valid but user is inactive" do
+        let(:staff) { Factory[:staff, :inactive] }
+        let(:attributes) { {login: staff.email, password: "password"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.inactive_account")
+          )
+        end
+      end
+    end
+
+    context "when credentials are valid" do
+      let(:staff) { Factory[:staff] }
+      let(:attributes) { {login: staff.email, password: "password"} }
+
+      it "expect return success" do
+        expect(contract).to be_success
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/staff_context/registration_contract_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::StaffContext::RegistrationContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:name]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:email]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:phone]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    it_behaves_like "validate_name_contract", :staff
+    it_behaves_like "validate_email_contract", :staff
+    it_behaves_like "validate_phone_contract", :staff
+  end
+end

data/spec/auction_fun_core/contracts/user_context/authentication_contract_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Contracts::UserContext::AuthenticationContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when params are blank" do
+      let(:attributes) { Dry::Core::Constants::EMPTY_HASH }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:login]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:password]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when login params are invalid" do
+      context "when email is invalid" do
+        let(:attributes) { {login: "invalid_email"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:login]).to include(
+            I18n.t("contracts.errors.custom.macro.login_format")
+          )
+        end
+      end
+
+      context "when phone is invalid" do
+        let(:attributes) { {login: "12345"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:login]).to include(
+            I18n.t("contracts.errors.custom.macro.login_format")
+          )
+        end
+      end
+    end
+
+    context "with database" do
+      context "when login is not found on database" do
+        let(:attributes) { {login: "notfound@user.com", password: "example"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.login_not_found")
+          )
+        end
+      end
+
+      context "when password doesn't match with storage password on database" do
+        let(:user) { Factory[:user] }
+        let(:attributes) { {login: user.email, password: "invalid"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.login_not_found")
+          )
+        end
+      end
+
+      context "when credentials are valid but user is inactive" do
+        let(:user) { Factory[:user, :inactive] }
+        let(:attributes) { {login: user.email, password: "password"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.default.inactive_account")
+          )
+        end
+      end
+    end
+
+    context "when credentials are valid" do
+      let(:user) { Factory[:user] }
+      let(:attributes) { {login: user.email, password: "password"} }
+
+      it "expect return success" do
+        expect(contract).to be_success
+      end
+    end
+  end
+end