mockery 0.4.1

data/lib/mockery/recorder.rb

@@ -0,0 +1,48 @@
+
+#
+# Name:  Mockery::Recorder  (lib/mockery/recorder.rb)
+#
+# Description:
+#
+#      The Recorder class makes a record of the events
+#      in the 'record' 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.
+#
+
+require 'mockery/call'
+
+module Mockery
+  
+  class Recorder
+    
+    attr_reader :history
+    
+    def initialize(klass = nil)
+      @klass = klass
+      @history = []
+    end
+    
+    def method_missing(*args)
+      call = Mockery::Call.new
+      call.digest(self, args)
+      @history << call
+      return call
+    end
+    
+  end
+
+end

data/tests/acc/acc_tests.rb

@@ -0,0 +1,18 @@
+
+$:.unshift('lib')
+$: << 'tests/acc'
+
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+
+require 'mockery/mockery_test'
+
+class Tests
+
+  def self.suite
+    suite = Test::Unit::TestSuite.new
+    suite << MockeryTest.suite
+    return suite
+  end
+
+end

data/tests/acc/mockery/mockery_test.rb

@@ -0,0 +1,105 @@
+
+#
+# Name:  MockeryTest  (tests/acc/mockery/mockery_test.rb)
+#
+# Description:
+#
+#      Acceptance tests for the Mockery package
+#
+#
+#  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/controller'
+
+class MockeryTest < Test::Unit::TestCase
+
+  def test_basic_history_fail
+  
+    testee_class = Class.new
+    testee_class.class_eval {
+      def route(where, x)
+      end
+    }
+    
+    mockery = Mockery::Controller.new(testee_class)
+    mockery.record do |testee|
+      testee.left(23)
+    end
+    mockery.try do |testee|
+      testee.route('left', 23)
+    end
+    assert_equal(false, mockery.validate)
+  end
+
+  def test_basic_history_success
+  
+    testee_class = Class.new
+    testee_class.class_eval {
+      def route(where, x)
+        if where == 'left'
+          left(x)
+        end
+      end
+      def left(value)
+      end
+    }
+    
+    mockery = Mockery::Controller.new(testee_class)
+    mockery.record do |testee|
+      testee.left(23)
+    end
+    mockery.try do |testee|
+      testee.route('left', 23)
+    end
+    assert_equal(true, mockery.validate, mockery.error_report)
+  end
+
+  def test_multi_class_history_success
+
+    class_a = Class.new
+    class_a.class_eval {
+      attr_writer :b
+      def start(x)
+        show(x - 1)
+        @b.show(x + 1)
+      end
+      def show(x)
+        puts "a.show(#{x})"
+      end
+    }
+
+    class_b = Class.new
+    class_b.class_eval {
+      def show(x)
+        puts "b.show(#{x})"
+      end
+    }
+    
+    mockery = Mockery::Controller.new(class_a, class_b)
+    mockery.record do |a, b, ctl|
+      a.show(22)
+      b.show(24)
+    end
+    mockery.try do |a, b|
+      a.b = b
+      a.start(23)
+    end
+    assert_equal(true, mockery.validate, mockery.error_report)
+  end
+  
+end

data/tests/unit/mockery/call_test.rb

@@ -0,0 +1,92 @@
+
+#
+# Name:  CallTest  (tests/unit/mockery/call_test.rb)
+#
+# Description:
+#
+#      Unit tests for the Mockery::Call 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/call'
+
+class CallTest < Test::Unit::TestCase
+
+  def test_digest
+    
+    obj = Object.new
+    
+    c = Mockery::Call.new
+    c.digest(obj, ['blork', 'a', 1])
+    
+    cr = Mockery::Call.new
+    cr.method_name = 'blork'
+    cr.args = ['a', 1]
+
+    assert_equal(cr, c)
+    
+    # the caller is not compared by '=='
+    assert_equal(obj, c.caller)
+    
+  end
+  
+  def test_equals
+    
+    caller1 = Object.new
+    caller2 = Object.new
+
+    c1 = Mockery::Call.new
+    c1.method_name = 'blork'
+    c1.args = ['a', 1]
+    c1.caller = caller1
+    c1.return_value = 23
+
+    c2 = Mockery::Call.new
+    c2.method_name = 'blork'
+    c2.args = ['a', 1]
+    c2.caller = caller1
+    c1.return_value = 23
+
+    assert_equal(c1, c2)
+    
+    c2.caller = caller2
+    assert_equal(true, c1 == c2)
+    c2.caller = caller1
+    assert_equal(true, c1 == c2)
+    
+    c2.return_value = 24
+    assert_equal(true, c1 == c2)
+    c2.return_value = 23
+    assert_equal(true, c1 == c2)
+
+    c2.method_name = 'blink'
+    assert_equal(false, c1 == c2)
+    c2.method_name = 'blork'
+    assert_equal(true, c1 == c2)
+
+    c2.method_name = 'blink'
+    assert_equal(false, c1 == c2)
+    c2.method_name = 'blork'
+    assert_equal(true, c1 == c2)
+
+    c2.args = ['a']
+    assert_equal(false, c1 == c2)
+  end
+  
+end

