auction_fun_core 0.8.9 → 0.8.10

data/spec/auction_fun_core/workers/operations/auction_context/processor/finish/standard_operation_job_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Operations::AuctionContext::Processor::Finish::StandardOperationJob, type: :worker do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_running_standard] }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when params are valid" do
+      it "expect execute auction start operation" do
+        expect { worker.perform(auction.id) }
+          .to change { auction_repository.by_id(auction.id).status }
+          .from("running")
+          .to("finished")
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/workers/operations/auction_context/processor/start_operation_job_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Operations::AuctionContext::Processor::StartOperationJob, type: :worker do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:auction) { Factory[:auction, :default_scheduled_standard] }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when params are valid" do
+      it "expect execute auction start operation" do
+        expect { worker.perform(auction.id) }
+          .to change { auction_repository.by_id(auction.id).status }
+          .from("scheduled")
+          .to("running")
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/workers/services/mail/auction_context/post_auction/participant_mailer_job_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Services::Mail::AuctionContext::PostAuction::ParticipantMailerJob, type: :worker do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:user_repository) { AuctionFunCore::Repos::UserContext::UserRepository.new }
+  let(:relation) { AuctionFunCore::Application[:container].relations[:auctions] }
+  let(:participant) { Factory[:user] }
+  let(:auction) { Factory[:auction, :default_finished_standard, :with_winner] }
+  let(:statistics) { ROM::OpenStruct.new(id: auction.id, auction_total_bids: 0, winner_bid: nil, winner_total_bids: 0) }
+  let(:participant_mailer) { AuctionFunCore::Services::Mail::AuctionContext::PostAuction::ParticipantMailer }
+  let(:mailer) { participant_mailer.new(auction, participant, statistics) }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when attributes are valid" do
+      before do
+        allow(AuctionFunCore::Repos::AuctionContext::AuctionRepository).to receive(:new).and_return(auction_repository)
+        allow(AuctionFunCore::Repos::UserContext::UserRepository).to receive(:new).and_return(user_repository)
+        allow(auction_repository).to receive(:by_id!).with(auction.id).and_return(auction)
+        allow(user_repository).to receive(:by_id!).with(participant.id).and_return(participant)
+        allow(relation).to receive_message_chain("load_participant_statistics.call.first").and_return(statistics)
+        allow(participant_mailer).to receive(:new).with(auction, participant, statistics).and_return(mailer)
+        allow(mailer).to receive(:deliver).and_return(true)
+      end
+
+      it "expect trigger registration mailer service" do
+        worker.perform(auction.id, participant.id)
+
+        expect(mailer).to have_received(:deliver).once
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil, nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil, nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/workers/services/mail/auction_context/post_auction/pre_auction/auction_start_reminder_mailer_job_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailerJob, type: :worker do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:user_repository) { AuctionFunCore::Repos::UserContext::UserRepository.new }
+  let(:participant) { Factory[:user] }
+  let(:auction) { Factory[:auction, :default_finished_standard, :with_winner] }
+  let(:auction_start_reminder_mailer) { AuctionFunCore::Services::Mail::AuctionContext::PreAuction::AuctionStartReminderMailer }
+  let(:mailer) { auction_start_reminder_mailer.new(auction, participant) }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when attributes are valid" do
+      before do
+        allow(AuctionFunCore::Repos::AuctionContext::AuctionRepository).to receive(:new).and_return(auction_repository)
+        allow(AuctionFunCore::Repos::UserContext::UserRepository).to receive(:new).and_return(user_repository)
+        allow(auction_repository).to receive(:by_id!).with(auction.id).and_return(auction)
+        allow(user_repository).to receive(:by_id!).with(participant.id).and_return(participant)
+        allow(auction_start_reminder_mailer).to receive(:new).with(auction, participant).and_return(mailer)
+        allow(mailer).to receive(:deliver).and_return(true)
+      end
+
+      it "expect trigger registration mailer service" do
+        worker.perform(auction.id, participant.id)
+
+        expect(mailer).to have_received(:deliver).once
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil, nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil, nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/workers/services/mail/auction_context/post_auction/winner_mailer_job_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Services::Mail::AuctionContext::PostAuction::WinnerMailerJob, type: :worker do
+  let(:auction_repository) { AuctionFunCore::Repos::AuctionContext::AuctionRepository.new }
+  let(:user_repository) { AuctionFunCore::Repos::UserContext::UserRepository.new }
+  let(:relation) { AuctionFunCore::Application[:container].relations[:auctions] }
+  let(:winner) { Factory[:user] }
+  let(:auction) { Factory[:auction, :default_finished_standard, :with_winner] }
+  let(:statistics) { ROM::OpenStruct.new(id: auction.id, auction_total_bids: 1, winner_bid: auction.minimal_bid_cents, winner_total_bids: 1) }
+  let(:winner_mailer) { AuctionFunCore::Services::Mail::AuctionContext::PostAuction::WinnerMailer }
+  let(:mailer) { winner_mailer.new(auction, winner, statistics) }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when attributes are valid" do
+      before do
+        allow(AuctionFunCore::Repos::AuctionContext::AuctionRepository).to receive(:new).and_return(auction_repository)
+        allow(AuctionFunCore::Repos::UserContext::UserRepository).to receive(:new).and_return(user_repository)
+        allow(auction_repository).to receive(:by_id!).with(auction.id).and_return(auction)
+        allow(user_repository).to receive(:by_id!).with(winner.id).and_return(winner)
+        allow(relation).to receive_message_chain("load_winner_statistics.call.first").and_return(statistics)
+        allow(winner_mailer).to receive(:new).with(auction, winner, statistics).and_return(mailer)
+        allow(mailer).to receive(:deliver).and_return(true)
+      end
+
+      it "expect trigger registration mailer service" do
+        worker.perform(auction.id, winner.id)
+
+        expect(mailer).to have_received(:deliver).once
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil, nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil, nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core/workers/services/mail/user_context/registration_mailer_job_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe AuctionFunCore::Workers::Services::Mail::UserContext::RegistrationMailerJob, type: :worker do
+  let(:user) { Factory[:user] }
+  let(:user_repo) { AuctionFunCore::Repos::UserRepository.new }
+  let(:mailer_class) { AuctionFunCore::Services::Mail::UserContext::RegistrationMailer }
+  let(:mailer) { mailer_class.new(user) }
+
+  describe "#perform" do
+    subject(:worker) { described_class.new }
+
+    context "when attributes are valid" do
+      before do
+        allow(mailer_class).to receive(:new).with(user).and_return(mailer)
+        allow(mailer).to receive(:deliver).and_return(true)
+      end
+
+      it "expect trigger registration mailer service" do
+        worker.perform(user.id)
+
+        expect(mailer).to have_received(:deliver).once
+      end
+    end
+
+    context "when an exception occours but retry limit is not reached" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 1)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect rescue/capture exception and reschedule job" do
+        expect { worker.perform(nil) }.to change(described_class.jobs, :size).from(0).to(1)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+
+    context "when the exception reaches the retry limit" do
+      before do
+        stub_const("::AuctionFunCore::Workers::ApplicationJob::MAX_RETRIES", 0)
+        allow(AuctionFunCore::Application[:logger]).to receive(:error)
+      end
+
+      it "expect raise exception and stop retry" do
+        expect { worker.perform(nil) }.to raise_error(ROM::TupleCountMismatchError)
+
+        expect(AuctionFunCore::Application[:logger]).to have_received(:error).at_least(:once)
+      end
+    end
+  end
+end

