nucleon 0.2.2 → 0.2.3

data/spec/core/core_spec.rb

@@ -0,0 +1,185 @@
+
+require 'spec_helper'
+
+module Nucleon
+
+  describe Core do
+
+    include_context "nucleon_test"
+    include_context "nucleon_config"
+
+
+    #***************************************************************************
+
+    def core(*args, &code)
+      test_object(Core, *args, &code)
+    end
+
+
+    #***************************************************************************
+
+    let(:core_object) { core(config_hash2) }
+
+
+    #***************************************************************************
+    # Constructor / Destructor
+
+    # Initialize a new Nucleon core object
+    #
+    describe "#initialize" do
+
+      it "creates via the default values if nil given as the primary data source" do
+        test_config core(nil, config_hash1, true, true, true), config_hash1
+        test_config core(nil, config_hash1, true, true, false), config_hash1
+        test_config core(nil, config_hash1, true, false, true), config_hash1
+        test_config core(nil, config_hash1, true, false, false), config_hash1
+
+        test_config core(nil, config_hash1, false, true, true), config_hash1
+        test_config core(nil, config_hash1, false, true, false), config_hash1
+        test_config core(nil, config_hash1, false, false, true), config_hash1
+        test_config core(nil, config_hash1, false, false, false), config_hash1
+      end
+
+      it "creates via a basic merge of hash with forced overwrites" do
+        test_config core(config_hash2, config_hash1, true, true, true), config_hash_force_basic_merge
+        test_config core(config_hash2, config_hash1, true, false, true), config_hash_force_basic_merge
+      end
+      it "creates via a deep merge of hash with forced overwrites" do
+        test_config core(config_hash2, config_hash1, true, true, false), config_hash_force_deep_merge
+        test_config core(config_hash2, config_hash1, true, false, false), config_hash_force_deep_merge
+      end
+      it "creates via a basic merge of hash with no forced overwrites" do
+        test_config core(config_hash2, config_hash1, false, true, true), config_hash_no_force_basic_merge
+        test_config core(config_hash2, config_hash1, false, false, true), config_hash_no_force_basic_merge
+      end
+      it "creates via a deep merge of hash with no forced overwrites" do
+        test_config core(config_hash2, config_hash1, false, true, false), config_hash_no_force_deep_merge
+        test_config core(config_hash2, config_hash1, false, false, false), config_hash_no_force_deep_merge
+      end
+
+      it "creates via a basic merge of Config object with forced overwrites" do
+        test_config core(core_object, config_hash1, true, true, true), config_hash_force_basic_merge
+        test_config core(core_object, config_hash1, true, false, true), config_hash_force_basic_merge
+      end
+      it "creates via a deep merge of Config object with forced overwrites" do
+        test_config core(core_object, config_hash1, true, true, false), config_hash_force_deep_merge
+        test_config core(core_object, config_hash1, true, false, false), config_hash_force_deep_merge
+      end
+      it "creates via a basic merge of Config object with no forced overwrites" do
+        test_config core(core_object, config_hash1, false, true, true), config_hash_no_force_basic_merge
+        test_config core(core_object, config_hash1, false, false, true), config_hash_no_force_basic_merge
+      end
+      it "creates via a deep merge of Config object with no forced overwrites" do
+        test_config core(core_object, config_hash1, false, true, false), config_hash_no_force_deep_merge
+        test_config core(core_object, config_hash1, false, false, false), config_hash_no_force_deep_merge
+      end
+    end
+
+
+    #***************************************************************************
+    # Checks
+
+    # Check if object is initialized?
+    #
+    describe "#initialized?" do
+
+      it "is true after initialization if set_initialized flag given" do
+        test_eq core(config_hash2, config_hash1, true, true, true).initialized?, true
+        test_eq core(config_hash2, config_hash1, true, true, false).initialized?, true
+        test_eq core(config_hash2, config_hash1, false, true, true).initialized?, true
+        test_eq core(config_hash2, config_hash1, false, true, false).initialized?, true
+      end
+
+      it "is false after initialization if set_initialized flag not given" do
+        test_eq core(config_hash2, config_hash1, true, false, true).initialized?, false
+        test_eq core(config_hash2, config_hash1, true, false, false).initialized?, false
+        test_eq core(config_hash2, config_hash1, false, false, true).initialized?, false
+        test_eq core(config_hash2, config_hash1, false, false, false).initialized?, false
+      end
+    end
+
+
+    #***************************************************************************
+    # Accessor / Modifiers
+
+    # Return global logger instance
+    #
+    describe "#logger" do
+
+      it "returns the global logger instance" do
+        test_type Core.logger, Nucleon::Util::Logger
+      end
+    end
+
+    # Set current object logger instance
+    #
+    describe "#logger=" do
+
+      it "assigns instance logger from existing logger instance" do
+        core(config_hash1, {}, true, true, true) do |core|
+          logger      = test_object(Util::Logger, "test1")
+          core.logger = logger
+
+          test_eq logger == core.logger, true
+          test_eq core.logger.resource == "test1", true
+        end
+      end
+
+      it "assigns instance logger from new logger instance with specific name" do
+        core(config_hash2, {}, true, true, true) do |core|
+          core.logger = "test2"
+          test_eq core.logger.resource == "test2", true
+        end
+      end
+    end
+
+    # Return global console instance
+    #
+    describe "#ui" do
+
+      it "returns the global console instance" do
+        test_type Core.ui, Nucleon::Util::Console
+      end
+    end
+
+    # Set current object console instance
+    #
+    describe "#ui=" do
+
+      it "assigns instance console from existing console instance" do
+        core(config_hash1, {}, true, true, true) do |core|
+          console = test_object(Util::Console, "test1")
+          core.ui = console
+
+          test_eq console == core.ui, true
+          test_eq core.ui.resource == "test1", true
+        end
+      end
+
+      it "assigns instance console from new console instance with specific name" do
+        core(config_hash2, {}, true, true, true) do |core|
+          core.ui = "test2"
+          test_eq core.ui.resource == "test2", true
+        end
+      end
+    end
+
+
+    #***************************************************************************
+    # General utilities
+
+    # Contextualize console operations in a code block with a given resource name.
+    #
+    describe "#ui_group" do
+
+      it "prints a colored message with a set prefix to the console" do
+        test_output("[\e\[36mtest string\e\[0m] -----------------------------------------------------") do |output|
+          Core.ui_group("test string", :cyan) do |ui|
+            ui.output = output
+            ui.info("-----------------------------------------------------")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/core/environment_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module Nucleon
+
+  describe Environment do
+
+    include_context "nucleon_test"
+    include_context "nucleon_plugin"
+    
+    
+    #***************************************************************************
+
+    def environment(*args, &code)
+      test_object(Environment, *args, &code)
+    end
+
+
+  #*****************************************************************************
+  # Constructor / Destructor
+  
+    describe "#initialize" do
+      
+      it "tests initialize method" do
+        test_config environment, plugin_environment_empty
+      end
+      
+    end
+    
+  #*****************************************************************************
+  # Plugin type accessor / modifiers
+  
+    describe "#namespaces" do
+      
+      it "tests namespaces with empty array values" do
+        test_eq environment.namespaces,[]
+      end
+      
+      it "tests namespaces with array values" do
+        environment do |environment|
+          environment.define_plugin_type :nucleon, :test, :first
+          environment.define_plugin_type :unit, :test, :first
+          environment.define_plugin_type :testing, :test, :first
+          test_eq environment.namespaces, [:nucleon, :unit, :testing]
+        end
+      end 
+      
+    end
+    
+    describe "#plugin_types" do
+      
+      it "returns an empty array when no plugin types are defined" do
+          test_eq environment.plugin_types(:nucleon),[]
+      end
+      
+      it "returns the existing plugin types for a namespace when given an existing namespace" do
+        environment do |environment|
+          environment.define_plugin_type :nucleon, :test, :first
+          test_eq environment.plugin_types(:nucleon), [:test]
+        end
+      end
+      
+      it "returns an empty array when plugin types are defined but specified namespace does not exist" do
+        environment do |environment|
+          environment.define_plugin_type :nucleon, :test, :first
+          test_eq environment.plugin_types(:nonexist), []
+        end
+      end      
+      
+    end
+    
+  # Define a new plugin type in a specified namespace.
+  #
+  
+    describe "#define_plugin_type" do
+      
+      it "returns loaded plugins state" do
+          test_config environment.define_plugin_type(:nucleon, :test, :first), {
+                                                                                  :plugin_types=>{:nucleon=>{:test=>:first}}, 
+                                                                                  :load_info=>{}, 
+                                                                                  :active_info=>{}
+                                                                               }
+      end
+      
+    end
+    
+  # Define one or more new plugin types in a specified namespace.
+  #
+  
+    describe "#define_plugin_types" do
+      
+      it "returns loaded plugins state" do
+        test_config environment.define_plugin_types(:nucleon, { :test1 => "test2", :test3 => "test4"}),{
+                                                                                                          :plugin_types=>{:nucleon=>{:test1=>"test2", :test3=>"test4"}}, 
+                                                                                                          :load_info=>{}, 
+                                                                                                          :active_info=>{}
+                                                                                                         }
+      end
+      
+      it "returns environment object" do
+        test_type environment.define_plugin_types(:nucleon, { :test1 => "test2", :test3 => "test4"}), Nucleon::Environment
+      end
+      
+    end
+    
+  # Check if a specified plugin type has been defined
+  #
+    
+    describe "#plugin_type_defined?" do
+      
+      it "returns true for defined plugins" do
+        environment do |environment|
+          environment.define_plugin_type(:nucleon, :test, :first)
+          test_eq environment.plugin_type_defined?(:nucleon, :test),true
+        end
+      end
+      
+      it "returns false for undefined plugins" do
+        environment do |environment|
+          environment.define_plugin_type(:nucleon, :test, :first)
+          test_eq environment.plugin_type_defined?(:notavail, :test),false
+        end  
+      end
+    end
+      
+  # Return the default provider currently registered for a plugin type
+  #
+  
+    describe "#plugin_type_default" do
+      
+      it "returns default provider using define_plugin_type" do
+        environment do |environment|
+          environment.define_plugin_type(:nucleon, :test, :first)
+          test_eq environment.plugin_type_default(:nucleon, :test),:first
+        end
+      end
+      
+      it "returns default provider using define_plugin_types" do
+        environment do |environment|
+          environment.define_plugin_types(:nucleon1, { :test1 => "test2", :test3 => "test4"})
+          test_eq environment.plugin_type_default(:nucleon1, :test3),"test4"
+        end
+      end
+ 
+    end
+    
+  end
+  
+end

