flapjack 0.6.38 → 0.6.39

data/spec/lib/flapjack/data/contact_spec.rb

@@ -4,12 +4,44 @@ require 'flapjack/data/contact'
 
 describe Flapjack::Data::Contact, :redis => true do
 
+  it "returns a list of all contacts" do
+    Flapjack::Data::Contact.add({'id'         => '362',
+                                 'first_name' => 'John',
+                                 'last_name'  => 'Johnson',
+                                 'email'      => 'johnj@example.com' },
+                                 :redis       => @redis)
+    Flapjack::Data::Contact.add({'id'         => '363',
+                                 'first_name' => 'Jane',
+                                 'last_name'  => 'Janeley',
+                                 'email'      => 'janej@example.com'},
+                                 :redis       => @redis)
+
+    contacts = Flapjack::Data::Contact.all(:redis => @redis)
+    contacts.should_not be_nil
+    contacts.should be_an(Array)
+    contacts.should have(2).contacts
+    contacts[0].id.should == '362'
+    contacts[1].id.should == '363'
+  end
+
+  it "finds a contact by id" do
+    Flapjack::Data::Contact.add({'id'         => '362',
+                                 'first_name' => 'John',
+                                 'last_name'  => 'Johnson',
+                                 'email'      => 'johnj@example.com' },
+                                 :redis       => @redis)
+
+    contact = Flapjack::Data::Contact.find_by_id('362', :redis => @redis)
+    contact.should_not be_nil
+    contact.name.should == "John Johnson"
+  end
+
   it "finds all contacts for a check on an entity"
 
   it "deletes all contacts"
 
-  it "adds a contact"
-
   it "returns pagerduty credentials for a contact"
 
+  it "returns a list of entities for a contact"
+
 end

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

@@ -6,10 +6,6 @@ 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)
 
@@ -18,22 +14,40 @@ describe Flapjack::Data::Entity, :redis => true do
     @redis.get("entity_id:#{name}").should == ''
   end
 
-  it "finds an entity by id"
+  it "finds an entity by id" do
+    Flapjack::Data::Entity.add({'id'   => '5000',
+                                'name' => name},
+                                :redis => @redis)
+
+    entity = Flapjack::Data::Entity.find_by_id('5000', :redis => @redis)
+    entity.should_not be_nil
+    entity.name.should == name
+  end
+
+  it "finds an entity by name" do
+    Flapjack::Data::Entity.add({'id'   => '5000',
+                                'name' => name},
+                                :redis => @redis)
+
+    entity = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
+    entity.should_not be_nil
+    entity.id.should == '5000'
+  end
 
   it "returns a list of all entities" do
