flapjack 1.6.0 → 2.0.0b1

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

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'flapjack/data/unscheduled_maintenance'
+
+describe Flapjack::Data::UnscheduledMaintenance, :redis => true do
+
+  #   it "creates an unscheduled maintenance period" do
+  #     t = Time.now.to_i
+  #     ec = Flapjack::Data::EntityCheck.for_entity_name(name, check)
+  #     ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
+
+  #     ec.should be_in_unscheduled_maintenance
+
+  #     umps = ec.maintenances(nil, nil, :scheduled => false)
+  #     umps.should_not be_nil
+  #     umps.should be_an(Array)
+  #     umps.should have(1).unscheduled_maintenance_period
+  #     umps[0].should be_a(Hash)
+
+  #     start_time = umps[0][:start_time]
+  #     start_time.should_not be_nil
+  #     start_time.should be_an(Integer)
+  #     start_time.should == t
+
+  #     duration = umps[0][:duration]
+  #     duration.should_not be_nil
+  #     duration.should be_a(Float)
+  #     duration.should == half_an_hour
+
+  #     summary = Flapjack.redis.get("#{name}:#{check}:#{t}:unscheduled_maintenance:summary")
+  #     summary.should_not be_nil
+  #     summary.should == 'oops'
+  #   end
+
+end

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

@@ -3,13 +3,15 @@ require 'flapjack/gateways/aws_sns'
 
 describe Flapjack::Gateways::AwsSns, :logger => true do
 
-  let(:lock) { double(Monitor) }
+  let(:lock)  { double(Monitor) }
+  let(:redis) { double(Redis)}
 
-  let(:redis) { double('redis') }
+  let(:queue) { double(Flapjack::RecordQueue) }
+  let(:alert) { double(Flapjack::Data::Alert) }
 
-  let(:time_int) { 1383252300 }
+  let(:time) { Time.new(2013, 10, 31, 13, 45) }
 
