protest 0.3.0 → 0.3.1

data/README.rdoc

@@ -2,16 +2,16 @@
 
     require "protest"
 
-    Protest.context("A user") do
+    Protest.describe("A user") do
       setup do
         @user = User.new(:name => "John Doe", :email => "john@example.org")
       end
 
-      test "has a name" do
+      it "has a name" do
         assert_equal "John Doe", @user.name
       end
 
-      test "has an email" do
+      it "has an email" do
         assert_equal "john@example.org", @user.email
       end
     end
@@ -49,7 +49,7 @@ If you need to run code before or after each test, declare a +setup+ or
 
 +setup+ and +teardown+ blocks are evaluated in the same context as your test,
 which means any instance variables defined in any of them are available in the
-rest.
+rest. Both methods are aliased for your comfort as before and after respectively.
 
 You can also use +global_setup+ and +global_teardown+ to run code only once per
 test case. +global_setup+ blocks will run once before the first test is run, and
@@ -69,13 +69,13 @@ them.
 
 Break down your test into logical chunks with nested contexts:
 
-    Protest.context("A user") do
+    Protest.describe("A user") do
       setup do
         @user = User.make
       end
 
       context "when validating" do
-        test "validates name" do
+        it "validates name" do
           @user.name = nil
           assert !@user.valid?
         end
@@ -84,7 +84,7 @@ Break down your test into logical chunks with nested contexts:
       end
 
       context "doing something else" do
-        # your get the idea
+        # you get the idea
       end
     end
 
