console-blackjack 1.0.0

data/spec/factories/dealer_hand_factory.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :dealer_hand do
+    blackjack { nil }
+    hide_down_card { true }
+
+    initialize_with { new(blackjack) }
+  end
+end

data/spec/factories/hand_factory.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :hand do
+    cards { [] }
+    game { nil }
+    played { false }
+
+    initialize_with { new(game) }
+  end
+end

data/spec/factories/player_hand_factory.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :player_hand do
+    game { nil }
+    bet { 500 }
+    status { UNKNOWN }
+    payed { false }
+    stood { false }
+
+    initialize_with { new(game, bet) }
+  end
+end

data/spec/factories/shoe_factory.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+FactoryBot.define do
+  factory :shoe do
+    num_decks { 1 }
+    cards { [] }
+
+    trait :new_regular do
+      after(:build, &:new_regular)
+    end
+
+    initialize_with { new(num_decks) }
+  end
+end

data/spec/lib/blackjack/card_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe Card do
+  let(:card) { build(:card) }
+
+  describe '.new' do
+    it 'creates a card' do
+      expect(card).to be
+    end
+
+    it 'has a value' do
+      expect(card.value).to eq(0)
+    end
+
+    it 'has a suite' do
+      expect(card.suite).to eq(0)
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns a string value' do
+      expect(card.to_s).to eq('🂡')
+    end
+  end
+
+  describe '#ace?' do
+    it 'returns true' do
+      expect(card).to be_ace
+    end
+
+    it 'returns false' do
+      card = build(:card, :two)
+      expect(card).not_to be_ace
+    end
+  end
+
+  describe '#ten?' do
+    it 'returns true' do
+      card = build(:card, :ten)
+      expect(card).to be_ten
+    end
+
+    it 'returns false' do
+      expect(card).not_to be_ten
+    end
+  end
+
+  describe '.faces' do
+    it 'returns a five of clubs' do
+      expect(described_class.faces[4][3]).to eq('🃕')
+    end
+  end
+end

