flapjack 1.6.0 → 2.0.0b1

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

@@ -1,173 +0,0 @@
-<%
-  require_css 'select2'
-  require_css 'select2-bootstrap'
-
-  require_js  'underscore'
-  require_js  'jquery-1.10.2'
-  require_js  'backbone'
-  require_js  'backbone.jsonapi'
-  require_js  'bootstrap'
-  require_js  'select2'
-%>
-
-<script type="text/template" id="contact-actions-template">
-  <button class="btn btn-success" id="addContact">
-    Add contact
-  </button>
-</script>
-
-<script type="text/template" id="contact-list-item-template">
-  <td><@- first_name @></td>
-  <td><@- last_name @></td>
-  <td class="actions">
-    <button type="button" class="btn btn-default contact-media" aria-hidden="true">Media</button>
-  </td>
-  <td class="actions">
-    <button type="button" class="btn btn-default contact-entities" aria-hidden="true">Entities</button>
-  </td>
-  <td class="actions">
-    <button type="button" class="btn btn-danger delete-contact">Delete</button>
-  </td>
-</script>
-
-<script type="text/template" id="contact-details-form-template">
-<div class="modal-content">
-  <div class="modal-header">
-    <h4 class="modal-title" id="contactModalLabel"><@- is_new ? 'New' : 'Edit' @> Contact</h4>
-  </div>
-  <div class="modal-body">
-    <form action="<%= @base_url %>contacts" method="post" role="form" class="form-horizontal">
-
-      <div id="contactDetails">
-        <div class="form-group">
-          <label class="col-sm-3 control-label" for="contact_first_name">First name</label>
-          <div class="col-sm-9">
-            <input type="text" autofocus="autofocus" name="contact_first_name" class="form-control" value="<@- first_name @>">
-          </div>
-        </div>
-        <div class="form-group">
-          <label class="col-sm-3 control-label" for="contact_last_name">Last name</label>
-          <div class="col-sm-9">
-            <input type="text" name="contact_last_name" class="form-control" value="<@- last_name @>">
-          </div>
-        </div>
-      </div>
-
-      <div class="modal-footer">
-        <button type="button" class="btn btn-success" id="contactAccept"<@- is_valid ? '' : ' disabled="disabled"' @>><@- is_new ? 'Create' : 'Update' @></button>
-        <button type="button" class="btn btn-cancel" id="contactCancel">Cancel</button>
-      </div>
-    </form>
-  </div>
-</div>
-</script>
-
-<script type="text/template" id="contact-media-template">
-<div class="modal-content">
-  <div class="modal-header">
-    <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
-    <h4 class="modal-title" id="contactModalLabel">Media for <@- first_name @> <@- last_name @></h4>
-  </div>
-  <div class="modal-body">
-    <table class="table">
-      <thead>
-        <tr>
-          <th style="width: 15%">Media</th>
-          <th style="width: 65%">Address</th>
-          <th style="width: 10%">Interval</th>
-          <th style="width: 10%">Rollup</th>
-        </tr>
-      </thead>
-      <tbody id="contactMediaList">
-      </tbody>
-    </table>
-  </div>
-</div>
-</script>
-
-<script type="text/template" id="contact-media-list-item-template">
-  <td>
-    <@- labels[type] @>
-  </td>
-  <td>
-    <input type="text" id="<@- labels[type] @>-address" data-attr="address" class="form-control" value="<@- address @>">
-  </td>
-  <td>
-    <input type="text" id="<@- labels[type] @>-interval" data-attr="interval" class="form-control" value="<@- interval @>">
-  </td>
-  <td>
-    <input type="text" id="<@- labels[type] @>-rollup_threshold" data-attr="rollup_threshold" class="form-control <@- labels[type] @>-rollup_threshold" value="<@- rollup_threshold @>">
-  </td>
-</script>
-
-<script type="text/template" id="contact-entities-template">
-<div class="modal-content">
-  <div class="modal-header">
-    <button type="button" class="close" data-dismiss="modal" aria-hidden="true">&times;</button>
-    <h4 class="modal-title" id="contactModalLabel">Entities for <@- first_name @> <@- last_name @></h4>
-  </div>
-  <div class="modal-body">
-    <div id="contactEntityChooser">
-    </div>
-
-    <table class="table" style="margin-top: 1em; width: 100%">
-      <thead>
-        <tr>
-          <th style="width: 90%">Entities</th>
-          <th>&nbsp;</th>
-        </tr>
-      </thead>
-      <tbody id="contactEntityList">
-      </tbody>
-    </table>
-  </div>
-</div><!-- /.modal-content -->
-</script>
-
-<script type="text/template" id="contact-entities-chooser-template">
-<input type="hidden" id="entityChooser" style="width: 440px">
-<button id="add-contact-entity" type="button" class="btn btn-default btn-xs">
-  <i class="fa fa-plus-square"></i>
-  &nbsp;
-  Add Entities
-</button>
-</script>
-
-<script type="text/template" id="contact-entities-list-item-template">
-  <td><@- name @></td>
-  <td><button type="button" class="close btn delete delete-entity" aria-hidden="true">&minus;</button></td>
-</script>
-
-<%
-  require_js  'flapjack'
-
-  require_js  'modules/contact'
-  require_js  'modules/entity'
-  require_js  'modules/medium'
-%>
-
-<div id="data-api-url" data-api-url="<%= @api_url %>">
-  <div class="page-header">
-    <h2>Edit Contacts</h2>
-  </div>
-  <div id="container">
-    <table class="table">
-      <thead>
-        <tr>
-          <th>First Name</th>
-          <th>Last Name</th>
-          <th colspan="3">Actions</th>
-        </tr>
-      </thead>
-      <tbody id="contactList">
-      </tbody>
-    </table>
-
-    <!-- Modal -->
-    <div class="modal fade" id="contactModal" tabindex="-1" role="dialog" aria-labelledby="contactModalLabel" aria-hidden="true">
-      <div class="modal-dialog">
-      </div><!-- /.modal-dialog -->
-    </div><!-- /.modal -->
-
-    </div>
-</div>

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