data/tests/unit/mockery/controller_test.rb

@@ -0,0 +1,207 @@
+
+#
+# Name:  ControllerTest  (tests/unit/mockery/controller_test.rb)
+#
+# Description:
+#
+#      Unit tests for the Mockery::Controller 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/controller'
+
+class ControllerTest < Test::Unit::TestCase
+
+  def test_initialize
+    
+    # the controller is initialized with some number of classes.
+    # each class presented to the controller will have a corresponding
+    # object available in each of
+    # the successive blocks.
+    #
+    # the controller creates and stashes a Mock object for each
+    # of the classes presented.
+
+    ctl_class = Class.new(Mockery::Controller)
+    ctl_class.class_eval {
+      attr_reader :mocks
+    }
+    
+    klasses = [Class.new, Class.new]
+    ctl = ctl_class.new(klasses[0], klasses[1])
+    
+    assert_equal(Array, ctl.mocks.class)
+    assert_equal(2, ctl.mocks.size)
+    
+    mock = ctl.mocks[0]
+    def mock.klass
+      return @klass
+    end
+    assert_equal(klasses[0], mock.klass)
+    
+    mock = ctl.mocks[1]
+    def mock.klass
+      return @klass
+    end
+    assert_equal(klasses[1], mock.klass)
+      
+    
+  end
+
+  def test_record
+    
+    ctl_class = Class.new(Mockery::Controller)
+    ctl_class.class_eval {
+      attr_reader :mocks
+    }
+    
+    klasses = [Class.new, Class.new]
+    ctl = ctl_class.new(klasses[0], klasses[1])
+
+    ctl.record do |obj0, obj1, rc|
+      assert_equal(Mockery::RecordControl, rc.class)
+      call = obj0.glorbl(23)
+      call.return_value = 'dog'
+      call = obj1.snurf('blork')
+      call.return_value = 1.7
+    end
+
+    # verify that recorder 0 has the right contents
+
+    mock = ctl.mocks[0]
+    recorder = mock.recorder
+    def recorder.history
+      return @history
+    end
+
+    assert_equal(1, recorder.history.size)
+    assert_equal(Mockery::Call, recorder.history[0].class)
+
+    call = recorder.history[0]
+    assert_equal(recorder, call.caller)
+    assert_equal(:glorbl, call.method_name)
+    assert_equal([23], call.args)
+    assert_equal('dog', call.return_value)
+
+    # verify that recorder 1 has the right contents
+
+    mock = ctl.mocks[1]
+    recorder = mock.recorder
+    def recorder.history
+      return @history
+    end
+
+    assert_equal(1, recorder.history.size)
+    assert_equal(Mockery::Call, recorder.history[0].class)
+
+    call = recorder.history[0]
+    assert_equal(recorder, call.caller)
+    assert_equal(:snurf, call.method_name)
+    assert_equal(['blork'], call.args)
+    assert_equal(1.7, call.return_value)
+    
+  end
+  
+  def test_try
+    
+    # a collection of mocks is presented to the
+    # user as arguments to a block.  the mocks
+    # are build by the #mocked_object method of Mock,
+    # which takes no arguments.  the last argument
+    # is a 'controller'.  the controller is used
+    # to temporarily pause recording.
+
+    ctl_class = Class.new(Mockery::Controller)
+    ctl_class.class_eval {
+      attr_accessor :mocks
+    }
+    ctl = ctl_class.new(Class.new)
+    
+    mock_class = Class.new
+    mock_class.class_eval {
+      attr_writer :ret_instance
+      def mocked_object
+        return @ret_instance
+      end
+    }
+    
+    mock0 = mock_class.new
+    ret0 = Object.new
+    mock0.ret_instance = ret0
+    
+    mock1 = mock_class.new
+    ret1 = Object.new
+    mock1.ret_instance = ret1
+
+    # note that this discards the Object.new placeholder
+    # in the #new above
+    ctl.mocks = [mock0, mock1]
+    
+    # try() creates the necessary objects for the block,
+    # whether the block is empty or not
+
+    ctl.try {|m1, m2|
+      assert_equal(ret0, m1)
+      assert_equal(ret1, m2)
+    }
+  end
+  
+  def test_validate
+
+    # validate steps through the mocks looking for
+    # an invalid one (meaning its #validate method
+    # returns false), and returns false if found.
+    # otherwise it returns true
+
+    ctl_class = Class.new(Mockery::Controller)
+    ctl_class.class_eval {
+      attr_accessor :mocks
+    }
+    ctl = ctl_class.new(Class.new)
+    
+    mock_class = Class.new
+    mock_class.class_eval {
+      attr_writer :ret_valid
+      def validate
+        return @ret_valid
+      end
+    }
+    
+    m1 = mock_class.new
+    m1.ret_valid = true
+
+    m2 = mock_class.new
+    m2.ret_valid = true
+
+    m3 = mock_class.new
+    m3.ret_valid = false
+    
+    # first test with true only
+
+    ctl.mocks = [m1, m2]
+    assert_equal(true, ctl.validate)
+    
+    # now with a false
+
+    ctl.mocks = [m1, m3, m2]
+    assert_equal(false, ctl.validate)
+
+  end
+  
+end