data/spec/lib/blackjack/dealer_hand_spec.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+RSpec.describe DealerHand do
+  let(:shoe) { build(:shoe, :new_regular) }
+  let(:blackjack) { build(:blackjack) }
+  let(:dealer_hand) { build(:dealer_hand, blackjack: blackjack) }
+  let(:ace) { build(:card, :ace) }
+  let(:five) { build(:card, :five) }
+  let(:six) { build(:card, :six) }
+  let(:seven) { build(:card, :seven) }
+  let(:eight) { build(:card, :eight) }
+  let(:nine) { build(:card, :nine) }
+  let(:ten) { build(:card, :ten) }
+
+  describe '.new' do
+    it 'creates a dealer_hand' do
+      expect(dealer_hand).to be
+    end
+
+    it 'has a blackjack' do
+      expect(dealer_hand.blackjack).to eq(blackjack)
+    end
+  end
+
+  describe '#busted?' do
+    it 'returns false' do
+      expect(dealer_hand).to_not be_busted
+    end
+
+    it 'returns true' do
+      dealer_hand.cards << ten << ten << ten
+      dealer_hand.hide_down_card = false
+      expect(dealer_hand).to be_busted
+    end
+  end
+
+  describe '#value' do
+    context 'with a soft count' do
+      it 'returns 10' do
+        dealer_hand.cards << ten << ace
+        expect(dealer_hand.value(SOFT)).to eq(10)
+      end
+
+      it 'returns 11' do
+        dealer_hand.cards << ace << ten
+        expect(dealer_hand.value(SOFT)).to eq(11)
+      end
+
+      it 'returns 12' do
+        dealer_hand.cards << ten << ace << ace
+        dealer_hand.hide_down_card = false
+        expect(dealer_hand.value(SOFT)).to eq(12)
+      end
+    end
+
+    context 'with a hard count' do
+      it 'returns 10' do
+        dealer_hand.cards << ten << ace
+        expect(dealer_hand.value(HARD)).to eq(10)
+      end
+
+      it 'returns 1' do
+        dealer_hand.cards << ace << ten
+        expect(dealer_hand.value(HARD)).to eq(1)
+      end
+    end
+  end
+
+  describe '#upcard_is_ace?' do
+    it 'returns false' do
+      dealer_hand.cards << ten << ace
+      expect(dealer_hand).to_not be_upcard_is_ace
+    end
+
+    it 'returns true' do
+      dealer_hand.cards << ace << ten
+      expect(dealer_hand).to be_upcard_is_ace
+    end
+  end
+
+  describe '#draw' do
+    it 'returns " 🂪 🂠  ⇒  10"' do
+      dealer_hand.cards << ten << ace
+      expected = ' 🂪 🂠  ⇒  10'
+      expect(dealer_hand.draw).to eq(expected)
+    end
+
+    it 'returns " 🂡 🂠  ⇒  11"' do
+      dealer_hand.cards << ace << ten
+      expected = ' 🂡 🂠  ⇒  11'
+      expect(dealer_hand.draw).to eq(expected)
+    end
+
+    it 'returns " 🂡 🂪  ⇒  21"' do
+      dealer_hand.cards << ace << ten
+      dealer_hand.hide_down_card = false
+      expected = ' 🂡 🂪  ⇒  21'
+      expect(dealer_hand.draw).to eq(expected)
+    end
+  end
+
+  describe '#both_values' do
+    context 'with a soft count' do
+      it 'returns [10, 10]' do
+        dealer_hand.cards << ten << ace
+        expect(dealer_hand.both_values).to eq([10, 10])
+      end
+
+      it 'returns [11, 1]' do
+        dealer_hand.cards << ace << ten
+        expect(dealer_hand.both_values).to eq([11, 1])
+      end
+
+      it 'returns [12, 12]' do
+        dealer_hand.cards << ten << ace << ace
+        dealer_hand.hide_down_card = false
+        expect(dealer_hand.both_values).to eq([12, 12])
+      end
+    end
+
+    context 'with a hard count' do
+      it 'returns [10, 10]' do
+        dealer_hand.cards << ten << ace
+        expect(dealer_hand.both_values).to eq([10, 10])
+      end
+
+      it 'returns [11, 1]' do
+        dealer_hand.cards << ace << ten
+        expect(dealer_hand.both_values).to eq([11, 1])
+      end
+    end
+  end
+
+  describe '#deal_required_cards' do
+    let(:shoe) { build(:shoe, :new_regular) }
+
+    before do
+      blackjack.shoe = shoe
+    end
+
+    context 'when soft is < 18' do
+      it 'deals cards' do
+        dealer_hand.cards << ace << seven
+        dealer_hand.deal_required_cards
+        expect(dealer_hand.cards.size >= 3).to be_truthy
+      end
+    end
+
+    context 'when hard is < 17' do
+      it 'deals cards' do
+        dealer_hand.cards << ace << ten << five
+        dealer_hand.deal_required_cards
+        expect(dealer_hand.cards.size >= 4).to be_truthy
+      end
+    end
+  end
+
+  describe '#play' do
+    before do
+      blackjack.dealer_hand = dealer_hand
+    end
+
+    it 'plays the dealer hand' do
+      dealer_hand.play
+      expect(dealer_hand.played).to be_truthy
+    end
+
+    it 'pays hands' do
+      allow(blackjack).to receive(:pay_hands)
+      dealer_hand.play
+      expect(blackjack).to have_received(:pay_hands)
+    end
+
+    context 'when does not need to play dealer hand' do
+      before do
+        allow(blackjack).to receive(:need_to_play_dealer_hand?).and_return(false)
+      end
+
+      it 'hides down card when no blackjack' do
+        allow(dealer_hand).to receive(:blackjack?).and_return(false)
+        dealer_hand.play
+        expect(dealer_hand.hide_down_card).to be_truthy
+      end
+
+      it 'shows down card if blackjack' do
+        allow(dealer_hand).to receive(:blackjack?).and_return(true)
+        dealer_hand.play
+        expect(dealer_hand.hide_down_card).to be_falsey
+      end
+
+      it 'does not deal any cards' do
+        allow(dealer_hand).to receive(:deal_required_cards)
+        dealer_hand.play
+        expect(dealer_hand).to_not have_received(:deal_required_cards)
+      end
+    end
+
+    context 'when need to play dealer hand' do
+      before do
+        blackjack.shoe = shoe
+        allow(blackjack).to receive(:need_to_play_dealer_hand?).and_return(true)
+      end
+
+      it 'shows down card if not blackjack' do
+        allow(dealer_hand).to receive(:blackjack?).and_return(false)
+        dealer_hand.play
+        expect(dealer_hand.hide_down_card).to be_falsey
+      end
+
+      it 'shows down card if blackjack' do
+        allow(dealer_hand).to receive(:blackjack?).and_return(true)
+        dealer_hand.play
+        expect(dealer_hand.hide_down_card).to be_falsey
+      end
+
+      it 'deals required cards' do
+        allow(dealer_hand).to receive(:deal_required_cards)
+        dealer_hand.play
+        expect(dealer_hand).to have_received(:deal_required_cards)
+      end
+    end
+  end
+end