@@ -1,30 +0,0 @@
-<% if @auto_refresh %>
-<meta http-equiv="refresh" content="<%= @auto_refresh %>" >
-<% end %>
-<% page_title "#{@adjective.capitalize} Entities" %>
-
-<div class="page-header">
-  <h2><%= h @adjective.capitalize %> Entities</h2>
-</div>
-
-<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">
-  <thead>
-    <tr>
-      <th data-placeholder="e.g. app[1-3]*">Entity</th>
-    </tr>
-  </thead>
-  <tbody>
-    <% @entities.sort.each do |entity| %>
-      <tr>
-        <td><a href="<%= @base_url %>entity/<%= CGI.escape(entity) %>"><%= h entity %></a>
-        </td>
-      </tr>
-    <% end %>
-  </tbody>
-</table>
-<% else %>
-  <p>No check output has been processed yet, so there are no entities we can show you here.</p>
-<% end %>

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

@@ -1,51 +0,0 @@
-<% if @auto_refresh %>
-<meta http-equiv="refresh" content="<%= @auto_refresh %>" >
-<% end %>
-<% page_title "#{h(@entity)} (entity)" %>
-
-<div class="page-header">
-  <h2><%= h @entity %></h2>
-</div>
-<% if @states.empty? %>
-  <div>
-    <p>This entity has no check output associated with it</p>
-  </div>
-<% else %>
-  <table class="table table-bordered table-hover table-condensed">
-    <tr>
-      <th>Check</th>
-      <th>State</th>
-      <th>Summary</th>
-      <th>Last State Change</th>
-      <th>Last Update</th>
-      <th>Last Notification</th>
-    </tr>
-    <% @states.each do |check, status, summary, changed, updated, in_unscheduled_outage, in_scheduled_outage, notified| %>
-      <%
-        row_colour = case status
-        when 'critical', 'unknown'
-          'danger'
-        when 'ok', 'up'
-          'success'
-        else
-          status
-        end
-
-        check_link = @base_url + "check?entity=" << u(@entity) << "&amp;check=" << u(check)
-
-      %>
-      <tr class="<%= row_colour %>">
-        <td><a href="<%= check_link %>" title="check detail"><%= h check %></a></td>
-        <td class="<%= status %>">
-          <%= h status.upcase %>
-          <% if in_unscheduled_outage%> (Ack'd)<% end %>
-          <% if in_scheduled_outage %> (Sched)<% end %>
-        </td>
-        <td><%= h summary %></td>
-        <td><%= h changed %></td>
-        <td><%= h updated %></td>
-        <td><%= h notified %></td>
-      </tr>
-    <% end %>
-  </table>
-<% end %>

data/lib/flapjack/rack_logger.rb

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-
-module Flapjack
-
-  class CommonLogger < Rack::CommonLogger
-
-    alias_method :orig_log, :log
-
-    private
-
-    def log(env, status, header, began_at)
-      ret = orig_log(env, status, header, began_at)
-      @logger.flush if @logger.is_a?(Flapjack::AsyncLogger)
-      ret
-    end
-
-  end
-
-  # from http://stackoverflow.com/questions/6427033/how-do-i-log-asynchronous-thinsinatrarack-requests
- class AsyncLogger < ::Logger
-
-    attr_accessor :messages
-
-    def initialize(logdev, shift_age = 0, shift_size = 1048576)
-      @messages = {}
-      super(logdev, shift_age, shift_size)
-    end
-
-    def write(message)
-      stack << message
-    end
-
-    def stack
-      # This is the important async awareness
-      # It stores messages for each fiber separately
-      @messages[Fiber.current.object_id] ||= []
-    end
-
-    def flush
-      stack.each do |msg|
-        self.send(:"<<", msg)
-      end
-      @messages.delete(Fiber.current.object_id)
-    end
-  end
-
-end

data/lib/flapjack/redis_pool.rb

@@ -1,42 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'eventmachine'
-# the redis/synchrony gems need to be required in this particular order, see
-# the redis-rb README for details
-require 'hiredis'
-require 'em-synchrony'
-require 'redis/connection/synchrony'
-require 'redis'
-
-require 'em-synchrony/connection_pool'
-
-require 'flapjack/data/migration'
-
-module Flapjack
-  class RedisPool < EventMachine::Synchrony::ConnectionPool
-
-    def initialize(opts = {})
-      config = opts.delete(:config)
-      @size  = opts[:size] || 5
-      logger = opts[:logger]
-      super(:size => @size) {
-        redis = ::Redis.new(config)
-        Flapjack::Data::Migration.correct_notification_rule_contact_linkages(:redis => redis,
-          :logger => logger)
-        Flapjack::Data::Migration.migrate_entity_check_data_if_required(:redis => redis,
-          :logger => logger)
-        Flapjack::Data::Migration.create_entity_ids_if_required(:redis => redis,
-          :logger => logger)
-        Flapjack::Data::Migration.clear_orphaned_entity_ids(:redis => redis,
-          :logger => logger)
-        Flapjack::Data::Migration.refresh_archive_index(:redis => redis)
-        Flapjack::Data::Migration.validate_scheduled_maintenance_periods(:redis => redis,
-          :logger => logger)
-        Flapjack::Data::Migration.correct_rollup_including_disabled_checks(:redis => redis,
-          :logger => logger)
-        redis
-      }
-    end
-
-  end
-end

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

@@ -1,1418 +0,0 @@
-require 'spec_helper'
-
-require 'flapjack/data/entity_check'
-
-describe Flapjack::Data::EntityCheck, :redis => true do
-
-  let(:name)  { 'abc-123' }
-  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'] },
-                               :redis => @redis)
-  end
-
-  it "is created for an event id" do
-    ec = Flapjack::Data::EntityCheck.for_event_id("#{name}:ping", :redis => @redis)
-    expect(ec).not_to be_nil
-    expect(ec.entity).not_to be_nil
-    expect(ec.entity.name).not_to be_nil
-    expect(ec.entity.name).to eq(name)
-    expect(ec.check).not_to be_nil
-    expect(ec.check).to eq('ping')
-  end
-
-  it "is created for an entity name" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, 'ping', :redis => @redis)
-    expect(ec).not_to be_nil
-    expect(ec.entity).not_to be_nil
-    expect(ec.entity.name).not_to be_nil
-    expect(ec.entity.name).to eq(name)
-    expect(ec.check).not_to be_nil
-    expect(ec.check).to eq('ping')
-  end
-
-  it "is created for an entity id" do
-    ec = Flapjack::Data::EntityCheck.for_entity_id(5000, 'ping', :redis => @redis)
-    expect(ec).not_to be_nil
-    expect(ec.entity).not_to be_nil
-    expect(ec.entity.name).not_to be_nil
-    expect(ec.entity.name).to eq(name)
-    expect(ec.check).not_to be_nil
-    expect(ec.check).to eq('ping')
-  end
-
-  it "is created for an entity object" do
-    e = Flapjack::Data::Entity.find_by_name(name, :redis => @redis)
-    ec = Flapjack::Data::EntityCheck.for_entity(e, 'ping', :redis => @redis)
-    expect(ec).not_to be_nil
-    expect(ec.entity).not_to be_nil
-    expect(ec.entity.name).not_to be_nil
-    expect(ec.entity.name).to eq(name)
-    expect(ec.check).not_to be_nil
-    expect(ec.check).to eq('ping')
-  end
-
-  it "is not created for a missing entity" do
-    expect {
-      Flapjack::Data::EntityCheck.for_entity(nil, 'ping', :redis => @redis)
-    }.to raise_error
-  end
-
-  it "raises an error if not created with a redis connection handle" do
-    expect {
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, 'ping')
-    }.to raise_error
-  end
-
-  it 'registers with current_checks and current_entities if explicitly added' do
-    expect(@redis.zrange("current_checks:#{name}", 0, -1)).to eq([])
-    expect(@redis.zrange("current_entities", 0, -1)).to eq([])
-
-    check_data = {'entity_id' => '5000',
-                  'name'      => 'ssh'}
-
-    Flapjack::Data::EntityCheck.add(check_data, :redis => @redis)
-
-    expect(@redis.zrange("current_checks:#{name}", 0, -1)).to eq(["ssh"])
-    expect(@redis.zrange("current_entities", 0, -1)).to eq([name])
-  end
-
-  it 'creates tags if passed when explicitly added' do
-    check_data = {'entity_id' => '5000',
-                  'name'      => 'ssh',
-                  'tags'      => ['virtual', 'staging']}
-
-    Flapjack::Data::EntityCheck.add(check_data, :redis => @redis)
-
-    entity_check = Flapjack::Data::EntityCheck.for_event_id("#{name}:ssh", :redis => @redis)
-    expect(entity_check).not_to be_nil
-    expect(entity_check.tags).to eq(Set.new(['abc-123', 'ssh', 'virtual', 'staging']))
-  end
-
-  it "adds tags to checks" do
-    entity_check = Flapjack::Data::EntityCheck.for_entity_name(name, 'ping', :redis => @redis)
-
-    entity_check.add_tags('source:foobar', 'foo')
-
-    expect(entity_check.tags).to include("source:foobar")
-    expect(entity_check.tags).to include("foo")
-
-    # and test the tags as read back from redis
-    entity_check = Flapjack::Data::EntityCheck.for_event_id("#{name}:ping", :redis => @redis)
-    expect(entity_check.tags).to include("source:foobar")
-    expect(entity_check.tags).to include("foo")
-  end
-
-  it "deletes tags from checks" do
-    entity_check = Flapjack::Data::EntityCheck.for_entity_name(name, 'ping', :redis => @redis)
-
-    entity_check.add_tags('source:foobar', 'foo')
-
-    expect(entity_check.tags).to include("source:foobar")
-    expect(entity_check.tags).to include("foo")
-
-    entity_check.delete_tags('source:foobar')
-
-    # and test the tags as read back from redis
-    entity_check = Flapjack::Data::EntityCheck.for_event_id("#{name}:ping", :redis => @redis)
-    expect(entity_check.tags).not_to include("source:foobar")
-    expect(entity_check.tags).to include("foo")
-  end
-
-  context "maintenance" do
-
-    it "returns that it is in unscheduled maintenance" do
-      @redis.set("#{name}:#{check}:unscheduled_maintenance", Time.now.to_i.to_s)
-
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      expect(ec).to be_in_unscheduled_maintenance
-    end
-
-    it "returns that it is not in unscheduled maintenance" do
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      expect(ec).not_to be_in_unscheduled_maintenance
-    end
-
-    it "returns that it is in scheduled maintenance" do
-      @redis.set("#{name}:#{check}:scheduled_maintenance", Time.now.to_i.to_s)
-
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      expect(ec).to be_in_scheduled_maintenance
-    end
-
-    it "returns that it is not in scheduled maintenance" do
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      expect(ec).not_to be_in_scheduled_maintenance
-    end
-
-    it "returns its current maintenance period" do
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      expect(ec.current_maintenance(:scheduled => true)).to be_nil
-
-      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')
-    end
-
-    it "creates an unscheduled maintenance period" do
-      t = Time.now.to_i
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_unscheduled_maintenance(t, half_an_hour, :summary => 'oops')
-
-      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(half_an_hour)
-
-      summary = @redis.get("#{name}:#{check}:#{t}:unscheduled_maintenance:summary")
-      expect(summary).not_to be_nil
-      expect(summary).to eq('oops')
-    end
-
-    it "creates an unscheduled maintenance period and ends the current one early", :time => true do
-      t = Time.now.to_i
-      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))
-      ec.create_unscheduled_maintenance(later_t, half_an_hour, :summary => 'spoo')
-
-      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(2)
-      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(15 * 60)
-
-      start_time_curr = umps[1][:start_time]
-      expect(start_time_curr).not_to be_nil
-      expect(start_time_curr).to be_an(Integer)
-      expect(start_time_curr).to eq(later_t)
-
-      duration_curr = umps[1][:duration]
-      expect(duration_curr).not_to be_nil
-      expect(duration_curr).to be_a(Float)
-      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)
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-      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))
-      expect(ec).to be_in_unscheduled_maintenance
-      ec.end_unscheduled_maintenance(later_t)
-      expect(ec).not_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(15 * 60)
-    end
-
-    it "creates 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),
-                                      half_an_hour, :summary => "30 minutes")
-
-      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 + (60 * 60))
-
-      duration = smps[0][:duration]
-      expect(duration).not_to be_nil
-      expect(duration).to be_a(Float)
-      expect(duration).to eq(half_an_hour)
-    end
-
-    it "creates a scheduled maintenance period covering the current 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")
-
-      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 - (60 * 60))
-
-      duration = smps[0][:duration]
-      expect(duration).not_to be_nil
-      expect(duration).to be_a(Float)
-      expect(duration).to eq(2 * (60 * 60))
-
-      ttl = @redis.ttl("#{name}:#{check}:scheduled_maintenance")
-      expect(ttl).to be_within(20).of(60 * 60) # 20-second margin of error,
-      # should be large enough for a slow machine running the test -- duration
-      # is considered to start at the begininng of the period
-    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")
-
-      ec.end_scheduled_maintenance(t + (60 * 60))
-
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      expect(smps).not_to be_nil
-      expect(smps).to be_an(Array)
-      expect(smps).to be_empty
-    end
-
-    # maint period starts an hour from now, goes for two hours -- at 30 minutes into
-    # it we stop it, and its duration should be 30 minutes
-    it "shortens a scheduled maintenance period covering a current time", :time => 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")
-
-      Delorean.time_travel_to(Time.at(t + (90 * 60)))
-
-      ec.end_scheduled_maintenance(t + (60 * 60))
-
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      expect(smps).not_to be_nil
-      expect(smps).to be_an(Array)
-      expect(smps).not_to be_empty
-      expect(smps.size).to eq(1)
-      expect(smps.first[:duration]).to eq(30 * 60)
-    end
-
-    it "does not alter or remove a scheduled maintenance period covering a past time", :time => 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")
-
-      Delorean.time_travel_to(Time.at(t + (6 * (60 * 60))))
-
-      ec.end_scheduled_maintenance(t + (60 * 60))
-
-      smps = ec.maintenances(nil, nil, :scheduled => true)
-      expect(smps).not_to be_nil
-      expect(smps).to be_an(Array)
-      expect(smps).not_to be_empty
-      expect(smps.size).to eq(1)
-      expect(smps.first[:duration]).to eq(2 * (60 * 60))
-    end
-
-    it "returns a list of scheduled maintenance periods" do
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_scheduled_maintenance(five_hours_ago, half_an_hour,
-                                      :summary => "first")
-      ec.create_scheduled_maintenance(three_hours_ago, half_an_hour,
-                                      :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")
-    end
-
-    it "returns a list of unscheduled maintenance periods" do
-      ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-      ec.create_unscheduled_maintenance(five_hours_ago,
-                                        half_an_hour, :summary => "first")
-      ec.create_unscheduled_maintenance(three_hours_ago,
-                                        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")
-    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
-    @redis.hset("check:#{name}:#{check}", 'state', 'ok')
-
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    state = ec.state
-    expect(state).not_to be_nil
-    expect(state).to eq('ok')
-  end
-
-  it "updates state" do
-    @redis.hset("check:#{name}:#{check}", 'state', 'ok')
-
-    old_timestamp = @redis.hget("check:#{name}:#{check}", 'last_update')
-
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    ec.update_state('critical')
-
-    state = @redis.hget("check:#{name}:#{check}", 'state')
-    expect(state).not_to be_nil
-    expect(state).to eq('critical')
-
-    new_timestamp = @redis.hget("check:#{name}:#{check}", 'last_update')
-    expect(new_timestamp).not_to eq(old_timestamp)
-  end
-
-  it "updates enabled checks" do
-    ts = Time.now.to_i
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    # was check.last_update=
-    @redis.hset("check:#{name}:#{check}", 'last_update', ts)
-    @redis.zadd("all_checks", ts, @key)
-    @redis.zadd("all_checks:#{name}", ts, check)
-    @redis.zadd("current_checks:#{name}", ts, check)
-    @redis.zadd('current_entities', ts, name)
-
-    saved_check_ts = @redis.zscore("current_checks:#{name}", check)
-    expect(saved_check_ts).not_to be_nil
-    expect(saved_check_ts).to eq(ts)
-    saved_entity_ts = @redis.zscore("current_entities", name)
-    expect(saved_entity_ts).not_to be_nil
-    expect(saved_entity_ts).to eq(ts)
-  end
-
-  it "exposes that it is enabled" do
-    @redis.zadd("current_checks:#{name}", Time.now.to_i, check)
-    @redis.zadd("current_entities", Time.now.to_i, name)
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    e = ec.enabled?
-    expect(e).to be true
-  end
-
-  it "exposes that it is disabled" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    e = ec.enabled?
-    expect(e).to be false
-  end
-
-  it "disables checks" do
-    @redis.zadd("current_checks:#{name}", Time.now.to_i, check)
-    @redis.zadd("current_entities", Time.now.to_i, name)
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    ec.disable!
-
-    saved_check_ts = @redis.zscore("current_checks:#{name}", check)
-    saved_entity_ts = @redis.zscore("current_entities", name)
-    expect(saved_check_ts).to be_nil
-    expect(saved_entity_ts).to be_nil
-  end
-
-  it "does not update state with invalid value" do
-    @redis.hset("check:#{name}:#{check}", 'state', 'ok')
-
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    ec.update_state('silly')
-
-    state = @redis.hget("check:#{name}:#{check}", 'state')
-    expect(state).not_to be_nil
-    expect(state).to eq('ok')
-  end
-
-  it "does not update state with a repeated state value" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    ec.update_state('critical', :summary => 'small problem', :details => 'none')
-    changed_at = @redis.hget("check:#{name}:#{check}", 'last_change')
-    summary = ec.summary
-    details = ec.details
-
-    ec.update_state('critical', :summary => 'big problem', :details => 'some')
-    new_changed_at = @redis.hget("check:#{name}:#{check}", 'last_change')
-    new_summary = ec.summary
-    new_details = ec.details
-
-    expect(changed_at).not_to be_nil
-    expect(new_changed_at).not_to be_nil
-    expect(new_changed_at).to eq(changed_at)
-
-    expect(summary).not_to be_nil
-    expect(new_summary).not_to be_nil
-    expect(new_summary).not_to eq(summary)
-    expect(summary).to eq('small problem')
-    expect(new_summary).to eq('big problem')
-
-    expect(details).not_to be_nil
-    expect(new_details).not_to be_nil
-    expect(new_details).not_to eq(details)
-    expect(details).to eq('none')
-    expect(new_details).to eq('some')
-  end
-
-  def time_before(t, min, sec = 0)
-    t - ((60 * min) + sec)
-  end
-
-  it "returns a list of historical states for a time range" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    t = Time.now.to_i
-    ec.update_state('ok', :timestamp => time_before(t, 5), :summary => 'a')
-    ec.update_state('critical', :timestamp => time_before(t, 4), :summary => 'b')
-    ec.update_state('ok', :timestamp => time_before(t, 3), :summary => 'c')
-    ec.update_state('critical', :timestamp => time_before(t, 2), :summary => 'd')
-    ec.update_state('ok', :timestamp => time_before(t, 1), :summary => 'e')
-
-    states = ec.historical_states(time_before(t, 4), t)
-    expect(states).not_to be_nil
-    expect(states).to be_an(Array)
-    expect(states.size).to eq(4)
-    expect(states[0][:summary]).to eq('b')
-    expect(states[1][:summary]).to eq('c')
-    expect(states[2][:summary]).to eq('d')
-    expect(states[3][:summary]).to eq('e')
-  end
-
-  it "returns a list of historical unscheduled maintenances for a time range" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    t = Time.now.to_i
-    ec.update_state('ok', :timestamp => time_before(t, 5), :summary => 'a')
-    ec.update_state('critical', :timestamp => time_before(t, 4), :summary => 'b')
-    ec.update_state('ok', :timestamp => time_before(t, 3), :summary => 'c')
-    ec.update_state('critical', :timestamp => time_before(t, 2), :summary => 'd')
-    ec.update_state('ok', :timestamp => time_before(t, 1), :summary => 'e')
-
-    states = ec.historical_states(time_before(t, 4), t)
-    expect(states).not_to be_nil
-    expect(states).to be_an(Array)
-    expect(states.size).to eq(4)
-    expect(states[0][:summary]).to eq('b')
-    expect(states[1][:summary]).to eq('c')
-    expect(states[2][:summary]).to eq('d')
-    expect(states[3][:summary]).to eq('e')
-  end
-
-  it "returns a list of historical scheduled maintenances for a time range" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    t = Time.now.to_i
-
-    ec.create_scheduled_maintenance(time_before(t, 180),
-                                    half_an_hour, :summary => "a")
-    ec.create_scheduled_maintenance(time_before(t, 120),
-                                    half_an_hour, :summary => "b")
-    ec.create_scheduled_maintenance(time_before(t, 60),
-                                    half_an_hour, :summary => "c")
-
-    sched_maint_periods = ec.maintenances(time_before(t, 150), t,
-                                          :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)
-    expect(sched_maint_periods[0][:summary]).to eq('b')
-    expect(sched_maint_periods[1][:summary]).to eq('c')
-  end
-
-  it "returns that it has failed" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'warning')
-    expect(ec).to be_failed
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'critical')
-    expect(ec).to be_failed
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'unknown')
-    expect(ec).to be_failed
-  end
-
-  it "returns that it has not failed" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'ok')
-    expect(ec).not_to be_failed
-
-    @redis.hset("check:#{name}:#{check}", 'state', 'acknowledgement')
-    expect(ec).not_to be_failed
-  end
-
-  it "returns a status summary" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-
-    t = Time.now.to_i
-    ec.update_state('ok', :timestamp => time_before(t, 5), :summary => 'a')
-    ec.update_state('critical', :timestamp => time_before(t, 4), :summary => 'b')
-    ec.update_state('ok', :timestamp => time_before(t, 3), :summary => 'c')
-    ec.update_state('critical', :timestamp => time_before(t, 2), :summary => 'd')
-
-    summary = ec.summary
-    expect(summary).to eq('d')
-  end
-
-  it "returns timestamps for its last notifications" do
-    t = Time.now.to_i
-    @redis.set("#{name}:#{check}:last_problem_notification", t - 30)
-    @redis.set("#{name}:#{check}:last_acknowledgement_notification", t - 15)
-    @redis.set("#{name}:#{check}:last_recovery_notification", t)
-
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    expect(ec.last_notification_for_state(:problem)[:timestamp]).to eq(t - 30)
-    expect(ec.last_notification_for_state(:acknowledgement)[:timestamp]).to eq(t - 15)
-    expect(ec.last_notification_for_state(:recovery)[:timestamp]).to eq(t)
-  end
-
-  it "finds all related contacts" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
-    contacts = ec.contacts
-    expect(contacts).not_to be_nil
-    expect(contacts).to be_an(Array)
-    expect(contacts.size).to eq(1)
-    expect(contacts.first.name).to eq('John Johnson')
-  end
-
-  it "generates ephemeral tags for itself" do
-    ec = Flapjack::Data::EntityCheck.for_entity_name('foo-app-01.example.com', 'Disk / Utilisation', :create_entity => true, :redis => @redis)
-    tags = ec.tags
-    expect(tags).not_to be_nil
-    expect(tags).to be_a(Set)
-    expect(['foo-app-01', 'example.com', 'disk', '/', 'utilisation'].to_set.subset?(tags)).to be true
-  end
-
-  it "returns unacknowledged failing checks"
-
-end