flapjack 1.0.0rc3 → 1.0.0rc5

data/lib/flapjack/gateways/web/views/checks.html.erb

@@ -4,7 +4,7 @@
   <h2><%= @adjective.capitalize %> Checks</h2>
 </div>
 
-<p><%= h @count_failing_checks %> failing out of <%= h @count_all_checks %></p>
+<p><%= h @count_failing_checks %> failing out of <%= h @count_current_checks %></p>
 
 <table class="table table-bordered table-hover table-condensed tablesorter">
   <thead>

data/lib/flapjack/gateways/web/views/contact.html.erb

@@ -31,7 +31,11 @@
           <td></td>
           <td></td>
         <% else %>
-          <td><%= h mk.capitalize %></td>
+          <% if 'sms'.eql?(mk) %>
+            <td><%= h mk.upcase %></td>
+          <% else %>
+              <td><%= h mk.capitalize %></td>
+          <% end %>
           <td><%= h mv %></td>
           <td>
             <% if @contact.media_intervals[mk] %>

data/lib/flapjack/gateways/web/views/edit_contacts.html.erb

@@ -90,13 +90,13 @@
     <@- labels[type] @>
   </td>
   <td>
-    <input type="text" data-attr="address" class="form-control" value="<@- address @>">
+    <input type="text" id="<@- labels[type] @>-address" data-attr="address" class="form-control" value="<@- address @>">
   </td>
   <td>
-    <input type="text" data-attr="interval" class="form-control" value="<@- interval @>">
+    <input type="text" id="<@- labels[type] @>-interval" data-attr="interval" class="form-control" value="<@- interval @>">
   </td>
   <td>
-    <input type="text" data-attr="rollup_threshold" class="form-control" value="<@- rollup_threshold @>">
+    <input type="text" id="<@- labels[type] @>-rollup_threshold" data-attr="rollup_threshold" class="form-control <@- labels[type] @>-rollup_threshold" value="<@- rollup_threshold @>">
   </td>
 </script>
 
@@ -171,4 +171,3 @@
 
     </div>
 </div>
-

data/lib/flapjack/gateways/web/views/entities.html.erb

@@ -4,7 +4,7 @@
   <h2><%= h @adjective.capitalize %> Entities</h2>
 </div>
 
-<p><%= h @count_failing_entities %> failing out of <%= h @count_all_entities %></p>
+<p><%= h @count_failing_entities %> failing out of <%= h @count_current_entities %></p>
 
 <% if @entities.length > 0 %>
 <table class="table table-bordered table-hover table-condensed tablesorter">

data/lib/flapjack/gateways/web/views/index.html.erb

@@ -4,5 +4,5 @@
   <h2>Summary</h2>
 </div> <!-- page header -->
 
-<h4><a href="<% @base_url %>entities_failing" title="failing entities"><%= h @count_failing_entities %></a> out of <a href="<% @base_url %>entities_all" title="all entities"><%= h @count_all_entities %></a> entities have failing checks</h4>
-<h4><a href="<% @base_url %>checks_failing" title="failing checks"><%= h @count_failing_checks %></a> out of <a href="<% @base_url %>checks_all" title="all checks"><%= h @count_all_checks %></a> checks are failing</h4>
+<h4><a href="<% @base_url %>entities_failing" title="failing entities"><%= h @count_failing_entities %></a> out of <a href="<% @base_url %>entities" title="all entities"><%= h @count_current_entities %></a> entities have failing checks</h4>
+<h4><a href="<% @base_url %>checks_failing" title="failing checks"><%= h @count_failing_checks %></a> out of <a href="<% @base_url %>checks_all" title="all checks"><%= h @count_current_checks %></a> checks are failing</h4>

data/lib/flapjack/gateways/web/views/layout.erb

@@ -38,10 +38,10 @@
               Summary
             </a>
           </li>
-          <li<%= include_active?('entities_all') %>>
-            <a title="All Entities" href="<%= @base_url %>entities_all">
+          <li<%= include_active?('entities') %>>
+            <a title="Entities" href="<%= @base_url %>entities">
               <i class="fa fa-bullseye fa-lg"></i>
-              All Entities
+              Entities
             </a>
           </li>
           <li<%= include_active?('entities_failing') %>>

data/lib/flapjack/gateways/web/views/self_stats.html.erb

@@ -41,16 +41,16 @@
         <td><%= h @events_queued %></td>
       </tr>
       <tr>
-        <td>Number of entities:</td>
-        <td><%= h @count_all_entities %></td>
+        <td>Number of enabled entities:</td>
+        <td><%= h @count_current_entities %></td>
       </tr>
       <tr>
         <td>Number of failing entities:</td>
         <td><%= h @count_failing_entities %></td>
       </tr>
       <tr>
-        <td>Number of checks:</td>
-        <td><%= h @count_all_checks %></td>
+        <td>Number of enabled checks:</td>
+        <td><%= h @count_current_checks %></td>
       </tr>
       <tr>
         <td>Number of failing checks:</td>
