mole 1.0.12 → 1.0.15

data/spec/models/mole_feature_spec.rb

@@ -1,48 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper" )
-                
-describe MoleFeature do                         
-  before( :each ) do                                                                    
-    ::Mole.reset_configuration!
-    ::Mole.initialize( :application => "Test", 
-                       :mode        => :persistent, 
-                       :log_level   => :debug, 
-                       :moleable    => true )
-  end
-                      
-  it "should find or create known features correctly" do
-    %w[ all performance exception].each do |f|
-      feature = MoleFeature.send( "find_#{f}_feature".to_sym, ::Mole.application )
-      feature.should_not           be_nil    
-      feature.name.downcase.should == f
-    end
-  end     
-  
-  it "should create a new feature" do
-    feature = MoleFeature.find_or_create_feature( "Fred", ::Mole.application, self.class.name )
-    feature.should_not     be_nil
-    feature.name.should    == "Fred"
-    feature.context.should == self.class.name
-  end  
-  
-  it "should not create a feature with no name" do
-    feature = MoleFeature.find_or_create_feature( "", ::Mole.application, self.class.name )
-    feature.should be_nil
-  end    
-  
-  it "should find all features for a given application correctly" do
-    %w[ all performance exception].each do |f|
-      MoleFeature.send( "find_#{f}_feature".to_sym, ::Mole.application )
-    end                                                                              
-    MoleFeature.find_or_create_feature( "Fred", ::Mole.application, self.class.name )
-    features = MoleFeature.find_features( ::Mole.application )
-    features.should have(4).mole_features
-  end     
-  
-  it "should find moled application names correctly" do
-    MoleFeature.find_moled_application_names.should be_empty
-    %w[ all performance exception].each do |f|
-      feature = MoleFeature.send( "find_#{f}_feature".to_sym, ::Mole.application )
-    end
-    MoleFeature.find_moled_application_names.should == ["Test"]
-  end
-end

data/spec/models/mole_log_spec.rb

@@ -1,62 +0,0 @@
-require File.join(File.dirname(__FILE__), "..", "spec_helper" )
-require 'ostruct'
-           
-describe MoleLog do                           
-  before( :each ) do    
-    ::Mole.reset_configuration!
-    ::Mole.initialize( :mode => :persistent, :log_level => :info, :moleable => true )
-    @args = { :blee => "Hello", :duh => "World" }
-  end
-                      
-  it "should log unchecked exceptions correctly" do
-     args = @args 
-     feature = MoleFeature.find_exception_feature( ::Mole.application )
-     feature.should_not be_nil      
-     begin
-       raise "Something crapped out"
-     rescue => boom     
-       args[:boom] = Mole::Moler.dump_stack( boom )
-       MoleLog.log_it( self, feature, 100, args )
-     end
-     check_it( feature, 100, @args )   
-  end
-      
-  it "should log perf exception correctly" do                       
-     feature = MoleFeature.find_performance_feature( ::Mole.application )
-     feature.should_not be_nil         
-     MoleLog.log_it( self, feature, 200, @args )
-     check_it( feature, 200, @args )
-  end
-
-  it "should mole a feature correctly" do
-     feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, "Test".class.name )
-     feature.should_not be_nil         
-     MoleLog.log_it( "Test", feature, 300, @args )
-     check_it( feature, 300, @args )
-  end
-
-  it "should log request info correctly" do
-     ctrl    = Moled::Controller.new
-     feature = MoleFeature.find_or_create_feature( "fred", ::Mole.application, ctrl.class.name )
-     feature.should_not be_nil          
-     MoleLog.log_it( ctrl, feature, 400, @args )
-     log = check_it( feature, 400, @args )
-     log.ip_address.should    == "1.1.1.1"
-     log.browser_type.should  == "GodZilla"
-  end      
-    
-  # Test Controller...
-  module Moled
-    class Controller
-      class Request
-        def env
-          {'REMOTE_ADDR' => "1.1.1.1", 'HTTP_USER_AGENT' => 'GodZilla' }
-        end
-      end
-    
-      def request
-        Request.new
-      end
-    end
-   end
-end

data/spec/module_spec.rb