data/spec/auction_fun_core_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe AuctionFunCore do
+  it "has a version number" do
+    expect(AuctionFunCore::VERSION).to eq("0.8.10")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+ENV["APP_ENV"] = "test"
+
+if ENV["CI"]
+  require "simplecov"
+  SimpleCov.start do
+    add_filter "/spec"
+    add_group "Commands", "lib/auction_fun_core/commands"
+    add_group "Contracts", "lib/auction_fun_core/contracts"
+    add_group "Entities", "lib/auction_fun_core/entities"
+    add_group "Operations", "lib/auction_fun_core/operations"
+    add_group "Relations", "lib/auction_fun_core/relations"
+    add_group "Repositories", "lib/auction_fun_core/repos"
+    add_group "Services", "lib/auction_fun_core/services"
+    add_group "Workers", "lib/auction_fun_core/workers"
+    add_group "System", "system"
+    add_group "Config", "config"
+  end
+end
+
+require_relative "../config/application"
+require "pry"
+require "dotenv"
+require "rom-factory"
+require "database_cleaner/sequel"
+require "sidekiq/testing"
+
+AuctionFunCore::Application.start(:core)
+
+Factory = ROM::Factory.configure do |config|
+  config.rom = AuctionFunCore::Application[:container]
+end
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |file| require file }
+
+RSpec.configure do |config|
+  config.add_setting :rom
+  config.rom = Factory.rom
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  config.before do
+    DatabaseCleaner.clean
+    Sidekiq::Worker.clear_all
+  end
+
+  config.after(:suite) do
+    AuctionFunCore::Application.stop(:core)
+  end
+end
+
+DatabaseCleaner.strategy = :truncation