@@ -187,6 +187,34 @@ Will output, when run with the <tt>:documentation</tt> report:
 
 This is similar to the specdoc runner in rspec[http://rspec.info].
 
+=== Summary report
+
+Use this report by calling <tt>Protest.report_with(:summary)</tt>
+
+Will output a brief summary with the total number of tests, assertions, passed
+tests, pending tests, failed tests and errors.
+
+=== Stories report
+
+Use this report by calling <tt>Protest.report_with(:stories)</tt>
+
+This report is based on Citrusbyte's Stories[http://github.com/citrusbyte/stories],
+by Damian Janowski and Michel Martens.
+
+=== Turn report
+
+Use this report by calling <tt>Protest.report_with(:turn)</tt>
+
+This report displays each test on a separate line with failures being displayed
+immediately instead of at the end of the tests.
+
+You might find this useful when running a large test suite, as it can be very
+frustrating to see a failure (....F...) and then have to wait until all the
+tests finish before you can see what the exact failure was.
+
+This report is based on the output displayed by TURN[http://github.com/TwP/turn],
+Test::Unit Reporter (New) by Tim Pease.
+
 === Defining your own reports
 
 This is really, really easy. All you need to do is subclass Report, and
@@ -196,5 +224,6 @@ Protest::Reports::Progress and Protest::Reports::Documentation.
 
 == Legal
 
+Maintainer:: Matías Flores — http://matflores.com
 Author:: Nicolás Sanguinetti — http://nicolassanguinetti.info
 License:: MIT (see bundled LICENSE file for more info)

data/lib/protest.rb

@@ -98,6 +98,9 @@ require "protest/report"
 require "protest/reports"
 require "protest/reports/progress"
 require "protest/reports/documentation"
+require "protest/reports/turn"
+require "protest/reports/summary"
+require "protest/reports/stories"
 
 Protest.autorun = true
 Protest.report_with(:progress)

data/lib/protest/reports/stories.rb

@@ -0,0 +1,61 @@
+module Protest
+  # This report is based on Citrusbyte's Stories[http://github.com/citrusbyte/stories],
+  # by Damian Janowski and Michel Martens.
+  class Reports::Stories < Report
+    include Utils::Summaries
+    include Utils::ColorfulOutput
+
+    attr_reader :stream #:nodoc:
+
+    # Set the stream where the report will be written to. STDOUT by default.
+    def initialize(stream=STDOUT)
+      @stream = stream
+    end
+
+    on :pass do |report, pass|
+      report.print ".", :passed
+    end
+
+    on :pending do |report, pending|
+      report.print "P", :pending
+    end
+
+    on :failure do |report, failure|
+      report.print "F", :failed
+    end
+
+    on :error do |report, error|
+      report.print "E", :errored
+    end
+
+    on :end do |report|
+      report.puts
+
+      Stories.all.values.to_a.each_with_index do |story,i|
+        report.puts "- #{story.name}"
+
+        story.scenarios.each do |scenario|
+          report.puts "    #{scenario.name}"
+
+          unless scenario.steps.empty? && scenario.assertions.empty?
+            scenario.steps.each do |step|
+              report.puts "      #{step}"
+            end
+
+            scenario.assertions.each do |assertion|
+              report.puts "      #{assertion}"
+            end
+
+            report.puts
+          end
+        end
+
+        report.puts unless i + 1 == Stories.all.values.size
+      end
+
+      report.puts "%d stories, %d scenarios" % [Stories.all.values.size, Stories.all.values.inject(0) {|total,s| total + s.scenarios.size }]
+    end
+  end
+
+  add_report :stories, Reports::Stories
+end

data/lib/protest/reports/stories/pdf.rb

@@ -0,0 +1,72 @@
+require "rubygems"
+
+gem "prawn", "~> 0.4"
+require "prawn"
+
+module Protest
+  # This report is based on Citrusbyte's Stories[http://github.com/citrusbyte/stories],
+  # by Damian Janowski and Michel Martens.
+  module Reports
+      class Stories::PDF < Report
+        include Utils::Summaries
+        include Utils::ColorfulOutput
+
+        attr_reader :stream #:nodoc:
+
+        # Set the stream where the report will be written to. STDOUT by default.
+        def initialize(stream=STDOUT)
+          @stream = stream
+        end
+
+        def render_header(pdf)
+        end
+
+        def render_many(pdf, elements)
+          elements.each do |el|
+            pdf.text el.to_s
+          end
+        end
+
+        on :end do |report|
+          Prawn::Document.generate("stories.pdf", :page_size => "A4") do |pdf|
+            report.render_header(pdf)
+
+            pdf.text "User Acceptance Tests", :size => 20, :style => :bold
+            
+            pdf.move_down(15)
+
+            Protest::Stories.all.values.each do |story|
+              pdf.text story.name, :style => :bold
+
+              story.scenarios.each_with_index do |scenario,i|
+                scenario_leading = 15
+
+                pdf.span(pdf.bounds.width - scenario_leading, :position => scenario_leading) do
+                  pdf.text "— #{scenario.name}"
+
+                  pdf.fill_color "666666"
+
+                  unless scenario.steps.empty? && scenario.assertions.empty?
+                    pdf.span(pdf.bounds.width - 30, :position => 30) do
+                      pdf.font_size(9) do
+                        report.render_many(pdf, scenario.steps)
+                        report.render_many(pdf, scenario.assertions)
+                      end
+                    end
+                  end
+
+                  pdf.move_down(5) unless i + 1 == story.scenarios.size
+                  
+                  pdf.fill_color "000000"
+                end
+              end
+
+              pdf.move_down(10)
+            end
+          end
+        end
+      end
+  end
+
+  add_report :stories_pdf, Reports::Stories::PDF
+end

data/lib/protest/reports/summary.rb

@@ -0,0 +1,22 @@
+module Protest
+  # The +:summary+ report will output a brief summary with the total number
+  # of tests, assertions, passed tests, pending tests, failed tests and
+  # errors.
+  class Reports::Summary < Report
+    include Utils::Summaries
+    include Utils::ColorfulOutput
+
+    attr_reader :stream #:nodoc:
+
+    # Set the stream where the report will be written to. STDOUT by default.
+    def initialize(stream=STDOUT)
+      @stream = stream
+    end
+
+    on :end do |report|
+      report.summarize_test_totals
+    end
+  end
+
+  add_report :summary, Reports::Summary
+end

data/lib/protest/reports/turn.rb

@@ -0,0 +1,76 @@
+module Protest
+  # This report displays each test on a separate line with failures being
+  # displayed immediately instead of at the end of the tests.
+  #
+  # You might find this useful when running a large test suite, as it can
+  # be very frustrating to see a failure (....F...) and then have to wait
+  # until all the tests finish before you can see what the exact failure
+  # was.
+  #
+  # This report is based on the output displayed by TURN[http://github.com/TwP/turn],
+  # Test::Unit Reporter (New) by Tim Pease.
+  class Reports::Turn < Report
+    include Utils::Summaries
+    include Utils::ColorfulOutput
+
+    attr_reader :stream #:nodoc:
+
+    PASS    = "PASS"
+    FAIL    = "FAIL"
+    ERROR   = "ERROR"
+    PENDING = "PENDING"
+
+    # Set the stream where the report will be written to. STDOUT by default.
+    def initialize(stream=STDOUT)
+      @stream = stream
+    end
+
+    on :enter do |report, context|
+      report.puts context.description unless context.tests.empty?
+    end
+
+    on :test do |report, test|
+      report.print "    %-67s" % test.test_name
+    end
+
+    on :pass do |report, passed_test|
+      report.puts  PASS, :passed
+    end
+
+    on :failure do |report, failed_test|
+      report.puts FAIL, :failed
+
+      report.puts "\t#{failed_test.error_message}", :failed
+      failed_test.backtrace.each { |backtrace| report.puts "\t#{backtrace}", :failed }
+    end
+
+    on :error do |report, errored_test|
+      report.puts ERROR, :errored
+
+      report.puts "\t#{errored_test.error_message}", :errored
+      errored_test.backtrace.each { |backtrace| report.puts "\t#{backtrace}", :failed }
+    end
+
+    on :pending do |report, pending_test|
+      report.puts PENDING, :pending
+    end
+
+    on :end do |report|
+      pass    = report.passes.count
+      pending = report.pendings.count
+      failure = report.failures.count
+      error   = report.errors.count
+      total   = report.tests.count
+
+      bar = '=' * 78
+      colorize_as = pass == total ? :passed : (pass + pending == total ? :pending : :failed)
+
+      report.puts bar, colorize_as
+      report.puts "  pass: %d,  pending: %d,  fail: %d,  error: %d" % [pass, pending, failure, error]
+      report.puts "  total: %d tests with %d assertions in #{report.time_elapsed} seconds" % [total, report.assertions]
+      report.puts bar, colorize_as
+    end
+  end
+
+  add_report :turn, Reports::Turn
+end

data/lib/protest/runner.rb

@@ -10,30 +10,35 @@ module Protest
     # events on the runner's report, at the +start+ and +end+ of the test run,
     # and before and after each test case (+enter+ and +exit+.)
     def run(*test_cases)
-      @report.on_start if @report.respond_to?(:on_start)
+      fire_event :start
       test_cases.each do |test_case|
-        @report.on_enter(test_case) if @report.respond_to?(:on_enter)
+        fire_event :enter, test_case
         test_case.run(self)
-        @report.on_exit(test_case) if @report.respond_to?(:on_exit)
+        fire_event :exit, test_case
       end
-      @report.on_end if @report.respond_to?(:on_end)
+      fire_event :end
     end
 
     # Run a test and report if it passes, fails, or is pending. Takes the name
-    # of the test as an argument. By passing +true+ as the second argument, you
-    # force any exceptions to be re-raied and the test not reported as a pass
-    # after it finishes (for global setup/teardown blocks)
-    def report(test, running_global_setup_or_teardown=false)
-      @report.on_test(Test.new(test)) if @report.respond_to?(:on_test) && !running_global_setup_or_teardown
+    # of the test as an argument.
+    def report(test)
+      fire_event(:test, Test.new(test)) if test.real?
       test.run(@report)
-      @report.on_pass(PassedTest.new(test)) unless running_global_setup_or_teardown
+      fire_event(:pass, PassedTest.new(test)) if test.real?
     rescue Pending => e
-      @report.on_pending(PendingTest.new(test, e))
+      fire_event :pending, PendingTest.new(test, e)
     rescue AssertionFailed => e
-      @report.on_failure(FailedTest.new(test, e))
+      fire_event :failure, FailedTest.new(test, e)
     rescue Exception => e
-      @report.on_error(ErroredTest.new(test, e))
-      raise if running_global_setup_or_teardown
+      fire_event :error, ErroredTest.new(test, e)
+      raise if test.raise_exceptions?
+    end
+
+    protected
+
+    def fire_event(event, *args)
+      event_handler_method = :"on_#{event}"
+      @report.send(event_handler_method, *args) if @report.respond_to?(event_handler_method)
     end
   end
 end

data/lib/protest/stories.rb

@@ -0,0 +1,128 @@
+module Protest
+  def self.story(description, &block)
+    context(description) do
+      Protest::Stories.all[self] = Protest::Stories::Story.new(description)
+      class_eval(&block) if block_given?
+    end
+  end
+
+  def self.scenario(name, &block)
+    scenario = Protest::Stories::Scenario.new(name)
+
+    Protest::Stories.all[self].scenarios << scenario
+
+    test(name) do
+      @scenario = scenario
+      instance_eval(&block)
+    end
+  end
+
+  module Stories
+    def self.all
+      @all ||= {}
+    end
+
+    module TestCase
+      def self.included(base)
+        class << base
+          def story(description, &block)
+            context(description) do
+              Protest::Stories.all[self] = Protest::Stories::Story.new(description)
+              class_eval(&block) if block_given?
+            end
+          end
+
+          def scenario(name, &block)
+            scenario = Protest::Stories::Scenario.new(name)
+
+            Protest::Stories.all[self].scenarios << scenario
+
+            test(name) do
+              @scenario = scenario
+              instance_eval(&block)
+            end
+          end
+        end
+      end
+    end
+
+    class Story
+      attr_accessor :name, :scenarios
+
+      def initialize(name)
+        @name = name
+        @scenarios = []
+      end
+    end
+
+    class Scenario
+      attr_accessor :name, :steps, :assertions
+
+      def initialize(name)
+        @name = name
+        @steps = []
+        @assertions = []
+      end
+    end
+
+    module Methods
+      def report(text, &block)
+        @scenario.steps << text
+        silent(&block) if block_given?
+      end
+
+      def silent(&block)
+        scenario, @scenario = @scenario, Stories::Scenario.new("#{@scenario.name} (Silent)")
+
+        begin
+          block.call
+        ensure
+          @scenario = scenario
+        end
+      end
+    end
+
+    module Webrat
+      def report_for(action, &block)
+        define_method(action) do |*args|
+          @scenario.steps << block.call(*args)
+          super(*args)
+        end
+      end
+      module_function :report_for
+
+      report_for :click_link do |name|
+        "Click #{quote(name)}"
+      end
+
+      report_for :click_button do |name|
+        "Click #{quote(name)}"
+      end
+
+      report_for :fill_in do |name, opts|
+        "Fill in #{quote(name)} with #{quote(opts[:with])}"
+      end
+
+      report_for :visit do |page|
+        "Go to #{quote(page)}"
+      end
+
+      report_for :check do |name|
+        "Check #{quote(name)}"
+      end
+
+      report_for :assert_contain do |text|
+        "I should see #{quote(text)}"
+      end
+
+      def quote(text)
+        "“#{text}”"
+      end
+      module_function :quote
+    end
+  end
+
+  Protest::TestCase.send(:include, Protest::Stories::TestCase)
+  Protest::TestCase.send(:include, Protest::Stories::Methods)
+  Protest::TestCase.send(:include, Protest::Stories::Webrat)
+end

data/lib/protest/test_case.rb

@@ -34,9 +34,9 @@ module Protest
     # Run all tests in this context. Takes a Runner instance in order to
     # provide output.
     def self.run(runner)
-      runner.report(TestWrapper.new(:setup, self), true)
-      tests.each {|test| runner.report(test, false) }
-      runner.report(TestWrapper.new(:teardown, self), true)
+      runner.report(TestWrapper.new(:setup, self))
+      tests.each {|test| runner.report(test) }
+      runner.report(TestWrapper.new(:teardown, self))
     rescue Exception => e
       # If any exception bubbles up here, then it means it was during the
       # global setup/teardown blocks, so let's just skip the rest of this
@@ -199,6 +199,16 @@ module Protest
       @name
     end
 
+    # Tests must not re-raise exceptions
+    def raise_exceptions?
+      false
+    end
+
+    # This is a real test
+    def real?
+      true
+    end
+
     private
 
     def setup #:nodoc:
@@ -248,6 +258,15 @@ module Protest
       def run(report)
         @test.send("do_global_#{@type}")
       end
+
+      def raise_exceptions?
+        true
+      end
+
+      # This is not a real test but a fake one
+      def real?
+        false
+      end
     end
   end
 end

data/protest.gemspec

@@ -1,14 +1,14 @@
 Gem::Specification.new do |s|
   s.name    = "protest"
-  s.version = "0.3.0"
-  s.date    = "2010-03-11"
+  s.version = "0.3.1"
+  s.date    = "2010-05-19"
 
   s.description = "Protest is a tiny, simple, and easy-to-extend test framework"
   s.summary     = s.description
-  s.homepage    = "http://rubyprotest.org"
+  s.homepage    = "http://matflores.github.com/protest"
 
-  s.authors = ["Nicolás Sanguinetti"]
-  s.email   = "contacto@nicolassanguinetti.info"
+  s.authors = ["Nicolás Sanguinetti", "Matías Flores"]
+  s.email   = "mflores@atlanware.com"
 
   s.require_paths     = ["lib"]
   s.rubyforge_project = "protest"
@@ -29,10 +29,15 @@ lib/protest/utils/colorful_output.rb
 lib/protest/test_case.rb
 lib/protest/tests.rb
 lib/protest/runner.rb
+lib/protest/stories.rb
 lib/protest/report.rb
 lib/protest/reports.rb
 lib/protest/reports/progress.rb
 lib/protest/reports/documentation.rb
+lib/protest/reports/summary.rb
+lib/protest/reports/turn.rb
+lib/protest/reports/stories.rb
+lib/protest/reports/stories/pdf.rb
 lib/protest/rails.rb
 ]
 end

metadata

@@ -5,21 +5,22 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 3
-  - 0
-  version: 0.3.0
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - "Nicol\xC3\xA1s Sanguinetti"
+- "Mat\xC3\xADas Flores"
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 -03:00
+date: 2010-05-19 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
 description: Protest is a tiny, simple, and easy-to-extend test framework
-email: contacto@nicolassanguinetti.info
+email: mflores@atlanware.com
 executables: []
 
 extensions: []
@@ -40,13 +41,18 @@ files:
 - lib/protest/test_case.rb
 - lib/protest/tests.rb
 - lib/protest/runner.rb
+- lib/protest/stories.rb
 - lib/protest/report.rb
 - lib/protest/reports.rb
 - lib/protest/reports/progress.rb
 - lib/protest/reports/documentation.rb
+- lib/protest/reports/summary.rb
+- lib/protest/reports/turn.rb
+- lib/protest/reports/stories.rb
+- lib/protest/reports/stories/pdf.rb
 - lib/protest/rails.rb
 has_rdoc: true
-homepage: http://rubyprotest.org
+homepage: http://matflores.github.com/protest
 licenses: []
 
 post_install_message: