spec_selector 0.1.6 → 0.1.9

data/spec/spec_selector_util/data_map_spec.rb

@@ -1,98 +0,0 @@
-describe 'SpecSelectorUtil::DataMap' do
-  subject(:spec_selector) { SpecSelector.new(StringIO.new) }
-
-  let(:example_group) { build(:example_group) }
-
-  let(:map) { spec_selector.ivar(:@map) }
-
-  describe '#top_level_push' do
-    before { spec_selector.top_level_push(example_group) }
-
-    it 'lazy-initializes @map[:top_level] to an array' do
-      expect(map[:top_level]).to be_an(Array)
-    end
-
-    it 'stores example group in @map[:top_level]' do
-      expect(map[:top_level]).to include(example_group)
-    end
-  end
-
-  # takes takes the metadata hash from an example group or from an
-  # example as its argument
-  describe '#parent_data' do
-    context 'when metadata hash is from an example' do
-      let(:example_metadata) { { example_group: example_group.metadata } }
-      let(:example) { instance_double('Example', metadata: example_metadata) }
-
-      it 'returns metadata of the example group to which the example belongs' do
-        expect(spec_selector.parent_data(example_metadata))
-          .to eq(example_group.metadata)
-      end
-    end
-
-    context 'when metadata hash is from an example group' do
-      context 'when the example group has a parent group' do
-        let(:example_group) do
-          instance_double('ExampleGroup', metadata: {
-                            parent_example_group: { block: :parent_example_block }
-                          })
-        end
-
-        it 'returns the parent group metadata' do
-          expect(spec_selector.parent_data(example_group.metadata))
-            .to eq(example_group.metadata[:parent_example_group])
-        end
-      end
-
-      context 'when the example group does not have a parent group' do
-        it 'returns nil' do
-          expect(spec_selector.parent_data(example_group.metadata)).to be_nil
-        end
-      end
-    end
-  end
-
-  describe '#map_group' do
-    let(:map) { spec_selector.ivar(:@map) }
-
-    before { spec_selector.map_group(example_group) }
-
-    context 'when example group has parent group' do
-      let(:example_group) do
-        instance_double('ExampleGroup', metadata: {
-                          parent_example_group: { block: :parent_block }
-                        })
-      end
-
-      it 'stores the parent block as a key in @map initialized to an array' do
-        expect(map[:parent_block]).to be_an(Array)
-      end
-
-      it 'stores the example group in the parent block array' do
-        expect(map[:parent_block]).to include(example_group)
-      end
-    end
-
-    context 'when example group does not have parent group' do
-      it 'passes the example group to #top_level_push' do
-        expect(map[:top_level]).to include(example_group)
-      end
-    end
-  end
-
-  describe '#map_example' do
-    let(:example) do
-      build(:example, example_group: example_group)
-    end
-
-    before do
-      map[example_group.metadata[:block]] = []
-      example_group.examples << example
-      spec_selector.map_example(example)
-    end
-
-    it 'appends the example to its example group in @map' do
-      expect(map[example_group.metadata[:block]]).to include(example)
-    end
-  end
-end

data/spec/spec_selector_util/data_presentation_spec.rb

