mofo 0.1 → 0.1.1

data/vendor/testspec-0.2.0/SPECS

@@ -0,0 +1,101 @@
+
+== TestUnit
+* still works on its own
+* supports should good enough
+* works inside test/spec
+
+== SpecDox
+* can unmangle Test::Unit names correctly
+* can unmangle Test::Spec names correctly
+* has sensible fallbacks
+
+== flexmock
+* should handle
+* should handle without a block
+* should handle with a block
+* should have a return value
+* should handle missing methods
+* should ignore missing methods
+* should count correctly
+* should raise on bad counts
+* should handle undetermined counts
+* should handle zero counts
+* should have file IO with use
+* should have use
+* should handle failures during use
+* should deal with sequential values
+* respond_to? should return false for non handled methods
+* respond_to? should return true for explicit methods
+* respond_to? should return true when ignoring_missing
+* respond_to? should return true for missing_methods when should_ignore_missing
+* should raise error on unknown method proc
+* should return callable proc on method
+* should return do nothing proc for missing methods
+* works with test/spec
+
+== mocha
+* works with test/spec
+* works with test/spec and Enterprise example
+
+== stubba
+* works with test/spec and instance method stubbing
+* works with test/spec and class method stubbing
+* works with test/spec and global instance method stubbing
+
+== Outer context
+=== Inner context
+* is nested
+* has multiple empty specifications
+=== Second Inner context
+* is indented properly
+* still runs in order of definition
+==== Inmost context
+* works too!
+* whoo!
+
+== should.output
+* works for print
+* works for puts
+* works with readline
+
+== test/spec
+* has should.satisfy
+* has should.equal
+* has should.raise
+* should.raise should return the exception
+* has should.be_an_instance_of
+* has should.be_nil
+* has should.include
+* has should.be_a_kind_of
+* has should.match
+* has should.be
+* has should.not.raise
+* has should.not.be
+* has should.not.equal
+* has should.not.match
+* has should.throw
+* has should.not.throw
+* has should.respond_to
+* has should.be_close
+* multiple negation works
+* has should.<predicate>
+* has should <operator> (>, >=, <, <=, ===)
+* is robust against careless users
+
+== setup/teardown
+* run in the right order
+
+== contexts
+* are defined in class scope
+* can include modules
+
+== Context First
+* runs before Second
+
+== Context Second
+* runs before Last
+
+== Context Last
+* runs last
+
+70 specifications (267 requirements), 0 failures

data/vendor/testspec-0.2.0/TODO

@@ -0,0 +1 @@
+- see ROADMAP

data/vendor/testspec-0.2.0/bin/specrb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+
+require 'optparse'
+
+testrbargv = []
+automatic = false
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: specrb [options] [files | -a] [-- untouched arguments]"
+
+  opts.separator ""
+  opts.separator "Ruby options:"
+
+  lineno = 1
+  opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
+    eval line, TOPLEVEL_BINDING, "-e", lineno
+    lineno += 1
+  }
+
+  opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
+    $DEBUG = true
+  }
+  opts.on("-w", "--warn", "turn warnings on for your script") {
+    $-w = true
+  }
+
+  opts.on("-I", "--include PATH",
+          "specify $LOAD_PATH (may be used more than once)") { |path|
+    $LOAD_PATH.concat path.split(":")
+  }
+
+  opts.on("-r", "--require LIBRARY",
+          "require the library, before executing your script") { |library|
+    require library
+  }
+
+  opts.separator ""
+  opts.separator "test/spec options:"
+
+  opts.on("-s", "--specdox", "do AgileDox-like output") {
+    testrbargv << "--runner=specdox"
+  }
+  opts.on("--rdox", "do AgileDox-like output with RDoc formatting") {
+    testrbargv << "--runner=rdox"
+  }
+
+  opts.on("-a", "--automatic", "gather tests from ./test/") {
+    automatic = true
+  }
+
+  opts.separator ""
+  opts.separator "test/unit options:"
+
+  opts.on('-n', '--name NAME', String,
+          "runs tests matching regexp NAME") { |n|
+    testrbargv << "-n" << "/#{n}/"
+  }
+  
+  opts.on('-t', '--testcase TESTCASE', String,
+          "runs tests in TestCases matching regexp TESTCASE") { |t|
+    testrbargv << "-t" << "/#{t}/"
+  }
+
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "Show version") do
+    require 'test/spec'
+    puts "specrb #{Test::Spec::VERSION}"
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+files = ARGV
+
+if automatic
+  files.concat Dir["test/test_*.rb"]
+  files.concat Dir["test/spec_*.rb"]
+  files.concat Dir["spec/spec_*.rb"]
+end
+
+if files.empty?
+  puts opts.banner
+  exit 1
+end
+
+argv = testrbargv + ["--"] + files
+
+require 'test/spec'
+
+Test::Unit.run = false
+runner = Test::Unit::AutoRunner.new true
+runner.process_args(argv) ||
+  abort("internal error calling Test::Unit, please report a bug")
+exit runner.run

