doggo 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e400910e348f37feab93f558dc22c8ccff17bb5978ac0466827274f7b568a3cc
+  data.tar.gz: db85734f689ef749c06ad135ce24bc5e36e92b3a749178da187cbddb95cfbe3c
+SHA512:
+  metadata.gz: c8f448cde211ab681a0057c1bfbeb56c3ae80aad416078c39fc1b12714ad81e7d934680ff77eaf71076fba55b67abe8f5839bf11ea31088bc352feca69c92964
+  data.tar.gz: e4561e754671832aab4f1afea408c2c06613b848387d7239679385e0ebe8ce684926ccbb279beb579cd032ec4e1c425142dabc833388be4e5f4d9a39759b6d09

data/lib/doggo.rb

@@ -0,0 +1,165 @@
+require 'rspec/core'
+require 'rspec/core/formatters/base_text_formatter'
+require 'rspec/core/formatters/console_codes'
+
+class Doggo < RSpec::Core::Formatters::BaseTextFormatter
+
+  RSpec::Core::Formatters.register(
+    self,
+    :start,
+    :example_started,
+    :example_group_started,
+    :example_group_finished,
+    :example_passed,
+    :example_pending,
+    :example_failed
+  )
+
+  attr_accessor(
+    :outstr,
+
+    :example_running,
+    :current_example_index,
+    :group_level,
+    :messages,
+
+    :total_count,
+    :pad,
+    :passed_count,
+    :pending_count,
+    :failed_count
+  )
+
+  def initialize(output)
+    @outstr                = output
+
+    @example_running       = false
+    @current_example_index = 0
+    @group_level           = 0
+    @messages              = []
+
+    @total_count           = 0
+    @pad                   = nil
+    @passed_count          = 0
+    @pending_count         = 0
+    @failed_count          = 0
+
+    super
+  end
+
+  def start(notification)
+    self.total_count = notification.count
+    self.pad         = notification.count.to_s.size
+    super
+  end
+
+  def example_started(_notification)
+    self.example_running        = true
+    self.current_example_index += 1
+  end
+
+  def example_group_started(notification)
+    self.outstr.puts() if self.group_level == 0
+    self.outstr.puts("#{group_progress()}#{current_indentation}#{notification.group.description.strip}")
+
+    self.group_level += 1
+  end
+
+  def example_group_finished(_notification)
+    self.group_level -= 1 if self.group_level > 0
+  end
+
+  def example_passed(passed)
+    self.outstr.puts(passed_output(passed.example))
+    flush_messages
+
+    self.passed_count   += 1
+    self.example_running = false
+  end
+
+  def example_pending(pending)
+    self.outstr.puts(
+      pending_output(
+        pending.example,
+        pending.example.execution_result.pending_message
+      )
+    )
+
+    flush_messages
+
+    self.pending_count  += 1
+    self.example_running = false
+  end
+
+  def example_failed(failure)
+    self.outstr.puts(failure_output(failure.example))
+    flush_messages
+
+    self.failed_count   += 1
+    self.example_running = false
+  end
+
+  def message(notification)
+    if self.example_running
+      self.messages << notification.message
+    else
+      self.outstr.puts("#{group_progress()}#{current_indentation}#{notification.message}")
+    end
+  end
+
+  private
+
+    def flush_messages
+      self.messages.each do |message|
+        self.outstr.puts("#{group_progress()}#{current_indentation(1)}#{message}")
+      end
+
+      self.messages.clear
+    end
+
+    def passed_output(example)
+      RSpec::Core::Formatters::ConsoleCodes.wrap(
+        "#{example_progress()} #{current_indentation}#{example.description.strip}",
+        :success
+      )
+    end
+
+    def pending_output(example, message)
+      message = nil if message.downcase == 'temporarily skipped with xit'
+      message = " (#{message})" unless message.nil? || message.empty?
+
+      RSpec::Core::Formatters::ConsoleCodes.wrap(
+        "#{example_progress()} #{current_indentation}PENDING#{message} - #{example.description.strip}",
+        :pending
+      )
+    end
+
+    def failure_output(example)
+      RSpec::Core::Formatters::ConsoleCodes.wrap(
+        "#{example_progress()} #{current_indentation}FAILED (#{next_failure_index}) - #{example.description.strip}",
+        :failure
+      )
+    end
+
+    def group_progress
+      if self.pad.nil?
+        ''
+      else
+        "[#{' ' * self.pad} #{self.total_count}] "
+      end
+    end
+
+    def example_progress
+      "[#{self.current_example_index.to_s.rjust(self.pad, '0')}/#{self.total_count}]"
+    end
+
+    def next_failure_index
+      @next_failure_index ||= 0
+      @next_failure_index  += 1
+    end
+
+    def current_indentation(offset = 0)
+      '  ' * (self.group_level + offset)
+    end
+
+end