@@ -127,6 +127,5 @@
 <p>
   <a class="btn btn-success" href="<% @base_url %>self_stats.json">View as JSON</a>
   Learn how to
-  <a href="https://github.com/flapjack/flapjack/wiki/Gathering-internal-statistics-with-collectd">
-    use these metrics</a>.
+  <a href="http://flapjack.io/docs/1.0/development/Gathering-internal-statistics-with-collectd"> use these metrics</a>.
 </p>

data/lib/flapjack/notifier.rb

@@ -15,6 +15,7 @@ require 'flapjack/utility'
 
 require 'flapjack/gateways/email'
 require 'flapjack/gateways/sms_messagenet'
+require 'flapjack/gateways/aws_sns'
 
 module Flapjack
 
@@ -50,7 +51,7 @@ module Flapjack
         tz = ActiveSupport::TimeZone.new(tz_string)
       rescue ArgumentError
         logger.error("Invalid timezone string specified in default_contact_timezone or TZ (#{tz_string})")
-        exit 1
+        exit_now!
       end
       @default_contact_timezone = tz
     end
@@ -165,6 +166,8 @@ module Flapjack
         when :email
           # FIXME(@auxesis): change Resque jobs to use raw blpop
           Resque.enqueue_to(@queues['email'], Flapjack::Gateways::Email, contents)
+        when :sns
+          Resque.enqueue_to(@queues['sns'], Flapjack::Gateways::AwsSns, contents)
         else
           @redis.rpush(@queues[media_type.to_s], Oj.dump(contents))
         end

data/lib/flapjack/patches.rb

@@ -127,7 +127,7 @@ module GLI
 
   class GLIOptionParser
     class NormalCommandOptionParser
-      def parse!(parsing_result)
+      def parse!(parsing_result,argument_handling_strategy)
         parsed_command_options = {}
         command = parsing_result.command
         arguments = nil
@@ -146,7 +146,9 @@ module GLI
           command_finder                  = CommandFinder.new(command.commands,command.get_default_command)
           next_command_name               = arguments.shift
 
-          verify_required_options!(command.flags,parsed_command_options[command])
+          gli_major_version, gli_minor_version = GLI::VERSION.split('.')
+          required_options = [command.flags, parsing_result.command, parsed_command_options[command]]
+          verify_required_options!(*required_options)
 
           begin
             command = command_finder.find_command(next_command_name)
@@ -181,6 +183,10 @@ module GLI
         parsing_result.command_options = command_options
         parsing_result.command = command
         parsing_result.arguments = Array(arguments.compact)
+
+        # Lets validate the arguments now that we know for sure the command that is invoked
+        verify_arguments!(parsing_result.arguments, parsing_result.command) if argument_handling_strategy == :strict
+
         parsing_result
       end
     end

data/lib/flapjack/pikelet.rb

@@ -25,6 +25,7 @@ require 'flapjack/gateways/oobetet'
 require 'flapjack/gateways/pagerduty'
 require 'flapjack/gateways/email'
 require 'flapjack/gateways/sms_messagenet'
+require 'flapjack/gateways/aws_sns'
 require 'flapjack/gateways/web'
 require 'flapjack/logger'
 require 'thin/version'