data/spec/core/util/console_spec.rb

@@ -5,517 +5,325 @@ module Nucleon
 
   describe Util::Console do
 
-    #---------------------------------------------------------------------------
-    # UI functionality
-    
+    include_context "nucleon_test"
+
+
+    #***************************************************************************
+
+    def console(*args, &code)
+      test_object(Util::Console, *args, &code)
+    end
+
+
+    #***************************************************************************
+    # Core IO
+
+    # Output via a printer method to an output channel unless quiet specified
+    #
     describe "#say" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Console.new({ :console_delegate => ui }).say(:info, 'message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Output formats
+        test_output('message', :puts) do |output|
+          console({ :output => output }) do |console|
+            console({ :console_delegate => console }).say(:info, 'message')
+          end
+        end
+      end
 
       it "prints a message with default options" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        Util::Console.new({ :output => output1 }).say(:info, 'message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('[component] message')
-        
-        Util::Console.new({
-          :resource => 'component', 
-          :output   => output2, 
-        }).say(:info, 'message')      
-      end
-      
-      #---
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output }).say(:info, 'message')
+        end
+
+        test_output('[component] message', :puts) do |output|
+          console({
+            :resource => 'component',
+            :output   => output,
+          }).say(:info, 'message')
+        end
+      end
+
       it "prints a message with and without newlines included" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Console.new({ :output => output1 })
