synthesis 0.0.7 → 0.0.8

data/README

@@ -2,7 +2,9 @@
 
 == Philosophy
 
-Currently we believe that developers are writing unnecessary functional tests to cover uncertainty about the validity of simulated interactions in their unit tests.  In other words, we cannot be certain that all our unit tests 'join up'.  If it were possible to correlate the simulated interactions in our unit tests, then we should be able to do away with the need to write large numbers of slow and annoying functional tests (apart from those which interact with the boundaries of the SUT).
+Currently we believe that developers are writing unnecessary <em>dependency wired</em> tests to cover uncertainty about the validity of simulated interactions in their <em>dependency neutral</em> tests.  In other words, we cannot be certain that all our simulated interaction based tests 'join up'.  If it were possible to correlate the simulated interactions in our tests, then we should be able to do away with the need to write large numbers of complex, slow and brittle wired tests (apart from those which interact with the boundaries of the SUT).
+
+Synthesis combines lightweight, <em>dependency neutral</em> tests to build confidence that the system under test is complete and reduces the need for large, overarching tests.
 
 == Installation
 
@@ -43,13 +45,13 @@ To use with Test::Unit and Mocha, ignoring Array and Hash:
     t.ignore Array, Hash
   end
 
-To use with RSpec, running all specs in the <tt>specs</tt> directory:
+To use with RSpec, running all specs in the <tt>spec</tt> directory:
 
   require "synthesis/task"
 
   Synthesis::Task.new do |t|
     t.adapter = :rspec
-    t.pattern = 'specs/*_spec.rb'
+    t.pattern = 'spec/**/*_spec.rb'
   end
 
 To use with Expectations, redirecting output to a file

data/Rakefile

@@ -91,7 +91,7 @@ end
 
 gem_spec = Gem::Specification.new do |s|
   s.name = 'synthesis'
-  s.version = '0.0.7'
+  s.version = '0.0.8'
   s.platform = Gem::Platform::RUBY
   s.rubyforge_project = "synthesis"
   s.summary, s.description = 'A tool for Synthesized Testing'

data/lib/synthesis/adapter/expectations.rb

@@ -6,14 +6,23 @@ require File.dirname(__FILE__) + "/../../synthesis"
 
 module Synthesis
   class ExpectationsAdapter < Adapter
- 
-    ignore_instances_of Class::AnyInstance
-    expectation_class Mocha::Expectation
-    intercept :method => :expects, :on => Object
-    
     def run
       fail_unless { Expectations::SuiteRunner.instance.suite.execute }
     end
+    
+    def collect_expectations
+      ignore_instances_of Class::AnyInstance
+      Object.extend(ExpectationRecordEnabled)
+      Object.record_expectations_on(:expects)
+      Mocha::Expectation.extend(ExpectationInterceptor)
+      Mocha::Expectation.intercept_expected_argument_types_on(:with)
+      Mocha::Expectation.intercept_expected_return_values_on(:returns)
+    end
+    
+    def stop_collecting_expectations
+      Mocha::Expectation.reset!
+      Object.reset!
+    end
   end
 end
 

data/lib/synthesis/adapter/mocha.rb

@@ -6,14 +6,23 @@ require File.dirname(__FILE__) + "/../../synthesis"
 
 module Synthesis
   class MochaAdapter < Adapter
-
-    ignore_instances_of Class::AnyInstance
-    expectation_class Mocha::Expectation
-    intercept :method => :expects, :on => Object
-    
     def run
       Test::Unit.run = true # Yes means no...
       fail_unless { Test::Unit::AutoRunner.run }
     end
+    
+    def collect_expectations
+      ignore_instances_of Class::AnyInstance
+      Object.extend(ExpectationRecordEnabled)
+      Object.record_expectations_on(:expects)
+      Mocha::Expectation.extend(ExpectationInterceptor)
+      Mocha::Expectation.intercept_expected_argument_types_on(:with)
+      Mocha::Expectation.intercept_expected_return_values_on(:returns)
+    end
+    
+    def stop_collecting_expectations
+      Mocha::Expectation.reset!
+      Object.reset!
+    end
   end  
 end

data/lib/synthesis/adapter/rspec.rb

@@ -6,14 +6,23 @@ require File.dirname(__FILE__) + "/../../synthesis"
 
 module Synthesis
   class RSpecAdapter < Adapter