@@ -156,7 +157,8 @@ module Flapjack
     class Resque < Flapjack::Pikelet::Base
 
       PIKELET_TYPES = {'email' => Flapjack::Gateways::Email,
-                       'sms'   => Flapjack::Gateways::SmsMessagenet}
+                       'sms'   => Flapjack::Gateways::SmsMessagenet,
+                       'sns'   => Flapjack::Gateways::AwsSns}
 
       def self.create(type, opts = {})
         self.new(type, PIKELET_TYPES[type], :config => opts[:config],

data/lib/flapjack/version.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
 module Flapjack
-  VERSION = "1.0.0rc3"
+  VERSION = "1.0.0rc5"
 end
 

data/libexec/httpbroker.go

@@ -15,7 +15,7 @@ import (
 
 // State is a basic representation of a Flapjack event, with some extra field.
 // The extra fields handle state expiry.
-// Find more at https://github.com/flapjack/flapjack/wiki/DATA_STRUCTURES
+// Find more at http://flapjack.io/docs/1.0/development/DATA_STRUCTURES
 type State struct {
 	flapjack.Event
 	TTL	int64  `json:"ttl"`

data/spec/lib/flapjack/coordinator_spec.rb

@@ -33,7 +33,7 @@ describe Flapjack::Coordinator do
       and_return(processor)
 
     expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep).and_return {
+    expect(EM::Synchrony).to receive(:sleep) {
       fc.instance_variable_set('@received_signals', ['INT'])
     }
 
@@ -102,7 +102,7 @@ describe Flapjack::Coordinator do
       and_return(notifier)
 
     expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep).and_return {
+    expect(EM::Synchrony).to receive(:sleep) {
       fc.instance_variable_set('@received_signals', ['INT'])
     }
 
@@ -136,7 +136,7 @@ describe Flapjack::Coordinator do
       and_return(processor)
 
     expect(EM).to receive(:stop)
-    expect(EM::Synchrony).to receive(:sleep).and_return {
+    expect(EM::Synchrony).to receive(:sleep) {
       fc.instance_variable_set('@received_signals', ['INT'])
     }
 

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

@@ -27,8 +27,8 @@ describe Flapjack::Data::Contact, :redis => true do
      :tags               => Flapjack::Data::TagSet.new([]),
      :time_restrictions  => [],
      :unknown_media      => [],
-     :warning_media      => ['email', 'sms', 'jabber', 'pagerduty'],
-     :critical_media     => ['email', 'sms', 'jabber', 'pagerduty'],
+     :warning_media      => ['email', 'sms', 'jabber', 'pagerduty', 'sns'],
+     :critical_media     => ['email', 'sms', 'jabber', 'pagerduty', 'sns'],
      :unknown_blackhole  => false,
      :warning_blackhole  => false,
      :critical_blackhole => false}

data/spec/lib/flapjack/data/entity_check_spec.rb

@@ -10,17 +10,28 @@ describe Flapjack::Data::EntityCheck, :redis => true do
   let(:check) { 'ping' }
 
   let(:half_an_hour) { 30 * 60 }
+  let(:t) { Time.now.to_i }
+  let(:five_minutes) { 60 * 5 }
+  let(:five_hours_ago) { t - (60 * 60 * 5) }
+  let(:four_hours_ago) { t - (60 * 60 * 4) }
+  let(:three_hours_ago) { t - (60 * 60 * 3) }
+  let(:two_hours_ago) { t - (60 * 60 * 2) }
+  let(:one_hour) { 60 * 60 }
+  let(:two_hours) { 60 * 60 * 2 }
+  let(:three_hours) { 60 * 60 * 3 }
+  let(:five_hours) { 60 * 60 * 5 }
+  let(:seven_hours) { 60 * 60 * 7 }
 
   before(:each) do
-    Flapjack::Data::Contact.add({'id'         => '362',
-                                 'first_name' => 'John',
-                                 'last_name'  => 'Johnson',
-                                 'email'      => 'johnj@example.com' },
-                                 :redis       => @redis)
-
-    Flapjack::Data::Entity.add({'id'   => '5000',
-                                'name' => name,
-                                'contacts' => ['362']},
+    Flapjack::Data::Contact.add({ 'id'         => '362',
+                                  'first_name' => 'John',
+                                  'last_name'  => 'Johnson',
+                                  'email'      => 'johnj@example.com' },
+                                :redis       => @redis)
+
+    Flapjack::Data::Entity.add({ 'id'   => '5000',
+                                 'name' => name,
+                                 'contacts' => ['362'] },
                                :redis => @redis)
   end
 
@@ -110,9 +121,9 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       t = Time.now.to_i
 
       ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
-      expect(ec.current_maintenance).to eq({:start_time => t,
-                                        :duration => half_an_hour,
-                                        :summary => 'oops'})
+      expect(ec.current_maintenance).to eq(:start_time => t,
+                                           :duration => half_an_hour,
+                                           :summary => 'oops')
     end
 
     it "creates an unscheduled maintenance period" do
@@ -148,7 +159,7 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       later_t = t + (15 * 60)
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
-      Delorean.time_travel_to( Time.at(later_t) )
+      Delorean.time_travel_to(Time.at(later_t))
       ec.create_unscheduled_maintenance(later_t, half_an_hour, :summary => 'spoo')
 
       expect(ec).to be_in_unscheduled_maintenance
@@ -180,6 +191,34 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       expect(duration_curr).to eq(half_an_hour)
     end
 
+    it "creates an unscheduled maintenance period from a human readable time" do
+      Flapjack::Data::EntityCheck.create_maintenance(:redis => @redis, :entity => name, :check => check, :type => 'unscheduled', :started => '14/3/2027 3pm', :duration => '30 minutes', :reason => 'oops')
+      t = Time.local(2027, 3, 14, 15, 0).to_i
+
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      expect(ec).to be_in_unscheduled_maintenance
+
+      umps = ec.maintenances(nil, nil, :scheduled => false)
+      expect(umps).not_to be_nil
+      expect(umps).to be_an(Array)
+      expect(umps.size).to eq(1)
+      expect(umps[0]).to be_a(Hash)
+
+      start_time = umps[0][:start_time]
+      expect(start_time).not_to be_nil
+      expect(start_time).to be_an(Integer)
+      expect(start_time).to eq(t)
+
+      duration = umps[0][:duration]
+      expect(duration).not_to be_nil
+      expect(duration).to be_a(Float)
+      expect(duration).to eq(1800.0)
+
+      summary = @redis.get("#{name}:#{check}:#{t}:unscheduled_maintenance:summary")
+      expect(summary).not_to be_nil
+      expect(summary).to eq('oops')
+    end
+
     it "ends an unscheduled maintenance period", :time => true do
       t = Time.now.to_i
       later_t = t + (15 * 60)
@@ -188,7 +227,7 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
       expect(ec).to be_in_unscheduled_maintenance
 
-      Delorean.time_travel_to( Time.at(later_t) )
+      Delorean.time_travel_to(Time.at(later_t))
       expect(ec).to be_in_unscheduled_maintenance
       ec.end_unscheduled_maintenance(later_t)
       expect(ec).not_to be_in_unscheduled_maintenance
@@ -214,7 +253,7 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(t + (60 * 60),
-        half_an_hour, :summary => "30 minutes")
+                                      half_an_hour, :summary => "30 minutes")
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       expect(smps).not_to be_nil
@@ -238,7 +277,7 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(t - (60 * 60),
-        2 * (60 * 60), :summary => "2 hours")
+                                      2 * (60 * 60), :summary => "2 hours")
 
       smps = ec.maintenances(nil, nil, :scheduled => true)
       expect(smps).not_to be_nil
@@ -257,11 +296,37 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       expect(duration).to eq(2 * (60 * 60))
     end
 
+    it "creates an scheduled maintenance period from a human readable time" do
+      Flapjack::Data::EntityCheck.create_maintenance(:redis => @redis, :entity => name, :check => check, :type => 'scheduled', :started => '14/3/2027 3pm', :duration => '30 minutes', :reason => 'oops')
+      t = Time.local(2027, 3, 14, 15, 0).to_i
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+      smps = ec.maintenances(nil, nil, :scheduled => true)
+      expect(smps).not_to be_nil
+      expect(smps).to be_an(Array)
+      expect(smps.size).to eq(1)
+      expect(smps[0]).to be_a(Hash)
+
+      start_time = smps[0][:start_time]
+      expect(start_time).not_to be_nil
+      expect(start_time).to be_an(Integer)
+      expect(start_time).to eq(t)
+
+      duration = smps[0][:duration]
+      expect(duration).not_to be_nil
+      expect(duration).to be_a(Float)
+      expect(duration).to eq(1800.0)
+
+      summary = @redis.get("#{name}:#{check}:#{t}:scheduled_maintenance:summary")
+      expect(summary).not_to be_nil
+      expect(summary).to eq('oops')
+    end
+
     it "removes a scheduled maintenance period for a future time" do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(t + (60 * 60),
-        2 * (60 * 60), :summary => "2 hours")
+                                      2 * (60 * 60), :summary => "2 hours")
 
       ec.end_scheduled_maintenance(t + (60 * 60))
 
@@ -277,9 +342,9 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(t + (60 * 60),
-        2 * (60 * 60), :summary => "2 hours")
+                                      2 * (60 * 60), :summary => "2 hours")
 
