micronaut 0.2.9

data/examples/lib/micronaut/matchers/respond_to_example.rb

@@ -0,0 +1,54 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe "should respond_to(:sym)" do
+  
+  it "should pass if target responds to :sym" do
+    Object.new.should respond_to(:methods)
+  end
+  
+  it "should fail target does not respond to :sym" do
+    lambda {
+      "this string".should respond_to(:some_method)
+    }.should fail_with("expected \"this string\" to respond to :some_method")
+  end
+  
+end
+
+describe "should respond_to(message1, message2)" do
+  
+  it "should pass if target responds to both messages" do
+    Object.new.should respond_to('methods', 'inspect')
+  end
+  
+  it "should fail target does not respond to first message" do
+    lambda {
+      Object.new.should respond_to('method_one', 'inspect')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
+  end
+  
+  it "should fail target does not respond to second message" do
+    lambda {
+      Object.new.should respond_to('inspect', 'method_one')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one"/)
+  end
+  
+  it "should fail target does not respond to either message" do
+    lambda {
+      Object.new.should respond_to('method_one', 'method_two')
+    }.should fail_with(/expected #<Object:.*> to respond to "method_one", "method_two"/)
+  end
+end
+
+describe "should_not respond_to(:sym)" do
+  
+  it "should pass if target does not respond to :sym" do
+    Object.new.should_not respond_to(:some_method)
+  end
+  
+  it "should fail target responds to :sym" do
+    lambda {
+      Object.new.should_not respond_to(:methods)
+    }.should fail_with(/expected #<Object:.*> not to respond to :methods/)
+  end
+  
+end

data/examples/lib/micronaut/matchers/satisfy_example.rb

@@ -0,0 +1,36 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe "should satisfy { block }" do
+  it "should pass if block returns true" do
+    true.should satisfy { |val| val }
+    true.should satisfy do |val|
+      val
+    end
+  end
+
+  it "should fail if block returns false" do
+    lambda {
+      false.should satisfy { |val| val }
+    }.should fail_with("expected false to satisfy block")
+    lambda do
+      false.should satisfy do |val|
+        val
+      end
+    end.should fail_with("expected false to satisfy block")
+  end
+end
+
+describe "should_not satisfy { block }" do
+  it "should pass if block returns false" do
+    false.should_not satisfy { |val| val }
+    false.should_not satisfy do |val|
+      val
+    end
+  end
+
+  it "should fail if block returns true" do
+    lambda {
+      true.should_not satisfy { |val| val }
+    }.should fail_with("expected true not to satisfy block")
+  end
+end

data/examples/lib/micronaut/matchers/simple_matcher_example.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+module Micronaut
+  module Matchers
+    describe SimpleMatcher do
+      it "should pass match arg to block" do
+        actual = nil
+        matcher = simple_matcher("message") do |given| actual = given end
+        matcher.matches?("foo")
+        actual.should == "foo"
+      end
+      
+      it "should provide a stock failure message" do
+        matcher = simple_matcher("thing") do end
+        matcher.matches?("other")
+        matcher.failure_message.should =~ /expected \"thing\" but got \"other\"/
+      end
+      
+      it "should provide a stock negative failure message" do
+        matcher = simple_matcher("thing") do end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should =~ /expected not to get \"thing\", but got \"other\"/
+      end
+      
+      it "should provide the given description" do
+        matcher = simple_matcher("thing") do end
+        matcher.description.should =="thing"
+      end
+      
+      it "should fail if a wrapped 'should' fails" do
+        matcher = simple_matcher("should fail") do
+          2.should == 3
+        end
+        lambda do
+          matcher.matches?("anything").should be_true
+        end.should fail_with(/expected: 3/)
+      end
+    end
+    
+    describe "with arity of 2" do
+      it "should provide the matcher so you can access its messages" do
+        provided_matcher = nil
+        matcher = simple_matcher("thing") do |given, matcher|
+          provided_matcher = matcher
+        end
+        matcher.matches?("anything")
+        provided_matcher.should equal(matcher)
+      end
+      
+      it "should support a custom failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.failure_message.should == "custom message"
+      end
+
+      it "should complain when asked for a failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom negative failure message" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.negative_failure_message = "custom message"
+        end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should == "custom message"
+      end
+      
+      it "should complain when asked for a negative failure message if you don't give it a description or a message" do
+        matcher = simple_matcher do |given, matcher| end
+        matcher.matches?("other")
+        matcher.negative_failure_message.should =~ /No description provided/
+      end
+
+      it "should support a custom description" do
+        matcher = simple_matcher("thing") do |given, matcher|
+          matcher.description = "custom message"
+        end
+        matcher.matches?("description")
+        matcher.description.should == "custom message"
+      end
+
+      it "should tell you no description was provided when it doesn't receive one" do
+        matcher = simple_matcher do end
+        matcher.description.should =~ /No description provided/
+      end
+    end
+    
+  end
+end

data/examples/lib/micronaut/matchers/throw_symbol_example.rb

@@ -0,0 +1,125 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Matchers::ThrowSymbol do
+
+  describe "with no args" do
+
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new
+    end
+
+    it "should match if any Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_true
+    end
+
+    it "should match if any Symbol is thrown with an arg" do
+      @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+    end
+
+    it "should not match if no Symbol is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should provide a failure message" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == "expected a Symbol but nothing was thrown"
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym})
+      @matcher.negative_failure_message.should == "expected no Symbol, got :sym"
+    end
+
+  end
+
+  describe "with a symbol" do
+
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new(:sym) 
+    end
+
+    it "should match if correct Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_true
+    end
+
+    it "should match if correct Symbol is thrown with an arg" do
+      @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+    end
+
+    it "should not match if no Symbol is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should not match if correct Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym }).should be_false
+    end
+
+    it "should provide a failure message when no Symbol is thrown" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == "expected :sym but nothing was thrown"
+    end
+
+    it "should provide a failure message when wrong Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym })
+      @matcher.failure_message.should == "expected :sym, got :other_sym"
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym })
+      @matcher.negative_failure_message.should == "expected :sym not to be thrown"
+    end
+
+    it "should only match NameErrors raised by uncaught throws" do
+      @matcher.matches?(lambda{ sym }).should be_false
+    end
+
+  end
+
+  describe "with a symbol and an arg" do
+    
+    before do
+      @matcher = Micronaut::Matchers::ThrowSymbol.new(:sym, "a") 
+    end
+
+    it "should match if correct Symbol and args are thrown" do
+      @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+    end
+
+    it "should not match if nothing is thrown" do
+      @matcher.matches?(lambda{ }).should be_false
+    end
+
+    it "should not match if other Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+    end
+
+    it "should not match if no arg is thrown" do
+      @matcher.matches?(lambda{ throw :sym }).should be_false
+    end
+
+    it "should not match if wrong arg is thrown" do
+      @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+    end
+
+    it "should provide a failure message when no Symbol is thrown" do
+      @matcher.matches?(lambda{})
+      @matcher.failure_message.should == %q[expected :sym with "a" but nothing was thrown]
+    end
+
+    it "should provide a failure message when wrong Symbol is thrown" do
+      @matcher.matches?(lambda{ throw :other_sym })
+      @matcher.failure_message.should == %q[expected :sym with "a", got :other_sym]
+    end
+
+    it "should provide a negative failure message" do
+      @matcher.matches?(lambda{ throw :sym })
+      @matcher.negative_failure_message.should == %q[expected :sym with "a" not to be thrown]
+    end
+
+    it "should only match NameErrors raised by uncaught throws" do
+      @matcher.matches?(lambda{ sym }).should be_false
+    end
+
+  end
+
+end