-
-    ignore_instances_of Spec::Mocks::Mock
-    expectation_class Spec::Mocks::MessageExpectation
-    intercept :method => :should_receive, :on => Spec::Mocks::Methods
-    
     def run
       rspec_options.files.clear
       fail_unless { rspec_options.run_examples }
     end
+    
+    def collect_expectations
+      ignore_instances_of Spec::Mocks::Mock
+      Spec::Mocks::Methods.extend(ExpectationRecordEnabled)
+      Spec::Mocks::Methods.record_expectations_on(:should_receive)
+      Spec::Mocks::MessageExpectation.extend(ExpectationInterceptor)
+      Spec::Mocks::MessageExpectation.intercept_expected_argument_types_on(:with)
+      Spec::Mocks::MessageExpectation.intercept_expected_return_values_on(:and_return)
+    end
+    
+    def stop_collecting_expectations
+      Spec::Mocks::MessageExpectation.reset!
+      Spec::Mocks::Methods.reset!
+    end
   end  
 end

data/lib/synthesis/adapter.rb

@@ -1,7 +1,8 @@
 module Synthesis
-  # Subclasses of Adapter must implement the "run" method. 
-  # For example implementations, refer to Synthesis::MochaAdapter and
-  # Synthesis::RSpecAdapter
+  # Subclasses of Adapter must implement the run, collect_expectations and
+  # stop_collecting_expectations methods. 
+  # For example implementations refer to Synthesis::MochaAdapter and
+  # Synthesis::RSpecAdapter.
   class Adapter
     include Logging
     
@@ -13,52 +14,22 @@ module Synthesis
     # once for verifying the collected expectations. 
     def fail_unless(&block)
       log "Collecting expectations..."
+      collect_expectations
       Dir[@pattern].each { |t| require t }
       exit -1 unless yield
       log "Verifying expectation invocations..."
+      stop_collecting_expectations
       ExpectationRecord.record_invocations
       yield
     end
     
+    # The type of object representing a mock or stub for the test framework. 
+    # Objects of this type will be ignored by Synthesis.
+    def ignore_instances_of(type)
+      Synthesis.const_set(:MOCK_OBJECT, type)
+    end
+    
     class << self
-      # The type of object representing a mock or stub for the test framework. 
-      # Objects of this type will be ignored by Synthesis.
-      def ignore_instances_of(type)
-        Synthesis.const_set(:MOCK_OBJECT, type)
-      end
-      
-      # The class representing a mock object expectation in the test framework. 
-      # Synthesis will intercept its "with" method in order to collect the
-      # expectation method parameters being passed to it. 
-      def expectation_class(klass)
-        klass.class_eval do
-          attr_accessor :synthesis_expectation
-
-          alias original_with with
-
-          def with(*expected_parameters, &matching_block)
-            synthesis_expectation.args = expected_parameters if synthesis_expectation
-            original_with *expected_parameters, &matching_block
-          end
-        end
-      end
-      
-      # Accepts a Hash parameter with two entries, :method and :on. These
-      # represent the name of the method used for declaring a method interaction
-      # expectation on an object and the name of the object the method is defined
-      # on respectively. Synthesis will intercept this method in order to collect
-      # simulated method interactions. 
-      def intercept(params)
-        method_name, obj = params[:method], params[:on]
-        obj.send(:alias_method, :original_meth, method_name)
-        obj.send(:define_method, method_name) do |meth|
-          s_expectation = Synthesis::ExpectationRecord.add_expectation(self, meth, caller[0])
-          m_expectation = original_meth(meth)
-          m_expectation.synthesis_expectation = s_expectation
-          m_expectation
-        end
-      end
-      
       def inherited(subclass)
         @adapter = subclass
       end

data/lib/synthesis/class.rb

@@ -1,5 +1,5 @@
 class Class
-  def expectation(method, track, args = [])
-    Synthesis::Expectation::Singleton.new(self, method, track, args)
+  def expectation(method, track, args = [], return_value = nil)
+    Synthesis::Expectation::Singleton.new(self, method, track, args, return_value)
   end
 end

data/lib/synthesis/expectation.rb

@@ -1,7 +1,7 @@
 module Synthesis
   module Expectation
