test_internals 0.0.2 → 1.0.0

data/Gemfile

@@ -1,6 +1,6 @@
 source 'http://rubygems.org'
 
-gem 'app_mode', '~> 0.0.1'
+gem 'app_mode', '~> 1.0.0'
 
 group :rake do
   gem 'rake_tasks', '~> 0.0.1'

data/Gemfile.lock

@@ -1,14 +1,14 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    app_mode (0.0.2)
+    app_mode (1.0.1)
     rake (0.8.7)
-    rake_tasks (0.0.1)
+    rake_tasks (0.0.4)
       rake (~> 0.8.7)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  app_mode (~> 0.0.1)
+  app_mode (~> 1.0.0)
   rake_tasks (~> 0.0.1)

data/README

@@ -1,15 +1,9 @@
 == Welcome to TestInternals
 
-TestInternals patches Test::Unit::TestCase to allow testing of private methods,
-as well as variables.
-
-The stack trace is also available, including the ability to check
-that specific parameter values were sent to a method.
-
-It will also prevent the application from stopping tests if exit is called.
-assert_alive and assert_dead have been included to assist in testing.
-
-There are also a number of assertions that have been added.
+TestInternals patches Test::Unit::TestCase to allow
+testing of private methods, as well as variables. The stack trace
+is also available, including the ability to check that specific
+parameters were sent to a method. This results in cotton candy goodness for all.
 
 == Getting Started
 
@@ -17,14 +11,68 @@ There are also a number of assertions that have been added.
 
     gem install test_internals
 
-2. Require the gem in your gemfile:
+2. Require the gem in your Gemfile:
 
-    gem 'test_internals', '~> 0.0.1'
+    gem 'test_internals', '~> 1.0.0'
 
-3. Require the gem wherever you need shell commands:
+3. Require the gem wherever you need to use it:
 
     require 'test_internals'
 
+== Overriding Default Behavior
+
+To call methods that enable functionality or to override
+variable settings, add an initialize method to your test
+and call the desired method, calling super after:
+
+ def initialize
+   expose_all_variables
+   expose_stack
+   expose_class_methods
+   expose_instance_methods
+   @class = MyClass
+   init_object(param1, param2, ...)
+   # ...
+   super
+ end
+
+NOTE: If it is not included in this example,
+it is not expected to be used in the initialize method.
+
+== Instance Variables
+
+=== @class
+
+The @class variable, will exist for every test.
+The class is inferred from the name of the test.
+For example, a class named MyClass
+is expected to be tested by a class named MyClassTest.
+
+The default behavior may be overridden by specifying the class
+in the initialize method of your test as shown above.
+
+=== @obj
+
+This is only non-nil if init_object has been called in the initialize method
+(and the class responds to the :new method).
+See rdoc for additional details.
+
+== Additional Notes
+
+* Methods marked protected are intended to be used by sub-classes.
+
+* Methods marked private are intended to be used only by the class itself
+  and are NOT intended for use in sub-classes.
+  If they are, results may be unpredictable.
+
+* When send_to_class or send_to_object are called, the calls are wrapped such
+  that output is captured and not sent to the console.
+  The output may be retrieved via the following methods:
+
+   out        #=> output to stdout
+   err        #=> output to stderr
+   real_finis #=> An array [out, err]
+
 == Additional Documentation
 
  rake rdoc:app

data/lib/test_internals/test_case.rb

@@ -34,16 +34,18 @@
 
 # Monkey patch Test::Unit::TestCase to make it do cool stuff.
 Test::Unit::TestCase.class_eval do
+  include TestInternals
+
   # Since this is in a class_eval, instance methods need to be wrapped up
   # in class_variable_set or ruby will throw warnings.
 
   # Indicates whether the class has already been initialized.
   # This combined with @@class_name prevents duplicate patching.
-  class_variable_set(:@@initialized, false)
+  class_variable_set(:@@initialized, nil)
 
   # Keeps track of the class that has most recently been initialized.
   # This combined with @@initialized prevents duplicate patching.
