em-langrove 0.0.4.5

data/spec/langrove/daemon_base_spec.rb

@@ -0,0 +1,154 @@
+require 'langrove'
+
+describe LanGrove::Daemon::Base do
+  
+  before :each do
+    
+    @logger = LanGrove::FakeLogger.new :silent
+    
+    @daemon_name = 'pretend_daemon'
+    
+    @adaptor_class = 'MyEventMachineServer'
+    @collection_class = 'Base'
+    @client_class = 'Base'
+    @protocol_class = 'Base'
+    
+    @config = {
+      
+      :daemons => {
+        
+        @daemon_name => {
+          
+          :server => false,
+          
+          :adaptor => {
+            
+            # Test default
+            
+          },
+          
+          :client => {
+            
+            :class => @client_class
+            
+          },
+          
+          :protocol => {
+            
+            :class => @protocol_class
+            
+          },
+          
+          :handler => {
+            
+            :collection => @collection_class
+            
+          }
+        }
+      }
+    }
+    
+  end
+  
+  subject do
+    
+    LanGrove::Daemon::Base.new( @config, @daemon_name, @logger )
+    
+  end
+  
+  it 'requires a logger' do
+    
+    expect {
+    
+      LanGrove::Daemon::Base.new( @config, @daemon_name, nil )
+    
+    }.to raise_error( LanGrove::DaemonConfigException, 
+    
+      /Requires a logger/ 
+      
+    )
+    
+  end
+  
+  it 'requires a configuration' do
+    
+    expect {
+      
+      LanGrove::Daemon::Base.new( {}, @daemon_name, @logger )
+      
+    }.to raise_error( LanGrove::DaemonConfigException, 
+    
+      /Missing config item/ 
+      
+    )
+    
+  end
+  
+  it 'attempts to latebind an adaptor by config' do
+    
+    @config[ :daemons ][ @daemon_name ][ :adaptor ][ :class ] = @adaptor_class
+    
+    expect {
+     
+      LanGrove::Daemon::Base.new( @config, @daemon_name, @logger )
+      
+    }.to raise_error( LanGrove::ClassLoaderException, 
+    
+    
+      "no such file to load -- adaptor/my_event_machine_server.rb"
+    
+    )
+    
+  end
+  
+  it 'defaults to Adaptor::Base' do
+    
+    
+    adaptor = subject.instance_variable_get( :@adaptor )
+    adaptor.should be_a( LanGrove::Adaptor::Base )
+    
+  end
+  
+  it 'latebinds a handler by config' do
+    
+    handler = subject.instance_variable_get( :@handler )
+    
+    handler.should be_a( LanGrove::Handler.const_get( @collection_class ) )
+    
+  end
+  
+  it 'loads the client defininition by config' do
+    
+    client = subject.instance_variable_get( :@client )
+    
+    client.should == LanGrove::Client::Base
+    
+  end
+  
+  it 'does not instanciate the client' do
+    
+    client = subject.instance_variable_get( :@client )
+    
+    client.should_not be_a(LanGrove::Client::Base)
+    
+  end
+  
+  it 'loads the protocol defininition by config' do
+    
+    protocol = subject.instance_variable_get( :@protocol )
+    
+    protocol.should == LanGrove::Protocol::Base
+    
+  end
+  
+  it 'does not instanciate the protocol' do
+    
+    protocol = subject.instance_variable_get( :@protocol )
+    
+    protocol.should_not be_a(LanGrove::Protocol::Base)
+    
+  end
+  
+  it 'it schedules periodics' 
+
+end

data/spec/langrove/ext/class_loader_spec.rb