-    def self.new(receiver, method, track, args = [])
-      receiver.expectation method, track, args
+    def self.new(receiver, method, track, args = [], return_values = [])
+      receiver.expectation(method, track, args, return_values)
     end
   
     class Expectation
@@ -9,13 +9,18 @@ module Synthesis
       attr_reader :receiver, :method
       attr_accessor :args
       
-      def initialize(receiver, method, track, args)
+      def initialize(receiver, method, track, args, return_values)
         @receiver, @method, @track, @args = receiver, method, track, args
+        @return_values = return_values
       end
       
       def record_invocations
-        meta_receiver.extend Recordable
-        meta_receiver.recordable_method @method
+        meta_receiver.extend(Recordable)
+        meta_receiver.recordable_method(@method)
+      end
+      
+      def eql?(other)
+        ExpectationMatcher.new(self, other).match?
       end
       
       def ==(other)
@@ -30,10 +35,21 @@ module Synthesis
         @invoked = true
       end
       
-      protected
+      def arg_types
+        args.map { |arg| arg.class }
+      end
       
-      def args_match?(other)
-        self.args.map { |arg| arg.class } == other.args.map { |arg| arg.class }
+      def return_value_types
+        @return_values.map { |val| val.class }.uniq
+      end
+      
+      def add_return_values(*vals)
+        @return_values_defined = true
+        @return_values += vals
+      end
+      
+      def return_values_defined?
+        @return_values_defined
       end
     end
   
@@ -42,19 +58,18 @@ module Synthesis
         @receiver.__metaclass__
       end
       
-      def eql?(other)
-        return false unless other.is_a?(Synthesis::Expectation::Singleton)
-        @receiver.name == other.receiver.name && 
-        @method == other.method && 
-        args_match?(other)
-      end
-      
       def hash
         (@receiver.name.hash * 23) + @method.hash
       end
       
+      def receiver_class
+        @receiver
+      end
+      
       def to_s
-        "#{@receiver.name}.#{@method}(#{@args.map { |arg| arg.class } * ', '}) in #{@track}"
+        "(#{return_value_types * ", "}) " +
+        "#{@receiver.name}.#{@method}(#{@args.map { |arg| arg.class } * ', '})" + 
+        "in #{@track}"
       end
     end
     
@@ -63,19 +78,19 @@ module Synthesis
         @receiver.class
       end
       
-      def eql?(other)
-        return false unless other.is_a?(Synthesis::Expectation::Instance)
-        meta_receiver.name == other.meta_receiver.name && 
-        @method == other.method && 
-        args_match?(other)
-      end
-      
       def hash
         (meta_receiver.name.hash * 23) + @method.hash
       end
       
+      def receiver_class
+        meta_receiver
+      end
+      
       def to_s
-        "#{meta_receiver.name}.new.#{@method}(#{@args.map { |arg| arg.class } * ', '}) in #{@track}"
+        "(#{return_value_types * ", "}) " +
+        "#{meta_receiver.name}.new.#{@method}" +
+        "(#{@args.map { |arg| arg.class } * ', '})" + 
+        "in #{@track}"
       end
     end
     

data/lib/synthesis/expectation_interceptor.rb

@@ -0,0 +1,57 @@
+module Synthesis
+  # Extend by the mock object framework's expectation mechanism to allow
+  # Synthesis to tap into it in order to collect simulated method arguments
+  # and return values.
+  module ExpectationInterceptor
+    # Intercept the mock object framework's expectation method for declaring a mocked
+    # method's arguments so that Synthesis can record them.
+    def intercept_expected_argument_types_on(method_name)
+      @original_with = method_name
+      
+      class_eval %(
+        alias intercepted_#{@original_with} #{@original_with}
+        
+        def #{@original_with}(*expected_parameters, &matching_block)
+          synthesis_expectation.args = expected_parameters if synthesis_expectation
+          intercepted_#{@original_with}(*expected_parameters, &matching_block)
+        end
+      )
+    end
+    
+    # Intercept the mock object framework's expectation method for declaring a mocked
+    # method's return values so that Synthesis can record them.
+    def intercept_expected_return_values_on(method_name)
+      @original_returns = method_name
+      
+      class_eval %(
+        alias intercepted_#{@original_returns} #{@original_returns}
+
+        def #{@original_returns}(*values)
+          mock_expectation = intercepted_#{@original_returns}(*values)
+          synthesis_expectation.add_return_values(*values) if synthesis_expectation
+          mock_expectation
+        end
+      )
+    end
+    
+    # Restore the original methods ExpectationInterceptor has rewritten and
+    # undefine their intercepted counterparts. Undefine the synthesis_expectation
+    # accessors.
+    def reset!
+      class_eval %(
+        alias #{@original_with} intercepted_#{@original_with}
+        alias #{@original_returns} intercepted_#{@original_returns}
+        undef intercepted_#{@original_with}
+        undef intercepted_#{@original_returns}
+        undef synthesis_expectation
+        undef synthesis_expectation=
+      )
+    end
+    
+    # Classes extending ExpectationInterceptor will have a synthesis_expectation
+    # attribute accessor added to them.
+    def self.extended(receiver)
+      receiver.send(:attr_accessor, :synthesis_expectation)
+    end
+  end
+end

