mockery 0.4.1

data/tests/unit/mockery/mock_class_factory_test.rb

@@ -0,0 +1,207 @@
+
+#
+# Name:  MockFactoryTest  (tests/unit/mockery/mock_factory_test.rb)
+#
+# Description:
+#
+#      Unit tests for the Mockery::MockFactory 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 'test/unit'
+
+require 'mockery/mock_class_factory'
+
+class MockClassFactoryTest < Test::Unit::TestCase
+
+  def test_initialize
+
+    factory_class = Class.new(Mockery::MockClassFactory)
+    factory_class.class_eval {
+      attr_reader :klass,
+        :return_values
+    }
+    
+    base_class = Class.new
+    factory = factory_class.new(base_class)
+    
+    assert_equal(base_class, factory.klass.superclass)
+    
+    assert_equal(Hash, factory.return_values.class)
+    
+    assert_equal(true, factory.klass.method_defined?(:instance_history))
+    mock = factory.klass.new
+    assert_equal(nil, mock.instance_history)
+    
+  end
+  
+  def test_add_method
+
+    # instruct the factory to mock a method.
+    # return values are pulled from an instance variable
+
+    factory_class = Class.new(Mockery::MockClassFactory)
+    factory_class.class_eval {
+      attr_accessor :klass
+    }
+    factory = factory_class.new(Class.new)
+    
+    # this is the class that the user would be handing
+    # to the factory
+    base_class = Class.new
+    base_class.class_eval {
+      attr_accessor :instance_history
+      def blruk(num)
+        return 'boss hog'
+      end
+    }
+    
+    # this is an adequate fake of the class built by the
+    # base_class method.  henceforth the 'mock class'.
+    # this class overrides the one set by the constructor,
+    # so we don't have to worry about what the constructor
+    # is actually doing
+    klass = Class.new(base_class)
+    factory.klass = klass
+    
+    # tell the factory to add an instrumented version of
+    # this method to the mock class.  do it multiple times
+    # so we know it's (whatever that damn word is, grrr)
+    factory.add_method('blruk')
+    factory.add_method('blruk')
+
+    # create an instance of the mock class, find out what
+    # happens when the method is called.
+
+    mock_class = Class.new(klass)
+    mock_class.class_eval {
+      attr_writer :___blruk_rv
+    }
+    mock = mock_class.new
+    mock.instance_history = []
+    mock.___blruk_rv = [27, 'arf']
+    
+    rv1 = mock.blruk('zzp', 47)
+    rv2 = mock.blruk('pwx', 83)
+    
+    assert_equal(2, mock.instance_history.size)
+    
+    # first call...
+    assert_equal(mock, mock.instance_history[0].caller)
+    assert_equal(:blruk, mock.instance_history[0].method_name)
+    assert_equal(['zzp', 47], mock.instance_history[0].args)
+    assert_equal(27, rv1)
+    
+    # second call...
+    assert_equal(mock, mock.instance_history[1].caller)
+    assert_equal(:blruk, mock.instance_history[1].method_name)
+    assert_equal(['pwx', 83], mock.instance_history[1].args)
+    assert_equal('arf', rv2)
+    
+  end
+  
+  def test_create_initialize
+  
+    # the initialize method sets up:
+    #   1) the instance variable where the
+    #      call history is stored, and 
+    #   2) the instance variables which hold
+    #      values which are returned from
+    #      the mocked methods.
+
+    factory_class = Class.new(Mockery::MockClassFactory)
+    factory_class.class_eval {
+      attr_accessor :klass,
+        :return_values
+    }
+    factory = factory_class.new(Class.new)
+    
+    # this is the class that the user would be handing
+    # to the factory
+    base_class = Class.new
+    base_class.class_eval {
+      def blruk(num)
+        return 'boss hog'
+      end
+    }
+    
+    # this is an adequate fake of the class built by the
+    # base_class method.  henceforth the 'mock class'.
+    # this overrides the class given in the constructor
+    # above, so we're not testing the constructor.
+    klass = Class.new(base_class)
+    klass.class_eval {
+      attr_accessor :instance_history
+    }
+    factory.klass = klass
+
+    # set the return values for the #xxx method
+    rvs = {:xxx =>[27, 'dog']}
+    
+    # create the initialize method
+    factory.create_initialize(rvs.keys)
+    
+    # create an instance of the class
+    # so that the presence and contents of the
+    # return sequence can be tested
+    mock = klass.new
+
+    assert(mock.instance_variables.index('@__xxx_rv') != nil)
+    assert_equal(Array, mock.instance_history.class)
+  end
+  
+  def test_create_instance
+
+    # use #new to create the instance and then
+    # set the return values for each method.
+
+    factory_class = Class.new(Mockery::MockClassFactory)
+    factory_class.class_eval {
+      attr_accessor :klass
+    }
+    factory = factory_class.new(Class.new)
+    
+    rvs = {:xxx => ['arf', 94]}
+    
+    # this is the class that the user would be handing
+    # to the factory
+    base_class = Class.new
+    base_class.class_eval {
+      attr_accessor :instance_history
+      attr_reader :___xxx_rv
+      def blruk(num)
+        return 'boss hog'
+      end
+    }
+    
+    # this is an adequate fake of the class built by the
+    # base_class method.  henceforth the 'mock class'.
+    # it overrides the class given in the constructor
+    # above, so we're not testing the constructor.
+    klass = Class.new(base_class)
+    factory.klass = klass
+    
+    instance = factory.create_instance(rvs)
+    
+    assert_equal(factory.klass, instance.class)
+    
+    # the instance must have been set up with the correct values
+
+    assert_equal(['arf', 94], instance.___xxx_rv)
+  end
+  
+end