-    Flapjack::Data::Entity.add({'id'       => '5000',
-                                'name'     => name},
+    Flapjack::Data::Entity.add({'id'   => '5000',
+                                'name' => name},
                                 :redis => @redis)
-    Flapjack::Data::Entity.add({'id'       => '5001',
-                                'name'     => "z_" + name},
+    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
+    entities[0].id.should == '5000'
+    entities[1].id.should == '5001'
   end
 
   it "returns a list of checks for an entity" do

data/spec/lib/flapjack/jabber_spec.rb

@@ -27,8 +27,7 @@ describe Flapjack::Jabber do
     fj.bootstrap(:config => config)
     fj.should_receive(:build_redis_connection_pool)
 
-    EM.should_receive(:next_tick).exactly(4).times.and_yield
-    EM.should_receive(:synchrony).exactly(4).times.and_yield
+    EventMachine::Synchrony.should_receive(:next_tick).exactly(4).times.and_yield
 
     fj.should_receive(:register_handler).with(:ready).and_yield(stanza)
     fj.should_receive(:on_ready).with(stanza)
@@ -149,7 +148,7 @@ describe Flapjack::Jabber do
       ["jabber_notifications", %q{{"notification_type":"shutdown"}}]
     )
 
-    EM.should_receive(:next_tick).twice.and_yield
+    EventMachine::Synchrony.should_receive(:next_tick).twice.and_yield
     fj.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
     fj.should_receive(:close)
 

data/spec/lib/flapjack/oobetet_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'flapjack/oobetet'
+
+describe Flapjack::Oobetet do
+
+  let(:config) { {'server'   => 'example.com',
+                  'port'     => '5222',
+                  'jabberid' => 'flapjack@example.com',
+                  'password' => 'password',
+                  'alias'    => 'flapjack',
+                  'watched_check'  => 'PING',
+                  'watched_entity' => 'foo.bar.net',
+                  'rooms'    => ['flapjacktest@conference.example.com']
+                 }
+  }
+
+  let(:stanza) { mock('stanza') }
+
+  it "raises an error if a required config setting is not set" do
+    Socket.should_receive(:gethostname).and_return('thismachine')
+
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config.delete('watched_check'))
+
+    lambda {
+      fo.setup
+    }.should raise_error
+  end
+
+  it "hooks up event handlers to the appropriate methods" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    EventMachine::Synchrony.should_receive(:next_tick).exactly(3).times.and_yield
+
+    fo.should_receive(:register_handler).with(:ready).and_yield(stanza)
+    fo.should_receive(:on_ready).with(stanza)
+
+    fo.should_receive(:register_handler).with(:message, :groupchat?).and_yield(stanza)
+    fo.should_receive(:on_groupchat).with(stanza)
+
+    fo.should_receive(:register_handler).with(:disconnected).and_yield(stanza)
+    fo.should_receive(:on_disconnect).with(stanza).and_return(true)
+
+    fo.register_handlers
+  end
+
+  it "joins a chat room after connecting" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    fo.should_receive(:write).with(an_instance_of(Blather::Stanza::Presence))
+    fo.should_receive(:write).with(an_instance_of(Blather::Stanza::Message))
+
+    fo.on_ready(stanza)
+  end
+
+  it "reconnects when disconnected (if not quitting)" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    EventMachine::Timer.should_receive(:new).with(1).and_yield
+    fo.should_receive(:connect)
+
+    ret = fo.on_disconnect(stanza)
+    ret.should be_true
+  end
+
+  it "records times of a problem status messages" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    fo.setup
+
+    t = Time.now
+
+    stanza.should_receive(:body).and_return( %q{PROBLEM: "PING" on foo.bar.net} )
+    Time.should_receive(:now).and_return(t)
+
+    fo.on_groupchat(stanza)
+    fo_times = fo.instance_variable_get('@times')
+    fo_times.should_not be_nil
+    fo_times.should have_key(:last_problem)
+    fo_times[:last_problem].should == t.to_i
+  end
+
+  it "records times of a recovery status messages" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    fo.setup
+
+    t = Time.now
+
+    stanza.should_receive(:body).and_return( %q{RECOVERY: "PING" on foo.bar.net} )
+    Time.should_receive(:now).and_return(t)
+
+    fo.on_groupchat(stanza)
+    fo_times = fo.instance_variable_get('@times')
+    fo_times.should_not be_nil
+    fo_times.should have_key(:last_recovery)
+    fo_times[:last_recovery].should == t.to_i
+  end
+
+  it "records times of an acknowledgement status messages" do
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+
+    fo.setup
+
+    t = Time.now
+
+    stanza.should_receive(:body).and_return( %q{ACKNOWLEDGEMENT: "PING" on foo.bar.net} )
+    Time.should_receive(:now).and_return(t)
+
+    fo.on_groupchat(stanza)
+    fo_times = fo.instance_variable_get('@times')
+    fo_times.should_not be_nil
+    fo_times.should have_key(:last_ack)
+    fo_times[:last_ack].should == t.to_i
+  end
+
+  it "runs a loop checking for recorded problems" do
+    timer = mock('timer')
+    timer.should_receive(:cancel)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(60).and_return(timer)
+
+    fo = Flapjack::Oobetet.new
+    fo.bootstrap(:config => config)
+    fo.should_receive(:register_handler).exactly(3).times
+
+    fo.should_receive(:connect)
+    fo.should_receive(:should_quit?).twice.and_return(false, true)
+
+    EM::Synchrony.should_receive(:sleep).with(10)
+
+    fo.main
+  end
+
+end