data/spec/example/doggo_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+RSpec.describe 'Doggo examples', for_example_output: true do
+  context 'in a context' do
+    context 'with a nested context' do
+
+      it 'passes' do
+        expect(true).to eql(true)
+      end
+
+      it 'fails' do
+        expect(true).to eql(false)
+      end
+
+      xit 'is pending with xit' do
+      end
+
+      it 'is pending with a custom message' do
+        pending('custom message')
+      end
+    end
+  end
+
+  it 'outer passes' do
+    expect(true).to eql(true)
+  end
+
+  it 'outer fails' do
+    expect(true).to eql(false)
+  end
+
+  xit 'outer is pending with xit' do
+  end
+
+  it 'outer is pending with a custom message' do
+    pending('custom message')
+  end
+
+  context 'test count' do
+    it 'is taken to 9' do
+      expect(true).to eql(true)
+    end
+
+    it 'is taken to 10, showing leading zero pad formatting' do
+      expect(true).to eql(true)
+    end
+  end
+end

data/spec/internal_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+RSpec.describe Doggo do
+  before :each do
+    @bork = StringIO.new
+    @dog  = Doggo.new(@bork)
+  end
+
+  context '#start' do
+    before :each do
+      @notification = double('Notification', count: 4)
+    end
+
+    it 'sets total count from notification' do
+      expect(@dog.total_count).to eql(0)
+      @dog.start(@notification)
+      expect(@dog.total_count).to eql(@notification.count)
+      @dog.start(@notification)
+      expect(@dog.total_count).to eql(@notification.count) # I.e. it was set, not incremented
+    end
+  end # "context '#start' do"
+
+  context 'individual examples' do
+    before :each do
+      @notification        = double('Notification', count: 4)
+      @example_description = 'Example description'
+      @pending_message     = 'Custom pending message'
+      @example             = double(
+        'Example',
+        description: @example_description,
+        execution_result: double(
+          'Execution result',
+          pending_message: @pending_message
+        )
+      )
+    end
+
+    context '#example_started' do
+      it 'notes an example is running' do
+        expect(@dog.example_running).to eq(false)
+        @dog.example_started(@notification)
+        expect(@dog.example_running).to eq(true)
+      end
+
+      it 'increments the example index' do
+        expect(@dog.current_example_index).to eql(0)
+        @dog.example_started(@notification)
+        expect(@dog.current_example_index).to eql(1)
+        @dog.example_started(@notification)
+        expect(@dog.current_example_index).to eql(2)
+      end
+    end # "context '#example_started' do"
+
+    context '#example_passed' do
+      before :each do
+        @dog.start(@notification)
+        @passed = double('Passing test', example: @example)
+      end
+
+      it 'notes an example is no longer running' do
+        expect(@dog.example_running).to eq(false)
+
+        @dog.example_started(@notification)
+        expect(@dog.example_running).to eq(true)
+
+        @dog.example_passed(@passed)
+        expect(@dog.example_running).to eq(false)
+      end
+
+      it 'increments the "passed" count' do
+        expect(@dog.passed_count).to eql(0)
+
+        @dog.example_started(@notification)
+        @dog.example_passed(@passed)
+        expect(@dog.passed_count).to eql(1)
+
+        @dog.example_started(@notification)
+        @dog.example_passed(@passed)
+        expect(@dog.passed_count).to eql(2)
+      end
+
+      it 'logs the success' do
+        @dog.example_started(@notification)
+        @dog.example_passed(@passed)
+
+        expect(@bork.string).to include("[1/#{@notification.count}]")
+        expect(@bork.string).to include(@example_description)
+      end
+    end # "context '#example_passed' do"
+
+    context '#example_failed' do
+      before :each do
+        @dog.start(@notification)
+        @failed = double('Failing test', example: @example)
+      end
+
+      it 'notes an example is no longer running' do
+        expect(@dog.example_running).to eq(false)
+
+        @dog.example_started(@notification)
+        expect(@dog.example_running).to eq(true)
+
+        @dog.example_failed(@failed)
+        expect(@dog.example_running).to eq(false)
+      end
+
+      it 'increments the "failed" count' do
+        expect(@dog.failed_count).to eql(0)
+
+        @dog.example_started(@notification)
+        @dog.example_failed(@failed)
+        expect(@dog.failed_count).to eql(1)
+
+        @dog.example_started(@notification)
+        @dog.example_failed(@failed)
+        expect(@dog.failed_count).to eql(2)
+      end
+
+      it 'logs the failure' do
+        @dog.example_started(@notification)
+        @dog.example_failed(@failed)
+
+        expect(@bork.string).to include("[1/#{@notification.count}]")
+        expect(@bork.string).to include('FAILED')
+        expect(@bork.string).to include(@example_description)
+      end
+    end # "context '#example_failed' do"
+
+    context '#example_pending' do
+      before :each do
+        @dog.start(@notification)
+        @pending = double('Pending test', example: @example)
+      end
+
+      it 'notes an example is no longer running' do
+        expect(@dog.example_running).to eq(false)
+
+        @dog.example_started(@notification)
+        expect(@dog.example_running).to eq(true)
+
+        @dog.example_pending(@pending)
+        expect(@dog.example_running).to eq(false)
+      end
+
+      it 'increments the "pending" count' do
+        expect(@dog.pending_count).to eql(0)
+
+        @dog.example_started(@notification)
+        @dog.example_pending(@pending)
+        expect(@dog.pending_count).to eql(1)
+
+        @dog.example_started(@notification)
+        @dog.example_pending(@pending)
+        expect(@dog.pending_count).to eql(2)
+      end
+
+      it 'logs the custom message' do
+        @dog.example_started(@notification)
+        @dog.example_pending(@pending)
+
+        expect(@bork.string).to include("[1/#{@notification.count}]")
+        expect(@bork.string).to include('PENDING')
+        expect(@bork.string).to include(@pending_message)
+        expect(@bork.string).to include(@example_description)
+      end
+    end # "context '#example_pending' do"
+  end   # "context 'individual examples' do"
+
+  context 'example groups' do
+    before :each do
+      @group_description  = 'Group description'
+      @group_notification = double(
+        'Group notification',
+        group: double(
+          'RSpec group',
+          description: @group_description
+        )
+      )
+    end
+
+    context '#example_group_started' do
+      it 'increments group level' do
+        expect(@dog.group_level).to eql(0)
+        @dog.example_group_started(@group_notification)
+        expect(@dog.group_level).to eql(1)
+        @dog.example_group_started(@group_notification)
+        expect(@dog.group_level).to eql(2)
+      end
+
+      it 'outputs an indication of group progress' do
+        @dog.example_group_started(@group_notification)
+        expect(@bork.string).to include(@group_description)
+      end
+
+      it 'outputs a separator at top level' do
+        @dog.example_group_started(@group_notification)
+        expect(@bork.string).to start_with("\n")
+      end
+
+      it 'does not output a separator below top level' do
+        @dog.example_group_started(@group_notification)
+        expect(@bork.string).to start_with("\n")
+        @bork.truncate(0)
+
+        @dog.example_group_started(@group_notification)
+        expect(@bork.string).to_not start_with("\n")
+      end
+    end # "context '#example_group_started' do"
+
+    context '#example_group_finished' do
+      it 'derements group level' do
+        @dog.example_group_started(@group_notification)
+        @dog.example_group_started(@group_notification)
+        expect(@dog.group_level).to eql(2)
+        @dog.example_group_finished(@group_notification)
+        expect(@dog.group_level).to eql(1)
+        @dog.example_group_finished(@group_notification)
+        expect(@dog.group_level).to eql(0)
+      end
+
+      it 'does not decrement below zero' do
+        expect(@dog.group_level).to eql(0)
+        @dog.example_group_finished(@group_notification)
+        expect(@dog.group_level).to eql(0)
+      end
+    end # "context '#example_group_finished' do"
+  end   # "context 'example groups' do"
+
+  context '#message' do
+    before :each do
+      @message              = 'A message'
+      @message_notification = double(
+        'Message notification',
+        message: @message
+      )
+    end
+
+    it 'logs directly with no example running' do
+      @dog.message(@message_notification)
+      expect(@bork.string.strip).to eql(@message)
+    end
+
+    it 'logs directly if an example-start occurs unexpectedly' do
+      notification = double('Notification', count: 4)
+      @dog.example_started(notification)
+      @dog.message(@message_notification)
+      @dog.send(:flush_messages)
+      expect(@bork.string.strip).to eql(@message)
+    end
+
+    it 'logs in context if an example is running' do
+      notification = double('Notification', count: 4)
+      @dog.start(notification)
+      @dog.example_started(notification)
+      @dog.message(@message_notification)
+      @dog.send(:flush_messages)
+      expect(@bork.string.strip).to start_with('[')
+      expect(@bork.string.strip).to end_with(@message)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+require 'doggo'
+
+RSpec.configure do | config |
+  config.color = true
+  config.tty   = true
+  config.order = :random
+
+  config.add_formatter 'Doggo'
+
+  if ENV['FOR_EXAMPLE']
+    config.filter_run_including for_example_output: true
+  else
+    config.filter_run_excluding for_example_output: true
+  end
+
+  Kernel.srand config.seed
+end
+
+def spec_helper_capture_stdout( &block )
+  result = ''
+
+  begin
+    old_stdout = $stdout
+    $stdout = StringIO.new
+
+    yield
+
+    result = $stdout.string
+
+  ensure
+    $stdout = old_stdout
+
+  end
+
+  return result
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: doggo
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- RIP Global
+- Andrew David Hodgkinson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+description: Similar to RSpec -f d, but adds indication of test number and total tests
+  on each line
+email:
+- andrew@ripglobal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/doggo.rb
+- spec/example/doggo_spec.rb
+- spec/internal_spec.rb
+- spec/spec_helper.rb
+homepage: https://ripglobal.com/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.5
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: RSpec formatter - documentation, with progress indication
+test_files:
+- spec/spec_helper.rb
+- spec/internal_spec.rb
+- spec/example/doggo_spec.rb