-  let(:time_str) { '2013-10-31T20:45:00Z' }
+  let(:time_str) { Time.at(time).strftime('%-d %b %H:%M') }
 
   let(:config) { {'region' => 'us-east-1',
                   'access_key' => 'AKIAIOSFODNN7EXAMPLE',
@@ -18,83 +20,133 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
                }
 
   let(:message) { {'notification_type'  => 'recovery',
-                   'contact_first_name' => 'John',
-                   'contact_last_name'  => 'Smith',
+                   'contact_name' => 'John Smith',
                    'state'              => 'ok',
                    'summary'            => 'smile',
                    'last_state'         => 'problem',
                    'last_summary'       => 'frown',
-                   'time'               => time_int,
-                   'address'            => 'arn:aws:sns:us-east-1:698519295917:My-Topic',
+                   'time'               => time.to_i,
                    'event_id'           => 'example.com:ping',
                    'id'                 => '123456789',
                    'duration'           => 55,
-                   'state_duration'     => 23
+                   'condition_duration'     => 23
                   }
                 }
 
-  it "sends an SMS message" do
-    # bad, bad, bad...
-    t = double('time')
-    ut  = double('utc_time')
-    expect(ut).to receive(:strftime).with('%Y-%m-%dT%H:%M:%SZ').and_return(time_str)
-    expect(t).to receive(:utc).and_return(ut)
-    expect(t).to receive(:strftime).with('%-d %b %H:%M').and_return('31 Oct 20:45')
-    expect(Time).to receive(:at).with(time_int).twice.and_return(t)
-
-    req = stub_request(:post, "http://sns.us-east-1.amazonaws.com/").
-      with(:query => hash_including({'Action'           => 'Publish',
-                                     'AWSAccessKeyId'   => config['access_key'],
-                                     'TopicArn'         => message['address'],
-                                     'SignatureVersion' => '2',
-                                     'SignatureMethod'  => 'HmacSHA256',
-                                     'Signature'        => '5fWqhmDrZQkQfP7wsxWDdQjzV0BLwm6cZNrNqZ+W/ok=',
-                                     'Timestamp'        => time_str})).
-      to_return(:status => 200)
+  let(:address) { 'arn:aws:sns:us-east-1:698519295917:My-Topic' }
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+  let(:check)  { double(Flapjack::Data::Check) }
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      aws_sns = Flapjack::Gateways::AwsSns.new(:config => config, :logger => @logger)
-      aws_sns.deliver(alert)
-      EM.stop
-    end
-    expect(req).to have_been_requested
+  before(:each) do
+    allow(Flapjack).to receive(:redis).and_return(redis)
   end
 
-  it 'truncates an overly long subject when sending' do
+ # it "sends an SMS message" do
+ #   # bad, bad, bad...
+ #   t = double('time')
+ #   ut  = double('utc_time')
+ #   expect(ut).to receive(:strftime).with('%Y-%m-%dT%H:%M:%SZ').and_return(time_str)
+ #   expect(t).to receive(:utc).and_return(ut)
+ #   expect(t).to receive(:strftime).with('%-d %b %H:%M').and_return('31 Oct 20:45')
+ #   expect(Time).to receive(:at).with(time_int).twice.and_return(t)
+
+ #   req = stub_request(:post, "http://sns.us-east-1.amazonaws.com/").
+ #     with(:query => hash_including({'Action'           => 'Publish',
+ #                                    'AWSAccessKeyId'   => config['access_key'],
+ #                                    'TopicArn'         => message['address'],
+ #                                    'SignatureVersion' => '2',
+ #                                    'SignatureMethod'  => 'HmacSHA256',
+ #                                    'Signature'        => '5fWqhmDrZQkQfP7wsxWDdQjzV0BLwm6cZNrNqZ+W/ok=',
+ #                                    'Timestamp'        => time_str})).
+ #     to_return(:status => 200)
+
+ #   EM.synchrony do
+ #     expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+
+ #     alert = Flapjack::Data::Alert.new(message, :logger => @logger)
+ #     aws_sns = Flapjack::Gateways::AwsSns.new(:config => config, :logger => @logger)
+ #     aws_sns.deliver(alert)
+ #     EM.stop
+ #   end
+ #   expect(req).to have_been_requested
+ # end
+
+ it 'truncates an overly long subject when sending' # FIXME port from maint/1.x
+
+  it "sends an SMS message" do
     req = stub_request(:post, "http://sns.us-east-1.amazonaws.com/").
-      with(:query => hash_including({'Action'           => 'Publish',
-                                     'AWSAccessKeyId'   => config['access_key'],
-                                     'TopicArn'         => message['address'],
-                                     'SignatureVersion' => '2',
-                                     'SignatureMethod'  => 'HmacSHA256',
-                                     'Subject'          => "Recovery: '#{'1234567890' * 8}123456..."})).
+      with(:body => hash_including({'Action'           => 'Publish',
+                                    'AWSAccessKeyId'   => config['access_key'],
+                                    'TopicArn'         => address,
+                                    'SignatureVersion' => '2',
+                                    'SignatureMethod'  => 'HmacSHA256'})).
       to_return(:status => 200)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(Flapjack::RecordQueue).to receive(:new).with('sns_notifications',
+      Flapjack::Data::Alert).and_return(queue)
 
-      long_event_id = "example.com:#{'1234567890' * 10}"
-      alert = Flapjack::Data::Alert.new(message.merge('event_id' => long_event_id), :logger => @logger)
-      aws_sns = Flapjack::Gateways::AwsSns.new(:config => config, :logger => @logger)
-      aws_sns.deliver(alert)
-      EM.stop
-    end
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return(address)
+
+    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(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).twice.and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(check).to receive(:name).twice.and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(alert).to receive(:state_title_case).twice.and_return('OK')
+    expect(alert).to receive(:time).twice.and_return(time)
+
+    expect(redis).to receive(:quit)
+
+    sns_gw = Flapjack::Gateways::AwsSns.new(:lock => lock,
+                                            :config => config)
+    expect { sns_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('sns_notifications',
+      Flapjack::Data::Alert).and_return(queue)
 
-      alert = Flapjack::Data::Alert.new(message, :logger => @logger)
-      aws_sns = Flapjack::Gateways::AwsSns.new(:config => config.reject {|k, v| k == 'secret_key'}, :logger => @logger)
-      aws_sns.deliver(alert)
-      EM.stop
-    end
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:address).and_return(address)
+
+    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(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).twice.and_return('Recovery')
+    expect(alert).to receive(:summary).and_return('smile')
+
+    expect(check).to receive(:name).twice.and_return('example.com:ping')
+    expect(alert).to receive(:check).and_return(check)
+
+    expect(alert).to receive(:state_title_case).twice.and_return('OK')
+    expect(alert).to receive(:time).twice.and_return(time)
+
+    expect(redis).to receive(:quit)
+
+    sns_gw = Flapjack::Gateways::AwsSns.new(:lock => lock,
+                                            :config => config.reject {|k, v| k == 'secret_key'})
 
+    expect { sns_gw.start }.to raise_error(Flapjack::PikeletStop)
     expect(WebMock).not_to have_requested(:get, "http://sns.us-east-1.amazonaws.com/")
   end
 
@@ -107,8 +159,7 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
     let(:uri) { '/' }
 
     let(:query) { {'TopicArn' => 'HelloWorld',
-                   'Action' => 'Publish',
-                   'Message' => 'Hello ~ World'} }
+                  'Action' => 'Publish'} }
 
     let(:string_to_sign) { Flapjack::Gateways::AwsSns.string_to_sign(method, host, uri, query) }
 
