mockery 0.4.1

data/Rakefile

@@ -0,0 +1,106 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/packagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+PKG_VERSION = "0.4.1"
+
+desc "Default task"
+task :default => [:unit_tests, :acc_tests]
+
+desc "Run the unit tests"
+Rake::TestTask.new do |t|
+  t.name = 'unit_tests'
+  #t.libs << 'tests/unit'
+  #t.libs << 'lib'
+  t.test_files = FileList['tests/unit/unit_tests.rb']
+  t.verbose = true
+end
+
+desc "Run the acceptance tests"
+Rake::TestTask.new do |t|
+  t.name = 'acc_tests'
+  #t.libs << 'tests/acc'
+  #t.libs << 'lib'
+  t.test_files = FileList['tests/acc/acc_tests.rb']
+  t.verbose = true
+end
+
+SOURCE_FILES = FileList.new do |fl|
+  ["lib", "tests"].each do |dir|
+    fl.include "#{dir}/**/*"
+  end
+  fl.include "Rakefile"
+  fl.include "setup.rb"
+  fl.exclude( /\bCVS\b/ )
+end
+
+desc "Build the Mockery distribution"
+Rake::PackageTask.new("mockery", PKG_VERSION) do |p|
+  p.need_tar = true
+  p.need_zip = true
+  p.package_dir = '../../tmp/mockery-pkg'
+  p.package_files = SOURCE_FILES
+end
+
+Rake::RDocTask.new do |rd|
+  rd.rdoc_files.include('lib/**/*.rb')
+  rd.template = 'jamis'
+end
+
+desc "Create the 'build' directory"
+task :build_build do
+  Dir.mkdir('build') unless File.directory?('build')
+end
+
+desc "Build rdoc pages"
+task :build_rdoc => [:rdoc, :build_build] do
+  File.rename('html', 'build/rdoc')
+end
+
+desc "create missing file rdoc blank.html"
+task :build_blank do
+  if ! File.exist?("build/rdoc/blank.html")
+    File.open('build/rdoc/blank.html', 'w') do |handle|
+      handle.puts('<html/>')
+    end
+  end
+end
+
+GEM_FILES = FileList.new do |fl|
+  ['lib', 'tests'].each do |dir|
+    fl.include "#{dir}/**/*"
+  end
+  fl.include "Rakefile"
+  fl.exclude( /\bCVS\b/ )
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.autorequire = 'mockery/controller'
+  s.description = <<EOF
+Mockery dynamically generates mock objects and verifies
+that they are used as expected.
+EOF
+  s.email = 'shea@gtsdesign.com'
+  s.files = GEM_FILES
+  s.has_rdoc = false
+  s.homepage = 'http://mockery.rubyforge.org'
+  s.name = 'mockery'
+  s.requirements << 'none'
+  s.rubyforge_project = 'mockery'
+  s.summary = "Dynamic mock objects"
+  s.version = PKG_VERSION
+end
+
+desc "Create a .gem file for Mockery"
+task :gem do
+end
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.package_dir = '../../tmp/mockery-pkg'
+  p.need_zip = true
+  p.need_tar = true
+end
+

data/lib/mockery/call.rb

@@ -0,0 +1,40 @@
+
+module Mockery
+  
+  class Call
+
+    attr_accessor :args,
+      :caller,
+      :method_name,
+      :return_value
+      
+    def digest(caller, args)
+      @caller = caller
+      @method_name = args[0]
+      @args = args[1 .. -1]
+    end
+
+    # equality of Call objects is based on equality of
+    # the attributes, with the exception of @caller (since
+    # the recording is done by a Recorder, not an object
+    # of the target class)
+    def ==(call)
+      return call != nil &&
+          call.class == Mockery::Call &&
+          @method_name == call.method_name &&
+          @args == call.args
+    end
+
+    def to_s
+      args_str = (@args == nil) ?
+        'nil' :
+        "[#{@args.join(',')}]"
+      return "<#{self.class.name}:0x#{object_id.abs.to_s(16)}" +
+        " caller=#{@caller}" +
+        " method_name=#{@method_name}" +
+        " args=#{args_str}" +
+        ">"
+    end
+  end
+
+end

