rproof 0.0.1

data/README.md

@@ -0,0 +1,9 @@
+Configuration to get Rproof working on your machine:
+
+- clone this project into <local repositery folder>
+
+- run gem install bundler if Bundler gem is not already install.
+
+- in <local repositery folder>, run bundle install to install dependencies
+
+- in <local repositery folder>/sample, run ruby run_rubyunit_test_sample to watch a simple test example

data/lib/rproof.rb

@@ -0,0 +1,16 @@
+require_relative './rproof/abstract_reporter'
+require_relative './rproof/assertion'
+require_relative './rproof/censor'
+require_relative './rproof/composite_reporter'
+require_relative './rproof/live_reporter'
+require_relative './rproof/located_info'
+require_relative './rproof/test_result'
+require_relative './rproof/test_runner'
+require_relative './rproof/test_suite'
+require_relative './rproof/test'
+require_relative './rproof/xml_reporter'
+require_relative './rproof/warning'
+
+module Rproof
+
+end

data/lib/rproof/abstract_reporter.rb

@@ -0,0 +1,37 @@
+########################################################################################################################
+# Defines the interface of a reporter.
+########################################################################################################################
+
+require_relative 'test_result'
+
+module Rproof
+  class AbstractReporter
+    def report_campaign_begin
+    end
+
+    def report_suite_begin(id, name, description)
+    end
+
+    def report_test_begin(id, name, description)
+    end
+
+    def report_assertion(assertion)
+    end
+
+    def report_warning(warning)
+    end
+
+    def report_exception(exception)
+    end
+
+    def report_test_end(id, test_result)
+    end
+
+    def report_suite_end(id, test_results)
+    end
+
+    #  test_results is either a Test_Result or a Test_Result Array
+    def report_campaign_end(test_results, start_time, end_time)
+    end
+  end
+end

data/lib/rproof/assertion.rb

@@ -0,0 +1,18 @@
+########################################################################################################################
+# Stores assertion result information
+########################################################################################################################
+
+require_relative 'located_info'
+
+module Rproof
+  class Assertion < LocatedInfo
+    def initialize(expected, obtained, is_successful, comment)
+      super()
+      @expected = expected
+      @obtained = obtained
+      @is_successful = is_successful
+      @comment = comment
+    end
+    attr_reader :expected, :obtained, :is_successful, :comment
+  end
+end

data/lib/rproof/censor.rb

@@ -0,0 +1,52 @@
+########################################################################################################################
+# Provide various assertion, warning and exception methods
+########################################################################################################################
+
+require_relative 'abstract_reporter'
+require_relative 'assertion'
+require_relative 'test_result'
+require_relative 'warning'
+
+module Rproof
+  class Censor
+    def initialize(reporter, name, description)
+      @reporter = reporter
+      @test_result = TestResult.new name, description
+    end
+    attr_reader :test_result
+
+    def assert_different(expected, obtained, comment)
+      @test_result.add_assertion Assertion.new(expected, obtained, (obtained != expected), comment)
+      @reporter.report_assertion @test_result.assertions.last
+    end
+
+    def assert_equal(expected, obtained, comment)
+      @test_result.add_assertion Assertion.new(expected, obtained, (obtained == expected), comment)
+      @reporter.report_assertion @test_result.assertions.last
+    end
+
+    def assert_exception(expected, comment, &block)
+      error = nil
+      begin
+        block.call
+      rescue Exception => error
+      ensure
+        assert_equal(expected, error.class, comment)
+      end
+    end
+
+    def assert(statement, comment)
+      assert_equal true, statement, comment
+    end
+
+    def warning(message)
+      @test_result.add_warning Warning.new(message)
+      @reporter.report_warning @test_result.warnings.last
+    end
+
+    def log_exception(error)
+      @test_result.add_exception error
+      @reporter.report_exception @test_result.exceptions.last
+    end
+  end
+end

data/lib/rproof/composite_reporter.rb

@@ -0,0 +1,53 @@
+########################################################################################################################
+#
+########################################################################################################################
+
+require_relative 'abstract_reporter'
+
+module Rproof
+  class CompositeReporter < AbstractReporter
+    def initialize
+      @reporters = []
+    end
+
+    def add(reporter)
+      @reporters << reporter
+    end
+
+    def report_campaign_begin
+      @reporters.each { |r| r.report_campaign_begin }
+    end
+
+    def report_suite_begin(id, name, description)
+      @reporters.each { |r| r.report_suite_begin id, name, description }
+    end
+
+    def report_test_begin(id, name, description)
+      @reporters.each { |r| r.report_test_begin id, name, description }
+    end
+
+    def report_assertion(assertion)
+      @reporters.each { |r| r.report_assertion assertion }
+    end
+
+    def report_warning(warning)
+      @reporters.each { |r| r.report_warning warning }
+    end
+
+    def report_exception(exception)
+      @reporters.each { |r| r.report_exception exception }
+    end
+
+    def report_test_end(id, test_result)
+      @reporters.each { |r| r.report_test_end id, test_result }
+    end
+
+    def report_suite_end(id, test_results)
+      @reporters.each { |r| r.report_suite_end id, test_results }
+    end
+
+    def report_campaign_end(test_results, start_time, end_time)
+      @reporters.each { |r| r.report_campaign_end test_results, start_time, end_time }
+    end
+  end
+end