@@ -1,314 +0,0 @@
-# frozen_string_literal: true
-
-describe 'SpecSelectorUtil::DataPresentation' do
-  include_context 'shared'
-
-  let(:spec_selector) { SpecSelector.new(StringIO.new) }
-  let(:output) { spec_selector.ivar(:@output).string }
-  let(:notification) { build(:summary_notification) }
-
-  before do
-    allow(spec_selector).to receive(:exit_only)
-  end
-
-  describe '#test_data_summary' do
-    before do
-      allow_methods(:status_count, :print_summary)
-      spec_selector.test_data_summary
-    end
-
-    it 'calls #status_count' do
-      expect(spec_selector).to have_received(:status_count)
-    end
-
-    it 'calls #print_summary' do
-      expect(spec_selector).to have_received(:print_summary)
-    end
-  end
-
-  describe '#print_errors' do
-    let(:notification) do
-      build(:summary_notification, errors_outside_of_examples_count: 2)
-    end
-
-    before do
-      spec_selector.ivar(:@messages) << 'some message'
-      spec_selector.print_errors(notification)
-    end
-
-    it 'calls #print_messages' do
-      expect(output).to match(/[some message]/)
-    end
-
-    it 'passes notification to #errors_summary' do
-      expect(output).to match(/[2 errors occurred outside of examples]/)
-    end
-  end
-
-  describe '#print_messages' do
-    before do
-      spec_selector.ivar(:@messages) << 'example message one'
-      spec_selector.ivar(:@messages) << 'example message two'
-    end
-
-    it 'prints each message' do
-      spec_selector.print_messages
-      expect(output).to match(/example message one/)
-      expect(output).to match(/example message two/)
-    end
-  end
-
-  describe '#examples_summary' do
-    before do
-      allow(spec_selector).to receive(:status_summary).with(notification)
-      allow(spec_selector).to receive(:selector)
-      spec_selector.ivar(:@map)[:top_level] = :top_level
-      spec_selector.examples_summary(notification)
-    end
-
-    it 'assigns the summary notification to an instance variable' do
-      summary_notification = spec_selector.ivar(:@summary_notification)
-      expect(summary_notification).to eq(notification)
-    end
-
-    it 'passes the notification object to #status_summary' do
-      expect(spec_selector).to have_received(:status_summary).with(notification)
-    end
-
-    it 'sets the value of @list to @map[:top_level]' do
-      expect(spec_selector.ivar(:@list)).to eq(:top_level)
-    end
-
-    it 'calls #selector' do
-      expect(spec_selector).to have_received(:selector)
-    end
-  end
-
-  describe '#errors_summary' do
-    it 'prints text indicating number of errors outside examples' do
-      allow(notification).to receive(:errors_outside_of_examples_count).and_return(3)
-      allow(notification).to receive(:duration)
-      allow(notification).to receive(:load_time)
-      spec_selector.errors_summary(notification)
-      expect(output).to match(/3 errors occurred outside of examples/)
-    end
-  end
-
-  describe '#status_count' do
-    it 'calls #pass_count' do
-      spec_selector.ivar_set(:@pass_count, 5)
-      spec_selector.status_count
-      expect(output).to match(/PASS: 5/)
-    end
-
-    it 'calls #fail_count' do
-      spec_selector.ivar_set(:@fail_count, 3)
-      spec_selector.status_count
-      expect(output).to match(/FAIL: 3/)
-    end
-
-    context 'when there are pending examples' do
-      it 'calls #pending_count' do
-        spec_selector.ivar_set(:@pending_count, 2)
-        spec_selector.status_count
-        expect(output).to match(/PENDING: 2/)
-      end
-    end
-
-    context 'when there no pending examples' do
-      it 'does not call #pending_count' do
-        expect(output).not_to match(/PENDING:/)
-      end
-    end
-  end
-
-  describe '#print_summary' do
-    before do
-      spec_selector.ivar_set(:@example_count, 30)
-      allow(notification).to receive(:duration).and_return(1.5)
-      allow(notification).to receive(:load_time).and_return(2.3)
-      spec_selector.status_summary(notification)
-      spec_selector.print_summary
-    end
-
-    it 'prints total examples' do
-      expect(output).to match(/Total Examples: 30/)
-    end
-
-    it 'prints total time for examples to run' do
-      expect(output).to match(/Finished in 1.5 seconds/)
-    end
-
-    it 'prints total time for files to load' do
-      expect(output).to match(/Files loaded in 2.3 seconds/)
-    end
-  end
-
-  describe '#exclude_passing!' do
-    before do
-      spec_selector.ivar_set(:@map, mixed_map)
-      spec_selector.exclude_passing!
-    end
-
-    it 'sets @active_map to map that excludes all-passing example groups' do
-      expect(spec_selector.ivar(:@active_map)[:top_level]).not_to include(pass_group)
-      expect(spec_selector.ivar(:@active_map)[:top_level]).to include(fail_group)
-    end
-
-    it 'sets @exclude_passing to true' do
-      expect(spec_selector.ivar(:@exclude_passing)).to be true
-    end
-  end
-
-  describe '#include_passing!' do
-    before do
-      spec_selector.ivar_set(:@map, mixed_map)
-      spec_selector.exclude_passing!
-    end
-
-    it 'sets @active_map to @map' do
-      expect(spec_selector.ivar(:@active)).not_to eq(spec_selector.ivar(:@map))
-      spec_selector.include_passing!
-      expect(spec_selector.ivar(:@active_map)).to eq(spec_selector.ivar(:@map))
-    end
-
-    it 'sets @exclude_passing to false' do
-      expect(spec_selector.ivar(:@exclude_passing)).to be true
-      spec_selector.include_passing!
-      expect(spec_selector.ivar(:@exclude_passing)).to be false
-    end
-  end
-
-  describe '#toggle_passing' do
-    before do
-      allow_methods(:display_list, :navigate)
-      map = mixed_map
-      list = mixed_list
-      group = pass_group
-      ivars_set(:@map => map, :@list => list, :@selected => group)
-    end
-
-    context 'when displayed list includes all-passing example groups' do
-      it 'removes all-passing example groups from displayed list' do
-        spec_selector.toggle_passing
-        expect(spec_selector.ivar(:@list)).not_to include(pass_group)
-      end
-    end
-
-    context 'when all-passing example groups are already excluded' do
-      it 'reverses the exclusion of all-passing example groups' do
-        spec_selector.toggle_passing
-        expect(spec_selector.ivar(:@list)).not_to include(pass_group)
-        spec_selector.toggle_passing
-        expect(spec_selector.ivar(:@list)).to include(pass_group)
-      end
-    end
-  end
-
-  describe '#status_summary' do
-    let(:summary) { spec_selector.ivar(:@summary) }
-
-    before do
-      spec_selector.ivar_set(:@example_count, 25)
-      spec_selector.status_summary(notification)
-    end
-
-    it 'stores message indicating example total in @summary' do
-      expect(summary).to include(/Total Examples: 25/)
-    end
-
-    it 'stores message indicating total time to run examples in @summary' do
-      expect(summary).to include(/Finished in 1.5 seconds/)
-    end
-
-    it 'stores message indicating total time to load files in @summary' do
-      expect(summary).to include(/Files loaded in 0.5 seconds/)
-    end
-  end
-
-  describe '#display_list' do
-    before { allow(spec_selector).to receive(:test_data_summary) }
-
-    context 'when all examples have passed' do
-      it 'displays message indicating that all examples have passed' do
-        ivars_set(:@map => all_passing_map, :@list => [pass_group, pass_group])
-        allow(spec_selector).to receive(:all_passing?).and_return(true)
-        spec_selector.display_list
-        expect(output).to match(/ALL EXAMPLES PASSED/)
-      end
-    end
-
-    context 'when not all examples have passed' do
-      it 'does not display message indicating that all examples have passed' do
-        ivars_set(:@map => mixed_map, :@list => mixed_list)
-        allow(spec_selector).to receive(:all_passing?).and_return(false)
-        spec_selector.display_list
-        expect(output).not_to match(/ALL EXAMPLES PASSED/)
-      end
-    end
-
-    it 'displays list of example groups or examples in current level' do
-      ivars_set(:@map => mixed_map, :@list => mixed_list)
-      spec_selector.display_list
-      expect(output).to match(/[passing example group]/)
-      expect(output).to match(/[non-passing example group]/)
-    end
-  end
-
-  describe '#display_example' do
-    before { allow_methods(:test_data_summary, :navigate) }
-
-    context 'when example is pending' do
-      it 'displays example summary' do
-        summary_settings(pending_example)
-        spec_selector.display_example
-        expect(output).to match(/[pending example]/)
-      end
-    end
-
-    context 'when example is failed' do
-      it 'displays example summary' do
-        summary_settings(failed_example)
-        spec_selector.display_example
-        expect(output).to match(/[failed example]/)
-      end
-    end
-
-    context 'when example is passing' do
-      it 'displays text indicating the example passed' do
-        ivars_set(:@selected => passing_example, :@passed => [passing_example])
-        spec_selector.display_example
-        expect(output).to match(/[PASSED]/)
-      end
-    end
-  end
-
-  describe '#example_list' do
-    it 'returns example list corresponding to execution result status' do
-      spec_selector.ivar_set(:@selected, failed_example)
-      expect(spec_selector.example_list).to include(@failed)
-    end
-
-    context 'when example failed' do
-      let(:notification) do
-        build(:failed_example_notification, example: failed_example)
-      end
-
-      it 'returns failure summary of selected example' do
-        summary_settings(failed_example)
-        expect(spec_selector.example_list).to include(notification)
-      end
-    end
-
-    context 'when example is pending' do
-      let(:notification) do
-        build(:skipped_example_notification, example: pending_example)
-      end
-
-      it 'returns pending summary of selected example' do
-        summary_settings(pending_example)
-        expect(spec_selector.example_list).to include(notification)
-      end
-    end
-  end
-end