-      Delorean.time_travel_to( Time.at(t + (90 * 60)) )
+      Delorean.time_travel_to(Time.at(t + (90 * 60)))
 
       ec.end_scheduled_maintenance(t + (60 * 60))
 
@@ -295,9 +360,9 @@ describe Flapjack::Data::EntityCheck, :redis => true do
       t = Time.now.to_i
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(t + (60 * 60),
-        2 * (60 * 60), :summary => "2 hours")
+                                      2 * (60 * 60), :summary => "2 hours")
 
-      Delorean.time_travel_to( Time.at(t + (6 * (60 * 60)) ))
+      Delorean.time_travel_to(Time.at(t + (6 * (60 * 60))))
 
       ec.end_scheduled_maintenance(t + (60 * 60))
 
@@ -310,55 +375,742 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     end
 
     it "returns a list of scheduled maintenance periods" do
-      t = Time.now.to_i
-      five_hours_ago = t - (60 * 60 * 5)
-      three_hours_ago = t - (60 * 60 * 3)
-
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_scheduled_maintenance(five_hours_ago, half_an_hour,
-        :summary => "first")
+                                      :summary => "first")
       ec.create_scheduled_maintenance(three_hours_ago, half_an_hour,
-        :summary => "second")
+                                      :summary => "second")
 
       smp = ec.maintenances(nil, nil, :scheduled => true)
       expect(smp).not_to be_nil
       expect(smp).to be_an(Array)
       expect(smp.size).to eq(2)
-      expect(smp[0]).to eq({:start_time => five_hours_ago,
-                        :end_time   => five_hours_ago + half_an_hour,
-                        :duration   => half_an_hour,
-                        :summary    => "first"})
-      expect(smp[1]).to eq({:start_time => three_hours_ago,
-                        :end_time   => three_hours_ago + half_an_hour,
-                        :duration   => half_an_hour,
-                        :summary    => "second"})
+      expect(smp[0]).to eq(:start_time => five_hours_ago,
+                           :end_time   => five_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "first")
+      expect(smp[1]).to eq(:start_time => three_hours_ago,
+                           :end_time   => three_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "second")
     end
 
     it "returns a list of unscheduled maintenance periods" do