-  class_variable_set(:@@class_name, '')
+  class_variable_set(:@@class_name, nil)
 
   # Initializes the class
   # and exposes private methods and variables of the class that is being tested.
@@ -51,19 +53,26 @@ Test::Unit::TestCase.class_eval do
     # Call initialize on the superclass.
     super
 
-    @obj = nil
+    @obj   = nil
+    @class = nil unless defined?(@class)
+
+    @init_object        = nil unless defined?(@init_object)
+    @init_object_params = nil unless defined?(@init_object_params)
+
+    @expose_instance_methods = nil unless defined?(@expose_instance_methods)
+    @expose_class_methods    = nil unless defined?(@expose_class_methods)
+    @expose_variables        = nil unless defined?(@expose_variables)
+    @expose_stack            = nil unless defined?(@expose_stack)
 
     reset_io
-    reset_trace
 
     # This block ensures that tests still work if there is not a class that
     # corresponds with the test file/class.
-    @class = nil
     begin
       # Get the class that is being tested.
       # Assume that the name of the class is found by removing 'Test'
       # from the test class.
-      @class = Kernel.const_get(self.class.name.gsub(/Test$/, ''))
+      @class ||= Kernel.const_get(self.class.name.gsub(/Test$/, ''))
       @@initialized = ((@class.name == @@class_name) && @@initialized)
       @@class_name = @class.name
     rescue
@@ -72,34 +81,41 @@ Test::Unit::TestCase.class_eval do
     end
 
     # Only patch if this code has not yet been run.
-    if !@@initialized and @class.class.name != 'Module'
-      set_instance_method_wrappers
+    if !@@initialized
+      set_instance_method_wrappers if @expose_stack
 
       # Expose private class methods.
       # We will only expose the methods we are responsible for creating.
       # (i.e. subtracting the superclass's private methods)
       expose_private_methods(:class,
         @class.private_methods - 
-        @class.superclass.private_methods)
+        @class.superclass.private_methods) if @expose_class_methods
 
       # Expose private instance methods.
       # We will only expose the methods we are responsible for creating.
       # (i.e. subtracting the superclass's private methods)
       expose_private_methods(:instance,
         @class.private_instance_methods -
-        @class.superclass.private_instance_methods)
+        @class.superclass.private_instance_methods) if @expose_instance_methods
 
       # Expose variables.
       # Requires that variables are assigned to in the constructor.
-      wrap_output {
-        expose_variables(@class.class_variables +
-          @class.new([]).instance_variables)
-      }
+      if @expose_variables
+        init_with_defaults if new_object_on_init?
+        instance_variable_list = @obj.nil? ? [] : @obj.instance_variables
+        expose_variables @class.class_variables + instance_variable_list
+      end
 
       # Indicate that this code has been run.
       @@initialized = true
     end
 
+    # This is potentially called a second time so that the object will
+    # include any goodies we have added here.
+    init_with_defaults if new_object_on_init?
+
+    reset_trace
+
     # If initializing the class with @class.new above kills the app,
     # we need to set it back to running, but we want to do this regardless.
     reset_app_state
@@ -110,194 +126,149 @@ Test::Unit::TestCase.class_eval do
   # Tracing is set up here so that it is only running during tests.
   #
   # If you want to disable tracing, simply override the setup method
-  # without calling super. (It would be good form to also override teardown).
+  # without calling super.
   def setup
-    set_trace_func proc { |event, file, line, id, binding, class_name|
-      if class_name == @class and
-          @stack_trace.last != {:class => class_name.name, :method => id}
-        @stack_trace  << {
-          :class => class_name.name,
-          :method => id,
-        }
-      end
-    }
+    if @expose_stack
+      set_trace_func proc { |event, file, line, id, binding, class_name|
+        if class_name == @class and
+            @stack_trace.last != {:class => class_name.name, :method => id}
+          @stack_trace  << {
+            :class => class_name.name,
+            :method => id,
+          }
+        end
+      }
+    end
   end
 
   # Clean up after each test.
-  #
-  # If you disable tracing, it would be good form to override this method
-  # as well without calling super.
   def teardown
