flapjack 0.5.5 → 0.6.23

data/spec/lib/flapjack/data/entity_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'flapjack/data/entity'
+
+describe Flapjack::Data::Entity, :redis => true do
+
+  let(:name)  { 'abc-123' }
+  let(:check) { 'ping' }
+
+  it "adds an entity, including contacts"
+
+  it "finds an entity by name"
+
+  it "creates an entity if allowed when it can't find it" do
+    entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis, :create => true)
+
+    entity.should_not be_nil
+    entity.name.should == name
+    @redis.get("entity_id:#{name}").should == ''
+  end
+
+  it "finds an entity by id"
+
+  it "returns a list of all entities" do
+    Flapjack::Data::Entity.add({'id'       => '5000',
+                                'name'     => name},
+                                :redis => @redis)
+    Flapjack::Data::Entity.add({'id'       => '5001',
+                                'name'     => "z_" + name},
+                                :redis => @redis)
+
+    entities = Flapjack::Data::Entity.all(:redis => @redis)
+    entities.should_not be_nil
+    entities.should be_an(Array)
+    entities.should have(2).entities
+    entities[0].id.should == 5000
+    entities[1].id.should == 5001
+  end
+
+  it "returns a list of checks for an entity" do
+    Flapjack::Data::Entity.add({'id'       => '5000',
+                                'name'     => name},
+                                :redis => @redis)
+
+    @redis.hset("check:#{name}:ping", 'state', 'OK')
+    @redis.hset("check:#{name}:ssh",  'state', 'OK')
+
+    entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
+    check_list = entity.check_list
+    check_list.should_not be_nil
+    check_list.should have(2).checks
+    sorted_list = check_list.sort
+    sorted_list[0].should == 'ping'
+    sorted_list[1].should == 'ssh'
+  end
+
+  it "returns a count of checks for an entity" do
+    Flapjack::Data::Entity.add({'id'       => '5000',
+                                'name'     => name,
+                                'contacts' => []},
+                               :redis => @redis)
+
+    @redis.hset("check:#{name}:ping", 'state', 'OK')
+    @redis.hset("check:#{name}:ssh",  'state', 'OK')
+
+    entity = Flapjack::Data::Entity.find_by_id(5000, :redis => @redis)
+    check_count = entity.check_count
+    check_count.should_not be_nil
+    check_count.should == 2
+  end
+
+end

data/spec/lib/flapjack/data/event_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/data/event'
+
+describe Flapjack::Data::Event, :redis => true do
+
+end

data/spec/lib/flapjack/executive_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'flapjack/executive'
+
+describe Flapjack::Executive, :redis => true do
+
+  # NB: this is only testing the public API of the Executive class, which is pretty limited.
+  # (initialize, main, stop). Most test coverage for this class comes from the cucumber features.
+
+  it "prompts the blocking redis connection to quit" do
+    redis = mock('redis')
+    redis.should_receive(:rpush).with('events', %q{{"type":"shutdown","host":"","service":"","state":""}})
+
+    executive = Flapjack::Executive.new
+    executive.bootstrap(:redis => @redis)
+    executive.add_shutdown_event(:redis => redis)
+  end
+
+  # TODO split out the setup stuff to a separate test
+  it "shuts down when provided with a shutdown event" do
+    t = Time.now.to_i
+
+    Flapjack::Filters::Ok.should_receive(:new)
+    Flapjack::Filters::ScheduledMaintenance.should_receive(:new)
+    Flapjack::Filters::UnscheduledMaintenance.should_receive(:new)
+    Flapjack::Filters::DetectMassClientFailures.should_receive(:new)
+    Flapjack::Filters::Delays.should_receive(:new)
+    Flapjack::Filters::Acknowledgement.should_receive(:new)
+
+    shutdown_evt = mock(Flapjack::Data::Event)
+    shutdown_evt.should_receive(:id).and_return('-:-')
+    shutdown_evt.should_receive(:type).exactly(3).times.and_return('shutdown')
+    shutdown_evt.should_receive(:state).and_return(nil)
+    shutdown_evt.should_receive(:summary).and_return(nil)
+    shutdown_evt.should_receive(:time).and_return(Time.now)
+    Flapjack::Data::Event.should_receive(:next).and_return(shutdown_evt)
+
+    EventMachine::Synchrony::ConnectionPool.should_receive(:new).and_return(@redis)
+
+    executive = Flapjack::Executive.new
+    executive.bootstrap(:config => {})
+
+    # hacky, but the behaviour it's mimicking (shutdown from another thread) isn't
+    # conducive to nice tests
+    executive.stub(:should_quit?).and_return(false, true)
+    executive.main
+
+    # TODO these will need to be made relative to the running instance,
+    # and a list of the running instances maintained somewhere
+    boot_time = @redis.get('boot_time')
+    boot_time.should_not be_nil
+    boot_time.to_i.should >= t
+
+    @redis.hget('event_counters', 'all').should == 1.to_s
+    @redis.hget('event_counters', 'ok').should == 0.to_s
+    @redis.hget('event_counters', 'failure').should == 0.to_s
+    @redis.hget('event_counters', 'action').should == 0.to_s
+  end
+
+end

