auction_fun_core 0.8.9 → 0.8.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a93057cdc62225a319b45c2836b5cfd713935664c8a7d9bdf2d39678909dacc7
-  data.tar.gz: 87f51a7eb83f0b47bc13394c36e37f36821a8ef5f4c429ec18e272155d9a1261
+  metadata.gz: 51265464431c461d76cdb8ea73db67d5c0e89b5940c40234a91bca69c8340824
+  data.tar.gz: 3412345a03d4524a63a25540a883476793c72e60acc8da1d5819168d8a9a6082
 SHA512:
-  metadata.gz: 70b11f00396f1195ae8e7060eb8316141abbe3e3f30621d80769d94b63b4d1469695b6ca0a35a9910419e7579f047b2bd9d4f7a3ad469803cf47cb3aae4efc75
-  data.tar.gz: 520de3854f324a0e79bca1c4bfdfe69288077e208de37831b3c25cd84e75acb2664f79cf87372cee2ffb4a4a3800398b0fd72c537cb83a330b925c2d0113cdbe
+  metadata.gz: dd567b1504d755539f5f3f277bfb763816b23b5b725aee4c84b3ccae0722be04565aba2eb4d419dd0a33e3d8c024dc49b261d152e839755b4669fe80f36f9a4a
+  data.tar.gz: c7bcec000da4c4fee6f51b4bc511b23caa89760d9b1559c7754d37f7cc9f4f3556b4e3060a6e0aba66131563da3c65a8908135c411a65f242a9b0f59042e6b26

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.8.10] - 2024-04-30
+
+### Changed
+
+- Allow spec files when publishing the gem;
+
 ## [0.8.9] - 2024-04-29
 
 ### Added

data/auction_fun_core.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(__dir__) do
     `git ls-files -z`.split("\x0").reject do |f|
       (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
+        f.start_with?(*%w[bin/ test/ features/ .git .github appveyor Gemfile])
     end
   end
   spec.bindir = "exe"

data/lib/auction_fun_core/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module AuctionFunCore
-  VERSION = "0.8.9"
+  VERSION = "0.8.10"
 
   # Required class module is a gem dependency
   class Version; end

data/spec/auction_fun_core/contracts/auction_context/create_contract_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::CreateContract, type: :contract do
+  let(:min) { described_class::AUCTION_MIN_TITLE_LENGTH }
+  let(:max) { described_class::AUCTION_MAX_TITLE_LENGTH }
+  let(:stopwatch_min_value) { described_class::AUCTION_STOPWATCH_MIN_VALUE }
+  let(:stopwatch_max_value) { described_class::AUCTION_STOPWATCH_MAX_VALUE }
+  let(:kinds) { described_class::AUCTION_KINDS.join(", ") }
+
+  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[:title]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:kind]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:started_at]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:staff_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "with default values" do
+      let(:attributes) { {initial_bid_cents: 100} }
+
+      it "expect minimal_bid_cents to be equal initial_bid_cents" do
+        expect(contract[:minimal_bid_cents]).to eq(100)
+      end
+    end
+
+    describe "#staff_id" do
+      context "when staff is not found on database" do
+        let(:attributes) { {staff_id: 1} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:staff_id])
+            .to include(I18n.t("contracts.errors.custom.default.not_found"))
+        end
+      end
+    end
+
+    describe "#title" do
+      let(:attributes) { {title: "abc"} }
+
+      context "when the characters in the title are outside the allowed range" do
+        it "expect failure with error messages" do
+          expect(subject).to be_failure
+
+          expect(subject.errors[:title]).to include(
+            I18n.t("contracts.errors.size?.value.string.arg.range", size_left: min, size_right: max)
+          )
+        end
+      end
+    end
+
+    describe "#kind" do
+      context "when kind is outside of default list" do
+        let(:attributes) { {kind: "unknown"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:kind]).to include(
+            I18n.t("contracts.errors.included_in?.arg.default", list: kinds)
+          )
+        end
+      end
+
+      context "when kind is standard or closed and finished_at is blank" do
+        let(:attributes) { {kind: "standard", started_at: 3.hours.from_now} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:finished_at]).to include(I18n.t("contracts.errors.filled?"))
+        end
+      end
+
+      context "when kind is closed and finished_at is blank" do
+        let(:attributes) { {kind: "closed", started_at: 3.hours.from_now} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:finished_at]).to include(I18n.t("contracts.errors.filled?"))
+        end
+      end
+    end
+
+    describe "#started_at" do
+      context "when is less than or equal to now" do
+        let(:attributes) { {started_at: 3.days.ago} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:started_at])
+            .to include(I18n.t("contracts.errors.custom.default.future"))
+        end
+      end
+    end
+
+    describe "#finished_at" do
+      context "when started_at is less than or equal to finished_at" do
+        let(:same_time) { 3.hours.from_now }
+        let(:attributes) { {kind: "standard", started_at: same_time, finished_at: same_time} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:finished_at])
+            .to include(I18n.t("contracts.errors.custom.auction_context.create.finished_at"))
+        end
+      end
+    end
+
+    describe "#initial_bid_cents" do
+      context "when kind is standard or closed and initial_bid_cents is blank" do
+        let(:attributes) { {kind: "standard"} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:initial_bid_cents]).to include(I18n.t("contracts.errors.filled?"))
+        end
+      end
+
+      context "when kind is standard or closed and initial_bid_cents is less than or equal to zero" do
+        let(:attributes) { {kind: "standard", initial_bid_cents: 0} }
+
+        it "expect failure with error messages" do
+          expect(contract).to be_failure
+          expect(contract.errors[:initial_bid_cents]).to include(I18n.t("contracts.errors.gt?", num: 0))
+        end
+      end
+
+      context "when kind is penny and initial_bid_cents is blank" do
+        let(:attributes) { {kind: "penny"} }
+
+        it "expect failure without error message in field" do
+          expect(contract).to be_failure
+          expect(contract.errors[:initial_bid_cents]).to be_blank
+        end
+      end
+
+      context "when kind is penny and initial_bid_cents is not zero" do
+        let(:attributes) { {kind: "penny", initial_bid_cents: 1000} }
+
+        it "expect failure with error message" do
+          expect(contract).to be_failure
+          expect(contract.errors[:initial_bid_cents]).to include(I18n.t("contracts.errors.eql?", left: 0))
+        end
+      end
+    end
+
+    it_behaves_like "validate_stopwatch_contract" do
+      let(:auction) { Factory.structs[:auction, :with_kind_penny, :with_status_scheduled, initial_bid_cents: 1000] }
+    end
+  end
+end