data/lib/mockery/controller.rb

@@ -0,0 +1,75 @@
+
+#
+# Name:  Mockery::Controller  (lib/mockery/controller.rb)
+#
+# Description:
+#
+#      The Controller class coordinates a test.
+#
+#
+#  Copyright 2005 Gary Shea
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+require 'mockery/call'
+require 'mockery/mock'
+require 'mockery/mock_class_factory'
+require 'mockery/record_control'
+require 'mockery/recorder'
+
+module Mockery
+
+  class Controller
+    
+    def initialize(*klasses)
+      @mocks = []
+      klasses.each do |klass|
+        mock = Mock.new(klass)
+        @mocks << mock
+      end
+    end
+
+    def record(&block)
+      recorders = @mocks.collect { |mock| mock.recorder }
+      ctl = RecordControl.new(recorders)
+      args = [recorders, ctl].flatten[0 ... block.arity.abs]
+      block.call(*args)
+    end
+    
+    def try(&block)
+      objs = @mocks.collect { |mock| mock.mocked_object }
+      block.call(*objs)
+    end
+    
+    def validate
+      @mocks.each do |mock|
+        return false if ! mock.validate
+      end
+      return true
+    end
+    
+    def error_report
+      report = ''
+      index = 1
+      @mocks.each do |mock|
+        tmp_index = index
+        index = index + 1
+        report << "mock #{tmp_index} (class: #{mock.class})\n"
+        report << mock.error_report
+      end
+      return report
+    end
+
+  end
+end

data/lib/mockery/mock.rb

@@ -0,0 +1,158 @@
+
+#
+# Name:  Mockery::Mock  (lib/mockery/mock.rb)
+#
+# Description:
+#
+#      The Mock class handles configuration, construction,
+#      and validation of a single mock object.
+#
+#
+#  Copyright 2005 Gary Shea
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+require 'mockery/call'
+require 'mockery/mock_class_factory'
+require 'mockery/recorder'
+
+module Mockery
+
+  class Mock
+
+    attr_reader :klass, :recorder
+    
+    def initialize(klass)
+      @klass = klass
+      @recorder = Recorder.new(klass)
+      @class_factory = MockClassFactory.new(klass)
+      @return_values = nil
+    end
+
+    def process_history
+      @recorder.history.each do |call|
+        method = call.method_name
+        if @return_values.has_key?(method)
+          @return_values[method] << call.return_value
+        else
+          @return_values[method] = [call.return_value]
+        end
+      end
+    end
+    
+    def add_methods
+      @return_values.each_key do |method_name|
+        @class_factory.add_method(method_name)
+      end
+    end
+    
+    def mocked_object
+      @return_values = Hash.new
+      process_history
+      add_methods
+      @class_factory.create_initialize(@return_values.keys)
+      @instance = @class_factory.create_instance(@return_values)
+      return @instance
+    end
+    
+    def validate
+      return @recorder.history == @instance.instance_history
+    end
+    
+    def error_report
+    
+      report = ''
+      
+      recorded = @recorder.history
+      actual = @instance.instance_history
+      if recorded.size > actual.size
+        max_idx = @recorder.history.size
+      else
+        max_idx = @instance.instance_history.size
+      end
+  
+      (0 ... max_idx).each do |idx|
+        if idx >= recorded.size
+          report << "unexpected: #{describe_call(actual[idx])}\n"
+        elsif idx >= actual.size
+          report << "expected: #{describe_call(recorded[idx])}\n"
+        elsif recorded[idx] != actual[idx]
+          report << "expected\n#{describe_call(recorded[idx])}\n"
+          report << "but got\n#{describe_call(actual[idx])}\n"
+        end
+      end
+      
+      return report
+      
+    end
+    
+    def describe_call(call)
+      return '<' + call.caller.class.name + '>.' +
+        call.method_name.to_s + '(' +
+        call.args[0 .. -1].collect{|arg| expanding_describe_value(arg)}.join(', ') +
+        ')'
+    end
+    
+    def expanding_describe_value(value)
+      dscr = describe_simple_value(value)
+      if dscr == nil
+        dscr = "<#{value.class.name}:#{object_id_to_s(value)} "
+        dscr << value.instance_variables.collect { |var_name|
+          var_dscr = ''
+          var_dscr << "#{var_name}="
+          var_value = value.instance_variable_get(eval(":#{var_name}"))
+          var_dscr << non_expanding_describe_value(var_value)
+          var_dscr
+        }.join(', ')
+        dscr << '>'
+      end
+      return dscr
+    end
+    
+    def non_expanding_describe_value(value)
+      dscr = describe_simple_value(value)
+      if dscr == nil
+         dscr = '<' + value.class.name + object_id_to_s(value) + '>'
+      end
+      return dscr
+    end
+    
+    def describe_simple_value(value)
+      if value == nil
+        return 'nil'
+      elsif value.class == Fixnum
+        return value.to_s
+      elsif value.class == Symbol
+        return ':' + value.to_s
+      elsif value.class == String
+        return "'" + value + "'"
+      elsif value.class == Array
+        return '[' + value.join(', ') + ']'
+      elsif value.class == Hash
+        dscrs = []
+        value.each { |key, value|
+          dscrs << "#{key} => #{value}"  
+        }
+        return '{' + dscrs.join(',') + '}'
+      else
+        return nil
+      end
+    end
+    
+    def object_id_to_s(obj)
+      return ':0x' + obj.object_id.abs.to_s(16)
+    end
+
+  end
+end

