flapjack 0.5.5 → 0.6.23

data/spec/lib/flapjack/api/entity_check_presenter_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'flapjack/api/entity_check_presenter'
+
+# require 'flapjack/data/entity'
+# require 'flapjack/data/entity_check'
+
+describe 'Flapjack::API::EntityCheck::Presenter' do
+
+  let(:entity_check) { mock(Flapjack::Data::EntityCheck) }
+
+  let(:time) { Time.now.to_i }
+
+  let(:states) {
+    [{:state => 'critical', :timestamp => time - (4 * 60 * 60)},
+     {:state => 'ok',       :timestamp => time - (4 * 60 * 60) + (5 * 60)},
+     {:state => 'critical', :timestamp => time - (3 * 60 * 60)},
+     {:state => 'ok',       :timestamp => time - (3 * 60 * 60) + (10 * 60)},
+     {:state => 'critical', :timestamp => time - (2 * 60 * 60)},
+     {:state => 'ok',       :timestamp => time - (2 * 60 * 60) + (15 * 60)},
+     {:state => 'critical', :timestamp => time - (1 * 60 * 60)},
+     {:state => 'ok',       :timestamp => time - (1 * 60 * 60) + (20 * 60)}
+    ]
+  }
+
+  # one overlap at start, one overlap at end, one wholly overlapping,
+  # one wholly contained
+  let(:maintenances) {
+    [{:start_time => time - ((4 * 60 * 60) + (1 * 60)), # 1 minute before outage starts
+      :end_time   => time - (4 * 60 * 60) + (2 * 60),   # 2 minutes after outage starts
+      :duration => (3 * 60)},
+     {:start_time => time - (3 * 60 * 60) + (8 * 60),   # 2 minutes before outage ends
+      :end_time   => time - (3 * 60 * 60) + (11 * 60),  # 1 minute after outage ends
+      :duration => (3 * 60)},
+     {:start_time => time - ((2 * 60 * 60) + (1 * 60)), # 1 minute before outage starts
+      :end_time   => time - (2 * 60 * 60) + (17 * 60),  # 2 minutes after outage ends
+      :duration => (3 * 60)},
+     {:start_time => time - (1 * 60 * 60) + (1 * 60),   # 1 minute after outage starts
+      :end_time   => time - (1 * 60 * 60) + (10 * 60),  # 10 minutes before outage ends
+      :duration => (9 * 60)}
+    ]
+  }
+
+  it "returns a list of outage hashes for an entity check" do
+    entity_check.should_receive(:historical_states).
+      with(time - (5 * 60 * 60), time - (2 * 60 * 60)).and_return(states)
+
+    entity_check.should_receive(:historical_state_before).
+      with(time - (4 * 60 * 60)).and_return(nil)
+
+    ecp = Flapjack::API::EntityCheckPresenter.new(entity_check)
+    outages = ecp.outages(time - (5 * 60 * 60), time - (2 * 60 * 60))
+    outages.should_not be_nil
+    outages.should be_an(Array)
+    outages.should have(4).time_ranges
+
+    # TODO check the data in those hashes
+  end
+
+  it "a list of unscheduled maintenances for an entity check" do
+    entity_check.should_receive(:maintenances).
+      with(time - (12 * 60 * 60), time, :scheduled => false).and_return(maintenances)
+
+    entity_check.should_receive(:maintenances).
+      with(nil, time - (12 * 60 * 60), :scheduled => false).and_return([])
+
+    ecp = Flapjack::API::EntityCheckPresenter.new(entity_check)
+    unsched_maint = ecp.unscheduled_maintenance(time - (12 * 60 * 60), time)
+
+    unsched_maint.should be_an(Array)
+    unsched_maint.should have(4).time_ranges
+
+    # TODO check the data in those hashes
+  end
+
+  it "a list of scheduled maintenances for an entity check" do
+    entity_check.should_receive(:maintenances).
+      with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
+
+    entity_check.should_receive(:maintenances).
+      with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
+
+    ecp = Flapjack::API::EntityCheckPresenter.new(entity_check)
+    sched_maint = ecp.scheduled_maintenance(time - (12 * 60 * 60), time)
+
+    sched_maint.should be_an(Array)
+    sched_maint.should have(4).time_ranges
+
+    # TODO check the data in those hashes
+  end
+
+  it "returns downtime and percentage for an entity check" do
+    entity_check.should_receive(:historical_states).
+      with(time - (12 * 60 * 60), time).and_return(states)
+
+    entity_check.should_receive(:historical_state_before).
+      with(time - (4 * 60 * 60)).and_return(nil)
+
+    entity_check.should_receive(:maintenances).
+      with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
+
+    entity_check.should_receive(:maintenances).
+      with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
+
+    ecp = Flapjack::API::EntityCheckPresenter.new(entity_check)
+    downtimes = ecp.downtime(time - (12 * 60 * 60), time)
+
+    # 22 minutes, 3 + 8 + 11
+    downtimes.should be_a(Hash)
+    downtimes[:total_seconds].should == (22 * 60)
+    downtimes[:percentage].should == (((22 * 60) * 100) / (12 * 60 * 60))
+    downtimes[:downtime].should be_an(Array)
+    # the last outage gets split by the intervening maintenance period,
+    # but the fully covered one gets removed.
+    downtimes[:downtime].should have(4).time_ranges
+  end
+
+end

