thumblemonks-protest 0.0.6 → 0.0.7

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Justin Knowlden, Gabriel Gironda, Dan Hodos, Thumble Monks
+Copyright (c) 2008 Justin Knowlden, Thumble Monks
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -1,12 +1,12 @@
 # Protest
 
-An extremely fast, expressive, and context-driven unit-testing framework.
+An extremely fast, expressive, and context-driven unit-testing framework. Protest the slow test.
 
 #### Example: Basic booleans
 
 **NOTE:** For no specific reason, I'm going to use an ActiveRecord model in the following examples.
 
-At it's very basic, Protest simply tries to assert that an expression is true or false. Protest does this through its `asserts` and `denies` tests. An `asserts` test will pass if the result of running the test is neither `nil` or `false`. A `denies` test confirms just the opposite.
+At it's very basic, Protest simply tries to assert that an expression is true or false. Protest does this through its `asserts` or `should` tests. An `asserts` test will pass if the result of running the test is neither `nil` or `false`. A `should` test does the exact same thing - they are in fact aliases. The only difference is in the way you write the assertion. 
 
 For instance, given a test file named `foo_test.rb`, you might have the following code in it:
 
@@ -15,10 +15,20 @@ For instance, given a test file named `foo_test.rb`, you might have the followin
     context "a new user" do
       setup { @user = User.new }
       asserts("that it is not yet created") { @user.new_record? }
-      denies("that it is valid") { @user.valid? }
     end
 
-Notice that you do not define a class anywhere. That would be the entire contents of that test file.
+Notice that you do not define a class anywhere. That would be the entire contents of that test file. If you wanted to use a `should` instead, you could say this:
+
+    require 'protest'
+
+    context "a new user" do
+      setup { @user = User.new }
+      should("not be created") { @user.new_record? }
+    end
+
+Sometimes it's more clear to say "this **should** be that" and sometimes it's better to say "**asserts** this is that". I promise you that Protest will get no more redundant than this, but also that besides speed, Protest will aim at being expressive with a minimal amount of syntax.
+
+I'm going to use `asserts` for the rest of this introduction, but you should know that you can replace any instance of `asserts` with `should` and nothing would change.
 
 #### Example: Equality
 
@@ -275,7 +285,6 @@ TONS OF STUFF
 1. Refactor reporting; some abstracting is needed for recording a result (for instance)
 1. Need to know where in backtrace a test failed (line number, etc.)
 1. More assertion macros: throws, etc.
-1. Handle denies macro different, so that an entire failure message can translated to the 'negative' assertion. I don't want to add deny\_this and deny\_that macros
 1. Aliases for context "with, without, when, ..."; add those words to test description
 1. Optimization and simplification (ex. flog is complaining print\_result\_stack)
 1. Better error messages (maybe need to rename asserts to should for better readability)

data/Rakefile

@@ -10,7 +10,12 @@ task :test do
   Protest.report
 end
 
-desc "Run flog against library (except tests)"
+desc "Run Flog against library (except tests)"
 task :flog do
   puts %x[find ./lib -name *.rb | xargs flog]
 end
+
+desc "Run Roodi against library (except tests)"
+task :roodi do
+  puts %x[find ./lib -name *.rb | xargs roodi]
+end

data/lib/protest/assertion.rb

@@ -1,9 +1,9 @@
 module Protest
 
   class Assertion
-    attr_reader :raised
+    attr_reader :raised, :to_s
     def initialize(description, target, &block)
-      @description = description
+      @description = @to_s = description
       actualize(target, &block)
     end
 
@@ -26,35 +26,12 @@ module Protest
     def error?; !failure? && raised; end
     def passed?; !failure? && !error?; end
     def result; @failure || error; end
-    def to_s; @description; end
   private
     def actualize(target, &block)
       @actual = target.instance_eval(&block)
-      @default_failure = base_assertion
+      @default_failure = failure("expected true, not #{@actual.inspect}") unless @actual
     rescue Exception => e
       @raised = e
     end