data/lib/rproof/live_reporter.rb

@@ -0,0 +1,161 @@
+########################################################################################################################
+# Implements a live reporter: assertion results are shown on-the-flow, with two verbose levels: dotted or full.
+########################################################################################################################
+
+require 'colorize'
+
+require_relative 'abstract_reporter'
+require_relative 'assertion'
+
+module Rproof
+  class LiveReporter < AbstractReporter
+
+    OK = '['.bold + 'OK'.green.bold + ']'.bold
+    KO = '['.bold + 'KO'.red.bold + ']'.bold
+    WA = '['.bold + 'W!'.yellow.bold + ']'.bold
+    WARNING = '/!\\ WARNING /!\\'.yellow.bold
+
+    STATUS = {
+      untested:   'untested'.bold.on_blue,
+      exception:  'exception'.bold.on_magenta,
+      failed:     'failed'.bold.red,
+      warning:    'succeed'.bold.green + ' with ' + 'warnings'.bold.yellow,
+      succeed:    'succeed'.bold.green
+    }
+
+    INDENT = "  "
+
+    def initialize(verbose: false, cli_width: 80, justification: ([60, cli_width - 100].max))
+      @verbose = verbose
+      @justification = justification
+    end
+
+    def report_campaign_begin
+      if @verbose
+        puts "Running test campaign..."
+      end
+    end
+
+    def report_suite_begin(id, name, description)
+    end
+
+    def report_test_begin(id, name, description)
+      if @verbose
+        puts
+        puts '-' * 120
+        puts "Running #{name}"
+        puts description
+        puts
+      end
+    end
+
+    def report_assertion(assertion)
+      if @verbose
+        if assertion.is_successful
+          puts "#{INDENT}#{(assertion.comment + ' ').ljust(@justification, '_')} #{OK} obtained #{assertion.obtained.inspect}"
+        else
+          puts "#{INDENT}#{(assertion.comment + ' ').ljust(@justification, '_')} #{KO} expected #{assertion.expected.inspect}"
+          puts "#{INDENT}#{' ' * @justification}      obtained #{assertion.obtained.inspect}"
+        end
+      end
+    end
+
+    def report_warning(warning)
+      if @verbose
+        puts "#{INDENT}#{WARNING} #{warning.message}"
+      end
+    end
+
+    def report_exception(exception)
+      if @verbose
+        puts "#{INDENT}exception: " + exception.message.bold.on_magenta
+        puts INDENT + exception.backtrace.join("\n#{INDENT}").bold.magenta
+      end
+    end
+
+    def report_test_end(id, test_result)
+      if @verbose
+        puts
+        puts "End: #{STATUS[test_result.status]}. #{test_result.successes_nb} successes, #{test_result.failures_nb} failures, #{test_result.warnings.count} warnings, #{test_result.exceptions.count} exceptions"
+      else
+        case
+        when !test_result.exceptions.empty? then dot = "E".bold.on_magenta
+        when !test_result.failures.empty? then dot = "F".bold.red
+        when !test_result.warnings.empty? then dot = "W".bold.yellow
+        else dot = "."
+        end
+        print dot
+      end
+    end
+
+    def report_suite_end(id, test_results)
+    end
+
+    def report_campaign_end(test_results, start_time, end_time)
+      if test_results.is_a? Array # if false, campaign was a single test
+        campaign_status = :succeed
+        successes_nb = 0
+        failures_nb = 0
+        warnings_nb = 0
+        exceptions_nb = 0
+
+        results = test_results.flatten
+        results.each do |result|
+          campaign_status = TestResult.get_worse_status campaign_status, result.status
+          successes_nb += result.successes_nb
+          failures_nb += result.failures_nb
+          warnings_nb += result.warnings.count
+          exceptions_nb += result.exceptions.count
+        end
+        if @verbose
+          puts
+          puts "End of campaign: #{STATUS[campaign_status]}. #{successes_nb} successes, #{failures_nb} failures, #{warnings_nb} warnings, #{exceptions_nb} exceptions"
+        else
+          puts
+          puts "#{STATUS[campaign_status]} in #{end_time - start_time}. #{successes_nb} successes, #{failures_nb} failures, #{warnings_nb} warnings, #{exceptions_nb} exceptions"
+          if warnings_nb > 0
+            puts
+            puts " warnings:"
+            results.each do |result|
+              result.warnings.each do |warning|
+                full_comment = "in #{warning.file}:#{warning.line}:#{warning.method}: #{warning.message} "
+                puts "  #{full_comment.ljust(@justification, '_')} #{WA}"
+              end
+            end
+          end
+          if failures_nb > 0
+            puts
+            puts " failures:"
+            results.each do |result|
+              result.failures.each do |failure|
+                full_comment = "in #{failure.file}:#{failure.line}:#{failure.method}: #{failure.comment} "
+                puts "  #{full_comment.ljust(@justification, '_')} #{KO} #{"expected".bold} #{failure.expected.inspect}, #{"obtained".bold} #{failure.obtained.inspect}"
+              end
+            end
+          end
+          if exceptions_nb > 0
+            print_header('exceptions')
+            print_exceptions(results)
+          end
+        end
+      end
+    end
+
+    private
+
+    def print_header(header)
+      puts
+      puts " #{header}:"
+    end
+
+    def print_exceptions(results)
+      results.each do |result|
+        result.exceptions.each do |exception|
+          puts "  " + exception.message.bold.on_magenta
+          puts "    " + exception.backtrace.join("\n    ").bold.magenta
+        end
+      end
+    end
+
+  end
+end