-    set_trace_func nil
+    set_trace_func nil if @expose_stack
   end
 
   ############################################################################
-  private
+  protected
   ############################################################################
 
+  # Protected methods are intended for use in this class and/or sub-classes.
+
   ############################################################################
-  # Monkey patching methods for the class being tested.
+  # @obj and @class-related methods
   ############################################################################
 
-  # Monkey patch the class's initializer to enable tracing
-  # with parameters and results.
-  def set_initializer
-    @class.class_eval do
-      attr_accessor :trace
-
-      alias :test_case_initialize :initialize
-      def initialize(*args)
-        @trace = []
-        result = test_case_initialize(*args)
-        return result
-      end
-    end
+  # Creates a new instance of the class using the arguments that are passed in.
+  #
+  # This method also resets the states of other variables prior to creation.
+  # ==== Input
+  # [*args : Array] The parameters that will be used to create a new instance.
+  def create(*args)
+    reset_io
+    reset_trace
+    reset_app_state
+    @obj = init_new_object(*args)
   end
 
-  # Loop through the instance methods, calling set_instance_methods for each.
-  def set_instance_method_wrappers
-    [
-      :public_instance_methods,
-      :protected_instance_methods,
-      :private_instance_methods
-    ].each do |method_id|
-
-      scope = method_id.to_s.gsub(/_.*/, '')
+  # Creates a new object using the specified parameters.
+  # ==== Input
+  # [*args : Array] The parameters to send to the new method
+  #                 when creating the object.
+  def init_new_object(*args)
+    @obj = send_to_class(:new, *args)
+  end
 
-      set_instance_methods(@class.send(method_id) -
-        @class.superclass.send(method_id), scope)
+  # Sets the value of the variable that indicates whether a new object
+  # should be created and sets the parameters that will be used.
+  # ==== Output
+  # [params : Array] The parameters to use when creating the object.
+  # ==== Notes
+  # This method should only be called from a child class's initialize method.
+  # Calling it elsewhere could cause unexpected results.
+  def init_object(*params)
+    @init_object = true
+
+    case params.length
+      when 0
+        @init_object_params = nil
+      when 1
+        @init_object_params = params[0]
+      else
+        @init_object_params = *params
     end
-
-    # If this is not at the end, the loop will attempt to do it's thing
-    # with the constructor created in this method, which is not necessary.
-    set_initializer
   end
 
-  # Loop through the list of methods that are passed in,
-  # creating a wrapper method that enables tracing.
-  #
-  # Tracing data includes method name, parameters, and result.
-  # ==== Input
-  # [method_list : Array] A list of methods that will have wrapping functions
-  #                       created to enable tracing.
-  # [scope : String] The scope of the original function.
-  def set_instance_methods(method_list, scope)
-    method_list.each do |method_id|
-      # Setters and methods that accept blocks do not appear to work.
-      next if method_id =~ /=/ or method_id =~ /wrap_output/
-
-      # Build the method.
-      new_method = <<-DOC
-        alias :test_case_#{method_id} :#{method_id}
-        def #{method_id}(*args)
-          result = test_case_#{method_id}(*args)
-          @trace << {
-            :method => '#{method_id}',
-            :args => args,
-            :result => result
-          }
-          return result
-        end
-        #{scope} :#{method_id}
-      DOC
-
-      # Add the method to the class.
-      @class.class_eval do
-        eval(new_method)
-      end
-    end
+  # Initializes a new object using the default parameters.
+  def init_with_defaults
+    init_new_object(*@init_object_params)
   end
 
-  # Expose the private methods that are passed in.  New methods will be created
-  # with the old method name followed by '_public_test'.  If the original
-  # method contained a '?', it will be removed in the new method.
+  # Sends a call to the class.
   # ==== Input
