Changeset 271

Timestamp:

06/17/07 11:16:31 (17 months ago)

Author:

ged

Message:

Converted a few more unit tests to specs

Location:

trunk

Files:

• lib/fm/event.rb (modified) (1 diff)
• spec/entity_spec.rb (modified) (3 diffs)
• spec/event_spec.rb (moved) (moved from trunk/spec/event.tests.rb) (2 diffs)

trunk/lib/fm/event.rb

@@ -110 +110 @@
             select {|kl| kl.class == Class }.
             collect {|kl| camelcase_to_underbarred(kl.name[/\w+$/]) }.
-            collect {|name| "handle_" + name }
+            collect {|name| ("handle_" + name).to_sym }
     end
 

trunk/spec/entity_spec.rb

@@ -18 +18 @@
 require 'spec/runner'
 require 'fm/entity'
-require 'fm/events/all'
 
 
 # Event classes for testing event handler.
 class TestingEntity < FaerieMUD::Entity
-    def initialize
-        @last_seen_event = nil
-        @last_handler = nil
-        super
-    end
-    attr_reader :last_seen_event, :last_handler
-end
-
-class TestingEvent < FaerieMUD::Event
-    def initialize; end
-end
-
-class DerivTestingEvent < TestingEvent; end
-class DerivDerivTestingEvent < DerivTestingEvent; end
-class ResultEvent < FaerieMUD::Event
-    def initialize; end
 end
 
@@ -46 +29 @@
     before( :each ) do
         @entity = TestingEntity.new
-        @testingEvent = TestingEvent.new
-        @derivTestingEvent = DerivTestingEvent.new
-        @derivDerivTestingEvent = DerivDerivTestingEvent.new
     end
 
@@ -58 +38 @@
     ### Unhandled events should raise an exception
     it "raises an exception for unhandled events" do
+        event = mock( "testing event", :null_object => true )
+        event.should_receive( :handler_names ).
+            and_return([:handle_testing_event])
 
         # Passing an event without a specific handler should cause an exception
         # to be raised.
         lambda {
-            @entity.handle_events( @testingEvent )
+            @entity.handle_events( event )
         }.should raise_error( FaerieMUD::UnhandledEventError )
+    end
+end
+
+
+describe FaerieMUD::Entity, " with an event handler defined" do
+    before( :each ) do
+        @entity = TestingEntity.new
+        
+        # Define an event handler for TestingEvents
+        def @entity.handle_testing_event( ev )
+            return :result_event
+        end
+    end
+    
+
+    it "asks incoming event objects what event handlers should handle them" do
+        event = mock( "event", :null_object => true )
+        event.should_receive( :handler_names ).
+            and_return([:handle_testing_event])
+        
+        @entity.handle_events( event ).should == [:result_event]
+    end
+
+    it "tries each event handler in turn until it finds an implemented one" do
+        event = mock( "event with one superclass", :null_object => true )
+        event.should_receive( :handler_names ).
+            and_return([:handle_special_event, :handle_testing_event])
+
+        @entity.handle_events( event ).should == [:result_event]
     end
 
 end
 