data/lib/synthesis/expectation_matcher.rb

@@ -0,0 +1,23 @@
+module Synthesis
+  class ExpectationMatcher
+    def initialize(expectation_one, expectation_two)
+      @expectation_one, @expectation_two = expectation_one, expectation_two
+    end
+    
+    def match?
+      return false unless @expectation_one.class == @expectation_two.class
+      return false unless @expectation_one.receiver_class == @expectation_two.receiver_class
+      return false unless @expectation_one.method == @expectation_two.method
+      return false unless @expectation_one.arg_types == @expectation_two.arg_types
+      return false unless return_values_match?
+      true
+    end
+    
+    private
+    
+    def return_values_match?
+      return true unless @expectation_one.return_values_defined? || @expectation_two.return_values_defined?
+      (@expectation_one.return_value_types & @expectation_two.return_value_types).any?
+    end
+  end
+end

data/lib/synthesis/expectation_record_enabled.rb

@@ -0,0 +1,32 @@
+module Synthesis
+  # Extend by the mock object framework's construct for declaring a
+  # mock object so that Synthesis can tap into it in order to record
+  # the expectation.
+  module ExpectationRecordEnabled
+    # Intercept the mock object framework's method for declaring a mock
+    # object so that Synthesis can record it.
+    def record_expectations_on(method_name)
+      @original_expects = method_name
+      
+      class_eval %(
+        alias intercepted_#{@original_expects} #{@original_expects}
+
+        def #{@original_expects}(meth)
+          s_expectation = Synthesis::ExpectationRecord.add_expectation(self, meth, caller[0])
+          m_expectation = intercepted_#{@original_expects}(meth)
+          m_expectation.synthesis_expectation = s_expectation
+          m_expectation
+        end
+      )
+    end
+    
+    # Restore the original methods ExpectationRecordEnabled has rewritten and
+    # undefine their intercepted counterparts.
+    def reset!
+      class_eval %(
+        alias #{@original_expects} intercepted_#{@original_expects}
+        undef intercepted_#{@original_expects}
+      )
+    end
+  end
+end

data/lib/synthesis/method_invocation_watcher.rb

@@ -1,7 +1,7 @@
 module Synthesis
   class MethodInvocationWatcher
-    def self.invoked(receiver, method, args = [])
-      matcher = Expectation.new(receiver, method, nil, args)
+    def self.invoked(receiver, method, args = [], return_values = [])
+      matcher = Expectation.new(receiver, method, nil, args, return_values)
       ExpectationRecord[matcher].invoked!
     end
   end

data/lib/synthesis/module.rb

@@ -1,5 +1,5 @@
 class Module
-  def expectation(method, track, args = [])
-    Synthesis::Expectation::Singleton.new(self, method, track, args)
+  def expectation(method, track, args = [], return_value = nil)
+    Synthesis::Expectation::Singleton.new(self, method, track, args, return_value)
   end
 end

data/lib/synthesis/object.rb

@@ -3,7 +3,7 @@ class Object
     class << self; self end
   end
   
-  def expectation(method, track, args = [])
-    Synthesis::Expectation::Instance.new(self, method, track, args)
+  def expectation(method, track, args = [], return_value = nil)
+    Synthesis::Expectation::Instance.new(self, method, track, args, return_value)
   end
 end

data/lib/synthesis/recordable.rb

@@ -1,17 +1,17 @@
 module Synthesis
   module Recordable
     def recordable_method(meth)