data/vendor/testspec-0.2.0/examples/stack.rb

@@ -0,0 +1,38 @@
+# Copied without code changes from RSpec.
+
+class StackUnderflowError < RuntimeError
+end
+
+class StackOverflowError < RuntimeError
+end
+
+class Stack
+  
+  def initialize
+    @items = []
+  end
+  
+  def push object
+    raise StackOverflowError if @items.length == 10
+    @items.push object
+  end
+  
+  def pop
+    raise StackUnderflowError if @items.empty?
+    @items.delete @items.last
+  end
+  
+  def peek
+    raise StackUnderflowError if @items.empty?
+    @items.last
+  end
+  
+  def empty?
+    @items.empty?
+  end
+
+  def full?
+    @items.length == 10
+  end
+  
+end

data/vendor/testspec-0.2.0/examples/stack_spec.rb

@@ -0,0 +1,119 @@
+# Copied with minor code changes (should_xxx -> should.xxx) from RSpec.
+
+require File.dirname(__FILE__) + '/../lib/test/spec'
+require File.dirname(__FILE__) + "/stack"
+
+context "A stack (in general)" do
+  setup do
+    @stack = Stack.new
+    ["a","b","c"].each { |x| @stack.push x }
+  end
+  
+  specify "should add to the top when sent 'push'" do
+    @stack.push "d"
+    @stack.peek.should.equal "d"
+  end
+  
+  specify "should return the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should NOT remove the top item when sent 'peek'" do
+    @stack.peek.should.equal "c"
+    @stack.peek.should.equal "c"
+  end
+  
+  specify "should return the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+  end
+  
+  specify "should remove the top item when sent 'pop'" do
+    @stack.pop.should.equal "c"
+    @stack.pop.should.equal "b"
+  end
+end
+
+context "An empty stack" do
+  setup do
+    @stack = Stack.new
+  end
+  
+  specify "should be empty" do
+    @stack.should.be.empty
+  end
+  
+  specify "should no longer be empty after 'push'" do
+    @stack.push "anything"
+    @stack.should.not.be.empty
+  end
+  
+  specify "should complain when sent 'peek'" do
+    lambda { @stack.peek }.should.raise StackUnderflowError
+  end
+  
+  specify "should complain when sent 'pop'" do
+    lambda { @stack.pop }.should.raise StackUnderflowError
+  end
+end
+
+context "An almost empty stack (with one item)" do
+  setup do
+    @stack = Stack.new
+    @stack.push 3
+  end
+  
+  specify "should not be empty" do
+    @stack.should.not.be.empty
+  end
+  
+  specify "should remain not empty after 'peek'" do
+    @stack.peek
+    @stack.should.not.be.empty
+  end
+  
+  specify "should become empty after 'pop'" do
+    @stack.pop
+    @stack.should.be.empty
+  end
+end
+
+context "An almost full stack (with one item less than capacity)" do
+  setup do
+    @stack = Stack.new
+    (1..9).each { |i| @stack.push i }
+  end
+  
+  specify "should not be full" do
+    @stack.should.not.be.full
+  end
+  
+  specify "should become full when sent 'push'" do
+    @stack.push Object.new
+    @stack.should.be.full
+  end
+end
+
+context "A full stack" do
+  setup do
+    @stack = Stack.new
+    (1..10).each { |i| @stack.push i }
+  end
+  
+  specify "should be full" do
+    @stack.should.be.full
+  end
+  
+  specify "should remain full after 'peek'" do
+    @stack.peek
+    @stack.should.be.full
+  end
+  
+  specify "should no longer be full after 'pop'" do
+    @stack.pop
+    @stack.should.not.be.full
+  end
+
+  specify "should complain on 'push'" do
+    lambda { @stack.push Object.new }.should.raise StackOverflowError
+  end
+end