data/tests/unit/mockery/mock_test.rb

@@ -0,0 +1,247 @@
+
+#
+# Name:  MockTest  (tests/unit/mockery/mock_test.rb)
+#
+# Description:
+#
+#      Unit tests for the Mockery::Mock object, which holds
+#      information used to construct 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 'test/unit'
+
+require 'mockery/mock'
+
+class MockTest < Test::Unit::TestCase
+
+  def test_initialize
+  
+    # a new instance is initialized with a class object.
+    # a new mock class factory and recorder should be created
+    # by the initializer.
+
+    mock_class = Class.new(Mockery::Mock)
+    mock_class.class_eval {
+      attr_reader :class_factory,
+        :klass,
+        :recorder,
+        :return_values
+    }
+  
+    klass = Class.new
+    
+    mock = mock_class.new(klass)
+    
+    assert_equal(klass, mock.klass)
+    assert_equal(Mockery::Recorder, mock.recorder.class)
+    assert_equal(Mockery::MockClassFactory, mock.class_factory.class)
+    assert_equal(nil, mock.return_values)
+    
+    recorder = mock.recorder
+    def recorder.klass
+      return @klass
+    end
+    assert_equal(klass, recorder.klass)
+    
+    factory = mock.class_factory
+    def factory.klass
+      return @klass
+    end
+    assert_equal(klass, factory.klass.superclass)
+  end
+
+  def test_mocked_object
+  
+    # mocked_object returns an instance of an object
+    # which is derived from the object the user
+    # gave us, with each method used in #record
+    # over-ridden so that the arguments can be
+    # recorded and the proper value (if any) returned.
+    #
+    # really what it does is set up an empty
+    # return_values hash, call process_history() to
+    # populate the hash, call add_methods() to build
+    # the mocked methods in the mock class, calls
+    # create_initialize to build the initialize() method
+    # in the mock class, and finally returns an instance
+    # of the mocked class constructed by the class_factory.
+
+
+    # can't tell if the return_values hash
+    # was changed unless we have a mock
+    # to look at it with.
+
+    klass = Class.new
+    
+    mock_class = Class.new(Mockery::Mock)
+    mock_class.class_eval {
+      attr_reader :am_called,
+        :instance,
+        :ph_called,
+        :return_values
+      attr_writer :class_factory
+      def process_history
+        @ph_called = true
+      end
+      def add_methods
+        @am_called = true
+      end
+    }
+    mock = mock_class.new(klass)
+
+    # can't tell if the correct methods have
+    # been called on the factory without a mock
+    factory_class = Class.new
+    factory_class.class_eval {
+      attr_reader :names,
+        :rvs
+      attr_writer :ret_instance
+      def create_initialize(names)
+        @names = names
+      end
+      def create_instance(rvs)
+        @rvs = rvs
+        return @ret_instance
+      end
+    }
+    factory = factory_class.new
+    
+    ret_obj = Object.new
+    factory.ret_instance = ret_obj
+    
+    mock.class_factory = factory
+    
+    obj = mock.mocked_object
+    assert_equal(true, mock.ph_called)
+    assert_equal(true, mock.am_called)
+    assert_equal(mock.return_values.keys, factory.names)
+    assert_equal(mock.return_values, factory.rvs)
+    assert_equal(ret_obj, obj)
+    
+    # we will be needing the instance value in
+    # validate:
+
+    assert_equal(ret_obj, mock.instance)
+    
+    return_values = mock.return_values
+
+  end
+
+  def test_process_history
+  
+    # process_history steps through the history
+    # held by the recorder, building the return_values
+    # hash.  every method used in the recorder is
+    # a key in the return_values hash.  each call
+    # to the method is given either a 'nil' value
+    # or the value in call.return_value.
+
+    # will need a mock recorder, as that is where
+    # history comes from
+
+    rec_class = Class.new(Mockery::Recorder)
+    rec_class.class_eval {
+      attr_writer :history
+    }
+    rec = rec_class.new
+
+    # the mock recorder needs some history, so
+    # build a couple Call objects
+
+    call = Mockery::Call.new
+    call.method_name = :blork
+    call.args = ['a', 1]
+    call.caller = Object.new
+    call.return_value = 23
+    rec.history << call
+
+    call = Mockery::Call.new
+    call.method_name = :xnurg
+    call.return_value = 'igg'
+    rec.history << call
+
+    call = Mockery::Call.new
+    call.method_name = :xnurg
+    call.return_value = 'ogg'
+    rec.history << call
+
+    # will need a Mock object to load the recorder
+    # into and call process_history() on
+
+    mock_class = Class.new(Mockery::Mock)
+    mock_class.class_eval {
+      attr_accessor :recorder,
+        :return_values
+    }
+    mock = mock_class.new(Class.new)
+
+    mock.recorder = rec
+    mock.return_values = Hash.new
+    
+    mock.process_history
+    
+    assert_equal(2, mock.return_values.size)
+    assert_equal([23], mock.return_values[:blork])
+    assert_equal(['igg', 'ogg'], mock.return_values[:xnurg])
+  end
+
+  def test_add_methods
+  
+    # add_methods steps through the method names
+    # in @return_values, adding each one to
+    # the class being built up in the mock class
+    # factory.
+
+    # will need to mock the object factory so we
+    # aren't trying to add real methods.
+
+    factory_class = Class.new
+    factory_class.class_eval {
+      attr_reader :method_name
+      def initialize
+        @method_name = []
+      end
+      def add_method(method_name)
+        @method_name << method_name
+      end
+    }
+    factory = factory_class.new
+
+    # will need a Mock object to load the factory
+    # into and call add_methods() on
+
+    mock_class = Class.new(Mockery::Mock)
+    mock_class.class_eval {
+      attr_accessor :return_values
+      attr_writer :class_factory
+    }
+    mock = mock_class.new(Class.new)
+    mock.class_factory = factory
+    mock.return_values = {
+      :xxx => nil,
+      :yyy => nil,
+    }
+    
+    mock.add_methods
+    
+    assert_equal(2, factory.method_name.size)
+    assert(factory.method_name.index(:xxx) != nil)
+    
+  end
+  
+end