-# describe FaerieMUD::Entity, " derivative which defines a fallback handler" do
-# 
-#   it "should handle any event, even ones with no specific handler" do
-#       # Add a fallback handler
-#       def @entity.handle_any_event( ev )
-#           @last_seen_event = ev
-#           @last_handler = :handle_any_event
-#       end
-# 
-#       lambda { @entity.handle_events(@testingEvent) }.should_not raise_error()
-#       @entity.last_seen_event.should == @testingEvent
-#       @entity.last_handler.should == :handle_any_event
-#   end
-#   
-# 
-#   ### Test fallback event handler.
-#   def test_entities_which_define_fallback_handler_should_handle_any_event
-#       rval = nil
-# 
-# 
-#   end
-# 
-# 
-#   ### Test to be sure handlers for base classes catch derivatives.
-#   def test_entities_should_handle_derivative_events_with_more_general_handlers
-#       rval = nil
-# 
-#       def @entity.handle_testing_event( ev )
-#           @last_seen_event = ev
-#           @last_handler = :handle_testing_event
-#       end
-# 
-#       assert_nothing_raised { @entity.handle_events(@testingEvent) }
-#       assert_same @testingEvent, @entity.last_seen_event,
-#           "last seen event for TestingEvent"
-#       assert_equal :handle_testing_event, @entity.last_handler,
-#           "last handler for TestingEvent"
-# 
-#       assert_nothing_raised { @entity.handle_events(@derivTestingEvent) }
-#       assert_same @derivTestingEvent, @entity.last_seen_event,
-#           "last seen event for DerivTestingEvent"
-#       assert_equal :handle_testing_event, @entity.last_handler,
-#           "last handler for DerivTestingEvent"
-# 
-#       assert_nothing_raised { @entity.handle_events(@derivDerivTestingEvent) }
-#       assert_same @derivDerivTestingEvent, @entity.last_seen_event,
-#           "last seen event for DerivDerivTestingEvent"
-#       assert_equal :handle_testing_event, @entity.last_handler,
-#           "last handler for DerivDerivTestingEvent"
-#   end
-# 
-# 
-#   def test_event_handler_should_be_able_to_handle_single_event_result
-#       rval = nil
-# 
-#       def @entity.handle_testing_event( ev )
-#           return ResultEvent.new
-#       end
-# 
-#       assert_nothing_raised { rval = @entity.handle_events(@testingEvent) }
-#       assert_instance_of Array, rval
-#       assert_equal 1, rval.length
-#       assert_instance_of ResultEvent, rval[0]
-# 
-#       assert_nothing_raised { rval = @entity.handle_event(@testingEvent) }
-#       assert_instance_of Array, rval
-#       assert_equal 1, rval.length
-#       assert_instance_of ResultEvent, rval[0]
-#   end
-# 
-# end
-# 
+
+describe FaerieMUD::Entity, " which defines a fallback handler" do
+
+    before( :each ) do
+        @entity = TestingEntity.new
+
+        # Add a fallback handler
+        def @entity.handle_any_event( ev )
+            return :result_event
+        end
+    end
+
+
+    it "should handle any event, even ones with no specific handler" do
+        event = mock( "event", :null_object => true )
+        event.should_receive( :handler_names ).
+            and_return([:handle_special_event, :handle_testing_event])
+        
+        @entity.handle_events( event ) == [:result_event]
+    end
+end
+

trunk/spec/event_spec.rb

@@ -1 +1 @@
 #!/usr/bin/ruby -w
 #
-# Unit test for the Event class
+# Specification for the FaerieMUD::Entity class
 # $Id$
 #
-# Unit test for the FaerieMUD::Logger class
-# $Id$
-#
-# Copyright (c) 2003-2005 The FaerieMUD Consortium. Most rights reserved.
-# 
-# This work is licensed under the Creative Commons Attribution-ShareAlike
-# License. To view a copy of this license, visit
-# http://creativecommons.org/licenses/by-sa/1.0/ or send a letter to Creative
-# Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
-#
+# Copyright (c) 2003-2007 The FaerieMUD Consortium.
 # 
 
@@ -21 +12 @@
     $LOAD_PATH.unshift "#{basedir}/lib" unless
         $LOAD_PATH.include?( "#{basedir}/lib" )
-    $LOAD_PATH.unshift "#{basedir}/tests/lib" unless
-        $LOAD_PATH.include?( "#{basedir}/tests/lib" )
-
-    require 'fmtestcase'
+    $LOAD_PATH.unshift "#{basedir}/spec/lib" unless
+        $LOAD_PATH.include?( "#{basedir}/spec/lib" )
 end
 
-require 'fm/events/all'
-require 'fm/gameobject'
-require 'fm/locus'
+require 'spec/runner'
+require 'fm/event'
 
-### Test case for the FaerieMUD::Event class and associated classes/modules.
-class EventTestCase < FaerieMUD::TestCase
 
-    class TestEntity < FaerieMUD::Entity; end
-    class TestLocus < FaerieMUD::Locus; end
-    class TestVerb < FaerieMUD::Verb; end
-
-    module Complex; end
-    class MyEvent < FaerieMUD::Event; end
-    class IntermediateEvent < MyEvent; end
-    class YourEvent < IntermediateEvent
-        include Complex
+describe FaerieMUD::Event do
+    
+    it "requires an instigator to be created" do
+        lambda {
+            FaerieMUD::Event.new( :origin => :locus, :verb => :run )
+        }.should raise_error( ArgumentError, /:instigator/ )
     end
 
-
-    # Set up instances of associated classes for testing
-    def setup
-        @entity = TestEntity::new
-        @locus = TestLocus::new
-        @verb = TestVerb::instance
-        super
+    it "requires an origin to be created" do
+        lambda {
+            FaerieMUD::Event.new( :instigator => :character, :verb => :run )
+        }.should raise_error( ArgumentError, /:origin/ )
     end
 
