# frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require "codebreaker_rg/version"
        
      
        

          
          
          
        
      
        

          1
          
          module CodebreakerRg
        
      
        

          
          
          
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe DataStorage do
        
      
        

          4
          
            let(:path) { 'database/data_test.yml' }
        
      
        

          
          
          
        
      
        

          1
          
            before do
        
      
        

          3
          
              File.new(path, 'w+')
        
      
        

          3
          
              stub_const('DataStorage::FILE_NAME', 'database/data_test.yml')
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          4
          
            after { File.delete(path) }
        
      
        

          
          
          
        
      
        

          1
          
            let(:test_object) do
        
      
        

          2
          
              {
        
      
        

          
          
                name: 'Denis',
        
      
        

          
          
                difficulty: Game::DIFFICULTIES.keys.first,
        
      
        

          
          
                all_attempts: 15,
        
      
        

          
          
                attempts_used: 15,
        
      
        

          
          
                all_hints: 2,
        
      
        

          
          
                hints_used: 0
        
      
        

          
          
              }
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #storage_exist?' do
        
      
        

          1
          
              it 'checks existence of file' do
        
      
        

          1
          
                expect(File).to exist(DataStorage::FILE_NAME)
        
      
        

          1
          
                expect(subject.storage_exist?).to eq true
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #load' do
        
      
        

          1
          
              it 'load database' do
        
      
        

          1
          
                subject.save(test_object)
        
      
        

          1
          
                expect(subject.load).to eq test_object
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #save_game_result' do
        
      
        

          1
          
              it 'saves result' do
        
      
        

          1
          
                subject.create
        
      
        

          1
          
                expect(subject).to receive(:save).with(subject.load.push(test_object))
        
      
        

          1
          
                subject.save_game_result(test_object)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe Game do
        
      
        

          1
          
            let(:lose_result) { '-+++' }
        
      
        

          2
          
            let(:start_code) { '1111' }
        
      
        

          3
          
            let(:hints_array) { [1, 2] }
        
      
        

          2
          
            let(:valid_name) { 'a' * rand(3..20) }
        
      
        

          2
          
            let(:code) { [1, 1, 1, 1] }
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #take_a_hint! method' do
        
      
        

          1
          
              it 'returnes last el of hints array' do
        
      
        

          1
          
                subject.instance_variable_set(:@hints, hints_array)
        
      
        

          1
          
                expected_value = subject.hints.last
        
      
        

          1
          
                expect(subject.take_a_hint!).to eq expected_value
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'testing #generate_secret_code method' do
        
      
        

          1
          
              it 'checks that number mathes regex template' do
        
      
        

          1
          
                secret_code = subject.send(:generate_secret_code).join
        
      
        

          1
          
                expect(secret_code).to match(/^[1-6]{#{Game::DIGITS_COUNT}}$/)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #generate method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                difficulty = Game::DIFFICULTIES[:easy]
        
      
        

          1
          
                expect(subject).to receive(:generate_secret_code).and_return(code)
        
      
        

          1
          
                subject.generate(difficulty)
        
      
        

          1
          
                expect(subject.attempts).to eq difficulty[:attempts]
        
      
        

          1
          
                expect(subject.instance_variable_get(:@difficulty)).to eq difficulty
        
      
        

          1
          
                expect(code).to include(*subject.instance_variable_get(:@hints))
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #start_process method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                process = subject.instance_variable_get(:@process)
        
      
        

          1
          
                win_code = Array.new(Game::DIGITS_COUNT, Processor::MATCHED_DIGIT_CHAR)
        
      
        

          1
          
                subject.instance_variable_set(:@code, win_code)
        
      
        

          1
          
                expect(process).to receive(:secret_code_proc).with(win_code.join, start_code)
        
      
        

          1
          
                subject.start_process(start_code)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'used #decrease_attempts! method' do
        
      
        

          1
          
              it 'decreases attempts by one when used' do
        
      
        

          1
          
                subject.instance_variable_set(:@attempts, 3)
        
      
        

          2
          
                expect { subject.decrease_attempts! }.to change(subject, :attempts).by(-1)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #hints_spent? method' do
        
      
        

          1
          
              it 'returns true' do
        
      
        

          1
          
                subject.instance_variable_set(:@hints, [])
        
      
        

          1
          
                expect(subject.hints_spent?).to be true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns false' do
        
      
        

          1
          
                subject.instance_variable_set(:@hints, [1, 2])
        
      
        

          1
          
                expect(subject.hints_spent?).to be false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #to_h method' do
        
      
        

          1
          
              it 'returns hash' do
        
      
        

          1
          
                subject.instance_variable_set(:@difficulty, Game::DIFFICULTIES[:easy])
        
      
        

          1
          
                subject.instance_variable_set(:@attempts, 2)
        
      
        

          1
          
                subject.instance_variable_set(:@hints, hints_array)
        
      
        

          1
          
                expect(subject.to_h(valid_name)).to be_an_instance_of(Hash)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe Menu do
        
      
        

          1
          
            let(:hints_array) { [1, 2] }
        
      
        

          1
          
            let(:code) { [1, 2, 3, 4] }
        
      
        

          5
          
            let(:command) { '1111' }
        
      
        

          6
          
            let(:valid_name) { 'a' * rand(3..20) }
        
      
        

          2
          
            let(:invalid_name) { 'a' * rand(0..2) }
        
      
        

          1
          
            let(:list) do
        
      
        

          2
          
              [{
        
      
        

          
          
                name: valid_name,
        
      
        

          
          
                difficulty: Game::DIFFICULTIES.keys.first.to_s,
        
      
        

          
          
                all_attempts: 15,
        
      
        

          
          
                attempts_used: 15,
        
      
        

          
          
                all_hints: 2,
        
      
        

          
          
                hints_used: 0
        
      
        

          
          
              }]
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #game_menu method' do
        
      
        

          1
          
              it 'works with choice_options' do
        
      
        

          1
          
                expect(subject.renderer).to receive(:start_message)
        
      
        

          1
          
                expect(subject).to receive(:ask)
        
      
        

          1
          
                expect(subject).to receive(:choice_menu_process).once
        
      
        

          1
          
                subject.game_menu
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #rules' do
        
      
        

          1
          
              it 'calls rules message' do
        
      
        

          1
          
                expect(subject.renderer).to receive(:rules)
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:rules)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #start method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                expect(subject).to receive(:registrate_user)
        
      
        

          1
          
                expect(subject).to receive(:level_choice)
        
      
        

          1
          
                expect(subject).to receive(:game_process)
        
      
        

          1
          
                subject.send(:start)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #stats method' do
        
      
        

          1
          
              it 'returns stats' do
        
      
        

          1
          
                statistics = subject.instance_variable_get(:@statistics)
        
      
        

          2
          
                expect(subject.storage).to receive(:load) { list }
        
      
        

          1
          
                expect(statistics).to receive(:stats)
        
      
        

          1
          
                expect(subject).to receive(:render_stats)
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:stats)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #save_result method' do
        
      
        

          1
          
              it 'expexts the choice of user' do
        
      
        

          1
          
                expect(subject).to receive(:ask).with(:save_results_message).and_return(Menu::CHOOSE_COMMANDS[:yes])
        
      
        

          1
          
                subject.instance_variable_set(:@name, valid_name)
        
      
        

          2
          
                expect(subject.game).to receive(:to_h).with(valid_name) { {} }
        
      
        

          1
          
                expect(subject.storage).to receive(:save_game_result).with({})
        
      
        

          1
          
                subject.send(:save_result)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #registration method' do
        
      
        

          1
          
              it 'set name' do
        
      
        

          1
          
                expect(subject).to receive(:ask).with(:registration).and_return(valid_name)
        
      
        

          1
          
                subject.send(:registrate_user)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #name_valid? method' do
        
      
        

          1
          
              it 'returns true' do
        
      
        

          1
          
                expect(subject.send(:name_valid?, valid_name)).to be true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns false' do
        
      
        

          1
          
                expect(subject.send(:name_valid?, invalid_name)).to be false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #level_choice method' do
        
      
        

          1
          
              it 'returns #generate_game' do
        
      
        

          1
          
                level = Game::DIFFICULTIES.keys.first
        
      
        

          2
          
                expect(subject).to receive(:ask).with(:hard_level, levels: Game::DIFFICULTIES.keys.join(' | ')) { level }
        
      
        

          1
          
                expect(subject).to receive(:generate_game).with(Game::DIFFICULTIES[level.to_sym])
        
      
        

          1
          
                subject.send(:level_choice)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #game_menu' do
        
      
        

          1
          
                exit = Menu::COMMANDS[:exit]
        
      
        

          2
          
                expect(subject).to receive(:ask).with(:hard_level, levels: Game::DIFFICULTIES.keys.join(' | ')) { exit }
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:level_choice)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #command_error' do
        
      
        

          2
          
                expect(subject).to receive(:ask).with(:hard_level, levels: Game::DIFFICULTIES.keys.join(' | ')) { command }
        
      
        

          1
          
                expect(subject.renderer).to receive(:command_error)
        
      
        

          1
          
                allow(subject).to receive(:loop).and_yield
        
      
        

          1
          
                subject.send(:level_choice)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #choice_code_process method' do
        
      
        

          1
          
              it 'returns #take_a_hint!' do
        
      
        

          1
          
                subject.instance_variable_set(:@guess, Menu::HINT_COMMAND)
        
      
        

          1
          
                expect(subject).to receive(:hint_process)
        
      
        

          1
          
                subject.send(:choice_code_process)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #game_menu' do
        
      
        

          1
          
                subject.instance_variable_set(:@guess, Menu::COMMANDS[:exit])
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:choice_code_process)
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #handle_command' do
        
      
        

          1
          
                subject.instance_variable_set(:@guess, command)
        
      
        

          1
          
                expect(subject).to receive(:handle_command)
        
      
        

          1
          
                subject.send(:choice_code_process)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #render_stats' do
        
      
        

          1
          
              it 'returns list' do
        
      
        

          1
          
                expect(list).to receive(:each_with_index)
        
      
        

          1
          
                subject.send(:render_stats, list)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #choice_menu_process' do
        
      
        

          1
          
              %i[rules stats start].each do |command|
        
      
        

          3
          
                it "returns ##{command}" do
        
      
        

          3
          
                  expect(subject).to receive(command)
        
      
        

          3
          
                  subject.send(:choice_menu_process, Menu::COMMANDS[command])
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #exit_from_game' do
        
      
        

          1
          
                expect(subject).to receive(:exit_from_game)
        
      
        

          1
          
                subject.send(:choice_menu_process, Menu::COMMANDS[:exit])
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns #command_error' do
        
      
        

          1
          
                expect(subject.renderer).to receive(:command_error)
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:choice_menu_process, command)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #exit_from_game method' do
        
      
        

          1
          
              it 'returns message' do
        
      
        

          1
          
                expect(subject.renderer).to receive(:goodbye_message)
        
      
        

          1
          
                expect(subject).to receive(:exit)
        
      
        

          1
          
                subject.send(:exit_from_game)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #hint_process method' do
        
      
        

          1
          
              it 'returns no_hints_message?' do
        
      
        

          1
          
                subject.game.instance_variable_set(:@hints, [])
        
      
        

          1
          
                expect(subject.renderer).to receive(:no_hints_message?)
        
      
        

          1
          
                subject.send(:hint_process)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #generate_game method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                difficulty = Game::DIFFICULTIES[:easy]
        
      
        

          1
          
                expect(subject.game).to receive(:generate).with(difficulty)
        
      
        

          1
          
                expect(subject.renderer).to receive(:message).with(:difficulty,
        
      
        

          
          
                                                                   hints: difficulty[:hints],
        
      
        

          
          
                                                                   attempts: difficulty[:attempts])
        
      
        

          1
          
                subject.send(:generate_game, difficulty)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #handle_lose method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                expect(subject.renderer).to receive(:lost_game_message).with(subject.game.code)
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:handle_lose)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #handle_win method' do
        
      
        

          1
          
              it do
        
      
        

          1
          
                expect(subject.renderer).to receive(:win_game_message)
        
      
        

          1
          
                expect(subject).to receive(:save_result)
        
      
        

          1
          
                expect(subject).to receive(:game_menu)
        
      
        

          1
          
                subject.send(:handle_win)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #game_process method' do
        
      
        

          1
          
              it 'returns #handle_win' do
        
      
        

          1
          
                subject.game.instance_variable_set(:@attempts, Game::DIFFICULTIES[:easy][:attempts])
        
      
        

          2
          
                expect(subject).to receive(:ask) { command }
        
      
        

          2
          
                expect(subject.game).to receive(:win?).with(command) { true }
        
      
        

          1
          
                expect(subject).to receive(:handle_win)
        
      
        

          1
          
                subject.send(:game_process)
        
      
        

          
          
              end
        
      
        

          1
          
              it 'retuns #handle_lose' do
        
      
        

          1
          
                subject.game.instance_variable_set(:@attempts, 0)
        
      
        

          1
          
                expect(subject).to receive(:handle_lose)
        
      
        

          1
          
                subject.send(:game_process)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when testing #ask method' do
        
      
        

          1
          
              it 'retuns msg' do
        
      
        

          1
          
                phrase_key = :rules
        
      
        

          1
          
                expect(subject.renderer).to receive(:message).with(phrase_key, {})
        
      
        

          1
          
                allow(subject).to receive(:gets).and_return('')
        
      
        

          1
          
                subject.send(:ask, phrase_key)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe Processor do
        
      
        

          1
          
            context 'when testing #secret_code_proc method' do
        
      
        

          
          
              [
        
      
        

          
          
                ['1234', '1234', '++++'], ['1234', '4321', '----'], ['1231', '1234', '+++'],
        
      
        

          
          
                ['1324', '1234', '++--'], ['1111', '1321', '++'], ['4441', '2233', ''],
        
      
        

          
          
                ['1234', '1111', '+'], ['2552', '1221', '--'], ['1234', '2332', '+-'],
        
      
        

          
          
                ['1234', '5561', '-'], ['1234', '1342', '+---'], ['3211', '1561', '+-'],
        
      
        

          
          
                ['1134', '1155', '++'], ['1134', '5115', '+-'], ['1134', '5511', '--'],
        
      
        

          
          
                ['1134', '1115', '++'], ['1134', '5111', '+-'], ['1234', '1555', '+'],
        
      
        

          
          
                ['1234', '2555', '-'], ['1234', '5224', '++'], ['1234', '5154', '+-'],
        
      
        

          
          
                ['1234', '2545', '--'], ['1234', '5234', '+++'], ['1234', '5134', '++-'],
        
      
        

          
          
                ['1234', '5124', '+--'], ['1234', '5115', '-'], ['1666', '6661', '++--'],
        
      
        

          
          
                ['1234', '1234', '++++'], ['5143', '4153', '++--'], ['5523', '5155', '+-'],
        
      
        

          
          
                ['6235', '2365', '+---'], ['1234', '4321', '----'], ['1234', '1235', '+++'],
        
      
        

          
          
                ['1234', '6254', '++'], ['1234', '5635', '+'], ['1234', '4326', '---'],
        
      
        

          
          
                ['1234', '3525', '--'], ['1234', '2552', '-'], ['1234', '4255', '+-'],
        
      
        

          
          
                ['1234', '1524', '++-'], ['1234', '5431', '+--'], ['1234', '6666', ''],
        
      
        

          
          
                ['1115', '1231', '+-'], ['1231', '1111', '++'],
        
      
        

          
          
                ['1111', '1111', '++++'], ['1111', '1115', '+++'], ['1111', '1155', '++'],
        
      
        

          
          
                ['1111', '1555', '+'], ['1111', '5555', ''], ['1221', '2112', '----'],
        
      
        

          
          
                ['1221', '2114', '---'], ['1221', '2155', '--'], ['1221', '2555', '-'],
        
      
        

          
          
                ['2245', '2254', '++--'], ['2245', '2253', '++-'], ['2245', '2435', '++-'],
        
      
        

          
          
                ['2245', '2533', '+-'], ['1234', '4321', '----'], ['3331', '3332', '+++'],
        
      
        

          
          
                ['1113', '1112', '+++'], ['1312', '1212', '+++'], ['1234', '1266', '++'],
        
      
        

          
          
                ['1234', '6634', '++'], ['1234', '1654', '++'], ['1234', '1555', '+'],
        
      
        

          
          
                ['1234', '4321', '----'], ['5432', '2345', '----'], ['1234', '2143', '----'],
        
      
        

          
          
                ['1221', '2112', '----'], ['5432', '2541', '---'], ['1145', '6514', '---'],
        
      
        

          
          
                ['1244', '4156', '--'], ['1221', '2332', '--'], ['2244', '4526', '--'],
        
      
        

          
          
                ['5556', '1115', '-'], ['1234', '6653', '-'], ['3331', '1253', '--'],
        
      
        

          
          
                ['2345', '4542', '+--'], ['1243', '1234', '++--'], ['4111', '4444', '+'],
        
      
        

          
          
                ['1532', '5132', '++--'], ['3444', '4334', '+--'], ['1113', '2155', '+'],
        
      
        

          
          
                ['2245', '4125', '+--'], ['4611', '1466', '---'], ['5451', '4445', '+-'],
        
      
        

          
          
                ['6541', '6541', '++++'], ['1234', '5612', '--'], ['5566', '5600', '+-'],
        
      
        

          
          
                ['6235', '2365', '+---'], ['1234', '4321', '----'], ['1234', '1235', '+++'],
        
      
        

          
          
                ['1234', '6254', '++'], ['1234', '5635', '+'], ['1234', '4326', '---'],
        
      
        

          
          
                ['1234', '3525', '--'], ['1234', '2552', '-'], ['1234', '4255', '+-'],
        
      
        

          
          
                ['1234', '1524', '++-'], ['1234', '5431', '+--'], ['1234', '6666', ''],
        
      
        

          
          
                ['1115', '1231', '+-'], ['1221', '2112', '----'], ['1231', '1111', '++']
        
      
        

          1
          
              ].each do |value|
        
      
        

          104
          
                it "tests that #{value.first} equals to #{value.last}" do
        
      
        

          104
          
                  expect(subject.secret_code_proc(value[1], value[0])).to eq value.last
        
      
        

          
          
                end
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe Renderer do
        
      
        

          3
          
            let(:code) { '1111' }
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #message method' do
        
      
        

          1
          
              it 'return puts I18n' do
        
      
        

          1
          
                msg = :start_message
        
      
        

          1
          
                expect(I18n).to receive(:t).with(msg, {})
        
      
        

          1
          
                subject.message(msg)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #start_message method' do
        
      
        

          1
          
              it 'return start_message' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:start_message)
        
      
        

          1
          
                subject.start_message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #rules method' do
        
      
        

          1
          
              it 'return rules' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:rules)
        
      
        

          1
          
                subject.rules
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #goodbye_message method' do
        
      
        

          1
          
              it 'return goodbye_message' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:goodbye_message)
        
      
        

          1
          
                subject.goodbye_message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #save_results_message method' do
        
      
        

          1
          
              it 'return save_results_message' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:save_results_message)
        
      
        

          1
          
                subject.save_results_message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #win_game_message method' do
        
      
        

          1
          
              it 'return win_game_message' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:win_game_message)
        
      
        

          1
          
                subject.win_game_message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #round_message method' do
        
      
        

          1
          
              it 'return promt_to_enter_secret_code_hint_exit' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:round_message)
        
      
        

          1
          
                subject.round_message
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #lost_game_message method' do
        
      
        

          1
          
              it 'return lost_game_message' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:lost_game_message, code: code)
        
      
        

          1
          
                subject.lost_game_message(code)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #no_hints_message? method' do
        
      
        

          1
          
              it 'return no_hints_message?' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:have_no_hints_message)
        
      
        

          1
          
                subject.no_hints_message?
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #print_hint_number method' do
        
      
        

          1
          
              it 'return print_hint_number' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:print_hint_number, code: code)
        
      
        

          1
          
                subject.print_hint_number(code)
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #registration_name_emptyness_error method' do
        
      
        

          1
          
              it 'return registration_name_emptyness_error' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:registration_name_emptyness_error)
        
      
        

          1
          
                subject.registration_name_emptyness_error
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #registration_name_length_error method' do
        
      
        

          1
          
              it 'return registration_name_length_error' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:registration_name_length_error)
        
      
        

          1
          
                subject.registration_name_length_error
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #command_error method' do
        
      
        

          1
          
              it 'return command_error' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:command_error)
        
      
        

          1
          
                subject.command_error
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #command_length_error method' do
        
      
        

          1
          
              it 'return command_length_error' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:command_length_error)
        
      
        

          1
          
                subject.command_length_error
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'when #command_int_error method' do
        
      
        

          1
          
              it 'return command_int_error' do
        
      
        

          1
          
                expect(subject).to receive(:message).with(:command_int_error)
        
      
        

          1
          
                subject.command_int_error
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe Statistics do
        
      
        

          1
          
            context 'when testing #stats method' do
        
      
        

          1
          
              let(:player_1) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.first.to_s,
        
      
        

          
          
                  all_attempts: 15,
        
      
        

          
          
                  attempts_used: 10,
        
      
        

          
          
                  all_hints: 2,
        
      
        

          
          
                  hints_used: 0
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          1
          
              let(:player_2) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.first.to_s,
        
      
        

          
          
                  all_attempts: 15,
        
      
        

          
          
                  attempts_used: 15,
        
      
        

          
          
                  all_hints: 2,
        
      
        

          
          
                  hints_used: 1
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          1
          
              let(:player_3) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.first.to_s,
        
      
        

          
          
                  all_attempts: 15,
        
      
        

          
          
                  attempts_used: 5,
        
      
        

          
          
                  all_hints: 2,
        
      
        

          
          
                  hints_used: 0
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              let(:player_4) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.last.to_s,
        
      
        

          
          
                  all_attempts: 5,
        
      
        

          
          
                  attempts_used: 3,
        
      
        

          
          
                  all_hints: 1,
        
      
        

          
          
                  hints_used: 0
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              let(:player_5) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.last.to_s,
        
      
        

          
          
                  all_attempts: 5,
        
      
        

          
          
                  attempts_used: 1,
        
      
        

          
          
                  all_hints: 1,
        
      
        

          
          
                  hints_used: 1
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              let(:player_6) do
        
      
        

          1
          
                {
        
      
        

          
          
                  name: '',
        
      
        

          
          
                  difficulty: Game::DIFFICULTIES.keys.last.to_s,
        
      
        

          
          
                  all_attempts: 5,
        
      
        

          
          
                  attempts_used: 3,
        
      
        

          
          
                  all_hints: 1,
        
      
        

          
          
                  hints_used: 1
        
      
        

          
          
                }
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns stats' do
        
      
        

          1
          
                list = [player_1, player_2, player_3, player_4, player_5, player_6]
        
      
        

          1
          
                expected_value = [player_6, player_4, player_5, player_2, player_1, player_3]
        
      
        

          1
          
                expect(subject.stats(list)).to eq expected_value
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          
          
          # frozen_string_literal: true
        
      
        

          
          
          
        
      
        

          1
          
          require 'spec_helper'
        
      
        

          
          
          
        
      
        

          1
          
          class DummyClass
        
      
        

          1
          
            include Validator
        
      
        

          
          
          end
        
      
        

          
          
          
        
      
        

          1
          
          RSpec.describe DummyClass do
        
      
        

          2
          
            let(:invalid_range) { (7..9) }
        
      
        

          3
          
            let(:valid_name) { 'a' * rand(3..20) }
        
      
        

          3
          
            let(:empty_name) { '' }
        
      
        

          6
          
            let(:code_valid) { Array.new(Game::DIGITS_COUNT) { rand(Game::RANGE) } }
        
      
        

          6
          
            let(:code_unvalid) { Array.new(Game::DIGITS_COUNT) { rand(invalid_range) } }
        
      
        

          
          
          
        
      
        

          1
          
            context 'testing #check_emptyness method' do
        
      
        

          1
          
              it 'returns true when name not empty' do
        
      
        

          1
          
                expect(subject.check_emptyness(valid_name)).to be false
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns false' do
        
      
        

          1
          
                expect(subject.check_emptyness(empty_name)).to be true
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'testing #check_name_length method' do
        
      
        

          1
          
              it 'returns true' do
        
      
        

          1
          
                expect(subject.check_length(valid_name, Menu::MIN_SIZE_VALUE, Menu::MAX_SIZE_VALUE)).to be true
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'returns false' do
        
      
        

          1
          
                expect(subject.check_length(empty_name, Menu::MIN_SIZE_VALUE, Menu::MAX_SIZE_VALUE)).to be false
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          
        
      
        

          1
          
            context 'testing #check_command_range method' do
        
      
        

          1
          
              it 'return true' do
        
      
        

          1
          
                expect(subject.check_command_range(code_valid.join)).to be_zero
        
      
        

          
          
              end
        
      
        

          
          
          
        
      
        

          1
          
              it 'return false' do
        
      
        

          1
          
                expect(subject.check_command_range(code_unvalid.join)).to be nil
        
      
        

          
          
              end
        
      
        

          
          
            end
        
      
        

          
          
          end
        
      
    
  

    

      
        

          1
          
          RSpec.describe CodebreakerRg do
        
      
        

          1
          
            it "has a version number" do
        
      
        

          1
          
              expect(CodebreakerRg::VERSION).not_to be nil
        
      
        

          
          
            end
        
      
        

          
          
          end