data/spec/spec_selector_util/format_spec.rb

@@ -1,213 +0,0 @@
-# frozen_string_literal: true
-
-describe 'SpecSelectorUtil::Format' do
-  include_context 'shared'
-
-  describe '#fetch_examples' do
-    context 'when argument is an example' do
-      let(:example) { build(:example) }
-
-      it 'returns an array containing only the argument' do
-        expect(spec_selector.fetch_examples(example)).to eq([example])
-      end
-    end
-
-    context 'when argument is an example group with no subgroups' do
-      before { ivar_set(:@map, mixed_map) }
-
-      it 'returns an array of the examples that belong to the example group' do
-        expect(spec_selector.fetch_examples(pass_group)).to eq(pass_group.examples)
-      end
-    end
-
-    context 'when argument is an example group with subgroups' do
-      before { ivar_set(:@map, deep_map) }
-
-      it 'returns an array of all descendent examples of the example group' do
-        expect(spec_selector.fetch_examples(fail_parent_group)).to eq(fail_subgroup.examples)
-      end
-    end
-  end
-
-  describe '#format_list_item' do
-    context 'when argument is a currently selected list item' do
-      before { ivars_set(:@list => deep_map[:top_level], :@selected => pass_parent_group, :@map => deep_map) }
-
-      it 'prints the argument description in highlighted text' do
-        spec_selector.format_list_item(pass_parent_group)
-        expect(output).to eq("\e[1;7mpass_parent_group\e[0m\n")
-      end
-    end
-
-    context 'when argument is non-selected passing example' do
-      before { ivar_set(:@map, deep_map) }
-
-      it 'prints the argument description in green text' do
-        spec_selector.format_list_item(passing_example)
-        expect(output).to eq("\e[1;32mpassing_example\e[0m\n")
-      end
-    end
-
-    context 'when argument is non-selected example group whose descendent examples all pass' do
-      before { ivar_set(:@map, mixed_map) }
-
-      it 'prints the argument description in green text' do
-        spec_selector.format_list_item(pass_group)
-        expect(output).to eq("\e[1;32mpass_group\e[0m\n")
-      end
-    end
-
-    context 'when argument is non-selected failed example' do
-      it 'prints the argument description in red text' do
-        spec_selector.format_list_item(failed_example)
-        expect(output).to eq("\e[1;31mfailed_example\e[0m\n")
-      end
-    end
-
-    context 'when argument is non-selected example group with at least one failed descendent example' do
-      before { ivar_set(:@map, deep_map) }
-
-      it 'prints the argument description in red text' do
-        spec_selector.format_list_item(fail_parent_group)
-        expect(output).to eq("\e[1;31mfail_parent_group\e[0m\n")
-      end
-    end
-
-    context 'when argument is a pending example' do
-      it 'prints the argument description in yellow text' do
-        spec_selector.format_list_item(pending_example)
-        expect(output).to eq("\e[1;33mpending_example\e[0m\n")
-      end
-    end
-
-    context 'when argument is non-selected example group with at least one pending and no failed descendent examples' do
-      before { ivar_set(:@map, pending_map) }
-
-      it 'prints the argument description in yellow text' do
-        spec_selector.format_list_item(pending_group)
-        expect(output).to eq("\e[1;33mpending_group\e[0m\n")
-      end
-    end
-
-    context 'when argument is included in filter' do
-      let(:example) { build(:example, metadata: { include: true, description: 'the example' }) }
-
-      it 'prints the argument description with a check mark' do
-        spec_selector.format_list_item(example)
-        expect(output).to eq("\e[1;32mthe example\e[0m √\n")
-      end
-    end
-  end
-
-  describe '#pass_count' do
-    before { ivar_set(:@pass_count, 30) }
-
-    it 'prints the current number of passing examples in green text' do
-      spec_selector.pass_count
-      expect(output).to eq("\e[1;32mPASS: 30\e[0m\n")
-    end
-  end
-
-  describe '#pending_count' do
-    before { ivar_set(:@pending_count, 10) }
-
-    it 'prints the current number of pending examples' do
-      spec_selector.pending_count
-      expect(output).to eq("\e[1;33mPENDING: 10\e[0m\n")
-    end
-  end
-
-  describe '#fail_count' do
-    before { ivar_set(:@fail_count, 20) }
-
-    it 'prints the current number of failed examples' do
-      spec_selector.fail_count
-      expect(output).to eq("\e[1;31mFAIL: 20\e[0m\n")
-    end
-  end
-
-  describe '#highlight' do
-    before { ivar_set(:@selected, passing_example) }
-
-    it 'prints the argument in highlighted text' do
-      spec_selector.highlight(passing_example.description)
-      expect(output).to eq("\e[1;7mpassing_example\e[0m\n")
-    end
-
-    context 'when argument is included in filter' do
-      it 'prints the argument with a check mark' do
-        spec_selector.highlight(passing_example.description, true)
-        expect(output).to eq("\e[1;7mpassing_example √\e[0m\n")
-      end
-    end
-  end
-
-  describe '#lineage' do
-    it 'recursively prepends descriptions of ancestor example groups to description of argument' do
-      expect(spec_selector.lineage(pass_subgroup.metadata)).to eq('pass_parent_group -> pass_subgroup')
-    end
-  end
-
-  describe '#format_example' do
-    it 'prints description of selected example' do
-      ivar_set(:@selected, passing_example)
-      spec_selector.format_example(:passed, nil)
-      expect(output).to match(/passing_example/)
-    end
-
-    context 'when selected example is passing' do
-      it 'prints "PASSED" in green text' do
-        ivar_set(:@selected, passing_example)
-        spec_selector.format_example(:passed, nil)
-        expect(output).to include("\e[1;32mPASSED\e[0m")
-      end
-    end
-
-    context 'when selected example is pending or failed' do
-      let(:notification) { build(:failed_example_notification) }
-
-      it 'prints example result summary' do
-        ivar_set(:@selector_index, 0)
-        spec_selector.format_example(:failed, notification)
-        expect(output).to include('failed example')
-      end
-    end
-  end
-
-  describe '#print_nonpassing_example' do
-    context 'when selected example is failed' do
-      let(:notification) { build(:failed_example_notification) }
-
-      it 'prints failure summary of selected example' do
-        ivar_set(:@selector_index, 0)
-        spec_selector.print_nonpassing_example(notification)
-        expect(output).to include('failed example')
-      end
-    end
-
-    context 'when selected example is pending' do
-      let(:notification) { build(:skipped_example_notification) }
-
-      it 'prints pending summary of selected example' do
-        ivar_set(:@selector_index, 0)
-        spec_selector.print_nonpassing_example(notification)
-        expect(output).to include('pending example')
-      end
-    end
-  end
-
-  describe '#print_passing_example' do
-    before do
-      ivar_set(:@selected, passing_example)
-      spec_selector.print_passing_example
-    end
-
-    it 'prints description of selected example' do
-      expect(output).to include('passing_example')
-    end
-
-    it 'prints "PASSED"' do
-      expect(output).to include('PASSED')
-    end
-  end
-end