-
-    def base_assertion
-      failure("expected true, not #{@actual.inspect}") unless @actual
-    end
   end # Assertion
-
-  # Denial will evaulate to true if the assertion failed in some way. Errors pass through. A Failure
-  # is generated if the assertion actually passed.
-  class Denial < Assertion
-    def actual
-      @actual # Do not forget default failure unless a failure is thrown
-    end
-    
-    alias :actual_failure :failure
-    def failure(message)
-      @default_failure = @failure = nil # this is a good thing
-    end
-  private
-    def base_assertion
-      actual_failure("expected assertion to fail") if @actual
-    end
-  end # Denial
-
 end # Protest

data/lib/protest/context.rb

@@ -23,8 +23,8 @@ module Protest
     def to_s; @to_s ||= [@parent.to_s, @description].join(' ').strip; end
 
     def context(description, &block) Protest.context(description, @reporter, self, &block); end
-    def asserts(description, &block) new_assertion(Assertion, description, &block); end
-    def denies(description, &block) new_assertion(Denial, description, &block); end
+    def asserts(description, &block) new_assertion("asserts #{description}", &block); end
+    def should(description, &block) new_assertion("should #{description}", &block); end
 
     def report
       assertions.each do |assertion|
@@ -38,8 +38,8 @@ module Protest
       end
     end
   private
-    def new_assertion(klass, description, &block)
-      (assertions << klass.new(description, self, &block)).last
+    def new_assertion(description, &block)
+      (assertions << Assertion.new(description, self, &block)).last
     end
   end # Context
 end # Protest

data/lib/protest/macros.rb

@@ -2,18 +2,21 @@ module Protest
   module AssertionMacros
     # Asserts that the result of the test equals the expected value
     #   asserts("test") { "foo" }.equals("foo")
+    #   should("test") { "foo" }.equals("foo")
     def equals(expected)
       expected == actual || failure("expected #{expected.inspect}, not #{actual.inspect}")
     end
 
     # Asserts that the result of the test is nil
     #   asserts("test") { nil }.nil
+    #   should("test") { nil }.nil
     def nil
       actual.nil? || failure("expected nil, not #{actual.inspect}")
     end
 
     # Asserts that the test raises the expected Exception
     #   asserts("test") { raise My::Exception }.raises(My::Exception)
+    #   should("test") { raise My::Exception }.raises(My::Exception)
     def raises(expected)
       failure("should have raised #{expected}, but raised nothing") unless raised
       failure("should have raised #{expected}, not #{error.class}") unless expected == raised.class
@@ -22,6 +25,7 @@ module Protest
 
     # Asserts that the result of the test equals matches against the proved expression
     #   asserts("test") { "12345" }.matches(/\d+/)