data/spec/auction_fun_core/contracts/auction_context/post_auction/participant_contract_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::PostAuction::ParticipantContract, type: :contract do
+  let(:auction) { Factory[:auction, :default_finished_standard, :with_winner] }
+  let(:participant) { Factory[:user] }
+
+  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.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:participant_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when auction is not found on database" do
+      let(:attributes) do
+        {
+          auction_id: 2_234_231,
+          participant_id: participant.id
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+      end
+    end
+
+    context "when participant is not found on database" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          participant_id: 2_234_231
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:participant_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+      end
+    end
+
+    context "when the user did not bid in the auction" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          participant_id: participant.id
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:participant_id]).to include(I18n.t("none", scope: described_class::I18N_SCOPE))
+      end
+    end
+
+    context "when the user placed at least one bid in the auction" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          participant_id: participant.id
+        }
+      end
+
+      before do
+        Factory[:bid, auction: auction, user_id: participant.id, value_cents: auction.minimal_bid_cents]
+      end
+
+      it "expect return success" do
+        expect(contract).to be_success
+        expect(contract.context[:auction]).to be_a(AuctionFunCore::Entities::Auction)
+        expect(contract.context[:participant]).to be_a(AuctionFunCore::Entities::User)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/auction_context/post_auction/winner_contract_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::PostAuction::WinnerContract, type: :contract do
+  let(:auction) { Factory[:auction, :default_finished_standard, :with_winner] }
+  let(:winner) { auction.winner }
+
+  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.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        expect(contract.errors[:winner_id]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    context "when auction is not found on database" do
+      let(:attributes) do
+        {
+          auction_id: 2_234_231,
+          winner_id: winner.id
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+      end
+    end
+
+    context "when winner is not found on database" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          winner_id: 2_234_231
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:winner_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+      end
+    end
+
+    context "when the informed winner is different from the one set in the auction" do
+      let(:real_winner) { Factory[:user] }
+      let(:fake_winner) { Factory[:user] }
+      let(:auction) { Factory[:auction, :default_scheduled_standard, winner_id: real_winner.id] }
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          winner_id: fake_winner.id
+        }
+      end
+
+      it "expect failure with error messages" do
+        expect(contract.errors[:winner_id]).to include(I18n.t("wrong", scope: described_class::I18N_SCOPE))
+      end
+    end
+
+    context "when the informed winner is the same as the one set in the auction" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          winner_id: winner.id
+        }
+      end
+
+      it "expect return sucess" do
+        expect(contract).to be_success
+        expect(contract.context[:auction]).to be_a(AuctionFunCore::Entities::Auction)
+        expect(contract.context[:winner]).to be_a(AuctionFunCore::Entities::User)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/contracts/auction_context/pre_auction/auction_start_reminder_contract_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::PreAuction::AuctionStartReminderContract, type: :contract do
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    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.errors[:auction_id]).to include(I18n.t("contracts.errors.key?"))
+        end
+      end
+
+      context "when auction is not found on database" do
+        let(:attributes) { {auction_id: 2_234_231} }
+
+        it "expect failure with error messages" do
+          expect(contract.errors[:auction_id]).to include(I18n.t("contracts.errors.custom.not_found"))
+        end
+      end
+
+      context "when the auction has already started" do
+        let(:auction) { Factory[:auction, :default_finished_standard, started_at: 3.hours.ago] }
+        let(:attributes) { {auction_id: auction.id} }
+
+        it "expect failure with error messages" do
+          expect(contract.errors[:base]).to include(
+            I18n.t("contracts.errors.custom.auction_context.pre_auction.auction_start_reminder.auction_already_started")
+          )
+        end
+      end
+
+      context "when the auction has not started" do
+        let(:auction) { Factory[:auction, :default_scheduled_standard, started_at: 3.hours.from_now] }
+        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
+end

