thumblemonks-protest 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Justin Knowlden, Gabriel Gironda, Dan Hodos, Thumble Monks
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,42 @@
+# Protest
+
+An extremely fast-running, context-driven, unit testing framework.
+
+    context "Foo" do
+      setup do
+        # some setup stuff
+        @foo = Foo.new
+      end
+      
+      asserts("this block returns true") do
+        true
+      end
+
+      asserts("this block returns a specific string").equals("my friend") do
+        @foo.your_mom
+      end
+    end
+
+MORE TO COME
+
+## You say, "OMG! Why did you write this?"
+
+#### Some background, I guess
+
+You start a new project. You get all excited. You're adding tests. You're adding factories. You're fixturating your setups. You're adding more tests. Your tests start slowing down, but you need to keep pushing because your backlog has a lot of new, nifty features in it. You've got 3000+ lines of test code, 2000+ assertions. Your tests are annoyingly slow. Your tests have become a burden.
+
+I hate this and it happens a lot, even when I'm conscience that it's happening.
+
+#### How Protest is different
+
+Protest differs in that it does not rerun setup for each test in a context. Each assertion should not mangle the context and therefore not require setup to be run more than once. Contexts can be nested and setups inherited, but setup is called only once per context.
+
+...
+
+You say, "Ok, but Shoulda is like this!"
+
+Well, it is ... sort of. I love Shoulda. It changed the way I coded. But, Shoulda is slow. Shoulda is based on Test::Unit. Shoulda reruns setups for every should. Shoulda could make my life even easier with some more expressiveness.
+
+#### How Protest is the same
+
+It defines a context. It prints .'s, F's, and E's when tests pass, fail, or error.

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+
+task :default => [:test]
+
+desc "Run tests"
+task :test do
+  $:.concat ['./test', './lib']
+  Dir.glob("./test/*_test.rb").each { |test| require test }
+  Protest.run
+end

data/lib/protest/assertion.rb

@@ -0,0 +1,39 @@
+module Protest
+  class Failure < Exception; end
+
+  class Assertion
+    def initialize(description, &block)
+      @description = description
+      @boolean_expectation = true
+      expectation(true, &block)
+    end
+
+    def to_s
+      "#{@description}: expected [#{@expectation}]"
+    end
+
+    def not(&block)
+      @boolean_expectation = false
+      expectation(@expectation, &block)
+    end
+
+    def equals(expectation, &block)
+      expectation(expectation, &block)
+    end
+
+    def run(context)
+      actual = context.instance_eval(&@block)
+      assert(@expectation == actual, "#{context} asserted #{self}, but received [#{actual}] instead")
+    end
+  private
+    def expectation(expectation, &block)
+      @expectation = expectation
+      @block = block if block_given?
+      self
+    end
+    
+    def assert(expression, msg)
+      @boolean_expectation == expression || raise(Failure, msg)
+    end
+  end # Assertion
+end # Protest

data/lib/protest/context.rb

@@ -0,0 +1,47 @@
+module Protest
+  class Context
+    attr_reader :assertions
+    def initialize(description, parent=nil)
+      @description = description
+      @assertions = []
+      @failures = []
+      @parent = parent
+      @setup = nil
+    end
+
+    def to_s
+      [@parent.to_s, @description].join(' ').strip
+    end
+
+    def context(description, &block)
+      Protest.context(description, self, &block)
+    end
+
+    def setup(&block)
+      @setup = block
+      self.bootstrap(self)
+    end
+
+    def asserts(description, &block)
+      (assertions << Assertion.new(description, &block)).last
+    end
+
+    def run(writer)
+      assertions.each do |assertion|
+        begin
+          assertion.run(self)
+          writer.print '.'
+        rescue Protest::Failure => e
+          writer.print 'F'
+          @failures << e
+        end
+      end
+      @failures
+    end
+
+    def bootstrap(binder)
+      @parent.bootstrap(binder) if @parent
+      binder.instance_eval(&@setup) if @setup
+    end
+  end # Context
+end # Protest

data/lib/protest/macros.rb

@@ -0,0 +1,9 @@
+module Protest
+  module ContextMacros
+    def denies(description, &block)
+      asserts(description, &block).not
+    end
+  end # ContextMacros
+end # Protest
+
+Protest::Context.instance_eval { include Protest::ContextMacros }

data/lib/protest.rb

@@ -0,0 +1,41 @@
+require 'protest/context'
+require 'protest/assertion'
+require 'protest/macros'
+
+module Protest
+  def self.contexts
+    @contexts ||= []
+  end
+
+  def self.context(description, parent = nil, &block)
+    context = Context.new(description, parent)
+    context.instance_eval(&block)
+    (contexts << context).last
+  end
+
+  def self.dequeue_context(context)
+    contexts.delete(context)
+  end
+
+  def self.run(writer=nil)
+    writer ||= STDOUT
+    start = Time.now
+    failures = @contexts.map { |context| context.run(writer) }.flatten
+    running_time = Time.now - start
+
+    writer.puts "\n\n"
+    failures.each_with_index { |failure, idx|
+      message = ["##{idx + 1} - #{failure.to_s}"]
+      # message += failure.backtrace
+      writer.puts message.join("\n") + "\n\n"
+    } unless failures.empty?
+    assertions = @contexts.inject(0) { |acc, context| acc + context.assertions.length }
+    writer.puts "#{@contexts.length} contexts, #{assertions} assertions: #{"%0.6f" % running_time} seconds"
+  end
+end # Protest
+
+module Kernel
+  def context(*args, &block)
+    Protest.context(*args, &block)
+  end
+end # Kernel