data/examples/lib/micronaut/mocha_example.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe "Mocha Regression involving double reporting of errors" do
+  
+  it "should not double report mocha errors" do
+    # The below example should have one error, not two
+    # I'm also not sure how to test this regression without having the failure counting by 
+    # the running Micronaut instance
+    formatter = Micronaut::Formatters::BaseFormatter.new
+
+    use_formatter(formatter) do
+
+      isolate_behaviour do
+        desc = Micronaut::Behaviour.describe("my favorite pony") do
+          example("showing a double fail") do
+            foo = "string"
+            foo.expects(:something)
+          end
+        end      
+        desc.examples_to_run.replace(desc.examples)
+        desc.run(formatter)
+      end
+
+    end
+
+    formatter.examples.size.should == 1  
+  end
+
+end

data/examples/lib/micronaut/runner_example.rb

@@ -0,0 +1,41 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::Runner do
+
+  before do 
+    @runner = Micronaut::Runner.new
+  end
+
+  describe '#configuration' do
+
+    it "should return Micronaut.configuration" do
+      @runner.configuration.should == Micronaut.configuration
+    end
+
+  end
+
+  describe '#formatter' do
+
+    it 'should return the configured formatter' do
+      @runner.formatter.should == Micronaut.configuration.formatter
+    end
+
+  end  
+  
+  describe 'Micronaut::Runner.at_exit' do
+    
+    it 'should set an at_exit hook if none is already set' do
+      Micronaut::Runner.stubs(:installed_at_exit?).returns(false)
+      Micronaut::Runner.expects(:at_exit)
+      Micronaut::Runner.autorun
+    end
+    
+    it 'should not set the at_exit hook if it is already set' do
+      Micronaut::Runner.stubs(:installed_at_exit?).returns(true)
+      Micronaut::Runner.expects(:at_exit).never
+      Micronaut::Runner.autorun
+    end
+    
+  end
+  
+end