+    #   should("test") { "12345" }.matches(/\d+/)
     def matches(expected)
       expected = %r[#{Regexp.escape(expected)}] if expected.kind_of?(String)
       actual =~ expected || failure("expected #{expected.inspect} to match #{actual.inspect}")
@@ -29,6 +33,7 @@ module Protest
 
     # Asserts that the result of the test is an object that is a kind of the expected type
     #   asserts("test") { "foo" }.kind_of(String)
+    #   should("test") { "foo" }.kind_of(String)
     def kind_of(expected)
       actual.kind_of?(expected) || failure("expected kind of #{expected}, not #{actual.inspect}")
     end

data/lib/protest/report.rb

@@ -59,13 +59,14 @@ module Protest
     def print_result_stack
       bad_results.each_with_index do |result, idx|
         @writer.puts render_result(idx + 1, result)
-        @writer.puts "  " + result.backtrace.join("\n  ") + "\n\n"
+        @writer.puts "  " + result.backtrace.join("\n  ") if result.print_stacktrace?
+        @writer.puts "\n\n"
       end
     end
 
     def render_result(idx, result)
       format_args = [idx, result.context.to_s, result.assertion.to_s, result.to_s]
-      "#%d - %s asserts %s: %s" % format_args
+      "#%d - %s %s: %s" % format_args
     end
   end # TextReport
 

data/lib/protest.rb

@@ -42,16 +42,20 @@ module Protest
       super(message)
       @assertion = assertion
     end
+
     def contextualize(ctx)
       @context = ctx
       self
     end
+    
+    def print_stacktrace?; false; end
   end
   class Error < Failure
     def initialize(message, assertion, error)
       super(message, assertion)
       set_backtrace(error.backtrace)
     end
+    def print_stacktrace?; true; end
   end
 end # Protest
 

data/protest.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
   s.name     = "protest"
-  s.version  = "0.0.6"
-  s.date     = "2009-07-05"
+  s.version  = "0.0.7"
+  s.date     = "2009-08-12"
   s.summary  = "An extremely fast, expressive, and context-driven unit-testing framework"
   s.email    = %w[gus@gusg.us]
   s.homepage = "http://github.com/thumblemonks/protest"

data/test/assertion_test.rb

@@ -1,79 +1,66 @@
 require 'protest'
 
-fake_context = Object.new
+fake_context = Object.new # It works ... so, why not?
 
 context "basic assertion:" do
-  asserts("its description") do
+  should "have a description" do
     Protest::Assertion.new("i will pass", fake_context).to_s
   end.equals("i will pass")
 
-  asserts("passed? if assertion returns true") do
+  asserts "pass? is true when assertion passed" do
     Protest::Assertion.new("i will pass", fake_context) { true }.passed?
   end
 
-  asserts("failure? when assertion does not pass") do
+  asserts "failure? is true when assertion does not pass" do
     Protest::Assertion.new("i will pass", fake_context) { false }.failure?
   end
 
-  asserts("error? when an unexpected Exception is raised") do
+  asserts "error? is true when an unexpected Exception is raised" do
     Protest::Assertion.new("error", fake_context) { raise Exception, "blah" }.error?
   end
 end
 
-context "basic denial:" do
-  asserts("false assertion passes") do
-    Protest::Denial.new("i will pass", fake_context) { false }.passed?
-  end
-
-  asserts("true assertion fails") do
-    Protest::Denial.new("i will not pass", fake_context) { true }.failure?
-  end
-end # basic assertion
-
 context "equals assertion:" do
-  asserts("results equals expectation") do
+  asserts "result equals expectation" do
     Protest::Assertion.new("i will pass", fake_context) { "foo bar" }.equals("foo bar")
   end
 
-  asserts("a Failure if results don't equal eachother") do
+  should "raise a Failure if results don't equal each other" do
     Protest::Assertion.new("failure", fake_context) { "bar" }.equals("foo")
   end.kind_of(Protest::Failure)
-
-  asserts("a non-matching string is a good thing when in denial") do
-    Protest::Denial.new("pass", fake_context) { "bar" }.equals("foo")
-  end.nil
 end # equals assertion
 
 context "nil assertion:" do
-  asserts("actual result is nil") { Protest::Assertion.new("foo", fake_context) { nil }.nil }
-  asserts("a Failure if not nil") do
+  asserts("result is nil") { Protest::Assertion.new("foo", fake_context) { nil }.nil }
+  should "raise a Failure if not nil" do
     Protest::Assertion.new("foo", fake_context) { "a" }.nil
   end.kind_of(Protest::Failure)
 end # nil assertion
 
 context "raises assertion:" do
-  asserts("an Exception is raised") { raise Exception }.raises(Exception)
-end # maching assertion
+  should("raise an Exception") { raise Exception }.raises(Exception)
+end # raises assertion
 
 context "matching assertion:" do
-  asserts("actual result matches expression") do
+  asserts "result matches expression" do
     Protest::Assertion.new("foo", fake_context) { "a" }.matches(%r[.])
   end.equals(0)
 
-  asserts("a Failure if not nil") do
+  should "raise a Failure if result does not match" do
     Protest::Assertion.new("foo", fake_context) { "" }.matches(%r[.])
   end.kind_of(Protest::Failure)
 
-  asserts("string matches string") do
+  should "return the result of a matching operation" do
     Protest::Assertion.new("foo", fake_context) { "a" }.matches("a")
   end.equals(0)
 end # maching assertion
 
 context "kind_of assertion:" do
-  asserts("result is kind of String") do
+  asserts "specific result is a kind of String" do
     Protest::Assertion.new("foo", fake_context) { "a" }.kind_of(String)
   end
-  asserts("a Failure if not a kind of String") do
+
+  should "raise a Failure if not a kind of String" do
     Protest::Assertion.new("foo", fake_context) { 0 }.kind_of(String)
   end.kind_of(Protest::Failure)
 end # kind_of assertion

data/test/context_test.rb

@@ -11,41 +11,35 @@ context "any context" do
 
   context "that doesn't have passing tests" do
     setup do
-      @context.asserts("a") { true }
-      @context.asserts("b") { false }
-      @context.asserts("c") { raise Exception, "blah" }
+      @context.should("a") { true }
+      @context.should("b") { false }
+      @context.should("c") { raise Exception, "blah" }
     end
 
-    asserts("that passes are disctinct") { @reporter.passes }.equals(1)
-    asserts("that failures are captured") { @reporter.failures }.equals(1)
-    asserts("that unexpected errors are captured") { @reporter.errors }.equals(1)
+    asserts("passed test count") { @reporter.passes }.equals(1)
+    asserts("failure count") { @reporter.failures }.equals(1)
+    asserts("unexpected errors count") { @reporter.errors }.equals(1)
   end # that doesn't have passing tests
 end # any context
 
-context "when denying things" do
-  denies("true is false") { false }
-  denies("bar equals foo") { "bar" }.equals("foo")
-  denies("bar matches only digits") { "bar" }.matches(/^\d+$/)
-end
-
 # 
 # Test Context
 
 test_context = context("foo", Protest::NilReport.new) do
   setup { @test_counter = 0 }
-  asserts("a block returns true") { @test_counter += 1; true }
-  asserts("another block returns true") { @test_counter += 1; true }
+  asserts("truthiness") { @test_counter += 1; true }
+  asserts("more truthiness") { @test_counter += 1; true }
 end # A CONTEXT THAT IS DEQUEUED
 
 context "test context" do
   setup { Protest.dequeue_context(test_context) }
-  asserts("context description") { test_context.to_s }.equals("foo")
-  asserts("assertion count") { test_context.assertions.length }.equals(2)
+  should("confirm context description") { test_context.to_s }.equals("foo")
+  should("confirm assertion count") { test_context.assertions.length }.equals(2)
 
-  asserts("setup runs only once") do
+  should("call setup once") do
     test_context.instance_variable_get(:@test_counter)
   end.equals(2)
-end
+end # test context
 
 # 
 # Nested Context
@@ -56,7 +50,7 @@ nested_context = context("foo", Protest::NilReport.new) do
     @test_counter = 0
     @foo = "bar"
   end
-  asserts("a block returns true") { @test_counter += 1; true }
+  asserts("truthiness") { @test_counter += 1; true }
   
   inner_nested_context = context("baz") do
     setup { @test_counter += 10 }
@@ -72,13 +66,13 @@ context "nested context" do
     end
   end
   
-  asserts("inner context inherits parent context setup") do
+  should("inherit parent context") do
     inner_nested_context.instance_variable_get(:@test_counter)
   end.equals(10)
 
-  asserts("nested context name") { inner_nested_context.to_s }.equals("foo baz")
+  should("chain context names") { inner_nested_context.to_s }.equals("foo baz")
 
-  asserts("inner context without setup is still bootstrapped") do
+  asserts "parent setup is called even if setup not defined for self" do
     other_nested_context.instance_variable_get(:@foo)
   end.equals("bar")
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: thumblemonks-protest
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors: 
 - Justin Knowlden
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 -07:00
+date: 2009-08-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -33,6 +33,7 @@ files:
 - protest.gemspec
 has_rdoc: false
 homepage: http://github.com/thumblemonks/protest
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -54,7 +55,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: An extremely fast, expressive, and context-driven unit-testing framework