data/vendor/testspec-0.2.0/lib/test/spec.rb

@@ -0,0 +1,366 @@
+#
+# test/spec -- a BDD interface for Test::Unit
+#
+# Copyright (C) 2006  Christian Neukirchen <mailto:chneukirchen@gmail.com>
+#
+# This work is licensed under the same terms as Ruby itself.
+#
+
+require 'test/unit'
+
+class Test::Unit::AutoRunner    # :nodoc:
+  RUNNERS[:specdox] = lambda {
+    require 'test/spec/dox'
+    Test::Unit::UI::SpecDox::TestRunner
+  }
+
+  RUNNERS[:rdox] = lambda {
+    require 'test/spec/rdox'
+    Test::Unit::UI::RDox::TestRunner
+  }
+end
+
+module Test                     # :nodoc:
+end
+
+module Test::Spec
+  VERSION = "0.1"
+  
+  CONTEXTS = {}
+
+  class DefinitionError < StandardError
+  end
+
+  class Should
+    include Test::Unit::Assertions
+
+    def initialize(object)
+      @object = object
+    end
+
+    $TEST_SPEC_TESTCASE = nil
+    def add_assertion
+      $TEST_SPEC_TESTCASE && $TEST_SPEC_TESTCASE.__send__(:add_assertion)
+    end
+
+
+    def an
+      self
+    end
+
+    def a
+      self
+    end
+
+    def not
+      ShouldNot.new(@object)
+    end
+
+
+    def satisfy(&block)
+      assert_block("satisfy block failed.") {
+        yield @object
+      }
+    end
+
+    def equal(value)
+      assert_equal value, @object
+    end
+    alias == equal
+
+    def close(value, delta)
+      assert_in_delta value, @object, delta
+    end
+    alias be_close close
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        assert_same value.first, @object
+      else
+        raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      assert_match value, @object
+    end
+    alias =~ match
+
+    def instance_of(klass)
+      assert_instance_of klass, @object
+    end
+    alias be_an_instance_of instance_of
+
+    def kind_of(klass)
+      assert_kind_of klass, @object
+    end
+    alias be_a_kind_of kind_of
+
+    def respond_to(method)
+      assert_respond_to @object, method
+    end
+
+    def _raise(*args)
+      args = [RuntimeError]  if args.empty?
+      assert_raise(*args, &@object)
+    end
+
+    def throw(*args)
+      assert_throws(*args, &@object)
+    end
+
+    def nil
+      assert_nil @object
+    end
+    alias be_nil nil
+
+
+    def include(value)
+      msg = build_message(nil, "<?> expected to include ?, but it didn't.",
+                          @object, value)
+      assert_block(msg) { @object.include?(value) }
+    end
+
+    def >(value)
+      assert_operator @object, :>, value
+    end
+
+    def >=(value)
+      assert_operator @object, :>=, value
+    end
+
+    def <(value)
+      assert_operator @object, :<, value
+    end
+
+    def <=(value)
+      assert_operator @object, :<=, value
+    end
+
+    def ===(value)
+      assert_operator @object, :===, value
+    end
+
+    def method_missing(name, *args)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args)  if name == :raise
+      
+      if @object.respond_to?("#{name}?")
+        assert @object.__send__("#{name}?", *args),
+               "#{name}? expected to be true."
+      else
+        super
+      end
+    end
+  end
+
+  class ShouldNot
+    include Test::Unit::Assertions
+
+    def initialize(object)
+      @object = object
+    end
+    
+    def equal(value)
+      assert_not_equal value, @object
+    end
+    alias == equal
+
+    def be(*value)
+      case value.size
+      when 0
+        self
+      when 1
+        assert_not_same value.first, @object
+      else
+        Kernel.raise ArgumentError, "should.be needs zero or one argument"
+      end
+    end
+
+    def match(value)
+      # Icky Regexp check
+      assert_no_match value, @object
+    end
+    alias =~ match
+
+    def _raise(*args)
+      assert_nothing_raised(*args, &@object)
+    end
+
+    def throw
+      assert_nothing_thrown(&@object)
+    end
+
+    def nil
+      assert_not_nil @object
+    end
+    alias be_nil nil 
+
+
+    def not
+      Should.new(@object)
+    end
+
+
+    def method_missing(name, *args)
+      # This will make raise call Kernel.raise, and self.raise call _raise.
+      return _raise(*args)  if name == :raise
+
+      if @object.respond_to?("#{name}?")
+        assert_block("#{name}? expected to be false.") {
+          not @object.__send__("#{name}?", *args)
+        }
+      else
+        super
+      end
+    end
+
+  end
+end
+
+class Test::Spec::TestCase
+  attr_reader :testcase
+  attr_reader :name
+  attr_reader :position
+
+  module InstanceMethods
+    def setup                 # :nodoc:
+      $TEST_SPEC_TESTCASE = self
+      super
+      self.class.setups.each { |s| instance_eval(&s) }
+    end
+    
+    def teardown              # :nodoc:
+      super
+      self.class.teardowns.each { |t| instance_eval(&t) }
+    end
+
+    def initialize(name)
+      super name
+
+      # Don't let the default_test clutter up the results and don't
+      # flunk if no tests given, either.
+      throw :invalid_test  if name == :default_test
+    end
+
+    def position
+      self.class.position
+    end
+
+    def context(*args)
+      raise Test::Spec::DefinitionError,
+        "context definition is not allowed inside a specify-block"
+    end
+  end
+
+  module ClassMethods
+    attr_accessor :count
+    attr_accessor :name
+    attr_accessor :position
+    attr_accessor :parent
+
+    attr_accessor :setups
+    attr_accessor :teardowns
+
+    def context(name, &block)
+      (Test::Spec::CONTEXTS[self.name + "\t" + name] ||=
+       Test::Spec::TestCase.new(name, self)).add(&block)
+    end
+    
+    def specify(specname, &block)
+      raise ArgumentError, "specify needs a block"  if block.nil?
+      
+      self.count += 1                 # Let them run in order of definition
+      
+      define_method("test_spec {%s} %03d [%s]" % [name, count, specname], &block)
+    end
+    
+    def setup(&block)
+      setups << block
+    end
+    
+    def teardown(&block)
+      teardowns << block
+    end
+
+    def init(name, position, parent)
+      self.position = position
+      self.parent = parent
+      
+      if parent
+        self.name = parent.name + "\t" + name
+      else
+        self.name = name
+      end
+
+      self.count = 0
+      self.setups = []
+      self.teardowns = []
+    end
+  end
+
+  @@POSITION = 0
+
+  def initialize(name, parent=nil)
+    @testcase = Class.new(Test::Unit::TestCase) {
+      include InstanceMethods
+      extend ClassMethods
+    }
+
+    @@POSITION = @@POSITION + 1
+    @testcase.init(name, @@POSITION, parent)
+  end
+
+  def add(&block)
+    raise ArgumentError, "context needs a block"  if block.nil?
+
+    @testcase.class_eval(&block)
+    self
+  end
+end
+
+
+# Monkey-patch test/unit to run tests in an optionally specified order.
+module Test::Unit               # :nodoc:
+  class TestSuite               # :nodoc:
+    undef run
+    def run(result, &progress_block)
+      sort!
+      yield(STARTED, name)
+      @tests.each do |test|
+        test.run(result, &progress_block)
+      end
+      yield(FINISHED, name)
+    end
+    
+    def sort!
+      @tests = @tests.sort_by { |test|
+        test.respond_to?(:position) ? test.position : 0
+      }
+    end
+    
+    def position
+      @tests.first.respond_to?(:position) ? @tests.first.position : 0
+    end
+  end
+end
+
+
+# Global helpers
+
+class Object
+  def should
+    Test::Spec::Should.new(self)
+  end
+end
+
+module Kernel
+  def context(name, &block)
+    (Test::Spec::CONTEXTS[name] ||= Test::Spec::TestCase.new(name)).add(&block)
+  end
+
+  private :context
+end