data/examples/lib/micronaut/world_example.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+class Bar; end
+class Foo; end
+
+describe Micronaut::World do
+  
+  before do
+    @world = Micronaut::World.new
+    Micronaut.stubs(:world).returns(@world)
+  end
+
+  describe "behaviour groups" do
+
+    it "should contain all defined behaviour groups" do
+      behaviour_group = Micronaut::Behaviour.describe(Bar, 'Empty Behaviour Group') { }
+      @world.behaviours.should include(behaviour_group)       
+    end
+
+  end
+
+  describe "find" do
+
+    before(:all) do
+      options_1 = { :foo => 1, :color => 'blue', :feature => 'reporting' }
+      options_2 = { :pending => true, :feature => 'reporting'  }
+      options_3 = { :array => [1,2,3,4], :color => 'blue', :feature => 'weather status' }      
+      @bg1 = Micronaut::Behaviour.describe(Bar, "find group-1", options_1) { }
+      @bg2 = Micronaut::Behaviour.describe(Bar, "find group-2", options_2) { }
+      @bg3 = Micronaut::Behaviour.describe(Bar, "find group-3", options_3) { }
+      @bg4 = Micronaut::Behaviour.describe(Foo, "find these examples") do
+        it('I have no options') {}
+        it("this is awesome", :awesome => true) {}
+        it("this is too", :awesome => true) {}
+        it("not so awesome", :awesome => false) {}
+        it("I also have no options") {}
+      end
+      @behaviours = [@bg1, @bg2, @bg3, @bg4]
+    end
+    
+    after(:all) do
+      Micronaut.world.behaviours.delete(@bg1)
+      Micronaut.world.behaviours.delete(@bg2)
+      Micronaut.world.behaviours.delete(@bg3)
+      Micronaut.world.behaviours.delete(@bg4)
+    end
+
+    it "should find awesome examples" do
+      @world.find(@bg4.examples, :awesome => true).should == [@bg4.examples[1], @bg4.examples[2]]
+    end
+    
+    it "should find no groups when given no search parameters" do
+      @world.find([]).should == []
+    end
+  
+    it "should find three groups when searching for :behaviour_describes => Bar" do
+      @world.find(@behaviours, :behaviour => { :describes => Bar }).should == [@bg1, @bg2, @bg3]
+    end
+    
+    it "should find one group when searching for :description => 'find group-1'" do
+      @world.find(@behaviours, :behaviour => { :description => 'find group-1' }).should == [@bg1]
+    end
+    
+    it "should find two groups when searching for :description => lambda { |v| v.include?('-1') || v.include?('-3') }" do
+      @world.find(@behaviours, :behaviour => { :description => lambda { |v| v.include?('-1') || v.include?('-3') } }).should == [@bg1, @bg3]
+    end
+    
+    it "should find three groups when searching for :description => /find group/" do
+      @world.find(@behaviours, :behaviour => { :description => /find group/ }).should == [@bg1, @bg2, @bg3]
+    end
+    
+    it "should find one group when searching for :foo => 1" do
+      @world.find(@behaviours, :foo => 1 ).should == [@bg1]
+    end
+    
+    it "should find one group when searching for :pending => true" do
+      @world.find(@behaviours, :pending => true ).should == [@bg2]
+    end
+
+    it "should find one group when searching for :array => [1,2,3,4]" do
+      @world.find(@behaviours, :array => [1,2,3,4]).should == [@bg3]
+    end
+
+    it "should find no group when searching for :array => [4,3,2,1]" do
+      @world.find(@behaviours, :array => [4,3,2,1]).should be_empty
+    end    
+
+    it "should find two groups when searching for :color => 'blue'" do
+      @world.find(@behaviours, :color => 'blue').should == [@bg1, @bg3]
+    end
+
+    it "should find two groups when searching for :feature => 'reporting' }" do
+      @world.find(@behaviours, :feature => 'reporting').should == [@bg1, @bg2]
+    end
+
+  end
+
+end