spicycode-micronaut 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Chad Humphries
+
+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

@@ -0,0 +1,17 @@
+= Micronaut
+
+* http://github.com/spicycode/micronaut
+
+== DESCRIPTION:
+
+Micronaut is an ultra light-weight BDD test framework.   For the moment think of it is a prototype of
+RSpec lite.  Definitely pre alpha at the moment.
+
+== REQUIREMENTS:
+
++ Ruby 1.8
+
+== CREDITS:
+
+* Mini/Unit for the great ideas and runner
+* RSpec for the great ideas and matchers

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+GEM = "micronaut"
+GEM_VERSION = "0.0.2"
+AUTHOR = "Chad Humphries"
+EMAIL = "chad@spicycode.com"
+HOMEPAGE = "http://spicycode.com"
+SUMMARY = "An excellent replacement for the wheel..."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  
+  # Uncomment this to add a dependency
+  s.add_dependency "mocha"
+  
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{lib,examples}/**/*")
+end
+
+desc "Run all examples"
+task :default do
+  examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
+  examples.map! {|f| %Q(require "#{f}")}
+  command = "-e '#{examples.join("; ")}'"
+  ruby command
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/examples/example_helper.rb

@@ -0,0 +1,19 @@
+lib_path = File.expand_path(File.dirname(__FILE__) + "/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'micronaut'
+
+
+module Micronaut  
+  module Matchers
+    def fail
+      raise_error(::Micronaut::Exceptions::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(::Micronaut::Exceptions::ExpectationNotMetError, message)
+    end
+  end
+end
+
+Micronaut::ExampleRunner.autorun

data/examples/lib/micronaut/example_group_example.rb

@@ -0,0 +1,116 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::ExampleGroup do
+  class Foo; end
+  
+  def scenario_1
+    example_group = Micronaut::ExampleGroup.new(Foo, "Scenario 1")
+    example_group.it("should do 1 thing") { 1 } 
+    example_group.it("should do 2 thing") { 2 } 
+    example_group.it("should do 3 thing") { 3 } 
+    example_group
+  end
+
+  def scenario_2
+    example_group = Micronaut::ExampleGroup.new(Foo, "Scenario 2")
+    example_group.before { 'beforeeach1' }
+    example_group.before { 'beforeeach2' }
+    example_group.before(:all) { 'beforeall1' }
+    example_group.before(:all) { 'beforeall2' }
+    example_group
+  end
+
+  def scenario_3
+    example_group = Micronaut::ExampleGroup.new(Foo, "Scenario 3")
+    example_group.after { 'aftereach1' }
+    example_group.after { 'aftereach2' }
+    example_group.after(:all) { 'afterall1' }
+    example_group.after(:all) { 'afterall2' }
+    example_group
+  end
+
+  it "should make the first parameter the name by calling to_s on it" do
+    scenario_1.name.should == 'Foo'
+  end
+
+  it "should make the second parameter the description" do
+    scenario_1.description.should == 'Scenario 1'
+  end
+
+  it "scenario 1 should have 3 examples" do
+    scenario_1.should have(3).examples
+  end
+
+  it "scenario 1 should maintain the example order" do
+    example_group = scenario_1
+    example_group.examples[0].first.should == 'should do 1 thing'
+    example_group.examples[1].first.should == 'should do 2 thing'
+    example_group.examples[2].first.should == 'should do 3 thing'
+  end
+
+  it "scenario 1 should allow you to call it's examples" do
+    example_group = scenario_1
+    example_group.examples[0].last.call.should == 1
+    example_group.examples[1].last.call.should == 2
+    example_group.examples[2].last.call.should == 3
+  end
+
+  it "scenario 2 should have 2 before each parts" do
+    scenario_2.should have(2).before_each_parts
+  end
+
+  it "scenario 2 should have 2 before all parts" do
+    scenario_2.should have(2).before_all_parts
+  end
+
+  it "scenario 2 should maintain the before parts order" do
+    example_group = scenario_2
+    example_group.before_all_parts[0].call.should == 'beforeall1'
+    example_group.before_all_parts[1].call.should == 'beforeall2'
+    example_group.before_each_parts[0].call.should == 'beforeeach1'
+    example_group.before_each_parts[1].call.should == 'beforeeach2'
+  end
+
+  it "scenario 3 should have 2 after each parts" do
+    scenario_3.should have(2).after_each_parts
+  end
+
+  it "scenario 3 should have 2 after all parts" do
+    scenario_3.should have(2).after_all_parts
+  end
+
+  it "scenario 3 should maintain the after parts order" do
+    example_group = scenario_3
+    example_group.after_all_parts[0].call.should == 'afterall1'
+    example_group.after_all_parts[1].call.should == 'afterall2'
+    example_group.after_each_parts[0].call.should == 'aftereach1'
+    example_group.after_each_parts[1].call.should == 'aftereach2'
+  end
+
+  def scenario_4
+    example_group = Micronaut::ExampleGroup.new(Foo, "Scenario 4")
+    example_group
+  end
+
+  it "scenario 4 should run the before all blocks, before each blocks, the example, the after each blocks, and finally the after all blocks" do
+    example_group = scenario_4
+    example_group.before(:all) { 'before_all_1' }
+    example_group.before(:all) { 'before_all_2' }
+    example_group.before { "before_each_1"; @foo = 2 }
+    example_group.before { "before_each_2"; @foo += 1 }
+    example_group.before { "before_each_3"; @foo += 2 }
+    example_group.after { "after_each_1"; @foo = 3 }
+    example_group.after { "after_each_2"; 'final after each' }
+    example_group.after(:all) { 'after_all_1' }
+    example_group.after(:all) { 'after_all_2' }
+
+    example_group.it("prints out the value of the @foo variable") do
+      @foo.should == 5
+    end
+    example_group.it("other example") do
+
+    end
+    example_group.run
+  end
+
+end

data/examples/lib/micronaut/example_runner_example.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::ExampleRunner do
+
+end

data/examples/lib/micronaut/expectations/differs/default_example.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../../example_helper")
+require 'micronaut/expectations/differs/default'
+
+module Micronaut
+  module Fixtures
+    class Animal
+      def initialize(name,species)
+        @name,@species = name,species
+      end
+
+      def inspect
+        <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+        EOA
+      end
+    end
+  end
+end
+
+describe "Diff" do
+
+  before do
+    @differ = Micronaut::Expectations::Differs::Default.new(:unified)
+  end
+
+  it "should output unified diff of two strings" do
+    expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+    actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+    expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+    diff = @differ.diff_as_string(expected, actual)
+    diff.should eql(expected_diff)
+  end
+
+  it "should output unified diff message of two arrays" do
+    expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+    actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+    expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+
+  it "should output unified diff message of two objects" do
+    expected = Micronaut::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Micronaut::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+
+end
+
+
+describe "Diff in context format" do
+  before(:each) do
+    @differ = Micronaut::Expectations::Differs::Default.new(:context)
+  end
+
+  it "should output unified diff message of two objects" do
+    expected = Micronaut::Fixtures::Animal.new "bob", "giraffe"
+    actual   = Micronaut::Fixtures::Animal.new "bob", "tortoise"
+
+    expected_diff = <<'EOD'
+
+***************
+*** 1,5 ****
+  <Animal
+    name=bob,
+!   species=tortoise
+  >
+--- 1,5 ----
+  <Animal
+    name=bob,
+!   species=giraffe
+  >
+EOD
+
+    diff = @differ.diff_as_object(expected,actual)
+    diff.should == expected_diff
+  end
+end

data/examples/lib/micronaut/expectations/extensions/object_example.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../../example_helper")
+
+describe Object, "#should" do
+  
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stubs(:matches?).returns(true)
+    @matcher.stubs(:failure_message)
+  end
+  
+  it "should accept and interact with a matcher" do
+    @matcher.expects(:matches?).with(@target).returns(true)    
+    @target.should @matcher
+  end
+  
+  it "should ask for a failure_message when matches? returns false" do
+    @matcher.expects(:matches?).with(@target).returns(false)
+    @matcher.expects(:failure_message).returns("the failure message")
+    
+    lambda { @target.should @matcher }.should fail_with("the failure message")
+  end
+  
+  it "should raise error if it receives false directly" do
+    lambda { @target.should false }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+  it "should raise error if it receives false (evaluated)" do
+    lambda { @target.should eql?("foo") }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+  it "should raise error if it receives true" do
+    lambda { @target.should true }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+end
+
+describe Object, "#should_not" do
+  
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+  
+  it "should accept and interact with a matcher" do
+    @matcher.expects(:matches?).with(@target).returns(false)
+    @matcher.stubs(:negative_failure_message)
+    
+    @target.should_not @matcher
+  end
+  
+  it "should ask for a negative_failure_message when matches? returns true" do
+    @matcher.expects(:matches?).with(@target).returns(true)
+    @matcher.expects(:negative_failure_message).returns("the negative failure message")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the negative failure message")
+  end
+
+  it "should raise error if it receives false directly" do
+    lambda {
+      @target.should_not false
+    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+  it "should raise error if it receives false (evaluated)" do
+    lambda {
+      @target.should_not eql?("foo")
+    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+  it "should raise error if it receives true" do
+    lambda {
+      @target.should_not true
+    }.should raise_error(Micronaut::Expectations::InvalidMatcherError)
+  end
+  
+end

data/examples/lib/micronaut/expectations/fail_with_example.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Expectations, "#fail_with with no diff" do
+  before(:each) do
+    @old_differ = Micronaut::Expectations.differ
+    Micronaut::Expectations.differ = nil
+  end
+  
+  it "should handle just a message" do
+    lambda {
+      Micronaut::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+  
+  it "should handle an Array" do
+    lambda {
+      Micronaut::Expectations.fail_with ["the message","expected","actual"]
+    }.should fail_with("the message")
+  end
+
+  after(:each) do
+    Micronaut::Expectations.differ = @old_differ
+  end
+end
+
+describe Micronaut::Expectations, "#fail_with with diff" do
+  before(:each) do
+    @old_differ = Micronaut::Expectations.differ
+    @differ = mock("differ")
+    Micronaut::Expectations.differ = @differ
+  end
+  
+  it "should not call differ if no expected/actual" do
+    lambda {
+      Micronaut::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+  
+  it "should call differ if expected/actual are presented separately" do
+    @differ.expects(:diff_as_string).returns("diff")
+    lambda {
+      Micronaut::Expectations.fail_with "the message", "expected", "actual"
+    }.should fail_with("the message\nDiff:diff")
+  end
+  
+  it "should call differ if expected/actual are not strings" do
+    @differ.expects(:diff_as_object).returns("diff")
+    lambda {
+      Micronaut::Expectations.fail_with "the message", :expected, :actual
+    }.should fail_with("the message\nDiff:diff")
+  end
+  
+  it "should not call differ if expected or actual are procs" do
+    @differ.expects(:diff_as_string).never
+    @differ.expects(:diff_as_object).never
+    lambda {
+      Micronaut::Expectations.fail_with "the message", lambda {}, lambda {}
+    }.should fail_with("the message")
+  end
+  
+  it "should call differ if expected/actual are presented in an Array with message" do
+    @differ.expects(:diff_as_string).with("actual","expected").returns("diff")
+    lambda {
+      Micronaut::Expectations.fail_with(["the message", "expected", "actual"])
+    }.should fail_with(/the message\nDiff:diff/)
+  end
+  
+  after(:each) do
+    Micronaut::Expectations.differ = @old_differ
+  end
+end

data/examples/lib/micronaut/expectations/wrap_expectation_example.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+module Micronaut
+  module Matchers
+    describe "wrap_expectation" do
+      
+      def stub_matcher
+        @_stub_matcher ||= simple_matcher do
+        end
+      end
+      
+      def failing_matcher
+        @_failing_matcher ||= simple_matcher do
+          1.should == 2
+        end
+      end
+      
+      it "should return true if there is no error" do
+        wrap_expectation stub_matcher do
+        end.should be_true
+      end
+      
+      it "should return false if there is an error" do
+        wrap_expectation failing_matcher do
+          raise "error"
+        end.should be_false
+      end
+    end
+  end
+end

data/examples/lib/micronaut_example.rb

@@ -0,0 +1,8 @@
+require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
+
+describe Micronaut do
+  
+  it "should allow pending examples by not supplying a block"
+
+  
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "micronaut" if File.directory?('examples')
+end

data/lib/autotest/micronaut.rb

@@ -0,0 +1,43 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^examples/.*_example.rb$%) { |filename, _| 
+    filename 
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| 
+    ["examples/#{m[1]}_example.rb"]
+  }
+  at.add_mapping(%r%^examples/(examples_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^examples/.*_example\.rb$%
+  }
+end
+
+class MicronautCommandError < StandardError; end
+
+class Autotest::Micronaut < Autotest
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+  
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*example\.rb):[\d]+:\Z?/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return '' if files_to_test.empty?
+    return "#{ruby} -S #{files_to_test.keys.flatten.join(' ')}"
+  end
+  
+end