@@ -0,0 +1,83 @@
+require 'langrove/ext/class_loader'
+require 'langrove/ext/fake_logger'
+
+describe LanGrove::ClassLoader do
+  
+  before :all do
+    
+    @logger = LanGrove::FakeLogger.new :silent
+    
+  end
+  
+  it 'raises on missing class definition file' do
+    
+    expect {
+    
+      LanGrove::ClassLoader.create( {
+     
+        :module => 'Protocol',
+        :class => 'MedievalLanternMorse' 
+      
+        }, @logger )
+    
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, 
+      
+      "no such file to load -- protocol/medieval_lantern_morse.rb"
+    
+    )
+  end
+  
+  it 'raises on missing ModuleName' do
+    
+    expect {
+      
+      LanGrove::ClassLoader.create( {
+
+       :class => 'MedievalLanternMorse' 
+
+      }, @logger )
+      
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, /:module/ 
+      
+    )
+    
+  end
+  
+  it 'raises on missing ClassName' do
+    
+    expect {
+      
+      LanGrove::ClassLoader.create( {
+
+       :module => 'Protocol'
+
+      }, @logger )
+      
+    }.to raise_error( 
+    
+      LanGrove::ClassLoaderException, /:class/ 
+      
+    )
+    
+  end
+  
+  it 'returns a constantized class definition' do
+    
+    test = LanGrove::ClassLoader.create( {
+   
+      :module => 'Protocol',
+      :class => 'Base' 
+    
+    }, @logger ).new( nil, @logger )
+    
+    test.should be_a( LanGrove::Protocol::Base )
+    
+  end
+  
+  it 'also works on local implementation'
+  
+end

data/spec/langrove/ext/config_item_spec.rb

@@ -0,0 +1,81 @@
+require 'langrove/ext'
+
+describe LanGrove::ConfigItem do
+  
+  before :each do
+    @config_hash = {
+      'root' => "3",  
+      'BLANK' => "",
+      :daemons => {
+        'puppet_log' => {
+          :handler => {
+            :collection   => 'SyslogStateMachines'            
+          }
+        }
+      }
+    }
+  end
+  
+  it 'accesses config items' do
+    LanGrove::ConfigItem.get(@config_hash, ['root']).should == '3'
+  end
+  
+  it 'accesses nested config items' do
+    LanGrove::ConfigItem.get(@config_hash, 
+    
+      [:daemons , 'puppet_log', :handler, :collection]
+    
+    ).should == 'SyslogStateMachines'
+  end
+  
+  it 'raises a config exception if the key isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['NOT'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'NOT'/ )
+    
+  end
+  
+  it 'raises a config exception if the key isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['BLANK'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'BLANK'/ )
+    
+  end
+  
+  it 'raises a config exception if the value isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, ['BLANK'], false)
+      
+    }.to_not raise_error( LanGrove::ConfigException, /Missing config item 'BLANK'/ )
+    
+  end
+  
+  it 'raises a config exception if the nested item isnt present' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, [ :daemons, 'NEITHER', 'this'])
+      
+    }.to raise_error( LanGrove::ConfigException, /Missing config item 'NEITHER'/ )
+    
+  end
+  
+  it 'does not raise on not mandatory fields' do
+    
+    expect {
+      
+      LanGrove::ConfigItem.get(@config_hash, [ :daemons, 'NEITHER' ], false)
+      
+    }.to_not raise_error( LanGrove::ConfigException )
+    
+  end
+  
+end

data/spec/langrove/ext/config_loader_spec.rb

@@ -0,0 +1,5 @@
+require 'langrove/ext'
+
+describe LanGrove::ConfigLoader do
+    
+end

data/spec/langrove/ext/find_spec.rb

@@ -0,0 +1,53 @@
+require 'langrove/ext/find'
+
+describe LanGrove::Find do
+  
+  before :each do
+    
+    
+    @path = File.expand_path('../../../../bin', __FILE__ )
+    
+  end
+  
+  it 'searches finds' do
+    
+    test = []
+    
+    LanGrove::Find.with(
+    
+      :type => :file,
+      :path => @path,
+      :relative => true
+      
+    ) do |found|
+      
+      test << found
+      
+    end
+    
+    test.length.should == 1
+    test[0].should == 'langrove'
+     
+  end
+  
+  it 'searches filters' do
+    
+    test = []
+    
+    LanGrove::Find.with(
+    
+      :type => :file,
+      :path => @path,
+      :include => 'scotch mist'
+      
+    ) do |found|
+      
+      test << found
+      
+    end
+    
+    test.length.should == 0
+    
+  end
+  
+end

data/spec/langrove/ext/persistable_spec.rb