@@ -127,7 +178,7 @@ describe Flapjack::Gateways::AwsSns, :logger => true do
     end
 
     it 'should put the encoded, sorted query-string on the fourth line' do
-      expect(lines[3]).to eq("Action=Publish&Message=Hello%20~%20World&TopicArn=HelloWorld")
+      expect(lines[3]).to eq("Action=Publish&TopicArn=HelloWorld")
     end
 
   end

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

@@ -3,191 +3,224 @@ require 'flapjack/gateways/email'
 
 describe Flapjack::Gateways::Email, :logger => true do
 
-  let(:client) { double('client') }
-  let(:redis) { double('redis') }
-
-  it "can have a custom from email address" do
-    expect(EM::P::SmtpClient).to receive(:send).with(
-      hash_including(host: 'localhost',
-                     port: 25,
-                     from: "from@example.org")
-    ).and_return(client)
-
-    response = double(response)
-    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
-    expect(response).to receive(:code).and_return(250)
-
-    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
-
-    notification = {'notification_type'   => 'recovery',
-                    'contact_first_name'  => 'John',
-                    'contact_last_name'   => 'Smith',
-                    'state'               => 'ok',
-                    'state_duration'      => 2,
-                    'summary'             => 'smile',
-                    'last_state'          => 'problem',
-                    'last_summary'        => 'frown',
-                    'time'                => Time.now.to_i,
-                    'event_id'            => 'example.com:ping'}
+  let(:redis) { double(::Redis) }
 
-    config = {"smtp_config" => {'from' => 'from@example.org'}}
+  let(:lock)  { double(Monitor) }
+
+  let(:queue) { double(Flapjack::RecordQueue) }
+  let(:alert) { double(Flapjack::Data::Alert) }
+
+  before(:each) do
+    Mail::TestMailer.deliveries.clear
+  end
+
+  it "sends a mail with text and html parts and custom from address" do
+    expect(redis).to receive(:quit)
+    allow(Flapjack).to receive(:redis).and_return(redis)
+
+    expect(Flapjack::RecordQueue).to receive(:new).with('email_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)
+
+    check = double(Flapjack::Data::Check)
+    expect(check).to receive(:name).exactly(3).times.and_return('example.com:ping')
+
+    contact = double(Flapjack::Data::Contact)
+    expect(contact).to receive(:name).twice.and_return('John Smith')
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:contact).twice.and_return(contact)
+    expect(medium).to receive(:address).and_return('johns@example.com')
+
+    expect(alert).to receive(:id).and_return('123456')
+
+    expect(alert).to receive(:medium).exactly(3).times.and_return(medium)
+
+    expect(alert).to receive(:check).exactly(3).times.and_return(check)
+    expect(alert).to receive(:state_title_case).exactly(3).times.and_return('OK')
+    expect(alert).to receive(:condition_duration).twice.and_return(2)
+    expect(alert).to receive(:summary).twice.and_return('smile')
+    expect(alert).to receive(:details).twice.and_return('')
+    expect(alert).to receive(:time).twice.and_return(Time.now)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(alert).to receive(:last_state).twice.and_return( double(Flapjack::Data::State) )
+    expect(alert).to receive(:last_state_title_case).twice.and_return('Critical')
+    expect(alert).to receive(:last_summary).twice.and_return('frown')
 