-      if method_defined? meth
-        defined_recordable_method meth
+      if method_defined?(meth)
+        defined_recordable_method(meth)
       else
-        magic_recordable_method meth
+        magic_recordable_method(meth)
       end
     end
     
     protected
     
     def defined_recordable_method(meth)
-      unless method_defined? "__recordable__#{meth}".intern
+      unless method_defined?("__recordable__#{meth}".intern)
         alias_method "__recordable__#{meth}".intern, meth
         class_eval @@recordable_method_def[meth]
       end
@@ -19,8 +19,9 @@ module Synthesis
       
     @@recordable_method_def = proc { |meth| %(
       def #{meth}(*args, &block)
-        MethodInvocationWatcher.invoked(self, "#{meth}".intern, args)
-        send "__recordable__#{meth}", *args, &block
+        return_value = send("__recordable__#{meth}", *args, &block)
+        MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [return_value])
+        return_value
       end
     )}
     
@@ -30,8 +31,9 @@ module Synthesis
       
     @@recordable_magic_method_def = proc { |meth| %(
       def #{meth}(*args)
-        MethodInvocationWatcher.invoked(self, "#{meth}".intern, args)
-        method_missing(:#{meth}, *args)
+        return_value = method_missing(:#{meth}, *args)
+        MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [return_value])
+        return_value
       end
       
       def __recordable__#{meth}() raise "Don't ever call me" end

data/lib/synthesis/reporter.rb

@@ -0,0 +1,24 @@
+module Synthesis
+  class Reporter
+    class << self
+      include Logging
+
+      def report
+        if failed?
+          ExpectationRecord.print_tested_expectations
+          ExpectationRecord.print_untested_expectations
+          ExpectationRecord.print_ignored
+          log; log "FAILED."
+          return -1
+        end
+        log; log "Verified #{ExpectationRecord.expectations.size} expectations"
+        log "SUCCESS."
+        0
+      end
+
+      def failed?
+        ExpectationRecord.untested_expectations.any?
+      end
+    end
+  end
+end

data/lib/synthesis/runner.rb

@@ -3,8 +3,7 @@ module Synthesis
     def self.run(adapter, pattern)
       require "synthesis/adapter/#{adapter}"
       Adapter.load(pattern).run
+      exit Reporter.report unless $!
     end    
   end
 end
-
-at_exit { exit Synthesis.report! unless $! }

data/lib/synthesis.rb

@@ -10,5 +10,8 @@ require "synthesis/module"
 require "synthesis/expectation_record"
 require "synthesis/method_invocation_watcher"
 require "synthesis/expectation"
-require "synthesis/report"
+require "synthesis/expectation_matcher"
+require "synthesis/expectation_interceptor"
+require "synthesis/expectation_record_enabled"
+require "synthesis/reporter"
 require "synthesis/adapter"

data/test/synthesis/adapter/mocha/helper.rb

@@ -1,2 +1,3 @@
 %w(test/unit rubygems mocha).each { |l| require l }
-require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
+require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
+Synthesis::MochaAdapter.new(nil).collect_expectations

data/test/synthesis/adapter/mocha/mocha_expectation_test.rb

@@ -2,17 +2,24 @@ require File.dirname(__FILE__) + "/helper"
 
 class MochaExpectationTest < Test::Unit::TestCase
   def setup
-    @mocha_expectation = Mocha::Expectation.new :mock, :blah
+    @mocha_expectation = Mocha::Expectation.new(:mock, :blah)
+    @synthesis_expectation = Synthesis::Expectation.new(Hash, :method, :track, [], [1])
   end
   
   def test_holds_synthesis_expectation
-    @mocha_expectation.synthesis_expectation = 1
-    assert_equal 1, @mocha_expectation.synthesis_expectation
+    @mocha_expectation.synthesis_expectation = @synthesis_expectation
+    assert_equal(@synthesis_expectation, @mocha_expectation.synthesis_expectation)
   end
   
   def test_with_passes_expected_params_to_synthesis_expectation
-    @mocha_expectation.synthesis_expectation = Synthesis::Expectation.new Hash, :foo, :track
-    @mocha_expectation.with 1, 2
+    @mocha_expectation.synthesis_expectation = @synthesis_expectation
+    @mocha_expectation.with(1, 2)
     assert_equal([1, 2], @mocha_expectation.synthesis_expectation.args)
   end
+  
+  def test_passes_return_values_to_synthesis_expectation
+    @mocha_expectation.synthesis_expectation = @synthesis_expectation
+    @mocha_expectation.returns(:rock)
+    assert_equal([Fixnum, Symbol], @synthesis_expectation.return_value_types)
+  end
 end

data/test/synthesis/adapter/rspec/helper.rb

@@ -1,2 +1,3 @@
 require "test/unit"
-require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/rspec"
+require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/rspec"
+Synthesis::RSpecAdapter.new(nil).collect_expectations

data/test/synthesis/expectation_matcher_test.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + "/helper"
+
+module Synthesis
+  class ExpectationMatcherTest < Test::Unit::TestCase
+    def test_match
+      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
+      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
+      assert(ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_no_match_based_on_expectation_type
+      exp1 = Expectation.new(Array, :foo, :track, [Array, Hash], [Array, Hash])
+      exp2 = Expectation.new(Array.new, :foo, :track, [Array, Hash], [Array, Hash])
+      assert(!ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_no_match_based_on_receiver_type
+      exp1 = Expectation.new(Array.new, :foo, :track, [Array, Hash], [Array, Hash])
+      exp2 = Expectation.new(Hash.new, :foo, :track, [Array, Hash], [Array, Hash])
+      assert(!ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_no_match_based_on_method_name
+      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [Array, Hash])
+      exp2 = Expectation.new(Object.new, :bar, :track, [Array, Hash], [Array, Hash])
+      assert(!ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_no_match_based_on_arg_types
+      exp1 = Expectation.new(Object.new, :foo, :track, [1, "a"], [Array, Hash])
+      exp2 = Expectation.new(Object.new, :foo, :track, [1, 2], [Array, Hash])
+      assert(!ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_no_match_based_on_return_value_types
+      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
+      exp1.add_return_values(:sym)
+      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], ["string"])
+      assert(!ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_match_based_on_intersection_of_return_value_types
+      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [[1], {:a => :b}])
+      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash], [[4], {:a => 9}])
+      assert(ExpectationMatcher.new(exp1, exp2).match?)
+    end
+    
+    def test_ignores_return_value_types_unless_return_values_defined
+      exp1 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
+      exp2 = Expectation.new(Object.new, :foo, :track, [Array, Hash])
+      assert(ExpectationMatcher.new(exp1, exp2).match?)
+    end
+  end  
+end

data/test/synthesis/expectation_record_test.rb

@@ -14,17 +14,17 @@ module Synthesis
 
     def test_watches_expectation_invocations
       c = Class.new { def foo; end }
-      ExpectationRecord.add_expectation c.new, :foo, :track
+      ExpectationRecord.add_expectation(c.new, :foo, :track)
       ExpectationRecord.record_invocations
       a = c.new
-      MethodInvocationWatcher.expects(:invoked).with(a, :foo, [])
+      MethodInvocationWatcher.expects(:invoked).with(a, :foo, [], [nil])
       a.foo
     end
 
     def test_finds_expectation
-      ExpectationRecord.add_expectation Object.new, :foo, :track
-      expected = ExpectationRecord.expectations.to_a[0]
-      matcher = Expectation.new Object.new, :foo, :track
+      expected = ExpectationRecord.add_expectation(Object.new, :foo, :track)
+      expected.add_return_values(20)
+      matcher = Expectation.new(Object.new, :foo, :track, [], [20])
       actual = ExpectationRecord[matcher]
       assert_equal(expected, actual)
     end
@@ -37,15 +37,16 @@ module Synthesis
     end
 
     def test_does_not_add_expectation_for_ignored_class
-      ExpectationRecord.ignore Hash
-      ExpectationRecord.add_expectation Hash, :foo, :track
+      ExpectationRecord.ignore(Hash)
+      ExpectationRecord.add_expectation(Hash, :foo, :track)
       assert ExpectationRecord.expectations.empty?
     end
     
     def test_returns_added_expectation_on_add
-      expected = Expectation.new Hash, :foo, :track
-      actual = ExpectationRecord.add_expectation Hash, :foo, :track
-      assert_equal expected, actual
+      expected = Expectation.new(Hash, :foo, :track, [], [:return_val])
+      actual = ExpectationRecord.add_expectation(Hash, :foo, :track)
+      actual.add_return_values(:return_val)
+      assert_equal(expected, actual)
     end
   end
 end

data/test/synthesis/expectation_test.rb

@@ -3,77 +3,76 @@ require File.dirname(__FILE__) + "/helper"
 module Synthesis
   class ExpectationTest < Test::Unit::TestCase
     def test_creates_singleton_method_expectation_given_class
-      expectation = Expectation.new Class.new, :foo, :track
-      assert_kind_of Expectation::Singleton, expectation
+      expectation = Expectation.new(Class.new, :foo, :track)
+      assert_kind_of(Expectation::Singleton, expectation)
     end
 
     def test_creates_instance_method_expectation_given_instance
-      expectation = Expectation.new Class.new.new, :foo, :track
-      assert_kind_of Expectation::Instance, expectation
+      expectation = Expectation.new(Class.new.new, :foo, :track)
+      assert_kind_of(Expectation::Instance, expectation)
     end
 
     def test_creates_singleton_method_expectation_given_module
-      expectation = Expectation.new Module.new, :foo, :track
-      assert_kind_of Expectation::Singleton, expectation
+      expectation = Expectation.new(Module.new, :foo, :track)
+      assert_kind_of(Expectation::Singleton, expectation)
     end
 
     def test_records_instance_receiver_method_invocations
       receiver = Class.new { def foo;end }
-      expectation = Expectation.new receiver.new, :foo, :track
+      expectation = Expectation.new(receiver.new, :foo, :track)
       expectation.record_invocations
-      assert_respond_to receiver.new, :__recordable__foo
+      assert_respond_to(receiver.new, :__recordable__foo)
     end
 
     def test_records_singleton_receiver_method_invocations
       receiver = Class.new { def self.foo;end }
-      expectation = Expectation.new receiver, :foo, :track
+      expectation = Expectation.new(receiver, :foo, :track, [], [:return])
       expectation.record_invocations
-      assert_respond_to receiver, :__recordable__foo
+      assert_respond_to(receiver, :__recordable__foo)
     end
-
-    def test_equality
-      exp1 = Expectation.new Object.new, :foo, :track
-      exp2 = Expectation.new Object.new, :foo, :track
-      assert_equal exp1, exp2
+    
+    def test_make_sure_equality_works_with_uniq
+      expectations = [
+        Expectation.new(String, :new, [], [:arg1, :arg2], [:return]), 
+        Expectation.new(String, :new, [], [:arg1, :arg2], [:return])
+      ]
+      assert_equal(1, expectations.uniq.size)
     end
-
-    def test_non_equality
-      exp1 = Expectation.new Hash.new, :foo, :track
-      exp2 = Expectation.new Array.new, :foo, :track
-      assert_not_equal exp1, exp2
+    
+    def test_singleton_receiver_class
+      assert_equal(String, Expectation.new(String, :new, :track, [], []).receiver_class)
     end
     
-    def test_equality_based_on_same_type_args
-      exp1 = Expectation.new Object.new, :foo, :track, [1, 2]
-      exp2 = Expectation.new Object.new, :foo, :track, [1, 2]
-      assert_equal exp1, exp2
+    def test_instance_receiver_class
+      assert_equal(String, Expectation.new(String.new, :new, :track, [], []).receiver_class)
     end
     
-    def test_args_based_non_equality_based_on_different_type_args
-      exp1 = Expectation.new Object.new, :foo, :track, [1, Hash.new]
-      exp2 = Expectation.new Object.new, :foo, :track, [1, 2]
-      assert_not_equal exp1, exp2
+    def test_arg_types
+      expectation = Expectation.new(String.new, :new, :track, [:sym, "str"], [])
+      assert_equal([Symbol, String], expectation.arg_types)
     end
-
-    def test_make_sure_equality_works_with_uniq
-      arr = [
-        Expectation.new(String, :new, []), 
-        Expectation.new(String, :new, [])
-      ]
-      assert_equal(1, arr.uniq.size)
+    
+    def test_return_value_types
+      expectation = Expectation.new(String.new, :new, :track, [], [:sym, "str"])
+      assert_equal([Symbol, String], expectation.return_value_types)
     end
-
-    def test_does_not_blow_up_on_name_error
-      expectation = Expectation.new Hash, :bad, :track
-      silent(expectation) do
-        assert_nothing_raised(NameError) { expectation.record_invocations }
-      end
+    
+    def test_adds_return_value
+      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
+      expectation.add_return_values("str")
+      actual = expectation.instance_variable_get(:@return_values)
+      assert_equal([:sym, "str"], actual)
     end
-
-    def silent(object)
-      object.silence!
-      yield
-      object.speak!
+    
+    def test_return_values_defined_when_return_values_added
+      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
+      expectation.add_return_values("str")
+      assert(expectation.return_values_defined?)
+    end
+    
+    def test_return_values_not_defined_when_no_return_values_added
+      expectation = Expectation.new(String.new, :new, :track, [], [:sym])
+      assert(!expectation.return_values_defined?)
     end
   end
 end

data/test/synthesis/method_invocation_watcher_test.rb

@@ -3,8 +3,8 @@ require File.dirname(__FILE__) + "/helper"
 module Synthesis
   class MethodInvocationWatcherTest < Test::Unit::TestCase
     def test_marks_expectation_invoked
-      ExpectationRecord.add_expectation(Hash, :to_s, [])
-      MethodInvocationWatcher.invoked(Hash, :to_s, [])
+      ExpectationRecord.add_expectation(Hash, :to_s, :track, []).add_return_values(1)
+      MethodInvocationWatcher.invoked(Hash, :to_s, [], [1])
       expectation = ExpectationRecord.expectations.to_a.first
       assert expectation.invoked?
     end

data/test/synthesis/recordable_test.rb

@@ -14,7 +14,7 @@ module Synthesis
       foo.extend Recordable
       foo.recordable_method(:b)
       bar = foo.new
-      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [])
+      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [], [nil])
       bar.b
     end
     
@@ -59,7 +59,7 @@ module Synthesis
       foo.extend Recordable
       foo.recordable_method(:b)
       bar = foo.new
-      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [])
+      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [], [:magic!])
       bar.b
     end
   end