data/lib/rproof/located_info.rb

@@ -0,0 +1,28 @@
+########################################################################################################################
+# Determines and stored location data for a test information
+########################################################################################################################
+
+require 'pathname'
+
+module Rproof
+  class LocatedInfo
+    def initialize
+      @pathname = nil
+      @file = nil
+      @line = nil
+      @method = nil
+      caller.each do |line|
+        matches = line.match /^.*\.rb/
+        pathname = Pathname.new(matches[0])
+        if not pathname.to_s.match(/lib\/(censor)|(assertion)|(warning)\.rb$/) and nil == @file # ignore lib files, until test definition file
+          @pathname = pathname
+          @file = pathname.basename
+          matches = line.match /^.*\.rb:(\d*):in `([^']*)'/
+          @line = matches[1]
+          @method = matches[2]
+        end
+      end
+    end
+    attr_reader :pathname, :file, :line, :method
+  end
+end

data/lib/rproof/test.rb

@@ -0,0 +1,41 @@
+########################################################################################################################
+# Define an atomic test. This class has to be inherited in child classes, where the developer writes test code.
+########################################################################################################################
+
+require_relative 'abstract_reporter'
+require_relative 'censor'
+
+module Rproof
+  class Test
+    def initialize(reporter, name, description = nil)
+      @id = object_id
+      @reporter = reporter
+      @name = name
+      @description = description
+      @censor = Censor.new reporter, name, description
+    end
+
+    def setup
+    end
+
+    def run
+      raise "This method has to be overriden. Please redefine 'run' method with your test code."
+    end
+
+    def clean_up
+    end
+
+    def execute
+      @reporter.report_test_begin(@id, @name, @description)
+      begin
+        setup
+        run
+        clean_up
+      rescue Exception => e
+        @censor.log_exception e
+      end
+      @reporter.report_test_end(@id, @censor.test_result)
+      @censor.test_result
+    end
+  end
+end

data/lib/rproof/test_result.rb

@@ -0,0 +1,63 @@
+require_relative 'assertion'
+
+module Rproof
+  class TestResult
+    def initialize(name, description)
+      @name = name
+      @description = description
+      @assertions = []
+      @warnings = []
+      @exceptions = []
+    end
+    attr_reader :name, :description, :assertions, :warnings, :exceptions
+
+    def add_assertion(assertion)
+      @assertions << assertion
+    end
+
+    def add_warning(warning)
+      @warnings << warning
+    end
+
+    def add_exception(exception)
+      @exceptions << exception
+    end
+
+    def successes_nb
+      successes.count
+    end
+
+    def failures_nb
+      failures.count
+    end
+
+    def successes
+      @assertions.select { |assertion| assertion.is_successful }
+    end
+
+    def failures
+      @assertions.select { |assertion| not assertion.is_successful }
+    end
+
+    def status
+      if @exceptions.count > 0
+        :exception
+      elsif failures_nb > 0
+        :failed
+      else
+        :succeed
+      end
+    end
+
+    # Return worse status between the two
+    def self.get_worse_status(status_1, status_2)
+      if [status_1, status_2].include? :exception
+        :exception
+      elsif [status_1, status_2].include? :failed
+        :failed
+      else
+        :succeed
+      end
+    end
+  end
+end