flapjack 1.6.0 → 2.0.0b1

data/spec/lib/flapjack/filters/delays_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'flapjack/filters/delays'
-
-describe Flapjack::Filters::Delays do
-
-end

data/spec/lib/flapjack/filters/ok_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'flapjack/filters/ok'
-
-describe Flapjack::Filters::Ok do
-
-end

data/spec/lib/flapjack/filters/scheduled_maintenance_spec.rb

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'flapjack/filters/scheduled_maintenance'
-
-describe Flapjack::Filters::ScheduledMaintenance do
-
-end

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

@@ -1,6 +0,0 @@
-require 'spec_helper'
-require 'flapjack/filters/unscheduled_maintenance'
-
-describe Flapjack::Filters::UnscheduledMaintenance do
-
-end

data/spec/lib/flapjack/gateways/jsonapi/check_methods_spec.rb

@@ -1,315 +0,0 @@
-require 'spec_helper'
-require 'flapjack/gateways/jsonapi'
-
-describe 'Flapjack::Gateways::JSONAPI::CheckMethods', :sinatra => true, :logger => true do
-
-  include_context "jsonapi"
-
-  let(:entity)          { double(Flapjack::Data::Entity) }
-  let(:entity_check)    { double(Flapjack::Data::EntityCheck) }
-
-  let(:entity_name)     { 'www.example.net'}
-  let(:check)           { 'ping' }
-  let(:check_esc)       { URI.escape(entity_name + ':' + check) }
-
-  let(:check_presenter) { double(Flapjack::Gateways::JSONAPI::CheckPresenter) }
-
-  let(:check_data)      { {'entity_name' => 'www.example.com', 'name' => 'PING' } }
-
-  it "retrieves all checks" do
-    expect(entity).to receive(:id).and_return('23')
-    expect(entity).to receive(:name).exactly(3).times.and_return('www.example.net')
-
-    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
-      with(['www.example.net:PING'], :redis => redis).and_return(['www.example.net:PING'])
-
-    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
-    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
-    expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:all).
-      with(:logger => @logger, :redis => redis).and_return([entity_check])
-
-    aget '/checks'
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq({:checks => [check_data]}.to_json)
-  end
-
-  it "retrieves one check" do
-    expect(entity).to receive(:id).and_return('23')
-    expect(entity).to receive(:name).exactly(3).times.and_return('www.example.net')
-
-    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
-      with(['www.example.net:PING'], :redis => redis).and_return(['www.example.net:PING'])
-
-    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
-    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
-    expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
-      with('www.example.com:PING', :logger => @logger, :redis => redis).
-      and_return(entity_check)
-
-    aget '/checks/www.example.com:PING'
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq({:checks => [check_data]}.to_json)
-  end
-
-  it "retrieves several checks" do
-    entity_check_2 = double(Flapjack::Data::EntityCheck)
-    check_data_2 = {'name'        => 'SSH',
-                    'entity_name' => 'www.example.com'}
-
-    expect(entity).to receive(:id).twice.and_return('23')
-    expect(entity).to receive(:name).exactly(6).times.and_return('www.example.net')
-
-    expect(Flapjack::Data::EntityCheck).to receive(:enabled_for).
-      with(['www.example.net:PING', 'www.example.net:SSH'], :redis => redis).
-      and_return(['www.example.net:PING', 'www.example.net:SSH'])
-
-    expect(entity_check).to receive(:entity).exactly(3).times.and_return(entity)
-    expect(entity_check).to receive(:check).exactly(3).times.and_return('PING')
-    expect(entity_check).to receive(:to_jsonapi).and_return(check_data.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
-      with('www.example.com:PING', :logger => @logger, :redis => redis).
-      and_return(entity_check)
-
-    expect(entity_check_2).to receive(:entity).exactly(3).times.and_return(entity)
-    expect(entity_check_2).to receive(:check).exactly(3).times.and_return('SSH')
-    expect(entity_check_2).to receive(:to_jsonapi).and_return(check_data_2.to_json)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
-      with('www.example.com:SSH', :logger => @logger, :redis => redis).
-      and_return(entity_check_2)
-
-    aget '/checks/www.example.com:PING,www.example.com:SSH'
-    expect(last_response).to be_ok
-    expect(last_response.body).to eq({:checks => [check_data, check_data_2]}.to_json)
-  end
-
-  it "does not find a check" do
-    expect(Flapjack::Data::EntityCheck).to receive(:for_event_id).
-      with('www.example.com:SSH', :logger => @logger, :redis => redis).
-      and_return(nil)
-
-    aget '/checks/www.example.com:SSH'
-    expect(last_response).to be_not_found
-  end
-
-  it "creates checks from a submitted list" do
-    checks = {'checks' =>
-      [
-       {"entity_id" => "10001",
-        "name" => "PING"
-       },
-       {"entity_id" => "10001",
-        "name" => "SSH"
-       }
-      ]
-    }
-
-    entity_check_2 = double(Flapjack::Data::EntityCheck)
-    expect(entity).to receive(:name).twice.and_return('example.com')
-
-    expect(entity_check).to receive(:entity).and_return(entity)
-    expect(entity_check_2).to receive(:entity).and_return(entity)
-
-    expect(entity_check).to receive(:check).and_return('PING')
-    expect(entity_check_2).to receive(:check).and_return('SSH')
-
-    expect(Flapjack::Data::EntityCheck).to receive(:add).twice.
-      and_return(entity_check, entity_check_2)
-
-    apost "/checks", checks.to_json, jsonapi_post_env
-    expect(last_response.status).to eq(201)
-    expect(last_response.headers['Location']).to eq("http://example.org/checks/example.com:PING,example.com:SSH")
-    expect(last_response.body).to eq('["example.com:PING","example.com:SSH"]')
-  end
-
-  it 'disables a check' do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(entity_check).to receive(:disable!)
-
-    apatch "/checks/#{check_esc}",
-      [{:op => 'replace', :path => '/checks/0/enabled', :value => false}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it 'enables a check' do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(entity_check).to receive(:enable!)
-
-    apatch "/checks/#{check_esc}",
-      [{:op => 'replace', :path => '/checks/0/enabled', :value => true}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "adds tags to a check" do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(entity_check).to receive(:add_tags).with('database', 'virtualised')
-
-    apatch "/checks/#{check_esc}",
-      [{:op => 'add', :path => '/checks/0/links/tags', :value => ['database', 'virtualised']}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "removes tags from a check" do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(entity_check).to receive(:delete_tags).with('database')
-
-    apatch "/checks/#{check_esc}",
-      [{:op => 'remove', :path => '/checks/0/links/tags/database'}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "creates an acknowledgement for an entity check" do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(entity_check).to receive(:entity_name).and_return(entity_name)
-    expect(entity_check).to receive(:check).and_return(check)
-
-    expect(Flapjack::Data::Event).to receive(:create_acknowledgement).
-      with(entity_name, check, :redis => redis, :duration => (4 * 60 * 60))
-
-    apost "/unscheduled_maintenances/checks/#{check_esc}", {}, jsonapi_post_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "ends an unscheduled maintenance period for an entity check" do
-    end_time = Time.now + (60 * 60) # an hour from now
-    expect(entity_check).to receive(:end_unscheduled_maintenance).with(end_time.to_i)
-
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-
-    apatch "/unscheduled_maintenances/checks/#{check_esc}",
-      [{:op => 'replace', :path => '/unscheduled_maintenances/0/end_time', :value => end_time.iso8601}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "ends an unscheduled maintenance period for an entity check with a / in the check name" do
-    end_time = Time.now + (60 * 60) # an hour from now
-    expect(entity_check).to receive(:end_unscheduled_maintenance).with(end_time.to_i)
-
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, 'Disk/Memory Usage', :redis => redis).and_return(entity_check)
-
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-
-    apatch "/unscheduled_maintenances/checks/#{URI.escape(entity_name + ':Disk/Memory Usage')}",
-      [{:op => 'replace', :path => '/unscheduled_maintenances/0/end_time', :value => end_time.iso8601}].to_json,
-      jsonapi_patch_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "creates a scheduled maintenance period for an entity check" do
-    start = Time.now + (60 * 60) # an hour from now
-    duration = (2 * 60 * 60)     # two hours
-
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-    expect(entity_check).to receive(:create_scheduled_maintenance).
-      with(start.getutc.to_i, duration, :summary => 'test')
-
-    apost "/scheduled_maintenances/checks/#{check_esc}",
-      {:scheduled_maintenances => [{:start_time => start.iso8601, :summary => 'test', :duration => duration}]}.to_json,
-      jsonapi_post_env
-    expect(last_response.status).to eq(204)
-  end
-
-  it "doesn't create a scheduled maintenance period for an entity check if the start time isn't passed" do
-    duration = (2 * 60 * 60)     # two hours
-
-    apost "/scheduled_maintenances/checks/#{check_esc}",
-      {:summary => 'test', :duration => duration}.to_json, jsonapi_post_env
-    expect(last_response.status).to eq(403)
-  end
-
-  it "deletes a scheduled maintenance period for an entity check" do
-    start_time = Time.now + (60 * 60) # an hour from now
-    expect(entity_check).to receive(:end_scheduled_maintenance).with(start_time.to_i)
-
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-
-    adelete "/scheduled_maintenances/checks/#{check_esc}",
-      :start_time => start_time.iso8601
-    expect(last_response.status).to eq(204)
-  end
-
-  it "doesn't delete a scheduled maintenance period if the start time isn't passed" do
-    expect(entity_check).not_to receive(:end_scheduled_maintenance)
-
-    adelete "/scheduled_maintenances/checks/#{check_esc}"
-    expect(last_response.status).to eq(403)
-  end
-
-  it "deletes scheduled maintenance periods for multiple entity checks" do
-    start_time = Time.now + (60 * 60) # an hour from now
-
-    entity_check_2 = double(Flapjack::Data::EntityCheck)
-
-    expect(entity_check).to receive(:end_scheduled_maintenance).with(start_time.to_i)
-    expect(entity_check_2).to receive(:end_scheduled_maintenance).with(start_time.to_i)
-
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, 'foo', :redis => redis).and_return(entity_check_2)
-
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-
-    adelete "/scheduled_maintenances/checks/#{check_esc},#{entity_name}:foo",
-      :start_time => start_time.iso8601
-    expect(last_response.status).to eq(204)
-  end
-
-  it "creates a test notification event for a check on an entity" do
-    expect(Flapjack::Data::Entity).to receive(:find_by_name).
-      with(entity_name, :redis => redis).and_return(entity)
-    expect(entity).to receive(:name).and_return(entity_name)
-    expect(entity_check).to receive(:entity).and_return(entity)
-    expect(entity_check).to receive(:entity_name).and_return(entity_name)
-    expect(entity_check).to receive(:check).and_return(check)
-    expect(Flapjack::Data::EntityCheck).to receive(:for_entity).
-      with(entity, check, :redis => redis).and_return(entity_check)
-
-    expect(Flapjack::Data::Event).to receive(:test_notifications).
-      with(entity_name, check, hash_including(:redis => redis))
-
-    apost "/test_notifications/checks/#{check_esc}"
-    expect(last_response.status).to eq(204)
-  end
-
-end

data/spec/lib/flapjack/gateways/jsonapi/check_presenter_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-require 'flapjack/gateways/jsonapi/check_presenter'
-
-describe 'Flapjack::Gateways::JSONAPI::CheckPresenter' do
-
-  let(:entity_check) { double(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
-    expect(entity_check).to receive(:historical_states).
-      with(time - (5 * 60 * 60), time - (2 * 60 * 60)).and_return(states)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    outages = ecp.outage(time - (5 * 60 * 60), time - (2 * 60 * 60))
-    expect(outages).not_to be_nil
-    expect(outages).to be_a(Hash)
-    expect(outages).to have_key(:outages)
-    expect(outages[:outages]).to be_an(Array)
-    expect(outages[:outages].size).to eq(4)
-
-    # TODO check the data in those hashes
-  end
-
-  it "returns a list of outage hashes with no start and end time set" do
-    expect(entity_check).to receive(:historical_states).
-      with(nil, nil).and_return(states)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    outages = ecp.outage(nil, nil)
-    expect(outages).not_to be_nil
-    expect(outages).to be_a(Hash)
-    expect(outages).to have_key(:outages)
-    expect(outages[:outages]).to be_an(Array)
-    expect(outages[:outages].size).to eq(4)
-
-    # TODO check the data in those hashes
-  end
-
-  it "returns a consolidated list of outage hashes with repeated state events" do
-    states[1][:state] = 'critical'
-    states[2][:state] = 'ok'
-
-    expect(entity_check).to receive(:historical_states).
-      with(nil, nil).and_return(states)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    outages = ecp.outage(nil, nil)
-    expect(outages).not_to be_nil
-    expect(outages).to be_a(Hash)
-    expect(outages).to have_key(:outages)
-    expect(outages[:outages]).to be_an(Array)
-    expect(outages[:outages].size).to eq(3)
-  end
-
-  it "returns a (small) outage hash for a single state change" do
-    expect(entity_check).to receive(:historical_states).
-      with(nil, nil).and_return([{:state => 'critical', :timestamp => time - (4 * 60 * 60)}])
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    outages = ecp.outage(nil, nil)
-    expect(outages).not_to be_nil
-    expect(outages).to be_a(Hash)
-    expect(outages).to have_key(:outages)
-    expect(outages[:outages]).to be_an(Array)
-    expect(outages[:outages].size).to eq(1)
-  end
-
-  it "a list of unscheduled maintenances for an entity check" do
-    expect(entity_check).to receive(:maintenances).
-      with(time - (12 * 60 * 60), time, :scheduled => false).and_return(maintenances)
-
-    expect(entity_check).to receive(:maintenances).
-      with(nil, time - (12 * 60 * 60), :scheduled => false).and_return([])
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    unsched_maint = ecp.unscheduled_maintenance(time - (12 * 60 * 60), time)
-
-    expect(unsched_maint).to be_a(Hash)
-    expect(unsched_maint).to have_key(:unscheduled_maintenances)
-    expect(unsched_maint[:unscheduled_maintenances]).to be_an(Array)
-    expect(unsched_maint[:unscheduled_maintenances].size).to eq(4)
-
-    # TODO check the data in those hashes
-  end
-
-  it "a list of scheduled maintenances for an entity check" do
-    expect(entity_check).to receive(:maintenances).
-      with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
-
-    expect(entity_check).to receive(:maintenances).
-      with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    sched_maint = ecp.scheduled_maintenance(time - (12 * 60 * 60), time)
-
-    expect(sched_maint).to be_a(Hash)
-    expect(sched_maint).to have_key(:scheduled_maintenances)
-    expect(sched_maint[:scheduled_maintenances]).to be_an(Array)
-    expect(sched_maint[:scheduled_maintenances].size).to eq(4)
-
-    # TODO check the data in those hashes
-  end
-
-  it "returns downtime and percentage for a downtime check" do
-    expect(entity_check).to receive(:historical_states).
-      with(time - (12 * 60 * 60), time).and_return(states)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    expect(entity_check).to receive(:maintenances).
-      with(time - (12 * 60 * 60), time, :scheduled => true).and_return(maintenances)
-
-    expect(entity_check).to receive(:maintenances).
-      with(nil, time - (12 * 60 * 60), :scheduled => true).and_return([])
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    downtimes = ecp.downtime(time - (12 * 60 * 60), time)
-
-    # 22 minutes, 3 + 8 + 11
-    expect(downtimes).to be_a(Hash)
-    expect(downtimes[:total_seconds]).to eq({'critical' => (22 * 60),
-      'ok' => ((12 * 60 * 60) - (22 * 60))})
-    expect(downtimes[:percentages]).to eq({'critical' => (((22 * 60) * 100.0) / (12 * 60 * 60)),
-      'ok' => ((((12 * 60 * 60) - (22 * 60)) * 100.0) / (12 * 60 *60))})
-    expect(downtimes[:downtime]).to be_an(Array)
-    # the last outage gets split by the intervening maintenance period,
-    # but the fully covered one gets removed.
-    expect(downtimes[:downtime].size).to eq(4)
-  end
-
-  it "returns downtime (but no percentage) for an unbounded downtime check" do
-    expect(entity_check).to receive(:historical_states).
-      with(nil, nil).and_return(states)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    expect(entity_check).to receive(:maintenances).
-      with(nil, nil, :scheduled => true).and_return(maintenances)
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    downtimes = ecp.downtime(nil, nil)
-
-    # 22 minutes, 3 + 8 + 11
-    expect(downtimes).to be_a(Hash)
-    expect(downtimes[:total_seconds]).to eq({'critical' => (22 * 60)})
-    expect(downtimes[:percentages]).to eq({'critical' => nil})
-    expect(downtimes[:downtime]).to be_an(Array)
-    # the last outage gets split by the intervening maintenance period,
-    # but the fully covered one gets removed.
-    expect(downtimes[:downtime].size).to eq(4)
-  end
-
-  it "returns downtime and handles an unfinished problem state" do
-    current = [{:state => 'critical', :timestamp => time - (4 * 60 * 60)},
-               {:state => 'ok',       :timestamp => time - (4 * 60 * 60) + (5 * 60)},
-               {:state => 'critical', :timestamp => time - (3 * 60 * 60)}]
-
-    expect(entity_check).to receive(:historical_states).
-      with(nil, nil).and_return(current)
-
-    expect(entity_check).to receive(:historical_state_before).
-      with(time - (4 * 60 * 60)).and_return(nil)
-
-    expect(entity_check).to receive(:maintenances).
-      with(nil, nil, :scheduled => true).and_return([])
-
-    ecp = Flapjack::Gateways::JSONAPI::CheckPresenter.new(entity_check)
-    downtimes = ecp.downtime(nil, nil)
-
-    expect(downtimes).to be_a(Hash)
-    expect(downtimes[:total_seconds]).to eq({'critical' => (5 * 60)})
-    expect(downtimes[:percentages]).to eq({'critical' => nil})
-    expect(downtimes[:downtime]).to be_an(Array)
-    # the last outage gets split by the intervening maintenance period,
-    # but the fully covered one gets removed.
-    expect(downtimes[:downtime].size).to eq(2)
-  end
-
-end