-  # [type : Symbol] Indicates whether to handle instance or class methods.
-  #
-  #                 Only :class and :instance are supported.
-  # [methods : Array] An array of the methods to expose.
-  def expose_private_methods(type, methods)
-    # Get the text that the method should be wrapped in.
-    method_wrapper = wrapper(type)
-
-    # Loop through the methods.
-    methods.each do |method|
-      # Remove ?s.
-      new_method = method.to_s.gsub(/\?/, '')
-
-      # This is the new method.
-      new_method = <<-DOC
-        def #{new_method}_public_test(*args)
-          #{method}(*args)
-        end
-      DOC
-
-      # Add the wrapping text.
-      new_method = method_wrapper % [new_method]
-
-      # Add the method to the class.
-      @class.class_eval do
-        eval(new_method)
-      end
-    end
+  # [method : Symbol, String] The method to call.
+  # [*args : Array] The parameters to send.
+  def send_to_class(method, *args)
+    return send_to(@class, method.to_sym, *args)
   end
 
-  # Expose the variables.
-  #
-  # New methods will be created (a getter and a setter) for each variable.
-  #
-  # Regardless of the type of variable, these methods are only available
-  # via an instance.
+  # Sends a method to the object in the class variable.
   # ==== Input
-  # [variables : Array] An array of variables to expose.
-  def expose_variables(variables)
-    # Get the text that the methods should be wrapped in.
-    var_wrapper = wrapper(:instance)
-
-    # Loop through the variables
-    variables.each do |var|
-      # Remove any @s.
-      new_method = var.to_s.gsub(/@/, '')
+  # [method : Symbol, String] The name of the method to call.
+  # [*args : Array] Parameters to use when calling the method.
+  def send_to_object(method, *args)
+    create(*args)
+    assert_alive
+    return send_to(@obj, method.to_sym, *args)
+  end
 
-      # These are the new getter and setters.
-      new_method = <<-DOC
-        def #{new_method}_variable_method
-          #{var}
-        end
+  ############################################################################
+  # Enable Functionality - These should only be called in initialize of a child.
+  ############################################################################
 
-        def #{new_method}_variable_method=(value)
-          #{var} = value
-        end
-      DOC
+  # Indicate that class and instance variables should be made available
+  # via public methods.
+  def expose_all_variables
+    @expose_variables = true
+  end
 
-      # Add the wrapping text.
-      new_method = var_wrapper % [new_method]
+  # Indicate that private class methods should be made available
+  # via public class methods.
+  def expose_class_methods
+    @expose_class_methods = true
+  end
 
-      # Add the methods to the class.
-      @class.class_eval do
-        eval(new_method)
-      end
-    end
+  # Indicate that private instance methods should be made available
+  # via public instance methods.
+  def expose_instance_methods
+    @expose_instance_methods = true
   end
 
-  # Returns the wrapping text for the specified type of method.
-  # ==== Input
-  # [type : Symbol] Indicates whether to handle instance or class methods.
-  #
-  #                 Only :class & :instance are supported.
-  # ==== Output
-  # [String] The text that the specified type of method should be wrapped in.
-  def wrapper(type)
-    case type
-      when :class then 'class << self;%s;end'
-      when :instance then '%s'
-    end
+  # Enables stack tracing so that assertions which rely on knowing
+  # which methods were called may be used.
+  def expose_stack
+    @expose_stack = true
   end
 
   ############################################################################
   # I/O support methods.
   ############################################################################
 
+  # Returns the output from stdout as a string.
+  # ==== Output
+  # [String] The output from stdout.
+  #
+  #          All trailing line feeds are removed.
+  def out
+    @out.respond_to?(:string) ?  @out.string.gsub(/\n*\z/, '') : ''
+  end
+
+  # Returns the output from stderr as a string.
+  # ==== Output
+  # [String] The output from stderr.
+  #
+  #          All trailing line feeds are removed.
+  def err
+    @err.respond_to?(:string) ?  @err.string.gsub(/\n*\z/, '') : ''
+  end
+
   # Return the actual output to stdout and stderr.
   # ==== Output
   # [Array] Two element array of strings.
@@ -309,6 +280,12 @@ Test::Unit::TestCase.class_eval do
     return out, err
   end
 
+  # Reset the stdout and stderr stream variables.
+  def reset_io
+    @out = StringIO.new
+    @err = StringIO.new
+  end
+
   # Wrap a block to capture the output to stdout and stderr.
   # ==== Input
   # [&block : Block] The block of code that will have stdout and stderr trapped.