-        test.say(:info, 'message', { :new_line => true })
-        
-        output2 = double('output2')
-        output2.should_receive(:print).with('message')
-        
-        test = Util::Console.new({ :output => output2 })
-        test.say(:info, 'message', { :new_line => false })      
-      end
-      
-      #---
-      
-      it "routes message to output and error channels based on type given" do       
+        test_output('message', :puts) do |output|
+          console({ :output => output }).say(:info, 'message', { :new_line => true })
+        end
+
+        test_output('message', :print) do |output|
+          console({ :output => output }).say(:info, 'message', { :new_line => false })
+        end
+      end
+
+      it "routes message of different types" do
         [:info, :warn, :success, :error].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message')
-        
-          Util::Console.new({
-            :output  => output,
-            :printer => :puts,
-            :color   => false,
-          }).say(type, 'message')
+          test_output('message', :puts) do |output|
+            console({ :output => output, :color => false }).say(type, 'message')
+          end
         end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Console.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        }).dump('message')   
-      end
-      
-      #---
-      
+      end
+
       it "routes message to output and error channels based on channel given" do
         [:info, :warn, :success].each do |type|
-          output = double('output')
-          output.should_receive(:puts).with('message1')
-        
-          Util::Console.new({
-            :printer => :puts,
-          }).say(:info, 'message1', { :channel => output })        
+          test_output(type.to_s, :puts) do |output|
+            console({ :color => false }).say(type, type.to_s, { :channel => output })
+          end
         end
