flapjack 1.6.0 → 2.0.0b1

data/spec/lib/flapjack/gateways/slack_spec.rb

@@ -3,69 +3,69 @@ require 'flapjack/gateways/slack'
 
 describe Flapjack::Gateways::Slack, :logger => true do
 
-  let(:lock) { double(Monitor) }
+#   let(:lock) { double(Monitor) }
 
-  let(:redis) { double('redis') }
+#   let(:redis) { double('redis') }
 
-  let(:config) { {'account_sid' => 'flapslack',
-                  'endpoint'    => 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
-                 }
-               }
+#   let(:config) { {'account_sid' => 'flapslack',
+#                   'endpoint'    => 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX'
+#                  }
+#                }
 
-  let(:time) { Time.new(2013, 10, 31, 13, 45) }
+#   let(:time) { Time.new(2013, 10, 31, 13, 45) }
 
-  let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
+#   let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
 
-  let(:message) { {'notification_type'  => 'recovery',
-                   'contact_first_name' => 'John',
-                   'contact_last_name'  => 'Smith',
-                   'state'              => 'ok',
-                   'summary'            => 'smile',
-                   'last_state'         => 'problem',
-                   'last_summary'       => 'frown',
-                   'time'               => time.to_i,
-                   'address'            => 'general',
-                   'event_id'           => 'example.com:ping',
-                   'id'                 => '123456789',
-                   'duration'           => 55,
-                   'state_duration'     => 23
-                  }
-                }
+#   let(:message) { {'notification_type'  => 'recovery',
+#                    'contact_first_name' => 'John',
+#                    'contact_last_name'  => 'Smith',
+#                    'state'              => 'ok',
+#                    'summary'            => 'smile',
+#                    'last_state'         => 'problem',
+#                    'last_summary'       => 'frown',
+#                    'time'               => time.to_i,
+#                    'address'            => 'general',
+#                    'event_id'           => 'example.com:ping',
+#                    'id'                 => '123456789',
+#                    'duration'           => 55,
+#                    'state_duration'     => 23
+#                   }
+#                 }
 
-  it "sends a Slack message" do
-    payload_json = Flapjack.dump_json(
-      'channel'    => '#general',
-      'username'   => 'flapslack',
-      'text'       => "Recovery: 'ping' on example.com is OK at #{time_str}, smile",
-      'icon_emoji' => ':ghost:'
-    )
+  it "sends a Slack message" # do
+#     payload_json = Flapjack.dump_json(
+#       'channel'    => '#general',
+#       'username'   => 'flapslack',
+#       'text'       => "Recovery: 'ping' on example.com is OK at #{time_str}, smile",
+#       'icon_emoji' => ':ghost:'
+#     )
 
-    req = stub_request(:post, config['endpoint']).
-      with(:body => {'payload' => payload_json}).
-      to_return(:status => 200)
+#     req = stub_request(:post, config['endpoint']).
+#       with(:body => {'payload' => payload_json}).
+#       to_return(:status => 200)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+#     EM.synchrony do
+#       expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      slack = Flapjack::Gateways::Slack.new(:config => config, :logger => @logger)
-      slack.deliver(alert)
-      EM.stop
-    end
-    expect(req).to have_been_requested
-  end
+#       alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+#       slack = Flapjack::Gateways::Slack.new(:config => config, :logger => @logger)
+#       slack.deliver(alert)
+#       EM.stop
+#     end
+#     expect(req).to have_been_requested
+#   end
 
-  it "does not send a Slack message with an invalid config" do
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+  it "does not send a Slack message with an invalid config" # do
+#     EM.synchrony do
+#       expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      slack = Flapjack::Gateways::Slack.new(:config => config.reject {|k, v| k == 'endpoint'}, :logger => @logger)
-      slack.deliver(alert)
-      EM.stop
-    end
+#       alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+#       slack = Flapjack::Gateways::Slack.new(:config => config.reject {|k, v| k == 'endpoint'}, :logger => @logger)
+#       slack.deliver(alert)
+#       EM.stop
+#     end
 
-    expect(WebMock).not_to have_requested(:post, config['endpoint'])
-  end
+#     expect(WebMock).not_to have_requested(:post, config['endpoint'])
+#   end
 
-end
+end