data/spec/lib/flapjack/filters/acknowledgement_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/acknowledgement'
+
+describe Flapjack::Filters::Acknowledgement do
+
+end

data/spec/lib/flapjack/filters/delays_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/delays'
+
+describe Flapjack::Filters::Delays do
+
+end

data/spec/lib/flapjack/filters/detect_mass_client_failures_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/detect_mass_client_failures'
+
+describe Flapjack::Filters::DetectMassClientFailures do
+
+end

data/spec/lib/flapjack/filters/ok_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/ok'
+
+describe Flapjack::Filters::Ok do
+
+end

data/spec/lib/flapjack/filters/scheduled_maintenance_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/scheduled_maintenance'
+
+describe Flapjack::Filters::ScheduledMaintenance do
+
+end

data/spec/lib/flapjack/filters/unscheduled_maintenance_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/filters/unscheduled_maintenance'
+
+describe Flapjack::Filters::UnscheduledMaintenance do
+
+end

data/spec/lib/flapjack/jabber_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+require 'flapjack/jabber'
+
+describe Flapjack::Jabber do
+
+  let(:config) { {'queue'    => 'jabber_notifications',
+                  'server'   => 'example.com',
+                  'port'     => '5222',
+                  'jabberid' => 'flapjack@example.com',
+                  'password' => 'password',
+                  'alias'    => 'flapjack',
+                  'rooms'    => ['flapjacktest@conference.example.com']
+                 }
+  }
+
+  let(:stanza) { mock('stanza') }
+
+  it "is initialized" do
+    fj = Flapjack::Jabber.new
+    fj.should_not be_nil
+  end
+
+  it "hooks up event handlers to the appropriate methods" do
+    Socket.should_receive(:gethostname).and_return('thismachine')
+
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    EM.should_receive(:next_tick).exactly(4).times.and_yield
+    EM.should_receive(:synchrony).exactly(4).times.and_yield
+
+    fj.should_receive(:register_handler).with(:ready).and_yield(stanza)
+    fj.should_receive(:on_ready).with(stanza)
+
+    fj.should_receive(:register_handler).with(:message, :groupchat?, :body => /^flapjack:\s+/).and_yield(stanza)
+    fj.should_receive(:on_groupchat).with(stanza)
+
+    fj.should_receive(:register_handler).with(:message, :chat?).and_yield(stanza)
+    fj.should_receive(:on_chat).with(stanza)
+
+    fj.should_receive(:register_handler).with(:disconnected).and_yield(stanza)
+    fj.should_receive(:on_disconnect).with(stanza).and_return(true)
+
+    fj.setup
+  end
+
+  it "joins a chat room after connecting" do
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Presence))
+    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+
+    fj.on_ready(stanza)
+  end
+
+  it "receives an acknowledgement message" do
+    stanza.should_receive(:body).and_return('flapjack: ACKID 876 fixing now duration: 90m')
+    from = mock('from')
+    from.should_receive(:stripped).and_return('sender')
+    stanza.should_receive(:from).and_return(from)
+
+    redis = mock('redis')
+    redis.should_receive(:hget).with('unacknowledged_failures', '876').
+      and_return('main-example.com:ping')
+
+    entity_check = mock(Flapjack::Data::EntityCheck)
+    entity_check.should_receive(:create_acknowledgement).
+      with('summary' => 'fixing now', 'acknowledgement_id' => '876', 'duration' => (90 * 60))
+    entity_check.should_receive(:entity_name).and_return('main-example.com')
+    entity_check.should_receive(:check).and_return('ping')
+
+    Flapjack::Data::EntityCheck.should_receive(:for_event_id).
+      with('main-example.com:ping', :redis => redis).
+      and_return(entity_check)
+
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+    fj.instance_variable_set('@redis_handler', redis)
+
+    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+
+    fj.on_groupchat(stanza)
+  end
+
+  it "receives a message it doesn't understand" do
+    stanza.should_receive(:body).once.and_return('flapjack: hello!')
+    from = mock('from')
+    from.should_receive(:stripped).and_return('sender')
+    stanza.should_receive(:from).and_return(from)
+
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+
+    fj.on_groupchat(stanza)
+  end
+
+  it "reconnects when disconnected (if not quitting)" do
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    EventMachine::Timer.should_receive(:new).with(1).and_yield
+    fj.should_receive(:connect)
+
+    ret = fj.on_disconnect(stanza)
+    ret.should be_true
+  end
+
+  it "prompts the blocking redis connection to quit" do
+    redis = mock('redis')
+    redis.should_receive(:rpush).with('jabber_notifications', %q{{"notification_type":"shutdown"}})
+
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    fj.add_shutdown_event(:redis => redis)
+  end
+
+  it "runs a blocking loop listening for notifications" do
+    timer_1 = mock('timer_1')
+    timer_2 = mock('timer_2')
+    timer_1.should_receive(:cancel)
+    timer_2.should_receive(:cancel)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(30).and_return(timer_1)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer_2)
+
+    redis = mock('redis')
+    EventMachine::Synchrony::ConnectionPool.should_receive(:new).and_return(redis)
+
+    fj = Flapjack::Jabber.new
+    fj.bootstrap(:config => config)
+
+    fj.should_receive(:connect)
+    fj.should_receive(:connected?).twice.and_return(true)
+    fj.should_receive(:should_quit?).exactly(3).times.and_return(false, false, true)
+    redis.should_receive(:blpop).twice.and_return(
+      ["jabber_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}],
+      ["jabber_notifications", %q{{"notification_type":"shutdown"}}]
+    )
+
+    EM.should_receive(:next_tick).twice.and_yield
+    fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+    fj.should_receive(:close)
+
+    fj.main
+  end
+
+end

data/spec/lib/flapjack/notification/email_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/notification/email'
+
+describe Flapjack::Notification::Email do
+
+end

data/spec/lib/flapjack/notification/sms_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+require 'flapjack/notification/sms'
+
+describe Flapjack::Notification::Sms do
+
+end

data/spec/lib/flapjack/pikelet_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'flapjack/pikelet'
+
+describe Flapjack::Pikelet do
+
+  let(:stdout) { mock('StdoutOutputter') }
+  let(:syslogout) { mock('SyslogOutputter') }
+  let(:logger) { mock('Logger') }
+
+  class Breakfast
+    include Flapjack::Pikelet
+  end
+
+  it "should bootstrap an including class" do
+    Log4r::StdoutOutputter.should_receive(:new).and_return(stdout)
+    Log4r::SyslogOutputter.should_receive(:new).and_return(syslogout)
+    logger.should_receive(:add).with(stdout)
+    logger.should_receive(:add).with(syslogout)
+    Log4r::Logger.should_receive(:new).and_return(logger)
+
+    b = Breakfast.new
+    b.bootstrap
+
+    b.should respond_to(:logger)
+    b.logger.should equal(logger)
+  end
+
+end

data/spec/lib/flapjack/web_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+require 'flapjack/web'
+
+# TODO move the rest of the redis operations down to data models, then this
+# test won't need read/write redis data
+
+describe Flapjack::Web, :sinatra => true, :redis => true do
+
+  def app
+    Flapjack::Web
+  end
+
+  let(:entity_name)     { 'example.com'}
+  let(:entity_name_esc) { URI.escape(entity_name) }
+  let(:check)           { 'ping' }
+
+  let(:entity)          { mock(Flapjack::Data::Entity) }
+  let(:entity_check)    { mock(Flapjack::Data::EntityCheck) }
+
+  before(:each) do
+    Flapjack::Web.class_variable_set('@@redis', @redis)
+  end
+
+  def expect_stats
+    @redis.should_receive(:keys).with('*').and_return([])
+    @redis.should_receive(:zcard).with('failed_checks')
+    @redis.should_receive(:keys).with('check:*:*').and_return([])
+    @redis.should_receive(:hget).with('event_counters', 'all')
+    @redis.should_receive(:hget).with('event_counters', 'ok')
+    @redis.should_receive(:hget).with('event_counters', 'failure')
+    @redis.should_receive(:hget).with('event_counters', 'action')
+    @redis.should_receive(:get).with('boot_time').and_return(0)
+    @redis.should_receive(:llen).with('events')
+  end
+
+  def expect_entity_check_status(ec)
+    time = Time.now.to_i
+
+    ec.should_receive(:state).and_return('ok')
+    ec.should_receive(:last_update).and_return(time - (3 * 60 * 60))
+    ec.should_receive(:last_change).and_return(time - (3 * 60 * 60))
+    ec.should_receive(:last_problem_notification).and_return(time - ((3 * 60 * 60) + (5 * 60)))
+    ec.should_receive(:last_recovery_notification).and_return(time - (3 * 60 * 60))
+    ec.should_receive(:last_acknowledgement_notification).and_return(nil)
+    ec.should_receive(:in_scheduled_maintenance?).and_return(false)
+    ec.should_receive(:in_unscheduled_maintenance?).and_return(false)
+  end
+
+  # TODO add data, test that pages contain representations of it
+  # (for the methods that access redis directly)
+
+  it "shows a page listing all checks" do
+    @redis.should_receive(:keys).with('*:*:states').and_return(["#{entity_name}:#{check}:states"])
+
+    expect_stats
+
+    expect_entity_check_status(entity_check)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+
+    get '/'
+    last_response.should be_ok
+  end
+
+  it "shows a page listing failing checks" do
+    @redis.should_receive(:zrange).with('failed_checks', 0, -1).and_return(["#{entity_name}:#{check}:states"])
+
+    expect_stats
+
+    expect_entity_check_status(entity_check)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+    get '/failing'
+    last_response.should be_ok
+  end
+
+  it "shows a page listing flapjack statistics" do
+    expect_stats
+
+    get '/self_stats'
+    last_response.should be_ok
+  end
+
+  it "shows the state of a check for an entity" do
+    time = Time.now.to_i
+
+    entity_check.should_receive(:state).and_return('ok')
+    entity_check.should_receive(:last_update).and_return(time - (3 * 60 * 60))
+    entity_check.should_receive(:last_change).and_return(time - (3 * 60 * 60))
+    entity_check.should_receive(:summary).and_return('all good')
+    entity_check.should_receive(:last_problem_notification).and_return(time - ((3 * 60 * 60) + (5 * 60)))
+    entity_check.should_receive(:last_recovery_notification).and_return(time - (3 * 60 * 60))
+    entity_check.should_receive(:last_acknowledgement_notification).and_return(nil)
+    entity_check.should_receive(:in_scheduled_maintenance?).and_return(false)
+    entity_check.should_receive(:in_unscheduled_maintenance?).and_return(false)
+    entity_check.should_receive(:maintenances).with(nil, nil, :scheduled => true).and_return([])
+    entity_check.should_receive(:failed?).and_return(false)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+
+    get "/check?entity=#{entity_name_esc}&check=ping"
+    last_response.should be_ok
+    # TODO test instance variables set to appropriate values
+  end
+
+  it "returns 404 if an unknown entity is requested" do
+    get "/check?entity=#{entity_name_esc}&check=ping"
+    last_response.should be_not_found
+  end
+
+  # TODO shouldn't create actual entity record
+  it "returns 404 if no entity check is passed" do
+    Flapjack::Data::Entity.add({'id'   => '5000',
+                                'name' => entity_name},
+                               :redis => @redis)
+    get "/check?entity=#{entity_name_esc}"
+    last_response.should be_not_found
+  end
+
+  it "creates an acknowledgement for an entity check" do
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+
+    entity_check.should_receive(:create_acknowledgement).
+      with(an_instance_of(Hash))
+
+    post "/acknowledgements/#{entity_name_esc}/ping"
+    last_response.status.should == 201
+  end
+
+  it "creates a scheduled maintenance period for an entity check" do
+    t = Time.now.to_i
+
+    start_time = Time.at(t - (24 * 60 * 60))
+    duration = 30 * 60
+    summary = 'wow'
+
+    Chronic.should_receive(:parse).with('1 day ago').and_return(start_time)
+    ChronicDuration.should_receive(:parse).with('30 minutes').and_return(duration)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+
+    entity_check.should_receive(:create_scheduled_maintenance).
+      with(:start_time => start_time.to_i, :duration => duration, :summary => summary)
+
+    post "/scheduled_maintenances/#{entity_name_esc}/ping?"+
+      "start_time=1+day+ago&duration=30+minutes&summary=wow"
+    last_response.status.should == 302
+  end
+
+  it "deletes a scheduled maintenance period for an entity check" do
+    t = Time.now.to_i
+
+    start_time = t - (24 * 60 * 60)
+
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => @redis).and_return(entity)
+
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', :redis => @redis).and_return(entity_check)
+
+    entity_check.should_receive(:delete_scheduled_maintenance).
+      with(:start_time => start_time)
+
+    delete "/scheduled_maintenances/#{entity_name_esc}/ping?start_time=#{start_time}"
+    last_response.status.should == 302
+  end
+
+end