langrove 0.0.4.5 → 0.0.5.3

data/spec/langrove/plugin/assessor_spec.rb

@@ -0,0 +1,278 @@
+require 'spec_helper'
+
+ASSESSES = {}
+
+describe LanGrove::Plugin::Assessor do
+
+  before :each do
+
+    CONFIG.plugins[:previous_state] = {
+      :class => 'Persistor',
+      :key => {
+        :uniq => :uniq
+      }
+    }
+
+    CONFIG.plugins[:assessor_plugin] = {
+      :class => 'Assessor',
+      :plugin => :previous_state,
+      :assess =>  ASSESSES
+    }
+
+  end
+  
+  subject {
+    
+    LanGrove::Plugin::Assessor.new( ROOT, CONFIG.plugins[:assessor_plugin], nil )
+    
+  }
+  
+  it 'ensures a nested persistor in config' do
+    
+    expect {
+      
+      LanGrove::Plugin::Assessor.new( ROOT, {}, nil )
+      
+    }.to raise_error(
+    
+      LanGrove::DaemonConfigException,
+      
+      /requires a nested Persistor :plugin:/
+    
+    )
+    
+  end
+  
+  it 'ensures an :assess: subconfig' do
+    
+    CONFIG.plugins[:assessor_plugin].delete( :assess )
+    
+    expect {
+    
+      LanGrove::Plugin::Assessor.new( ROOT, CONFIG.plugins[:assessor_plugin], nil )
+      
+    }.to raise_error( 
+    
+      LanGrove::DaemonConfigException,
+      
+      /requires :assess: subconfig/
+    
+    )
+    
+  end
+  
+  it 'loads the nested persistor' do
+    
+    subject.persistor.should be_a( LanGrove::Plugin::Persistor )
+    
+  end
+  
+  context 'collects the previously collated capsule' do
+    
+    before :each do
+      
+      @handler = mock( 'handler' )
+      @key = { 'key' => { :uniq => 'value' } } 
+      
+      @handler.should_receive( 
+      
+        :key
+      
+      ).twice.and_return(
+      
+        @key
+      
+      )
+      
+      @handler.should_receive( 
+      
+        :capsule
+      
+      ).twice
+      
+    end
+    
+    it 'yields changes and then stores the new state' do
+      
+      subject.persistor.should_receive( 
+      
+        :fetch
+      
+      ).with(
+      
+        be_a( LanGrove::Plugin::Handler )
+      
+      ).and_return(
+      
+        true
+      
+      )
+      
+      subject.should_receive( 
+      
+        :each_change
+        
+      )
+      
+      subject.persistor.should_receive( 
+      
+        :store
+      
+      )
+      
+      subject.assess( @handler )
+      
+    end
+    
+  end
+  
+  context 'yields presence state changes' do
+    
+    before :each do
+      
+      ASSESSES['thing'] = :present
+      
+      @new = {}
+      @old = {}
+      
+    end
+    
+    it 'with :on' do
+      
+      @new['thing'] = 2
+      
+      key = nil
+      state = nil
+      value = nil
+      
+      subject.each_change( @old, @new ) do |k, s, v| 
+        
+        key, state, value = k, s, v
+        
+      end
+      
+      key.should == 'thing'
+      state.should == :on
+      value.should  == 2
+      
+    end
+    
+    it 'with :repeat' do
+      
+      @new['nested'] = { 'thing' => 3 }
+      @old['nested'] = { 'thing' => 1 }
+      
+      key = nil
+      state = nil
+      value = nil
+      delta = nil
+      
+      subject.each_change( @old, @new ) do |k, s, v, d| 
+        
+        key, state, value, delta = k, s, v, d
+        
+      end
+      
+      key.should == 'thing'
+      state.should == :repeat
+      value.should  == 3
+      delta.should == 2
+      
+    end
+    
+    it 'with :off' do
+      
+      @old['nested'] = { 'thing' => 3 }
+      
+      key = nil
+      state = nil
+      value = nil
+      
+      subject.each_change( @old, @new ) do |k, s, v|
+        
+        key, state, value = k, s, v
+        
+      end
+      
+      key.should == 'thing'
+      state.should == :off
+      value.should  == nil
+      
+    end
+    
+  end
+  
+  context 'yields all nested presence state changes from subkeys of a match' do
+    
+    before :each do
+      
+      ASSESSES['known_errors'] = :present
+      
+      @new = {}
+      @old = {}
+      
+    end
+  
+    it 'with one :on and one :repeat' do
+      
+      @new['known_errors'] = { 
+        
+        'error_new' => 1,
+        'error_repeated' => 41
+        
+      }
+      
+      @old['known_errors'] = { 
+
+        'error_repeated' => 39
+        
+      }
+      
+      
+      key = []
+      state = []
+      value = []
+      delta = []
+      
+      subject.each_change( @old, @new ) do |k, s, v, d|
+        
+        key   << k
+        state << s
+        value << v
+        delta << d
+        
+      end
+      
+      key.should == [ 'error_new', 'error_repeated' ]
+      state.should == [ :on, :repeat ]
+      value.should  == [ 1, 41 ]
+      delta.should == [ nil, 2 ]
+      
+    end
+  
+    it 'with one :off and one :on' do
+      
+      @new['known_errors'] = { 'error_two' => 3 }
+      @old['known_errors'] = { 'error_one' => 3 }
+      
+      key = []
+      state = []
+      value = []
+      
+      subject.each_change( @old, @new ) do |k, s, v|
+        
+        key   << k
+        state << s
+        value << v
+        
+      end
+      
+      key.should == [ 'error_two', 'error_one' ]
+      state.should == [ :on, :off ]
+      value.should  == [ 3, nil ]
+
+    end
+  
+  end
+  
+end