@@ -317,55 +294,21 @@ Test::Unit::TestCase.class_eval do
       $stdout = @out
       $stderr = @err
       yield
+    rescue SystemExit
+      AppState.state = :dead
     ensure
       $stdout = STDOUT
       $stderr = STDERR
     end
   end
 
-  # Returns the output from stdout as a string.
-  # ==== Output
-  # [String] The output from stdout.
-  #
-  #          All trailing line feeds are removed.
-  def out
-    @out.respond_to?(:string) ?  @out.string.gsub(/\n*\z/, '') : ''
-  end
-
-  # Returns the output from stderr as a string.
-  # ==== Output
-  # [String] The output from stderr.
-  #
-  #          All trailing line feeds are removed.
-  def err
-    @err.respond_to?(:string) ?  @err.string.gsub(/\n*\z/, '') : ''
-  end
-
-  # Reset the stdout and stderr stream variables.
-  def reset_io
-    @out = StringIO.new
-    @err = StringIO.new
-  end
-
   ############################################################################
   # Support methods.
   ############################################################################
 
-  # Indicates whether the specified method has been called on a given class.
-  # ==== Input
-  # [method_name : String] The name of the method.
-  #
-  #                        This value may be a string or a symbol.
-  # [class_name : String : @class.name] The name of the class that the method
-  #                                     should have been invoked from.
-  def method_called?(method_name, class_name = @class.name)
-    !@stack_trace.index(
-      {:method => method_name.to_sym, :class => class_name}).nil?
-  end
-
   # Set the application state to alive.
   def reset_app_state
-    TestInternals::AppState.state = :alive unless TestInternals::AppState.alive
+    AppState.state = :alive unless AppState.alive
   end
 
   # Resets the trace arrays.
@@ -387,14 +330,6 @@ Test::Unit::TestCase.class_eval do
   # Assertions.
   ############################################################################
 
-  # Asserts that a value is equal to false.
-  # ==== Input
-  # [value : Any] The value to check for equality against false.
-  # [message : String : nil] The message to display if the value is not false.
-  def assert_false(value, message = nil)
-    assert_equal false, value, message
-  end
-
   # Asserts that a value is equal to true.
   # ==== Input
   # [value : Any] The value to check for equality against true.
@@ -403,6 +338,14 @@ Test::Unit::TestCase.class_eval do
     assert_equal true, value, message
   end
 
+  # Asserts that a value is equal to false.
+  # ==== Input
+  # [value : Any] The value to check for equality against false.
+  # [message : String : nil] The message to display if the value is not false.
+  def assert_false(value, message = nil)
+    assert_equal false, value, message
+  end
+
   # Asserts that the negation of a value is true.
   # ==== Input
   # [value : Any] The value which will be negated and then asserted.
@@ -513,39 +456,250 @@ Test::Unit::TestCase.class_eval do
   # Assertions - Application state.
   ############################################################################
 
-  # Asserts that the application has been stopped.
+  # Asserts that the application is still running.
   # ==== Input
   # [message : String : nil] The message to show if the assertion fails.
-  def assert_dead(message = nil)
-    message = "#{@class} was not stopped as expected" if message.nil?
+  def assert_alive(message = nil)
+    message = "#{@class} is not running as expected" if message.nil?
 
     # Hold the state in a local variable so that the state can be reset
     # prior to the assertion.
-    dead = TestInternals::AppState.dead
+    alive = AppState.alive
 
     # Reset the application state so that later tests are not adversely
     # affected if this assertion fails, which otherwise could leave
     # the application in an incorrect state.
     reset_app_state
 
-    assert_true dead, message
+    assert alive, message
   end
 
-  # Asserts that the application is still running.
+  # Asserts that the application has been stopped.
   # ==== Input
   # [message : String : nil] The message to show if the assertion fails.
