synthesis 0.0.1

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,55 @@
+= Synthesis
+
+== 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).
+
+== Installation
+
+ sudo gem i synthesis
+
+== Dependencies
+
+Synthesis's core doesn't have any dependencies. 
+
+When used with the Expectations adapter, it will depend on the Expectations[http://expectations.rubyforge.org] library.
+
+When used with the Mocha adapter, it will depend on the Mocha[http://mocha.rubyforge.org] library.
+
+== Usage
+
+Synthesis can be used through its Rake task. It currently has two supported adapters: Mocha (with Test::Unit) 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/**/*.rb</tt>
+
+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.ignore Array, Hash
+  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
+
+== Known Issues
+
+Synthesis will currently ignore dynamically generated at runtime methods.
+
+== Related reading
+
+* Synthesized Testing: A Primer ( http://nutrun.com/weblog/synthesized-testing-a-primer )
+* Using Synthesis With Test::Unit and Mocha ( http://nutrun.com/weblog/using-synthesis-with-test-unit-and-mocha )
+* Using Synthesis With Expectations ( http://nutrun.com/weblog/using-synthesis-with-expectations )

data/Rakefile

@@ -0,0 +1,92 @@
+require "rubygems"
+require "rake/testtask"
+require "rake/gempackagetask"
+require 'rake/rdoctask'
+require 'rake/contrib/sshpublisher'
+require File.dirname(__FILE__) + "/lib/synthesis/task"
+
+task :default => :test
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+end
+
+Synthesis::Task.new('synthesis:test:expectations') do |t|
+  t.adapter = :expectations
+  t.pattern = 'test_project/expectations/test/*_test.rb'
+end
+
+Synthesis::Task.new do |t|
+  t.pattern = 'test_project/mocha/test/*_test.rb'
+  t.ignore Array, Hash
+  # t.out = File.new('synthesis.test.txt', 'a')
+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
+
+namespace :svn do
+  task :st do
+    puts %x[svn st]
+  end
+
+  task :up do
+    puts %x[svn up]
+  end
+
+  task :add do
+    %x[svn st].split(/\n/).each do |line|
+      trimmed_line = line.delete('?').lstrip
+      if line[0,1] =~ /\?/
+        %x[svn add #{trimmed_line}]
+        puts %[added #{trimmed_line}]
+      end
+    end
+  end
+  
+  task :delete do
+    %x[svn st].split(/\n/).each do |line|
+      trimmed_line = line.delete('!').lstrip
+      if line[0,1] =~ /\!/
+        %x[svn rm #{trimmed_line}]
+        puts %[removed #{trimmed_line}]
+      end
+    end
+  end
+
+  desc "Run before checking in"
+  task :pc => ['svn:add', 'svn:delete', 'svn:up', :default, 'svn:st']
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.name = 'synthesis'
+  s.version = '0.0.1'
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "synthesis"
+  s.summary, s.description = 'A tool for Synthesized Testing'
+  s.author = 'Stuart Caborn, George Malamidis'
+  s.email = 'george@nutrun.com'
+  s.homepage = 'http://nutrun.com/synthesis'
+  s.has_rdoc = true
+  s.rdoc_options += ['--quiet', '--title', 'Queueue', '--main', 'README', '--inline-source']
+  s.extra_rdoc_files = ['README', 'COPYING']
+  excluded = FileList['etc/*']
+  # s.test_files = FileList['test/**/*_test.rb']
+  s.files = FileList['**/*.rb', 'COPYING', 'README', 'Rakefile'] - excluded
+end
+
+Rake::GemPackageTask.new(gem_spec) do |t|
+  t.need_zip = false
+  t.need_tar = false
+end

data/lib/synthesis.rb

@@ -0,0 +1,12 @@
+require "set"
+
+$: << File.dirname(__FILE__)
+
+require "synthesis/logging"
+require "synthesis/recordable"
+require "synthesis/object"
+require "synthesis/expectation_record"
+require "synthesis/method_invocation_watcher"
+require "synthesis/expectation"
+require "synthesis/report"
+require "synthesis/adapter"

data/lib/synthesis/adapter.rb

@@ -0,0 +1,27 @@
+module Synthesis
+  # Subclasses of Synthesis::Adapter must implement the run method
+  class Adapter
+    include Logging
+    
+    def initialize(pattern)
+      @pattern = pattern
+    end
+    
+    def fail_unless(&block)
+      log "Collecting expectations..."
+      Dir[@pattern].each { |t| require t }
+      exit -1 unless yield
+      log "Verifying expectation invocations..."
+      ExpectationRecord.record_invocations
+      yield
+    end
+    
+    def self.inherited(subclass)
+      @adapter = subclass
+    end
+    
+    def self.load(pattern)
+      @adapter.new(pattern)
+    end
+  end
+end

data/lib/synthesis/adapter/expectations.rb

@@ -0,0 +1,13 @@
+require "rubygems"
+require "mocha_standalone"
+require "expectations"
+
+$: << File.dirname(__FILE__) + "/../../"
+
+require "synthesis"
+require "synthesis/adapter/mocha/object"
+require "synthesis/adapter/mocha/class_method"
+require "synthesis/adapter/mocha/expectation_record"
+require "synthesis/adapter/mocha/method_invocation_watcher"
+require "synthesis/adapter/expectations/expectations_adapter"
+require "synthesis/adapter/expectations/suite_runner"

data/lib/synthesis/adapter/expectations/expectations_adapter.rb

@@ -0,0 +1,7 @@
+module Synthesis
+  class ExpectationsAdapter < Adapter
+    def run
+      fail_unless { Expectations::SuiteRunner.instance.suite.execute }
+    end
+  end
+end

data/lib/synthesis/adapter/expectations/suite_runner.rb

@@ -0,0 +1,7 @@
+module Expectations
+  class SuiteRunner  
+    def initialize
+      self.suite = Expectations::Suite.new
+    end  
+  end
+end

data/lib/synthesis/adapter/mocha.rb

@@ -0,0 +1,12 @@
+require "rubygems"
+require "mocha_standalone"
+require "test/unit"
+
+$: << File.dirname(__FILE__) + "/../../"
+
+require "synthesis"
+require "synthesis/adapter/mocha/object"
+require "synthesis/adapter/mocha/class_method"
+require "synthesis/adapter/mocha/expectation_record"
+require "synthesis/adapter/mocha/method_invocation_watcher"
+require "synthesis/adapter/mocha/mocha_adapter"

data/lib/synthesis/adapter/mocha/class_method.rb

@@ -0,0 +1,17 @@
+module Mocha
+  class ClassMethod
+    alias mocha_stub stub
+    
+    def stub
+      @stubbee.mocked!
+      mocha_stub
+    end
+    
+    alias mocha_unstub unstub
+    
+    def unstub
+      mocha_unstub
+      @stubbee.unmocked!
+    end
+  end
+end

data/lib/synthesis/adapter/mocha/expectation_record.rb

@@ -0,0 +1,13 @@
+module Synthesis
+  class ExpectationRecord
+    class << self
+      alias_method :add_mocha_expectation, :add_expectation
+
+      def add_expectation(obj, meth, args = [])
+        # Ignone things like "foo = mock"
+        return nil if obj.is_a?(Class::AnyInstance)
+        add_mocha_expectation(obj, meth, args)
+      end
+    end
+  end
+end

data/lib/synthesis/adapter/mocha/method_invocation_watcher.rb

@@ -0,0 +1,12 @@
+module Synthesis
+  class MethodInvocationWatcher
+    class << self
+      alias mocha_invoked invoked
+
+      def invoked(receiver, method, args = [])
+        return nil if receiver.mocked?
+        mocha_invoked(receiver, method, args)
+      end
+    end
+  end
+end

data/lib/synthesis/adapter/mocha/mocha_adapter.rb

@@ -0,0 +1,8 @@
+module Synthesis
+  class MochaAdapter < Adapter
+    def run
+      Test::Unit.run = true # Yes means no...
+      fail_unless { Test::Unit::AutoRunner.run }
+    end
+  end
+end

data/lib/synthesis/adapter/mocha/object.rb

@@ -0,0 +1,20 @@
+class Object
+  alias mocha_expects expects
+  
+  def expects(meth)
+    Synthesis::ExpectationRecord.add_expectation(self, meth)
+    mocha_expects(meth)
+  end
+  
+  def mocked!
+    @mocked = true
+  end
+  
+  def unmocked!
+    @mocked = false
+  end
+  
+  def mocked?
+    @mocked
+  end
+end

data/lib/synthesis/expectation.rb

@@ -0,0 +1,81 @@
+module Synthesis
+  module Expectation
+    def self.new(receiver, method, args = [])
+      if receiver.is_a?(Class) || receiver.is_a?(Module)
+        Singleton.new(receiver, method, args)
+      else
+        Instance.new(receiver, method, args)
+      end
+    end
+  
+    class Expectation
+      include Logging
+      attr_reader :receiver, :method, :args
+      
+      def initialize(receiver, method, args)
+        @receiver, @method, @args = receiver, method, args
+      end
+      
+      def record_invocations
+        meta_receiver.extend Recordable
+        meta_receiver.recordable_method @method
+      rescue NameError => e
+        log "Failed to record #{@method} on #{@receiver} : #{e.message}"
+      end
+      
+      def ==(other)
+        eql?(other)
+      end
+      
+      def invoked?
+        @invoked
+      end
+      
+      def invoked!
+        @invoked = true
+      end
+    end
+  
+    class Singleton < Expectation
+      def meta_receiver
+        @receiver.__metaclass__
+      end
+      
+      def eql?(other)
+        @receiver.name == other.receiver.name && @method == other.method
+      end
+      
+      def hash
+        (@receiver.name.hash * 23) + @method.hash
+      end
+      
+      def to_s
+        "#{@receiver.name}.#{@method}"
+      end
+    end
+    
+    class Instance < Expectation
+      def meta_receiver
+        @receiver.class
+      end
+      
+      def eql?(other)
+        meta_receiver.name == other.meta_receiver.name && @method == other.method
+      end
+      
+      def hash
+        (meta_receiver.name.hash * 23) + @method.hash
+      end
+      
+      def to_s
+        "#{meta_receiver.name}.new.#{@method}"
+      end
+    end
+    
+    class NilExpectation < Expectation
+      def initialize;end
+      def invoked!;end
+      def record_invocations;end
+    end
+  end
+end

data/lib/synthesis/expectation_record.rb

@@ -0,0 +1,59 @@
+module Synthesis
+  class ExpectationRecord
+    class << self
+      include Logging
+      
+      def add_expectation(receiver, method, args = [])
+        expectations << Expectation.new(receiver, method, args) unless ignore? receiver
+      end
+      
+      def ignore(*args)
+        ignored.merge args
+      end
+      
+      def expectations
+        @expectations ||= Set.new
+      end
+      
+      def ignored
+        @ignored ||= Set.new
+      end
+      
+      def [](matcher)
+        expectations.detect { |e| e == matcher } || Expectation::NilExpectation.new
+      end
+      
+      def record_invocations
+        expectations.each { |e| e.record_invocations }
+      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 ignore?(obj)
+        ignored.include?(obj.class) || ignored.include?(obj)
+      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 = [])
+      matcher = Expectation.new(receiver, method, args)
+      ExpectationRecord[matcher].invoked!
+    end
+  end
+end

data/lib/synthesis/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def __metaclass__
+    class << self; self end
+  end
+end

data/lib/synthesis/recordable.rb

@@ -0,0 +1,15 @@
+module Synthesis
+  module Recordable
+    def recordable_method(method)
+      alias_method "__recordable__#{method}", method
+      class_eval @@recordable_method_def[method]
+    end
+      
+    @@recordable_method_def = proc { |method| %(
+      def #{method}(*args, &block)
+        MethodInvocationWatcher.invoked(self, "#{method}".intern, args)
+        send "__recordable__#{method}", *args, &block
+      end
+    )}
+  end
+end

data/lib/synthesis/report.rb

@@ -0,0 +1,21 @@
+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 "SUCCESS."
+    0
+  end
+  
+  def failed?
+    ExpectationRecord.untested_expectations.any?
+  end
+  
+  module_function :report!, :failed?
+end

data/lib/synthesis/runner.rb

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

data/lib/synthesis/task.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+require 'rake'
+require 'rake/tasklib'
+
+module Synthesis
+  class Task < Rake::TaskLib
+    attr_accessor :verbose, :pattern, :ruby_opts, :adapter, :out
+
+    def initialize(name='synthesis:test')
+      @name = name
+      @ignored = []
+      yield self if block_given?
+      @pattern ||= 'test/**/*.rb'
+      @ruby_opts ||= []
+      @adapter ||= :mocha
+      define
+    end
+    
+    def ignore(*classes)
+      @ignored << classes
+      @ignored.flatten!
+    end
+
+    def define
+      desc "Run Synthesis tests"
+      task @name do
+        RakeFileUtils.verbose(@verbose) do
+          @ruby_opts.unshift("-w") if @warning
+          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
+  end
+end

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

@@ -0,0 +1,16 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
+
+module Synthesis
+  class ExpectationRecordTest < Test::Unit::TestCase
+    def teardown
+      ExpectationRecord.expectations.clear
+    end
+
+    def test_does_not_add_any_instance_expectation
+      any = Class::AnyInstance.new(Object)
+      ExpectationRecord.add_expectation(any, :foo)
+      assert_equal(0, ExpectationRecord.expectations.size)
+    end  
+  end
+end

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

@@ -0,0 +1,29 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
+
+module Synthesis
+  class MethodInvocationWatcherTest < Test::Unit::TestCase
+    def teardown
+      ExpectationRecord.expectations.clear
+    end
+
+    def test_ignores_invocation_for_mocked_object
+      foo = Class.new { def self.bar;end }
+      ExpectationRecord.add_expectation foo, :bar
+      ExpectationRecord.record_invocations
+      e = ExpectationRecord.expectations.to_a[0]
+      foo.expects(:bar)
+      foo.bar
+      assert !e.invoked?
+    end
+
+    def test_records_invocation_for_non_mocked_object
+      foo = Class.new { def self.bar;end }
+      ExpectationRecord.add_expectation foo, :bar
+      ExpectationRecord.record_invocations
+      e = ExpectationRecord.expectations.to_a[0]
+      foo.bar
+      assert e.invoked?
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../../../lib/synthesis/adapter/mocha"
+
+module Synthesis
+  class ObjectTest < Test::Unit::TestCase
+    def test_records_singleton_method_expectation
+      ExpectationRecord.expects(:add_expectation).with(Hash, :foo)
+      Hash.expects(:foo)
+      Hash.foo
+    end
+
+    def test_records_instance_method_expectation
+      hash = Hash.new
+      ExpectationRecord.expects(:add_expectation).with(hash, :foo)
+      hash.expects(:foo)
+      hash.foo
+    end  
+  end
+end

data/test/synthesis/expectation_record_test.rb

@@ -0,0 +1,46 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../lib/synthesis"
+
+module Synthesis
+  class ExpectationRecordTest < Test::Unit::TestCase
+    def teardown
+      ExpectationRecord.expectations.clear
+      ExpectationRecord.ignored.clear
+    end
+
+    def test_adds_expectation
+      ExpectationRecord.add_expectation Object.new, :to_s
+      assert_equal(1, ExpectationRecord.expectations.size)
+    end
+
+    def test_watches_expectation_invocations
+      c = Class.new { def foo; end }
+      ExpectationRecord.add_expectation c.new, :foo
+      ExpectationRecord.record_invocations
+      a = c.new
+      MethodInvocationWatcher.expects(:invoked).with(a, :foo, [])
+      a.foo
+    end
+
+    def test_finds_expectation
+      ExpectationRecord.add_expectation Object.new, :foo
+      expected = ExpectationRecord.expectations.to_a[0]
+      matcher = Expectation.new Object.new, :foo
+      actual = ExpectationRecord[matcher]
+      assert_equal(expected, actual)
+    end
+
+    def test_returns_nil_expectation_on_no_expectation_found
+      ExpectationRecord.add_expectation Object.new, :foo
+      matcher = Expectation.new Object.new, :bar
+      actual_instance = ExpectationRecord[matcher]
+      assert_kind_of Expectation::NilExpectation, actual_instance
+    end
+
+    def test_does_not_add_expectation_for_ignored_class
+      ExpectationRecord.ignore Hash
+      ExpectationRecord.add_expectation Hash, :foo
+      assert ExpectationRecord.expectations.empty?
+    end
+  end
+end

data/test/synthesis/expectation_test.rb

@@ -0,0 +1,68 @@
+require "test/unit"
+require File.dirname(__FILE__) + "/../../lib/synthesis"
+
+module Synthesis
+  class ExpectationTest < Test::Unit::TestCase
+    def test_creates_singleton_method_expectation_given_class
+      expectation = Expectation.new Class.new, :foo
+      assert_kind_of Expectation::Singleton, expectation
+    end
+
+    def test_creates_instance_method_expectation_given_instance
+      expectation = Expectation.new Class.new.new, :foo
+      assert_kind_of Expectation::Instance, expectation
+    end
+
+    def test_creates_singleton_method_expectation_given_module
+      expectation = Expectation.new Module.new, :foo
+      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
+      expectation.record_invocations
+      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
+      expectation.record_invocations
+      assert_respond_to receiver, :__recordable__foo
+    end
+
+    def test_equality
+      exp1 = Expectation.new Object.new, :foo
+      exp2 = Expectation.new Object.new, :foo
+      assert_equal exp1, exp2
+    end
+
+    def test_non_equality
+      exp1 = Expectation.new Hash.new, :foo
+      exp2 = Expectation.new Array.new, :foo
+      assert_not_equal exp1, exp2
+    end
+
+    def test_make_sure_equality_works_with_uniq
+      arr = [
+        Expectation.new(String, :new, []), 
+        Expectation.new(String, :new, [])
+      ]
+      assert_equal(1, arr.uniq.size)
+    end
+
+    def test_does_not_blow_up_on_name_error
+      expectation = Expectation.new(Hash, :bad)
+      silent(expectation) do
+        assert_nothing_raised(NameError) { expectation.record_invocations }
+      end
+    end
+
+    def silent(object)
+      object.silence!
+      yield
+      object.speak!
+    end
+  end
+end

data/test/synthesis/method_invocation_watcher_test.rb

@@ -0,0 +1,13 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../lib/synthesis"
+
+module Synthesis
+  class MethodInvocationWatcherTest < Test::Unit::TestCase
+    def test_marks_expectation_invoked
+      ExpectationRecord.add_expectation(Hash, :to_s, [])
+      MethodInvocationWatcher.invoked(Hash, :to_s, [])
+      expectation = ExpectationRecord.expectations.to_a.first
+      assert expectation.invoked?
+    end
+  end
+end

data/test/synthesis/recordable_test.rb

@@ -0,0 +1,22 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../lib/synthesis"
+
+module Synthesis
+  class RecordableTest < Test::Unit::TestCase
+    def test_redefines_method
+      foo = Class.new { def a; end }
+      foo.extend Recordable
+      foo.recordable_method(:a)
+      assert_respond_to(foo.new, :__recordable__a)
+    end
+
+    def test_records_method_invocation
+      foo = Class.new { def b; end }
+      foo.extend Recordable
+      foo.recordable_method(:b)
+      bar = foo.new
+      MethodInvocationWatcher.expects(:invoked).with(bar, :b, [])
+      bar.b
+    end  
+  end
+end

data/test_project/expectations/test/data_brander_test.rb

@@ -0,0 +1,9 @@
+require "rubygems"
+require "expectations"
+require File.dirname(__FILE__) + "/../../test_project"
+
+Expectations do
+  expect Storage.new('whatever').to_receive(:save).with('METAL - rock') do |storage|
+    DataBrander.new(storage).save_branded 'rock'
+  end
+end

data/test_project/expectations/test/storage_test.rb

@@ -0,0 +1,14 @@
+require "rubygems"
+require "expectations"
+require File.dirname(__FILE__) + "/../../test_project"
+
+Expectations do
+  expect "rock" do
+    begin
+      Storage.new('test.txt').save('rock')
+      File.read 'test.txt'
+    ensure
+      FileUtils.rm_f 'test.txt'
+    end
+  end
+end

data/test_project/lib/data_brander.rb

@@ -0,0 +1,11 @@
+class DataBrander
+  BRAND = "METAL"
+  
+  def initialize(pstore)
+    @pstore = pstore
+  end
+  
+  def save_branded(data)
+    @pstore.save "#{BRAND} - #{data}"
+  end
+end

data/test_project/lib/storage.rb

@@ -0,0 +1,9 @@
+class Storage
+  def initialize(filename)
+    @filename = filename
+  end
+  
+  def save(val)
+    File.open(@filename, 'w') {|f| f << val}
+  end
+end

data/test_project/mocha/test/data_brander_test.rb

@@ -0,0 +1,10 @@
+%w(test/unit rubygems mocha).each { |l| require l }
+require File.dirname(__FILE__) + "/../../test_project"
+
+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'
+  end
+end

data/test_project/mocha/test/storage_test.rb

@@ -0,0 +1,12 @@
+require "test/unit"
+require "fileutils"
+require File.dirname(__FILE__) + "/../../test_project"
+
+class StorageTest < Test::Unit::TestCase
+  def test_saves_to_file
+    Storage.new('test.txt').save('rock')
+    assert_equal 'rock', File.read('test.txt')
+  ensure
+    FileUtils.rm_f('test.txt')
+  end
+end

data/test_project/test_project.rb

@@ -0,0 +1,3 @@
+$: << File.dirname(__FILE__) + '/lib/'
+require "storage"
+require "data_brander"

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: synthesis
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stuart Caborn, George Malamidis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-01-12 00:00:00 +00:00
+default_executable: 
+dependencies: []
+
+description: 
+email: george@nutrun.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- COPYING
+files: 
+- lib/synthesis/adapter/expectations/expectations_adapter.rb
+- lib/synthesis/adapter/expectations/suite_runner.rb
+- lib/synthesis/adapter/expectations.rb
+- lib/synthesis/adapter/mocha/class_method.rb
+- lib/synthesis/adapter/mocha/expectation_record.rb
+- lib/synthesis/adapter/mocha/method_invocation_watcher.rb
+- lib/synthesis/adapter/mocha/mocha_adapter.rb
+- lib/synthesis/adapter/mocha/object.rb
+- lib/synthesis/adapter/mocha.rb
+- lib/synthesis/adapter.rb
+- lib/synthesis/expectation.rb
+- lib/synthesis/expectation_record.rb
+- lib/synthesis/logging.rb
+- lib/synthesis/method_invocation_watcher.rb
+- lib/synthesis/object.rb
+- lib/synthesis/recordable.rb
+- lib/synthesis/report.rb
+- lib/synthesis/runner.rb
+- lib/synthesis/task.rb
+- lib/synthesis.rb
+- test/synthesis/adapter/mocha/expectation_record_test.rb
+- test/synthesis/adapter/mocha/method_invocation_watcher_test.rb
+- test/synthesis/adapter/mocha/object_test.rb
+- test/synthesis/expectation_record_test.rb
+- test/synthesis/expectation_test.rb
+- test/synthesis/method_invocation_watcher_test.rb
+- test/synthesis/recordable_test.rb
+- test_project/expectations/test/data_brander_test.rb
+- test_project/expectations/test/storage_test.rb
+- test_project/lib/data_brander.rb
+- test_project/lib/storage.rb
+- test_project/mocha/test/data_brander_test.rb
+- test_project/mocha/test/storage_test.rb
+- test_project/test_project.rb
+- COPYING
+- README
+- Rakefile
+has_rdoc: true
+homepage: http://nutrun.com/synthesis
+post_install_message: 
+rdoc_options: 
+- --quiet
+- --title
+- Queueue
+- --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.0.1
+signing_key: 
+specification_version: 2
+summary: A tool for Synthesized Testing
+test_files: []
+