@@ -1,229 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper" )
-
-
-describe Module do     
-  before( :all ) do
-    ::Mole.initialize( :perf_threshold => 1, :log_level => :info )
-    require File.join( File.dirname(__FILE__),  %w[data blee] )                          
-  end
-                    
-  before( :each ) do
-    @blee = Blee.new    
-    CallStackChecker.reset!                                                                 
-  end                    
-
-  it "should handle features with punctuation correctly" do
-    Blee.mole_before( :feature => :get_out? ) { |context, feature, *args| 
-      CallStackChecker.called
-    }              
-    @blee.get_out?
-    CallStackChecker.should be_called    
-  end
-  
-  it "should trap mole before handler exceptions" do
-    Blee.mole_before( :feature => :crap_out ) { |context, feature, *args| 
-      raise "LEGIT !! - Before - Something did crap out"
-      CallStackChecker.called
-    }              
-    @blee.crap_out                      
-    CallStackChecker.should_not be_called
-  end
-
-  it "should trap mole after handler exceptions" do
-    Blee.mole_after( :feature => :crap_out ) { |context, feature, *args| 
-      raise "LEGIT !! - After - Something did crap out"
-      CallStackChecker.called
-    }              
-    @blee.crap_out                      
-    CallStackChecker.should_not be_called
-  end
-
-  it "should trap mole handler exceptions" do
-    Blee.mole_unchecked( :features => [:blee_raise_too] ) { |context, feature, *args| 
-      raise "-- LEGIT !! - Unchecked - Something did crap out"
-      CallStackChecker.called
-    }                           
-    @blee.blee_raise_too rescue nil                    
-    CallStackChecker.should_not be_called
-  end
-
-  it "should trap a perf handler exception" do
-    Blee.mole_perf( :features => [:blee_slow_too] ) do |context, feature, elapsed_time, args, block|
-      raise "---LEGIT !! - Perf - Something did crap out"      
-      CallStackChecker.called
-    end         
-    @blee.blee_slow_too
-    CallStackChecker.should_not be_called    
-  end 
-  
-  # it "should trap mole handler exceptions" do
-  #   Blee.mole_before( :feature => :crap_out ) { |context, feature, *args| 
-  #     raise "Something did crap out"
-  #     CallStackChecker.called
-  #   }              
-  #   @blee.crap_out                      
-  #   CallStackChecker.should_not be_called
-  # end
-  
-  it "should correctly setup a before call" do
-    Blee.mole_before( :feature => :blee_no_args ) { |context, feature, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_no_args"
-      block.should         be_nil
-      args.should          have(0).items
-      CallStackChecker.called
-    }              
-    @blee.blee_no_args                         
-    CallStackChecker.should be_called
-  end
-  
-  it "should correctly setup an after call" do
-    Blee.mole_after( :feature => :blee_no_args ) { |context, feature, ret_val, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_no_args"
-      args.should          have(0).items      
-      CallStackChecker.called
-    }              
-    @blee.blee_no_args                         
-    CallStackChecker.should be_called
-  end
-  
-  it "should correctly trap an exception" do
-    Blee.mole_unchecked( :features => [:blee_raise] ) do |context, feature, boom, args, block|  
-      context.class.should == Blee
-      feature.should       == "blee_raise"
-      boom.to_s.should     == "Blee exception"
-      CallStackChecker.called
-    end         
-    @blee.blee_raise rescue nil                          
-    CallStackChecker.should be_called    
-  end     
-  
-  it "should not trap a before call" do     
-    @blee.blee_args( "Hello", "World", "Good", "Day" )
-    CallStackChecker.should_not be_called
-  end  
-  
-  it "should correctly trap the before call arguments" do
-    Blee.mole_before( :feature => :blee_args ) { |context, feature, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_args"      
-      args.should          have(4).items
-      args[0].should       == "Hello"
-      args[1].should       == "World"
-      args[2].should       == "Good"
-      args[3].should       == "Day"                  
-      CallStackChecker.called
-    }              
-    @blee.blee_args( "Hello", "World", "Good", "Day" )                         
-    CallStackChecker.should be_called    
-  end    
-
-  it "should correctly trap a before call with a block" do
-    Blee.mole_before( :feature => :blee_block ) do |context, feature, block, *args|
-      context.class.should == Blee
-      feature.should       == "blee_block"      
-      block.should_not     be_nil
-      block.call.should    == "Do it already!!"
-      args.size.should     == 4
-      args[0].should       == "Hello"
-      args[1].should       == "World"
-      args[2].should       == "Good"
-      args[3].should       == "Day"            
-      CallStackChecker.called
-    end         
-    @blee.blee_block( "Hello", "World", "Good", "Day" ) { "Do it already!!" }
-    CallStackChecker.should be_called    
-  end 
-  
-  it "should correctly trap the after call with many arguments" do
-    Blee.mole_after( :feature => :blee_args ) { |context, feature, ret_val, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_args"            
-      ret_val.should       == 20
-      args.size.should     == 4
-      args[0].should       == "Hello"
-      args[1].should       == "World"
-      args[2].should       == "Good"
-      args[3].should       == "Day"      
-      CallStackChecker.called
-    }              
-    @blee.blee_args( "Hello", "World", "Good", "Day" )                         
-    CallStackChecker.should be_called    
-  end    
-
-  it "should correctly trap the after call with a block" do
-    Blee.mole_after( :feature => :blee_block ) do |context, feature, ret_val, block, *args|
-      context.class.should == Blee
-      feature.should       == "blee_block"      
-      block.should_not     be_nil
-      block.call.should    == "Do it already!!"
-      ret_val.should       == 10
-      args.size.should     == 4
-      args[0].should       == "Hello"
-      args[1].should       == "World"
-      args[2].should       == "Good"
-      args[3].should       == "Day"            
-      CallStackChecker.called
-    end         
-    @blee.blee_block( "Hello", "World", "Good", "Day" ) { "Do it already!!" }
-    CallStackChecker.should be_called    
-  end 
-  
-  it "should correctly trap a slow call" do
-    Blee.mole_perf( :features => [:blee_slow] ) do |context, feature, elapsed_time, ret_val, block, *args|
-      context.class.should == Blee
-      feature.should       == "blee_slow"      
-      ret_val.should       == 1
-      block.should         be_nil      
-      args.size.should     == 0      
-      elapsed_time.should  > 1      
-      CallStackChecker.called
-    end         
-    @blee.blee_slow
-    CallStackChecker.should be_called    
-  end 
-  
-  it "should trap a private method correctly" do  
-    Blee.mole_after( :feature => :blee_private ) { |context, feature, ret_val, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_private"            
-      ret_val.should       == "Hello"
-      block.should         be_nil      
-      args.size.should     == 1
-      args[0].should       == "Hello"
-      CallStackChecker.called
-    }              
-    @blee.send( :blee_private, "Hello" )
-    CallStackChecker.should be_called        
-  end
-  
-  it "should trap a protected method correctly" do
-    Blee.mole_after( :feature => :blee_protected ) { |context, feature, ret_val, block, *args| 
-      context.class.should == Blee
-      feature.should       == "blee_protected"            
-      ret_val.should       == "Hello"
-      block.should         be_nil
-      args.size.should     == 1
-      args[0].should       == "Hello"
-      CallStackChecker.called
-    }              
-    @blee.send( :blee_protected, "Hello" )
-    CallStackChecker.should be_called        
-  end      
-                 
-  it "should mole a static method correctly" do
-    pending do
-      Blee.mole_after( :feature => :blee_static ) { |context, feature, ret_val, block, *args| 
-        context.class.should == Blee
-        feature.should       == "blee_static"            
-        ret_val.should       be_nil
-        block.should         be_nil
-        args.size.should     == 0
-        CallStackChecker.called
-      }              
-      Blee.blee_static
-      CallStackChecker.should be_called            
-    end
-  end
-end