data/spec/support/background_job.rb

@@ -0,0 +1,7 @@
+Sidekiq::Testing.fake!
+
+RSpec.configure do |config|
+  config.before do
+    Sidekiq::Worker.clear_all
+  end
+end

data/spec/support/factories/auctions.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+Factory.define(:auction, struct_namespace: AuctionFunCore::Entities) do |f|
+  f.association(:staff)
+  f.title { fake(:commerce, :product_name) }
+  f.description { fake(:lorem, :paragraph) }
+  f.initial_bid_cents { 0 }
+  f.initial_bid_currency { AuctionFunCore::Application[:settings].default_currency }
+  f.minimal_bid_cents { 0 }
+  f.minimal_bid_currency { AuctionFunCore::Application[:settings].default_currency }
+
+  f.trait :with_minimal_bid do |t|
+  end
+
+  f.trait :with_winner do |t|
+    f.association(:winner)
+  end
+
+  f.trait :with_participants do |t|
+    f.association(:winner)
+  end
+
+  f.trait :with_kind_standard do |t|
+    t.kind { "standard" }
+  end
+
+  f.trait :with_kind_penny do |t|
+    t.kind { "penny" }
+  end
+
+  f.trait :with_kind_closed do |t|
+    t.kind { "closed" }
+  end
+
+  f.trait :with_status_scheduled do |t|
+    t.status { "scheduled" }
+  end
+
+  f.trait :with_status_running do |t|
+    t.status { "running" }
+  end
+
+  f.trait :with_status_paused do |t|
+    t.status { "paused" }
+  end
+
+  f.trait :with_status_canceled do |t|
+    t.status { "canceled" }
+  end
+
+  f.trait :with_status_finished do |t|
+    t.status { "finished" }
+  end
+
+  f.trait :started_in_one_hour_from_now do |t|
+    t.started_at { 1.hour.from_now }
+  end
+
+  f.trait :started_in_one_day_from_now do |t|
+    t.started_at { 1.day.from_now }
+  end
+
+  f.trait :finished_in_two_days_from_now do |t|
+    t.started_at { 1.day.from_now }
+    t.finished_at { 2.days.from_now }
+  end
+
+  f.trait :default_scheduled_standard do |t|
+    t.kind { "standard" }
+    t.status { "scheduled" }
+
+    t.started_at { 1.hour.from_now }
+    t.finished_at { 1.week.from_now }
+    t.initial_bid_cents { 100 }
+    t.minimal_bid_cents { 100 }
+  end
+
+  f.trait :default_running_standard do |t|
+    t.kind { "standard" }
+    t.status { "running" }
+
+    t.started_at { 1.hour.ago }
+    t.finished_at { 1.day.from_now }
+    t.initial_bid_cents { 100 }
+    t.minimal_bid_cents { 100 }
+  end
+
+  f.trait :default_finished_standard do |t|
+    t.kind { "standard" }
+    t.status { "finished" }
+
+    t.started_at { 2.days.ago }
+    t.finished_at { 1.day.ago }
+    t.initial_bid_cents { 100 }
+    t.minimal_bid_cents { 100 }
+  end
+
+  f.trait :default_paused_standard do |t|
+    t.kind { "standard" }
+    t.status { "paused" }
+
+    t.started_at { 1.hour.ago }
+    t.finished_at { 1.day.from_now }
+    t.initial_bid_cents { 100 }
+    t.minimal_bid_cents { 100 }
+  end
+
+  f.trait :default_scheduled_penny do |t|
+    t.kind { "penny" }
+    t.status { "scheduled" }
+
+    t.stopwatch { AuctionFunCore::Business::Configuration::AUCTION_STOPWATCH_MIN_VALUE }
+    t.started_at { 1.hour.from_now }
+    t.finished_at { 1.hour.from_now + AuctionFunCore::Business::Configuration::AUCTION_STOPWATCH_MIN_VALUE }
+  end
+
+  f.trait :default_running_penny do |t|
+    t.kind { "penny" }
+    t.status { "running" }
+
+    t.started_at { 1.hour.ago }
+    t.finished_at { 60.seconds.from_now }
+    t.initial_bid_cents { 100 }
+  end
+
+  f.trait :default_scheduled_closed do |t|
+    t.kind { "closed" }
+    t.status { "scheduled" }
+
+    t.initial_bid_cents { 100 }
+    t.started_at { 1.hour.from_now }
+    t.finished_at { 1.week.from_now }
+  end
+
+  f.trait :default_running_closed do |t|
+    t.kind { "closed" }
+    t.status { "running" }
+
+    t.started_at { 1.hour.ago }
+    t.finished_at { 1.day.from_now }
+    t.initial_bid_cents { 100 }
+  end
+end