-  def assert_alive(message = nil)
-    message = "#{@class} is not running as expected" if message.nil?
+  def assert_dead(message = nil)
+    message = "#{@class} was not stopped as expected" if message.nil?
 
     # Hold the state in a local variable so that the state can be reset
     # prior to the assertion.
-    alive = TestInternals::AppState.alive
+    dead = AppState.dead
 
     # Reset the application state so that later tests are not adversely
     # affected if this assertion fails, which otherwise could leave
     # the application in an incorrect state.
     reset_app_state
 
-    assert_true alive, message
+    assert dead, message
+  end
+
+  ############################################################################
+  private
+  ############################################################################
+
+  # Private methods are intended for use in this class only.
+  # They are NOT intended for use in sub-classes.
+
+  ############################################################################
+  # @obj and @class-related methods
+  ############################################################################
+
+  # Indicates whether a new object instance should (and can)
+  # be created during initialization.
+  # ==== Output
+  # [Boolean] Whether a new object should (and can) be created.
+  def new_object_on_init?
+    @init_object && @class.respond_to?(:new)
+  end
+
+  # Sends a method to the specified object along with parameters.
+  # ==== Input
+  # [object : Any] The object to send the method to.
+  # [method : Symbol, String] The method to call.
+  # [*args : Array] The parameters to pass to the method.
+  def send_to(object, method, *args)
+    result = nil
+
+    if args.length == 0
+      wrap_output { result = object.send(method.to_sym) }
+    else
+      wrap_output { result = object.send(method.to_sym, *args) }
+    end
+
+    return result
+  end
+
+  ############################################################################
+  # Monkey patching methods for the class being tested.
+  ############################################################################
+
+  # Monkey patch the class's initializer to enable tracing
+  # with parameters and results.
+  def set_initializer
+    @class.class_eval do
+      attr_accessor :trace
+
+      alias :test_case_initialize :initialize
+      def initialize(*args)
+        @trace = []
+        result = test_case_initialize(*args)
+        return result
+      end
+    end
+  end
+
+  # Loop through the instance methods, calling set_instance_methods for each.
+  def set_instance_method_wrappers
+    [
+      :public_instance_methods,
+      :protected_instance_methods,
+      :private_instance_methods,
+    ].each do |method_id|
+
+      scope = method_id.to_s.gsub(/_.*/, '')
+
+      set_instance_methods(@class.send(method_id) -
+        @class.superclass.send(method_id), scope)
+    end
+
+    # If this is not at the end, the loop will attempt to do it's thing
+    # with the constructor created in this method, which is not necessary.
+    set_initializer
+  end
+
+  # Loop through the list of methods that are passed in,
+  # creating a wrapper method that enables tracing.
+  #
+  # Tracing data includes method name, parameters, and result.
+  # ==== Input
+  # [method_list : Array] A list of methods that will have wrapping functions
+  #                       created to enable tracing.
+  # [scope : String] The scope of the original function.
+  def set_instance_methods(method_list, scope)
+    method_list.each do |method_id|
+      # Setters and methods that accept blocks do not appear to work.
+      next if method_id =~ /=/ or method_id =~ /wrap_output/
+
+      # Build the method.
+      new_method = <<-DOC
+        alias :test_case_#{method_id} :#{method_id}
+        def #{method_id}(*args)
+          result = test_case_#{method_id}(*args)
+          @trace << {
+            :method => '#{method_id}',
+            :args => args,
+            :result => result
+          }
+          return result
+        end
+        #{scope} :#{method_id}
+      DOC
+
+      # Add the method to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Expose the private methods that are passed in.  New methods will be created
+  # with the old method name followed by '_public_test'.  If the original
+  # method contained a '?', it will be removed in the new method.
+  # ==== Input
+  # [type : Symbol] Indicates whether to handle instance or class methods.
+  #
+  #                 Only :class and :instance are supported.
+  # [methods : Array] An array of the methods to expose.
+  def expose_private_methods(type, methods)
+    # Get the text that the method should be wrapped in.
+    method_wrapper = wrapper(type)
+
+    # Loop through the methods.
+    methods.each do |method|
+      # Remove ?s.
+      new_method = method.to_s.gsub(/\?/, '')
+
+      # This is the new method.
+      new_method = <<-DOC
+        def #{new_method}_public_test(*args)
+          #{method}(*args)
+        end
+      DOC
+
+      # Add the wrapping text.
+      new_method = method_wrapper % [new_method]
+
+      # Add the method to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Expose the variables.
+  #
+  # New methods will be created (a getter and a setter) for each variable.
+  #
+  # Regardless of the type of variable, these methods are only available
+  # via an instance.
+  # ==== Input
+  # [variables : Array] An array of variables to expose.
+  def expose_variables(variables)
+    # Get the text that the methods should be wrapped in.
+    var_wrapper = wrapper(:instance)
+
+    # Loop through the variables
+    variables.each do |var|
+      # Remove any @s.
+      new_method = var.to_s.gsub(/@/, '')
+
+      # These are the new getter and setters.
+      new_method = <<-DOC
+        def #{new_method}_variable_method
+          #{var}
+        end
+
+        def #{new_method}_variable_method=(value)
+          #{var} = value
+        end
+      DOC
+
+      # Add the wrapping text.
+      new_method = var_wrapper % [new_method]
+
+      # Add the methods to the class.
+      @class.class_eval do
+        eval(new_method)
+      end
+    end
+  end
+
+  # Returns the wrapping text for the specified type of method.
+  # ==== Input
+  # [type : Symbol] Indicates whether to handle instance or class methods.
+  #
+  #                 Only :class & :instance are supported.
+  # ==== Output
+  # [String] The text that the specified type of method should be wrapped in.
+  def wrapper(type)
+    case type
+      when :class then 'class << self;%s;end'
+      when :instance then '%s'
+    end
+  end
+
+  ############################################################################
+  # Support methods.
+  ############################################################################
+
+  # Indicates whether the specified method has been called on a given class.
+  # ==== Input
+  # [method_name : String] The name of the method.
+  #
+  #                        This value may be a string or a symbol.
+  # [class_name : String : @class.name] The name of the class that the method
+  #                                     should have been invoked from.
+  def method_called?(method_name, class_name = @class.name)
+    !@stack_trace.index(
+      {:method => method_name.to_sym, :class => class_name}).nil?
   end
 end