data/spec/auction_fun_core/contracts/auction_context/processor/finish/closed_contract_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::Finish::ClosedContract, type: :contract do
+  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 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 not equal to 'closed'" do
+      let(:auction) { Factory[:auction, :default_running_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_kind")
+        )
+      end
+    end
+
+    context "when auction status is not equal to 'running'" do
+      let(:auction) { Factory[:auction, :default_paused_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_status")
+        )
+      end
+    end
+
+    context "when attributes are valid" do
+      let(:auction) { Factory[:auction, :default_running_closed] }
+      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/auction_context/processor/finish/penny_contract_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::Finish::PennyContract, type: :contract do
+  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 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 not equal to 'penny'" do
+      let(:auction) { Factory[:auction, :default_running_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_kind")
+        )
+      end
+    end
+
+    context "when auction status is not equal to 'running'" do
+      let(:auction) { Factory[:auction, :default_paused_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_status")
+        )
+      end
+    end
+
+    context "when attributes are valid" do
+      let(:auction) { Factory[:auction, :default_running_penny] }
+      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/auction_context/processor/finish/standard_contract_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::Finish::StandardContract, type: :contract do
+  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 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 not equal to 'standard'" do
+      let(:auction) { Factory[:auction, :default_running_penny] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_kind")
+        )
+      end
+    end
+
+    context "when auction status is not equal to 'running'" do
+      let(:auction) { Factory[:auction, :default_paused_standard] }
+      let(:attributes) { {auction_id: auction.id} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:base]).to include(
+          I18n.t("contracts.errors.custom.auction_context.processor.finish.invalid_status")
+        )
+      end
+    end
+
+    context "when attributes are valid" do
+      let(:auction) { Factory[:auction, :default_running_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/auction_context/processor/pause_contract_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::PauseContract, 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 'running'" 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 'running'" do
+      let(:auction) { Factory[:auction, :default_running_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/auction_context/processor/start_contract_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore::Contracts::AuctionContext::Processor::StartContract, type: :contract do
+  let(:auction) { Factory[:auction, :default_scheduled_standard] }
+  let(:kinds) { described_class::AUCTION_KINDS.join(", ") }
+
+  describe "#call" do
+    subject(:contract) { described_class.new.call(attributes) }
+
+    context "when all attributes 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[:kind]).to include(I18n.t("contracts.errors.key?"))
+      end
+    end
+
+    it_behaves_like "validate_stopwatch_contract" do
+      let(:auction) { Factory[:auction, :default_scheduled_penny] }
+    end
+
+    context "when auction_id is not founded on database" do
+      let(:attributes) { {auction_id: 2_234_231} }
+
+      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
+
+    describe "when auction kind is invalid" do
+      let(:attributes) { {auction_id: auction.id, auction: "invalid"} }
+
+      it "expect failure with error messages" do
+        expect(contract).to be_failure
+        expect(contract.errors[:kind]).to include(
+          I18n.t("contracts.errors.included_in?.arg.default", list: kinds)
+        )
+      end
+    end
+
+    context "when attributes are valid" do
+      let(:attributes) do
+        {
+          auction_id: auction.id,
+          kind: auction.kind,
+          stopwatch: described_class::AUCTION_STOPWATCH_MIN_VALUE
+        }
+      end
+
+      it "expect return success" do
+        expect(contract).to be_success
+        expect(contract.context[:auction]).to be_a(AuctionFunCore::Entities::Auction)
+      end
+    end
+  end
+end