data/spec/lib/blackjack/hand_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe Hand do
+  let(:shoe) { build(:shoe, :new_regular) }
+  let(:blackjack) { build(:blackjack, shoe: shoe) }
+  let(:hand) { build(:hand, blackjack: blackjack) }
+
+  describe '.new' do
+    it 'creates a hand' do
+      expect(hand).to be
+    end
+
+    it 'has a blackjack' do
+      expect(hand.blackjack).to eq(blackjack)
+    end
+  end
+
+  describe '#deal_card' do
+    it 'adds a card to the hand' do
+      expect {
+        hand.deal_card
+      }.to change { hand.cards.size }.by(1)
+    end
+  end
+
+  describe '#blackjack?' do
+    context 'with an empty hand' do
+      it 'returns false' do
+        expect(hand).to_not be_blackjack
+      end
+    end
+
+    context 'with two cards' do
+      let(:ace) { build(:card, :ace) }
+      let(:ten) { build(:card, :ten) }
+
+      it 'an ace and a ten returns true' do
+        hand.cards << ace << ten
+        expect(hand).to be_blackjack
+      end
+
+      it 'a ten and an ace returns true' do
+        hand.cards << ten << ace
+        expect(hand).to be_blackjack
+      end
+
+      it 'two aces returns false' do
+        hand.cards << ace << ace
+        expect(hand).to_not be_blackjack
+      end
+    end
+  end
+end

data/spec/lib/blackjack/player_hand_spec.rb