-      t = Time.now.to_i
-      five_hours_ago = t - (60 * 60 * 5)
-      three_hours_ago = t - (60 * 60 * 3)
-
       ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
       ec.create_unscheduled_maintenance(five_hours_ago,
-        half_an_hour, :summary => "first")
+                                        half_an_hour, :summary => "first")
       ec.create_unscheduled_maintenance(three_hours_ago,
-        half_an_hour, :summary => "second")
+                                        half_an_hour, :summary => "second")
 
       ump =  ec.maintenances(nil, nil, :scheduled => false)
       expect(ump).not_to be_nil
       expect(ump).to be_an(Array)
       expect(ump.size).to eq(2)
-      expect(ump[0]).to eq({:start_time => five_hours_ago,
-                        :end_time   => five_hours_ago + half_an_hour,
-                        :duration   => half_an_hour,
-                        :summary    => "first"})
-      expect(ump[1]).to eq({:start_time => three_hours_ago,
-                        :end_time   => three_hours_ago + half_an_hour,
-                        :duration   => half_an_hour,
-                        :summary    => "second"})
+      expect(ump[0]).to eq(:start_time => five_hours_ago,
+                           :end_time   => five_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "first")
+      expect(ump[1]).to eq(:start_time => three_hours_ago,
+                           :end_time   => three_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "second")
     end
 