data/spec/langrove/plugin/buffered_persistor_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+require 'em-rspec'
+
+BUFFERED_PERSISTOR = {
+  :interval => 1,
+  :class => 'BufferedPersistor',
+  :table => 'tablename',
+  :key => {
+
+    :hostname => :hostname
+
+  }
+}
+
+describe LanGrove::Plugin::BufferedPersistor do
+  
+  subject {
+    
+    LanGrove::Plugin::BufferedPersistor.new( 
+    
+      ROOT, BUFFERED_PERSISTOR, nil
+      
+    )
+    
+  }
+
+  
+  it 'is a persistor' do
+
+    # LOG.on
+    
+    subject.provides.has_key?( 
+    
+      :persistor 
+      
+    ).should == true
+    
+  end
+
+  it 'requires eventmachine' do
+
+    EM.should_receive( :reactor_running? ).and_return( false )
+
+    expect {
+
+      subject
+
+    }.to raise_error(
+
+      LanGrove::PluginException,
+
+      /only runs inside EventMachine enabled daemons/
+
+    )
+
+  end
+
+  it 'pends persistance for interval' do
+
+    EM.should_receive(
+
+      :add_periodic_timer ).with( 1
+
+    )
+
+    subject
+
+  end
+
+  it 'pends persistance into @capsules Hash' do
+
+    @handler1 = LanGrove::Handler::Base.new
+    @handler1.capsule = {
+
+      :hostname => 'one.test.com',
+      :value => '1'
+
+    }
+    subject.store( @handler1 )
+    @handler2 = LanGrove::Handler::Base.new
+    @handler2.capsule = {
+
+      :hostname => 'two.test.com',
+      :value => '2'
+
+    }
+    subject.store( @handler2 )
+
+
+    subject.store_all
+
+  end
+
+end