-    # Discard testing objects
-    def teardown
-        super
-        @entity = @locus = @verb = nil
-    end
-
-
-
-    #################################################################
-    ### E X A M P L E S
-    #################################################################
-
-    ### Instance test
-    def test_instantiation_should_require_an_instigator
-        rval = derivClass = derivObject = nil
-
-        # Instantiation requires an :instigator
-        assert_raises( ArgumentError ) do
-            derivClass = Class::new( FaerieMUD::Event )
-            derivObject = derivClass::new(
-                :origin => @locus,
-                :verb => @verb
-                )
-        end
-    end
-
-    # Instantiation requires an :origin
-    def test_instantiation_should_require_an_origin
-        rval = derivClass = derivObject = nil
-
-        assert_raises( ArgumentError ) do
-            derivClass = Class::new( FaerieMUD::Event )
-            derivObject = derivClass::new(
-                :instigator => @entity,
-                :verb => @verb
-                )
-        end
-    end
-    
-    
-    # Instantiation requires a :verb
-    def test_instantiation_should_require_a_verb
-        rval = derivClass = derivObject = nil
-
-        assert_raises( ArgumentError ) do
-            derivClass = Class::new( FaerieMUD::Event )
-            derivObject = derivClass::new(
-                :instigator => @entity,
-                :origin => @locus
-                )
-        end
-    end
-    
-
-    ### Event handler names should use the name of the event class
-    def test_event_handler_names_should_follow_shalow_inheritance
-        rval = ev = nil
-
-        # Simple 1-deep inheritance
-        assert_nothing_raised do
-            ev = MyEvent::new(
-                :instigator => @entity,
-                :origin => @locus,
-                :verb => @verb
-                )
-            rval = ev.handler_names
-        end
-
-        assert_instance_of Array, rval
-        assert_equal ["handle_my_event"], rval
-    end
-
-
-    #### Test the generation of handler names for deep/complex inheritance
-    def test_event_handler_names_should_follow_deep_inheritance
-        rval = ev = nil
-
-        # Complex 2-deep with mixin
-        assert_nothing_raised do
-            ev = YourEvent::new(
-                :instigator => @entity,
-                :origin => @locus,
-                :verb => @verb
-                )
-            rval = ev.handler_names
-        end
-
-        # If we do end up implementing mixin-sensitive event handlers, this
-        # assert_equal will fail.
-        assert_instance_of Array, rval
-        assert_equal [
-            "handle_your_event", "handle_intermediate_event", "handle_my_event"
-        ], rval
-
+    it "requires a verb to be created" do
+        lambda {
+            FaerieMUD::Event.new( :origin => :locus, :instigator => :character )
+        }.should raise_error( ArgumentError, /:verb/ )
     end
 
 end
 
+
+# The handler-name examples below use a dummy class hierarchy:
+# 
+#           AstrologicalEvent
+#                   |
+#              LunarEvent
+#                   | ____ Remarkable (mixin)
+#                   |/
+#                   |\____ AstrologicallySignificant (mixin)
+#                   |
+#           LunarEclipseEvent
+#
+class AstronomicalEvent < FaerieMUD::Event; end
+
+describe "A direct simple subclass of FaerieMUD::Event" do
+    
+    before( :each ) do
+        @event = AstronomicalEvent.new(
+            :origin => :a_locus,
+            :verb => :run,
+            :instigator => :the_world
+          )
+    end
+    
+
+    it "suggests a single handler derived from its name" do
+        @event.handler_names.should == [:handle_astronomical_event]
+    end
+
+end
+
+
+class LunarEvent < AstronomicalEvent; end
+
+describe "An indirect simple subclass of FaerieMUD::Event" do
+    before( :each ) do
+        @event = LunarEvent.new(
+            :origin => :a_locus,
+            :verb => :run,
+            :instigator => :the_world
+          )
+    end
+    
+
+    it "suggests handlers derived from the names of its class and parent classes," +
+       " in order from most-specific to least" do
+        @event.handler_names.should == [:handle_lunar_event, :handle_astronomical_event]
+    end
+end
+
+
+class LunarEclipseEvent  < LunarEvent; end
+
+describe "An indirect subclass of FaerieMUD::Event that has included mixins" do
+    before( :each ) do
+        @event = LunarEclipseEvent.new(
+            :origin => :a_locus,
+            :verb => :run,
+            :instigator => :the_world
+          )
+    end
+    
+
+    it "suggests handlers derived from the names of its class and parent classes, " +
+       "in order from most-specific to least" do
+        @event.handler_names.should == [
+            :handle_lunar_eclipse_event,
+            :handle_lunar_event,
+            :handle_astronomical_event
+          ]
+    end
+end
+