data/spec/support/factories/bids.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+Factory.define(:bid, struct_namespace: AuctionFunCore::Entities) do |f|
+  f.association(:auction, :default_scheduled_standard)
+  f.association(:user)
+end

data/spec/support/factories/staffs.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Factory.define(:staff, struct_namespace: AuctionFunCore::Entities) do |f|
+  f.name { fake(:name, :name) }
+  f.email { fake(:internet, :email) }
+  f.phone { fake(:phone_number, :cell_phone_in_e164).tr_s("^0-9", "") }
+  f.password_digest { BCrypt::Password.create("password") }
+  f.kind { "common" }
+  f.active { true }
+
+  f.trait :with_root_kind do |t|
+    t.kind { "root" }
+  end
+
+  f.trait :inactive do |t|
+    t.active { false }
+  end
+end

data/spec/support/factories/users.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+Factory.define(:user, struct_namespace: AuctionFunCore::Entities) do |f|
+  f.name { fake(:name, :name) }
+  f.email { fake(:internet, :email) }
+  f.phone { fake(:phone_number, :cell_phone_in_e164).tr_s("^0-9", "") }
+  f.password_digest { BCrypt::Password.create("password") }
+  f.email_confirmation_at { Time.current - 1.day }
+  f.phone_confirmation_at { Time.current - 1.day }
+  f.confirmed_at { Time.current }
+  f.active { true }
+
+  f.trait :inactive do |t|
+    t.active { false }
+  end
+
+  f.trait :unconfirmed do |t|
+    t.email_confirmation_token { nil }
+    t.phone_confirmation_token { nil }
+    t.confirmed_at { nil }
+  end
+
+  f.trait :with_unconfirmed_email do |t|
+    t.email_confirmation_at { nil }
+  end
+
+  f.trait :with_unconfirmed_phone do |t|
+    t.phone_confirmation_at { nil }
+  end
+
+  f.trait :with_email_confirmation_token do |t|
+    t.email_confirmation_token { AuctionFunCore::Business::TokenGenerator.generate_email_token }
+  end
+
+  f.trait :with_phone_confirmation_token do |t|
+    t.phone_confirmation_token { AuctionFunCore::Business::TokenGenerator.generate_phone_token }
+  end
+
+  f.trait :with_balance do |t|
+    t.balance_cents { 1000 }
+    t.balance_currency { AuctionFunCore::Application[:settings].default_currency }
+  end
+end

data/spec/support/faker.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+if defined?(Faker)
+  I18n.enforce_available_locales = false
+  Faker::Config.locale = "pt-BR"
+end

data/spec/support/mail.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+IdleMailer.config do |config|
+  config.delivery_method = :test
+end
+
+RSpec.configure do |config|
+  config.include IdleMailer::Testing::Helpers
+
+  config.after :each do
+    IdleMailer::Testing.clear_mail!
+  end
+end

data/spec/support/shared_examples/validate_email_contract.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+shared_examples "validate_email_contract" do |factory_name|
+  let(:factory) { Factory[factory_name] }
+
+  context "when email is in wrong format" do
+    let(:attributes) { {email: "wrongemail"} }
+
+    it "expect failure with error messages" do
+      expect(subject).to be_failure
+
+      expect(subject.errors[:email]).to include(I18n.t("contracts.errors.custom.macro.email_format"))
+    end
+  end
+
+  context "when email is already exists on database" do
+    let(:attributes) { {email: factory.email} }
+
+    it "expect failure with error messages" do
+      expect(subject).to be_failure
+
+      expect(subject.errors[:email]).to include(I18n.t("contracts.errors.custom.default.taken"))
+    end
+  end
+end