-        
-        error = double('error')
-        error.should_receive(:puts).with('message2')
-        
-        Util::Console.new({
-          :printer => :puts,
-          :color   => false,
-        }).say(:info, 'message2', { :channel => error })
-      end  
+      end
     end
-    
-    #---
-    
+
+    # Dump an object to an output channel even if quiet specified
+    #
+    describe "#dump" do
+
+      it "can delegate to another class that contains this method" do
+        test_output('message', :puts) do |output|
+          console({ :error => output }) do |console|
+            console({ :console_delegate => console }).dump('message')
+          end
+        end
+      end
+
+      it "dumps data to stderr output channel" do
+        test_output('message', :puts) do |output|
+          console({ :error => output }).dump('message')
+        end
+      end
+    end
+
+    # Ask terminal user for an input value
+    #
     describe "#ask" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method"
-      
-      #-------------------------------------------------------------------------
-      # Input
-      
+
       it "displays a prompt and returns user feedback"
     end
-    
-    #---
-    
+
+    # Ask terminal user for an input value
+    #
+    describe "#password" do
+
+      it "can delegate to another class that contains this method"
+
+      it "displays a prompt and returns user feedback with user typing hidden"
+    end
+
+
+    #***************************************************************************
+    # Specialized output
+
+    # Output information to an output channel unless quiet specified
+    #
     describe "#info" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Console.new({ :console_delegate => ui }).info('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output }) do |console|
+            console({ :console_delegate => console }).info('message')
+          end
+        end
+      end
+
       it "prints an uncolored information message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Console.new({ 
-          :output  => output,
-          :printer => :puts, 
-        }).info('message')
-      end    
+        test_output('message', :puts) do |output|
+          console({ :output => output }).info('message')
+        end
+      end
     end
-    
-    #---
-    
+
+    # Output warning to an output channel unless quiet specified
+    #
     describe "#warn" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Console.new({ :console_delegate => ui }).warn('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }) do |console|
+            console({ :console_delegate => console }).warn('message')
+          end
+        end
+      end
+
       it "prints an uncolored warning message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Console.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).warn('message')
-      end
-      
-      #---
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }).warn('message')
+        end
+      end
+
       it "prints a colored warning message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[33mmessage\e\[0m$/)
-        
-        Util::Console.new({ 
-          :output => output,
-          :color  => true, 
-        }).warn('message', { :new_line => false })
-      end    
+        test_output("\e\[33mmessage\e\[0m", :print) do |output|
+          console({ :output => output, :color => true }).warn('message', { :new_line => false })
+        end
+      end
     end
-    
-    #---
-    
+
+    # Output error to an output channel unless quiet specified
+    #
     describe "#error" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Console.new({ :console_delegate => ui }).error('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }) do |console|
+            console({ :console_delegate => console }).error('message')
+          end
+        end
+      end
+
       it "prints an uncolored error message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Console.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).error('message')
-      end
-      
-      #---
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }).error('message')
+        end
+      end
+
       it "prints a colored error message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[31mmessage\e\[0m$/)
-        
-        Util::Console.new({ 
-          :output => output,
-          :color  => true, 
-        }).error('message', { :new_line => false })
-      end 
+        test_output("\e\[31mmessage\e\[0m", :print) do |output|
+          console({ :output => output, :color => true }).error('message', { :new_line => false })
+        end
+      end
     end