data/lib/test_internals/{app_state.rb → test_internals.rb}

@@ -1,5 +1,4 @@
-# This file contains the constant that is used to determine whether the
-# application is still running or not.
+# This file contains the main part of the module for this gem.
 
 #--
 ################################################################################
@@ -33,7 +32,8 @@
 ################################################################################
 #++
 
+# Main module for this gem.
 module TestInternals
-  # This constant is used to track whether the application is still running.
-  AppState = AppMode.new(:alive, [:alive, :dead])
+  # This constant is used to indicate whether the application has been stopped.
+  AppState = StateManager.new(:alive, [:alive, :dead])
 end

data/lib/test_internals.rb

@@ -1,8 +1,7 @@
 gem_name = File.basename(__FILE__, '.rb')
 
-require 'app_mode'
 require 'test/unit'
+require 'app_mode'
 
-require_relative File.join(gem_name, 'app_state')
-require_relative File.join(gem_name, 'kernel')
+require_relative File.join(gem_name, gem_name)
 require_relative File.join(gem_name, 'test_case')

data/test_internals.gemspec

@@ -1,19 +1,22 @@
 Gem::Specification.new do |s|
   s.name    = 'test_internals'
-  s.version = '0.0.2'
+  s.version = '1.0.0'
 
   s.summary     = 'Allows tests to check the stack trace, ' +
     'parameters, private methods, and class variables.'
-  s.description = 'TestInternals patches Test::Unit::TestCase to allow ' +
-    'testing of private methods, as well as variables. The stack trace ' +
-    'is also available, including the ability to check that specific ' +
-    'parameters were sent to a method.'
+
+  s.description = %Q{
+TestInternals patches Test::Unit::TestCase to allow
+testing of private methods, as well as variables. The stack trace
+is also available, including the ability to check that specific
+parameters were sent to a method. This results in cotton candy goodness for all.
+}.strip
 
   s.author   = 'Travis Herrick'
   s.email    = 'tthetoad@gmail.com'
   s.homepage = 'http://www.bitbucket.org/ToadJamb/gems_test_internals'
 
