rsanheim-micronaut 0.1.3.2

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,96 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+module Micronaut
+  module Matchers
+    describe ThrowSymbol do
+      describe "with no args" do
+        before { @matcher = ThrowSymbol.new }
+      
+        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 { @matcher = ThrowSymbol.new(:sym) }
+      
+        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 { @matcher = ThrowSymbol.new(:sym, "a") }
+    
+        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
+  end
+end

data/examples/lib/micronaut/runner_example.rb

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

data/examples/lib/micronaut/runner_options_example.rb

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

data/examples/lib/micronaut/world_example.rb

@@ -0,0 +1,102 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../example_helper")
+
+class Bar; end
+
+describe Micronaut::World do
+
+  describe "behaviour groups" do
+
+    it "should contain all defined behaviour groups" do
+      behaviour_group = Micronaut::Behaviour.describe(Bar, 'Empty Behaviour Group') { }
+      Micronaut::World.behaviours.should include(behaviour_group)       
+      remove_last_describe_from_world
+    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) { }
+      @behaviours = [@bg1, @bg2, @bg3]
+    end
+
+    after(:all) do
+      Micronaut::World.behaviours.delete(@bg1)
+      Micronaut::World.behaviours.delete(@bg2)
+      Micronaut::World.behaviours.delete(@bg3)
+    end
+    
+    it "should find no groups when given no search parameters" do
+      Micronaut::World.find([]).should == []
+    end
+  
+    it "should find three groups when searching for :described_type => Bar" do
+      Micronaut::World.find(@behaviours, :described_type => Bar).should == [@bg1, @bg2, @bg3]
+    end
+    
+    it "should find one group when searching for :description => 'find group-1'" do
+      Micronaut::World.find(@behaviours, :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
+      Micronaut::World.find(@behaviours, :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
+      Micronaut::World.find(@behaviours, :description => /find group/).should == [@bg1, @bg2, @bg3]
+    end
+    
+    it "should find one group when searching for :options => { :foo => 1 }" do
+      Micronaut::World.find(@behaviours, :options => { :foo => 1 }).should == [@bg1]
+    end
+    
+    it "should find one group when searching for :options => { :pending => true }" do
+      Micronaut::World.find(@behaviours, :options => { :pending => true }).should == [@bg2]
+    end
+
+    it "should find one group when searching for :options => { :array => [1,2,3,4] }" do
+      Micronaut::World.find(@behaviours, :options => { :array => [1,2,3,4] }).should == [@bg3]
+    end
+
+    it "should find no group when searching for :options => { :array => [4,3,2,1] }" do
+      Micronaut::World.find(@behaviours, :options => { :array => [4,3,2,1] }).should be_empty
+    end    
+
+    it "should find two groups when searching for :options => { :color => 'blue' }" do
+      Micronaut::World.find(@behaviours, :options => { :color => 'blue' }).should == [@bg1, @bg3]
+    end
+
+    it "should find two groups when searching for :options => { :feature => 'reporting' }" do
+      Micronaut::World.find(@behaviours, :options => { :feature => 'reporting' }).should == [@bg1, @bg2]
+    end
+
+  end
+
+  describe "reset" do
+
+    it "should clear the list of behaviour groups" do
+      original_groups = Micronaut::World.behaviours
+
+      Micronaut::World.behaviours.should_not be_empty
+      Micronaut::World.reset
+      Micronaut::World.behaviours.should be_empty
+
+      Micronaut::World.behaviours.concat(original_groups)
+    end
+
+  end
+  
+  describe "filter_behaviours_to_run" do
+    
+    it "does nothing if there are no filters"
+      # how do you spec this kind of behavior?  It feels like we need to be able to create new instances of Micronaut to properly spec 
+      # this kind of thing, so we can mock/stub or interrogate state without affecting the actual running instance.
+  end
+
+end

data/examples/lib/micronaut_example.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
+
+describe Micronaut do
+
+  describe "configuration" do
+    
+    it "should return an instance of Micronaut::Configuration" do
+      Micronaut.configuration.should be_an_instance_of(Micronaut::Configuration)
+    end
+    
+  end
+  
+  describe "configure" do
+    
+    it "should yield the current configuration" do
+      Micronaut.configure do |config|
+        config.should == Micronaut.configuration
+      end
+    end
+    
+  end
+  
+end

data/examples/resources/example_classes.rb

@@ -0,0 +1,67 @@
+# This file contains various classes used by the specs.
+module Micronaut
+  module Expectations
+    class Person
+      attr_reader :name
+      def initialize name
+        @name = name
+      end
+      def == other
+        return @name == other.name
+      end
+    end
+    
+    class ClassWithMultiWordPredicate
+      def multi_word_predicate?
+        true 
+      end
+    end
+
+    module Helper
+      class CollectionWithSizeMethod
+        def initialize; @list = []; end
+        def size; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithLengthMethod
+        def initialize; @list = []; end
+        def length; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionOwner
+        attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method
+
+        def initialize
+          @items_in_collection_with_size_method = CollectionWithSizeMethod.new
+          @items_in_collection_with_length_method = CollectionWithLengthMethod.new
+        end
+
+        def add_to_collection_with_size_method(item)
+          @items_in_collection_with_size_method.push(item)
+        end
+
+        def add_to_collection_with_length_method(item)
+          @items_in_collection_with_length_method.push(item)
+        end
+        
+        def items_for(arg)
+          return [1, 2, 3] if arg == 'a'
+          [1]
+        end
+        
+        def items
+          @items_in_collection_with_size_method
+        end
+      end
+
+      class ClassWithUnqueriedPredicate
+        attr_accessor :foo
+        def initialize(foo)
+          @foo = foo
+        end
+      end
+    end
+  end
+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,47 @@
+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$%) { |filename, m| 
+    ["examples/lib/#{m[1]}_example.rb"]
+  }
+  at.add_mapping(%r%^examples/(example_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?
+    
+    examples = files_to_test.keys.flatten
+    
+
+    "#{ruby} #{examples.join(" ")}"
+  end
+  
+end

data/lib/micronaut/behaviour.rb

@@ -0,0 +1,211 @@
+module Micronaut
+  class Behaviour
+    include Micronaut::Matchers 
+
+    def self.inherited(klass)
+      super
+      Micronaut::World.behaviours << klass
+    end
+    
+    def self.extended_modules #:nodoc:
+      ancestors = class << self; ancestors end
+      ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+    end
+
+    def self.befores
+      @_befores ||= { :all => [], :each => [] }
+    end
+
+    def self.before_eachs
+      befores[:each]
+    end
+
+    def self.before_alls
+      befores[:all]
+    end
+
+    def self.before(type=:each, options={}, &block)
+      befores[type] << [options, block]
+    end
+
+    def self.afters
+      @_afters ||= { :all => [], :each => [] }
+    end
+
+    def self.after_eachs
+      afters[:each]
+    end
+
+    def self.after_alls
+      afters[:all]
+    end
+
+    def self.after(type=:each, options={}, &block)
+      afters[type] << [options, block]
+    end
+
+    def self.it(desc=nil, options={}, &block)
+      examples << Micronaut::Example.new(self, desc, options, block)
+    end
+    
+    def self.focused(desc=nil, options={}, &block)
+      it(desc, options.update(:focused => true), &block)
+    end
+
+    def self.examples
+      @_examples ||= []
+    end
+    
+    def self.examples_to_run
+      @_examples_to_run ||= []
+    end
+
+    def self.set_it_up(*args)
+      metadata[:options] = args.last.is_a?(Hash) ? args.pop : {}
+      metadata[:described_type] = args.first.is_a?(String) ? self.superclass.described_type : args.shift
+      metadata[:description] = args.shift || ''
+      metadata[:name] = "#{metadata[:described_type]} #{metadata[:description]}".strip
+      
+      Micronaut.configuration.find_modules(self).each do |include_or_extend, mod, opts|
+        if include_or_extend == :extend
+          send(:extend, mod) unless extended_modules.include?(mod)
+        else
+          send(:include, mod) unless included_modules.include?(mod)
+        end
+      end
+    end
+
+    def self.metadata
+      @_metadata ||= {}
+    end
+
+    def self.name
+      metadata[:name]
+    end
+
+    def self.described_type
+      metadata[:described_type]
+    end
+
+    def self.description
+      metadata[:description]
+    end
+
+    def self.options
+      metadata[:options]
+    end
+
+    def self.describe(*args, &describe_block)
+      raise ArgumentError if args.empty? || describe_block.nil?
+      subclass('NestedLevel') do
+        set_it_up(*args)
+        module_eval(&describe_block)
+      end
+    end
+
+    def self.ancestors(superclass_last=false)
+      classes = []
+      current_class = self
+
+      while current_class < Micronaut::Behaviour
+        superclass_last ? classes << current_class : classes.unshift(current_class)
+        current_class = current_class.superclass
+      end
+      
+      classes
+    end
+    
+    def self.before_ancestors
+      @_before_ancestors ||= ancestors 
+    end
+    
+    def self.after_ancestors
+      @_after_ancestors ||= ancestors(true)
+    end
+
+    def self.eval_before_alls(example)
+      Micronaut.configuration.find_before_or_after(:before, :all, self).each { |blk| example.instance_eval(&blk) }
+      
+      before_ancestors.each do |ancestor| 
+        ancestor.before_alls.each { |opts, blk| example.instance_eval(&blk) }
+      end
+    end
+        
+    def self.eval_before_eachs(example)
+      Micronaut.configuration.find_before_or_after(:before, :each, self).each { |blk| example.instance_eval(&blk) }
+      
+      before_ancestors.each do |ancestor| 
+        ancestor.before_eachs.each { |opts, blk| example.instance_eval(&blk) }
+      end
+    end
+
+    def self.eval_after_alls(example)
+      Micronaut.configuration.find_before_or_after(:after, :all, self).each { |blk| example.instance_eval(&blk) }
+            
+      after_ancestors.each do |ancestor| 
+        ancestor.after_alls.each { |opts, blk| example.instance_eval(&blk) }
+      end
+    end
+
+    def self.eval_after_eachs(example)
+      Micronaut.configuration.find_before_or_after(:after, :each, self).each { |blk| example.instance_eval(&blk) }
+      
+      after_ancestors.each do |ancestor|
+        ancestor.after_eachs.each { |opts, blk| example.instance_eval(&blk) }
+      end
+    end
+
+    def self.run(reporter)
+      return true if examples_to_run.empty?
+
+      reporter.add_behaviour(self)
+      
+      group = new
+      eval_before_alls(group)
+      success = true
+
+      examples_to_run.each do |ex|
+        reporter.example_started(ex)
+
+        execution_error = nil
+        begin
+          group._setup_mocks
+          eval_before_eachs(group)
+
+          if ex.example_block
+            group.instance_eval(&ex.example_block)
+            group._verify_mocks
+            reporter.example_passed(ex)
+          else
+            reporter.example_pending(ex, 'Not yet implemented')
+          end
+          eval_after_eachs(group)
+        rescue Exception => e
+          reporter.example_failed(ex, e)
+          execution_error ||= e
+        ensure
+          group._teardown_mocks
+        end
+
+        success &= execution_error.nil?
+      end
+      eval_after_alls(group)
+      success
+    end
+
+    def self.subclass(base_name, &body) # :nodoc:
+      @_sub_class_count ||= 0
+      @_sub_class_count += 1
+      klass = Class.new(self)
+      class_name = "#{base_name}_#{@_sub_class_count}"
+      const_set(class_name, klass)
+      klass.instance_eval(&body)
+      klass
+    end
+
+    def self.to_s
+      self == Micronaut::Behaviour ? 'Micronaut::Behaviour' : name
+    end
+
+  end
+end