data/spec/lib/flapjack/api/entity_presenter_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'flapjack/api/entity_presenter'
+
+describe 'Flapjack::API::Entity::Presenter' do
+
+  let(:entity) { mock(Flapjack::Data::Entity) }
+
+  let(:check_a) { mock(Flapjack::Data::EntityCheck) }
+  let(:check_b) { mock(Flapjack::Data::EntityCheck) }
+
+  let(:checkpres_a) { mock(Flapjack::API::EntityCheckPresenter) }
+  let(:checkpres_b) { mock(Flapjack::API::EntityCheckPresenter) }
+
+  let(:time) { Time.now.to_i }
+
+  let(:start_time) { time - (6 * 60 * 60) }
+  let(:end_time)   { time - (2 * 60 * 60) }
+
+  def expect_check_presenters
+    entity.should_receive(:check_list).and_return(['ssh', 'ping'])
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ssh', anything).and_return(check_a)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, 'ping', anything).and_return(check_b)
+
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(check_a).and_return(checkpres_a)
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(check_b).and_return(checkpres_b)
+  end
+
+  it "returns a list of outage hashes for each check on an entity" do
+    expect_check_presenters
+    outages_a = mock('outages_a')
+    outages_b = mock('outages_b')
+    checkpres_a.should_receive(:outages).with(start_time, end_time).
+      and_return(outages_a)
+    checkpres_b.should_receive(:outages).with(start_time, end_time).
+      and_return(outages_b)
+
+    ep = Flapjack::API::EntityPresenter.new(entity)
+    outages = ep.outages(start_time, end_time)
+    outages.should == [{:check => 'ssh',  :outages => outages_a},
+                       {:check => 'ping', :outages => outages_b}]
+  end
+
+  it "returns a list of unscheduled maintenance periods for each check on an entity" do
+    expect_check_presenters
+    unsched_maint_a = mock('unsched_maint_a')
+    unsched_maint_b = mock('unsched_maint_b')
+    checkpres_a.should_receive(:unscheduled_maintenance).with(start_time, end_time).
+      and_return(unsched_maint_a)
+    checkpres_b.should_receive(:unscheduled_maintenance).with(start_time, end_time).
+      and_return(unsched_maint_b)
+
+    ep = Flapjack::API::EntityPresenter.new(entity)
+    unsched_maint = ep.unscheduled_maintenance(start_time, end_time)
+    unsched_maint.should == [{:check => 'ssh',  :unscheduled_maintenance => unsched_maint_a},
+                             {:check => 'ping', :unscheduled_maintenance => unsched_maint_b}]
+  end
+
+  it "returns a list of scheduled maintenance periods for each check on an entity" do
+    expect_check_presenters
+    sched_maint_a = mock('sched_maint_a')
+    sched_maint_b = mock('sched_maint_b')
+    checkpres_a.should_receive(:scheduled_maintenance).with(start_time, end_time).
+      and_return(sched_maint_a)
+    checkpres_b.should_receive(:scheduled_maintenance).with(start_time, end_time).
+      and_return(sched_maint_b)
+
+    ep = Flapjack::API::EntityPresenter.new(entity)
+    sched_maint = ep.scheduled_maintenance(start_time, end_time)
+    sched_maint.should == [{:check => 'ssh',  :scheduled_maintenance => sched_maint_a},
+                           {:check => 'ping', :scheduled_maintenance => sched_maint_b}]
+  end
+
+  it "returns a list of downtime for each check on an entity" do
+    expect_check_presenters
+    downtime_a = mock('downtime_a')
+    downtime_b = mock('downtime_b')
+    checkpres_a.should_receive(:downtime).with(start_time, end_time).
+      and_return(downtime_a)
+    checkpres_b.should_receive(:downtime).with(start_time, end_time).
+      and_return(downtime_b)
+
+    ep = Flapjack::API::EntityPresenter.new(entity)
+    downtime = ep.downtime(start_time, end_time)
+    downtime.should == [{:check => 'ssh',  :downtime => downtime_a},
+                        {:check => 'ping', :downtime => downtime_b}]
+  end
+
+end

