gmalamid-synthesis 0.1.6

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2007 nutrun.com, Stuart Caborn, George Malamidis
+
+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 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,107 @@
+= Synthesis
+
+== Philosophy
+
+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 tests to build confidence that the system under test is complete and reduces the need for large, overarching tests.
+
+== Installation
+
+ sudo gem i synthesis
+
+== Download
+
+Synthesis RubyForge page ( http://rubyforge.org/projects/synthesis )
+
+== Dependencies
+
+Synthesis's core doesn't have any dependencies. 
+
+When used with the Mocha adapter, it will depend on the Mocha[http://mocha.rubyforge.org] library.
+
+When used with the RSpec adapter, it will depend on the RSpec[http://rspec.info/] library.
+
+When used with the Expectations adapter, it will depend on the Expectations[http://expectations.rubyforge.org] library.
+
+== Usage
+
+Synthesis can be used through its Rake task. It currently has three supported adapters: Mocha (with Test::Unit), RSpec and Expectations. If +adapter+ is not explicitly specified, the Mocha adapter will be used by default. 
+
+By default, Synthesis outputs to +STDOUT+, but output can be redirected to alternative IO streams.
+
+Synthesis can be setup to ignore certain classes or modules when collecting expectations for verification.
+
+If +pattern+ is not specified, it will default to <tt>test/**/*_test.rb</tt>
+
+== Usage examples
+
+To use with Test::Unit and Mocha, ignoring Array and Hash:
+
+  require "synthesis/task"
+	
+  Synthesis::Task.new do |t|
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.ignored = [Array, Hash]
+  end
+
+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 = 'spec/**/*_spec.rb'
+  end
+
+To use with Expectations, redirecting output to a file
+
+  require "synthesis/task"
+	
+  Synthesis::Task.new do |t|
+    t.adapter = :expectations
+    t.out = File.new "synthesis.test.txt", "a"
+  end
+
+== Utilities
+
+=== mock_instance
+
+  require "synthesis/util/mock_instance"
+  foo_mock = Foo.mock_instance(arg_one, arg_2)
+
+This is equivalent, but without calling the real <tt>initialize</tt>, to:
+
+  foo_mock = Foo.new
+  Foo.expects(:new).with(arg_one, arg_two).returns(foo_mock)
+
+Or, in the case of RSpec, it is equivalent to:
+
+  foo_mock = Foo.new
+  Foo.should_receive(:new).with(arg_one, arg_two).and_return(foo_mock)
+
+Either <tt>"mocha_standalone"</tt> or <tt>"spec/mocks"</tt> need to be required before using <tt>mock_instance</tt>.
+
+== Git
+
+Public clone URL: git://github.com/gmalamid/synthesis.git
+
+== Known Issues
+
+Reporting the location (filename and line number) of tested/untested expectations doesn't work as intended with the Expectations adapter.
+
+== Contributors
+
+Danilo Sato, Paul Nasrat
+
+== Discuss
+
+http://groups.google.com/group/synthesized-testing
+
+== Related reading
+
+* Synthesized Testing: A Primer ( http://nutrun.com/weblog/synthesized-testing-a-primer )
+* Confidence as a test code metric ( http://nutrun.com/weblog/confidence-as-a-test-code-metric )
+* Using Synthesis With Test::Unit and Mocha ( http://nutrun.com/weblog/using-synthesis-with-testunit-and-mocha )
+* Using Synthesis With Expectations ( http://nutrun.com/weblog/using-synthesis-with-expectations )
+* Synthesis validates simulated method calls taking method signature arguments into account ( http://nutrun.com/weblog/synthesis-002 )

data/Rakefile

@@ -0,0 +1,77 @@
+require "rubygems"
+require "rake/testtask"
+require "rake/gempackagetask"
+require 'rake/rdoctask'
+require 'rake/contrib/sshpublisher'
+require File.dirname(__FILE__) + "/lib/synthesis/task"
+
+load 'synthesis.gemspec'
+
+task :default => :test
+
+desc "Run all tests"
+task :test => %w[test:core test:mocha test:spec]
+
+desc "Run core tests"
+Rake::TestTask.new('test:core') do |t|
+  t.pattern = 'test/synthesis/*_test.rb'
+end
+
+desc "Run Mocha adapter tests"
+Rake::TestTask.new('test:mocha') do |t|
+  t.pattern = 'test/synthesis/adapter/mocha/*_test.rb'
+end
+
+desc "Run RSpec adapter tests"
+Rake::TestTask.new('test:spec') do |t|
+  t.pattern = 'test/synthesis/adapter/rspec/*_test.rb'
+end
+
+Synthesis::Task.new do |t|
+  t.pattern = 'test_project/mocha/test/*_test.rb'
+  t.ignored = [Array, Hash]
+  # t.out = File.new('synthesis.test.txt', 'a')
+end
+
+Synthesis::Task.new('synthesis:expectations') do |t|
+  t.adapter = :expectations
+  t.pattern = 'test_project/expectations/test/*_test.rb'
+end
+
+Synthesis::Task.new('synthesis:spec') do |t|
+  t.adapter = :rspec
+  t.pattern = 'test_project/rspec/*_spec.rb'
+end
+
+desc 'Generate RDoc'
+Rake::RDocTask.new do |task|
+  task.main = 'README'
+  task.title = 'synthesis'
+  task.rdoc_dir = 'doc'
+  task.options << "--line-numbers" << "--inline-source"
+  task.rdoc_files.include('README', 'lib/**/*.rb')
+end
+
+desc "Upload RDoc to RubyForge"
+task :publish_rdoc do
+  Rake::Task[:rdoc].invoke
+  Rake::SshDirPublisher.new("gmalamid@rubyforge.org", "/var/www/gforge-projects/synthesis", "doc").upload
+end
+
+Rake::GemPackageTask.new(GEMSPEC) do |t|
+  t.need_zip = false
+  t.need_tar = false
+end
+
+desc "Remove rdoc and package artefacts"
+task :clean => %w[clobber_package clobber_rdoc]
+
+task(:lf) {p Dir["lib/**/*rb"] }
+
+task(:check_gemspec) do
+  require 'rubygems/specification'
+  data = File.read('synthesis.gemspec')
+  spec = nil
+  Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+  puts spec
+end

data/lib/synthesis/adapter/expectations.rb

@@ -0,0 +1,35 @@
+require "rubygems"
+require "mocha_standalone"
+require "expectations"
+
+require File.dirname(__FILE__) + "/../../synthesis"
+
+module Synthesis
+  class ExpectationsAdapter < Adapter
+    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.record_expected_arguments_on(:with)
+      Mocha::Expectation.record_expected_return_values_on(:returns)
+      Mocha::Expectation.record_expected_return_values_on(:raises)
+      Mocha::Expectation.remove_expectation_on(:never)
+    end
+    
+    def stop_collecting_expectations
+      Mocha::Expectation.stop_intercepting!
+      Object.stop_recording!
+    end
+  end
+end
+
+class Expectations::SuiteRunner  
+  def initialize
+    self.suite = Expectations::Suite.new
+  end  
+end

data/lib/synthesis/adapter/mocha.rb

@@ -0,0 +1,30 @@
+require "rubygems"
+require "mocha_standalone"
+require "test/unit"
+
+require File.dirname(__FILE__) + "/../../synthesis"
+
+module Synthesis
+  class MochaAdapter < Adapter
+    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.record_expected_arguments_on(:with)
+      Mocha::Expectation.record_expected_return_values_on(:returns)
+      Mocha::Expectation.record_expected_return_values_on(:raises)
+      Mocha::Expectation.remove_expectation_on(:never)
+    end
+    
+    def stop_collecting_expectations
+      Mocha::Expectation.stop_intercepting!
+      Object.stop_recording!
+    end
+  end  
+end

data/lib/synthesis/adapter/rspec.rb

@@ -0,0 +1,34 @@
+require "rubygems"
+require "spec"
+require "spec/mocks"
+
+require File.dirname(__FILE__) + "/../../synthesis"
+
+module Synthesis
+  class RSpecAdapter < Adapter
+    def run
+      rspec_options.files.clear
+      fail_unless do
+        rspec_options.instance_variable_set(:@formatters, nil)
+        # rspec_options.instance_variable_set(:@format_options, [["profile", STDOUT]])
+        rspec_options.run_examples
+      end
+    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.record_expected_arguments_on(:with)
+      Spec::Mocks::MessageExpectation.record_expected_return_values_on(:and_return)
+      Spec::Mocks::MessageExpectation.record_expected_return_values_on(:and_raise)
+      Spec::Mocks::MessageExpectation.remove_expectation_on(:never)
+    end
+    
+    def stop_collecting_expectations
+      Spec::Mocks::MessageExpectation.stop_intercepting!
+      Spec::Mocks::Methods.stop_recording!
+    end
+  end  
+end

data/lib/synthesis/adapter.rb

@@ -0,0 +1,42 @@
+module Synthesis
+  # 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
+    
+    def initialize(pattern)
+      @pattern = pattern
+    end
+    
+    # The block parameter will yield twice, once for collecting and
+    # 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
+      def inherited(subclass)
+        @adapter = subclass
+      end
+
+      def load(pattern)
+        @adapter.new(pattern)
+      end
+    end
+  end
+end

data/lib/synthesis/class.rb

@@ -0,0 +1,5 @@
+class Class
+  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

@@ -0,0 +1,115 @@
+module Synthesis
+  module Expectation
+    def self.new(receiver, method, track, args = [], return_values = [])
+      receiver.expectation(method, track, args, return_values)
+    end
+  
+    class Expectation
+      include Logging
+      attr_reader :receiver, :method, :return_values
+      protected :return_values
+      attr_accessor :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)
+      end
+      
+      def explode
+        if @return_values.size > 1
+          @return_values.map do |v|
+            expectation = self.class.new(@receiver, @method, @track, @args, [])
+            expectation.add_return_values(v)
+            expectation
+          end
+        else
+          self
+        end
+      end
+      
+      def eql?(other)
+        ExpectationMatcher.new(self, other).match?
+      end
+      
+      def ==(other)
+        eql?(other)
+      end
+      
+      def invoked?
+        @invoked
+      end
+      
+      def invoked!
+        @invoked = true
+      end
+      
+      def arg_types
+        args.map { |arg| arg.class }
+      end
+      
+      def return_value_type
+        @return_values.size == 1 ? @return_values[0].class : nil
+      end
+      
+      def add_return_values(*vals)
+        @return_values_defined = true
+        @return_values += vals
+      end
+      
+      def return_values_defined?
+        @return_values_defined
+      end
+    end
+  
+    class Singleton < Expectation
+      def meta_receiver
+        @receiver.__metaclass__
+      end
+      
+      def hash
+        (@receiver.name.hash * 23) + @method.hash
+      end
+      
+      def receiver_class
+        @receiver
+      end
+      
+      def to_s
+        "(#{return_value_type}) " +
+        "#{@receiver.name}.#{@method}(#{@args.map { |arg| arg.class } * ', '})" + 
+        "in #{@track}"
+      end
+    end
+    
+    class Instance < Expectation
+      def meta_receiver
+        @receiver.class
+      end
+      
+      def hash
+        (meta_receiver.name.hash * 23) + @method.hash
+      end
+      
+      def receiver_class
+        meta_receiver
+      end
+      
+      def to_s
+        "(#{return_value_type}) #{meta_receiver.name}.new.#{@method}" +
+        "(#{@args.map { |arg| arg.class } * ', '})" + 
+        "in #{@track}"
+      end
+    end
+    
+    class NilExpectation < Expectation
+      def initialize;end
+      def invoked!;end
+      def record_invocations;end
+    end
+  end
+end

data/lib/synthesis/expectation_interceptor.rb

@@ -0,0 +1,78 @@
+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 record_expected_arguments_on(method_name)
+      (@original_methods ||= []) << method_name
+      
+      class_eval do
+        alias_method "intercepted_#{method_name}", method_name
+        
+        define_method(:get_method_name) {method_name}
+        
+        def temp_method(*expected_parameters, &matching_block)
+          synthesis_expectation.args = expected_parameters if synthesis_expectation
+          send("intercepted_#{get_method_name}", *expected_parameters, &matching_block)
+        end
+        
+        alias_method method_name, :temp_method
+        undef temp_method
+      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 record_expected_return_values_on(method_name)
+      (@original_methods ||= []) << method_name
+      
+      class_eval do
+        alias_method "intercepted_#{method_name}", method_name
+        
+        define_method(method_name) do |*values|
+          mock_expectation = send("intercepted_#{method_name}", *values)
+          synthesis_expectation.add_return_values(*values) if synthesis_expectation
+          mock_expectation
+        end
+      end
+    end
+    
+    def remove_expectation_on(method_name)
+      (@original_methods ||= []) << method_name
+      
+      class_eval do
+        alias_method "intercepted_#{method_name}", method_name
+        
+        define_method(method_name) do |*values|
+          Synthesis::ExpectationRecord.remove(synthesis_expectation) if synthesis_expectation
+          send("intercepted_#{method_name}")
+        end
+      end
+    end
+    
+    # Restore the original methods ExpectationInterceptor has rewritten and
+    # undefine their intercepted counterparts. Undefine the synthesis_expectation
+    # accessors.
+    def stop_intercepting!
+      @original_methods.each do |m|
+        class_eval do
+          alias_method m, "intercepted_#{m}"
+          remove_method "intercepted_#{m}"
+        end
+      end
+
+      class_eval do
+        remove_method :synthesis_expectation
+        remove_method :synthesis_expectation=
+      end
+    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_type == @expectation_two.return_value_type
+    end
+  end
+end

data/lib/synthesis/expectation_record.rb

@@ -0,0 +1,102 @@
+module Synthesis
+  class ExpectationRecord
+    class << self
+      include Logging
+
+      def add_expectation(receiver, method, track, args = [])
+        unless ignore?(receiver)
+          expectation = Expectation.new(receiver, method, track, args)
+          expectations << expectation
+          expectation
+        end
+      end
+      
+      def remove(expectation)
+        expectations.delete(expectation)
+      end
+
+      def ignore(*args)
+        ignored.merge(args)
+      end
+
+      def expectations
+        # Using an Array instead of a Set because the +Expectation+ instance 
+        # is not complete when first added. A Set would result to possible duplicates.
+        # obj.expects(:method).with(:args)
+        # the +Expectation+ will be added when obj.expects(:method) is called
+        # the +Expectation+ arguments will be added when .with(:args) is called
+        @expectations ||= []
+      end
+
+      def ignored
+        @ignored ||= Set.new
+      end
+
+      def [](matcher)
+        # Using a hash for faster look up of expectations 
+        # when recording invocations
+        expectations_with_return_values[matcher] ||
+        expectations_without_return_values[matcher] ||
+        Expectation::NilExpectation.new
+      end
+
+      def record_invocations
+        expectations.map! { |e| e.explode }
+        expectations.flatten!
+        expectations.uniq!
+        expectations.each do |e|
+          e.record_invocations
+          if e.return_values_defined?
+            expectations_with_return_values[e] = e 
+          else
+            expectations_without_return_values[e] = e
+          end
+        end
+      end
+
+      def tested_expectations
+        expectations.select { |e| e.invoked? }
+      end
+
+      def untested_expectations
+        expectations.select { |e| !e.invoked? }
+      end
+
+      def print_tested_expectations
+        log; log "Tested Expectations: "
+        tested_expectations.each { |e| log e }
+      end
+
+      def print_untested_expectations
+        log; log "Untested Expectations: "
+        untested_expectations.each { |e| log e }
+      end
+
+      def print_ignored
+        log; log "Ignoring: #{ignored.to_a * ', '}"
+      end
+
+      private
+      def expectations_with_return_values
+        @expectations_with_return_values ||= {}
+      end
+
+      def expectations_without_return_values
+        @expectations_without_return_values ||= {}
+      end
+
+      def ignore?(obj)
+        ignored.include?(obj.class) ||
+        (obj.is_a?(Class) && ignored.include?(obj)) ||
+        (obj.is_a?(Module) && ignored.include?(obj)) ||
+        obj.is_a?(MOCK_OBJECT)
+      end
+
+      def reset!
+        @expectations_with_return_values = nil
+        @expectations_without_return_values = nil
+        @expectations, @ignored = nil
+      end
+    end
+  end
+end

data/lib/synthesis/expectation_record_enabled.rb

@@ -0,0 +1,39 @@
+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 do
+        alias_method "intercepted_#{method_name}", method_name
+
+        define_method(:get_expectation_method_name) {method_name}
+
+        def temp_expectation_record(meth, *expected_parameters, &matching_block)
+          s_expectation = ExpectationRecord.add_expectation(self, meth, caller[0])
+          m_expectation = send("intercepted_#{get_expectation_method_name}", meth, *expected_parameters, &matching_block)
+          m_expectation.synthesis_expectation = s_expectation
+          m_expectation
+        end
+          
+        alias_method method_name, :temp_expectation_record
+        undef temp_expectation_record
+      end
+    end
+    
+    # Restore the original methods ExpectationRecordEnabled has rewritten and
+    # undefine their intercepted counterparts.
+    def stop_recording!
+      method_name = @original_expects
+      class_eval do
+        alias_method method_name, "intercepted_#{method_name}"
+        remove_method "intercepted_#{method_name}"
+        remove_method :get_expectation_method_name
+      end
+    end
+  end
+end

data/lib/synthesis/logging.rb

@@ -0,0 +1,21 @@
+module Synthesis
+  module Logging
+    def silence!
+      @silent = true
+    end
+    
+    def speak!
+      @silent = false
+    end
+    
+    protected
+
+    def log(msg = '')
+      out.puts "[Synthesis] #{msg}" unless @silent
+    end
+    
+    def out
+      Synthesis::Logging.const_defined?(:OUT) ? OUT : STDOUT
+    end
+  end
+end

data/lib/synthesis/method_invocation_watcher.rb

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

data/lib/synthesis/module.rb

@@ -0,0 +1,5 @@
+class Module
+  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

@@ -0,0 +1,9 @@
+class Object
+  def __metaclass__
+    class << self; self end
+  end
+  
+  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

@@ -0,0 +1,48 @@
+module Synthesis
+  module Recordable
+    def recordable_method(meth)
+      if method_defined?(meth)
+        defined_recordable_method(meth)
+      else
+        magic_recordable_method(meth)
+      end
+    end
+    
+    protected
+    
+    def defined_recordable_method(meth)
+      unless method_defined?("__recordable__#{meth}".intern)
+        alias_method "__recordable__#{meth}".intern, meth
+        class_eval <<-end_eval
+          def #{meth}(*args, &block)
+            begin
+              return_value = send("__recordable__#{meth}", *args, &block)
+              MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [return_value])
+              return_value
+            rescue Exception => e
+              MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [e])
+              raise e
+            end
+          end
+        end_eval
+      end
+    end
+      
+    def magic_recordable_method(meth)
+      class_eval <<-end_eval
+        def #{meth}(*args)
+          begin
+            return_value = method_missing(:#{meth}, *args)
+            MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [return_value])
+            return_value
+          rescue Exception => e
+            MethodInvocationWatcher.invoked(self, "#{meth}".intern, args, [e])
+            raise e
+          end
+        end
+
+        def __recordable__#{meth}() raise "Don't ever call me" end
+      end_eval
+    end
+  end
+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

@@ -0,0 +1,9 @@
+module Synthesis
+  class Runner
+    def self.run(adapter, pattern)
+      require "synthesis/adapter/#{adapter}"
+      Adapter.load(pattern).run
+      at_exit { Reporter.report unless $! }
+    end    
+  end
+end

data/lib/synthesis/task.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+require "rake"
+require "rake/tasklib"
+require File.dirname(__FILE__) + "/../synthesis/logging"
+
+module Synthesis
+  class Task < Rake::TaskLib
+    include Logging
+    attr_accessor :verbose, :pattern, :ruby_opts, :adapter, :out, :ignored, :libs
+
+    def initialize(name='synthesis:test')
+      @name, @ignored, @libs = name, [], ['lib']
+      yield self if block_given?
+      @pattern ||= 'test/**/*_test.rb'
+      @ruby_opts ||= []
+      @adapter ||= :mocha
+      define
+    end
+    
+    def ignore(*classes)
+      STDERR.puts
+      STDERR.puts "DEPRECATION WARNING!!!"
+      STDERR.puts caller[0]
+      STDERR.puts "Synthesis::Task#ignore(*classes) has been deprecated."
+      STDERR.puts "Use Synthesis::Task#ignored = [#{classes * ','}] instead."
+      STDERR.puts
+      @ignored << classes
+      @ignored.flatten!
+    end
+
+    def define
+      desc "Run Synthesis tests"
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+          load_paths
+          require File.dirname(__FILE__) + "/../synthesis"
+          require File.dirname(__FILE__) + "/../synthesis/runner"
+          Synthesis::Logging.const_set(:OUT, @out) if @out
+          Synthesis::ExpectationRecord.ignore(*@ignored)
+          Synthesis::Runner.run(@adapter, @pattern)
+        end
+      end
+      self
+    end
+
+    private 
+    def load_paths
+      @libs.each { |path| $:.unshift(File.join(Dir.pwd, path)) }
+    end
+  end
+end

data/lib/synthesis/util/mock_instance/mocha.rb

@@ -0,0 +1,18 @@
+class Object
+  def self.mock_instance(*args)
+    class_eval do
+      alias original_initialize initialize
+      def initialize()end
+    end
+
+    instance = new
+    expects(:new).with(*args).returns(instance)
+
+    class_eval do
+      alias initialize original_initialize
+      undef original_initialize
+    end
+
+    return instance
+  end
+end

data/lib/synthesis/util/mock_instance/rspec.rb

@@ -0,0 +1,18 @@
+module Spec::Mocks::Methods
+  def mock_instance(*args)
+    class_eval do
+      alias original_initialize initialize
+      def initialize()end
+    end
+
+    instance = new
+    should_receive(:new).with(*args).and_return(instance)
+
+    class_eval do
+      alias initialize original_initialize
+      undef original_initialize
+    end
+
+    return instance
+  end
+end

data/lib/synthesis/util/mock_instance.rb

@@ -0,0 +1,7 @@
+if defined? Mocha
+  require File.dirname(__FILE__) + "/mock_instance/mocha"
+elsif defined? Spec
+  require File.dirname(__FILE__) + "/mock_instance/rspec"
+else
+  raise "Either mocha_standalone or spec/mocks must be required before you can use mock_instance"
+end

data/lib/synthesis.rb

@@ -0,0 +1,17 @@
+require "set"
+
+$: << File.dirname(__FILE__)
+
+require "synthesis/logging"
+require "synthesis/recordable"
+require "synthesis/object"
+require "synthesis/class"
+require "synthesis/module"
+require "synthesis/expectation_record"
+require "synthesis/method_invocation_watcher"
+require "synthesis/expectation"
+require "synthesis/expectation_matcher"
+require "synthesis/expectation_interceptor"
+require "synthesis/expectation_record_enabled"
+require "synthesis/reporter"
+require "synthesis/adapter"

data/synthesis.gemspec

@@ -0,0 +1,41 @@
+GEMSPEC =Gem::Specification.new do |s|
+  s.name = 'synthesis'
+  s.version = '0.1.6'
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "synthesis"
+  s.summary, s.description = 'A tool for Synthesized Testing'
+  s.authors = 'Stuart Caborn, George Malamidis'
+  s.email = 'george@nutrun.com'
+  s.homepage = 'http://synthesis.rubyforge.org'
+  s.has_rdoc = true
+  s.rdoc_options += ['--quiet', '--title', 'Synthesis', '--main', 'README', '--inline-source']
+  s.extra_rdoc_files = ['README', 'COPYING']
+  s.files = [
+    "COPYING",
+    "Rakefile",
+    "README",
+    "synthesis.gemspec",
+    "lib/synthesis/adapter/expectations.rb",
+    "lib/synthesis/adapter/mocha.rb",
+    "lib/synthesis/adapter/rspec.rb",
+    "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/reporter.rb",
+    "lib/synthesis/runner.rb",
+    "lib/synthesis/task.rb",
+    "lib/synthesis/util/mock_instance/mocha.rb",
+    "lib/synthesis/util/mock_instance/rspec.rb",
+    "lib/synthesis/util/mock_instance.rb",
+    "lib/synthesis.rb"
+  ]
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: gmalamid-synthesis
+version: !ruby/object:Gem::Version 
+  version: 0.1.6
+platform: ruby
+authors: 
+- Stuart Caborn, George Malamidis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: george@nutrun.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- COPYING
+files: 
+- COPYING
+- Rakefile
+- README
+- synthesis.gemspec
+- lib/synthesis/adapter/expectations.rb
+- lib/synthesis/adapter/mocha.rb
+- lib/synthesis/adapter/rspec.rb
+- 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/reporter.rb
+- lib/synthesis/runner.rb
+- lib/synthesis/task.rb
+- lib/synthesis/util/mock_instance/mocha.rb
+- lib/synthesis/util/mock_instance/rspec.rb
+- lib/synthesis/util/mock_instance.rb
+- lib/synthesis.rb
+has_rdoc: true
+homepage: http://synthesis.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Synthesis
+- --main
+- README
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: synthesis
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A tool for Synthesized Testing
+test_files: []
+