-    
-    #---
-    
+
+    # Output success message to an output channel unless quiet specified
+    #
     describe "#success" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Console.new({ :console_delegate => ui }).success('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }) do |console|
+            console({ :console_delegate => console }).success('message')
+          end
+        end
+      end
+
       it "prints an uncolored success message" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Console.new({ 
-          :output  => output,
-          :printer => :puts,
-          :color   => false, 
-        }).success('message')
-      end
-      
-      #---
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :color => false }).success('message')
+        end
+      end
+
       it "prints a colored success message" do
-        output = double('output')
-        output.should_receive(:print).with(/^\e\[32mmessage\e\[0m$/)
-        
-        Util::Console.new({ 
-          :output => output,
-          :color  => true, 
-        }).success('message', { :new_line => false })
-      end  
-    end
-  
-    #---
-    
-    describe "#dump" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
-      it "can delegate to another class that contains this method" do
-        error  = double('error')
-        error.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :error   => error,
-          :printer => :puts,
-          :color   => false,
-        })        
-        Util::Console.new({ :console_delegate => ui }).dump('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Printing
-      
-      it "dumps data to stderr output channel" do
-        error  = double('error')
-        error.should_receive(:puts).with('message')
-        
-        Util::Console.new({ 
-          :error   => error,
-          :printer => :puts,
-          :color   => false, 
-        }).dump('message')
+        test_output("\e\[32mmessage\e\[0m", :print) do |output|
+          console({ :output => output, :color => true }).success('message', { :new_line => false })
+        end
       end
     end
-    
-    #---------------------------------------------------------------------------
+
+
+    #***************************************************************************
     # Utilities
-    
+
+    # Format a message for display
+    #
     describe "#format_message" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        message = Util::Console.new({ 
-          :console_delegate => Util::Console.new('delegate')
-        }).format_message(:info, 'message', { :prefix => true })
-        
-        message.should == '[delegate] message'
-      end
-    
-      #-------------------------------------------------------------------------
-      # Prefix specifications
-      
+        console({ :console_delegate => console('delegate') }) do |console|
+          test_eq console.format_message(:info, 'message', { :prefix => true }), '[delegate] message'
+        end
+      end
+
       it "returns without a prefix because no resource" do
-        message = Util::Console.new.format_message(:info, 'message', { :prefix => true })
-        message.should == 'message'
+        test_eq console.format_message(:info, 'message', { :prefix => true }), 'message'
       end
-      
-      #---
-      
+
       it "returns without a prefix because prefix is false" do
-        message = Util::Console.new('component').format_message(:info, 'message', { :prefix => false })
-        message.should == 'message'
+        test_eq console('component').format_message(:info, 'message', { :prefix => false }), 'message'
       end
-      
-      #---
-            
+
       it "returns without a prefix because no prefix option given" do
-        message = Util::Console.new('component').format_message(:info, 'message')
-        message.should == 'message'
+        test_eq console('component').format_message(:info, 'message'), 'message'
       end
-      
-      #---
-            
+
       it "returns with a prefix if resource and prefix option given" do
-        message = Util::Console.new('component').format_message(:info, 'message', { :prefix => true })
-        message.should == '[component] message'
+        test_eq console('component').format_message(:info, 'message', { :prefix => true }), '[component] message'
       end
-      
-      #-------------------------------------------------------------------------
-      # Color specifications
-      
+
       it "formats a error message in red if color enabled" do
-        message = Util::Console.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:error, 'message')
-        message.should match(/^\e\[31mmessage\e\[0m$/)
-      end
-      
-      #---
-      
+        test_eq console({ :resource => 'component', :color => true }).format_message(:error, 'message'), "\e\[31mmessage\e\[0m"
+      end
+
       it "formats a warning message in yellow if color enabled" do
-        message = Util::Console.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:warn, 'message')
-        message.should match(/^\e\[33mmessage\e\[0m$/)
-      end
-      
-      #---
-      
+        test_eq console({ :resource => 'component', :color => true }).format_message(:warn, 'message'), "\e\[33mmessage\e\[0m"
+      end
+
       it "formats a success message in green if color enabled" do
-        message = Util::Console.new({
-          :resource => 'component',
-          :color    => true,
-        }).format_message(:success, 'message')
-        message.should match(/^\e\[32mmessage\e\[0m$/)
+        test_eq console({ :resource => 'component', :color => true }).format_message(:success, 'message'), "\e\[32mmessage\e\[0m"
       end
     end
-    
-    #---------------------------------------------------------------------------
-    
+
+    # Safely output via a printer method to an output channel unless quiet specified
+    #
     describe "#safe_puts" do
-    
-      #-------------------------------------------------------------------------
-      # Delegation
-      
+
       it "can delegate to another class that contains this method" do
-        output  = double('output')
-        output.should_receive(:puts).with('message')
-        
-        ui = Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        })        
-        Util::Console.new({ :console_delegate => ui }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Instance configuration
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output }) do |console|
+            console({ :console_delegate => console }).safe_puts('message')
+          end
+        end
+      end
+
       it "prints an empty string unless message given" do
-        output  = double('output')
-        output.should_receive(:puts).with('')
-        
-        Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts()
-      end
-      
-      #---
-      
+        test_output('', :puts) do |output|
+          console({ :output => output }).safe_puts()
+        end
+      end
+
       it "prints to different output channels if they are given" do
-        output1 = double('output1')
-        output1.should_receive(:puts).with('message')
-        
-        test = Util::Console.new({
-          :output  => output1,
-          :printer => :puts,
-        })
-        test.safe_puts('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        test.output = output2
-        test.safe_puts('message')
-      end
-      
-      #---
-      
+        console do |console|
+          test_output('message1', :puts) do |output|
+            console.output = output
+            console.safe_puts('message1')
+          end
+          test_output('message2', :puts) do |output|
+            console.output = output
+            console.safe_puts('message2')
+          end
+        end
+      end
+
       it "prints with puts if puts printer option given" do
-        output = double('output')
-        output.should_receive(:puts).with('message')
-        
-        Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message')
-      end
-      
-      #---
-      
+        test_output('message', :puts) do |output|
+          console({ :output => output, :printer => :puts }).safe_puts('message')
+        end
+      end
+
       it "prints with print if print printer option given" do
-        output = double('output')
-        output.should_receive(:print).with('message')
-        
-        Util::Console.new({
-          :output  => output,
-          :printer => :print,
-        }).safe_puts('message')
-      end
-      
-      #-------------------------------------------------------------------------
-      # Method configuration
-      
+        test_output('message', :print) do |output|
+          console({ :output => output, :printer => :print }).safe_puts('message')
+        end
+      end
+
       it "can override the instance output channel" do
-        output1 = double('output1')
-        output1.should_not_receive(:puts).with('message')
-        
-        output2 = double('output2')
-        output2.should_receive(:puts).with('message')
-        
-        Util::Console.new({
-          :output  => output1,
-          :printer => :puts,
-        }).safe_puts('message', { :channel => output2 })  
-      end
-      
-      #---
-      
+        test_output('message1', :puts) do |output|
+          console({ :output => output }) do |console|
+            console.safe_puts('message1')
+            console.safe_puts('message2', { :channel => test_output('message2', :puts) })
+          end
+        end
+      end
+
       it "can override the instance printer handler" do
-        output = double('output')
-        output.should_not_receive(:puts).with('message')
-        output.should_receive(:print).with('message')
-        
-        Util::Console.new({
-          :output  => output,
-          :printer => :puts,
-        }).safe_puts('message', { :printer => :print })
+        test_output('message1', :puts) do |output|
+          console({ :output => output, :printer => :puts }) do |console|
+            console.safe_puts('message1')
+            console.safe_puts('message2', { :channel => test_output('message2', :print), :printer => :print })
+          end
+        end
       end
     end
-    
-    #---------------------------------------------------------------------------
-    
+
+    # Check if a registered delegate exists and responds to a specified method.
+    #
     describe "#check_delegate" do
-      
+
       it "returns false if no delegate exists" do
-        Util::Console.new.check_delegate('safe_puts').should be_false
+        test_eq console.check_delegate('safe_puts'), false
       end
+
       it "returns true if a delegate exists and it implements given method" do
-        test = Util::Console.new({ :console_delegate => Util::Console.new })
-        test.check_delegate('safe_puts').should be_true
-        test.check_delegate('nonexistent').should be_false
+        console({ :console_delegate => console }) do |console|
+          test_eq console.check_delegate('safe_puts'), true
+          test_eq console.check_delegate('nonexistent'), false
+        end
       end
-    end  
+    end
   end
 end