data/test_project/mocha/test/data_brander_test.rb

@@ -5,7 +5,7 @@ class DataBranderTest < Test::Unit::TestCase
   def test_saves_branded_to_pstore
     pstore = Storage.new 'whatever'
     pstore.expects(:save).with('METAL - rock')
-    DataBrander.new(pstore).save_branded 'rock'
+    DataBrander.new(pstore).save_branded('rock')
   end
   
   def test_ignores_total_ducks

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: synthesis
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors: 
 - Stuart Caborn, George Malamidis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-10 00:00:00 +00:00
+date: 2008-04-13 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -29,13 +29,16 @@ files:
 - lib/synthesis/adapter.rb
 - lib/synthesis/class.rb
 - lib/synthesis/expectation.rb
+- lib/synthesis/expectation_interceptor.rb
+- lib/synthesis/expectation_matcher.rb
 - lib/synthesis/expectation_record.rb
+- lib/synthesis/expectation_record_enabled.rb
 - lib/synthesis/logging.rb
 - lib/synthesis/method_invocation_watcher.rb
 - lib/synthesis/module.rb
 - lib/synthesis/object.rb
 - lib/synthesis/recordable.rb
-- lib/synthesis/report.rb
+- lib/synthesis/reporter.rb
 - lib/synthesis/runner.rb
 - lib/synthesis/task.rb
 - lib/synthesis.rb
@@ -49,6 +52,7 @@ files:
 - test/synthesis/adapter/rspec/message_expectation_test.rb
 - test/synthesis/adapter/rspec/methods_test.rb
 - test/synthesis/class_test.rb
+- test/synthesis/expectation_matcher_test.rb
 - test/synthesis/expectation_record_test.rb
 - test/synthesis/expectation_test.rb
 - test/synthesis/helper.rb
@@ -95,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: synthesis
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: A tool for Synthesized Testing

data/lib/synthesis/report.rb

@@ -1,22 +0,0 @@
-module Synthesis
-  extend Logging
-  
-  def report!
-    if failed?
-      ExpectationRecord.print_tested_expectations
-      ExpectationRecord.print_untested_expectations
-      ExpectationRecord.print_ignored
-      log; log "FAILED."
-      return -1
-    end
-    log; log "Verified #{ExpectationRecord.expectations.size} expectations"
-    log "SUCCESS."
-    0
-  end
-  
-  def failed?
-    ExpectationRecord.untested_expectations.any?
-  end
-  
-  module_function :report!, :failed?
-end