data/spec/langrove/plugin/enqueuer_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+describe LanGrove::Plugin::Enqueuer do
+  
+  subject {
+    
+    LanGrove::Plugin::Enqueuer.new( 
+    
+      ROOT, ENQUEUER_CONFIG, nil
+      
+    )
+    
+  }
+  
+  before :each do
+    
+    @capsule = {
+      
+      'data' => 'DATA',
+      'persisted_seq' => 1
+      
+    }
+    
+  end
+  
+  it 'enqueues the handler persistance key into a work queue' do
+    
+    handler = mock( handler )
+    
+    handler.should_receive( 
+    
+      :key
+      
+    ).and_return(
+      
+      "the handler.key to collect a persisted capsule"
+    
+    )
+    
+    handler.should_receive( 
+    
+      :capsule
+      
+    ).and_return(
+      
+      @capsule
+    
+    )
+    
+    expect {
+  
+      subject.enqueue_key( handler )
+      
+    }.to raise_error(
+    
+      LanGrove::PluginException,
+      
+      /not implemented/
+    
+    )
+    
+  end
+  
+  it 'enqueues the handler capsule into a work queue' do
+    
+    handler = mock( handler )
+    
+    handler.should_receive( 
+    
+      :capsule
+      
+    ).twice.and_return(
+      
+      @capsule
+    
+    )
+    
+    expect {
+  
+      subject.enqueue_capsule( handler )
+      
+    }.to raise_error(
+    
+      LanGrove::PluginException,
+      
+      /not implemented/
+    
+    )
+    
+  end
+  
+  it 'assembles a queue header with the sequence number' do
+    
+    handler = mock( handler )
+    
+    handler.should_receive( 
+    
+      :capsule
+      
+    ).and_return(
+      
+      @capsule
+    
+    )
+    
+    header = subject.queue_header( 
+    
+      :get_capsule, handler 
+      
+    )
+    
+    header['action'].should == :get_capsule
+    header['sequence'].should == 1
+    header['created_at'].should be_a( Time )
+    
+  end
+  
+  it 'validates presence of :worker in config' do
+    
+    ENQUEUER_CONFIG.delete :job
+    
+    expect {
+    
+      subject.validate_config
+      
+    }.to raise_error(
+    
+      LanGrove::DaemonConfigException,
+      
+      /equires :job:/
+    
+    )
+    
+  end
+  
+end

data/spec/langrove/plugin/notifier_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe LanGrove::Plugin::Notifier do
+  
+  before :all do
+    
+    NOTIFIER_CONFIG = {
+      
+    }
+    
+    @capsule = {
+      
+      'system' => 'Red Bull',
+      'application' => 'Protocol Routing Challenge',
+      'source' => 'hop.checkpoint12.ip_routing_challenge.redbull.com',
+      'key' => 'ttl_zero',
+      'state' => 'on',
+      'value' => 'contestant404',
+      'delta' => nil
+      
+    }
+    
+  end
+  
+  subject {
+    
+    LanGrove::Plugin::Notifier.new( ROOT, NOTIFIER_CONFIG, nil )
+    
+  }
+  
+  it 'can transform the contents of the notification' do
+    
+    handler = mock( 'handler' )
+    
+    handler.should_receive(
+    
+      :transform
+      
+    ).with(
+    
+      :notifier, @capsule
+      
+    ).and_yield(
+    
+      @capsule
+    
+    )
+    
+    handler.should_receive( 
+      
+      :capsule
+    
+    ).twice.and_return(
+    
+      @capsule
+      
+    )
+    
+    expect {
+    
+      subject.notify_handler( handler ) 
+    
+    }.to raise_error( 
+      
+      LanGrove::PluginException,
+      
+      /.notify\(\) not implemented/
+    
+    )
+    
+  end
+  
+  it 'skips the notification if transform returns false' do
+  
+    handler = mock( 'handler' )
+    
+    handler.should_receive( 
+      
+      :capsule
+    
+    ).and_return(
+    
+      @capsule
+      
+    )
+    
+    subject.should_receive( 
+    
+      :transform
+      
+    ).and_return( 
+    
+      false
+      
+    )
+    
+    subject.should_not_receive( 
+    
+      :notify
+      
+    )
+    
+    subject.notify_handler( handler )
+    
+  end
+  
+end