+    it "finds current scheduled maintenance periods for multiple entities" do
+      ec = nil
+
+      %w(alpha lima bravo).each do |entity|
+        Flapjack::Data::Entity.add({ 'name' => entity }, :redis => @redis)
+
+        ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
+        ec.create_scheduled_maintenance(five_hours_ago, seven_hours,
+          :summary => "Test scheduled maintenance for #{entity}")
+      end
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis,
+        :type => 'scheduled', :finishing => 'more than 0 minutes from now').sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(3)
+      %w(alpha bravo lima).each_with_index do |entity, index|
+      expect(smp[index]).to eq(:entity     => entity,
+                               :check      => "ping",
+                               # The state here is nil due to no check having gone
+                               # through for this item.  This is normally 'critical' or 'ok'
+                               :state      => nil,
+                               :start_time => five_hours_ago,
+                               :end_time   => five_hours_ago + seven_hours,
+                               :duration   => seven_hours,
+                               :summary    => "Test scheduled maintenance for #{entity}")
+      end
+    end
+
+  it "finds current unscheduled maintenance periods for multiple entities" do
+      ec = nil
+
+      %w(alpha bravo lima).each do |entity|
+        Flapjack::Data::Entity.add({ 'name' => entity }, :redis => @redis)
+
+        ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
+        ec.create_unscheduled_maintenance(five_hours_ago, seven_hours, :summary => "Test unscheduled maintenance for #{entity}")
+      end
+
+      ump = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'unscheduled', :finishing => 'more than 0 minutes from now').sort_by { |k| k[:entity] }
+
+      expect(ump).not_to be_nil
+      expect(ump).to be_an(Array)
+      expect(ump.size).to eq(3)
+      %w(alpha bravo lima).each_with_index do |entity, index|
+      expect(ump[index]).to eq(:entity     => entity,
+                               :check      => "ping",
+                               # The state here is nil due to no check having gone
+                               # through for this item.  This is normally 'critical' or 'ok'
+                               :state      => nil,
+                               :start_time => five_hours_ago,
+                               :end_time   => five_hours_ago + seven_hours,
+                               :duration   => seven_hours,
+                               :summary    => "Test unscheduled maintenance for #{entity}")
+      end
+    end
+
+    it "finds all scheduled maintenance starting more than 3 hours ago" do
+      ['more than three hours ago', 'before 3 hours ago'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(five_hours_ago, half_an_hour, :summary => "30 minute maintenance")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago + five_minutes, seven_hours, :summary => "Scheduled maintenance started 3 hours ago")
+        ec.create_scheduled_maintenance(four_hours_ago, seven_hours, :summary => "Scheduled maintenance started 4 hours ago")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :started => input).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(2)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => five_hours_ago,
+                             :end_time   => five_hours_ago + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "30 minute maintenance")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => four_hours_ago,
+                             :end_time   => four_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Scheduled maintenance started 4 hours ago")
+      end
+    end
+
+    it "finds all scheduled maintenance starting within the next four hours" do
+      ['less than four hours ago', 'after 4 hours ago'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(five_hours_ago, half_an_hour, :summary => "30 minute maintenance")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago")
+        ec.create_scheduled_maintenance(four_hours_ago, seven_hours, :summary => "Scheduled maintenance started 4 hours ago")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :started => input).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(1)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => three_hours_ago,
+                             :end_time   => three_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Scheduled maintenance started 3 hours ago")
+      end
+    end
+
+    it "finds all scheduled maintenance ending within the next two hours" do
+      ['less than two hours', 'before 2 hours'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago + five_minutes, half_an_hour, :summary => "Scheduled maintenance started 3 hours ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+        ec.create_scheduled_maintenance(five_hours_ago, seven_hours + five_minutes, :summary => "Scheduled maintenance started 5 hours ago")
+        # Current maintenance
+        ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :finishing => input).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(3)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => two_hours_ago + five_minutes,
+                             :end_time   => two_hours_ago + five_minutes + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance started 3 hours ago")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => t,
+                             :end_time   => t + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance started now")
+        expect(smp[2]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => t + five_minutes,
+                             :end_time   => t + five_minutes + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance starting in 5 minutes")
+      end
+    end
+
+    it "finds all scheduled maintenance ending between two times (1 hour ago - 2 hours ago)" do
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago + five_minutes, half_an_hour, :summary => "Scheduled maintenance started 1 hour, 55 minutes ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+        ec.create_scheduled_maintenance(five_hours_ago, three_hours + five_minutes, :summary => "Scheduled maintenance started 5 hours ago")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :finishing => 'between one and two hours ago').sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(2)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => five_hours_ago,
+                             :end_time   => five_hours_ago + three_hours + five_minutes,
+                             :duration   => three_hours + five_minutes,
+                             :summary    => "Scheduled maintenance started 5 hours ago")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => two_hours_ago + five_minutes,
+                             :end_time   => two_hours_ago + five_minutes + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance started 1 hour, 55 minutes ago")
+    end
+
+    it "finds all scheduled maintenance ending between two times (1 hour from now - 2 hours from now)" do
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago + five_minutes, half_an_hour, :summary => "Scheduled maintenance started 1 hour, 55 minutes ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, five_hours - five_minutes, :summary => "Scheduled maintenance started 3 hours ago for 4 hours, 25 minutes")
+        ec.create_scheduled_maintenance(five_hours_ago, three_hours + five_minutes, :summary => "Scheduled maintenance started 5 hours ago")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, one_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :finishing => 'between one and two hours').sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(2)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => three_hours_ago,
+                             :end_time   => three_hours_ago + five_hours - five_minutes,
+                             :duration   => five_hours - five_minutes,
+                             :summary    => "Scheduled maintenance started 3 hours ago for 4 hours, 25 minutes")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => t + five_minutes,
+                             :end_time   => t + five_minutes + one_hour,
+                             :duration   => one_hour,
+                             :summary    => "Scheduled maintenance starting in 5 minutes")
+    end
+
+    it "finds all scheduled maintenance ending in more than two hours" do
+      ['more than two hours', 'after 2 hours'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago, half_an_hour, :summary => "Scheduled maintenance started 2 hours ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+        ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Scheduled maintenance started 5 hours ago")
+        # Current maintenance
+        ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :finishing => input).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(1)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => three_hours_ago,
+                             :end_time   => three_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Scheduled maintenance started 3 hours ago for 7 hours")
+      end
+    end
+
+    it "finds all scheduled maintenance with a duration of less than one hour" do
+      ['less than', 'before'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago, half_an_hour, :summary => "Scheduled maintenance started 3 hours ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+        ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Scheduled maintenance started 5 hours ago")
+        # Current maintenance
+        ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :duration => "#{input} one hour").sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(3)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => two_hours_ago,
+                             :end_time   => two_hours_ago + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance started 3 hours ago")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => t,
+                             :end_time   => t + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance started now")
+        expect(smp[2]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => t + five_minutes,
+                             :end_time   => t + five_minutes + half_an_hour,
+                             :duration   => half_an_hour,
+                             :summary    => "Scheduled maintenance starting in 5 minutes")
+      end
+    end
+
+    it "finds all scheduled maintenance with a duration of 30 minutes" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      # Maintenance in the past, now ended
+      ec.create_scheduled_maintenance(two_hours_ago, half_an_hour, :summary => "Scheduled maintenance started 3 hours ago")
+      # Maintenance started in the past, still running
+      ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+      ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Scheduled maintenance started 5 hours ago")
+      # Current maintenance
+      ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+      # Future maintenance
+      ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :duration => '30 minutes').sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(3)
+
+      expect(smp[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => two_hours_ago,
+                           :end_time   => two_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance started 3 hours ago")
+      expect(smp[1]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t,
+                           :end_time   => t + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance started now")
+      expect(smp[2]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t + five_minutes,
+                           :end_time   => t + five_minutes + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance starting in 5 minutes")
+    end
+
+    it "finds all scheduled maintenance with a duration of between 15 and 65 minutes" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      # Maintenance in the past, now ended
+      ec.create_scheduled_maintenance(two_hours_ago, half_an_hour, :summary => "Scheduled maintenance started 3 hours ago")
+      # Maintenance started in the past, still running
+      ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+      ec.create_scheduled_maintenance(five_hours_ago, one_hour, :summary => "Scheduled maintenance started 5 hours ago")
+      # Current maintenance
+      ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+      # Future maintenance
+      ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :duration => 'between 15 and 65 minutes').sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(4)
+
+      expect(smp[1]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => two_hours_ago,
+                           :end_time   => two_hours_ago + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance started 3 hours ago")
+      expect(smp[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => five_hours_ago,
+                           :end_time   => five_hours_ago + one_hour,
+                           :duration   => one_hour,
+                           :summary    => "Scheduled maintenance started 5 hours ago")
+      expect(smp[2]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t,
+                           :end_time   => t + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance started now")
+      expect(smp[3]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t + five_minutes,
+                           :end_time   => t + five_minutes + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance starting in 5 minutes")
+    end
+
+    it "finds all scheduled maintenance with a duration of more than one hour" do
+      ['more than, after'].each do |input|
+        ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+        # Maintenance in the past, now ended
+        ec.create_scheduled_maintenance(two_hours_ago, half_an_hour, :summary => "Scheduled maintenance started 3 hours ago")
+        # Maintenance started in the past, still running
+        ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Scheduled maintenance started 3 hours ago for 7 hours")
+        ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Scheduled maintenance started 5 hours ago")
+        # Current maintenance
+        ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Scheduled maintenance started now")
+        # Future maintenance
+        ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :duration => "#{input} one hour").sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(2)
+
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => five_hours_ago,
+                             :end_time   => five_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Scheduled maintenance started 5 hours ago")
+        expect(smp[1]).to eq(:entity     => name,
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => three_hours_ago,
+                             :end_time   => three_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Scheduled maintenance started 3 hours ago for 7 hours")
+      end
+    end
+
+    it "finds all scheduled maintenance with a particular entity name" do
+      ['bravo', 'br.*'].each do |input|
+        %w(alpha bravo lima).each do |entity|
+          Flapjack::Data::Entity.add({ 'name' => entity }, :redis => @redis)
+
+          ec = Flapjack::Data::EntityCheck.for_entity_name(entity, check, :redis => @redis)
+          ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Test scheduled maintenance for #{entity}")
+        end
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :entity => input ).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(1)
+        expect(smp[0]).to eq(:entity     => "bravo",
+                             :check      => check,
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => five_hours_ago,
+                             :end_time   => five_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Test scheduled maintenance for bravo")
+      end
+    end
+
+    it "finds all scheduled maintenance with a particular check name" do
+      ['http', 'ht.*'].each do |input|
+        %w(ping http ssh).each do |check|
+          ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+          ec.create_scheduled_maintenance(five_hours_ago, seven_hours, :summary => "Test scheduled maintenance for #{check}")
+        end
+
+        smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :check => input ).sort_by { |k| k[:entity] }
+
+        expect(smp).to be_an(Array)
+        expect(smp.size).to eq(1)
+        expect(smp[0]).to eq(:entity     => name,
+                             :check      => "http",
+                             # The state here is nil due to no check having gone
+                             # through for this item.  This is normally 'critical' or 'ok'
+                             :state      => nil,
+                             :start_time => five_hours_ago,
+                             :end_time   => five_hours_ago + seven_hours,
+                             :duration   => seven_hours,
+                             :summary    => "Test scheduled maintenance for http")
+      end
+    end
+
+    it "finds all scheduled maintenance with a particular summary" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+      # Maintenance started in the past, still running
+      ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Bring me a shrubbery!")
+      # Current maintenance
+      ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Bring me a shrubbery!")
+      # Future maintenance
+      ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :reason => "Bring me a shrubbery!").sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(2)
+
+      expect(smp[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => three_hours_ago,
+                           :end_time   => three_hours_ago + seven_hours,
+                           :duration   => seven_hours,
+                           :summary    => "Bring me a shrubbery!")
+      expect(smp[1]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t,
+                           :end_time   => t + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Bring me a shrubbery!")
+    end
+
+    it "finds all scheduled maintenance with a summary regex" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+      # Maintenance started in the past, still running
+      ec.create_scheduled_maintenance(three_hours_ago, seven_hours, :summary => "Bring me a shrubbery!")
+      # Current maintenance
+      ec.create_scheduled_maintenance(t, half_an_hour, :summary => "Bring me a shrubbery!")
+      # Future maintenance
+      ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled', :reason => '.* shrubbery!').sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(2)
+
+      expect(smp[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => three_hours_ago,
+                           :end_time   => three_hours_ago + seven_hours,
+                           :duration   => seven_hours,
+                           :summary    => "Bring me a shrubbery!")
+      expect(smp[1]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t,
+                           :end_time   => t + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Bring me a shrubbery!")
+    end
+
+    it "deletes scheduled maintenance from list" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      # Current maintenance
+      ec.create_scheduled_maintenance(two_hours_ago, seven_hours, :summary => "Scheduled maintenance started 2 hours ago")
+      ec.create_scheduled_maintenance(t + half_an_hour, half_an_hour, :summary => "Scheduled maintenance starting in half an hour")
+      # Future maintenance
+      ec.create_scheduled_maintenance(t + five_minutes, half_an_hour, :summary => "Scheduled maintenance starting in 5 minutes")
+
+      smp = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled').sort_by { |k| k[:entity] }
+
+      expect(smp).to be_an(Array)
+      expect(smp.size).to eq(3)
+
+      expect(smp[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => two_hours_ago,
+                           :end_time   => two_hours_ago + seven_hours,
+                           :duration   => seven_hours,
+                           :summary    => "Scheduled maintenance started 2 hours ago")
+      expect(smp[1]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t + five_minutes,
+                           :end_time   => t + five_minutes + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance starting in 5 minutes")
+      expect(smp[2]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t + half_an_hour,
+                           :end_time   => t + half_an_hour + half_an_hour,
+                           :duration   => half_an_hour,
+                           :summary    => "Scheduled maintenance starting in half an hour")
+
+      delete = Flapjack::Data::EntityCheck.delete_maintenance(:redis => @redis, :type => 'scheduled', :duration => '30 minutes' )
+      expect(delete).to eq({})
+
+      remain = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'scheduled').sort_by { |k| k[:entity] }
+
+      expect(remain).to be_an(Array)
+      expect(remain.size).to eq(1)
+
+      expect(remain[0]).to eq(:entity     => name,
+                              :check      => check,
+                              # The state here is nil due to no check having gone
+                              # through for this item.  This is normally 'critical' or 'ok'
+                              :state      => nil,
+                              :start_time => two_hours_ago,
+                              :end_time   => two_hours_ago + seven_hours,
+                              :duration   => seven_hours,
+                              :summary    => "Scheduled maintenance started 2 hours ago")
+    end
+
+    it "deletes unscheduled maintenance from list" do
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => "Unscheduled maintenance starting now")
+
+      ump = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'unscheduled').sort_by { |k| k[:entity] }
+      expect(ump).to be_an(Array)
+      expect(ump.size).to eq(1)
+
+      expect(ump[0]).to eq(:entity     => name,
+                              :check      => check,
+                              # The state here is nil due to no check having gone
+                              # through for this item.  This is normally 'critical' or 'ok'
+                              :state      => nil,
+                              :start_time => t,
+                              :duration   => half_an_hour,
+                              :end_time   => t + half_an_hour,
+                              :summary    => "Unscheduled maintenance starting now")
+
+      later_t = t + (15 * 60)
+      Delorean.time_travel_to(Time.at(later_t))
+
+      delete = Flapjack::Data::EntityCheck.delete_maintenance(:redis => @redis, :type => 'unscheduled', :duration => '30 minutes')
+      expect(delete).to eq({})
+
+      remain = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'unscheduled').sort_by { |k| k[:entity] }
+      expect(remain).to be_an(Array)
+      expect(remain.size).to eq(1)
+
+      expect(remain[0]).to eq(:entity     => name,
+                              :check      => check,
+                              # The state here is nil due to no check having gone
+                              # through for this item.  This is normally 'critical' or 'ok'
+                              :state      => nil,
+                              :start_time => t,
+                              :duration   => half_an_hour,
+                              :end_time   => t + half_an_hour,
+                              :summary    => "Unscheduled maintenance starting now")
+    end
+
+    it "shows errors when deleting maintenance in the past" do
+      Flapjack::Data::EntityCheck.create_maintenance(:redis => @redis, :entity => name, :check => check, :type => 'unscheduled', :started => '14/3/1927 3pm', :duration => '30 minutes', :reason => 'Unscheduled maintenance')
+      t = Time.local(1927, 3, 14, 15, 0).to_i
+      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+
+      ump = Flapjack::Data::EntityCheck.find_maintenance(:redis => @redis, :type => 'unscheduled').sort_by { |k| k[:entity] }
+      expect(ump).to be_an(Array)
+      expect(ump.size).to eq(1)
+
+      expect(ump[0]).to eq(:entity     => name,
+                           :check      => check,
+                           # The state here is nil due to no check having gone
+                           # through for this item.  This is normally 'critical' or 'ok'
+                           :state      => nil,
+                           :start_time => t,
+                           :duration   => half_an_hour,
+                           :end_time   => t + half_an_hour,
+                           :summary    => "Unscheduled maintenance")
+
+      delete = Flapjack::Data::EntityCheck.delete_maintenance(:redis => @redis, :type => 'unscheduled', :duration => '30 minutes')
+      expect(delete).to eq({"abc-123:ping:#{t}"=>"Maintenance can't be deleted as it finished in the past"})
+    end
   end
 
   it "returns its state" do
@@ -517,14 +1269,14 @@ describe Flapjack::Data::EntityCheck, :redis => true do
     t = Time.now.to_i
 
     ec.create_scheduled_maintenance(time_before(t, 180),
-      half_an_hour, :summary => "a")
+                                    half_an_hour, :summary => "a")
     ec.create_scheduled_maintenance(time_before(t, 120),
-      half_an_hour, :summary => "b")
+                                    half_an_hour, :summary => "b")
     ec.create_scheduled_maintenance(time_before(t, 60),
-      half_an_hour, :summary => "c")
+                                    half_an_hour, :summary => "c")
 
     sched_maint_periods = ec.maintenances(time_before(t, 150), t,
-      :scheduled => true)
+                                          :scheduled => true)
     expect(sched_maint_periods).not_to be_nil
     expect(sched_maint_periods).to be_an(Array)
     expect(sched_maint_periods.size).to eq(2)