data/spec/lib/flapjack/gateways/sms_aspsms_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'flapjack/gateways/sms_aspsms'
+
+describe Flapjack::Gateways::SmsAspsms, :logger => true do
+
+  let(:lock)  { double(Monitor) }
+  let(:redis) { double(Redis)}
+
+  let(:config) { {'username'  => 'user',
+                  'password'  => 'password',
+                  'originator' => 'FlapjackT'
+                 }
+               }
+
+  let(:time) { Time.new(2013, 10, 31, 13, 45) }
+  let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
+
+  let(:queue) { double(Flapjack::RecordQueue) }
+  let(:alert) { double(Flapjack::Data::Alert) }
+
+  let(:check)  { double(Flapjack::Data::Check) }
+
+  before(:each) do
+    allow(Flapjack).to receive(:redis).and_return(redis)
+  end
+
+  it "sends an SMS message" do
+    req = stub_request(:get, "https://webservice.aspsms.com/aspsmsx.asmx/SimpleTextSMS").
+      with(:query => {'Recipient' => '555-555555',
+                      'UserKey' => 'user',
+                      'Password' => 'password',
+                      'Originator' => 'FlapjackT',
+                      'MessageText' => "Recovery: 'example.com:ping' is OK at #{time_str}, smile"}).
+      to_return(:status => 200)
+
+    expect(Flapjack::RecordQueue).to receive(:new).with('sms_aspsms_notifications',
+      Flapjack::Data::Alert).and_return(queue)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return('555-555555')
+
+    expect(alert).to receive(:medium).and_return(medium)
+
+    expect(alert).to receive(:id).twice.and_return('123456789')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(alert).to receive(:type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(alert).to receive(:state_title_case).and_return('OK')
+    expect(alert).to receive(:time).and_return(time.to_i)
+
+    expect(check).to receive(:name).and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    expect(redis).to receive(:quit)
+
+    sms_gw = Flapjack::Gateways::SmsAspsms.new(:lock => lock,
+                                                   :config => config)
+    expect { sms_gw.start }.to raise_error(Flapjack::PikeletStop)
+    expect(req).to have_been_requested
+  end
+
+
+  it "does not send an SMS message with an invalid config" do
+    expect(Flapjack::RecordQueue).to receive(:new).with('sms_aspsms_notifications',
+      Flapjack::Data::Alert).and_return(queue)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return('555-555555')
+
+    expect(alert).to receive(:medium).and_return(medium)
+
+    expect(alert).to receive(:id).and_return('123456789')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(alert).to receive(:type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(alert).to receive(:state_title_case).and_return('OK')
+    expect(alert).to receive(:time).and_return(time.to_i)
+
+    expect(check).to receive(:name).and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    expect(redis).to receive(:quit)
+
+    sms_gw = Flapjack::Gateways::SmsAspsms.new(:lock => lock,
+                                                   :config => config.reject {|k, v| k == 'password'})
+    expect { sms_gw.start }.to raise_error(Flapjack::PikeletStop)
+
+    expect(WebMock).not_to have_requested(:get,
+                                      "https://webservice.aspsms.com/aspsmsx.asmx/SimpleTextSMS")
+  end
+
+end

data/spec/lib/flapjack/gateways/sms_messagenet_spec.rb

@@ -3,9 +3,8 @@ require 'flapjack/gateways/sms_messagenet'
 
 describe Flapjack::Gateways::SmsMessagenet, :logger => true do
 
-  let(:lock) { double(Monitor) }
-
-  let(:redis) { double('redis') }
+  let(:lock)  { double(Monitor) }
+  let(:redis) { double(Redis)}
 
   let(:config) { {'username'  => 'user',
                   'password'  => 'password'
@@ -13,82 +12,140 @@ describe Flapjack::Gateways::SmsMessagenet, :logger => true do
                }
 
   let(:time) { Time.new(2013, 10, 31, 13, 45) }
-
   let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
 
-  let(:message) { {'notification_type'  => 'recovery',
-                   'contact_first_name' => 'John',
-                   'contact_last_name'  => 'Smith',
-                   'state'              => 'ok',
-                   'summary'            => 'smile',
-                   'last_state'         => 'problem',
-                   'last_summary'       => 'frown',
-                   'time'               => time.to_i,
-                   'address'            => '555-555555',
-                   'event_id'           => 'example.com:ping',
-                   'id'                 => '123456789',
-                   'duration'           => 55,
-                   'state_duration'     => 23
-                  }
-                }
+  let(:queue) { double(Flapjack::RecordQueue) }
+  let(:alert) { double(Flapjack::Data::Alert) }
+
+  let(:check)  { double(Flapjack::Data::Check) }
+
+  before(:each) do
+    allow(Flapjack).to receive(:redis).and_return(redis)
+  end
 
   it "sends an SMS message" do
     req = stub_request(:get, "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage").
-      with(:query => {'PhoneNumber'  => '555-555555',
-                      'Username'     => 'user',
-                      'Pwd'          => 'password',
-                      'PhoneMessage' => "Recovery: 'ping' on example.com is OK at #{time_str}, smile"}).
+      with(:query => {'PhoneNumber' => '555-555555',
+                      'Username' => 'user',
+                      'Pwd' => 'password',
+                      'PhoneMessage' => "Recovery: 'example.com:ping' is OK at #{time_str}, smile"}).
       to_return(:status => 200)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(Flapjack::RecordQueue).to receive(:new).with('sms_notifications',
+      Flapjack::Data::Alert).and_return(queue)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return('555-555555')
+
+    expect(alert).to receive(:medium).and_return(medium)
+
+    expect(alert).to receive(:id).twice.and_return('123456789')
+    expect(alert).to receive(:rollup).and_return(nil)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config, :logger => @logger)
-      sms_messagenet.deliver(alert)
-      EM.stop
-    end
+    expect(alert).to receive(:type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(alert).to receive(:state_title_case).and_return('OK')
+    expect(alert).to receive(:time).and_return(time.to_i)
+
+    expect(check).to receive(:name).and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    expect(redis).to receive(:quit)
+
+    sms_gw = Flapjack::Gateways::SmsMessagenet.new(:lock => lock,
+                                                   :config => config)
+    expect { sms_gw.start }.to raise_error(Flapjack::PikeletStop)
     expect(req).to have_been_requested
   end
 
-  it "truncates a long message a" do
-    long_msg = message.merge('summary' => 'Four score and seven years ago our ' +
-      'fathers brought forth on this continent, a new nation, conceived in ' +
-      'Liberty, and dedicated to the proposition that all men are created equal.')
+  it "truncates a long message" do
+     long_summary = 'Four score and seven years ago our ' +
+       'fathers brought forth on this continent, a new nation, conceived in ' +
+       'Liberty, and dedicated to the proposition that all men are created equal.'
 
     req = stub_request(:get, "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage").
-      with(:query => {'PhoneNumber'  => '555-555555',
-                      'Username'     => 'user',
-                      'Pwd'          => 'password',
-                      'PhoneMessage' => "Recovery: 'ping' on example.com is " +
+      with(:query => {'PhoneNumber' => '555-555555',
+                      'Username' => 'user',
+                      'Pwd' => 'password',
+                      'PhoneMessage' => "Recovery: 'example.com:ping' is " +
                         "OK at #{time_str}, Four score and seven years ago " +
                         'our fathers brought forth on this continent, a new ' +
                         'nation, conceived i...'}).
       to_return(:status => 200)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return('555-555555')
+
+    expect(alert).to receive(:medium).and_return(medium)
+
+    expect(alert).to receive(:id).twice.and_return('123456789')
+    expect(alert).to receive(:rollup).and_return(nil)
 
-      alert = Flapjack::Data::Alert.new(long_msg, :logger => @logger)
-      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config, :logger => @logger)
-      sms_messagenet.deliver(alert)
-      EM.stop
-    end
+    expect(alert).to receive(:type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:summary).and_return(long_summary)
+
+    expect(alert).to receive(:state_title_case).and_return('OK')
+    expect(alert).to receive(:time).and_return(time.to_i)
+
+    expect(check).to receive(:name).and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(Flapjack::RecordQueue).to receive(:new).with('sms_notifications',
+      Flapjack::Data::Alert).and_return(queue)
+
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    expect(redis).to receive(:quit)
+
+    sms_gw = Flapjack::Gateways::SmsMessagenet.new(:lock => lock,
+                                                   :config => config)
+    expect { sms_gw.start }.to raise_error(Flapjack::PikeletStop)
     expect(req).to have_been_requested
   end
 
   it "does not send an SMS message with an invalid config" do
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(Flapjack::RecordQueue).to receive(:new).with('sms_notifications',
+      Flapjack::Data::Alert).and_return(queue)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return('555-555555')
+
+    expect(alert).to receive(:medium).and_return(medium)
+
+    expect(alert).to receive(:id).and_return('123456789')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(alert).to receive(:type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(alert).to receive(:state_title_case).and_return('OK')
+    expect(alert).to receive(:time).and_return(time.to_i)
+
+    expect(check).to receive(:name).and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    expect(redis).to receive(:quit)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      sms_messagenet = Flapjack::Gateways::SmsMessagenet.new(:config => config.reject {|k, v| k == 'password'}, :logger => @logger)
-      sms_messagenet.deliver(alert)
-      EM.stop
-    end
+    sms_gw = Flapjack::Gateways::SmsMessagenet.new(:lock => lock,
+                                                   :config => config.reject {|k, v| k == 'password'})
+    expect { sms_gw.start }.to raise_error(Flapjack::PikeletStop)
 
     expect(WebMock).not_to have_requested(:get,
-      "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage")
+                                      "https://www.messagenet.com.au/dotnet/Lodge.asmx/LodgeSMSMessage")
   end
 
-end
+end

data/spec/lib/flapjack/gateways/sms_nexmo_spec.rb

@@ -1,65 +1,64 @@
 require 'spec_helper'
-require 'nexmo'
 require 'flapjack/gateways/sms_nexmo'
 
 describe Flapjack::Gateways::SmsNexmo, :logger => true do
-  let(:lock) { double(Monitor) }
+#   let(:lock) { double(Monitor) }
 
-  let(:redis) { double('redis') }
+#   let(:redis) { double('redis') }
 
-  let(:nexmo_client) { double(Nexmo::Client) }
+#   let(:nexmo_client) { double(Nexmo::Client) }
 
-  let(:config) { {'api_key' => 'THEAPIKEY',
-                  'secret'  => 'secret', 
-                  'from'    => 'flapjack'
-                 }
-               }
+#   let(:config) { {'api_key' => 'THEAPIKEY',
+#                   'secret'  => 'secret',
+#                   'from'    => 'flapjack'
+#                  }
+#                }
 
-  let(:time) { Time.new(2013, 10, 31, 13, 45) }
+#   let(:time) { Time.new(2013, 10, 31, 13, 45) }
 
-  let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
+#   let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
 
-  let(:message) { {'notification_type'  => 'recovery',
-                   'contact_first_name' => 'John',
-                   'contact_last_name'  => 'Smith',
-                   'state'              => 'ok',
-                   'summary'            => 'smile',
-                   'last_state'         => 'problem',
-                   'last_summary'       => 'frown',
-                   'time'               => time.to_i,
-                   'address'            => '0034123456789',
-                   'event_id'           => 'example.com:ping',
-                   'id'                 => '123456789',
-                   'duration'           => 55,
-                   'state_duration'     => 23
-                  }
-                }
+#   let(:message) { {'notification_type'  => 'recovery',
+#                    'contact_first_name' => 'John',
+#                    'contact_last_name'  => 'Smith',
+#                    'state'              => 'ok',
+#                    'summary'            => 'smile',
+#                    'last_state'         => 'problem',
+#                    'last_summary'       => 'frown',
+#                    'time'               => time.to_i,
+#                    'address'            => '0034123456789',
+#                    'event_id'           => 'example.com:ping',
+#                    'id'                 => '123456789',
+#                    'duration'           => 55,
+#                    'state_duration'     => 23
+#                   }
+#                 }
 
-  it "sends an SMS message" do
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
-      expect(Nexmo::Client).to receive(:new).and_return(nexmo_client)
-      expect(nexmo_client).to receive(:send_message).
-        with(from: "flapjack",
-             to:   "0034123456789",
-             text: "Recovery: 'ping' on example.com is OK at 31 Oct 13:45, smile")
+  it "sends an SMS message" # do
+#     EM.synchrony do
+#       expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+#       expect(Nexmo::Client).to receive(:new).and_return(nexmo_client)
+#       expect(nexmo_client).to receive(:send_message).
+#         with(from: "flapjack",
+#              to:   "0034123456789",
+#              text: "Recovery: 'ping' on example.com is OK at 31 Oct 13:45, smile")
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      sms_nexmo = Flapjack::Gateways::SmsNexmo.new(:config => config, :logger => @logger)
-      sms_nexmo.deliver(alert)
-      EM.stop
-    end
-  end
+#       alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+#       sms_nexmo = Flapjack::Gateways::SmsNexmo.new(:config => config, :logger => @logger)
+#       sms_nexmo.deliver(alert)
+#       EM.stop
+#     end
+#   end
 
-  it "does not send an SMS message with an invalid configuration" do
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
-      expect_any_instance_of(Nexmo::Client).not_to receive(:send_message)
+  it "does not send an SMS message with an invalid configuration" # do
+#     EM.synchrony do
+#       expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+#       expect_any_instance_of(Nexmo::Client).not_to receive(:send_message)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      sms_nexmo = Flapjack::Gateways::SmsNexmo.new(:config => config.reject {|k, v| k == 'secret'}, :logger => @logger)
-      sms_nexmo.deliver(alert)
-      EM.stop
-    end
-  end
-end
+#       alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+#       sms_nexmo = Flapjack::Gateways::SmsNexmo.new(:config => config.reject {|k, v| k == 'secret'}, :logger => @logger)
+#       sms_nexmo.deliver(alert)
+#       EM.stop
+#     end
+#   end
+end