-      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
-      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
-      email.deliver(alert)
-      EM.stop
-    end
+    expect(alert).to receive(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(Mail::TestMailer.deliveries).to be_empty
+
+    config = {"smtp_config" => {'from' => 'from@example.org'}}
+    email_gw = Flapjack::Gateways::Email.new(:lock => lock, :config => config)
+    expect { email_gw.start }.to raise_error(Flapjack::PikeletStop)
+
+    expect(Mail::TestMailer.deliveries.size).to eq(1)
+    mail = Mail::TestMailer.deliveries.first
+    expect(mail.header['From'].addresses).to eq(['from@example.org'])
   end
 
   it "can have a full name in custom from email address" do
-    expect(EM::P::SmtpClient).to receive(:send).with(
-      hash_including(host: 'localhost',
-                     port: 25,
-                     from: "from@example.org")
-    ).and_return(client)
-
-    response = double(response)
-    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
-    expect(response).to receive(:code).and_return(250)
-
-    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
-
-    notification = {'notification_type'   => 'recovery',
-                    'contact_first_name'  => 'John',
-                    'contact_last_name'   => 'Smith',
-                    'state'               => 'ok',
-                    'state_duration'      => 2,
-                    'summary'             => 'smile',
-                    'last_state'          => 'problem',
-                    'last_summary'        => 'frown',
-                    'time'                => Time.now.to_i,
-                    'event_id'            => 'example.com:ping'}
+    expect(redis).to receive(:quit)
+    allow(Flapjack).to receive(:redis).and_return(redis)
+
+    expect(Flapjack::RecordQueue).to receive(:new).with('email_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)
+
+    check = double(Flapjack::Data::Check)
+    expect(check).to receive(:name).exactly(3).times.and_return('example.com:ping')
+
+    contact = double(Flapjack::Data::Contact)
+    expect(contact).to receive(:name).twice.and_return('John Smith')
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:contact).twice.and_return(contact)
+    expect(medium).to receive(:address).and_return('johns@example.com')
+
+    expect(alert).to receive(:id).and_return('123456')
+
+    expect(alert).to receive(:medium).exactly(3).times.and_return(medium)
+
+    expect(alert).to receive(:check).exactly(3).times.and_return(check)
+    expect(alert).to receive(:state_title_case).exactly(3).times.and_return('OK')
+    expect(alert).to receive(:condition_duration).twice.and_return(2)
+    expect(alert).to receive(:summary).twice.and_return('smile')
+    expect(alert).to receive(:details).twice.and_return('')
+    expect(alert).to receive(:time).twice.and_return(Time.now)
+
+    expect(alert).to receive(:last_state).twice.and_return( double(Flapjack::Data::State) )
+    expect(alert).to receive(:last_state_title_case).twice.and_return('Critical')
+    expect(alert).to receive(:last_summary).twice.and_return('frown')
+
+    expect(alert).to receive(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(Mail::TestMailer.deliveries).to be_empty
 
     config = {"smtp_config" => {'from' => 'Full Name <from@example.org>'}}
+    email_gw = Flapjack::Gateways::Email.new(:lock => lock, :config => config)
+    expect { email_gw.start }.to raise_error(Flapjack::PikeletStop)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(Mail::TestMailer.deliveries.size).to eq(1)
 
-      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
-      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
-      email.deliver(alert)
-      EM.stop
-    end
+    mail = Mail::TestMailer.deliveries.first
+    expect(mail.header['Reply-To'].display_names).to eq(['Full Name'])
+    expect(mail.header['Reply-To'].addresses).to eq(['from@example.org'])
   end
 
   it "can have a custom reply-to address" do
-    expect(EM::P::SmtpClient).to receive(:send) { |message|
-      # NOTE No access to headers directly. Must be determined from message content
-      expect( message[:content] ).to include("Reply-To: reply-to@example.com")
-      # NOTE Ensure we haven't trashed any other arguments
-      expect( message[:host] ).to eql('localhost')
-      expect( message[:port] ).to eql(25)
-      expect( message[:from] ).to eql('from@example.org')
-    }.and_return(client)
-
-    response = double(response)
-    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
-    expect(response).to receive(:code).and_return(250)
-
-    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
-
-    notification = {'notification_type'   => 'recovery',
-                    'contact_first_name'  => 'John',
-                    'contact_last_name'   => 'Smith',
-                    'state'               => 'ok',
-                    'state_duration'      => 2,
-                    'summary'             => 'smile',
-                    'last_state'          => 'problem',
-                    'last_summary'        => 'frown',
-                    'time'                => Time.now.to_i,
-                    'event_id'            => 'example.com:ping'}
+    expect(redis).to receive(:quit)
+    allow(Flapjack).to receive(:redis).and_return(redis)
+
+    expect(Flapjack::RecordQueue).to receive(:new).with('email_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)
+
+    check = double(Flapjack::Data::Check)
+    expect(check).to receive(:name).exactly(3).times.and_return('example.com:ping')
+
+    contact = double(Flapjack::Data::Contact)
+    expect(contact).to receive(:name).twice.and_return('John Smith')
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:contact).twice.and_return(contact)
+    expect(medium).to receive(:address).and_return('johns@example.com')
+
+    expect(alert).to receive(:id).and_return('123456')
+
+    expect(alert).to receive(:medium).exactly(3).times.and_return(medium)
+
+    expect(alert).to receive(:check).exactly(3).times.and_return(check)
+    expect(alert).to receive(:state_title_case).exactly(3).times.and_return('OK')
+    expect(alert).to receive(:condition_duration).twice.and_return(2)
+    expect(alert).to receive(:summary).twice.and_return('smile')
+    expect(alert).to receive(:details).twice.and_return('')
+    expect(alert).to receive(:time).twice.and_return(Time.now)
+
+    expect(alert).to receive(:last_state).twice.and_return( double(Flapjack::Data::State) )
+    expect(alert).to receive(:last_state_title_case).twice.and_return('Critical')
+    expect(alert).to receive(:last_summary).twice.and_return('frown')
+
+    expect(alert).to receive(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(Mail::TestMailer.deliveries).to be_empty
 
     config = {"smtp_config" => {'from' => 'from@example.org', 'reply_to' => 'reply-to@example.com'}}
+    email_gw = Flapjack::Gateways::Email.new(:lock => lock, :config => config)
+    expect { email_gw.start }.to raise_error(Flapjack::PikeletStop)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(Mail::TestMailer.deliveries.size).to eq(1)
 
-      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
-      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
-      email.deliver(alert)
-      EM.stop
-    end
+    mail = Mail::TestMailer.deliveries.first
+    expect(mail.header['From'].addresses).to eq(['from@example.org'])
+    expect(mail.header['Reply-To'].addresses).to eq(['reply-to@example.com'])
   end
 
   it "must default to from address if no reply-to given" do
-    expect(EM::P::SmtpClient).to receive(:send) { |message|
-      # NOTE No access to headers directly. Must be determined from message content
-      expect( message[:content] ).to include("Reply-To: from@example.org")
-    }.and_return(client)
-
-    response = double(response)
-    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
-    expect(response).to receive(:code).and_return(250)
-
-    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
-
-    notification = {'notification_type'   => 'recovery',
-                    'contact_first_name'  => 'John',
-                    'contact_last_name'   => 'Smith',
-                    'state'               => 'ok',
-                    'state_duration'      => 2,
-                    'summary'             => 'smile',
-                    'last_state'          => 'problem',
-                    'last_summary'        => 'frown',
-                    'time'                => Time.now.to_i,
-                    'event_id'            => 'example.com:ping'}
+    expect(redis).to receive(:quit)
+    allow(Flapjack).to receive(:redis).and_return(redis)
 
-    config = {"smtp_config" => {'from' => 'from@example.org'}}
+    expect(Flapjack::RecordQueue).to receive(:new).with('email_notifications',
+      Flapjack::Data::Alert).and_return(queue)
 
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
+    expect(lock).to receive(:synchronize).and_yield
+    expect(queue).to receive(:foreach).and_yield(alert)
+    expect(queue).to receive(:wait).and_raise(Flapjack::PikeletStop)
 
-      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
-      email = Flapjack::Gateways::Email.new(:config => config, :logger => @logger)
-      email.deliver(alert)
-      EM.stop
-    end
-  end
+    check = double(Flapjack::Data::Check)
+    expect(check).to receive(:name).exactly(3).times.and_return('example.com:ping')
+
+    contact = double(Flapjack::Data::Contact)
+    expect(contact).to receive(:name).twice.and_return('John Smith')
+
+    medium = double(Flapjack::Data::Medium)
+    expect(medium).to receive(:contact).twice.and_return(contact)
+    expect(medium).to receive(:address).and_return('johns@example.com')
+
+    expect(alert).to receive(:id).and_return('123456')
+
+    expect(alert).to receive(:medium).exactly(3).times.and_return(medium)
+
+    expect(alert).to receive(:check).exactly(3).times.and_return(check)
+    expect(alert).to receive(:state_title_case).exactly(3).times.and_return('OK')
+    expect(alert).to receive(:condition_duration).twice.and_return(2)
+    expect(alert).to receive(:summary).twice.and_return('smile')
+    expect(alert).to receive(:details).twice.and_return('')
+    expect(alert).to receive(:time).twice.and_return(Time.now)
+
+    expect(alert).to receive(:last_state).twice.and_return( double(Flapjack::Data::State) )
+    expect(alert).to receive(:last_state_title_case).twice.and_return('Critical')
+    expect(alert).to receive(:last_summary).twice.and_return('frown')
+
+    expect(alert).to receive(:notification_type).and_return('recovery')
+    expect(alert).to receive(:type_sentence_case).and_return('Recovery')
+    expect(alert).to receive(:rollup).and_return(nil)
+
+    expect(Mail::TestMailer.deliveries).to be_empty
+
+    config = {"smtp_config" => {'from' => 'from@example.org'}}
+    email_gw = Flapjack::Gateways::Email.new(:lock => lock, :config => config)
+    expect { email_gw.start }.to raise_error(Flapjack::PikeletStop)
+
+    expect(Mail::TestMailer.deliveries.size).to eq(1)
 
-  it "sends a mail with text, html parts and default from address" do
-    entity_check = double(Flapjack::Data::EntityCheck)
-
-    # TODO better checking of what gets passed here
-    expect(EM::P::SmtpClient).to receive(:send).with(
-      hash_including(:host    => 'localhost',
-                     :port    => 25,
-                     :from    => "flapjack@example.com"
-                    )).and_return(client)
-
-    response = double(response)
-    expect(response).to receive(:"respond_to?").with(:code).and_return(true)
-    expect(response).to receive(:code).and_return(250)
-
-    expect(EM::Synchrony).to receive(:sync).with(client).and_return(response)
-
-    notification = {'notification_type'   => 'recovery',
-                    'contact_first_name'  => 'John',
-                    'contact_last_name'   => 'Smith',
-                    'state'               => 'ok',
-                    'state_duration'      => 2,
-                    'summary'             => 'smile',
-                    'last_state'          => 'problem',
-                    'last_summary'        => 'frown',
-                    'time'                => Time.now.to_i,
-                    'event_id'            => 'example.com:ping'}
-
-    EM.synchrony do
-      expect(Flapjack::RedisPool).to receive(:new).and_return(redis)
-
-      alert = Flapjack::Data::Alert.new(notification, :logger => @logger)
-      email = Flapjack::Gateways::Email.new(:config => {}, :logger => @logger)
-      email.instance_variable_set('@fqdn', "example.com")
-      email.deliver(alert)
-      EM.stop
-    end
+    mail = Mail::TestMailer.deliveries.first
+    expect(mail.header['Reply-To'].addresses).to eq(['from@example.org'])
   end
 
 end