data/protest.gemspec

@@ -0,0 +1,31 @@
+Gem::Specification.new do |s|
+  s.name     = "protest"
+  s.version  = "0.0.2"
+  s.date     = "2009-06-28"
+  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"
+  s.description = "An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks"
+  s.authors  = %w[Justin\ Knowlden]
+
+  s.has_rdoc = false
+  s.rdoc_options = ["--main", "README.markdown"]
+  s.extra_rdoc_files = ["README.markdown"]
+
+  # run git ls-files to get an updated list
+  s.files = %w[
+    MIT-LICENSE
+    README.markdown
+    lib/protest.rb
+    lib/protest/assertion.rb
+    lib/protest/context.rb
+    lib/protest/macros.rb
+    protest.gemspec
+  ]
+  
+  s.test_files = %w[
+    Rakefile
+    test/assertion_test.rb
+    test/context_test.rb
+  ]
+end

data/test/assertion_test.rb

@@ -0,0 +1,41 @@
+require 'protest'
+
+context "any assertion" do
+  asserts("its description").equals("i will pass: expected [true]") do
+    Protest::Assertion.new("i will pass").to_s
+  end
+end # any assertion
+
+context "passing assertion" do
+  asserts("true is expected") do
+    Protest::Assertion.new("i will pass") { true }.run(Object.new)
+  end
+
+  asserts("provided block was executed and returned true") do
+    Protest::Assertion.new("i will pass").equals("foo bar") { "foo bar" }.run(Object.new)
+  end
+
+  asserts("false on denial") do
+    Protest::Assertion.new("i will fail").not { false }.run(Object.new)
+  end
+
+  asserts("expectation does not equal actual result") do
+    Protest::Assertion.new("i will fail").not.equals("foo") { "bar" }.run(Object.new)
+  end
+end # passing assertion
+
+context "failing assertion" do
+  setup do
+    @expected_message = "test context asserted failure: expected [true], but received [false] instead"
+    assertion = Protest::Assertion.new("failure") { false }
+    begin
+      assertion.run(Protest::Context.new("test context"))
+    rescue Protest::Failure => e
+      @result = e
+    end
+  end
+  
+  asserts("failure message").equals(@expected_message) do
+    @result.to_s
+  end
+end # failing assertion

data/test/context_test.rb

@@ -0,0 +1,60 @@
+require 'protest'
+require 'stringio'
+
+context "any context" do
+  denies("two contexts with same name are the same").equals(Protest::Context.new("a")) do
+    Protest::Context.new("a")
+  end
+end
+
+# 
+# Test Context
+
+test_context = context "foo" do
+  setup { @test_counter = 0 }
+  asserts("a block returns true") { @test_counter += 1; true }
+  asserts("another block returns true") { @test_counter += 1; true }
+end # A CONTEXT THAT IS DEQUEUED
+
+context "test context" do
+  setup { Protest.dequeue_context(test_context) }
+  asserts("context description").equals("foo") { test_context.to_s }
+  asserts("assertion count").equals(2) { test_context.assertions.length }
+
+  asserts("setup runs only once").equals(2) do
+    test_context.run(StringIO.new)
+    test_context.instance_variable_get(:@test_counter)
+  end
+end
+
+# 
+# Nested Context
+
+inner_nested_context = nil
+nested_context = context "foo" do
+  setup do
+    @test_counter = 0
+  end
+  asserts("a block returns true") { @test_counter += 1; true }
+  
+  inner_nested_context = context("baz") do
+    setup { @test_counter += 10 }
+  end # A CONTEXT THAT IS DEQUEUED
+end # A CONTEXT THAT IS DEQUEUED
+
+context "nested context" do
+  setup do
+    Protest.dequeue_context(nested_context)
+    Protest.dequeue_context(inner_nested_context)
+    nested_context.run(StringIO.new)
+    inner_nested_context.run(StringIO.new)
+  end
+  
+  asserts("inner context inherits parent context setup").equals(10) do
+    inner_nested_context.instance_variable_get(:@test_counter)
+  end
+
+  asserts("nested context name").equals("foo baz") do
+    inner_nested_context.to_s
+  end
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: thumblemonks-protest
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Justin Knowlden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-28 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: An extremely fast, expressive, and context-driven unit-testing framework. A replacement for all other testing frameworks
+email: 
+- gus@gusg.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- MIT-LICENSE
+- README.markdown
+- lib/protest.rb
+- lib/protest/assertion.rb
+- lib/protest/context.rb
+- lib/protest/macros.rb
+- protest.gemspec
+has_rdoc: false
+homepage: http://github.com/thumblemonks/protest
+post_install_message: 
+rdoc_options: 
+- --main
+- README.markdown
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An extremely fast, expressive, and context-driven unit-testing framework
+test_files: 
+- Rakefile
+- test/assertion_test.rb
+- test/context_test.rb