data/lib/mockery/mock_class_factory.rb

@@ -0,0 +1,54 @@
+
+module Mockery
+
+  class MockClassFactory
+    
+    def initialize(user_klass)
+
+      klass = Class.new(user_klass)
+      klass.class_eval {
+        attr_reader :instance_history
+      }
+      
+      @klass = klass
+      @return_values = Hash.new
+      
+    end
+
+    def add_method(method_name)
+      var_name = "@___#{method_name}_rv"
+      def_string = "@klass.class_eval {\n" +
+        "  def #{method_name}(*args)\n" +
+        "    call = Mockery::Call.new\n" +
+        "    call.caller = self\n" +
+        "    call.method_name = :#{method_name}\n" +
+        "    call.args = args\n" +
+        "    @instance_history << call\n" +
+        "    return #{var_name}.size == 0 ? nil : #{var_name}.shift\n" +
+        "  end\n" +
+        "}\n"
+      eval(def_string)
+    end
+    
+    def create_initialize(method_names)
+      def_string = "@klass.class_eval {\n" +
+        "  def initialize(*args, &block)\n" +
+        "    @instance_history = []\n"
+      method_names.each do |method, values|
+        def_string << "    @__#{method.to_s}_rv = nil\n"
+      end
+      def_string << ("  end\n" + "}\n")
+      eval(def_string)
+    end
+
+    def create_instance(return_values)
+      mock = @klass.new
+      return_values.each do |method, value|
+        mock.instance_variable_set(eval(":@___#{method}_rv"), value)
+      end
+      return mock
+    end
+
+  end
+
+end

data/lib/mockery/record_control.rb

@@ -0,0 +1,54 @@
+
+#
+# Name:  Mockery::RecordControl  (lib/mockery/record_control.rb)
+#
+# Description:
+#
+#      The RecordControl class enables recording to be 'paused'
+#      inside a 'try' block.
+#
+#
+#  Copyright 2005 Gary Shea
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+module Mockery
+  
+  class RecordControl
+    
+    def initialize(mocks)
+      @mocks = mocks
+    end
+    
+    def pause(&block)
+      self.stop
+      block.call
+      self.start
+    end
+
+    def stop
+      @mocks.each do |mock|
+        mock.__record_state = false
+      end
+    end
+
+    def start
+      @mocks.each do |mock|
+        mock.__record_state = true
+      end
+    end
+
+  end
+
+end