spec_selector 0.1.0

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'spec_selector'
+require 'stringio'
+require 'factory_bot'
+require 'timeout'
+require 'shared'
+
+RCN = RSpec::Core::Notifications
+EXAMPLE_STUBS = { description: 'description',
+                  execution_result: 'result',
+                  full_description: 'full_description' }.freeze
+
+alias ivar instance_variable_get
+alias ivar_set instance_variable_set
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.filter_run_when_matching :focus
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.include_context 'shared', include_shared: true
+
+  config.include FactoryBot::Syntax::Methods
+
+  config.before(:suite) do
+    FactoryBot.find_definitions
+  end
+
+  config.around(:example, break_loop: true) do |example|
+    begin
+      Timeout.timeout(0.001) do
+        example.run
+      end
+    rescue Timeout::Error
+      nil
+    end
+  end
+end

data/spec/spec_selector_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+describe SpecSelector do
+  include_context 'shared'
+
+  let(:spec_selector) { described_class.new(StringIO.new) }
+
+  let(:output) { spec_selector.ivar(:@output).string }
+  let(:pass_result) { build(:execution_result) }
+  let(:pending_result) { build(:execution_result, status: :pending) }
+
+  let(:fail_result) do
+    build(:execution_result, status: :failed, exception: 'error')
+  end
+
+  describe '#message' do
+    let(:notification) { RCN::MessageNotification.new('message') }
+
+    it 'stores the message string in the @messages array' do
+      messages = spec_selector.ivar(:@messages)
+      spec_selector.message(notification)
+      expect(messages).to include('message')
+    end
+  end
+
+  describe '#example_group_started' do
+    let(:group) do
+      instance_double('ExampleGroup', metadata: { block: 'key' }, examples: [])
+    end
+
+    let(:notification) { RCN::GroupNotification.new(group) }
+
+    it 'passes the example group to SpecSelector#map_group' do
+      expect(spec_selector).to receive(:map_group).with(group)
+      spec_selector.example_group_started(notification)
+    end
+
+    it 'stores example group in the @groups hash' do
+      spec_selector.example_group_started(notification)
+      groups = spec_selector.ivar(:@groups)
+      expect(groups.values).to include(group)
+    end
+  end
+
+  describe '#example_passed' do
+    let(:example) { instance_double('Example', execution_result: pass_result) }
+    let(:notification) { RCN::ExampleNotification.send(:new, example) }
+
+    before do
+      allow(spec_selector).to receive(:map_example)
+      allow(spec_selector).to receive(:check_inclusion_status)
+      spec_selector.example_passed(notification)
+    end
+
+    it 'stores example in @passed array' do
+      passed = spec_selector.ivar(:@passed)
+      expect(passed).to include(example)
+    end
+
+    it 'increments @pass_count' do
+      pass_count = spec_selector.ivar(:@pass_count)
+      expect(pass_count).to eq(1)
+    end
+
+    it 'updates passing example status display' do
+      expect(output).to match(/PASS: \d+/)
+    end
+  end
+
+  describe '#example_pending' do
+    let(:example) { instance_double('Example', execution_result: pending_result) }
+    let(:notification) { RCN::ExampleNotification.send(:new, example) }
+
+    before do
+      allow(spec_selector).to receive(:map_example)
+      allow(spec_selector).to receive(:check_inclusion_status)
+      spec_selector.example_pending(notification)
+    end
+
+    it 'stores example in @pending array' do
+      pending = spec_selector.ivar(:@pending)
+      expect(pending).to include(notification.example)
+    end
+
+    it 'increments @pending_count' do
+      pending_count = spec_selector.ivar(:@pending_count)
+      expect(pending_count).to eq(1)
+    end
+
+    it 'updates pending status display' do
+      expect(output).to match(/PENDING: \d+/)
+    end
+  end
+
+  describe '#example_failed' do
+    let(:example) do
+      instance_double('Example',
+                      full_description: 'full description',
+                      execution_result: fail_result)
+    end
+
+    let(:notification) { RCN::FailedExampleNotification.send(:new, example) }
+
+    before do
+      allow(spec_selector).to receive(:map_example)
+      allow(spec_selector).to receive(:check_inclusion_status)
+      spec_selector.example_failed(notification)
+    end
+
+    it 'stores example in @failed array' do
+      failed = spec_selector.ivar(:@failed)
+      expect(failed).to include(notification.example)
+    end
+
+    it 'increments @fail_count' do
+      fail_count = spec_selector.ivar(:@fail_count)
+      expect(fail_count).to eq(1)
+    end
+
+    it 'calls #status_count' do
+      expect(output).to match(/FAIL: \d+/)
+    end
+  end
+
+  describe '#dump_summary', break_loop: true do
+    let(:notification) { build(:summary_notification) }
+
+    context 'when errors outside of examples have occurred' do
+      let(:notification) do
+        build(:summary_notification, errors_outside_of_examples_count: 2)
+      end
+
+      it 'passes notification to #print_errors' do
+        allow(spec_selector).to receive(:print_errors).and_call_original
+        spec_selector.dump_summary(notification)
+        expect(spec_selector).to have_received(:print_errors).with(notification)
+      end
+    end
+
+    context 'when errors outside of examples have not occured' do
+      it 'does not call #print_errors' do
+        allow(spec_selector).to receive(:print_errors).and_call_original
+        spec_selector.dump_summary(notification)
+        expect(spec_selector).not_to have_received(:print_errors)
+      end
+    end
+
+    context 'when non-error messages are present with no examples' do
+      it 'calls #messages only' do
+        spec_selector.ivar(:@messages) << 'some message'
+        spec_selector.dump_summary(notification)
+      end
+    end
+
+    context 'when examples successfully executed' do
+      it 'passes notification to #examples_summary' do
+        ivar_set(:@map, mixed_map)
+        allow(spec_selector).to receive(:examples_summary).and_call_original
+        spec_selector.dump_summary(notification)
+        expect(spec_selector).to have_received(:examples_summary)
+          .with(notification)
+      end
+    end
+  end
+end

data/spec/spec_selector_util/data_map_spec.rb

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,314 @@
+# 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