data/spec/lib/flapjack/pagerduty_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+require 'yajl/json_gem'
+
+require 'flapjack/pagerduty'
+
+describe Flapjack::Pagerduty, :redis => true do
+
+  let(:config) { {'queue'    => 'pagerduty_notifications'} }
+
+  let(:time)   { Time.new }
+
+  it "prompts the blocking redis connection to quit" do
+    redis = mock('redis')
+    redis.should_receive(:rpush).with(nil, %q{{"notification_type":"shutdown"}})
+
+    pagerduty = Flapjack::Pagerduty.new
+    pagerduty.bootstrap
+    pagerduty.add_shutdown_event(:redis => redis)
+  end
+
+  it "doesn't look for acknowledgements if this search is already running" do
+    @redis.set(Flapjack::Pagerduty::SEM_PAGERDUTY_ACKS_RUNNING, 'true')
+
+    fp = Flapjack::Pagerduty.new
+    fp.bootstrap(:config => config)
+    fp.instance_variable_set("@redis_timer", @redis)
+
+    fp.should_not_receive(:find_pagerduty_acknowledgements)
+    fp.find_pagerduty_acknowledgements_if_safe
+  end
+
+  it "looks for acknowledgements if the search is not already running" do
+    fp = Flapjack::Pagerduty.new
+    fp.bootstrap(:config => config)
+    fp.instance_variable_set("@redis_timer", @redis)
+
+    fp.should_receive(:find_pagerduty_acknowledgements)
+    fp.find_pagerduty_acknowledgements_if_safe
+  end
+
+  # Testing the private PagerDuty methods separately, it's simpler. May be
+  # an argument for splitting some of them to another module, accessed by this
+  # class, in which case it makes more sense for the methods to be public.
+
+  # NB: needs to run in synchrony block to catch the evented HTTP requests
+  it "looks for acknowledgements via the PagerDuty API" do
+    EM.synchrony do
+      fp = Flapjack::Pagerduty.new
+      fp.bootstrap(:config => config)
+
+      check = 'PING'
+      Time.should_receive(:now).and_return(time)
+      since = (time.utc - (60*60*24*7)).iso8601 # the last week
+      unt   = (time.utc + (60*60*24)).iso8601   # 1 day in the future
+
+      response = {"incidents" =>
+        [{"incident_number" => 12,
+          "status" => "acknowledged",
+          "last_status_change_by" => {"id"=>"ABCDEFG", "name"=>"John Smith",
+                                      "email"=>"johns@example.com",
+                                      "html_url"=>"http://flpjck.pagerduty.com/users/ABCDEFG"}
+         }
+        ],
+        "limit"=>100,
+        "offset"=>0,
+        "total"=>1}
+
+      stub_request(:get, "https://flpjck.pagerduty.com/api/v1/incidents?" +
+        "fields=incident_number,status,last_status_change_by&incident_key=#{check}&" +
+        "since=#{since}&status=acknowledged&until=#{unt}").
+         with(:headers => {'Authorization'=>['flapjack', 'password123']}).
+         to_return(:status => 200, :body => response.to_json, :headers => {})
+
+      result = fp.send(:pagerduty_acknowledged?, 'subdomain' => 'flpjck', 'username' => 'flapjack',
+        'password' => 'password123', 'check' => check)
+
+      result.should be_a(Hash)
+      result.should have_key(:pg_acknowledged_by)
+      result[:pg_acknowledged_by].should be_a(Hash)
+      result[:pg_acknowledged_by].should have_key('id')
+      result[:pg_acknowledged_by]['id'].should == 'ABCDEFG'
+      EM.stop
+    end
+  end
+
+  it "creates acknowledgements when pagerduty acknowledgements are found" do
+    fp = Flapjack::Pagerduty.new
+    fp.bootstrap(:config => config)
+
+    entity_check = mock('entity_check')
+    entity_check.should_receive(:check).and_return('PING')
+    entity_check.should_receive(:pagerduty_credentials).and_return([{
+      'service_key' => '12345678',
+      'subdomain"'  => 'flpjck',
+      'username'    => 'flapjack',
+      'password'    => 'password123'
+    }])
+    entity_check.should_receive(:create_acknowledgement).with('summary' => 'Acknowledged on PagerDuty')
+
+    Flapjack::Data::Global.should_receive(:unacknowledged_failing_checks).and_return([entity_check])
+
+    fp.should_receive(:pagerduty_acknowledged?).and_return({})
+
+    fp.send(:find_pagerduty_acknowledgements)
+  end
+
+  it "runs a blocking loop listening for notifications" do
+    timer = mock('timer')
+    timer.should_receive(:cancel)
+    EM::Synchrony.should_receive(:add_periodic_timer).with(10).and_return(timer)
+
+    redis = mock('redis')
+    redis.should_receive(:del).with('sem_pagerduty_acks_running')
+    redis.should_receive(:empty!)
+
+    fp = Flapjack::Pagerduty.new
+    fp.bootstrap(:config => config)
+    fp.should_receive(:build_redis_connection_pool).and_return(redis)
+
+    fp.should_receive(:should_quit?).exactly(3).times.and_return(false, false, true)
+    redis.should_receive(:blpop).twice.and_return(
+      ["pagerduty_notifications", %q{{"notification_type":"problem","event_id":"main-example.com:ping","state":"critical","summary":"!!!"}}],
+      ["pagerduty_notifications", %q{{"notification_type":"shutdown"}}]
+    )
+
+    fp.should_receive(:test_pagerduty_connection).and_return(true)
+    fp.should_receive(:send_pagerduty_event)
+
+    fp.main
+  end
+
+  it "tests the pagerduty connection" do
+    EM.synchrony do
+
+      evt = { "service_key"  => "11111111111111111111111111111111",
+              "incident_key" => "Flapjack is running a NOOP",
+              "event_type"   => "nop",
+              "description"  => "I love APIs with noops." }
+
+      body = evt.to_json
+      stub_request(:post, "https://events.pagerduty.com/generic/2010-04-15/create_event.json").
+        with(:body => body).to_return(:status => 200, :body => '{"status":"success"}', :headers => {})
+
+      fp = Flapjack::Pagerduty.new
+      fp.bootstrap(:config => config)
+
+      ret = fp.send(:test_pagerduty_connection)
+      ret.should be_true
+
+      EM.stop
+    end
+  end
+
+  it "sends an event to pagerduty" do
+    EM.synchrony do
+
+      evt = {"service_key"  => "abcdefg",
+             "incident_key" => "Flapjack test",
+             "event_type"   => "nop",
+             "description"  => "Not really sent anyway"}
+      body = evt.to_json
+      stub_request(:post, "https://events.pagerduty.com/generic/2010-04-15/create_event.json").
+        with(:body => body).to_return(:status => 200, :body => "", :headers => {})
+
+      fp = Flapjack::Pagerduty.new
+      fp.bootstrap(:config => config)
+
+      ret = fp.send(:send_pagerduty_event, evt)
+      ret.should_not be_nil
+      ret.should == [200, nil]
+
+      EM.stop
+    end
+  end
+
+end

data/spec/lib/flapjack/redis_pool_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'flapjack/redis_pool'
+
+describe Flapjack::RedisPool do
+
+  it "is initialized, and emptied" do
+    EM.synchrony do
+      redis_count = 3
+
+      redis_conns = redis_count.times.collect {
+        redis = mock('redis')
+        redis.should_receive(:quit)
+        redis
+      }
+      ::Redis.should_receive(:new).exactly(redis_count).times.and_return(*redis_conns)
+
+      frp = Flapjack::RedisPool.new(:size => redis_count)
+      frp.empty!
+
+      EM.stop
+    end
+  end
+
+end