@@ -0,0 +1,117 @@
+require 'langrove/ext'
+
+#
+# This will likely change.
+#
+
+describe LanGrove::Persistable do
+  
+  before :each do
+    
+    class TestSerialization
+      attr_accessor :data
+    end
+    
+    @class_instance = TestSerialization.new
+    @class_instance.data = 'VALUE'
+    
+    @now = Time.now
+    @state_file = File.dirname( __FILE__ ) + "/../../../tmp/persistable.yml"
+    
+    #
+    # delete the file
+    #
+    File.delete( @state_file ) if File.file?( @state_file )
+    
+    @hash = {
+      'tree' => {
+        'type' => {
+          :thing1 => 1
+        }
+      },
+      :now => @now,
+      :class_instance => @class_instance
+    }
+    
+  end
+  
+  subject do
+    
+    test = LanGrove::Persistable.new
+    test.instance_variable_set :@logger, (LanGrove::FakeLogger.new :silent)
+    test
+    
+  end
+  
+  it 'can serialize a hash to file' do
+    
+    #
+    # install the hash to be 'stored'
+    # 
+    subject.instance_variable_set( :@hash, @hash )
+    subject.store_hash( '@hash', @state_file )
+    
+    #
+    # is the file there?
+    # 
+    File.file?( @state_file ).should == true
+    
+  end
+  
+  context 'can de-serialize a hash' do
+    
+    before :each do
+      
+      #
+      # set up the file to read
+      #
+      subject.instance_variable_set( :@hash, @hash )
+      subject.store_hash( '@hash', @state_file )
+      
+      #
+      # replace the hash with another containg other things
+      #
+      subject.instance_variable_set( :@hash, { 'thing2' => 2 } )
+      
+    end
+    
+    it 'from file' do
+      
+      subject.load_hash( '@hash', @state_file )
+      
+      hash = subject.instance_variable_get( :@hash )
+      hash['tree']['type'][:thing1].should == 1
+        
+    end
+    
+    it 'from file and re-instanciate as correct native ruby classes' do
+    
+      subject.load_hash( '@hash', @state_file )
+      hash = subject.instance_variable_get( :@hash )
+      
+      hash[:now].should be_a( Time )
+      hash[:now].should == @now
+    
+    end
+    
+    it 'from file and re-instanciate as correct userland ruby classes' do
+      
+      subject.load_hash( '@hash', @state_file )
+      hash = subject.instance_variable_get( :@hash )
+      
+      hash[:class_instance].should be_a( TestSerialization )
+      hash[:class_instance].data.should == 'VALUE'
+      
+    end
+    
+    it 'from file and not overrwrite other variables in the hash' do
+      
+      subject.load_hash( '@hash', @state_file )
+      hash = subject.instance_variable_get( :@hash )
+      
+      hash['tree']['type'][:thing1].should == 1
+      hash['thing2'].should == 2
+      
+    end
+  end
+end

data/spec/langrove/ext/string_spec.rb

@@ -0,0 +1,16 @@
+require 'langrove/ext'
+describe String do
+  
+  it 'has been extended to camelize' do
+    
+    "this_is_a_class_file_name".camelize.should == "ThisIsAClassFileName"
+    
+  end
+  
+  it 'has been extended to underscore' do
+    
+    "ThisIsAClassName".underscore.should == "this_is_a_class_name"
+    
+  end
+  
+end

data/spec/langrove/handler_base_spec.rb