@@ -0,0 +1,563 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+RSpec.describe PlayerHand do
+  let(:shoe) { build(:shoe, :new_regular) }
+  let(:blackjack) { build(:blackjack, shoe: shoe) }
+  let(:player_hand) { build(:player_hand, blackjack: blackjack) }
+  let(:dealer_hand) { build(:dealer_hand, blackjack: blackjack) }
+  let(:ace) { build(:card, :ace) }
+  let(:six) { build(:card, :six) }
+  let(:seven) { build(:card, :seven) }
+  let(:eight) { build(:card, :eight) }
+  let(:nine) { build(:card, :nine) }
+  let(:ten) { build(:card, :ten) }
+
+  describe '.new' do
+    it 'creates a player_hand' do
+      expect(player_hand).to be
+    end
+
+    it 'has a blackjack' do
+      expect(player_hand.blackjack).to eq(blackjack)
+    end
+
+    it 'has a bet' do
+      expect(player_hand.bet).to eq(500)
+    end
+
+    it 'has an unknown status' do
+      expect(player_hand.status).to eq(UNKNOWN)
+    end
+
+    it 'has not been payed' do
+      expect(player_hand.payed).to be_falsey
+    end
+  end
+
+  describe '#busted?' do
+    it 'returns false' do
+      expect(player_hand).to_not be_busted
+    end
+
+    it 'returns true' do
+      player_hand.cards << ten << ten << ten
+      expect(player_hand).to be_busted
+    end
+  end
+
+  describe '#value' do
+    context 'with a soft count' do
+      it 'returns 21' do
+        player_hand.cards << ten << ace
+        expect(player_hand.value(SOFT)).to eq(21)
+      end
+
+      it 'returns 12' do
+        player_hand.cards << ten << ace << ace
+        expect(player_hand.value(SOFT)).to eq(12)
+      end
+    end
+
+    context 'with a hard count' do
+      it 'returns 11' do
+        player_hand.cards << ten << ace
+        expect(player_hand.value(HARD)).to eq(11)
+      end
+    end
+  end
+
+  describe '#done?' do
+    context 'when played' do
+      it 'returns true' do
+        player_hand.played = true
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when stood' do
+      it 'returns true' do
+        player_hand.stood = true
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when blackjack' do
+      it 'returns true' do
+        player_hand.cards << ace << ten
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when busted' do
+      it 'returns true' do
+        player_hand.cards << ten << ten << ten
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when soft count of 21' do
+      it 'returns true' do
+        player_hand.cards << ace << ace << nine
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when hard count of 21' do
+      it 'returns true' do
+        player_hand.cards << ace << ten << ten
+        expect(player_hand).to be_done
+      end
+    end
+
+    context 'when pair of sevens' do
+      it 'returns false' do
+        player_hand.cards << seven << seven
+        expect(player_hand).to_not be_done
+      end
+    end
+  end
+
+  describe '#can_split?' do
+    context 'when stood' do
+      it 'returns false' do
+        player_hand.stood = true
+        expect(player_hand).to_not be_can_split
+      end
+    end
+
+    context 'when MAX_PLAYER_HANDS' do
+      it 'returns false' do
+        6.times { blackjack.player_hands << build(:player_hand) }
+        expect(player_hand).to_not be_can_split
+      end
+    end
+
+    context 'when not enough money' do
+      it 'returns false' do
+        blackjack.money = 9999
+        expect(player_hand).to_not be_can_split
+      end
+    end
+
+    context 'when more than 2 cards' do
+      it 'returns false' do
+        player_hand.cards << ace << ace << ace
+        expect(player_hand).to_not be_can_split
+      end
+    end
+
+    context 'when card values do not match' do
+      it 'returns false' do
+        player_hand.cards << seven << nine
+        expect(player_hand).to_not be_can_split
+      end
+    end
+
+    context 'when card values match' do
+      it 'returns true' do
+        player_hand.cards << seven << seven
+        expect(player_hand).to be_can_split
+      end
+    end
+  end
+
+  describe '#can_dbl?' do
+    context 'when not enough money' do
+      it 'returns false' do
+        blackjack.money = 9999
+        expect(player_hand).to_not be_can_dbl
+      end
+    end
+
+    context 'when stood' do
+      it 'returns false' do
+        player_hand.stood = true
+        expect(player_hand).to_not be_can_dbl
+      end
+    end
+
+    context 'when more than 2 cards' do
+      it 'returns false' do
+        player_hand.cards << ace << ace << ace
+        expect(player_hand).to_not be_can_dbl
+      end
+    end
+
+    context 'when blackjack' do
+      it 'returns false' do
+        player_hand.cards << ace << ten
+        expect(player_hand).to_not be_can_dbl
+      end
+    end
+
+    context 'when a pair of sixes' do
+      it 'returns true' do
+        player_hand.cards << six << six
+        expect(player_hand).to be_can_dbl
+      end
+    end
+  end
+
+  describe '#can_stand?' do
+    context 'when stood' do
+      it 'returns false' do
+        player_hand.stood = true
+        expect(player_hand).to_not be_can_stand
+      end
+    end
+
+    context 'when blackjack' do
+      it 'returns false' do
+        player_hand.cards << ace << ten
+        expect(player_hand).to_not be_can_stand
+      end
+    end
+
+    context 'when busted' do
+      it 'returns false' do
+        player_hand.cards << eight << eight << eight
+        expect(player_hand).to_not be_can_stand
+      end
+    end
+
+    context 'when a pair of sixes' do
+      it 'returns true' do
+        player_hand.cards << six << six
+        expect(player_hand).to be_can_stand
+      end
+    end
+  end
+
+  describe '#can_hit?' do
+    context 'when played' do
+      it 'returns false' do
+        player_hand.played = true
+        expect(player_hand).to_not be_can_hit
+      end
+    end
+
+    context 'when stood' do
+      it 'returns false' do
+        player_hand.stood = true
+        expect(player_hand).to_not be_can_hit
+      end
+    end
+
+    context 'when blackjack' do
+      it 'returns false' do
+        player_hand.cards << ace << ten
+        expect(player_hand).to_not be_can_hit
+      end
+    end
+
+    context 'when busted' do
+      it 'returns false' do
+        player_hand.cards << eight << eight << eight
+        expect(player_hand).to_not be_can_hit
+      end
+    end
+
+    context 'when a hard 21' do
+      it 'returns false' do
+        player_hand.cards << seven << seven << seven
+        expect(player_hand).to_not be_can_hit
+      end
+    end
+
+    context 'when a pair of sixes' do
+      it 'returns true' do
+        player_hand.cards << six << six
+        expect(player_hand).to be_can_hit
+      end
+    end
+  end
+
+  describe '#draw' do
+    it 'draws the hand' do
+      player_hand.cards << ace << ten
+      expected = " 🂡 🂪  ⇒  21  $5.00  \n\n"
+      expect(player_hand.draw(1)).to eq(expected)
+    end
+
+    it 'draws a lost hand' do
+      player_hand.cards << ace << ace
+      player_hand.status = LOST
+      expected = " 🂡 🂡  ⇒  12  -$5.00  Lose!\n\n"
+      expect(player_hand.draw(1)).to eq(expected)
+    end
+
+    it 'draws a won hand' do
+      player_hand.cards << ace << ace
+      player_hand.status = WON
+      expected = " 🂡 🂡  ⇒  12  +$5.00  Won!\n\n"
+      expect(player_hand.draw(1)).to eq(expected)
+    end
+
+    it 'draws a push hand' do
+      player_hand.cards << ace << ace
+      player_hand.status = PUSH
+      expected = " 🂡 🂡  ⇒  12  $5.00  Push\n\n"
+      expect(player_hand.draw(1)).to eq(expected)
+    end
+  end
+
+  describe '#process' do
+    context 'with more hands to play' do
+      before do
+        allow(blackjack).to receive(:more_hands_to_play?).and_return(true)
+        allow(blackjack).to receive(:play_more_hands)
+      end
+
+      it 'plays more hands' do
+        player_hand.process
+        expect(blackjack).to have_received(:play_more_hands)
+      end
+    end
+
+    context 'with no more hands to play' do
+      before do
+        allow(blackjack).to receive(:more_hands_to_play?).and_return(false)
+        allow(blackjack).to receive(:play_dealer_hand)
+      end
+
+      it 'plays dealer hand' do
+        player_hand.process
+        expect(blackjack).to have_received(:play_dealer_hand)
+      end
+    end
+  end
+
+  describe '#hit' do
+    before do
+      blackjack.dealer_hand = dealer_hand
+    end
+
+    context 'when done' do
+      let(:dealer_hand) { build(:dealer_hand, blackjack: blackjack) }
+
+      before do
+        allow(player_hand).to receive(:done?).and_return(true)
+        allow(player_hand).to receive(:process)
+      end
+
+      it 'adds a card to the hand' do
+        expect { player_hand.hit }.to change { player_hand.cards.size }.by(1)
+      end
+    end
+
+    context 'when not done' do
+      before do
+        allow(player_hand).to receive(:done?).and_return(false)
+        allow(blackjack).to receive(:current_player_hand).and_return(player_hand)
+        allow(player_hand).to receive(:action?)
+        allow(blackjack).to receive(:draw_hands)
+      end
+
+      it 'adds a card to the hand' do
+        expect { player_hand.hit }.to change { player_hand.cards.size }.by(1)
+      end
+    end
+  end
+
+  describe '#dbl' do
+    before do
+      blackjack.dealer_hand = dealer_hand
+      allow(blackjack).to receive(:draw_hands)
+      allow(blackjack).to receive(:draw_bet_options)
+      allow(player_hand).to receive(:process)
+    end
+
+    context 'when done' do
+      before do
+        allow(player_hand).to receive(:done?).and_return(true)
+        player_hand.dbl
+      end
+
+      it 'adds a card to the hand' do
+        expect(player_hand.cards.size).to eq(1)
+      end
+
+      it 'sets hand to played' do
+        expect(player_hand.played).to be_truthy
+      end
+
+      it 'doubles the bet' do
+        expect(player_hand.bet).to eq(1000)
+      end
+
+      it 'calls process' do
+        expect(player_hand).to have_received(:process)
+      end
+    end
+
+    context 'when not done' do
+      before do
+        allow(player_hand).to receive(:done?).and_return(false)
+        player_hand.dbl
+      end
+
+      it 'does not call process' do
+        expect(player_hand).to_not have_received(:process)
+      end
+    end
+  end
+
+  describe '#stand' do
+    before do
+      allow(player_hand).to receive(:process)
+      allow(blackjack).to receive(:draw_hands)
+      allow(blackjack).to receive(:draw_bet_options)
+      blackjack.dealer_hand = dealer_hand
+      player_hand.stand
+    end
+
+    it 'sets the hand as stood' do
+      expect(player_hand.stood).to be_truthy
+    end
+
+    it 'sets the hand as played' do
+      expect(player_hand.played).to be_truthy
+    end
+
+    it 'calls process' do
+      expect(player_hand).to have_received(:process)
+    end
+  end
+
+  describe '#action?' do
+    before do
+      player_hand.cards << ace << ace
+      blackjack.player_hands << player_hand
+      blackjack.dealer_hand = dealer_hand
+      allow(player_hand).to receive(:puts)
+    end
+
+    context 'when standing' do
+      before do
+        allow(Blackjack).to receive(:getc).and_return('s', 'q')
+        allow(player_hand).to receive(:stand)
+      end
+
+      it 'stands the hand' do
+        player_hand.action?
+        expect(player_hand).to have_received(:stand)
+      end
+    end
+
+    context 'when hitting' do
+      before do
+        allow(Blackjack).to receive(:getc).and_return('h', 'q')
+        allow(player_hand).to receive(:hit)
+      end
+
+      it 'hits the hand' do
+        player_hand.action?
+        expect(player_hand).to have_received(:hit)
+      end
+    end
+
+    context 'when doubling' do
+      before do
+        allow(Blackjack).to receive(:getc).and_return('d', 'q')
+        allow(player_hand).to receive(:dbl)
+      end
+
+      it 'doubles the hand' do
+        player_hand.action?
+        expect(player_hand).to have_received(:dbl)
+      end
+    end
+
+    context 'when splitting' do
+      before do
+        allow(Blackjack).to receive(:getc).and_return('p', 'q')
+        allow(blackjack).to receive(:split_current_hand)
+      end
+
+      it 'splits the hand' do
+        player_hand.action?
+        expect(blackjack).to have_received(:split_current_hand)
+      end
+    end
+
+    context 'when invalid input' do
+      before do
+        allow(Blackjack).to receive(:getc).and_return('x', 's', 'q')
+        allow(blackjack).to receive(:clear)
+        allow(blackjack).to receive(:draw_hands)
+        allow(blackjack).to receive(:puts)
+      end
+
+      it 'gets the action again' do
+        expect { player_hand.action? }.to raise_error(SystemExit)
+      end
+    end
+  end
+
+  describe '#pay' do
+    it 'returns if already payed' do
+      player_hand.payed = true
+      allow(player_hand).to receive(:value)
+      player_hand.pay(18, false)
+      expect(player_hand).to_not have_received(:value)
+    end
+
+    context 'when dealer busted' do
+      it 'hand is won' do
+        player_hand.pay(22, true)
+        expect(player_hand.status).to eq(WON)
+      end
+    end
+
+    context 'when dealer is not busted' do
+      it 'hand is set to payed' do
+        player_hand.cards << ten << ten
+        player_hand.pay(18, false)
+        expect(player_hand.payed).to be_truthy
+      end
+
+      it 'hand status is won' do
+        player_hand.cards << ten << ten
+        player_hand.pay(18, false)
+        expect(player_hand.status).to eq(WON)
+      end
+
+      it 'blackjack money is increased by player hand bet' do
+        player_hand.cards << ten << ten
+        player_hand.pay(18, false)
+        expect(blackjack.money).to eq(10_500)
+      end
+
+      it 'hand bet is * 1.5' do
+        player_hand.cards << ace << ten
+        player_hand.pay(18, false)
+        expect(player_hand.bet).to eq(750)
+      end
+
+      it 'hand is lost' do
+        player_hand.cards << ten << seven
+        player_hand.pay(18, false)
+        expect(player_hand.status).to eq(LOST)
+      end
+
+      it 'blackjack money is descreased by player hand bet' do
+        player_hand.cards << ten << seven
+        player_hand.pay(18, false)
+        expect(blackjack.money).to eq(9500)
+      end
+
+      it 'hand is push' do
+        player_hand.cards << ten << seven
+        player_hand.pay(17, false)
+        expect(player_hand.status).to eq(PUSH)
+      end
+
+      it 'blackjack money is unaltered' do
+        player_hand.cards << ten << seven
+        player_hand.pay(17, false)
+        expect(blackjack.money).to eq(10_000)
+      end
+    end
+  end
+end