-  s.license = 'GPLV3'
+  s.license = 'GPLv3'
 
   s.extra_rdoc_files << 'README'
 
@@ -21,7 +24,7 @@ Gem::Specification.new do |s|
   s.files = Dir['lib/**/*.rb', '*']
   s.test_files = Dir['test/**/*.rb']
 
-  s.add_dependency 'app_mode', '~> 0.0.1'
+  s.add_dependency 'app_mode', '~> 1.0.0'
 
   s.add_development_dependency 'rake_tasks', '~> 0.0.1'
 

metadata

@@ -3,10 +3,10 @@ name: test_internals
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors: 
 - Travis Herrick
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-08-08 00:00:00 -04:00
+date: 2011-08-15 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -25,10 +25,10 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version 
         segments: 
+        - 1
         - 0
         - 0
-        - 1
-        version: 0.0.1
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: *id001
@@ -47,7 +47,11 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id002
-description: TestInternals patches Test::Unit::TestCase to allow testing of private methods, as well as variables. The stack trace is also available, including the ability to check that specific parameters were sent to a method.
+description: |-
+  TestInternals patches Test::Unit::TestCase to allow
+  testing of private methods, as well as variables. The stack trace
+  is also available, including the ability to check that specific
+  parameters were sent to a method. This results in cotton candy goodness for all.
 email: tthetoad@gmail.com
 executables: []
 
@@ -56,19 +60,18 @@ extensions: []
 extra_rdoc_files: 
 - README
 files: 
-- lib/test_internals/test_case.rb
-- lib/test_internals/app_state.rb
-- lib/test_internals/kernel.rb
 - lib/test_internals.rb
+- lib/test_internals/test_case.rb
+- lib/test_internals/test_internals.rb
 - Gemfile.lock
 - Gemfile
-- rakefile
 - README
+- rakefile
 - test_internals.gemspec
 has_rdoc: true
 homepage: http://www.bitbucket.org/ToadJamb/gems_test_internals
 licenses: 
-- GPLV3
+- GPLv3
 post_install_message: 
 rdoc_options: []
 
@@ -79,7 +82,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2525836242587382346
+      hash: 2800249786482312969
       segments: 
       - 0
       version: "0"

data/lib/test_internals/kernel.rb

@@ -1,42 +0,0 @@
-# This file contains a monkey patch of Kernel functions for use during testing.
-
-#--
-################################################################################
-#                      Copyright (C) 2011 Travis Herrick                       #
-################################################################################
-#                                                                              #
-#                                 \v^V,^!v\^/                                  #
-#                                 ~%       %~                                  #
-#                                 {  _   _  }                                  #
-#                                 (  *   -  )                                  #
-#                                 |    /    |                                  #
-#                                  \   _,  /                                   #
-#                                   \__.__/                                    #
-#                                                                              #
-################################################################################
-# This program is free software: you can redistribute it                       #
-# and/or modify it under the terms of the GNU General Public License           #
-# as published by the Free Software Foundation,                                #
-# either version 3 of the License, or (at your option) any later version.      #
-#                                                                              #
-# Commercial licensing may be available for a fee under a different license.   #
-################################################################################
-# This program is distributed in the hope that it will be useful,              #
-# but WITHOUT ANY WARRANTY;                                                    #
-# without even the implied warranty of MERCHANTABILITY                         #
-# or FITNESS FOR A PARTICULAR PURPOSE.                                         #
-# See the GNU General Public License for more details.                         #
-#                                                                              #
-# You should have received a copy of the GNU General Public License            #
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.        #
-################################################################################
-#++
-
-# Monkey patch Kernel classes and functions for testing.
-module Kernel
-  # Patch exit so that it sets a flag rather than ends the application.
-  # (A call to exit will cause testing to stop otherwise).
-  def exit(*args)
-    TestInternals::AppState.state = :dead
-  end
-end