@@ -0,0 +1,103 @@
+require 'langrove'
+
+describe LanGrove::Handler::Base do
+  
+  before :each do
+    
+    @logger      = LanGrove::FakeLogger.new :silent
+    
+    @daemon_name = 'test_daemon'
+    
+    @config = {
+      
+      :daemons => {
+        
+        @daemon_name => {
+          
+          :handler => {
+            
+            :collection => 'Base'
+          }
+        }
+      }
+    }
+    
+  end
+  
+  subject do
+    
+    LanGrove::Handler::Base.new( @config, @daemon_name, @logger )
+    
+  end
+  
+  context 'maintains a connected client collection with' do
+    
+    it 'in a hash' do
+      
+      clients = subject.instance_variable_get( :@clients )
+      
+      clients.should be_a( Hash )
+      
+    end
+    
+    context 'connect()' do
+      
+      it 'using a key defined by the client' do
+        
+        client = double( 'Client' )
+        client.should_receive( :respond_to? ).with( :unique_key ).and_return( true )
+        client.should_receive( :unique_key ).and_return('KEY1')
+        
+        subject.connect( client )
+        
+        clients = subject.instance_variable_get( :@clients )
+        
+        clients['KEY1'].should == client
+        
+      end
+      
+      it 'using the client itself as the key if unique is not defined' do
+        
+        client = double( 'Client' )
+        client.should_receive( :respond_to? ).with( :unique_key ).and_return( false )
+        
+        subject.connect( client )
+        
+        clients = subject.instance_variable_get( :@clients )
+        
+        clients[ client ].should == 1
+        
+      end
+      
+    end
+    
+    context 'disconnect()' do
+      
+      it 'to remove the client from the collection'
+      
+    end
+    
+    it 'call the periodic ticker to all attached clients' do
+      
+      client1 = Object.const_set( 'Client', Class.new() do
+        
+        self.class_eval { attr_accessor :unique }
+        
+      end).new
+      client1.unique = 'kEy'
+      
+      client2 = Object.new
+      
+      client1.should_receive( :periodic )
+      client2.should_receive( :periodic )
+      
+      subject.connect( client1 )
+      subject.connect( client2 )
+      
+      subject.periodic
+      
+    end
+    
+  end
+  
+end

data/spec/langrove/job_base_spec.rb

@@ -0,0 +1,28 @@
+require 'langrove'
+
+describe LanGrove::Job::Base do
+  
+  before :each do
+    
+    @logger = LanGrove::FakeLogger.new
+    
+    @queue_name = :snooker_queue
+    
+    @config = {}
+    
+  end
+  
+  it 'initializes' do
+    
+    test = LanGrove::Job::Base.new( @config, @queue_name, @logger )
+    test.should be_a( LanGrove::Job::Base )
+    
+  end 
+  
+  it 'has methods' do
+    
+    LanGrove::Job::Base.new( @config, @queue_name, @logger ).undefined_method( "TEST" )
+    
+  end
+
+end

data/spec/langrove/protocol/syslog_spec.rb

@@ -0,0 +1,45 @@
+require 'langrove/protocol/syslog'
+require 'date'
+
+describe LanGrove::Protocol::Syslog.new do
+  
+  before :each do
+    
+    @message1 = "<00>Apr  4 11:00:06 host program[321]: Message with: 1"
+    @message2 = "<00>Jun 25 16:15:15 host.name.co.za tag[3241]: Message with: 2"
+    
+  end
+  
+  pending 'it decodes the loglevel'
+  
+  pending 'it supports tagless and pidless'
+  
+  it 'decodes a timestamp' do
+    
+    subject.decode( @message1 )[:timestamp].should == DateTime.parse( 'Apr 4 11:00:06' )
+    subject.decode( @message2 )[:timestamp].should == DateTime.parse( 'Jun 25 16:15:15' )
+    
+  end
+  
+  it 'decodes a hostname corrected for prepended vlanN' do
+    
+    subject.decode( @message1 )[:hostname].should == 'host'
+    subject.decode( @message2 )[:hostname].should == 'host.name.co.za'
+    
+  end
+  
+  it 'decodes the log tag' do
+    
+    subject.decode( @message1 )[:tag].should == 'program[321]'
+    subject.decode( @message2 )[:tag].should == 'tag[3241]'
+    
+  end
+  
+  it 'decodes the log event' do
+    
+    subject.decode( @message1 )[:event].should == 'Message with: 1'
+    subject.decode( @message2 )[:event].should == 'Message with: 2'
+    
+  end
+  
+end

data/spec/langrove/protocol_base_spec.rb

@@ -0,0 +1,6 @@
+require 'langrove'
+
+describe LanGrove::Protocol::Base do
+  
+  
+end

data/spec/todo_spec.rb

@@ -0,0 +1,12 @@
+describe 'Outstanding:' do
+
+  pending 'Symbolize the config keys'
+  pending 'make a langrove --create for developers to recursively copy ./functional from the gem install dir as a base for getting the framework up and running'
+  pending 'cut and publish'
+  
+  
+  
+  
+  pending 'rdoc'
+  
+end

data/tmp/README

@@ -0,0 +1,2 @@
+Certain test write files into here
+