micronaut 0.2.9

data/examples/lib/micronaut/configuration_example.rb

@@ -0,0 +1,133 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::Configuration do
+
+  describe "#mock_with" do
+
+    it "should require and include the mocha adapter when called with :mocha" do
+      Micronaut.configuration.expects(:require).with('micronaut/mocking/with_mocha')
+      Micronaut::Behaviour.expects(:send)
+      Micronaut.configuration.mock_with :mocha
+    end
+
+    it "should include the null adapter for nil" do
+      Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithAbsolutelyNothing)
+      Micronaut.configuration.mock_with nil
+    end
+    
+    # if the below example doesn't pass, @behaviour_instance._setup_mocks and similiar calls fail without a mock library specified
+    # this is really a case where cucumber would be a better fit to catch these type of regressions
+    it "should include the null adapter by default, if no mocking library is specified" do
+      Micronaut::Behaviour.expects(:send).with(:include, Micronaut::Mocking::WithAbsolutelyNothing)
+      config = Micronaut::Configuration.new
+    end
+    
+  end  
+ 
+  describe "#include" do
+
+    module InstanceLevelMethods
+      def you_call_this_a_blt?
+        "egad man, where's the mayo?!?!?"
+      end
+    end
+
+    it "should include the given module into each matching behaviour" do
+      Micronaut.configuration.include(InstanceLevelMethods, :magic_key => :include)
+      group = Micronaut::Behaviour.describe(Object, 'does like, stuff and junk', :magic_key => :include) { }
+      group.should_not respond_to(:you_call_this_a_blt?)
+      remove_last_describe_from_world
+
+      group.new.you_call_this_a_blt?.should == "egad man, where's the mayo?!?!?"
+    end
+
+  end
+
+  describe "#extend" do
+
+    module ThatThingISentYou
+
+      def that_thing
+      end
+
+    end
+
+    it "should extend the given module into each matching behaviour" do
+      Micronaut.configuration.extend(ThatThingISentYou, :magic_key => :extend)      
+      group = Micronaut::Behaviour.describe(ThatThingISentYou, :magic_key => :extend) { }
+      
+      group.should respond_to(:that_thing)
+      remove_last_describe_from_world
+    end
+
+  end
+
+  describe "#run_all_when_everything_filtered" do
+
+    it "defaults to true" do
+      Micronaut::Configuration.new.run_all_when_everything_filtered.should == true
+    end
+
+    it "can be queried with question method" do
+      config = Micronaut::Configuration.new
+      config.run_all_when_everything_filtered = false
+      config.run_all_when_everything_filtered?.should == false
+    end
+  end
+  
+  describe '#trace?' do
+    
+    it "is false by default" do
+      Micronaut::Configuration.new.trace?.should == false
+    end
+    
+    it "is true if configuration.trace is true" do
+      config = Micronaut::Configuration.new
+      config.trace = true
+      config.trace?.should == true
+    end
+    
+  end
+  
+  describe '#trace' do
+    
+    it "requires a block" do
+      config = Micronaut::Configuration.new
+      config.trace = true
+      lambda { config.trace(true) }.should raise_error(ArgumentError)
+    end
+    
+    it "does nothing if trace is false" do
+      config = Micronaut::Configuration.new
+      config.trace = false
+      config.expects(:puts).with("my trace string is awesome").never
+      config.trace { "my trace string is awesome" }
+    end
+    
+    it "allows overriding tracing an optional param" do
+      config = Micronaut::Configuration.new
+      config.trace = false
+      config.expects(:puts).with(includes("my trace string is awesome"))
+      config.trace(true) { "my trace string is awesome" }
+    end
+       
+  end
+  
+  describe '#formatter' do
+
+    it "sets formatter_to_use based on name" do
+      config = Micronaut::Configuration.new
+      config.formatter = :documentation
+      config.instance_eval { @formatter_to_use.should == Micronaut::Formatters::DocumentationFormatter }
+      config.formatter = 'documentation'
+      config.instance_eval { @formatter_to_use.should == Micronaut::Formatters::DocumentationFormatter }
+    end
+    
+    it "raises ArgumentError if formatter is unknown" do
+      config = Micronaut::Configuration.new
+      lambda { config.formatter = :progresss }.should raise_error(ArgumentError)
+    end
+    
+  end
+
+end

data/examples/lib/micronaut/example_example.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+describe Micronaut::Example, :parent_metadata => 'sample' do
+
+  before do
+    behaviour = stub('behaviour', :metadata => { :behaviour => { :name => 'behaviour_name' }})
+    @example = Micronaut::Example.new(behaviour, 'description', {}, (lambda {}))
+  end
+    
+  describe "attr readers" do
+  
+    it "should have one for the parent behaviour" do
+      @example.should respond_to(:behaviour)
+    end
+  
+    it "should have one for it's description" do
+      @example.should respond_to(:description)
+    end
+  
+    it "should have one for it's metadata" do
+      @example.should respond_to(:metadata)
+    end
+  
+    it "should have one for it's block" do
+      @example.should respond_to(:example_block)
+    end
+  
+  end
+  
+  describe '#inspect' do
+    
+    it "should return 'behaviour_name - description'" do
+      @example.inspect.should == 'behaviour_name - description'
+    end
+    
+  end
+  
+  describe '#to_s' do
+    
+    it "should return #inspect" do
+      @example.to_s.should == @example.inspect
+    end
+    
+  end
+  
+  describe "accessing metadata within a running example" do
+  
+    it "should have a reference to itself when running" do
+      running_example.description.should == "should have a reference to itself when running"
+    end
+  
+    it "should be able to access the behaviours top level metadata as if it were its own" do
+      running_example.behaviour.metadata.should include(:parent_metadata => 'sample')
+      running_example.metadata.should include(:parent_metadata => 'sample')
+    end
+  
+  end
+  
+  describe "#run" do
+    
+    pending "should run after(:each) when the example fails"
+  
+    pending "should run after(:each) when the example raises an Exception" 
+    
+  end
+  
+end

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

