spec_selector 0.1.6 → 0.1.9

data/spec/spec_selector_util/ui_spec.rb

@@ -1,459 +0,0 @@
-# frozen_string_literal: true
-
-describe 'SpecSelectorUtil::UI' do
-  include_context 'shared'
-
-  let(:spec_selector) { SpecSelector.new(StringIO.new) }
-  let(:output) { spec_selector.ivar(:@output).string }
-
-  describe '#exit_only', break_loop: true do
-    before { allow(spec_selector).to receive(:quit) }
-
-    it 'prints instructions to quit' do
-      spec_selector.exit_only
-      expect(output).to match(/Press Q to quit/)
-    end
-
-    context 'when user enters "q"' do
-      before { $stdin = StringIO.new('q') }
-
-      it 'calls #quit' do
-        spec_selector.exit_only
-        expect(spec_selector).to have_received(:quit)
-      end
-    end
-
-    context 'when user does not enter "q"' do
-      it 'does not call #quit' do
-        spec_selector.exit_only
-        expect(spec_selector).not_to have_received(:quit)
-      end
-    end
-  end
-
-  describe '#selector' do
-    before do
-      ivars_set({ :@active_map => mixed_map, :@example_count => 10 })
-      allow_methods(:display_list, :navigate)
-      spec_selector.selector
-    end
-
-    it 'sets default value of @list to @active_map[:top_level]' do
-      expect(spec_selector.ivar(:@list)).to eq(mixed_map[:top_level])
-    end
-
-    it 'sets default value of @selected to @list.first' do
-      expect(ivar(:@selected)).to eq(ivar(:@list).first)
-    end
-
-    it 'calls #display_list' do
-      expect(spec_selector).to have_received(:display_list)
-    end
-
-    it 'calls #navigate' do
-      expect(spec_selector).to have_received(:navigate)
-    end
-  end
-
-  describe '#navigate', break_loop: true do
-    context 'when @selected is included in @list' do
-      it 'sets @selector_index to index position of @selected in @list' do
-        ivars_set(:@selected => fail_group, :@list => mixed_map[:top_level])
-        spec_selector.navigate
-        expect(ivar(:@selector_index)).to eq(1)
-      end
-    end
-
-    context 'when @selected is not included in @list' do
-      it 'sets @selected to zero' do
-        ivars_set(:@selected => failed_example, :@list => mixed_map[:top_level])
-        spec_selector.navigate
-        expect(ivar(:selector_index)).to eq(0)
-      end
-    end
-
-    it 'calls #bind_input continuously' do
-      allow_methods(:bind_input)
-      spec_selector.navigate
-      expect(spec_selector).to have_received(:bind_input).at_least(:twice)
-    end
-  end
-
-  describe '#bind_input' do
-    it 'captures user input' do
-      binding = nil
-      trace = TracePoint.new(:call) { |t| binding = t.binding }
-      trace.enable(target: spec_selector.method(:bind_input))
-      allow_methods(:tree_nav_keys)
-      allow(spec_selector).to receive(:user_input).and_return("\r")
-      spec_selector.bind_input
-      expect(binding.eval('input')).to be("\r")
-    end
-
-    context 'when DIRECTION_KEYS includes input string' do
-      it 'passes input string to #direction_keys' do
-        allow(spec_selector).to receive(:user_input).and_return("\e[A")
-        allow(spec_selector).to receive(:direction_keys)
-        spec_selector.bind_input
-        expect(spec_selector).to have_received(:direction_keys).with("\e[A")
-      end
-    end
-
-    context 'when TREE_NAVIGATION_KEYS includes input string' do
-      it 'passes input string to #tree_nav_keys' do
-        allow(spec_selector).to receive(:user_input).and_return("\x7F")
-        allow(spec_selector).to receive(:tree_nav_keys)
-        spec_selector.bind_input
-        expect(spec_selector).to have_received(:tree_nav_keys).with("\x7F")
-      end
-    end
-
-    context 'when input string matches pattern in OPTION_KEYS' do
-      it 'passes input string to #option_keys' do
-        allow(spec_selector).to receive(:user_input).and_return('q')
-        allow(spec_selector).to receive(:option_keys)
-        spec_selector.bind_input
-        expect(spec_selector).to have_received(:option_keys).with('q')
-      end
-    end
-  end
-
-  describe '#quit' do
-    before do
-      allow_methods(:clear_frame, :reveal_cursor, :exit)
-      spec_selector.quit
-    end
-
-    it 'calls #clear_frame' do
-      expect(spec_selector).to have_received(:clear_frame)
-    end
-
-    it 'calls #reveal_cursor' do
-      expect(spec_selector).to have_received(:reveal_cursor)
-    end
-
-    it 'exits program' do
-      expect(spec_selector).to have_received(:exit)
-    end
-  end
-
-  describe '#top_level_list' do
-    before do
-      ivars_set(:@active_map => mixed_map, :@list => [passing_example])
-      ivars_set(:@selected => passing_example, :@example_display => true)
-      allow_methods(:display_list)
-      spec_selector.top_level_list
-    end
-
-    it 'sets @example_display to false' do
-      expect(ivar(:@example_display)).to be false
-    end
-
-    it 'sets @list to @active_map[:top_level]' do
-      expect(ivar(:@list)).to eq(mixed_map[:top_level])
-    end
-
-    it 'calls #display_list' do
-      expect(spec_selector).to have_received(:display_list)
-    end
-  end
-
-  describe '#select_item' do
-    context 'when @example_display is true' do
-      it 'returns immediately' do
-        spec_selector.ivar_set(:@example_display, true)
-        allow(spec_selector).to receive(:example?)
-        spec_selector.select_item
-        expect(spec_selector).not_to have_received(:example?)
-      end
-    end
-
-    context 'when @example_display is false' do
-      it 'does not return immediately' do
-        ivars_set(:@selected => fail_group, :@example_display => false)
-        allow_methods(:display_list, :example?, :set_selected)
-        spec_selector.select_item
-        expect(spec_selector).to have_received(:example?)
-      end
-    end
-
-    context 'when @selected is an example' do
-      it 'calls #display_example' do
-        ivars_set(:@selected => failed_example, :@list => [failed_example])
-        allow_methods(:display_example, :selector)
-        spec_selector.select_item
-        expect(spec_selector).to have_received(:display_example)
-      end
-    end
-
-    context 'when @selected is not an example' do
-      before do
-        ivars_set(:@active_map => mixed_map, :@selected => pass_group)
-        allow_methods(:display_list)
-        spec_selector.select_item
-      end
-
-      it 'sets @list subgroups and/or examples that belong to @selected' do
-        expect(ivar(:@list)).to eq(pass_group.examples)
-      end
-
-      it 'calls #display_list' do
-        expect(spec_selector).to have_received(:display_list)
-      end
-    end
-  end
-
-  describe '#top_fail' do
-    before { allow(spec_selector).to receive(:display_example) }
-
-    context 'when there are no failed examples' do
-      it 'returns immediately' do
-        spec_selector.top_fail
-        expect(spec_selector).not_to have_received(:display_example)
-      end
-    end
-
-    context 'when there are failed examples' do
-      before do
-        spec_selector.ivar_set(:@failed, fail_group.examples)
-        spec_selector.top_fail
-      end
-
-      it 'sets @selected to the top failed example' do
-        expect(ivar(:@selected)).to eq(ivar(:@failed).first)
-      end
-
-      it 'calls #display_example' do
-        expect(spec_selector).to have_received(:display_example)
-      end
-    end
-  end
-
-  describe '#back' do
-    before { allow_methods(:parent_list, :display_list) }
-
-    context 'when top level list is currently displayed' do
-      it 'returns immediately' do
-        spec_selector.back
-        expect(spec_selector).not_to have_received(:parent_list)
-        expect(spec_selector).not_to have_received(:display_list)
-      end
-    end
-
-    context 'when top level list is not currently displayed' do
-      before do
-        spec_selector.ivar_set(:@list, mixed_map[fail_group.metadata[:block]])
-        spec_selector.back
-      end
-
-      it 'calls #parent_list' do
-        expect(spec_selector).to have_received(:parent_list)
-      end
-
-      it 'calls #selector' do
-        expect(spec_selector).to have_received(:display_list)
-      end
-    end
-  end
-
-  describe '#parent_list' do
-    context 'when @example_display is true' do
-      before do
-        attrs = {
-          :@active_map => mixed_map,
-          :@selected => fail_group.examples.first,
-          :@example_display => true
-        }
-        ivars_set(attrs)
-        allow(ivar(:@selected)).to receive(:example_group) { fail_group }
-        spec_selector.parent_list
-      end
-
-      it 'sets @example_display to false' do
-        expect(ivar(:@example_display)).to be false
-      end
-
-      it 'sets @list to example group that includes @selected' do
-        expect(ivar(:@list)).to eq(fail_group.examples)
-      end
-    end
-
-    context 'when @example_display is already false' do
-      before do
-        ivars_set(:@selected => fail_subgroup, :@active_map => deep_map)
-        ivars_set(:@groups => {
-                    fail_parent_group.metadata[:block] => fail_parent_group
-                  })
-        spec_selector.parent_list
-      end
-
-      it 'sets @list to group that includes parent group' do
-        expect(ivar(:@list)).to eq(deep_map[:top_level])
-      end
-
-      it 'sets @selected to parent group' do
-        expect(ivar(:@selected)).to eq(fail_parent_group)
-      end
-    end
-  end
-
-  describe '#direction_keys' do
-    let(:list) do
-      [fail_group, pass_group, fail_group, fail_group, fail_group]
-    end
-
-    before do
-      ivars_set(:@list => list, :@selector_index => 2)
-      allow_methods(:display_list, :display_example)
-    end
-
-    context 'when input string is "\e[A"' do
-      it 'decrements @selector_index' do
-        spec_selector.direction_keys("\e[A")
-        expect(ivar(:@selector_index)).to eq(1)
-      end
-    end
-
-    context 'when input string is not "\e[A"' do
-      # the only possible value of input string in this case is "\e[B"
-      it 'increments @selector_index' do
-        spec_selector.direction_keys("\e[B")
-        expect(ivar(:@selector_index)).to eq(3)
-      end
-    end
-
-    it 'sets @selected to @list element at @selector_index' do
-      spec_selector.direction_keys("\e[A")
-      expect(ivar(:@selected)).to eq(pass_group)
-    end
-
-    context 'when @example_display is true' do
-      it 'calls #display_example' do
-        ivar_set(:@example_display, true)
-        spec_selector.direction_keys("\e[A")
-        expect(spec_selector).to have_received(:display_example)
-      end
-    end
-
-    context 'when @example_display is false' do
-      it 'calls #display_list' do
-        ivar_set(:@example_display, false)
-        spec_selector.direction_keys("\e[A")
-        expect(spec_selector).to have_received(:display_list)
-      end
-    end
-  end
-
-  describe '#tree_nav_keys' do
-    before do
-      allow_methods(:select_item, :back, :top_level_list)
-    end
-
-    context 'when input string is "\r"' do
-      it 'calls #select_item' do
-        spec_selector.tree_nav_keys("\r")
-        expect(spec_selector).to have_received(:select_item)
-      end
-    end
-
-    context 'when input string is "\x7F"' do
-      it 'calls #back' do
-        spec_selector.tree_nav_keys("\x7F")
-        expect(spec_selector).to have_received(:back)
-      end
-    end
-
-    context 'when input string is "\e"' do
-      it 'calls #top_level_list' do
-        spec_selector.tree_nav_keys("\e")
-        expect(spec_selector).to have_received(:top_level_list)
-      end
-    end
-  end
-
-  describe '#option_keys' do
-    before do
-      allow_methods(:top_fail, :toggle_passing, :quit)
-    end
-
-    context 'when input string matches /^ $/' do
-      it 'calls #top_fail' do
-        spec_selector.option_keys(' ')
-        expect(spec_selector).to have_received(:top_fail)
-      end
-    end
-
-    context 'when input string matches /^p$/i' do
-      it 'calls #toggle_passing' do
-        spec_selector.option_keys('p')
-        expect(spec_selector).to have_received(:toggle_passing)
-      end
-    end
-
-    context 'when input string matches /^q$/i' do
-      it 'calls #quit' do
-        spec_selector.option_keys('q')
-        expect(spec_selector).to have_received(:quit)
-      end
-    end
-
-    context 'when input string matches /^i$/i' do
-      context 'when instruction page is not open' do
-        it 'calls #view_instructions_page' do
-          allow(spec_selector).to receive(:view_instructions_page)
-          spec_selector.option_keys('i')
-          expect(spec_selector).to have_received(:view_instructions_page)
-        end
-      end
-
-      context 'when instruction page is already open' do
-        it 'calls #exit_instruction_page_only' do
-          spec_selector.ivar_set(:@instructions, true)
-          allow(spec_selector).to receive(:exit_instruction_page_only)
-          spec_selector.option_keys('i')
-          expect(spec_selector).to have_received(:exit_instruction_page_only)
-        end
-      end
-    end
-  end
-
-  describe '#user_input' do
-    it 'initially captures one byte of keyboard input' do
-      binding = nil
-      trace = TracePoint.new(:call) { |t| binding = t.binding }
-      trace.enable(target: spec_selector.method(:user_input))
-      allow($stdin).to receive(:getch).and_return("\x7F")
-      spec_selector.user_input
-      expect(binding.eval('input')).to eq("\x7F")
-    end
-
-    context 'when there is no further readable data in buffer' do
-      before do
-        stdin, user = IO.pipe
-        user.print "\e"
-        allow($stdin).to receive(:getch).and_return(stdin.getc)
-        allow(IO).to receive(:select).and_return(more_data?(stdin))
-      end
-
-      it 'returns input string' do
-        expect(spec_selector.user_input).to eq("\e")
-      end
-    end
-
-    context 'when input buffer still contains readable data' do
-      # user is assumed to have pressed a directional key
-      before do
-        stdin, user = IO.pipe
-        user.print "\e[A"
-        allow($stdin).to receive(:getch).and_return(stdin.getc)
-        allow(IO).to receive(:select).and_return(more_data?(stdin))
-        last_two_bytes = stdin.read_nonblock(2)
-        allow($stdin).to receive(:read_nonblock).with(2).and_return(last_two_bytes)
-      end
-
-      it 'appends the next two bytes to the input string' do
-        expect(spec_selector.user_input).to eq("\e[A")
-      end
-    end
-  end
-end