data/spec/lib/flapjack/api_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+require 'flapjack/api'
+
+describe 'Flapjack::API', :sinatra => true do
+
+  def app
+    Flapjack::API
+  end
+
+  let(:entity)          { mock(Flapjack::Data::Entity) }
+  let(:entity_check)    { mock(Flapjack::Data::EntityCheck) }
+
+  let(:entity_name)     { 'example.com'}
+  let(:entity_name_esc) { URI.escape(entity_name) }
+  let(:check)           { 'ping' }
+
+  let(:entity_presenter)       { mock(Flapjack::API::EntityPresenter) }
+  let(:entity_check_presenter) { mock(Flapjack::API::EntityCheckPresenter) }
+
+  let(:redis)           { mock(::Redis) }
+
+  before(:each) do
+    Flapjack::API.class_variable_set('@@redis', redis)
+  end
+
+  it "returns a list of checks for an entity" do
+    check_list = ['ping']
+    entity.should_receive(:check_list).and_return(check_list)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/checks/#{entity_name_esc}"
+    last_response.should be_ok
+    last_response.body.should == check_list.to_json
+  end
+
+  it "returns a list of scheduled maintenance periods for an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_presenter.should_receive(:scheduled_maintenance).with(nil, nil).and_return(result)
+    Flapjack::API::EntityPresenter.should_receive(:new).
+      with(entity, :redis => redis).and_return(entity_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/scheduled_maintenances/#{entity_name_esc}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of scheduled maintenance periods within a time window for an entity"
+
+  it "returns a list of scheduled maintenance periods for a check on an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_check_presenter.should_receive(:scheduled_maintenance).with(nil, nil).and_return(result)
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(entity_check).and_return(entity_check_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    get "/scheduled_maintenances/#{entity_name_esc}/#{check}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of unscheduled maintenance periods for an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_presenter.should_receive(:unscheduled_maintenance).with(nil, nil).and_return(result)
+    Flapjack::API::EntityPresenter.should_receive(:new).
+      with(entity, :redis => redis).and_return(entity_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/unscheduled_maintenances/#{entity_name_esc}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of unscheduled maintenance periods for a check on an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_check_presenter.should_receive(:unscheduled_maintenance).with(nil, nil).and_return(result)
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(entity_check).and_return(entity_check_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    get "/unscheduled_maintenances/#{entity_name_esc}/#{check}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+
+  it "returns a list of unscheduled maintenance periods within a time window for a check an entity"
+
+  it "returns a list of outages for an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_presenter.should_receive(:outages).with(nil, nil).and_return(result)
+    Flapjack::API::EntityPresenter.should_receive(:new).
+      with(entity, :redis => redis).and_return(entity_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/outages/#{entity_name_esc}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of outages for a check on an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_check_presenter.should_receive(:outages).with(nil, nil).and_return(result)
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(entity_check).and_return(entity_check_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    get "/outages/#{entity_name_esc}/#{check}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of downtimes for an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
+    Flapjack::API::EntityPresenter.should_receive(:new).
+      with(entity, :redis => redis).and_return(entity_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+
+    get "/downtime/#{entity_name_esc}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+  it "returns a list of downtimes for a check on an entity" do
+    result = mock('result')
+    result_json = %q{"result"}
+    result.should_receive(:to_json).and_return(result_json)
+    entity_check_presenter.should_receive(:downtime).with(nil, nil).and_return(result)
+    Flapjack::API::EntityCheckPresenter.should_receive(:new).
+      with(entity_check).and_return(entity_check_presenter)
+    Flapjack::Data::Entity.should_receive(:find_by_name).
+      with(entity_name, :redis => redis).and_return(entity)
+    Flapjack::Data::EntityCheck.should_receive(:for_entity).
+      with(entity, check, :redis => redis).and_return(entity_check)
+
+    get "/downtime/#{entity_name_esc}/#{check}"
+    last_response.should be_ok
+    last_response.body.should == result_json
+  end
+
+end

data/spec/lib/flapjack/coordinator_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'flapjack/coordinator'
+
+describe Flapjack::Coordinator do
+
+  it "is initialized"
+
+  it "starts a suite of services based on config settings"
+
+  it "runs daemonized"
+
+  it "runs undaemonized"
+
+  it "stops its services when closing"
+
+end

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

@@ -0,0 +1,398 @@
+require 'spec_helper'
+
+require 'yajl/json_gem'
+
+require 'flapjack/data/entity'
+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 }
+
+  before(:each) do
+    Flapjack::Data::Entity.add({'id'   => '5000',
+                                'name' => name},
+                               :redis => @redis)
+  end
+
+  it "is created for an event id" do
+    ec = Flapjack::Data::EntityCheck.for_event_id("#{name}:ping", :redis => @redis)
+    ec.should_not be_nil
+    ec.entity.should_not be_nil
+    ec.entity.name.should_not be_nil
+    ec.entity.name.should == name
+    ec.check.should_not be_nil
+    ec.check.should == 'ping'
+  end
+
+  it "is created for an entity name" do
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, 'ping', :redis => @redis)
+    ec.should_not be_nil
+    ec.entity.should_not be_nil
+    ec.entity.name.should_not be_nil
+    ec.entity.name.should == name
+    ec.check.should_not be_nil
+    ec.check.should == 'ping'
+  end
+
+  it "is created for an entity id" do
+    ec = Flapjack::Data::EntityCheck.for_entity_id(5000, 'ping', :redis => @redis)
+    ec.should_not be_nil
+    ec.entity.should_not be_nil
+    ec.entity.name.should_not be_nil
+    ec.entity.name.should == name
+    ec.check.should_not be_nil
+    ec.check.should == '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)
+    ec.should_not be_nil
+    ec.entity.should_not be_nil
+    ec.entity.name.should_not be_nil
+    ec.entity.name.should == name
+    ec.check.should_not be_nil
+    ec.check.should == '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
+
+  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)
+      ec.should 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)
+      ec.should_not 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)
+      ec.should 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)
+      ec.should_not be_in_scheduled_maintenance
+    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(:start_time => t, :duration => half_an_hour, :summary => 'oops')
+
+      timestamp = @redis.get("#{name}:#{check}:unscheduled_maintenance")
+      timestamp.should_not be_nil
+      timestamp.should == t.to_s
+
+      umps = @redis.zrange("#{name}:#{check}:unscheduled_maintenances", 0, -1, :with_scores => true)
+      umps.should_not be_nil
+      umps.should be_an(Array)
+      umps.should have(1).unscheduled_maintenance_period
+      umps[0].should be_an(Array)
+
+      start_time = umps[0][0]
+      start_time.should_not be_nil
+      start_time.should be_a(String)
+      start_time.should == t.to_s
+
+      score = umps[0][1]
+      score.should_not be_nil
+      score.should be_a(Float)
+      score.should == half_an_hour
+
+      summary = @redis.get("#{name}:#{check}:#{t}:unscheduled_maintenance:summary")
+      summary.should_not be_nil
+      summary.should == 'oops'
+    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(:start_time => t + (60 * 60),
+        :duration => half_an_hour, :summary => "30 minutes")
+
+      smps = @redis.zrange("#{name}:#{check}:scheduled_maintenances", 0, -1, :with_scores => true)
+      smps.should_not be_nil
+      smps.should be_an(Array)
+      smps.should have(1).scheduled_maintenance_period
+      smps[0].should be_an(Array)
+
+      start_time = smps[0][0]
+      start_time.should_not be_nil
+      start_time.should be_a(String)
+      start_time.should == (t + (60 * 60)).to_s
+
+      score = smps[0][1]
+      score.should_not be_nil
+      score.should be_a(Float)
+      score.should == half_an_hour
+    end
+
+    it "creates a scheduled maintenance period covering the current time"
+
+    it "removes a scheduled maintenance period for a future time"
+
+    it "removes a scheduled maintenance period covering a current time"
+
+    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(:start_time => five_hours_ago,
+        :duration => half_an_hour, :summary => "first")
+      ec.create_scheduled_maintenance(:start_time => three_hours_ago,
+        :duration => half_an_hour, :summary => "second")
+
+      smp = ec.maintenances(nil, nil, :scheduled => true)
+      smp.should_not be_nil
+      smp.should be_an(Array)
+      smp.should have(2).scheduled_maintenance_periods
+      smp[0].should == {:start_time => five_hours_ago,
+                        :end_time   => five_hours_ago + half_an_hour,
+                        :duration   => half_an_hour,
+                        :summary    => "first"}
+      smp[1].should == {: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(:start_time => five_hours_ago,
+        :duration => half_an_hour, :summary => "first")
+      ec.create_unscheduled_maintenance(:start_time => three_hours_ago,
+        :duration => half_an_hour, :summary => "second")
+
+      ump =  ec.maintenances(nil, nil, :scheduled => false)
+      ump.should_not be_nil
+      ump.should be_an(Array)
+      ump.should have(2).unscheduled_maintenance_periods
+      ump[0].should == {:start_time => five_hours_ago,
+                        :end_time   => five_hours_ago + half_an_hour,
+                        :duration   => half_an_hour,
+                        :summary    => "first"}
+      ump[1].should == {:start_time => three_hours_ago,
+                        :end_time   => three_hours_ago + half_an_hour,
+                        :duration   => half_an_hour,
+                        :summary    => "second"}
+    end
+
+    it "updates scheduled maintenance periods"
+
+  end
+
+  it "creates an event" do
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+    t = Time.now.to_i
+    ec.create_event('type'    => 'service',
+                    'state'   => 'ok',
+                    'summary' => 'everything checked out',
+                    'time'    => t)
+    event_json = @redis.rpop('events')
+    event_json.should_not be_nil
+    event = nil
+    expect {
+      event = JSON.parse(event_json)
+    }.not_to raise_error
+    event.should_not be_nil
+    event.should be_a(Hash)
+    event.should == {
+      'entity'  => name,
+      'check'   => check,
+      'type'    => 'service',
+      'state'   => 'ok',
+      'summary' => 'everything checked out',
+      'time'    => t
+    }
+  end
+
+  it "creates an acknowledgement" do
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+    t = Time.now.to_i
+    ec.create_acknowledgement('summary'            => 'looking now',
+                              'time'               => t,
+                              'acknowledgement_id' => '75',
+                              'duration'           => 40 * 60)
+    event_json = @redis.rpop('events')
+    event_json.should_not be_nil
+    event = nil
+    expect {
+      event = JSON.parse(event_json)
+    }.not_to raise_error
+    event.should_not be_nil
+    event.should be_a(Hash)
+    event.should == {
+      'entity'             => name,
+      'check'              => check,
+      'type'               => 'action',
+      'state'              => 'acknowledgement',
+      'summary'            => 'looking now',
+      'time'               => t,
+      'acknowledgement_id' => '75',
+      'duration'           => 2400
+    }
+  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
+    state.should_not be_nil
+    state.should == 'ok'
+  end
+
+  it "updates state" do
+    @redis.hset("check:#{name}:#{check}", 'state', 'ok')
+
+    ec = Flapjack::Data::EntityCheck.for_entity_name(name, check, :redis => @redis)
+    ec.update_state('critical')
+
+    state = @redis.hget("check:#{name}:#{check}", 'state')
+    state.should_not be_nil
+    state.should == 'critical'
+  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')
+    state.should_not be_nil
+    state.should == 'ok'
+  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)
+    states.should_not be_nil
+    states.should be_an(Array)
+    states.should have(4).data_hashes
+    states[0][:summary].should == 'b'
+    states[1][:summary].should == 'c'
+    states[2][:summary].should == 'd'
+    states[3][:summary].should == '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)
+    # states.should_not be_nil
+    # states.should be_an(Array)
+    # states.should have(4).data_hashes
+    # states[0][:summary].should == 'b'
+    # states[1][:summary].should == 'c'
+    # states[2][:summary].should == 'd'
+    # states[3][:summary].should == '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(:start_time => time_before(t, 180),
+      :duration => half_an_hour, :summary => "a")
+    ec.create_scheduled_maintenance(:start_time => time_before(t, 120),
+      :duration => half_an_hour, :summary => "b")
+    ec.create_scheduled_maintenance(:start_time => time_before(t, 60),
+      :duration => half_an_hour, :summary => "c")
+
+    sched_maint_periods = ec.maintenances(time_before(t, 150), t,
+      :scheduled => true)
+    sched_maint_periods.should_not be_nil
+    sched_maint_periods.should be_an(Array)
+    sched_maint_periods.should have(2).data_hashes
+    sched_maint_periods[0][:summary].should == 'b'
+    sched_maint_periods[1][:summary].should == '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')
+    ec.should be_failed
+
+    @redis.hset("check:#{name}:#{check}", 'state', 'critical')
+    ec.should 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')
+    ec.should_not be_failed
+
+    @redis.hset("check:#{name}:#{check}", 'state', 'acknowledgement')
+    ec.should_not be_failed
+
+    @redis.hset("check:#{name}:#{check}", 'state', 'unknown')
+    ec.should_not be_failed
+  end
+
+  it "returns a status summary"
+
+  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)
+    ec.last_problem_notification.should == t - 30
+    ec.last_acknowledgement_notification.should == t - 15
+    ec.last_recovery_notification.should == t
+  end
+
+end