data/spec/mole_spec.rb

@@ -1,135 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper" )
-
-describe Mole do     
-  before( :all ) do        
-    ::Mole.reset_configuration!
-    ::Mole.initialize( :moleable => true )
-    @root = ::File.expand_path( ::File.join(::File.dirname(__FILE__), ".." ) )
-  end
-                                 
-  it "is versioned" do
-    ::Mole::Version.version.should =~ /\d+\.\d+\.\d+/
-  end
-  
-  it "should have the right defaults" do
-    Mole.should                be_moleable
-    Mole.logger.should_not     be_nil
-    Mole.perf_threshold.should == 5
-    Mole.should_not            be_persistent  
-    Mole.application.should    == "Default"
-  end         
-  
-  it "generates a correct path relative to root" do
-    Mole.path( "mole.rb" ).should == ::File.join(@root, "mole.rb" )
-  end
-  
-  it "generates a correct path relative to lib" do
-    Mole.libpath(%w[ mole db_mole.rb]).should == ::File.join(@root, "lib", "mole", "db_mole.rb")
-  end       
-  
-  it "should define the correct run modes" do
-    Mole.run_modes.should == [:transient,:persistent]
-  end       
-  
-  it "should dump config info to console" do
-    Mole.dump
-  end
-  
-  it "should locate controller classes correctly" do
-    classes = Mole.find_controller_classes( File.join(File.dirname(__FILE__), %w[data] ) )
-    classes.should == %w[Blee]
-  end
-  
-  describe ".auto_xxx" do
-    before( :each ) do
-      ::Mole.reset_configuration!
-      ::Mole.initialize( :perf_threshold => 1, :log_level => :debug )
-      require File.join( File.dirname(__FILE__),  %w[data blee] )
-      Blee.send( :mole_clear! )
-      CallStackChecker.reset! 
-    end
-
-    it "should auto perf a set of controllers correctly" do
-      Mole.auto_perf( File.join(File.dirname(__FILE__), %w[data] ) ) do |context, feature, elapsed_time, ret_val, block, *args|  
-        context.class.should == Blee
-        block.should         be_nil      
-        args.size.should     == 0      
-        elapsed_time.should  > 1      
-        CallStackChecker.called
-      end         
-      Blee.new.blee_slow      
-      CallStackChecker.should be_called    
-      CallStackChecker.reset!
-      Blee.new.blee_slow_too  
-      CallStackChecker.should be_called          
-    end
-    
-    it "should auto check a set of controllers correctly" do
-      Mole.auto_unchecked( File.join(File.dirname(__FILE__), %w[data] ) ) do |context, feature, elapsed_time, block, *args|  
-        context.class.should == Blee
-        feature.should       == "blee_raise"      
-        block.should         be_nil      
-        args.size.should     == 0      
-        CallStackChecker.called
-      end   
-      Blee.new.blee_raise rescue nil
-      CallStackChecker.should be_called    
-    end
-
-    it "should auto before a set of controllers correctly" do
-      Mole.auto_before( File.join(File.dirname(__FILE__), %w[data] ) ) do |context, feature, block, *args|  
-        context.class.should == Blee
-        feature.should       == "blee_no_args"      
-        block.should         be_nil      
-        args.size.should     == 0      
-        CallStackChecker.called
-      end   
-      Blee.new.blee_no_args
-      CallStackChecker.should be_called    
-    end
-
-    it "should auto after a set of controllers correctly" do
-      Mole.auto_after( File.join(File.dirname(__FILE__), %w[data] ) ) do |context, feature, ret_val, block, *args|  
-        context.class.should == Blee
-        feature.should       == "blee_no_args"      
-        ret_val.should       == 10
-        block.should         be_nil      
-        args.size.should     == 0      
-        CallStackChecker.called
-      end   
-      Blee.mole_dump( "After" )
-      Blee.new.blee_no_args
-      CallStackChecker.should be_called    
-    end
-    
-  end
-    
-  describe ".load_mole_configuration" do
-    before( :each ) do
-      ::Mole.reset_configuration!
-    end
-    
-    it "should load single file correctly" do
-      ::Mole.initialize( :moleable => true, :mole_config => File.join( File.dirname(__FILE__), %w[config mole_config.rb] ) )
-      ::Mole.load_mole_configuration
-      require( File.join( File.dirname(__FILE__), %w[config mole_config.rb] ) ).should == []
-    end
-    
-    it "should load config for directory correctly" do
-      ::Mole.initialize( :moleable => true, :mole_config => File.join( File.dirname(__FILE__), %w[config moles] ) )
-      ::Mole.load_mole_configuration
-      require( File.join( File.dirname(__FILE__), %w[config moles fred_config.rb] ) ).should == []      
-    end
-    
-    it "should raise an error if the configuration file does not exist" do
-      ::Mole.initialize( :moleable => true, :mole_config => File.join( File.dirname(__FILE__), %w[config fred_mole.rb] ) )
-      lambda{ ::Mole.load_mole_configuration }.should raise_error( "Unable to find the MOle configuration from `./spec/config/fred_mole.rb" )       
-    end
-    
-    it "should raise an error if the config directory does not exist" do
-      ::Mole.initialize( :moleable => true, :mole_config => File.join( File.dirname(__FILE__), %w[config freds] ) )
-      lambda{ ::Mole.load_mole_configuration }.should raise_error( "Unable to find the MOle configuration from `./spec/config/freds" )       
-    end
-  end
-  
-end