protest 0.4.2 → 0.5.0

data/README.rdoc

@@ -1,237 +0,0 @@
-= Protest, the simplicity rebel test framework
-
-    require "protest"
-
-    Protest.describe("A user") do
-      setup do
-        @user = User.new(:name => "John Doe", :email => "john@example.org")
-      end
-
-      it "has a name" do
-        assert_equal "John Doe", @user.name
-      end
-
-      it "has an email" do
-        assert_equal "john@example.org", @user.email
-      end
-    end
-
-Protest is a small, simple, and easy-to-extend testing framework for ruby. It
-was written as a replacement for Test::Unit, given how awful its code is, and
-how difficult it is to extend in order to add new features.
-
-I believe in minimalistic software, which is easily understood, easy to test,
-and specially, easy to extend for third parties. That's where I'm aiming with
-Protest.
-
-== Get it
-
-    gem install protest
-
-Or
-
-    rip install git://github.com/matflores/protest.git v0.4.0
-
-== Setup and teardown
-
-If you need to run code before or after each test, declare a +setup+ or
-+teardown+ block (respectively.)
-
-    Protest.context("A user") do
-      setup do # this runs before each test
-        @user = User.create(:name => "John")
-      end
-
-      teardown do # this runs after each test
-        @user.destroy
-      end
-    end
-
-+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. 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
-+global_teardown+ will run after all the tests have been run.
-
-These methods, however, are dangerous, and should be used with caution, as
-they might introduce dependencies between your tests if you don't write
-your tests properly. Make sure that any state modified by code run in a
-+global_setup+ or +global_teardown+ isn't changed in any of your tests.
-
-Also, you should be aware that the code of +global_setup+ and +global_teardown+
-blocks isn't evaluated in the same context as your tests and normal
-+setup+/+teardown+ blocks are, so you can't share instance variables between
-them.
-
-== Nested contexts
-
-Break down your test into logical chunks with nested contexts:
-
-    Protest.describe("A user") do
-      setup do
-        @user = User.make
-      end
-
-      context "when validating" do
-        it "validates name" do
-          @user.name = nil
-          assert !@user.valid?
-        end
-
-        # etc, etc
-      end
-
-      context "doing something else" do
-        # you get the idea
-      end
-    end
-
-Any +setup+ or +teardown+ blocks you defined in a context will run in that
-context and in _any_ other context nested in it.
-
-== Pending tests
-
-There are two ways of marking a test as pending. You can declare a test with no
-body:
-
-    Protest.context("Some tests") do
-      test "this test will be marked as pending"
-
-      test "this tests is also pending"
-
-      test "this test isn't pending" do
-        assert true
-      end
-    end
-
-Or you can call the +pending+ method from inside your test.
-
-    Protest.context("Some tests") do
-      test "this test is pending" do
-        pending "oops, this doesn't work"
-        assert false
-      end
-    end
-
-== Custom assertions
-
-Previous versions of Protest used to bundle all the assertions defined in
-Test::Unit, but that has changed and now Protest includes just three basic
-assertion methods:
-
-- assert
-- assert_equal
-- assert_raise
-
-If you want to add assertions, just define methods that rely on +assert+.
-This method takes a boolean and an optional error message as arguments, and
-the assertion is considered to fail if the boolean evaluates to neither
-+false+ nor +nil+.
-
-For example:
-
-    module AwesomenessAssertions
-      def assert_awesomeness(object)
-        assert object.awesome?, "#{object.inspect} is not awesome enough"
-      end
-    end
-
-    class Protest::TestCase
-      include AwesomenessAssertions
-    end
-
-You could also define rspec-like matchers if you like that style. See
-<tt>matchers.rb</tt> in the examples directory for an example.
-
-== Reports
-
-Protest can report the output of a test suite in many ways. The library ships
-with a <tt>:progress</tt> report, and a <tt>:documentation</tt> report,
-<tt>:progress</tt> being the default.
-
-=== Progress report
-
-This is the default option, but you can force this by calling 
-<tt>Protest.report_with(:progress)</tt>.
-
-The progress report will output the "classic" Test::Unit output of periods for
-passing tests, "F" for failing assertions, "E" for unrescued exceptions, and 
-"P" for pending tests, in full color.
-
-=== Documentation report
-
-Use this report by calling <tt>Protest.report_with(:documentation)</tt>
-
-For each testcase in your suite, this will output the description of the test
-case (whatever you provide TestCase.context), followed by the name of each test
-in that context, one per line. For example:
-
-    Protest.context "A user" do
-      test "has a name"
-      test "has an email"
-
-      context "validations" do
-        test "ensure the email can't be blank"
-      end
-    end
-
-Will output, when run with the <tt>:documentation</tt> report:
-
-    A user
-    - has a name (Not Yet Implemented)
-    - has an email (Not Yet Implemented)
-
-    A user validations
-    - ensure the email can't be blank (Not Yet Implemented)
-
-(The 'Not Yet Implemented' messages are because the tests have no body. See
-"Pending tests", above.)
-
-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
-register your subclass by calling +Protest.add_report+. See the
-documentation for details, or take a look at the source code for
-Protest::Reports::Progress and Protest::Reports::Documentation.
-
-== Using Rails?
-
-If you are using Rails you may want to take a look at http://github.com/matflores/protest-rails.
-
-== 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/reports/stories.rb

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

@@ -1,72 +0,0 @@
-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/stories.rb

@@ -1,130 +0,0 @@
-# encoding: utf-8
-
-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