@@ -0,0 +1,146 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../../example_helper")
+
+describe Object do
+
+  describe "#should" do
+
+    before 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 "#should_not" do
+
+    before 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
+  
+  module ExampleExpectations
+
+    class ArbitraryMatcher
+      def initialize(*args, &block)
+        if args.last.is_a? Hash
+          @expected = args.last[:expected]
+        end
+        if block_given?
+          @expected = block.call
+        end
+        @block = block
+      end
+
+      def matches?(target)
+        @target = target
+        return @expected == target
+      end
+
+      def with(new_value)
+        @expected = new_value
+        self
+      end
+
+      def failure_message
+        "expected #{@expected}, got #{@target}"
+      end
+
+      def negative_failure_message
+        "expected not #{@expected}, got #{@target}"
+      end
+    end
+
+    class PositiveOnlyMatcher < ArbitraryMatcher
+      undef negative_failure_message rescue nil
+    end
+
+    def arbitrary_matcher(*args, &block)
+      ArbitraryMatcher.new(*args, &block)
+    end
+
+    def positive_only_matcher(*args, &block)
+      PositiveOnlyMatcher.new(*args, &block)
+    end
+
+  end
+
+  describe "should and should not matcher handling" do
+    include ExampleExpectations
+
+    it "should handle submitted args" do
+      5.should arbitrary_matcher(:expected => 5)
+      5.should arbitrary_matcher(:expected => "wrong").with(5)
+      lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+      lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+      5.should_not arbitrary_matcher(:expected => 4)
+      5.should_not arbitrary_matcher(:expected => 5).with(4)
+      lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+      lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+    end
+
+    it "should handle the submitted block" do
+      5.should arbitrary_matcher { 5 }
+      5.should arbitrary_matcher(:expected => 4) { 5 }
+      5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+    end
+
+    it "should explain when matcher does not support should_not" do
+      lambda {
+        5.should_not positive_only_matcher(:expected => 5)
+      }.should fail_with(/Matcher does not support should_not.\n/)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Expectations do
+
+  describe "#fail_with" do
+  
+    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
+
+  end
+
+end

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

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Matchers, '#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

data/examples/lib/micronaut/formatters/base_formatter_example.rb

@@ -0,0 +1,117 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Formatters::BaseFormatter do
+  
+  before do
+    @formatter = Micronaut::Formatters::BaseFormatter.new 
+  end
+
+  class HaveInterfaceMatcher
+    def initialize(method)
+      @method = method
+    end
+
+    attr_reader :object
+    attr_reader :method
+
+    def matches?(object)
+      @object = object
+      object.respond_to?(@method)
+    end
+
+    def with(arity)
+      WithArity.new(self, @method, arity)
+    end
+
+    class WithArity
+      def initialize(matcher, method, arity)
+        @have_matcher = matcher
+        @method = method
+        @arity  = arity
+      end
+
+      def matches?(an_object)
+        @have_matcher.matches?(an_object) && real_arity == @arity
+      end
+
+      def failure_message
+        "#{@have_matcher} should have method :#{@method} with #{argument_arity}, but it had #{real_arity}"
+      end
+
+      def arguments
+        self
+      end
+
+      alias_method :argument, :arguments
+
+      private
+
+      def real_arity
+        @have_matcher.object.method(@method).arity
+      end
+
+      def argument_arity
+        if @arity == 1
+          "1 argument"
+        else
+          "#{@arity} arguments"
+        end
+      end
+    end
+  end
+
+  def have_interface_for(method)
+    HaveInterfaceMatcher.new(method)
+  end
+
+  it "should have start as an interface with one argument" do
+    @formatter.should have_interface_for(:start).with(1).argument
+  end
+
+  it "should have add_behaviour as an interface with one argument" do
+    @formatter.should have_interface_for(:add_behaviour).with(1).argument
+  end
+
+  it "should have example_finished as an interface with one argument" do
+    @formatter.should have_interface_for(:example_finished).with(1).arguments
+  end
+
+  it "should have start_dump as an interface with 1 arguments" do
+    @formatter.should have_interface_for(:start_dump).with(1).arguments
+  end
+
+  it "should have dump_failures as an interface with no arguments" do
+    @formatter.should have_interface_for(:dump_failures).with(0).arguments
+  end
+
+  it "should have dump_summary as an interface with zero arguments" do
+    @formatter.should have_interface_for(:dump_summary).with(0).arguments
+  end
+
+  it "should have dump_pending as an interface with zero arguments" do
+    @formatter.should have_interface_for(:dump_pending).with(0).arguments
+  end
+
+  it "should have close as an interface with zero arguments" do
+    @formatter.should have_interface_for(:close).with(0).arguments
+  end
+  
+  describe '#format_backtrace' do
+    
+    before do
+      @full_backtrace = ["examples/lib/micronaut/formatters/base_formatter_example.rb:118", "vendor/rails/x.rb:1", "/bin/micronaut"]
+    end
+
+    it "should display the full backtrace when the example is given the :full_backtrace => true option", :full_backtrace => true do
+      running_example.metadata[:full_backtrace].should be_true
+      @formatter.format_backtrace(@full_backtrace, running_example).should ==  @full_backtrace
+    end
+
+    it "should clean the backtrace when the full_backtrace option is not given" do
+      running_example.metadata[:full_backtrace].should be_nil
+      @formatter.format_backtrace(@full_backtrace, running_example).should ==  ["examples/lib/micronaut/formatters/base_formatter_example.rb:118"]
+    end
+    
+  end
+  
+end